Why SignalX#

SignalX (sigx) is a fine-grained reactive TypeScript framework. State is signals, views are TSX components, and there is no virtual DOM: when a signal changes, only the DOM nodes that read it update. The same component model renders to the browser, to native iOS and Android views, to the terminal and to a server-rendered stream.

Fine-grained reactivity with signals#

A signal is a value that remembers who read it. A computed derives another value from signals and caches it until a dependency changes; an effect runs code whenever the signals it read change. Dependencies are tracked automatically at read time — there are no dependency arrays and no manual subscriptions.

TSX 
import { signal, computed, effect } from 'sigx';

const state = signal({ count: 0 });
const doubled = computed(() => state.count * 2);

effect(() => console.log(state.count, doubled.value));

state.count++; // logs "1 2" — nothing else re-runs

signal(primitive) returns a { value } box; signal(object) returns a deeply reactive proxy you mutate directly. If you know SolidJS-style signals, the model will feel familiar.

Read more: Signals · Computed · Effects

No virtual DOM, no re-renders#

A SignalX component function runs once. Its setup creates state, and its render function returns TSX whose reactive expressions are bound directly to the DOM nodes they produce. Later updates do not diff a tree — each changed signal patches exactly the text, attribute or list item that depends on it. That is what makes the core runtime small (about 7 kB) and updates proportional to what changed rather than to the size of the component.

Read more: Components · Lifecycle

One component model, four render targets#

The reactivity core and the component model are renderer-neutral. Each target is a package that maps the same TSX tree onto a different surface:

TargetPackageWhat it renders to
WebsigxThe browser DOM
Native iOS & Android@sigx/lynxReal native views, with a library of native modules
Terminal@sigx/terminalTerminal cells with flexbox layout and keyboard input
Server@sigx/server-rendererA streaming HTML response

Shared packages — router, store, i18n, composables — are written once against the core and run on every target.

Server rendering, islands and resume#

SignalX Server streams HTML from the server and gives you a choice of how much JavaScript the client loads. Islands hydrate only the components you mark with a client:* directive. Resume ships almost no JavaScript on load and lifts event handlers into lazily-imported chunks that run against a resumed scope of named signals, so component setup never re-runs in the browser. Server functions are typed RPC you call like an ordinary function.

Actors for server state#

SignalX Actors adds addressable, single-threaded server objects to the same wire as server functions: one activation per key, turn-based concurrency so a method body never races itself, persistent state with optimistic concurrency, and clustering across hosts when one process is not enough.

Where to start#