Mobile
Native apps, phones and tablets.
Android today. iOS on the roadmap.
GPU-native, cross-platform UI. Built from first principles.EARLY. REAL. RUNNING.
Native speed.
Nothing in
the way.
An entirely different foundation for interfaces.
A reactive C++ core. A direct line to the GPU.
And nothing running when nothing changes.
No Skia.No WebView.No bridge.No canvas on web.
↳ No retained tree.↳ No diffing.↳ No bridge.
SCROLL TO DISCOVER 01 / A different starting point
What if the fastest UI
was the one that simply
did less?
Flash doesn’t keep a tree and figure out what changed. Your UI is a function. A signal changes, the function runs, and the GPU draws. When it settles, everything stops. The architecture is the optimization.
LESS BETWEEN.MORE AHEAD.
Origin / Where Flash can go
Born in a game engine.
Built for more.
Flash began as the UI framework for my own work-in-progress C++ game engine. I extracted it into a standalone technology so the same GPU-native foundation could power interfaces far beyond the engine.
GAME-ENGINE ROOTS. CROSS-PLATFORM AMBITION.Desktop
Tools, dashboards and creative applications.
Windows, macOS and Linux on the roadmap.
Web
Direct JSX through my Flash JSX runtime.
Signals, SSR, streaming and SEO. No canvas.
Games & game engines
HUDs, editors and interfaces inside a C++ engine.
The place Flash started.
TV & connected screens
Android TV and Apple TV / tvOS are potential targets.
Future shells, focus and remote navigation.
Automotive & embedded
Dashboards, kiosks and custom device interfaces.
Target-specific hardware and host integration.
One platform-agnostic core. Platform coverage grows through dedicated shells, input support and testing. TV and automotive are exploratory targets; Android Auto / Automotive OS need their own integrations.
See what runs today02 / The signal playground
Change something.
Then watch it stop.
A small idea with a big consequence.
Interact with the interface. Follow the frame path. Leave it alone, and it goes idle.
Accent color
Frosted glass
ILLUSTRATIVE BROWSER PREVIEW
A LITTLE STATE.
A lot less machinery.
0
count.get() → pixels on screen
FRAME PATH
Signal changesinvalidate subscribers
UI function runslayout → commands
GPU drawssubmit the frame
0pending frames
No change. No scheduled work.
That’s the whole idea.
Waiting for your first change.
This demo uses HTML, CSS & JavaScript to illustrate Flash’s reactive model. It is not the Flash runtime or a performance benchmark.CHANGE → DRAW → IDLE
03 / Under the hood
A straight line
from state to screen.
UI described as code. Layout computed in-process. Commands drawn by a pass-based GPU renderer. The way a game engine draws a frame, brought to the interface.
FLASH / FRAME PIPELINE01—03
{ s }
SIGNALf( )
UI + LAYOUT▧
GPU PASSESState changes. Work begins.
C++ CORE / NATIVE C LAYOUTNO RECONCILER
Any shader is a style.
Register a pixel shader once. Use it on an element like a background color. Glass, distortion, custom SDFs — the same rendering path.
YOUR EFFECT.YOUR RULES.
Many elements.
One material.
Instanced batching turns elements that share a material into a draw call. Rendering is native to the GPU.
SHARED MATERIAL → INSTANCED BATCH
Fluid in motion.
Silent at rest.
Tweens, springs and layout transitions. Enter, exit, resurrect and share elements across screens. When motion settles, the frames stop.
ANIMATE → SETTLE → ZERO FRAMES
Familiar on the surface.
Components, props, state, composition.
All functions. All plain values.
Native all the way down.
C++20, DiligentCore, a fork of Clay.
FreeType and MSDF text.
Smooth without workarounds.
No worklets. No UI / logic thread split.
Multi-thread ready, without requiring it.
Design / Built into the renderer
The details are
part of the foundation.
Glass, continuous corners and custom effects belong to the rendering system. Styles are values, so you can compose them, override them and animate them.
01 / Corners, your wayApple-style corners.
Apple-style corners.
By default.
Continuous squircles on every rounded element. Switch to classic web / Material corners app-wide or per element. The radius means the same size in both.
CornerStyle::Continuous
SHAPE STUDY / SVG APPROXIMATION02 / Liquid glass, built in
Depth you can feel.
Refraction, edge light, contact shadows and a press lift. Frosted glass and backdrop blur share the same native effects path.
LIQUID GLASS / EXPERIMENTALPRESS & HOLD / BROWSER ILLUSTRATION
THE SAME SHADER CONTRACT
Backdrop blur · Frosted glass · Liquid glass · Custom SDF shapes · Subtree opacity · Animated noise
STYLE APIMotion / Part of the framework
Change the layout.
Keep the flow.
Tweens and springs animate values or whole styles. Retarget in flight; springs carry their velocity. Size, padding, radius, opacity and color move together. Gesture-driven springs carry motion out of a drag.
01
Layout that animates itself.
Add or remove items and the list makes room. Resize a component and layout animations carry it and its direct children into the new arrangement.
02
Enter. Exit. Resurrect.
Resurrection by construction: bring an element back mid-exit and its animation turns around. The same identity continues from where it is.
03
Shared elements across screens.
A gallery card becomes a detail hero. Separate elements, a matching shared id: the old geometry becomes the start, the new layout sets the destination. Position, size, corners and opacity morph together.
SAME ELEMENT / NEW LAYOUT
Add, remove or undo. A browser illustration of the motion model.
Rendering / Another dimension
3D & UI.
The same frame.
RENDERING / IN DEVELOPMENT
Games, product viewers, AR and data in three dimensions. A shared device, command queue and color pipeline. A viewport, or 3D layered directly between UI elements. Your renderer, inside your interface.
UI + SCENE / COMPOSITION STUDYSHARED GPU FOUNDATION
BACKGROUND → 3D → FOREGROUNDHTML / CSS ILLUSTRATION
3D between your UI layers.
Draw straight into the shared frame. Models over panels, particles across the interface, glass blurring the live scene behind it — without an offscreen composition step.
A still scene should schedule no frames.
Motion wakes only the frames it needs.
Custom passes & compute.
Your own rendering, materials and shader work on the same GPU foundation.
Bloom. HDR. Wide gamut.
Content blur and glow effects, with high dynamic range and wider color output.
Render graph & GPU-driven batching.
A rendering foundation that can grow with data-heavy interfaces and richer scenes.
Two planned paths: a composited viewport, or direct rendering into the shared frame. The visual above illustrates the idea in HTML/CSS; it is not the Flash renderer.SAME DEVICE. SAME QUEUE. SAME COLOR PIPELINE.
Platform / Batteries included
Native essentials.
Included.
Files, clipboard, haptics, sharing, audio and notifications under one platform API. Thin wrappers over what the OS already has. The features you don’t call cost nothing.
Platform::Clipboard::SetText(code.c_str());
Platform::Haptics::Impact();
Platform::Share::Text(link.c_str());ONE TYPESCRIPT FILEapp.config.ts
App identityName & icons
Native featuresEnabled builtins
PermissionsCamera · microphone · location
AndroidManifest.xmlInfo.plist
Evaluated by my own runtime at build time.
Permission declarations flow into the native app.
01
File system & secure storage
Local files and protected app data.
02
Clipboard & share sheet
Copy and share through the OS.
03
Haptics & audio
Feedback you can feel and hear.
04
Notifications
The system’s native notification surface.
05
Camera & microphone
Device input, with permissions in app.config.ts.
06
Location
Platform location access through the same API.
IsAvailable() where a platform differs. Asynchronous results return as signals.
From the device to the interface.
Touch input, momentum scrolling, soft keyboard and IME insets. Safe areas and density-independent sizing.
Text deserves the full treatment.
Focus, caret and UTF-8-safe editing. Text selection, handles and magnifier; CJK composition and HarfBuzz shaping.
A surface for the system.
Accessibility integration belongs in the platform foundation, alongside text input and native capabilities.
VULKAN · METAL · D3D12 · GLES
A platform-agnostic C++ core, with native GPU backends underneath and an OpenGL ES fallback for older Android devices.
04 / A runtime of its own
TypeScript.
Without the detour.
Not just a UI framework. Flash’s native TSX authoring is being built on my own TypeScript runtime, written from scratch in Odin and bridgeless by design. Real TypeScript compiles to typed bytecode. TSX describes. C++ renders.
No JavaScript engine.No TS → JS step.
Compare C++ & TSX
ODIN-TS-RUNTIME / NATIVE AUTHORINGFLASH INTEGRATION / IN DEVELOPMENT
</>
Your app. In TSX.COMPONENTS / PROPS / SCOPED SIGNALS
.tsx↓COMPILES TO TYPED BYTECODE
{ TS }A purpose-built, bridgeless VM.
Interpreter · JIT · AOT
TYPED HANDLESSAME NATIVE MEMORY
C++
Signals. Widgets. Native calls.LAYOUT / ANIMATION / GPU RENDERING
A TS signal is the native signal.
Native structs stay in native memory. Typed handles reach fields, methods, callbacks and containers in place — no boxing, serialization or proxies. A field read is the same offset load as in C.
Interpret. JIT. Or compile ahead.
Execution modes over one intermediate representation, chosen per platform and build. The runtime embeds in anything with a C ABI — beyond Flash itself.
Native speed. Fast iteration.
State-preserving hot reload, over-the-air bundles and AOT release builds. Scoped state and a real component lifecycle above an immediate-mode foundation.
NATIVE FIRST.
THE WEB, TOO.
THE WEB, TOO.
The web path is Flash JSX, my own web runtime: signals, SSR, streaming, SEO, providers and layout animations. Shared TSX components, state and logic are the goal — native rendering on device, Flash JSX on the web. No canvas on web.
STATUS05 / Authoring
Looks familiar.
Works differently.
A signal. A function. A button.
C++ keeps the UI a function; the if is the click handler. The TSX layer adds scoped state, lifecycle hooks and cleanup — with immediate mode underneath.
#include "UI.h"
#include "Widgets.h"
using namespace Flash::UI;
Signal<int> count{0};
window([&] {
column({}, { .gap = 12, .padding = 24 }, [&] {
label({ .text = std::to_string(count.get()).c_str() },
{ .fontSize = 24 });
if (button({ .id = "inc" }, {}, [&] {
label({ .text = "Increment" });
})) count.set(count.peek() + 1);
});
});API excerpt from the latest Flash README.
06 / The honest part
A big idea.
A real beginning.
Flash is an early, independent technology in active development.
Android runs today. Platform ports, builtins, 3D and native TSX integration continue to evolve. This page presents the full feature direction; the current implementation details live in the README.
Mobile
Android
Reactive core + GPU renderer
iOS
Metal
Desktop
Windows · macOS · Linux
D3D12 / Metal / Vulkan
Web
Flash JSX
Signals / SSR / streaming / SEO
Flash Browser
Native applications. Delivered over the internet.
Typed bytecode. Bridgeless execution. Flash rendering.
07 / Follow development
Watch Flash
take shape.
Flash is in early development and isn’t available to try yet. I’m sharing demos, engineering decisions and progress as I build it.
Closed source. Free to use when released.
A different foundation. An open horizon.
Less in the way.
More possible.
Go deeper into Flash THE ARCHITECTURE, API & ROADMAP. ALL HERE.