status and roadmap

demonstrated today

the engine has live mechanisms, experimental backends, and build-specific ui proofs. these establish different scopes of support.

capability	evidence	scope
live themes	whole-window and targeted color changes	controlled gpui apps, macos arm64
plugins	wasm execution, app-defined hooks, capability checks, and resource budgets	controlled native targets
behavior changes	live argument rewrites and return overrides	controlled test functions
byte patches	same-length text and force-return changes in memory	controlled targets; executable file hash unchanged
function replacement	constant-result detour implemented and unit tested	end-to-end live proof pending
site discovery	string-xref anchors resolve stripped function entries across rebuilds	stripped release binaries
native scene drawing	a card drawn from quads through the app’s own paint method; text and image sprites pending	one pinned release build, custom agent and re-signed app copy
routed ui entry	a settings category added to the app’s returned page list and routed natively	the same pinned build, custom agent
javascript plugins	javy transforms, hook dispatch, observation, and a shared engine backend	experimental library feature; not wired into agent plugin loading
companion overlay	interactive controls and click-through outside the content	separate window prototype

platforms and targets

the core patches machine code and hosts plugins independently of the target’s ui framework. compatibility depends on the executable build, architecture, calling conventions, signing policy, and available backends.

macos arm64 is the demonstrated platform. linux and windows loaders have compiling prototypes; write backends and runtime verification there remain work in progress.

the current gpui scene and settings-entry proofs use hand-authored agents and a cloned, ad-hoc re-signed copy of one release. they demonstrate the mechanisms, not a reusable installer or compatibility across applications and versions.

current limits

each app build needs an adapter, compatible calling conventions, and supported platform backends. changing the ui framework does not change the core patch mechanism.
live byte patches must preserve length. arbitrary-length native code injection is not available.
argument and return overrides keep the original body’s side effects. constant-result replacement skips the body, but its end-to-end live proof is pending.
native scene drawing and routed settings entries are pinned experiments. a general native ui element or view-tree api is not available to plugins.
signing policy can prevent agent loading or executable-memory writes. a required code-signing policy blocks the live text patch backend.
the monitor covers color, event, and byte-patch sites, not return, argument, or replacement sites.
the javascript backend is off by default behind the js feature. capability host imports and integration with the agent’s plugin configuration remain unfinished.
there is no public installer or general release; setup is a developer workflow.

hardening

recent fixes cover byte-safe hex parsing, a panic boundary around the injected constructor, wasm linear-memory limits, and refusal to patch an unreadable executable. a non-exact build is reported rather than silently accepted as an identity match.

native address bounds, consistent site resolution across backends, in-place write handling, and file-offset versus mapped-address handling remain under review. adapters are trusted, build-specific inputs; the wasm sandbox does not validate native addresses supplied by an adapter.

roadmap

open work, grouped by area. each entry describes its current state and next step.

native address safety

in progress. bound every address and range an adapter supplies against the mapped image, resolve sites through one shared resolver across site families and the monitor, harden the in-place write path, and keep file offsets and mapped addresses distinct.

javascript plugins in the agent

future work. connect the javascript backend to the agent’s plugin loading so FPUI_PLUGINS can select it, and add capability host imports so javascript plugins can call app services. today the agent loads modules through the pointer/length wasm abi.

reusable native ui tooling

in progress. move the pinned scene-drawing and routed-entry experiments into adapter, discovery, and apply tooling so they no longer need hand-authored agents. the text and image sprite stage of scene drawing is pending, and the two proofs have not been combined into one full ui surface. paint and routing mappings remain specific to each target.

live function replacement

pending. validate constant-result replacement end to end against a live target. today it is implemented and unit tested only.

linux and windows

planned. add write backends behind the compiling loader prototypes, then run runtime tests on each platform.

project and license

the engine source is licensed GPL-3.0-or-later. this website is a separate mit-licensed project.

the framework repository contains the engine and development tools. these guides describe their current interfaces and evidence.