Volt

Components are classes

Declared with TC39 standard decorators. A component is constructed once and never re-run to produce a view.

One prefix, one meaning

Everything dynamic starts with ':' — :if, :for, :click, :class. The name alone decides what it does.

Standard signals

Signal.State and Signal.Computed implemented to the TC39 proposal. Lazy, glitch-free, and standards-tracking.

The compiler does the work

Static markup is cloned, constant bindings are folded away, and identical templates are shared. What is left is one effect per binding that can actually change.

Server rendering is a choice

Off until you ask for it. Render to a string or a stream, attach to it with hydrate, and let the compiler say which components have nothing to attach — no island annotation to write.

Server rendering

Behaviour, not markup

Headless primitives held to the WAI-ARIA Authoring Practices — keyboard models, focus, roles and announcements — with a styled layer, a data grid and a rich-text editor built on them.

Primitives

In one file

import { Component, Signal } from '@voltdev/core';

@Component({
  selector: 'v-counter',
  templateUrl: './counter.html',
})
export class Counter {
  count = new Signal.State(0);

  increment() { this.count.set(this.count.get() + 1); }
  decrement() { this.count.set(this.count.get() - 1); }
}

html

<!-- counter.html -->
<div>
  <button :click="decrement()">−</button>
  <output>{ count.get() }</output>
  <button :click="increment()">+</button>

  <p :if="count.get() > 9">That's a lot.</p>
</div>

Pressing + updates one text node. Not the component, not a subtree — the text node whose value changed.

What else is here

The core is components, templates and signals. Around it, each in a package of its own so an application carries only what it imports:

Router — a declared route table whose links are real anchors, with typed parameters and a rendering mode per route.

Query cache — one entry per question, so two components asking it make one request.

Server functions — a method marked @Server() runs on the server and is called from the browser as if it were local.

Server rendering — to a string, or streamed with the slowest query filled in last, and hydrated by claiming the server's nodes.

Primitives, styled components, a data grid and a rich-text editor.

Testing helpers that find parts by role and name, a template type-checker, editor support, and create-volt to start a project with any of it.

Volt is pre-alpha, and two things follow from that. Several of these are partly built, and each page says which parts — a reader who finds out from an exception is worse off than one who read it first. And only the core is on npm: core, reactivity, compiler and the Vite plugin. The rest are in the repository and not yet released, and each of their pages says so at the top. This site documents the repository, which is ahead of the published alpha.

VoltClasses, templates, signals.