Vibeleaderboard
Index / tool
Visit arrow-js.com
Category
Developer Tools
Rank
No. 2711Tools index

Previous survey · No. 2574 ·

Pricing
Open Source
Type
TOOL
Use case
Coding
Interfaces
SDK
Latest release
v1.0.6
Date

About

A tiny, zero-dependency UI framework designed for the AI agent era that can isolate agent-generated UI components inside WebAssembly sandboxes while rendering directly to the DOM. No build step required and uses simple JavaScript primitives that coding agents already understand.

What it does

ArrowJS lets you write interface code as plain JavaScript template strings bound to reactive state objects. When a value changes, only the text, attribute or event it feeds is updated in the live page, with no compile step. Optional layers add async components, server rendering and adoption of that server output in the browser. A separate sandbox layer runs component code inside a QuickJS engine compiled to WebAssembly, away from the main page context, while still drawing into the real page.

Why it's ranked here

The pitch is specific: stick to modules, template literals and the page's own object model, so a coding agent writes it correctly without learning a compiler or a custom file format. The repository backs that with an installer that teaches Codex or Claude the framework, a one-line app scaffolder, and a WebAssembly sandbox for untrusted generated components. It is MIT licensed and its continuous integration typechecks, tests and builds on every push. The performance notes are candid that it still trails Solid and Vue on first render.

What's good

The core surface is small: components, templates, reactive state, a watcher, cleanup and a next-tick helper, most with one-letter aliases. Server rendering and hydration are layered on the same component model rather than a second API. Hydration is forgiving: it tries to adopt existing server markup, falls back to swapping only marked regions, and replaces the whole subtree as a last resort, reporting each mismatch through a callback. The performance plan bans benchmark-only shortcuts and measures against the standard framework benchmark suite.

Tradeoffs

By the project's own published measurements, creating a thousand rows took about 42 ms against about 32 ms for Solid, and non-keyed partial updates were more than twice as slow as keyed ones. The plan calls create cost the main remaining gap. Async components need the framework, server or hydration layer imported before rendering, a load-order rule that is easy to miss. The scaffolder assumes Vite, and the sandbox, compiler and Vite plugin are only partly visible from the files read.

How to use it well

Reach for it when agents generate interface code and you want output that runs straight in a browser module import, or when you need to render agent-written components in isolation from the host page. Start with the core package alone and add the server layers only when you need them. Prefer keyed lists for data that updates often. Teams chasing top benchmark numbers on large initial renders, or needing a mature component ecosystem, are better served elsewhere.

Technical notes+

packages/core/src/index.ts exports component, html, svg, pick, reactive, watch, onCleanup and nextTick, with aliases c, t, props, r and w. packages/hydrate/src/index.ts implements hydrate() in three stages: reconcile against a staged render, then replaceMarkedBoundaries() using data-arrow-boundary-start/end attributes, then full replaceChildren(), invoking onMismatch with a repaired flag; readPayload() parses JSON from the arrow-ssr-payload element. packages/sandbox/src/index.ts exposes sandbox(props, events, hostBridge) with shadowDOM and debug options. packages/create-arrow-js/index.js accepts --skill-agent codex|claude|both|skip and --no-install. vitest.config.ts runs specs under jsdom; .github/workflows/tests.yml runs typecheck, test and build on push. PERF_PLAN.md records the js-framework-benchmark baseline.

Observed

License
MIT
Language
TypeScript
Packaging
pnpm monorepo publishing separate npm packages for core, framework, SSR, hydration and sandbox
Install surface
npm package, create-arrow-js scaffolder, npx agent-skill installer, browser ESM import
Interfaces
JavaScript library; CLI scaffolder; CLI skill installer for Codex and Claude
Sandbox
QuickJS compiled to WebAssembly, rendering into the host DOM
Testing
Vitest with jsdom for unit specs; Playwright for end-to-end
CI
Typecheck, test and build run on every push

Read from README.md, package.json, LICENSE.txt, packages/core/src/index.ts, packages/framework/src/index.ts, packages/ssr/src/index.ts, packages/hydrate/src/index.ts, packages/sandbox/src/index.ts, packages/create-arrow-js/index.js, packages/skill/index.js, PERF_PLAN.md, vitest.config.ts, .github/workflows/tests.yml.

What it can do

  • Render UI components directly to the DOM

    JavaScript UI component code → Rendered DOM elements

  • Isolate agent-generated UI components in WebAssembly sandboxes

    Agent-generated UI component code → Sandboxed UI components

  • Execute UI framework without build step

    Raw JavaScript code → Running UI application

  • Process simple JavaScript primitives for UI creation

    Basic JavaScript objects and functions → Interactive UI elements

  • Create zero-dependency UI applications

    JavaScript component definitions → Standalone web application

Tags

javascriptui-frameworkwebassemblyai-agentsreactivetypescriptzero-dependency

Tech Stack

Node.jsTypeScript

Media

ArrowJS

Comments (0)

No comments yet

Editorially curated, with community endorsements as a secondary signal. Corrections welcome.