Literate visual programming for AI-generated business logic

Let the agent build the app.
Keep the logic inspectable.

A gallery of working apps where every pricing rule, eligibility check, and policy gate lives in a Leapter Blueprint: a side-effect-free program you can read, render, run, and trace.

Examples

5 working apps. Pick one.

Each example is a Next.js page wired to its own Leapter project. Open one, change inputs, then click Glass Mode to see the logic that ran.

The artifact

Same file. Two views.
Both are the program.

Veritas is a text-based logic format. It validates locally, executes deterministically, and renders as an editable visual Blueprint. Sections carry the intent of a rule alongside its executable body.

Drag the handle on the showcase to compare the two representations. The diagram below replays a real run with the active path lit up — exactly what Glass Mode shows inside every example.

validates locallyrenders as a diagramexecutes deterministicallytraceableside-effect-free
vehicle-tax / regime.logic.vts
VERITAS
section "Pure electric vehicles are tax-exempt" {
    """
    Electric vehicles are exempt from annual tax for 10 years
    from first registration under § 3d KraftStG. After expiry,
    the tax is reduced by 50% (§ 9 (2) KraftStG).
    """
    choose {
        if (engineType is "electric") {
            taxExempt = true;
            annualTax = 0;
            regime = "ev-exempt";
            return;
        }
    }
}
vehicle-tax / regime
BLUEPRINT
inputengineType="electric"
Electric

Pure electric vehicles are tax-exempt

Electric vehicles are exempt from annual tax for 10 years from first registration under § 3d KraftStG.

Branch by engine type10
IF
electric11
engineType is "electric"
Set regime12
regime = "ev-exempt"; annualTax = 0;
ELSE
any other engine type13
fallback
Compute tariff14
annualTax = displacement * rate+ co2Tax;
outputannualTax=€0
trace ▶ 11

Drag the handle. Same file, two views.

Why Veritas

What happens to business logic in each approach

Generated app code
Logic works, but disappears into ordinary source files.
Prompt-only agent
Logic is flexible, but runtime behavior may vary.
Low-code workflow
Logic is visual, but tied to a platform runtime and limited literate context.
Documentation
Intent is readable, but does not execute.
Rules engine
Deterministic, but rarely built for AI literate editing or trace replay.
Leapter / Veritas
All of the above. Text in Git, visual in the editor, executable at runtime, traceable after each run, reviewable with visual diffs, and editable with AI support.
Same pattern, your domain

Build your own with the same workflow

Clone the starter, point Claude Code at a requirements doc, and it will write the Veritas, validate it, build the UI, and wire it to the runtime, Glass Mode included.