Hypertool

Technology

What makes Hypertool different under the hood?

A GPU design canvas that speaks Figma both ways, an AI agent that sees the stage and tests what it builds, and real builds (npm, git, a dev server) that run inside your browser tab.

Last updated

Everything aliveVectors, type, images and running pieces on one GPU-drawn canvas
Figma, both waysPaste frames in as editable layers; copy layers back out to Figma
Eyes and handsThe agent sees the stage, clicks, types and watches motion to check its work
No build servernpm, git and a live dev server run in your browser tab

Why it is different, and what makes it work

Hypertool is a browser studio that turns a prompt into a live, controllable visual (WebGL, shaders, typography, motion) with a shareable URL, video export and real code. Each of these is something you get, and the engineering behind it.

A design canvas where everything is alive

The stage is a full design engine drawn on your GPU (WebGPU, with WebGL 2 as fallback). Vector shapes, text, images, video, 3D models and your running pieces share one infinite canvas with layers, undo and Figma's shortcuts, and every piece keeps running while you zoom out to see the whole system. Any layer exports as SVG, PNG, JPG, WebP or code.

Speaks Figma, both ways

Paste a selection from Figma and it lands on the stage as editable layers (vectors, text with its fonts, images), not a screenshot. Copy layers on the stage and paste them straight back into Figma. Text is set with professional shaping (HarfBuzz, FreeType, right-to-left and mixed scripts), so type looks the way it was designed.

An agent with eyes and hands

The agent works the stage the way you do. It takes screenshots up to 4K, reads the layer tree, samples a contact sheet that tells it whether the motion moves and settles, and reads the piece's console errors, frame rate and memory. It clicks, drags, types and moves controls to test what it built, lays out whole scenes on the stage in one undo step, and fixes what is off before it hands back.

Real builds, with no server to wait for

On a laptop or desktop, opening a project starts a complete development environment inside the page: a filesystem written in Rust and compiled to WebAssembly, a shell, real processes, a package manager, git and a live dev server. Your piece is installed, built and run on your own machine, so a change shows up the moment it is written, the agent's included.

The whole npm ecosystem, not a toy subset

Packages install for real, into a real node_modules: Three.js, p5.js, PixiJS, GSAP, Tone.js, React, Vite and anything else that runs in a browser or in plain Node, including libraries that ship WebAssembly. Common packages come from a pre-extracted cache, so their installs skip most of the downloading and unpacking.

Controls that turn a result into a tool

Every control lives in one plain file in the project, controls.toml, and runs on its own engine compiled to WebAssembly, in a worker of its own, off the piece's thread. The panel and its automation travel with every share link and every export: whoever gets the piece gets the tool.

Links that never change under people

A share link, its embed and an export are made from a single build bound to the exact version it came from, so they can never disagree. A link never changes under the people you sent it to; publishing again makes a new version, and a remix starts from exactly the version that was shared.

Video of exactly what ran

Record encodes the running piece on your machine to H.264 MP4 with its sound mixed in, frame by frame as it paints. Nothing goes to a render farm and nothing is re-rendered, so the video is exactly what ran.

What it gives you

Live pieces, not pictures

Everything you make runs: motion, interaction, sound and 3D stay alive from the first prompt to the final link.

An AI agent that designs with you

Describe the idea, show references, and the agent builds it, refines it and checks its own work.

A visual direction, and design tokens that hold it

Ready-made style directions when you have no brand yet, and a shared DESIGN.md of colours, fonts, spacing and radii.

Start from what you have

Paste Figma frames, drop Claude Design hand-offs, web pages, code, ZIPs, folders or GitHub repositories: they arrive working.

Every project is a running card on one canvas

An infinite, GPU-drawn stage where pieces keep running side by side: zoom out to see the whole system, focus one to work on it.

Variations side by side, each its own live project

Duplicate a card and the copy gets its own folder and its own dev server: compare directions while all of them run.

Real design tools next to live code

Frames, shapes, pen, pencil, text, auto layout, components, boolean operations, masks, gradients, shadows, blurs and glass.

Speaks Figma, both ways

Paste Figma selections as editable layers, not screenshots, and copy layers on the stage back into Figma.

Any material, placed live

Images, GIFs, SVG, video, audio, fonts and 3D models in 19 formats, placed on the stage and used by every piece.

Draw your feedback on the piece

Sketch over a running card, add a note, and the agent gets the marked-up picture.

Real controls on every piece

25 kinds of control, from sliders, palettes and gradients to 3D points, seeds, matrices and live audio readouts.

Hand over a tool, not a file

Share the piece with its panel and a client or brand team makes their own variations, safely.

The agent sees the stage and uses it

Screenshots up to 4K, the layer tree, motion contact sheets, console errors: it clicks, drags, types and tests what it builds.

Watch every agent work

Each agent, helper agent and connected tool gets its own named cursor on the stage, pointing at what it is doing.

Open to your other agents

Claude Code, Codex and Cursor can work in your projects through Hypertool Studio's own MCP server.

Every turn saved, every change reversible

Work saves itself; every agent turn shows what it changed, with Restore. Connect GitHub and every turn is committed.

A live link for every device

A link that runs the piece live, with controls or without, set separately for desktop and for phones, plus embed code.

Video with sound, straight from the piece

Record the running piece to MP4 with its sound, or take a still, at the exact size you set.

Projector mode with a phone remote

Send a piece to a wall or a screen in its own output window, with corner pinning, flipping and masks.

Code and files your team can ship

A web component or an npm package with TypeScript and React wrappers; any layer as SVG, PNG, JPG, WebP, React, CSS or JSON.

A gallery you can remix

Publish to the gallery, and open, explore and remix what others made, with credit kept.

Questions

Does my work run on Hypertool's servers?

On a laptop or desktop, no: your piece is installed, built and run inside your browser tab. What crosses the network is the AI model's messages, packages from the npm registry and your saved project.

Which packages work?

Anything that runs in a browser or in plain Node without compiling native code: Three.js, p5.js, PixiJS, GSAP, Tone.js, React, Vite and libraries that ship WebAssembly. Packages that need a native compiler or a server socket do not.

Which browsers does it need?

A current Chrome, Edge, Arc, Firefox or Safari on a laptop or desktop. Shared pieces open in any modern browser, on desktop or phone, with no account.

Is the code mine?

Yes. Every piece is real code you can open with Show code, export as a web component or an npm package, and commit to your own GitHub repository.

Open a project and the whole toolchain starts with the page.

Start for free →