GeezerVison

Contract-first anomaly detection across ~30 formats — logs, security telemetry (syslog, CEF/LEEF, EVTX, Suricata EVE, osquery, CloudTrail), network (pcap, NetFlow, DNS), observability (OTLP, Prometheus, journald), data (CSV/JSON/Parquet/SQLite/Avro/ORC). Deterministic Rust CLI; 9 detectors / 7 classes; NIST-validated, mutation-tested.

Deterministic crawl kernel in Rust — same seed, identical crawl, identical replay. BoringSSL TLS impersonation (JA3/JA4), 17-patch CDP stealth mode, BLAKE3 content-addressed storage, WARC++ format, distributed crawling, RAG extraction. 288 tests, 15 crates, 10K pages proven.

Agent-first Linux packet-path tracing with Rust/eBPF: bounded evidence, deterministic replay, and packet routes with receipts.

Detect C2 beacons in network traffic using Floquet spectral analysis from quantum chaos theory. Fast, 274KB Zig binary. Reads pcap, live capture, or OpenTelemetry JSONL.

Operation Long Shadow · Forensic investigation of a four-cluster GitHub repo-laundering operation that buries fabricated commits in 2037 to bubble laundered repos to the top of every AI-built-code search.

Forensic dataset + live dashboard for the 2026-04-29 'A Mini Shai-Hulud has Appeared' npm supply-chain worm by TeamPCP. 1,117 dropbox repos, 22 compromised accounts, 47 IOCs across 14 kinds. Trojaned: @cap-js, mbt, @bitwarden/cli. C2 attribution to AS209101 IP Vendetta Inc. JSONL data · kinetic dashboard · CC-BY-4.0.

Live crypto market observatory with a fluid correlation network, streaming telemetry, and historical replay.

Zero-trust proxy network — nodes prove hardware identity via TPM 2.0 remote attestation before receiving ephemeral mTLS certificates. Written in Rust.

Production-grade Claude Code artifacts (hooks, agents, commands, gates, sweeps, drifts) wrapped around an axum + sqlx + sqlite todo API. Tutorial.

Backend-less internet health and flux monitoring tool (Zig)

Evidence file: a DEV comment-spam campaign traced to a legitimate SaaS affiliate link. Not malware — the economics are the vulnerability. 15 raw captures, 6 diagrams, reproduce script.

A runnable evidence-driven development tutorial: falsifiable claims, SQLite retries, negative controls, and reproducible results.

A native Linux backup lab with independent verification, eBPF probes, CPU sampling, packet captures, and a reproducible companion article.

Can a ten-bedroom creator house in Hawaii pay for itself? An exact-arithmetic feasibility model where no figure was produced by a language model. Powered by Bento.

Open threat-intelligence and IP-reputation ETL for phishing and abuse screening, with BGP and Arrow/Parquet releases

Local-first deterministic IP intelligence CLI with auditable evidence and policy-grade JSON

Touch every layer of Git and GitHub—from first commit to platform engineering.

Height-ordered incremental computation DAG, cutoff propagation, O(1) incremental folds, idempotent delta algebra, sequence-gap book reconstruction, and VOPR simulation testing for prediction-market orderbooks.

A complete, safe JSONata implementation in Rust — JSON query, transform, and expression evaluation

Independent Rust implementation of SOLVE v0.5, Irregular's rubric for scoring vulnerability-discovery and exploit-development difficulty. Reproduces all 16 published DownUnderCTF calibration assessments.

Trust-scheduling execution fabric: run untrusted workloads in tiered disposable sandboxes (Firecracker microVM / gVisor / Xen) and emit host-sourced, tamper-evident evidence.

Security-hardened, allocation-free no_std HOTP/TOTP for Rust with strict RFC 4226/6238 behavior and constant-time verification.

Focused, offline-first vulnerability intelligence CLI — CVE & package-version checks with typed evidence, from verified data releases

Deterministic data pipeline for VulnGraph — ingests 11 vulnerability sources, publishes reproducible checksummed graph releases

