Web-born. Native without a browser.
EffinDOM combines a retained cross-language runtime, typed FUI SDKs, project scaffolders, native packaging, shared delivery, and developer tooling. Build for the browser through WebAssembly or run directly on macOS, Windows, and Linux.
The premise
The browser is an excellent display server. It should not dictate your application architecture.
Myth versus implementation
These common beliefs are accurate for a raw bitmap with mouse events, but they are not inherent limitations of canvas presentation. Here is what EffinDOM actually implements instead.
A raw canvas is. EffinDOM separately projects its retained semantic tree through DOM and ARIA in browsers, NSAccessibility on macOS, Microsoft UI Automation on Windows, and AT-SPI on Linux. Assistive technology receives controls, names, state, bounds, actions, focus, and editable text rather than being asked to interpret pixels.
Inspect the accessibility implementation ↗Controls are intentionally not DOM layout elements, so the CSS inspector is not the right debugger. EffinDOM exposes its retained tree, semantic tree, bounds, state, and node properties through an on-demand DevTools DOM mirror, Inspect Mode, and a built-in debug dialog. You inspect the model that actually owns the UI.
EffinDOM mirrors editor state into real browser editing and form elements while retaining visual rendering itself. This lets the browser and operating system handle composition, mobile keyboards, clipboard conventions, autofill, and password-manager extensions.
Retained text supports caret placement, mouse and touch selection, cross-node ranges, teardrop handles, context menus, and clipboard operations. The normal desktop shortcut opens EffinDOM's retained find experience. Mobile and explicit browser-native find search the projected semantic text too; the match works, although the browser's highlight can use a slightly different DOM font from the canvas-rendered text beneath it.
EffinDOM is retained and demand-driven. Controls preserve identity, layout and text results are cached, static content is reused, and frames are requested by invalidation or active animation. A canvas presentation surface does not require an immediate-mode application model or a permanent render loop.
Tier 1, Tier 2, ICU, and built-in fonts are immutable, content-addressed runtime assets shared across EffinDOM applications. The current demo transfers about 7.6 MB compressed from a cold cache, excluding page images, and under 500 KB for a warm home-page load. Browser caches can still be evicted; this is architecture, not magic.
Client-rendered React is no different. Google can render a client application and index the semantic DOM produced after startup. In EffinDOM, application and UI state run in WebAssembly; the retained WASM runtime emits a semantic buffer, and the small browser bridge materialises that buffer as DOM and ARIA. React produces its client-rendered DOM from JavaScript instead. A rendering crawler can inspect either result; a crawler that never runs the client runtime sees neither application tree. Canvas presentation does not make EffinDOM uniquely opaque to bots.
Google's JavaScript SEO guidance ↗Native hosts run the EffinDOM C++ runtime directly against Metal, Direct3D 12, or Vulkan. There is no embedded Chromium and no system WebView. The browser and native hosts share retained UI behaviour, while platform adapters handle operating-system-specific services.
The whole stack
EffinDOM is the common foundation for a growing application ecosystem. Developers normally enter through an FUI SDK or a scaffolder; the rendering runtime, browser bridge, native hosts, delivery system, and packaging engine sit underneath.
Retained Rust UI for browser and native desktop, with Cargo-native tooling and an npm-oriented browser workflow.
SDK, docs, and source ↗ Application SDKAssemblyScript application development with a TypeScript-shaped fluent API and independently loaded route WASM.
SDK, docs, and source ↗ Shared infrastructureRendering, layout, typography, input, selection, semantics, browser integration, and native platform hosts.
Runtime source and docs ↗ Rust developer toolingScaffold, develop, build, and package FUI-RS applications for web, native, or universal targets.
Install from crates.io ↗ Packaging engineCross-language application metadata, icon generation, signing inputs, and packages for six desktop targets.
Packaging crate and source ↗ Browser scaffoldernpm-oriented simple and routed project templates for FUI-RS and FUI-AS browser applications.
Open the FUI-RS scaffolder ↗ Shared deliveryImmutable content-addressed WebAssembly runtimes, ICU data, and fixed assets shared across EffinDOM applications.
Inspect published runtime sets ↗ Agent guidanceOfficial, versioned Agent Skills that teach retained FUI-RS architecture, drawing, fonts, host integration, accessibility, and packaging.
Install the official skills ↗ Community applicationThe first independent FUI-RS application: a complete community-built Galaga-style space shooter with a live web build.
Source and live demo ↗ Incubating SDKsKotlin/Wasm and C# language surfaces currently at smoke-stage maturity, built against the same language-neutral ABI.
Follow the ecosystem ↗Why EffinDOM
Native-first frameworks usually arrive on the web as ports. EffinDOM began with browser constraints: accessibility, IME, password managers, touch, routing, asynchronous assets, and a globally cacheable runtime. Moving that architecture onto native operating systems is the simpler direction.
Layout, text, hit testing, scrolling, and control state live in one retained runtime without virtual DOM diffing.
EffinDOM projects semantics and editor state separately, preserving ARIA, IME, selection, and password-manager integration.
The same runtime executes directly through native macOS, Windows, and Linux hosts with platform accessibility adapters.
HarfBuzz and ICU provide shaping, line breaking, BiDi, global scripts, rich text, editing, and fallback-font handling.
Content-addressed runtime modules and fixed assets can remain cached across routes, applications, SDKs, and languages.
A stable C ABI keeps rendering infrastructure language-neutral. Rust and AssemblyScript are first-class application surfaces.
Native applications run the EffinDOM engine directly. GPU acceleration uses the platform renderer below, with automatic software raster fallback when a suitable GPU surface is unavailable.
The hard parts
Drawing controls was never the difficult part. The work is in the behaviour users notice only when it is missing: editing, selection, international text, accessibility, native input, and state that survives real application use.
Browser editor mirrors let canvas-rendered TextInput and TextArea controls cooperate with composition, autocorrect, platform clipboard conventions, forms, and password-manager extensions.
HarfBuzz and ICU shape global scripts while incremental font fallback detects missing glyphs, loads only required coverage, and keeps live text stable as new fonts arrive.
Mouse drag, reverse selection, cross-node ranges, touch teardrops, handle crossover, context menus, copy, and viewport auto-scroll share one retained selection model.
EffinDOM projects retained semantics through DOM and ARIA on the web, NSAccessibility on macOS, Microsoft UI Automation on Windows, and AT-SPI on Linux.
Visible-line processing, incremental edits, fixed line heights, monospaced metrics, wrapping, and static-content reuse reduce work while preserving identical Unicode, caret, hit-testing, and selection behaviour.
Native trackpad momentum, wheel behaviour, keyboard conventions, multi-click timing, window resizing, system themes, accent colours, and platform context menus are handled by host adapters rather than approximated globally.
Control identity preserves focus, text, selection, scroll position, overlays, and subscriptions. Browser history can restore named retained state instead of reconstructing a blank page.
Mandatory runtime assets expose bounded startup progress. Optional script coverage and page fonts load asynchronously, update retained content when ready, and do not block an already usable application.
Applications declare their own host-service boundary and generate strongly typed SDK bindings. Browser or platform code implements the capability without leaking bridge calls, raw pointers, or transport details into application UI.
FUI workers run computation outside the application UI thread with generated message contracts, progress reporting, cooperative yields, cancellation, and an explicit allowlist of host services available inside the worker.
Choose your surface
FUI SDKs provide retained controls, fluent composition, reactive state, theming, accessibility, and application lifecycle without exposing the runtime ABI.
Idiomatic Rust application development for browser, macOS, Windows, and Linux from one retained UI model.
A TypeScript-shaped AssemblyScript SDK with fluent retained controls and compact route-level WebAssembly applications.
The runtime concepts do not change between languages. Controls, capabilities, layout, and fluent configuration remain recognisable; each SDK only adapts composition and naming to its language.
fn build_page() -> FlexBox {
ui! {
column()
.gap(12.0)
.fill_width()
.padding(24.0, 24.0, 24.0, 24.0) {
text("Profile").font_size(28.0),
row().gap(8.0) {
text_input()
.placeholder("Name")
.fill_width(),
button("Save"),
},
}
}
}function buildPage(): FlexBox {
return Column(
new Text("Profile")
.fontSize(28.0),
Row(
new TextInput()
.placeholder("Name")
.fillWidth(),
new Button("Save"),
).gap(8.0),
)
.gap(12.0)
.fillWidth()
.padding(24.0, 24.0, 24.0, 24.0);
}AI-native developer experience
Generic models often mistake retained UI for React-style rerendering or immediate mode. FUI-RS ships official Agent Skills grounded in released APIs, so an agent can follow the real ownership, lifecycle, rendering, accessibility, and packaging contracts instead of inventing plausible-looking framework code.
Fluent ui! composition, cheap retained handles, callbacks, capability traits, state ownership, and universal application boundaries.
Reusable components, templates, presenters, themes, focus, activation, semantics, and cycle-safe Rust ownership.
CustomDrawable, DrawContext, paths, text resources, retained bitmaps, dirty-region uploads, animation, and measured invalidation.
Font faces, families, weight and style mapping, mixed-script fallback, async readiness, and web/native asset packaging.
Typed service and event contracts, browser and native adapters, worker allowlists, subscriptions, and ABI-safe generation.
Retained semantic projection, custom-control accessibility, forms, editors, keyboard operation, and assistive-technology testing.
cargo-fui project targets, verified runtime acquisition, offline builds, icons, assets, DMG, MSIX, AppImage, and cross-platform CI.
See it running
Retained controls, text editing, custom drawing, touch interaction, and a community-built space shooter, all running through FUI-RS.
The operating model
The expensive runtime is infrastructure, not application payload. Applications ship their own retained logic while browsers reuse cached engines, ICU data, and built-in fonts.
“Your app is your app. The engine should not be downloaded again for every site.”
EffinDOM publishes immutable runtime sets selected by capability. Web applications consume them through a small browser bridge with packaged fallback assets. Native applications consume the same engine architecture as platform runtime libraries.
Build a retained Rust application for the browser and native desktop, or start with AssemblyScript on the web.