Demos

Working systems, not screenshots. Each demo runs against real infrastructure, shows its own source, and lets you drive it yourself.

How these contracts are tested →

  • ZK Escrow Explorer

    An upgradeable escrow on Base Sepolia where funds move on a Groth16 zero-knowledge proof — the seller proves knowledge of a delivery secret without revealing it. Contested deliveries fall to an AI arbiter whose ruling and full reasoning land on-chain, verbatim.

    • Solidity
    • Groth16
    • Go
    • BaseBase Sepolia

    Open demo → Source

  • RWA Tokenization Explorer

    An ERC-3643-inspired real-world-asset token on Base Sepolia. Fractions of an asset trade as an ERC-20 whose every mint and transfer is gated on an on-chain KYC whitelist — a transfer to an unverified address is refused by the token itself, live and on-chain.

    • Solidity
    • ERC-3643
    • Go
    • BaseBase Sepolia

    Open demo → Source

  • ZK KYC Pass Explorer

    Privacy-preserving KYC for a tokenized asset on Base Sepolia. A holder proves a valid credential from an approved issuer in zero knowledge — no identity list is ever written on-chain — and the token refuses transfers to anyone who has not redeemed a proof.

    • Circom
    • Groth16
    • Solidity
    • BaseBase Sepolia

    Open demo → Source

  • Gas Optimization Race

    The same contract deployed twice on Base Sepolia — once written the way most people write it, once optimized — with a compiler-enforced identical ABI and one test suite proving both behave the same. Race an operation against both in a single transaction and read the two gas figures out of the receipt.

    • Solidity
    • Foundry
    • Go
    • BaseBase Sepolia

    Open demo → Source

  • Interest Rate Model Explorer

    The kinked lending curve nearly every DeFi protocol uses, deployed to Base Sepolia with every parameter immutable — no owner, no setter, no upgrade path. Move utilization and watch the borrow and supply rates come back from live contract reads, with the kink marked. Eight invariants, fuzzed by three engines.

    • Solidity
    • Foundry
    • Echidna
    • BaseBase Sepolia

    Open demo → Source

  • AI Parametric Insurance

    A parametric policy on Base Sepolia whose claim is adjudicated by independent language models, each pinned and drawn from more than one vendor. The evidence hash is committed before any adjudicator is asked anything, so “the evidence was chosen after the answer” is a claim the chain refutes. Every verdict publishes the model, prompt and evidence hashes it answered to.

    • Solidity
    • Go
    • Foundry
    • BaseBase Sepolia

    Open demo → Source

  • Oracle Health Explorer

    Protocols rarely lose money because an oracle was attacked — they lose it because the consuming contract used a price that was stale, negative, or from a round that never finished. A contract on Base Sepolia reads live Chainlink feeds and names which, with the raw round data beside every verdict.

    • Solidity
    • Chainlink
    • Foundry
    • BaseBase Sepolia

    Open demo → Source

  • Deposit Dispute

    A rental security deposit split line by line on Base Sepolia. Three pinned models, spanning more than one vendor, answer one question per deduction — did the landlord establish this on the evidence — and never name an amount. The amounts are fixed at deployment; the contract computes the split and its cap.

    • Solidity
    • Go
    • Foundry
    • BaseBase Sepolia

    Open demo → Source

  • MMR Log

    An append-only log whose on-chain account is 1040 bytes at any length — it keeps at most 32 peak hashes and a count, never the leaves. Measured compute cost per append on Solana devnet, against a model committed before the first measurement, with a Base Sepolia verifier checking the same proofs byte for byte.

    • Rust
    • Solana
    • Solidity
    • BaseSolanaBase Sepolia + Solana devnet

    Open demo → Source

  • Bench Lab

    Three models against one fixed 40-task suite whose answers are checked by code, never judged by another model. Accuracy, first-token latency and dollars per correct answer — scored against predictions committed before the run existed. Three of six were refuted, and the run exposed one of the metrics as broken.

    • Go
    • Evals
    • LLMs

    Open demo → Source

  • Judge Lab

    Two models grade a third against a gold set labeled entirely by code, scored against six predictions committed beforehand. One held. The largest finding is about the harness: a strict output contract discarded 815 of one judge's 1,032 replies over their punctuation, and the contract was not amended afterwards.

    • Go
    • Evals
    • LLMs

    Open demo → Source

  • SBA Lab

    An AI model was given a list of industry and state names with no numbers in it and asked which were riskier. Then 2.19 million real SBA loans were aggregated and its answers were graded by code. It nailed restaurants and put farming and mining in the worst tier when they are the safest — the maximum possible error, twice.

    • Go
    • LLMs
    • Evals

    Open demo →

  • Access Audit Lab

    An access audit over a made-up 50-person company — over-broad access, conflicting permission pairs, dormant accounts — with every finding filed under the SOC 2, SOX ITGC and ISO 27001 controls it is evidence for. Move a threshold and it re-runs in your browser, then print the evidence report.

    • Go
    • WebAssembly
    • LLMs

    Open demo →

  • Agent Gateway

    A policy gate in front of six AI agents, replaying 150 requested actions as allowed, held for a person, or refused. Change a threshold and diff the old policy against the new one in your browser — two rules read history, so an edit moves actions whose own numbers never crossed a line.

    • Go
    • WebAssembly
    • LLMs

    Open demo →

  • unselect2

    Replaces the <select> but looks like and behaves like the <select>. There is no native control anywhere in the rendered page — a listbox handles every interaction and one hidden input per field is what posts. Native constraint validation is gone, and with JavaScript off there is no field at all.

    • JavaScript
    • ARIA
    • Go

    Open demo → Source

  • WASM Keygrind

    EVM vanity addresses ground out in your browser by Go compiled to WebAssembly. Keys are derived from the browser's own cryptographic random source and never leave the tab — pull the network cable mid-run and it keeps going. The page states the worker count it chose for your device, and why.

    • Go
    • WebAssembly
    • JavaScript

    Open demo → Source

  • Backpressure Lab

    A bounded queue pushed past its own capacity, simulated in Go and streamed to the page ten times a second. The same load meets three different answers to a full queue — make the producer wait, refuse the arrival, or discard the oldest item — and each charges a visibly different cost.

    • Go
    • Concurrency
    • SSE

    Open demo → Source

  • Aegean Placement

    Where to put supply depots among sixteen real Aegean ports, solved two ways in your browser. Max-coverage greedy is submodular, so it is proven to reach 1 − 1/e of the optimum; the p-median heuristic beside it carries no guarantee at all — and up to four depots the page checks both against an exhaustive search.

    • Go
    • WebAssembly
    • Optimization

    Open demo → Source

  • pprof Lab

    Recorded Go profiles of the backpressure lab's queue, compared two captures at a time. Under the blocking policy the block profiler attributes the producer's stall to a named function — and the CPU profile of that same run is nearly empty, because the workers sleep rather than spin. Both are shown.

    • Go
    • pprof
    • Concurrency

    Open demo → Source

  • Reconcile Lab

    A Kubernetes-style reconcile loop and a competing writer reaching for the same object. Every write carries the version it was read at, so the loser is rejected — and the only thing this page varies is what the loop does next. Retry at once, retry with backoff, or wait for the next full pass. Each pays in a different currency.

    • Go
    • Kubernetes
    • Reconciliation

    Open demo → Source

  • Orbit Lab

    An SGP4 propagator compiled to WebAssembly, running a thousand objects a frame in your browser. Drag the globe, scrub time, watch the day/night terminator move. A staged conjunction sieve throws pairs away in three passes — and runs the exhaustive all-pairs search beside it, so you can see the two agree.

    • Go
    • WebAssembly
    • Canvas

    Open demo → Source

  • Kafka Lab

    A simulated model of consumer backpressure, compiled to WebAssembly. One consumer spending N milliseconds per message cannot beat 1000/N a second, whatever its rate limit says — drag the work delay, watch a backlog build, then add consumers and watch it drain. The runnable Kafka stack is linked underneath.

    • Go
    • WebAssembly
    • Kafka

    Open demo → Source

  • RAG Lab

    A retrieval pipeline measured rather than described: 93 pages, 825 chunks, local embeddings in pgvector, and a question set locked before grading. 16 of 20 questions retrieved the right page — and all four failures are here, with what came back instead. No API key; the linked repository reproduces every figure.

    • Go
    • pgvector
    • Retrieval

    Open demo → Source

  • Cosmos Lab

    A signed header and two chained ICS-23 proofs, captured from a public Cosmos test network at one height and replayed offline. Watch the verifier accept the real bytes, then refuse a single flipped bit — and see why three of five validators fail where two succeed: the threshold is two thirds of voting power, not of heads.

    • Go
    • Cosmos
    • ICS-23
    • Cosmososmo-test-5

    Open demo → Source

  • Goroutine Visualizer

    Real goroutines and real channels, running on the server and drawn as they block. Park one on a bare channel send, press kill, and watch nothing happen — a canceled context is not something that operation can see. Rebuild the same worker with a select arm on ctx.Done() and it dies instantly.

    • Go
    • Goroutines
    • Concurrency

    Open demo →

  • Rust Lifetime Lab

    Three borrow-checker errors, captured from a real rustc and shown with their carets, their labels and the fixes it suggests. Beside each one is the Go program that compiles instead — and the Go compiler, asked the same question, reports the same finding and then moves the value to the heap.

    • Rust
    • Go
    • Borrow Checker

    Open demo → Source

  • Rust Move Lab

    Three rustc rejections of one ownership transfer written three ways — a second name, a function call, a second turn of a loop — each with the compiler's own carets and the fixes it grades. Beside each is a Go program that runs instead, printing the moment two names turn out to be writing into one array.

    • Rust
    • Go
    • Ownership

    Open demo → Source

  • Rust Borrow Lab

    Any number of readers, or one writer, never both at once. Two refusals captured from a real rustc for breaking that, each pointing at three places — and the program it accepts, which is the first one with two statements swapped. Beside each, a Go program that runs the same shape and reports nothing at all.

    • Rust
    • Go
    • Aliasing

    Open demo → Source

  • Rust Send/Sync Lab

    Two captured refusals for moving and for sharing a value across threads — both the ordinary trait-bound error, not a special case — and the program rustc accepts once the types carry the guarantee. Beside them, a Go race that the compiler and the vet tool both pass over and a runtime detector reports.

    • Rust
    • Go
    • Send + Sync

    Open demo → Source

  • LangDAG Lab

    Three conversation trees captured from a real orchestration library rather than drawn: a model asking for a tool and being answered, one reply continued two ways from the same prompt, and a weighted routing policy whose preferred deployment declines mid-conversation while a standby picks it up.

    • Go
    • LLM Orchestration
    • DAG

    Open demo → Source

  • ETL Lab

    A synthetic multi-exchange feed rebuilt from nothing every few seconds: messy quotes parsed and rejected by cause, symbols canonicalized, duplicate pairs collapsed, and the graph searched for a negative cycle. Then every structure is discarded and the loop starts over, because state never kept is state that cannot go stale.

    • Go
    • SSE
    • ETL

    Open demo → Source

  • Slack AI Lab

    A Go bot answers mentions in Pigfox's own Slack workspace with one model call, and this page mirrors what it said as it says it. The question, the reply, the model and what the call cost — without who asked. Nothing here sends anything: the conversation already happened, somewhere else.

    • Go
    • SSE
    • Slack

    Open demo → Source