Live system cognition engine. Reimagines tail from "show me lines" to "what's happening, what matters, and why?" Auto-detects log formats, groups patterns, detects anomalies, reconstructs traces, outputs structured JSON for AI agents. 144 KB. Zero config. 69K events/sec.

Break noise. Preserve truth. A deterministic semantic reduction engine for structured data — JSON, YAML, CSV, NDJSON, Markdown, PDF. Fingerprinting, entropy, anomaly detection, schema drift, clustering, and AI-ready essence generation. Built in Rust.

Multi-pattern fixed-string matcher. Aho-Corasick + SIMD on mmap'd files. NDJSON output for AI agents and pipelines.

Distributed attested CI mesh — property-tested at every layer

Specification-first developer portal: modular OpenAPI 3.1 + AsyncAPI 3.1 sharing one domain model, an enforced error registry, and CI that can actually fail.

Zig SDK for TypeSafe AI's Jev decision API. Typed classification, scoring and yes/no probabilities with bounded buffers, retries and deadlines.

Activity-aware rankings for US-based GitHub developers, with transparent scoring and exportable public data.

What actually matters across N files: consensus, drift, outliers and variant families — for configs, JSON, YAML, XML, PDF, even executables (SSDeep-class fuzzy analysis). Deterministic, evidence-backed, zero-dependency Zig.

Why prompts are just the surface. Depth comes from the system you build. — Don Johnson

Polite, exhaustive tap of Kalshi live-market chat: AIMD adaptive polling that hears the whole venue without overwhelming it. Position-annotated NDJSON stream.

Forge the past. Test the future. A reproducible Git and GitHub forensics lab with synthetic histories, virtual time, and ground-truth fixtures.

A convention-safe genome-variant kernel: normalization + VCF/HGVS/VRS boundaries + liftover, validated byte-for-byte against bcftools, vrs-python, and biocommons hgvs.

AI-first Unix primitives, clean-room reimplemented in Zig under one self-describing, machine-checkable contract

A forensic instrument for codebases. A quantifiable way to tell the truth.

A cartographic browser survey for entropyx: streaming scans over SSE, a printable plain-language brief, and the scoring kernel in WebAssembly.

Care Compass: Gemma 4 healthcare navigation demo with Aion signed-policy decision evidence

Single-binary webhook inbox — capture, inspect, and debug HTTP webhooks with zero dependencies. Embedded SQLite, live dashboard, cross-platform. Just scp and run.

Typed Jev decisions, native Playwright actions. Reusable browser automation with procedural and business UAT gyms.

Unofficial safety-focused MCP kernel for Kalshi market workflows

Hands-on exercises for forgotten Linux pipe & stream commands — sample data, real exercises, Claude Code skill included.

Fast, allocation-free Rust library for signed overpunch and zoned decimal encoding/decoding. ASCII/EBCDIC, exact decimals, fixed-width COBOL/mainframe records, and no_std.

A modern, extensible, high-performance CI/CD engine written in Rust.

Text and structural search with readable PEG patterns, typed captures, and JSON output.

Cost-optimized 10-inch Raspberry Pi cluster rack builds (–). Four verified BOMs with PoE+ switch, DeskPi RackMate, and UPS. MILP-optimized pricing.

Chaos & adversarial testing framework for Arbitrum rollup stacks — deterministic simulation + live Docker fault injection. Same seed = same chaos = reproducible bugs.

Deterministic-first shard router for the Kalshi exchange: verified shard resolution, exact integer fee schedules, async-safe prefunding, ledger reconciliation, VOPR-style DST. Rust, TigerStyle.

Stop Guessing: simulated annealing article with a reproducible Rust experiment, equal-budget baselines, raw results, and independent verification.

Thirteen research-attributed forecasting skills for Claude — Brier scoring, calibration decomposition, logit pooling, Bayesian updating, reference classes, conditional trees. Every technique names its research and states its limits.

