Why SignalX#

SignalX (sigx) is a fine-grained reactive TypeScript framework. State is signals, views are TSX components, and updates are bounded by signals: when a signal changes, only the components that read it re-render, and only the DOM that differs is patched. 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

Updates bounded by signals, not by the tree#

A SignalX component's setup runs once; its render function re-runs only when a signal it read changes. Under the hood the renderer is a vnode renderer with keyed reconciliation, but a state change never walks the whole app: it invalidates just the components that actually read the changed signal, and the diff is bounded by that signal's readers rather than by the size of the component tree. Work stays proportional to what changed.

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#