❯ /demo — live synthesis

Watch it discover a program.

… loading wasm

This page runs the actual compiled NPCoT runtime — the same 130 KB Rust-to-WASM binary that ships to edge devices. Below, it boots and discovers a program on its own. Then it's your turn: give it examples, watch it search, keep the proof — and watch it refuse when no program explains your data.

● discovery reel

loading runtime …

❯ station 1

Teach it yourself.

Pick a rule to teach. The runtime searches its whole program space — field-combine × guard × mined thresholds × transform × reduce × post-scale — in milliseconds, and keeps only the simplest program consistent with every example.

❯ station 2

Consult the library.

A consult is a cosine-similarity lookup over skill signatures — the production runtime keys on transformer hidden states. Drag the noise slider to corrupt the query and watch the gate refuse below 0.85.

parsed: [3, -1, 4, -1, 5, 9, -2, 6] · 8 points

● consult437.30 µs · js
23.000

rounded to integer: 23

cached program

fn sum(points: &[[f32; 1]]) -> f32 {
    let mut acc: f32 = 0.0;
    for pt in points {
        let v = pt[0];
        acc += v;
    }
    acc
}

❯ station 3 — the full synthesizer, hosted

Use the real engine.

Stations 1–2 run the 130 KB embeddable runtime in your tab. This one sends your examples to the hosted Rust synthesizer — the full solver portfolio with persistent cross-run memory. Multi-input integer functions, verified against every example before anything is returned. If no program explains your data, it says so.

inputs (comma-sep ints)output

free tier · 30s budget · first request may cold-start (~10s)

● verified program output

❯ awaiting examples — the program that comes back is verified against every row before you see it.

❯ station 4 — natural language in, verified code out

Write a prompt. Get a proof.

A deterministic parser — no LLM anywhere — pulls the I/O contract out of your prose: asserts, doctests, f(x) -> y arrows, or "returns" sentences. The cascade then searches for a function and verifies it against every example it found before you see a single line. No examples in your prompt → it refuses and tells you what to add.

● your prompt
● verified output

❯ paste a prompt with examples, or run the starter.

❯ go deeper

The library is the asset — 4 skills, 0 taught this sessionopen ▾

Skills

  • ○ sum — acc += x
  • ○ mean — acc += x, / n
  • ○ max — acc = max(acc, x)
  • ○ dot_product — Σ x·y over (x,y) points

Exports use the lowest format the library needs: v2 when any skill uses records or guards, v3 when any skill is stateful. Older runtimes reject higher-format files cleanly instead of mis-executing them — a stateful program can never be silently run as a stateless fold.

Why this matters

  • The same loop — miss, synthesize, verify, cache — lifted Qwen3.5-4B to 85.98% HumanEval for $0.39 of GPU time (keyed on hidden states instead of dropdowns).
  • One discovered program → working code in 5 languages. The artifact is an IR, not a string.
  • Guard thresholds and constants are mined from your data — nothing hardcoded.
  • Static verifier proves termination + bounded output before caching.
  • Consults are deterministic, microsecond, zero-GPU.
Teach it a stateful skill — format v3: counters, debouncers, resettable aggregatesopen ▾

A v3 skill is (state, input) → (state', output) — a per-step pipeline plus one persistent state cell. You teach it from a trace: a sequence of input → expected output steps, one per row, instead of a single target. Reset rules are mined from the trace data, never hardcoded.

Loading the WASM runtime…