High-performance Kalshi venue scanner: liquid markets, whale fills, live SSE stream. Rust, SIMD hot path, TigerStyle discipline.

Ask a TLA+ specification about a state, and get an answer. A parser and evaluator for TLA+ in Rust — not a model checker.

Official Go SDK for the TokenTip API — tips that buy AI inference credit. Zero dependencies, stdlib only.

Official TypeScript SDK for the TokenTip API — tips that buy AI inference credit. Zero runtime deps.

Official Python SDK for the TokenTip API — tips that buy AI inference credit. Sync + async, typed.

AI-native adversary-emulation & breach-and-attack-simulation (BAS) instrument in Rust — atomic MITRE ATT&CK techniques an LLM can orchestrate, behind Ed25519-signed authorization scopes, emitting typed tamper-evident evidence.

Self-hosted ngrok alternative in Rust. Development in progress - check out the issues for detailed specs.

AI-native exact calculator and contract-first Rust CLI for typed JSON math, symbolic reasoning, property tests, and mutation-tested agent workflows.

Unofficial portable Claude Code and Codex skill for NASA/JPL Power of Ten code reviews.

Bounded semantic routing with Jev and Poise. Rust, single-server, alpha.

Never confidently wrong: a TLA+-verified consensus kernel around TypeSafe's Jev, run through 1,680 chaos-tested pharmacy decisions with zero wrong verdicts. Film, code, and every captured call.

OpenAPI testing and deterministic API fuzzing for AI agents—catch contract bugs before unsafe calls with local-first sealed plans, MCP, and replayable evidence.

The skills of the gods, encoded for mortals. Legendary engineer coding philosophies as Anthropic-compatible Skills.

Consensus without a center: a Rust protocol where agents coordinate through signals that diffuse, decay and get reinforced. A2A v1.0 gateway, QUIC P2P mesh, plain-language agent routing, and a read-only prediction-market research mesh.

SCGP reference implementation in Rust: compile large codebases into verified semantic graphs, deterministic glyphs, and token-budgeted AI context.

Voice typing that never leaves your machine. Local NVIDIA Parakeet transcription, Rust + iced, for Linux.

AI cost, with the vibes removed. Exact-rational models + a live calculator for the 8 LLM inference-cost decisions every agent builder faces — model choice, routing, self-host, the reasoning-token tax, cascades, caching, and the O(K²) agent loop. Every number reproducible.

A curated, living directory of open-source AI tools that run on inference — and how to fund the people who build them. Published by TokenTip.

Agent-orchestrated web crawler for exact evidence and historical changepoints—with deterministic policy, robots compliance, and local MCP support.

An elite dev team as a signal mesh: LLMs propose, deterministic gates adjudicate, humans ratify

High-performance MCP agent mail server — lock-free message routing, NRT search, Git audit trail. Built in Rust.

Systems-level software engineer building security tools, developer infrastructure, and AI-native systems in Rust, Go, and Zig. 560+ open source repositories.

Formally verified spreading activation primitives for the Co-Wiki architecture (Shomo, 2026). 7 Rust crates, 113 tests, 0 unsafe.

An MCP server for authorship on dev.to, with the platform's real rules built in — offline validation, rate-budget pacing, and a capability gate dev.to's unscoped API key cannot provide.

Put AI compute in the 82 million houses that already have a grid connection. An exact-arithmetic feasibility study of residential AI inference as an alternative to the data center buildout.

37 programming languages, one human intent. Token bucket rate limiter implemented across 60 years of languages (1957-2016) — proving that human language is the ultimate source code.

Defensive Claude Code scam-baiting agent harness with personas, stall tactics, anti-detection, session state, intel extraction, and call QA.

Nim implementation of TOON (Token-Oriented Object Notation): compact, human-readable JSON serialization and parsing for AI and LLM prompt workflows.

A binary container for agent skills: SKILL.md compiled into a signed, tiered, content-addressed graph — with capability-gated wasm segments and an organization compiler.

