Why Formo Exists

The gap between drawing and building. We're closing it.

A decade of building reactive tools, converging into one.

The gap

When Flash died, nothing replaced it.

Flash was a single environment where the distance from "draw a shape" to "make it interactive" was zero. A designer could build a game, an animated UI, or a widget — all in one tool. No switching apps. No export pipeline. No "hand it to a developer."

Adobe killed Flash in 2020. Then announced Animate's end-of-sale for March 2026. The community that built interactive web content for two decades — orphaned.

What exists today:

None of them are Flash. Every one sacrifices at least two columns. The tool that fills all five — with vector editing approaching Figma, animation from After Effects, scripting simpler than Flash, a real component model, and web-native export — did not exist.

So we built it.

The backstory

Formo didn't start in 2024. It started in 2013.

2013 — Reactive primitives

An FRP lecture by Alexander Solovyov changed everything. The idea: UI as reactive expressions, not imperative code. Started building reactive Store primitives — values that automatically propagate changes to anything that depends on them.

This became the foundation for everything that followed.

2013–2018 — Quokka: the ideas that became Formo

Founded a software company and built a platform for self-service terminals — payment kiosks, ATMs, identity verification. The main client was a publicly traded fintech company operating tens of thousands of terminals.

The architecture had the right ideas: a reactive declarative language (QuokkaScript) where UI was described as expressions, not procedures. Visual and non-visual components with typed interfaces. Event handlers, reactive bindings, component hierarchy.

NumberBox amount
postfix: {{currency}}
Button: Pay
.click: ()-> myPayment.process()
Transaction myPayment // non-visual component
amount: {{amount}}
.complete: ()-> navigate('success')

The concept was sound — but the visual IDE that would have made it all click was planned and never built. Without it, the language was a good idea without its other half. When funding stopped, the honest conclusion was: we should have used an existing UI framework and shipped faster instead of reinventing the wheel.

The lesson stuck. Formo doesn't reinvent rendering (Canvas2D), doesn't reinvent physics (planck.js), doesn't reinvent parsing (acorn). It reinvents only what nobody else has built: the reactive formula system that connects a visual editor to a live runtime. QuokkaScript's ideas — reactive bindings, visual + non-visual components, declarative UI — finally found the right home.

2020s — Figma renderer

Built a Figma plugin that renders 99% of Figma's visual output and exports animations as MP4. Tech stack: Skia + TypeScript. This meant understanding Figma's rendering pipeline at the deepest level — vector paths, boolean operations, gradients, blend modes, masks, text shaping with OpenType.

That renderer knowledge is now Formo's rendering engine.

Now — Convergence

Vector networks (beyond Figma's data model). Reactive formula system (compiler, signal graph, dependency tracking). Physics engine (planck.js — real Box2D, not tweening hacks). Animation (formula-keyframe hybrid with IK solvers). Components (typed inputs/outputs, non-visual logic, custom editors).

Every piece built over the last decade — reactive primitives, production UI architecture, rendering pipeline, formula language — converges into one tool.

Why now

The pieces that didn't exist in 2013:

• TypeScript — v0.8 in 2012, unusable. Universal standard in 2026.
• Canvas/WebGL performance — slow in 2012. GPU-accelerated with OffscreenCanvas in 2026.
• WebAssembly — didn't exist until 2017. Now runs physics at native speed.
• React as universal component model — didn't exist in 2012. Now the default export target.
• Web platform maturity — pointer events, resize observer, CSS containment, web workers.

The browser is finally ready. The market gap has existed for 9 years and is widening — Adobe Animate's death in 2026 makes it urgent.

What makes Formo different

Not a feature list. An architecture list.

Vector networks, not paths. Every other vector tool uses path chains — ordered sequences of points. Formo uses a graph: any vertex connects to any other vertex. This enables shapes, junctions, and topologies that are structurally impossible in Figma, Illustrator, or any path-based tool.

Reactive formulas, not scripting. Write Ball.x = mouse.x and the ball follows your cursor. No event listeners. No update loops. No state management. The signal graph handles dependency tracking, evaluation order, and batch updates automatically. One line replaces 20 lines of imperative code.

Physics is built in. Not a plugin. Not a library you import. Click a shape, enable physics, set density and restitution. Colliders auto-generate from geometry. Collision events fire into the formula system. Real Box2D simulation — forces, joints, constraints — with visual controls.

Formula-keyframe animation. Keyframes can hold formulas, not just static values. A keyframe can say x = mouse.x + sin(time) * 50 and crossfade into another keyframe with a different formula. Timeline and reactive system are the same thing.

One tool, not five. Draw → animate → add logic → build components → export. No switching apps. No export pipeline. No "now hand it to a developer." The editor is the runtime.

The team behind it

Formo was built solo to prove the concept. A team of five developers — the same people who built Quokka's production software together — is ready to scale it.

Not a team assembled from LinkedIn. People who've shipped together for years, who know each other's code, who've debugged production systems at 2am.

The Breakout test

The litmus test: can you build Breakout in under a minute?

1. Draw a paddle. Formula: x = mouse.x. Paddle follows cursor. (5 sec)
2. Draw a ball. Enable physics: bounce, no friction. (10 sec)
3. Draw bricks, duplicate into a grid. (15 sec)
4. Ball collision event: if target is brick → destroy it. (20 sec)
5. Press Play. The game runs.

No other tool can do this. Figma is static. Rive can't do game logic. Unity takes an hour of setup. Flash could — but Flash is dead.

Formo is what should have existed all along.

Join the Beta →