React asks you to learn JSX. Vue asks you to learn SFCs. Svelte asks you to learn a compiler. Xuda is a clean break. One reactive runtime, two authoring paths, Slim for HTML-first pages and CLI for app-first products, with a direct on-ramp to xuda.ai when you're ready to deploy.
<script type="module">
import { xuda } from "@xuda.io/xuda-runtime-slim-es";
new xuda(document.body, { prog_id: "home" });
</script>
<div xu-store="{count:0}">
<button xu-click="count++">
Clicked <span xu-text="count"/> times
</button>
</div>Authoring paths · One runtime
npm dependencies in your bundle
Whole framework, gzipped
From localhost to xuda.ai prod
React lets you build a UI, then leaves you alone with hosting, data, auth, and ops. Next.js wraps a hosting bill around your code and calls it a framework. Svelte ships a compiler and waves goodbye. The Xuda JavaScript Framework is the only reactive runtime designed to scale from a single HTML file to a deployed production app on a platform we own, end to end.
No JSX. No .vue files. No template compiler. The HTML you write is the HTML the browser parses, with reactivity layered on with xu-* directives.
Xuda binds straight to real DOM nodes. No diffing. No reconciler. No mystery re-renders. Just the elements that depend on the value that changed, updated.
Slim ships as a single self-contained ES module. No transitive deps. No npm-package-of-the-week incident. Audit it once, ship it forever.
Start with a single HTML page. Outgrow it? Switch to the CLI without rewriting. Ready to ship? Push to xuda.ai. One runtime, one mental model, zero migrations.
Xuda was designed alongside large language models. Stable directives, deterministic structure, named building blocks. AI agents that emit Xuda produce running apps, not "now wire it up yourself" stubs.
The framework, the runtime, the AI codegen, the database, the deployment system, and the hosting are all one platform. Stop renting six tools. Stop wiring six dashboards. Ship.
Both compile down to the same reactive runtime. Start with one, switch to the other, or use them side by side. There is no migration story between them. There is no second framework to learn. Just the path that matches the job in front of you, right now.
HTML-first · page-first · ~140 KB ES module
The lighter path. Drop a <script type="module">, import Slim from a CDN or npm, and decorate your existing HTML with xu-store, xu-text, xu-click, xu-for, and xu-show. Your file becomes reactive. No build, no JSX, no toolchain.
App-first · source-driven · cloud-syncable
The serious path. Author App.xu, drop screens into components/, shared state into globals/, reads into data/get/, writes into data/set/, plus tables/, routes/, apis/, alerts/, and ai-agents/. Add an api_key and it syncs straight to xuda.ai.
api_key away from xuda.ai cloud sync & deploymentEvery other framework treats LLM output the same way: a wall of generated React, a 600-line component file, an import graph the model 'hopes' resolves. Xuda flipped the assumption, designed alongside Xuda AI from the start. Stable directive vocabulary. Deterministic source layout. AI agents emit Xuda HTML and CLI source the same way humans do, and the result is a running app.
The directive set is small, named, and frozen. Models trained on Xuda once stay correct across releases. No "renamed in v4" footguns. No deprecated hooks the AI hasn't heard of yet.
CLI apps have explicit folders for components, globals, reads, writes, tables, routes, alerts, and AI agents. An LLM doesn't have to guess the project shape. It already knows.
xuda-cli dev compiles source into runtime documents that double as machine-readable specs. Agents read the docs, edit the source, and rerun. No reverse-engineering.
Xuda AI generates Xuda source. The program checker validates it. The runtime executes it. There is no "did the model invent an npm package this week" risk. The pipeline is sealed.
The CLI has a first-class ai_agent source unit. AI is not a plugin you bolt on. It is a building block of the framework, with the same lifecycle as components, routes, and tables.
Xuda apps written by humans and Xuda apps written by AI agents are indistinguishable. Same directives, same files, same runtime. Mix freely. Ship without disclaimers.
Xuda doesn't invent a new templating language. It uses HTML attributes, the same mechanism that already drives id, class, and data-*. The directive set is intentionally small, so the whole framework fits in your head, and in a model's context window.
xu-storeDeclare reactive state on any element. Every descendant can read it, mutate it, and bind to it.
xu-textWrite text into an element. Prefix it with xu-exp: and it binds to a live expression. No setState.
xu-contentSet rendered content from a literal or expression. No template literal interpolation gymnastics.
xu-showConditionally render an element. Hide and re-show without re-mounting.
xu-forIterate over arrays or objects directly in HTML. List items stay in sync with the underlying data.
xu-clickUpdate state on click from an inline map, like {'@count': @count + 1}. No handler wiring.
xu-bindTwo-way bind a form input to a store value. The onChange + setState ceremony is gone.
xu-on:*Attach a full workflow to any DOM event: actions, conditions, async steps, declared in the markup.
Xuda is the only JavaScript framework with a credible path to production that doesn't involve a stack of third-party services. Start small with Slim. Outgrow it? CLI. Ready to ship? Push to xuda.ai. The runtime stays the same. The directives stay the same. The bill stays one bill.
Drop Slim into one HTML file. Reactive page in five minutes. Static-host it anywhere.
Move to typed source units. App.xu, components, globals, tables, routes. The framework grows with you.
Let Xuda AI generate components, programs, and ai_agent units. They drop into the same source tree and run.
Add an api_key. Your CLI app syncs straight to the xuda.ai platform. The Studio sees every source unit.
Roll out to xuda.ai's geo-distributed VPS network. Build, hosting, monitoring, rollback, all included. One bill.
With React, the same path is: pick a build tool (Vite or Webpack or Rspack?), pick a router (react-router, TanStack, Next?), pick a state lib (Redux, Zustand, Jotai, signals?), pick a hosting platform (Vercel, Netlify, Cloudflare?), pick a backend (Supabase, Firebase, Convex?), pick an auth provider, pick an email provider, pick a logging service, glue them together, debug the integration, pay six invoices. Xuda is one runtime, two paths, one platform. That's it.
A complete reactive counter with state, a derived condition, an event handler, and a reset. Save it as index.html, open it in a browser, and it runs.
<!DOCTYPE html>
<html>
<body>
<script type="module">
import { xuda } from "https://cdn.skypack.dev/@xuda.io/xuda-runtime-slim-es";
new xuda(document.getElementById("app"), { prog_id: "counter" });
</script>
<div id="app"></div>
<template id="counter">
<xu-single-view>
<div xu-store="{'count':0}">
<h1>Clicks: <span xu-exp:xu-content="@count"></span></h1>
<p xu-exp:xu-show="@count >= 5">That escalated quickly.</p>
<button xu-click="{'@count': @count + 1}">+1</button>
<button xu-click="{'@count': 0}">reset</button>
</div>
</xu-single-view>
</template>
</body>
</html>component with one move. Ready to ship? api_key + sync to xuda.ai. Same runtime, all the way up.Every JavaScript framework on the market today gives you part of the story: a UI library that needs a backend, a meta-framework that needs a hosting plan, a compiler that needs a CLI. Xuda is the only framework that owns the whole path: runtime, AI codegen, deployment, and hosting.
Xuda You | React | Next.js | Vue | Svelte | |
|---|---|---|---|---|---|
| Author in plain HTML | ~ | ||||
| Runs without a build step | ~ | ||||
| No virtual DOM | |||||
| Zero npm dependencies in bundle | |||||
| Reactive store baked in | ~ | ||||
| Routing in the runtime | ~ | ||||
| AI-native source layout | |||||
| First-class ai_agent unit | |||||
| Same runtime, page → app → prod | |||||
| Owned hosting & deployment | ~ | ||||
| One bill end-to-end | |||||
| Runtime size (gzipped) | ~140 KB · runtime + data layer | ~45 KB +DOM lib | ~85 KB + framework | ~35 KB | small per-component |
The Xuda JavaScript Framework is the only reactive, AI-native runtime that scales from a single HTML file to a deployed production app on a platform we own end to end. No JSX. No virtual DOM. No supply chain. No Vercel. No Supabase. No surprise bill.