Weave

A fine‑grained reactive UI framework — signal‑native, tiny, and TypeScript‑first.

No Virtual DOM. No dependency arrays. No ceremony. Just the threads you need, woven tight.

📚 Documentation · 🚀 Get started · 🎡 Live demo · 🗺️ Roadmap

Weave is 1.0 — the public API is stable and frozen. Breaking changes only ever land in a major version, deprecated‑first. Read the 1.0 notes →

npm create weave@latest my-app

Whether you've just stumbled onto Weave or you've been threading along since the early commits — glad you're here.

Weave is a UI framework built around one idea taken all the way: the screen is a fabric, and reactivity is the thread. When a value changes, Weave touches only the exact part of the page that depends on it. Nothing re‑renders wholesale. Nothing diffs a shadow copy of your UI. You describe your interface once, and from then on your signals do the talking.

The result feels calm: state that updates exactly where it should, a runtime small enough to forget about, and tooling that treats you like a grown‑up. No mental bookkeeping, no “why did this re‑render,” no incantations to make it fast.

We love the frameworks that came before. React made components mainstream, Angular brought structure and a real toolchain, Vue made the on‑ramp gentle, Svelte showed how small a runtime can be, Solid proved signals could carry an entire UI. Weave isn't here to dunk on any of them — it's here to take the threads developers reached for again and again, and weave them into one coherent piece of cloth.

So what does Weave do a little differently?

• Signals all the way down. Reactivity is one model, and it powers everything — from a single piece of text to the router. There's no second system to learn and no observables to bridge.
• Dependencies track themselves. Things update when — and only when — what they depend on actually changes. Nothing to declare by hand, nothing to cache, nothing to forget.
• No Virtual DOM. Your interface maps straight onto the page, so updates stay surgical and the runtime that ships stays genuinely small.
• Batteries included, not bolted on. Routing, state, forms, translations, and motion are all first‑party and share the same reactive core — so they compose instead of competing.
• A component library cut from the same cloth. Buttons to data tables to date pickers — a complete set of UI components, themed by one token system and composed rather than duplicated. Not a bolt‑on kit: they're built on the same signals as everything else.
• Accessible by construction. Those components are built to the WAI‑ARIA patterns — correct roles and state, full keyboard support, focus management, and reduced‑motion — so the hard parts of accessibility are handled before you write a line.
• A real IDE citizen. First‑class VS Code and WebStorm support, with the kind of editor experience you'd expect from a mature framework.
• Honest TypeScript. Types flow through by inference, your editor understands your UI for free, and there's no decorator boilerplate to wade through.

None of this makes the others "wrong." It's a different set of trade‑offs — small, fast, signal‑native, low‑ceremony — for people who want exactly that.

Weave's core is solid — signal-native, covered by a broad browser test suite, and dogfooded end to end by a complete demo app. It evolves deliberately, and one rule sits above the rest: don't break your app. As of 1.0, that's a formal promise: the public API is frozen and versioned under semver — breaking changes only ever land in a major, deprecated‑first. On the horizon:

• Documentation site — the home this README keeps pointing you toward: live today, and filling in component by component.
• Server‑side rendering & hydration — added when there's a real need, with a clean boundary rather than magic strings.
• DevTools — an in‑app panel to watch the fabric update live: named signals/computeds/effects, their values, who triggers whom, a temporal trigger‑trace, and a component/owner tree. Shipped — mountDevtoolsPanel().
• Editor & monorepo integration — an MCP server (@weave-framework/mcp) so AI editors can compile‑check, type‑check, and scaffold through structured tools, and an Nx plugin (@weave-framework/nx) so a Weave app is a first‑class project with inferred cached targets. Shipped.
• More of everything — the long tail of polish that turns a framework into a daily driver.

Ideas and contributions are welcome — the roadmap is a direction, not a fence.

Scaffold a new app in one command — pick npm, pnpm, or yarn:

npm create weave@latest my-app
cd my-app && npm install && npm run dev

Your first component, guides, and the complete API reference all live in the documentation:

Weave is small, fast, signal‑native, and low‑ceremony — and built to hold up in serious codebases, not just demos. Its sharpest edge is the one large teams worry about most: zero third‑party runtime dependencies. No transitive packages, no audit scramble — a supply‑chain attack surface that's effectively nil. Pair that with performance that stays flat as the UI grows, first‑party routing, state, forms, and i18n that share one reactive core, a UI component library built to the WAI‑ARIA accessibility patterns, and type‑checking that reaches all the way into your templates, and you get a framework that scales with a team, not against it.

We won't oversell the young parts: SSR/hydration is still on the roadmap, and the ecosystem is still growing. But the foundation is real and tested today — and it's aimed squarely at the work real applications demand.

Weave is free and MIT‑licensed, built and maintained in the open. If it saves your team time — or you just want to see it thrive — you can sponsor its development:

Every tier is recognition‑based — your name or logo on the docs and in this README — and it keeps Weave independent, maintained, and moving. Thank you for helping the threads stay tight. 🧵

MIT — woven with care. 🧵