Run the feed. See the silicon. A WebAssembly twin of a NASDAQ TotalView-ITCH 5.0 parser, measured on your own hardware, with a WebGPU order-book visualisation and a single-file local backend. Pre-silicon, reproducible, and honest about what is not proven.
Live demo · Local demo after node backend/server.mjs.
- An RTL ITCH 5.0 parser (
rtl/) that decodes all 22 official opcodes, preserves reference data, handlestkeep/tlast, and ships 128/256/512-bit variants. - A MoldUDP64 front-end (
moldudp64_frontend.sv+depacketizer.sv) with IP/UDP filtering, sequence-gap detection and back-to-back multi-frame flow control. - A field-accurate reference model in Python (
tb/itch_model.py) and Rust (wasm-core/), cross-checked record-by-record. - A local-first web app: WASM in a Worker, WebGPU compute for price bins and latency histograms, Canvas2D fallback, OPFS persistence, PWA/offline.
- A Node backend / MCP server / REST API / npm package / PyPI package / single EXE / Docker image / Vercel build around the same WASM core.
- A native Vulkan/DX12 compute runner (
native/) usingwgpu, with an opt-in Windows process boost. - Verification evidence: 1,000,000-message full-field regression, Z3 formal (BMC, k-induction, covers), CVC5 recorded pass (2026-11-03; see the formal note), proofs, synthesis matrix, mutation tests, browser gates.
- Not silicon-proven. There is no tapeout. The wrapper has a completed Sky130 25 ns P&R (0 DRC/0 LVS, timing closed, ≈42 MHz); the parser/BBO blocks and silicon themselves are not signed off.
- Not a trading system. No order routing, no live feed, no investment advice.
- Not a zero-cycle wire-to-output parser. The honest latency is:
one clock from
s_axis_tdatainto the window register + one clock to the registered output = 2 clocks (6.20 ns at 322.26 MHz). The async bypass is valid in the same cycle as the window, one clock after ingress. - MoldUDP64 is verified in simulation, not on a 100G MAC. Back-to-back frames (including a sequence gap and a dropped-port frame) pass end to end; the Ethernet ingress itself is modelled in the testbench.
v0.3.1 (patch of v0.3.0) is the first release meant to be installed and used without a developer. It ships local cloud + web + EXE + GitHub Releases, with honest limits.
| Piece | What you get |
|---|---|
| Local cloud | LAN service on your machine, local JSON persistence under .data/, optional bearer token, no cloud account |
| Web | Same PWA at localhost, on a phone over LAN, and on Vercel; WebGPU with Canvas2D fallback |
| EXE | dist\chiplab.exe starts the local cloud + web UI from one file |
| GitHub | Tag-driven release with EXE, npm tarball, Python wheel/sdist, SBOM and SHA-256 checksums |
| MCP | 12 read-only tools for agents, strict schemas, hashed audit log |
| Design | Reviewed copy, mobile 390 px and desktop 1440 px layouts |
# loopback only (default): writes allowed from this machine
node backend/server.mjs
# LAN: phone/tablet on the same network, token required for remote writes
node backend/server.mjs --host 0.0.0.0 --token "choose-a-long-token"
# or use the single EXE
dist\chiplab.exe --host 0.0.0.0 --port 4173 --token "choose-a-long-token"Open the LAN URL printed on startup in the Local cloud panel of the web app, enter the token if you set one, then press Test → Sync / Pull.
| Endpoint | Method | Auth | Purpose |
|---|---|---|---|
/api/cloud/info |
GET | none | version, LAN URLs, token state, data dir, uptime, namespaces |
/api/store |
GET | token if set, else loopback | list namespaces |
/api/store/:namespace |
GET | same | read {revision, updatedAt, data} |
/api/store/:namespace |
PUT | same | write {data, expectedRevision}; 409 on conflict, 413 over 1 MB |
/api/store/:namespace |
DELETE | same | delete one namespace |
Namespaces are [A-Za-z0-9_-]{1,32}. Files are written atomically (temp + rename),
mode 0o600, and capped at 1 MB. There is no directory browsing.
- Loopback by default;
--host 0.0.0.0is an explicit opt-in. - With
--token, all store operations requireAuthorization: Bearer <token>. Without a token, only loopback clients may read or write. - Data lives only in
.data/on your machine (git-ignored); the Vercel deployment has no database and never receives it. - The EXE is not code-signed; verify the published SHA-256 before running it.
- Semantic Versioning; contents of a published version never change.
CHANGELOG.mdfollows Keep a Changelog and is the source of release notes..github/workflows/release.ymlruns on tagv*: verify → Windows EXE → npm/Python packages → SBOM →SHA256SUMS.txt→ GitHub Release.- v1.0.0 is deliberately not claimed. It is reserved for multi-frame MoldUDP64 back-pressure, RTL top-of-book, LibreLane/OpenSTA timing/DRC/LVS sign-off and published artifacts with provenance.
Release artifacts:
| Artifact | Produced by |
|---|---|
chiplab.exe |
npm run build:exe (Node SEA, unsigned) |
chiplab-core-0.3.1.tgz |
cd packages/npm && npm pack |
chiplab_itch-0.3.1-py3-none-any.whl + .tar.gz |
cd packages/python && python -m build |
sbom.json |
node scripts/sbom.mjs |
SHA256SUMS.txt |
node scripts/checksums.mjs dist/release |
Verify a download with sha256sum -c SHA256SUMS.txt (or Get-FileHash on Windows).
Every release EXE, npm tarball and Python wheel/sdist also carries a SLSA build
provenance attestation from GitHub Actions:
gh attestation verify chiplab.exe --repo timfromhcs/ultra-low-latency-nasdaq-itch50-core
gh attestation verify chiplab-core-0.3.1.tgz --repo timfromhcs/ultra-low-latency-nasdaq-itch50-coreThe container image publishes provenance: mode=max, an SBOM attestation and a
keyless cosign signature. Inspect the attestation manifest with
docker buildx imagetools inspect ghcr.io/timfromhcs/ultra-low-latency-nasdaq-itch50-core:main
and verify the signature (using the image digest from that output):
cosign verify ghcr.io/timfromhcs/ultra-low-latency-nasdaq-itch50-core@sha256:<digest> \
--certificate-identity-regexp 'https://github.com/timfromhcs/.*' \
--certificate-oidc-issuer https://token.actions.githubusercontent.comThe npm tarball, Python wheel and sdist are signed as blobs (*.sigstore.json bundles
attached to the release). Verify one with:
cosign verify-blob --bundle chiplab-core-0.3.1.tgz.sigstore.json \
--certificate-identity-regexp 'https://github.com/timfromhcs/.*' \
--certificate-oidc-issuer https://token.actions.githubusercontent.com \
chiplab-core-0.3.1.tgzThe first published release is
v0.3.1 (first: v0.3.0)
with chiplab.exe, the npm tarball, the Python wheel/sdist, sbom.json and
SHA256SUMS.txt. Reproducibility status: the WASM (make repro-wasm, pinned rustc
1.98.1), the Python wheel/sdist (make repro-python, SOURCE_DATE_EPOCH + normalized
sdist) and the Windows EXE (node scripts/repro_exe.mjs, same Node 22 toolchain)
rebuild byte-identically. The weekly Repro workflow checks all three.
Registry publishing is opt-in and off by default: set the repository variable
NPM_PUBLISH=true (npm trusted publishing or token) or PYPI_PUBLISH=true (PyPI
trusted publishing) before pushing a tag. Without them the Release workflow only
produces the GitHub Release assets. The publish steps are prepared but have not been
run against the registries.
git clone https://github.com/timfromhcs/ultra-low-latency-nasdaq-itch50-core.git
cd ultra-low-latency-nasdaq-itch50-core
# 1) Web demo + local API (Node 22, no npm dependencies)
node backend/server.mjs
# open http://127.0.0.1:4173The web app also works as a static PWA. The browser keeps its own run history in OPFS; nothing is uploaded.
| Runtime | Command | What you get |
|---|---|---|
| Web + API | node backend/server.mjs |
WebGPU/WASM demo, /api/* |
| Local cloud | node backend/server.mjs --host 0.0.0.0 --token … |
LAN service + local JSON store |
| CLI | node backend/run.mjs --compare --count 1000000 |
8-chip comparison |
| Single EXE | npm run build:exe && dist\chiplab.exe |
one file, embedded web + WASM + local cloud |
| Docker | docker compose up --build |
same demo at localhost:4173 |
| Vercel | npx vercel (or MCP) |
static app + stateless /api/* |
| MCP | node mcp/server.mjs |
12 read-only tools for agents |
| npm | npm i @chiplab/core |
WASM core + CLI |
| PyPI | pip install chiplab-itch |
Python reference model + CLI |
# Linux/WSL toolchain: verilator, yosys, iverilog, z3, cvc5, python cocotb/pytest
make lint # Verilator, 0 warnings
python tb/itch_model.py --count 100000 --out tb/vectors
make sim # full-field Verilator regression
make formal # Z3 BMC + k-induction + covers
./formal/solver_matrix.sh
python -m pytest -q tb/test_model.py
node scripts/wasm_smoke.mjs && python scripts/check_wasm_fixture.py
node backend/run.mjs --compare --count 1000000
node mcp/client_smoke.mjs
node scripts/test_cloud_api.mjs
node scripts/release_check.mjs
node scripts/build_vercel.mjs && node scripts/test_vercel_api.mjsAll numbers below are model/simulation results at 322.26 MHz, not silicon.
Reports live in reports/.
| Check | Result | Evidence |
|---|---|---|
| Full-field RTL regression | 1,000,000 / 1,000,000 records, 0 mismatches, 31,383,973 bytes, 1,961,516 cycles, 41.290 Gbps | reports/sim_1m.txt |
| Fields checked | type, flags, length, locate, tracking, timestamp, ref, new-ref, shares (64b), stock, price, match, MPID, printable, event, payload checksum | tb/sim_main.cpp |
| Reference model | independent Python, all 22 opcodes | tb/itch_model.py |
| WASM ↔ Python | 10,000 records, 0 mismatches | scripts/check_wasm_fixture.py |
| RTL ↔ WASM | 100,000 records on one stream, every canonical field equal | scripts/rtl_wasm_equiv.mjs |
| Formal | Z3 PASS (BMC + k-induction + covers); CVC5 1.3.2 re-run: BMC + k-induction PASS at depth 8, covers not completed (needs depth 20; slow on this host). The committed CVC5 pass is from 2026-11-03 | reports/formal.json, reports/formal_cvc5.log |
| Mutation | 10/10 RTL mutants killed (length, offsets, share width, flags, append, consume) | reports/mutation.json |
| Mutation (BBO) | 9/9 parser→BBO mutants killed (side, hash slot, cancel, max/min, volume, last) | reports/mutation_book.json |
| Synthesis 128-bit | 22,710 cells, 2,228 DFFs | reports/synth_128.log |
| Synthesis 256-bit | 25,324 cells | reports/synth_256.log |
| Synthesis 512-bit | 29,568 cells | reports/synth_512.log |
| Native Vulkan (Radeon 680M) | 200,000 records in 46.49 ms (re-run 2026-11-10), bins vs CPU 0 mismatches, checksum 254251 | reports/native_bins.bin |
| Local cloud | token required for non-loopback writes, revision conflict → 409, traversal → 400 | backend/store.mjs |
| AXI4-Stream skid | 200 random beats under random tready, no loss |
tb/test_skid.py |
| MoldUDP64 multi-frame | 5 frames back-to-back, 28 records, 1 gap, 1 drop, no loss | tb/test_mold_multi.py |
| Mold back-pressure | 329 bytes under random m_axis_tready, no loss or reordering |
tb/test_mold_pipeline.py |
| Sequence recovery | gap request, replay recovery, timeout abandon, duplicates | tb/test_recovery.py |
| RTL top-of-book | 400 random events + 100 back-to-back (1 event/cycle, no stall), 0 mismatches; top-4 depth; risk limits | tb/test_book.py |
| LibreLane full flow | wrapper completes the whole flow at 25 ns (2200 µm, resizers): 0 Magic/KLayout DRC, 0 LVS, setup +1.3333 ns, hold +0.0840 ns, Fmax ≈ 42.25 MHz (reports/openlane_25fx-full.json) |
openlane/README.md |
| Level-table flow (reduced) | 8/2/4 at 42 ns: KLayout DRC 0, LVS 0, setup +0.1200 ns, hold +0.0163 ns, Fmax ≈ 23.88 MHz (reports/openlane_lvlsmall42-full.json) |
openlane/README.md |
| Sky130 pre-PnR STA | 250 MHz WNS −8.27 ns · 322 MHz WNS −9.14 ns · Fmax ≈ 81.5 MHz; worst path FF → raw_payload[0] (ss, pre-PnR, no sign-off) |
reports/openlane_sky130-250mhz-sta.json |
| GF180 pre-PnR STA | 322 MHz WNS −19.87 ns · Fmax ≈ 43.5 MHz; worst path FF → raw_order_data[260] (ss/125 °C, pre-PnR) |
reports/openlane_gf180-sta.json |
| IHP SG13G2 pre-PnR STA | 322 MHz WNS −3.08 ns · Fmax ≈ 161.9 MHz; hold WNS −0.052 ns; worst path FF → FF (slow/125 °C, pre-PnR) | reports/openlane_ihp-sta.json |
| Wrapper pre-PnR STA | 322 MHz WNS −8.62 ns · Fmax ≈ 85.3 MHz; worst path FF → FF, no debug bus (ss, pre-PnR) | reports/openlane_wrap-sta.json |
| Small-block full flow | itch_metrics 6,776 cells: 0 DRC, 0 LVS, timing closed at 10 ns (Fmax ≈ 101 MHz) |
reports/openlane_metrics-full3.json |
| 32-bit wrapper STA | 322 MHz WNS −6.55 ns · Fmax ≈ 103.7 MHz; worst path FF → FF (ss, pre-PnR) | reports/openlane_wrap32-sta.json |
| Wrapper full flow (50 ns) | first completed P&R: 0 Magic/KLayout DRC, 0 LVS, setup +17.49 ns, hold +0.0088 ns, Fmax ≈ 30.8 MHz (AREA synth, 1800 µm die; not a 10 ns result) | reports/openlane_routetest-full.json |
| BBO area estimate | 70,715 cells, 115,792 wires (Yosys 0.52, reduced 32/4/4 config, includes top-4 depth + risk checks; not optimized) | reports/synth_book.json |
| Parser → BBO | 152 raw ITCH messages, 0 mismatches end to end | tb/test_book_top.py |
| A/B feed arbiter | selection + recovery: request→replay, multi-gap [1..8], abandon on timeout | tb/test_arbiter.py |
| A/B system | 2 Ethernet feeds → arbiter → 10 ITCH records, 1 gap | tb/test_ab_system.py |
| Optional ingress skid | INGRESS_SKID=1: identical 152-message BBO and counters under input gaps | tb/run_book_top_skid_cocotb.py |
| Host book snapshot (unit) | 2 locates + miss + stability + re-read, updates=4 | tb/test_snapshot.py |
| Book snapshot integration | parser→book→snapshot mirrors the last BBO per locate; locate 3 is a miss | tb/test_book_snapshot.py |
| Narrow host wrapper | 128-bit ingress → 32-bit host registers; 2 messages, X/type/locate/shares/ref read back | tb/test_host_wrap.py |
| Wishbone wrapper | Caravel-style Wishbone reads of count/type/locate/shares/ref; writes ACK but are ignored; 20 back-to-back messages, no beat loss | tb/test_wishbone.py |
| 32-bit ingress | DATA_WIDTH=32 through parser + Wishbone: same fields read back (Caravel/FPGA-friendly narrow port) | tb/run_wishbone32_cocotb.py |
| Caravel-shaped top | 38-bit io_in stream + Wishbone reads; io_oeb leaves only io_out[0] driven | tb/test_caravel_wrap.py |
| Caravel drop-in wrapper | caravel/user_project_wrapper.v (exact Caravel port list) passes the same test |
tb/run_caravel_upw_cocotb.py |
| Full-field regression | 10,000,000 messages, 0 mismatches (nightly default; 200k smoke 19 s, 10M 3m06s sim) | tb/sim_main.cpp, .github/workflows/nightly.yml |
| Performance counters | 9-message histogram [1,2,1,1,1,1,1,1]; 152 messages / 4800 bytes in the parser→BBO integration |
tb/test_metrics.py, tb/test_book_top.py |
| Supply chain | 163-component SBOM; SLSA provenance for EXE/npm/wheel via Artifact Attestations; Docker provenance mode=max + SBOM + keyless cosign signature; npm/PyPI cosign blob signatures |
reports/sbom.json, release.yml, sign.yml, docker-publish.yml |
| Reproducible WASM | toolchain pinned (rustc 1.98.1); two clean builds and the shipped artifact all d2b5f58f… (50,322 B) |
reports/repro_wasm.json, wasm-core/rust-toolchain.toml |
| Reproducible Python | SOURCE_DATE_EPOCH: wheel identical twice; sdist identical after container normalization | reports/repro_python.json, scripts/repro_python.sh |
| Reproducible EXE | two build_exe runs byte-identical (67d05b22…, 87,785,472 B, Node 22.23.1); weekly Windows CI job |
reports/repro_exe.json |
| Browser demo | 1,000,000 messages in 664 ms, 0 errors, WebGPU compute | reports/web-1440-depth.png |
| Browser re-verify (2026-11-10) | 100k: 41.29 Gbps, 177.3 M msg/s, 0 errors; compare PASS×7 + lossy FAIL (58,458); 390 px no horizontal overflow | reports/web-1440.png, reports/web-390.png |
| Local-cloud UI round-trip | Test → connected; Sync → revision 2 (runs/lastRun); Pull → "Pulled 2 runs from revision 2" | .data/default.json |
| PWA offline | service worker chiplab-v4 active; offline reload renders title + hero from cache; only /api/health fails (expected offline) |
Playwright offline run |
| Single EXE | 83.7 MB; --probe OK (WASM 50,322 B, v0x301, 8 chips); rebuild hash 67d05b22… unchanged |
dist/chiplab.exe |
| Docker | image + docker compose: /api/health v0.3.1, token PUT → revision 1, data survives compose restart (named volume) |
Dockerfile, docker-compose.yml |
| Vercel | READY, live at https://chiplab-ten.vercel.app/; /api/health ok v0.3.1, page 200 |
reports/web-vercel.png |
| GitHub CI | green on main: lint, 50k full-field, cocotb (19 suites), Docker, packages |
Actions |
| npm package | npm pack + clean install (0 vulnerabilities) parses 2,000 records at 41.28 Gbps |
packages/npm/ |
| PyPI package | wheel installs in a clean venv; selfcheck = 10,000 records, 22 opcodes |
packages/python/ |
Throughput model. 128-bit @ 322.26 MHz = 41.25 Gbps line rate. The parser consumes at most one message per cycle; ITCH average message size (~30 B) means the useful message rate is ~177 M msg/s in the model, not a blanket 165 Gbps at 512-bit. The 512-bit variant removes input-side byte starvation but does not multiply parser slots.
Latency model. 1 clock from window to registered output; 2 clocks from
s_axis_tdata. The 452/484-bit output mux and 1024-bit shifter are the critical path;
a 322 MHz sign-off requires OpenSTA/OpenLane, which is not claimed here.
AXI4-Stream 128/256/512
│
▼
┌─────────────────────────────┐ ┌──────────────────────────────┐
│ moldudp64_frontend.sv │ │ itch_shifter.sv │
│ L2/L3/L4 filter, Mold hdr, │────▶│ tkeep, cleared append, │
│ sequence gap │ │ 512-bit sliding window │
└─────────────────────────────┘ └──────────────┬───────────────┘
│
┌──────────────▼───────────────┐
│ itch_parser_core.sv │
│ all 22 opcodes, full payload │
│ 64-bit shares, pre-trigger │
└───────┬──────────────┬───────┘
│ │
┌─────────────▼───┐ ┌──────▼─────────────┐
│ registered egress│ │ async bypass │
│ 1 cycle │ │ same-cycle window │
└──────────────────┘ └────────────────────┘
Offline twin: Rust → wasm32 → Worker / Node / MCP / npm / EXE / Docker / Vercel
Visualisation: WebGPU compute (bins + histogram) + WebGPU render / Canvas2D fallback
| ID | Model | Latency model | Purpose |
|---|---|---|---|
| 0 | Scalar reference | 0 | golden |
| 1 | ITCH-50 v2 | 1 cycle after window | this RTL |
| 2 | ITCH-50 safe | 2 cycles | timing-closed variant |
| 3 | Enyx-class | 3 cycles | commercial-class comparison |
| 4 | NovaSparks-class | 2 cycles | comparison |
| 5 | Lossy admin-drop | 1 cycle | negative control, must fail |
| 6 | MoldUDP64 front-end | 3 cycles | L2–L4 + Mold |
| 7 | Parser + top-of-book | 2 cycles | parse-to-book |
- WebGPU compute bins prices and latency on the GPU; WebGPU render draws the density. On devices without WebGPU, Canvas2D draws the same data.
- Worker-isolated WASM: the UI stays responsive while 1M records are generated, parsed and packed.
- OPFS persistence: the last runs and settings stay in this browser. No account,
no upload.
navigator.storage.persist()is requested. - PWA/offline: service worker caches the app shell and WASM.
- Responsive: 390 px bottom navigation, 768 px stack, 1440 px three-column lab.
The demo is a dense tool, not a marketing page: tape, depth density, latency histogram, chip comparison and containers share one scan path.
curl -s http://127.0.0.1:4173/api/health
curl -s -X POST -H 'content-type: application/json' \
-d '{"chip":1,"count":100000,"seed":1337}' http://127.0.0.1:4173/api/run
curl -s -X POST -H 'content-type: application/json' \
-d '{"count":100000,"seed":1337}' http://127.0.0.1:4173/api/compare| Endpoint | Method | Purpose |
|---|---|---|
/api/health |
GET | wasm version, chips, host |
/api/chips |
GET | chip registry |
/api/run |
POST | one chip + sample records + book |
/api/compare |
POST | all chips vs golden |
/api/book |
POST | top-of-book |
/api/cloud/info |
GET | local cloud version, LAN URLs, token state, namespaces |
/api/store/:namespace |
GET/PUT/DELETE | local JSON persistence (see Local cloud) |
MCP (node mcp/server.mjs) exposes 12 read-only tools:
chiplab.chips, chiplab.run, chiplab.compare, chiplab.book,
chiplab.formal_status, chiplab.health, chiplab.cloud_info, chiplab.history,
chiplab.release_status, chiplab.sbom, chiplab.synth_status, chiplab.docs.
See mcp/SECURITY.md.
# npm
cd packages/npm && npm pack
npm install ./chiplab-core-0.3.1.tgz
# PyPI
cd packages/python
python -m build
pip install dist/chiplab_itch-0.3.1-py3-none-any.whl
chiplab-itch selfcheck --count 100000Publishing requires NPM_TOKEN / PYPI_TOKEN; the repository only builds and tests
locally. The @chiplab/core package bundles the same 50 KB WASM artifact used by the
web app, Node and the EXE.
| Target | Build | Run |
|---|---|---|
| EXE | npm run build:exe |
dist\chiplab.exe --port 4190 or --host 0.0.0.0 --token … |
| Docker | docker build -t chiplab:0.3.1 . |
docker run --rm -p 4173:4173 -e CHIPLAB_TOKEN=… chiplab:0.3.1 |
| GHCR | CI pushes ghcr.io/timfromhcs/ultra-low-latency-nasdaq-itch50-core:main |
docker pull ghcr.io/timfromhcs/ultra-low-latency-nasdaq-itch50-core:main |
| Vercel | node scripts/build_vercel.mjs |
vercel / Vercel MCP |
Native Vulkan/DX12 runner (optional):
cd native && cargo build --release
chiplab-native --probe
chiplab-native --input reports/native_records.bin --auto-boost--auto-boost applies Windows HIGH_PRIORITY_CLASS only when a GPU adapter is present;
it is opt-in and visible in the output. --affinity additionally pins to the first eight
logical CPUs.
The EXE embeds the web assets and the WASM; it serves the same API, the local cloud
and opens the browser. Docker runs as a non-root Node 22 alpine user with a healthcheck;
because requests reach the container from a non-loopback bridge address, set
CHIPLAB_TOKEN for store writes (docker run -e CHIPLAB_TOKEN=…).
The Vercel build is static-first (public/) plus stateless api/* functions; per-user
data stays in the browser (OPFS/IndexedDB). For server-side persistence, Vercel
Sandbox Drives are a separate, paid option — not used by this repository.
- RTL: Verilator lint, full-field 1M regression, cocotb (
tb/test_itch.py), Mold front-end/depacketizer tests (tb/test_mold*.py). - Formal:
formal/itch_formal.svchecks pre-trigger gating (known, non-corrupt opcode), class exclusivity, legal lengths, register equivalence and flow control;formal/run_formal.shruns BMC, k-induction and covers;formal/solver_matrix.shrecords each solver. The pull-request CI runs lint + 50k full-field + model + cocotb; the weeklyFormalworkflow runs the deep 20-step proof with a pinnedoss-cad-suite(Yosys + Z3) so results do not drift with Ubuntu's older packages. The weekly workflow also runs the parser→BBO mutation job. - Mutation:
tools/mutate.pyinjects RTL mutants and requires the suite to kill them. - Reference model: Python and Rust independently, compared field-by-field.
- Browser: Playwright at 390/1440, console-error gate, WebGPU/Canvas2D paths.
- Packages: clean npm/PyPI installs, MCP handshake, Vercel handler smoke, Docker health.
rtl/ SystemVerilog parser, shifter, Mold front-end/depacketizer
formal/ SVA harness, SymbiYosys runner, solver matrix
tb/ Python model, vector generator, Verilator/Cocotb tests
wasm-core/ Rust → wasm32 core (parser, generator, chips, book)
web/ PWA: UI, Worker, WebGPU, Canvas2D, OPFS
backend/ Node server, CLI, WASM wrapper
mcp/ stdio MCP server + smoke client
api/ Vercel serverless handlers
native/ Rust wgpu Vulkan/DX12 compute runner + optional boost
packages/npm/ @chiplab/core
packages/python/ chiplab-itch
scripts/ build/gate/synth/formality/heartbeat/autonomy tools
caravel/ user_project_wrapper.v drop-in for the Caravel harness
docs/guides/ zero-to-hero guides (EN / DE / FR)
docs/design/ Mold back-pressure design note (R1)
docs/datasheet.md ports, timing, area estimate, verification evidence
docs/integration-guide.md how to instantiate parser/book/Mold and poll counters
docs/errata.md known limitations (no tapeout; parser/BBO not signed off)
docs/api.md HTTP, MCP, npm and Python API reference
LONG_TERM_PLAN.md 12-month roadmap, KPIs, gates
AUTONOMOUS_PLAN_V2.md
EXECUTION_LOG.md
reports/ measured evidence (logs, JSON, screenshots)
- Datasheet — ports, timing targets, area estimate, evidence
- Register map — host, Wishbone, Caravel, snapshot and counter registers
- Integration guide — instantiate, drive, poll counters
- API reference — HTTP, MCP, npm, Python
- Errata — what is deliberately out of scope
- Long LibreLane runs — resume, knobs, failure modes, cleanup
- English
- Deutsch
- Français
Each guide covers: run the demo, read the tape/book, verify a record, run the formal proof, build the EXE/Docker image, and understand the honest limits.
The repository ships three project skills in .opencode/skills/:
chiplab-verify— full verification: lint, RTL regression, formal, cocotb, WASM cross-check, MCP, local cloud, Vercel API, plus gate triage rules.chiplab-local-cloud— run, connect, secure and test the LAN service and.datastore.chiplab-release— bump the single version, rebuild artifacts, update changelog, tag, and publish via the Release workflow.
Planning and research: LONG_TERM_PLAN.md,
AUTONOMOUS_PLAN_V2.md, docs/research-v2.md,
EXECUTION_LOG.md, mcp/SECURITY.md.
- No tapeout, no silicon. "Silicon lab" means executable RTL + digital twin.
- No Fmax sign-off. 322.26 MHz is the target/model clock. OpenLane configs are flow-ready; full P&R and slack reports are not claimed.
- MoldUDP64 is simulation-verified, not MAC-integrated. Five frames back-to-back (4 valid, 1 gap, 1 dropped port) pass end to end; the Ethernet ingress is a testbench model, not a 100G MAC.
- WebGPU numbers are visualisation samples. Totals come from the exact parser;
GPU bins use the same integer prices.
f32is only used for bar heights. - The feed is synthetic. Seeded generation is reproducible; it is not a captured NASDAQ day.
- The native boost is opt-in.
--boostsets Windows priority/affinity; it is not applied silently and is restored when the process exits.
- Back-to-back multi-frame MoldUDP64 (5 frames, gap + drop) — no skid needed, the front-end holds beats under back-pressure.
- Optional skid/FIFO stage for timing isolation at higher clock rates.
- RTL top-of-book (functional reference): locate-indexed BBO, last trade, volume
(
rtl/itch_top_of_book.sv, 400-event random test vs. Python model). - Timing-closed BBO: BRAM/hash order store, pipelined ladder, no rescan stall.
- OpenLane P&R + OpenSTA slack for Sky130/GF180/IHP.
- Bitwuzla/Yices in the solver matrix.
- Optional Vercel Sandbox/Drives recipe for team persistence.
- Published npm/PyPI artifacts and GHCR image (tokens required).
PolyForm Small Business Dual-License 1.0.0. Free for entities under $100,000 USD annual gross revenue with the mandatory attribution string:
Hardware powered by ultra-low-latency-nasdaq-itch50-core by @timfromhcs
(https://github.com/timfromhcs/ultra-low-latency-nasdaq-itch50-core)
Enterprise/white-label: timfromhcs@gmail.com. See LICENSE.md.
Keywords: NASDAQ ITCH 5.0 parser, ITCH50, market data, HFT, FPGA, ASIC, SystemVerilog, WebAssembly, WebGPU, Rust, MCP, formal verification, Z3, CVC5, SymbiYosys, OpenLane, Sky130, order book, MoldUDP64, low latency, silicon lab.

