Keeno compiles your components into precise DOM updates. No virtual DOM, no diffing: when a value changes, only the nodes that read it update.
Components that read like HTML
state() and derived(): read a state like a value, write it with .set().
<script lang="ts">
const count = state(0)
const doubled = derived(() => count * 2)
</script>
<h1>Clicked {count} times ({doubled} doubled)</h1>
<button onClick={() => count.set(count + 1)}>+1</button>
<style>
h1 { color: orange }
</style>👆 Click the buttons and watch what updates
By the numbers
The compiler does the work ahead of time, so what runs in the browser is a tiny runtime and code that writes to the page directly.
18.4KB
The whole runtime, min + gzip
Reactivity, components, lists and built-ins. The rest of your bundle is your code.
0
Virtual DOM nodes
A change goes straight to the text node or attribute that shows it.
Under the hood
The compiler reads your markup once and writes the code a careful human would: clone a template, wire one event, and bind each {expression} to exactly the text node it fills.
<script lang="ts">
const count = state(0)
const doubled = derived(() => count * 2)
</script>
<button onClick={() => count.set(count + 1)}>
Clicked {count} times ({doubled} doubled)
</button>
<style>
button { color: orange }
</style>import { state, derived } from "@inflector/keeno";
import { on as _$on, insert as _$insert, template as _$template } from "@inflector/keeno/internal";
const _tmpl$1 = _$template("<button class=\"keeno-abab74ae\">Clicked <!----> times (<!----> doubled)</button>");
export default function Counter($props) {
const count = state(0);
const doubled = derived(() => count.get() * 2);
const _el$1 = _tmpl$1();
const _el$2 = _el$1.firstChild;
const _el$3 = _el$2.nextSibling;
const _el$4 = _el$3.nextSibling;
const _el$5 = _el$4.nextSibling;
_$on(_el$1, "click", () => count.set(count.get() + 1));
_$insert(_el$1, () => count.get(), _el$3);
_$insert(_el$1, () => doubled.get(), _el$5);
return _el$1;
} Reads become .get(): the compiler tracks which names are states.
One template clone builds the static markup in a single call.
Two text nodes update when count changes. Nothing else runs.
Features
A script, some markup and a scoped style: that's a component. Built-ins cover the hard parts: error boundaries, async data, portals, transitions and state-preserving reparenting.
state() creates a signal, derived() computes from others. Templates subscribe to exactly what they read, so a change updates one text node, not a component tree.
Every <style> is scoped to its component, with :global() as the escape hatch and first-class Tailwind CSS v4.
The compiler turns HTML-first .kn files into direct DOM code. Components run once and never re-render.
Move live content between places, iframes and videos included, without re-creating it, using native moveBefore.
One renderStrategy option: streamed SSR, static pages, or islands where only client="…" components ship JavaScript.
A Vite plugin with HMR, in-page dev tools with state time travel and a dependency graph, a VS Code extension with full TypeScript IntelliSense in .kn files, and keeno-check for CI.
A small History API router with route loaders, a query cache, actions that revalidate, and links that prefetch on hover.
Wrap an async function in server() and call it from the browser like any function: typed, with no API route to write.
Examples
Tooling
Vite for dev and builds, Bun for packages and tests, Node, Bun or Deno to render on the server. Bring TypeScript and Tailwind: they just work.