OJ

Why it's ranked here

The memory numbers are the case for it. In the project's own benchmark, published with its method, OJ holds 96 to 190 MB from 1,000 to 10,000 components while default Vite dev climbs from 325 MB to 1.1 GB, and it starts cold about 1.7 times faster at the largest size. Production output matches Vite's byte for byte because both use Rolldown. Lovable maintains it, it is MIT licensed, and the test strategy goes well past unit tests. The limit on the verdict: it calls itself experimental, and the numbers come from the authors' runs on one Mac.

What's good

The test suite is organised around failure modes rather than modules: fuzzing over the compiler, env files and cache entries, property tests that re-parse every compiled output, model-based tests for the dependency graph, and mutation testing on the pure crates with each surviving case explained. Request paths are tested against every spelling of directory traversal. Each embedded JavaScript job runs under a heap cap and a wall-clock deadline, so a runaway job fails alone instead of taking the dev server down. The docs are unusually candid, listing where behaviour differs from Vite and which cases are deliberately left unhandled.

Tradeoffs

Vite's own experimental bundled dev mode beats OJ on cold start and page reload at every size in OJ's table: 1.6 seconds against 4.2 cold at 10,000 components, and 0.3 against 2.9 on reload. Hot module replacement, the in-place update after a save, is a tie. Embedding V8 grows the stripped binary from about 30 MB to about 98 MB, and platforms are limited to those prebuilt V8 ships for. Watch-mode builds are not supported yet, the on-disk module cache is opt-in and experimental, and a crashing native addon in a plugin still takes the process down. The changelog is mostly Vite-parity fixes, so compatibility is still moving.

How to use it well

Reach for it where many dev servers or builds run side by side and memory is the bill: CI fleets, coding agents spinning up previews, multi-tenant hosting of React apps. Install it with Cargo or Nix, point it at an existing Vite or TanStack Start app, and compare against your current setup before switching, since plugin and config coverage is broad but still being filled in. For a single developer laptop where fast reloads matter more than memory, Vite's bundled dev mode measured faster. It does not cover frameworks beyond plain Vite-style apps and TanStack Start, and it is not a test runner.

Observed

License

MIT

Language

Rust, a 16-crate Cargo workspace

Install

cargo install from crates.io, or nix run

Interface

CLI with dev, build and preview commands, Vite-compatible flags

Platforms

Linux glibc and musl, macOS, Windows MSVC; x64 and arm64

JavaScript runtime

Embedded V8 via the Deno runtime; Node not required

Plugin support

Vite/Rollup-style plugins, read from the app's Vite config or a plugins file

Framework support

React apps and TanStack Start; Svelte 5 components in dev and build

Testing

Rust unit, integration and property suites, cargo-fuzz targets, Node end-to-end scripts

Project status

Self-described experimental

Maintainer

Lovable