Write SolidJS.
Ship native applications.

Why I built it

I’m a Linux fanatic, and I write JavaScript a lot. Not because it’s a beautiful language, but because it runs everywhere. Websites, obviously. Apps, with React Native. Server-side and scripting with Node.js. Just about everywhere.

I’d been working on a fun website for a while, and was considering turning it into a product. But it was really more suitable as a native application. A native desktop application, with a GUI.

Now what?

Read more →

Quick start

Install Bun. Scaffold an app. Run it.

$ bun create solidrt@latest my-app
$ cd my-app
$ bun run dev

Bun is a development-time tool only. A shipped application runs on the SolidRT runtime, which embeds its own JavaScript engine and carries no Bun.

Sponsoring

SolidRT is free and open source. If it is useful to you personally, or to your company, consider sponsoring — it helps keep development going.

Sponsorship helps pay for the work that doesn’t always make a good announcement: platform support, tooling, performance, documentation, and the maintenance that keeps everything moving.

Development happens entirely in the open. Sponsorship funds work on SolidRT itself, and the results are available to everyone. There is nothing exclusive behind a sponsorship tier.

Sponsor on GitHub →

How it works

The core is Rust: layout, the render tree and every draw call are compiled code. Around that sits a set of platform-independent modules — SQLite, networking, filesystem, FFI and WebAssembly — so an application behaves the same on every target instead of growing a branch per operating system.

Impeller, Flutter’s renderer, draws the frame. SolidRT feeds it from outside as well: textures created on the GL side are adopted without a copy, and paths are built, dashed and stroked in Rust before Impeller sees them.

The GPU is fully exposed too: fragment and vertex shaders can be compiled from source while the application is running. Most UI frameworks hand you a canvas and keep the pipeline to themselves. This one hands you the pipeline.

The scene side is native too. A spatial core in Rust owns the transform hierarchy, picking and animation — the parts of a scene graph where an interpreter is least useful. It stays generic, so a 3D scene, a sprite layer or a skeleton can all sit on the same foundation.

Together, this makes powerful 2D and 3D extensions possible without dropping down into a browser stack. They are native, with direct access to the rendering pipeline and the underlying platform.

It is also why the JavaScript layer can stay small. Flux, the runtime SolidRT is using, is built on QuickJS — an interpreter rather than a JIT. That works because the expensive work has already moved into Rust and onto the GPU.

SolidJS runs on top of Flux and does the orchestration: fine-grained reactivity means an update touches only what changed, keeping JavaScript out of the hot path as much as possible.

Development

One dev server serves every client at once. Spin up several instances side by side on your own machine at different sizes, or point a phone, a tablet, a TV or a Raspberry Pi at the same server. No simulators, no emulators, no per-platform project setup.

Agents get access to the same development environment, with deeper access to the runtime itself. SolidRT ships with MCP tooling wired into every layer, and every project is set up for it from the start. An agent can read the live render tree, snapshot any part of it, inject debug commands into a running application, and drive it with real keyboard, mouse and gamepad events.

That access reaches the GPU too: the shaders and draw calls behind a frame, not just the tree that produced it.

It controls time as well. Slow the application down, pause it, or step forward one frame at a time. This exposes the actual state of the application at the level the renderer sees it — so an animation can be inspected frame by frame instead of guessed at.

Repository

Rust crates

npm packages

npm extension packages

Platform packages

Prebuilt runtimes, one per target.

Apps

Status

SolidRT is in alpha and under active development. Expect APIs to change and new surface to land: it is being built in the open, and it is moving.

• iOS is not supported yet. Every platform runs the same rendering path, so it is work not yet done.
• Agents are the best way to take it for a spin today; the MCP integration already works well.
• The extension packages move fastest — younger than the core, and they will change more.
• Focus is shifting to the human experience: documentation and developer tooling.