A.r.i.a.n.n.A.v1.5.0
Loading framework bundles…

A reactive UI framework
built for speed and clarity.

AriannA is a zero-dependency, bundler-free framework with 145+ web components, fine-grained reactivity, and a single fluent API. Faster than Solid on most operations. 1.5 KB gzipped core.

Open the Playground → Reference Get started
counter.ts
import { Component, signal, html } from 'arianna';

class Counter extends Component('arianna-counter', HTMLElement, {}, {}) {
    build() {
        const n = signal(0);
        this.template = html`
            <button @click="${() => n.set(n.get() + 1)}">
                Clicked {{ ${n} }} times
            </button>
        `;
    }
}
145+
Components
455/455
Tests passing
1.5 KB
Core gzipped
8.7 ms
Select row (vs 11.1 Solid)
0
Dependencies

Getting started

Three primitives carry the entire framework: signal, Component, and html. Everything else builds on top.

Hello world signal

const name = signal('Arianna');
host.append(
    new Real('h2').add(() => `Hello, ${name.get()}!`).valueOf()
);

Counter effect

const n = signal(0);
const btn = new Real('button')
    .on('click', () => n.set(n.get() + 1))
    .add(() => `Clicked ${n.get()}× `);
host.append(btn.valueOf());

Computed computed

const first = signal('Riccardo');
const last  = signal('Angeli');
const full  = computed(() => `${first.get()} ${last.get()}`);

host.append(new Real('p').add(() => full.get()).valueOf());

Two-way binding signal⇄input

const text = signal('type here');
const input = new Real('input').set('value', text);
input.on('input', e => text.set(e.target.value));
const out = new Real('p').add(() => text.get());
host.append(input.valueOf(), out.valueOf());

Reactive primitives

Fine-grained reactivity with automatic dependency tracking. Updates only touch the exact DOM nodes that need to change.

Observable (mutable object) Observable

State (proxy reactivity) State

Batch updates batch

Effect with cleanup effect

Inputs

Form controls. Each one is a real custom element with shadow DOM, reactive props, and a fluent API.

Layout

Structural primitives. All resizable, draggable, persistent where it makes sense.

Display

Atoms — avatars, badges, chips, dividers, tooltips. The small things you compose larger UIs from.

Data

Tabular and hierarchical data with virtual scrolling, sortable columns, and reactive cells.

Charts

Canvas-rendered, animated, reactive. Pass a signal and the chart redraws on change.

Finance

Trading-grade widgets: candlesticks, depth, heatmap, sparklines, portfolio, risk, screener, order book.

Payments

Drop-in payment widgets for Apple/Google Pay, Stripe, PayPal, Satispay, Nexi, AliPay. PCI-conscious, brand-correct.

Shipments

Carrier-branded trackers for DHL, UPS, FedEx, BRT — and a multi-carrier component that aggregates them.

Maps

Universal map embed plus provider-specific components for Google, Apple, Bing, Azure, OpenStreetMap, MapLibre.

Audio

Web Audio API, simplified. Players, channel strips, piano roll, transport, multitrack — all on a shared AudioContext.

Video

Adaptive provider switching: native, YouTube, Vimeo, Twitch. Plus a track editor for sequencing.

Animations

Keyframe-based animation engine with curve editor and onion-skin stage for visual sequencing.

Graphics 2D & 3D

Canvas2D editor with layers, bezier, color pickers; 3D viewer with camera, materials, modifiers — all reactive.

Modifiers

Reactive transform pipeline — chain modifiers on shapes (Array, Bend, Mirror, Twist, Wave…) like Blender stack.

Composite

Big widgets built on top of everything else: NodeEditor (Daedalus brain), Chat, CodeEditor.

Physics

2D physics engine: world, bodies, springs, constraints, gravity, drag. Bridges to the reactivity layer.

AI

WebGPU-accelerated tensors, layers, models (Sequential, Transformer), tokenizer, Markov chain. CPU fallback.