MCP control plane kernel — routes intents through policy, federates upstream MCP servers, and reasons with Claude Opus 4.7. Named after IBM Project Stretch (IBM 7030, 1961).

Rust primitives for probabilistic forecasting and AI agents: Bayesian updates, calibration, scoring, decision theory, and auditable journals.

An adversarial certification environment for agentic RPA: does the agent respect its authorization envelope and commit exactly once under ambiguity? Scores conduct, not just correctness.

A high-performance optimization server implementing the Model Context Protocol (MCP) for mathematical optimization tasks, with a focus on Bayesian Optimization using Gaussian Processes. Designed for reliability, scalability, and ease of integration in production environments.

The Agentic MCP Server for Emacs. Multi-agent orchestration and autonomous coding tools in Zig.

avoid metered tokens

EMV 3-D Secure 2.x (3DS2) protocol — AReq/ARes/CReq/CRes messages, transaction state machine, ECI/CAVV helpers, and full EMVCo spec serialization for payment authentication (SCA/PSD2)

One Go HTTP server. Five isolation runtimes. gVisor, Kata, Firecracker, and WASM benchmarked.

High-performance Rust kernel for the TAK (Team Awareness Kit) ecosystem — drop-in replacement for the messaging core of the Java TAK Server. Cursor-on-Target (CoT) over mTLS, single-node firehose at 10k+ concurrent clients. Compatible with ATAK, iTAK, WinTAK.

The $20 Question: exact-math essay on why spreading $20 across 0.1¢ prediction-market longshots beats the lottery (10.23x less loss per dollar)

Composable, rigorously verified load-balancing primitives for Rust

ClaimZen — evidence-backed denial recovery. Marketing site.

Composable, kernel-adjacent DDoS-mitigation primitives in Rust — rate limiting, SYN cookies, signatures, reflection/amplification defense, learned fingerprints, nftables enforcement, flow telemetry, and upstream RTBH.

Does the grid bind? An invariant audit of the AI energization gap — the conclusion is ~80% likely right, and most of its stated reasons are wrong. TLA+, exact rational arithmetic, 86 provenance-tagged parameters.

Adversarial load testing and correctness verification for Arbitrum Nitro rollup infrastructure. Built by @copyleftdev. Hat tip to @PlasmaPower and the @OffchainLabs engineering team.

Unofficial Effect-native TypeScript SDK for the Humana Data Exchange APIs (Apigee + FHIR R4).

Early alpha. A Hyperliquid kernel for Rust in TigerBeetle's style: no_std, no floats, deterministic simulation. Not ready for real money.

Media for I Interviewed an Executable. It Had Notes. — cover art, replay stills, and video. No executable source or raw telemetry.

Marketing site for invariantd.com — video-first landing

Jane Street personas and practice skills for Claude Code, grounded in public sources and gated by verbatim-quote, speaker-attribution and compiled-snippet checks. Not affiliated with Jane Street.

Lock-free delta-xDS control plane for Envoy. Incremental updates, zero-copy fan-out, content-addressed versioning — the performant Rust alternative to go-control-plane.

Seuil Proof of Rigor — WASM benchmark visualization

Unity Simple 3D Shooter

An essay about abstraction, engineering judgment, and why AI changes the burden of proof—not the need for engineering.

Executable essay on AI system boundaries, property-based testing, and mutation testing

Hands-on exercises for forgotten git commands — crafted history, real bugs, real bisect targets.

A robust, over-engineered "Hello World" Go application demonstrating: DDD, CQRS, and event sourcing Redis and file-backed event bus Plugin system (ASCII, TTS, LED, etc) Prometheus & OpenTelemetry observability Property-based and integration tests Automated test reporting and coverage

Mathematically serious Rust crate for a deeply unserious Silicon Valley tip-to-tip efficiency empire.

FAFO as a Service — an event-driven homage to FOAAS and a working masterclass in spec-first engineering: AsyncAPI 3 + MCP, polyglot codegen, derived contract tests, a generated conformant server, 98/98 mutation score. Consequences: eventual.