What the texture road looked like
The texture plan reads cleanly: the engine composites with Vulkan and places the result into a cross-API shared texture; on the host side a bridge thread mirrors it onto the texture registered with Flutter; one Texture widget in the UI connects the picture into the composition tree, with transforms, gestures and lifecycle all provided. On the engine side I opened a proper interface for it: an export of the output as a shared texture, together with a fence for per-frame synchronization, for the outside to take by handle.
The texture road was made to work, and what it saved was the CPU readback copy; the reasons for choosing it back then still hold — textures are first-class citizens, entering the composition tree is nearly free, and platform differences are locked inside one bridge per platform. Along the way I fixed a string of synchronization bugs: the fence's duplicate notifications became an atomic ticket draw, which cured a second-long stretch of corrupted frames; the mirror buffer gained slots and the block rate came down. The reasons held, and the illness stayed — it had one that could not be cured.

Torn blocks: the root cause is multi-consumer concurrency
With some sources the picture tears into scattered blocks. The investigation took detours: the sync fence became an atomic ticket draw, which cured a second of corrupted frames; the mirror buffer went from one slot to several, the block rate dropped but the steady state remained; a frame gate on the engine left the blocks untouched and made the stutter worse. Variable isolation finally pinned it: the same title, three hosts, the only difference being whether texture export was on — on, it broke; off, it was clean. Direct output through a native window never showed the problem, and cross-process import was clean too. The failure had exactly one shape: pulling Flutter's compositor into the same chain as a third consumer. The compositor samples the texture, the bridge thread's mirror races the engine's next-frame write, and neither level of consumption has reliable synchronization; the content of the blocks came steadily from adjacent frames, not noise.
There is one more bill to pay: a single 8K frame in RGBA is over 130 megabytes, and this chain makes it hop three times per frame. Even if the synchronization could be fixed, the bandwidth would not carry it.
So the conclusion was to go around, not to fix.
Native windows: around the compositor
The new plan takes a different shape on each of the three platforms. On Windows I open a top-level video window, black background, frameless, taking no activation focus, tucked directly behind the host's main window; the main window goes whole-window transparent, the video area is left as a transparent hole, and UI controls overlay the picture with real transparency. The video window takes no input at all, so clicks fall through to the page layer naturally; if another window cuts in front in z-order, a watchdog re-pins it on a timer. macOS and iOS use the official platform views (PlatformView), with a Metal layer built inside the view and handed to the engine; Android uses a platform view plus SurfaceView, with JNI attaching the native window. Linux keeps the old CPU-readback shape for now — the only exception across all platforms, with throttling on the readback step holding the frame rate at a low tier.

The result holds up: same machine, same title, the texture group tears and the direct-output group is clean. The edges are concentrated too: the video surface sits outside the composition tree, so Flutter's animations and transforms cannot touch it, and the video rectangle trails by one frame; screen-capture tools cannot grab the picture showing through; whole-window transparency depends on an undocumented interface — a trade accepted after evaluation.
Complexity did not vanish, it moved house
The texture plan's complexity lived in frame synchronization; the native window plan's lives in window lifecycle. Three examples.
One is zero by zero. Everything looked fine in the probe page, but in the real shell the video window was zero by zero with all controls hidden. Measuring down the UI tree level by level found it: one layer's layout used loose constraints, that layer was hidden during playback and measured out zero, dragging the playback page that filled it down with it. The fix was to make that layer fill its constraints — a change in one place.
One is rotation black screen. Portrait had a picture; rotating to landscape blacked out with sound and no image, by probability. On rotation the platform view rebuilds entirely and a new SurfaceView arrives, while on some systems the old surface's destroyed callback may never come; the surface-attach gate compared handles only, so the new surface was swallowed as a duplicate request, the engine polled a dead old window for a zero size, and the screen stayed black. The fix: re-attach whenever either the handle or the Surface object changes. Same-path regression after the fix: all black before, full picture after.
One is a dangling pointer across lane switches. Switching render lanes mid-playback, a reference count stepped on the previous title's already-released Metal layer. The root cause was unpaired registration: the view registered its pointer at creation, nobody unregistered at destruction, and the bridge only guarded nulls, not danglers. The fix came in three layers: unregister at destruction, a weak-reference liveness gate on the bridge side, and clearing the lane-switch state when a new title opens so nothing jumps the gun.
One lane, no switch left behind
Once verification passed, the texture passthrough was deleted whole: the setting, its localization strings, the environment-variable injection at startup, along with the texture symbols in the bridge, all removed; the engine now refuses a windowless creation request outright. One render chain remains in the product, and from now on no rendering question starts with "which chain did it happen on".
The engine's two interop openings remain, with new tenants: the entry that feeds textures into the engine belongs to the capture and external textures described in the frame-source article; the exports that turn engine output into a shared texture now serve the self-check page — verifying GPU interop capability, no longer the main playback chain.
Textures were not repudiated. For low frame rates, small sizes, and pictures that need to join UI transforms — thumbnails, previews — the texture is still the shortest road. For a fullscreen, high-frame-rate, high-bit-depth video surface, the native window is the only stable answer I have verified; and there is the HDR layer: inside the composition tree a texture is forever standard dynamic range, so if the highlights are to genuinely reach out of the screen, the pixels must leave through the engine's own presentation surface.
The engine avox is open source on GitHub: github.com/xxxzhou/avox, where the two interop openings and this single lane live.