Built with MIND

Live demos that run in your browser, and open projects written in MIND. Each card shows the real capture and the project's own published numbers.
A gallery of projects built with MIND, one highlighted.

Runs in your browser

Live demos

Each demo is a standalone page with its own design, running in your browser. The GPU demos use WebGPU; the fractal explorer falls back to WebGL2.

One integer kernel paints half an image on the GPU and half on the CPU. The seam is invisible, the XOR diff is all black and the SHA-256 seals match.GPUCPUXOR0 cellsdifferSHA-256 match
Same kernel, two substrates, one image. Identical bytes give an invisible seam, an all-black XOR diff and a matching SHA-256 seal.
Substrate Stitch: the live GPU and CPU output stitched at a seam, with one flipped bit spreading in red on the CPU side

WebGPU + CPU

Cross-Substrate Byte-Identity

One integer kernel (add, subtract and shift only) runs on your GPU and your CPU in the same tab and is stitched into one image. Identical bytes give an invisible seam, an all-black XOR diff and a matching SHA-256 seal; flip one bit and all three break.

  • GPU against CPU: zero differing cells, checkable offline
  • 35 of 35 MIND fixtures pin x86 = ARM; the Lorenz fixture is replayed live and reproduces its pinned hash
Fractal Voyager: a deep Mandelbrot spiral rendered live by the demo

WebGPU / WebGL2

Real-time Fractal Explorer

Mandelbrot, Julia, Burning Ship and Tricorn with smooth zoom and pan, rendered on your GPU. The repository holds the MIND sources for the complex arithmetic, iteration and colour palettes.

  • WebGPU compute with a WebGL2 fallback
  • Audio-reactive colours from a track or your microphone
Swarm Brain: the particle swarm during a saga rollback after an invariant violation

WebGPU

Cognitive Runtime Demo

A particle simulation of MIND's cognitive cycle: sense, think, act, verify, learn. A SHA-256 hash chain makes each seeded run tamper-evident and replayable.

  • 5 invariants checked on the GPU every frame; a violation rolls back to the last verified snapshot
  • Optional WebNN / NPU path where the browser exposes one
MIND Inference Reactor: pipeline rings around the MIND-Law gate of nine invariants and six extensions, invariant eight violated

Simulation

In progress

MIND-Native Inference Pipeline

Follow one token through a model-serving pipeline written in MIND: paged KV cache, FlashAttention-2-style attention, speculative decoding, continuous batching and disaggregated prefill/decode, behind a governance gate.

  • End-to-end inference is not wired yet, so no throughput or latency figures are claimed
  • Determinism-first design (CALF 1.0); the bit-exact check is pending
MIND-Law War Room: the kernel ring of nine invariants and six extensions, with invariant eight violated

Governance simulation

MIND-Law War Room

Launch ten simulated attacks against MIND-Law's nine invariants and six extensions (forge a constraint, cut a feed, replay evidence, collude) and watch every refusal sealed as an evidence record. MIND-Law is STARGA's implementation of the 512 constraint by Dr. J.M. Watson. 512 defines seven canonical conditions. I1–I9 are MIND-Law's implementation of them. Extensions are MIND-Law's own and are not part of 512.

  • 9 invariants · 6 extensions · 10 attacks · kernel checks computed in your browser
  • Story mode · Free attack · Lens · Audit summary
Arch-MIND: the nine Q16.16 metric charts from the dated MIND-Mem fixture scan

Code governance

Commercial · v0.2.0

Deterministic Code Scanner

Nine Q16.16 fixed-point metrics over a typed dependency graph, with architectural rules declared in .mind and enforced fail-closed. Session deltas are chained with HMAC-SHA256. The demo reads a dated, checked-in scan of MIND-Mem, not a live feed.

  • Python, TypeScript, Go, Rust via tree-sitter; MIND via reflection
  • Reproducibility gate automated on Linux; ARM checked manually
GEMM Bench: an excerpt of the MIND GEMM kernel source

WebGPU benchmark

In-Browser GEMM Benchmark

A register-tiled WGSL GEMM shader against ONNX Runtime Web's WebGPU backend on the same matrices, on your own GPU. The number you see is your measurement, not ours.

  • Measured on your GPU1024, 2048 and 4096 square f32 matrices, same GPU
  • Dispatch time and GFLOPS reported for each side

Open repositories

Projects built with MIND

Open repositories you can clone, build and benchmark yourself.

Mind-Ray: recorded wall-clock geomean, Mind-Ray against four reference renderers

GPU computing

GPU Path Tracer

A path tracer written in MIND with an optional BVH-accelerated CUDA backend. Its harness times it against Mitsuba 3, Falcor, Cycles and LuxCore on the same scenes, with the method and raw results in the repository.

  • Measured10.5× to 50.5× lower wall-clock than the four reference renderers (geomean of three stress scenes, one laptop GPU). Results
  • 48.4× steady-state per frame against Mitsuba 3 in persistent mode, same GPU
NikolaChess logo

Game engine

NNUE Chess Engine

A chess engine written in MIND: hybrid alpha-beta and Monte Carlo tree search with NNUE evaluation, Syzygy endgame tablebases and the UCI protocol. Batched GPU evaluation runs through the MIND runtime.

  • Alpha-beta + MCTS hybrid search · HalfKA NNUE
  • Syzygy tablebases · UCI protocol · SPRT testing · release v3.21.0
MIND-Mem: a fresh workspace created with mind-mem-init, then mm status

SI memory

PyPI 5.0.3

Governed Memory for Agents

Replayable memory for SI coding agents. Every write goes through propose, review and apply; every applied decision is hash-anchored in a Q16.16 audit chain that replays byte-identically with query, corpus, configuration and scoring date held fixed.

  • PyPI 5.0.3 · 107 MCP tools · zero core dependencies · one workspace serves 19 coding clients
  • Python scoring path; MIND kernel sources ship, not yet compiled
Mind-Nerve: a real top-5 route over the 11,922-candidate public catalog

Intent router

PyPI 0.3.1 · Apache-2.0

Skill Router for Agents

A small classifier between the request and the agent runtime returns only the top-K relevant skills, tools and MCP servers, so library size decouples from token cost. The encoder is compiled to native Q16.16 fixed-point.

  • Measured96.06% top-5 accuracy across 11,922 routing candidates (manifest)
  • CPU backends in the open-source release; weights auto-download
An exhibition floor of projects built with MIND: a path tracer, a chess engine and a fractal explorer on plinths, and an empty plinth where your project rises under the spotlight.

Building something with MIND?

Send us your project. We feature work from the community here and in the newsletter.