v0.9.0Try Keeno in the playground

Write HTML.
Ship fast UIs.

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().

Counter.kn
<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>

Clicked 0 times (0 doubled)

👆 Click the buttons and watch what updates

Small, direct, predictable.

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.

RuntimeLearn more

18.4KB

The whole runtime, min + gzip

Reactivity, components, lists and built-ins. The rest of your bundle is your code.

RenderingLearn more

0

Virtual DOM nodes

A change goes straight to the text node or attribute that shows it.

LifecycleLearn more

1×

Each component runs once

Setup code never re-runs, so there are no hooks rules or dependency arrays.

ExamplesLearn more

40

Live examples to play with

Every one runs on this site. Open any of them in the playground and change it.

Compiled to plain DOM code

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.

Counter.kn
<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>
Counter.js
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.

Everything you need,
nothing you don't.

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.

See it, then change it.

All 40 examples

Works with your tools.

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.