Stars in the Window
Generative content finally shows up in the live editor window, not just in exports. The display cache now tracks textures by what they are rather than what they were called this frame, and the texture pool stops buying a new texture every frame and throwing it away.
Load an SDF patch, wire it to the output, and look at the preview panel. Until this release, what you saw there was a very confident rectangle of black. The export pipeline produced the right pixels. The headless tests produced the right pixels. The screenshot tool produced the right pixels. The one surface that produced nothing was the one you were looking at, which is a special kind of insult when the patch is called hello_sdf_stars.
This release is the one where the window joins the rest of the application.
A cache with a naming problem
The live display works on a small delay. The GPU renders your patch into a texture, the result is read back asynchronously, and the window draws the snapshot a frame later. One frame of latency, invisible at speed, and the price of never stalling the render to wait for pixels.
The catch was in how the snapshot was filed. The cache stored it under the texture’s handle, the per-frame ID the engine mints for every result. Generative nodes mint a fresh handle every single frame, so by the time a snapshot arrived, the window was already asking for the next handle. The answer was perpetually “not yet”. Frame after frame, forever, while a perfectly good snapshot of the previous frame sat in the cache under a name nobody would ever ask for again.
Snapshots are now filed under the texture’s physical identity, which survives from frame to frame, and a small per-frame table maps whatever the handle is called today onto the texture it actually is. The window asks for this frame’s handle, the table points at the real texture, the cache hands over last frame’s stars. The arrangement works the way you assumed it already did.
The pool that never reused anything
Fixing the filing system exposed a second, better-hidden problem: there was no stable texture to file under. Every per-frame producer node allocated a brand new GPU texture each frame and simply never returned the old one. The texture pool has a free list, a perfectly good recycling system, with reuse logic and identity tracking and everything. Nothing ever arrived in it. In a four minute run of one small patch, the pool performed fourteen thousand fresh allocations, zero frees, and quietly accumulated 346 MB of textures it intended to look at later, until the garbage collector swept through and binned the lot.
Now the engine returns each frame’s transient outputs to the free list the moment the next frame stops referencing them. The same physical texture gets reused frame after frame, identity intact, which is precisely what the display cache needed, and the allocation graph for that same patch reads: one. One texture, recycled five hundred times, zero garbage collected. The patch that used to consume a megabyte of fresh VRAM per frame now consumes none, which is the kind of number zero GPU allocations promised the rest of the engine and the 2D path is finally keeping.
The preview panel was double-booked
One more capture remained. The editor draws your graph and the output preview in a separate pass from the output itself, and that pass kept its own list of textures to show, a list the readback system never saw. So even with identities fixed and textures recycled, the inline preview could still come up empty while the dedicated output rendered fine. The canvas pass now registers its previews with the same sync that feeds the output window. One system, every surface.
What it buys you
You can now watch your generative patches in the editor, live, which is not normally a feature one has to announce. The preview panel shows the stars, the output window shows the stars, the export still shows the stars, and they are all the same stars. Memory stays flat instead of sawtoothing toward a GC cliff, which on long-running sets means one less reason for a mid-show hitch. And when a texture does go missing, the log now says which half of the handoff dropped it, in words, so the next investigation starts from evidence instead of archaeology.