Playground ·
A generative melody box
A WebAudio toy that improvises a melody with a random walk over a pentatonic scale, plus a drone and an echo — silent until you press Play.
Work
Professional engineering — how software, search, data, and AI systems are built and run.
Software engineering 188Search and retrieval 19Applied AI 37Data and event platforms 56Developer tools 90
Playground ·
A harmonograph drawing machine
Four decaying pendulums steer a pen; frequencies near simple ratios draw the spirograph-like curves Victorian harmonographs were famous for.
Playground ·
A raymarched scene
A whole 3-D scene — a blobby shape on a checkered floor, soft shadows, an orbiting camera — drawn by one fragment shader with no triangles at all.
Playground ·
A tiny JSON parser in thirteen languages
A recursive-descent JSON parser and pretty-printer, written from scratch in thirteen languages — how each one represents "a value that could be anything", reports errors, and handles strings, escapes and Unicode.
Playground ·
BQN playground
BQN, a modern APL, in your browser — whole-array primitives, folds and scans, tables, and tacit trains like (+´÷≠) for the mean.
Playground ·
Boids
Craig Reynolds' flocking model — three local rules per bird, and a flock emerges; the mouse is a predator.
Playground ·
Clojure playground
Clojure in your browser through Scittle — immutable data, lazy sequences, transducers, threading macros, atoms, and multimethods.
Playground ·
Esoteric languages: Brainfuck and Befunge
Two famous esoteric languages to run in your browser — Brainfuck's eight commands on a byte tape, and Befunge's program counter wandering a 2-D grid.
Playground ·
FizzBuzz in nineteen languages
The smallest interesting program, written the way each language would write it — from JavaScript and Rust to SQL, Prolog, BQN, Forth and a Befunge maze. Every block runs and prints the same twenty lines.
Playground ·
Flow fields
Thousands of particles drifting through a Perlin-noise vector field, leaving trails that pile up into silk.
Playground ·
Forth playground
A small Forth that runs in your browser — the data stack, defining new words, loops, and memory, in the language that fits in 8 KB.
Playground ·
Fortran playground
Modern Fortran compiled in your browser by LFortran — whole-array arithmetic, matrix intrinsics, modules and derived types, and a numerical kernel solving the heat equation.
Exploration ·
How a database survives a crash
Pull the plug on a database halfway through a write and it comes back with every committed transaction and none of the half-finished ones. How? Follow a write through the log, the buffer pool and the disk, compare B+trees with LSM-trees, watch compaction, and then see the other half of the promise — what concurrent transactions are allowed to see — with real PostgreSQL and SQLite running between the paragraphs.
Exploration ·
How web search works
Follow a query from the box you type it into to the ten blue links: how text becomes terms, how an inverted index stores and compresses them, how BM25 scores a match, how we know a ranking is any good, and how the whole thing is split across thousands of machines — with the tools running live between the paragraphs.
Tool ·
Jet engines and gas turbines
How jet engines work and what their numbers mean: an animated cutaway of turbojet, turbofan, turboprop, turboshaft, ramjet and afterburning engines with numbered stations; ideal and real Brayton cycle analysis at any Mach and altitude — thrust, TSFC, efficiencies, T–s and P–v diagrams and trade studies; compressor stages, draggable velocity triangles and a compressor map with surge margin; approximate figures for real engine families; and fuel, run time and start-up for model turbojets.
Playground ·
Kotlin playground
Edit Kotlin here and JetBrains' Kotlin Playground compiles and runs it — data classes, null safety, sealed types with when, extension functions, sequences, and coroutines.
Playground ·
L-system plants
A few rewriting rules and a turtle grow a meadow of plants that are never quite the same twice.
Playground ·
Life with colour trails
Conway's Game of Life where live cells are coloured by age and dead ones leave a fading ghost, so you can see where the action has been.
Playground ·
N-body: a small solar system, timed
The same five-body gravity simulation in fifteen languages, each timing itself — a hands-on look at how much the runtime matters when the program is all floating-point arithmetic in a tight loop.
Playground ·
OCaml playground
The OCaml 5 toplevel in your browser — type inference, pattern matching, variants, records, and modules with functors.
Playground ·
PHP playground
PHP 8.4 running as WebAssembly in your browser — its do-everything arrays, the string library, match, enums, readonly classes, and generators.
Playground ·
Perl playground
Perl 5 running as WebAssembly in your browser — regular expressions, hashes, text munging, and the context rules that make Perl Perl.
Playground ·
R playground
Real R running in your browser through webR — vectors, data frames, a linear model with its summary, simulation, and base-graphics plots.
Playground ·
Reaction–diffusion
The Gray–Scott model — two imaginary chemicals that spread and react — grows coral, fingerprints and dividing cells from a few drops.
Playground ·
The Mandelbrot set as ASCII art
Nested loops and floating-point arithmetic in eighteen languages — plain loops, complex numbers, whole-array versions in R and BQN, and a recursive query in SQL — all drawing the same 66 × 23 picture, character for character.
Tool ·
Turbocharger matching
Match a turbo to an engine: pressure ratio and corrected air flow (lb/min and kg/s) at every rpm plotted on an illustrative compressor map — or your own surge and choke lines — with surge and choke margins, compressor-outlet and intake temperatures and estimated power; the turbine side from the power balance (back-pressure, drive ratio, wastegate flow and size, A/R and twin-scroll notes); injectors and fuel pump for the power; and the intercooler.
Playground ·
Word frequency in fifteen languages
Count the words in a paragraph and list the ten most common — split, count, sort — in fifteen languages, from one-line pipelines in Ruby and Clojure to a hand-rolled hash table in C and a recursive string split in SQL.
Tool ·
Coding interviews
A coding-interview trainer: thirty-three patterns with the signals that give them away, animated step-throughs and templates in Python, JavaScript, Java and Go; a clickable pattern map from problem signals to patterns; about 160 original problems with staged hints, reference solutions you can step through line by line, and hidden tests, run in your browser in JavaScript or Python with a scaling check; a visualiser your own code can draw with; a which-pattern quiz; a 45-minute mock interview with a rubric and history; a STAR story bank for the behavioural round; and per-pattern mastery.
Tool ·
Consistency models lab
Watch a three-region replicated store at Cosmos DB's five consistency levels — strong, bounded staleness, session, consistent prefix, eventual — with stale and out-of-order reads, latency and availability counted as you cut regions off or fail them; the four session guarantees and causality, each broken and fixed; a linearizability and sequential-consistency checker for your own histories; and a clickable map of the models.
Tool ·
Distributed patterns on Redis
A catalogue of 75 distributed patterns built on Redis — locks, leases and fencing, transactions and Lua, queues and streams, notification, rate limiting, caching, idempotency, counting, data structures, service coordination and cluster-aware design — each with its guarantees, its Lua, its failure modes and 185 labs you can step through: clients racing on a Redis in the page, real Lua included, without the pattern and with it, and on your own server. Plus Redis Cluster and Sentinel, animated.
Tool ·
MongoDB replica sets and sharding, simulated
An animated MongoDB cluster in your browser: a replica set with its oplogs, elections in terms, write concern and the rollback of acknowledged w:1 writes, read concern and read preference with maxStalenessSeconds; a sharded cluster with mongos, config servers, ranges, hashed and ranged keys, zones, the balancer and jumbo ranges; a query-targeting checker and a shard-key evaluator.
Tool ·
NoSQL capacity and cost
Size NoSQL deployments with the working shown: Cassandra and ScyllaDB nodes from rows, replication and compaction headroom, with node-replacement and repair times; Redis memory per key by encoding (listpack, intset, hashtable, skiplist) with fragmentation, replication buffers and an eviction policy; MongoDB working set, WiredTiger cache and oplog window; Azure Cosmos DB request units, partitions and cost; and a Zipf hot-partition checker.
Tool ·
NoSQL data modelling
Model one application four ways — document (embed or reference, with the subset, bucket, extended-reference, computed and outlier patterns), wide column (one table per query), key-value (keys and hand-made indexes) and graph — and see for each which access patterns are one read, several or scatter-gather, how many copies every write touches and what can go out of step; then a "Which database?" questionnaire with a reasoned shortlist and a CAP/PACELC explainer, and exports as CQL, MongoDB $jsonSchema, Cypher and JSON.
Tool ·
Offline-first sync and replication
How offline-first apps sync, animated: CouchDB/PouchDB-style replication between a phone, a laptop and a server that go offline — revision trees, the changes feed, checkpoints, _revs_diff and _bulk_docs, conflicts and the deterministic winning revision, three ways to resolve them, compaction and _revs_limit's false conflicts — against a Firestore-style single-leader cache with pending writes, server timestamps and rolled-back writes.
Tool ·
System design interviews
Practise big-tech style system design interviews: a paced 45- or 60-minute framework with a mock interviewer, random questions and a self-scoring rubric, a back-of-the-envelope estimator, 38 reference architectures (likes, web search, webhooks, group chat, Kafka- and Dynamo-style stores, maps, a matching engine and more) as clickable diagrams with model deep-dive answers and interview cards, a live simulation of each one you can overload and break, a searchable question bank with a compare view, runnable building blocks (rate limiters, consistent hashing, Snowflake IDs, Bloom filters, fencing tokens, the outbox pattern and more) with Python, Go and Java versions, and trade-off cards.
Tool ·
AWS IAM policy evaluator
Paste IAM policies — identity-based, resource-based, permissions boundaries, session policies, SCPs and RCPs — and a request, and see Allow, explicit deny or implicit deny with a trace of every statement and every step of AWS’s evaluation logic; plus a policy linter and an ARN parser.
Tool ·
Binary inspector: Mach-O, ELF and PE
Drop an executable or library — Mach-O (thin or universal), ELF or Windows PE — and see its load commands or headers, libraries and run paths, symbols demangled, fixups, the code signature with entitlements and requirements, a checksec-style hardening list, Go build info, Rust crates, strings, a hex view of any section and a size treemap.
Tool ·
Bundle analyzer
Drop webpack stats, Vite/Rollup visualizer data, an esbuild metafile or your minified .js with its .map and see what is in the bundle — a zoomable treemap, modules and packages by size, duplicated packages, why each module is included, the chunks, and what changed between two builds.
Tool ·
Click models workbench
Load a query and click log (or simulate one from known relevance and a known user), see CTR by rank, abandonment and reformulations, fit the click models of Chuklin, Markov & de Rijke — PBM, cascade, DCM, UBM, SDBN, DBN — checked against PyClick, correct for position bias with propensities from PBM or swap experiments, and compare interleaving with A/B testing.
Tool ·
Concurrency lab
Step through concurrent programs one operation at a time, rewind, and try other interleavings: Go goroutines, channels, select, WaitGroup, Mutex and context (with a race detector, deadlocks and leaks), async Rust futures on a tokio-like executor, Java virtual threads on carriers with pinning, executors and CompletableFuture, and the JavaScript event loop — plus a runner that shows the real order of your own JS snippet.
Tool ·
Connection pool sizing
How big should the database connection pool be? Little's law and Erlang C from your request rate and connection hold time, the PostgreSQL wiki's cores × 2 + spindles explained, every instance's pool against max_connections (RDS defaults included), a simulation of a pool too small and too large, and HikariCP's settings with maxLifetime and keepalive worked out from the idle limits on your network path.
Tool ·
Container image layers
Open a docker save tar or an OCI image layout and see each layer with its Dockerfile instruction and size, the merged file tree with what every layer added, changed and deleted, wasted space and dive's efficiency score, the config, the platforms in the index, every digest checked — and the packages inside, handed to the SBOM viewer.
Tool ·
DHCP, ARP, NAT and routing
A small network you can watch frame by frame: DHCP's Discover–Offer–Request–Ack with every option decoded, ARP and a learning switch, a ping through NAT and its translation table, port forwarding, longest-prefix match — plus OSPF-style flooding and Dijkstra, RIP counting to infinity, and BGP's decision process. Exports a .pcap.
Tool ·
Data mining: frequent patterns and clustering
Frequent itemsets with Apriori (level by level, pruning shown) and FP-Growth (the FP-tree drawn), association rules with support, confidence, lift, leverage and conviction; and clustering — k-means step by step with k-means++, elbow and silhouette, DBSCAN with its k-distance plot, hierarchical clustering with a dendrogram — on points you edit or a CSV, checked against mlxtend, scikit-learn and scipy.
Tool ·
Dependency tree analyser
Paste mvn dependency:tree, gradle dependencies, go mod graph or cargo tree output, or drop a package-lock.json, pnpm-lock.yaml, yarn.lock or Cargo.lock, and see the tree, why each package is there, which version won each conflict and why, duplicates, depth and weight, licences, and (if you ask) known vulnerabilities from OSV.dev.
Tool ·
Documentation linter
Lint Markdown with the real markdownlint rules (MD001–MD060, your .markdownlint.json) and AsciiDoc with structure checks that match Asciidoctor's warnings, with quick fixes — plus a table formatter for Markdown, AsciiDoc, CSV and TSV.
Tool ·
EventBridge pattern tester
Test EventBridge event patterns against events and see why each field matches or not — exact values, prefix and suffix (with equals-ignore-case), every anything-but form, numeric ranges, exists, IP CIDR, wildcards, $or and array semantics, following the AWS content-filtering rules — plus input transformers (InputPathsMap and InputTemplate) and a library of sample events.
Tool ·
Explain plan
Paste PostgreSQL EXPLAIN (JSON or the usual text) or MySQL EXPLAIN ANALYZE / FORMAT=JSON and see the plan as a tree with each node's own time, a flame chart and a table of hotspots, the problems found — row misestimates, sorts and hashes spilling to disk, big filtered scans, missing join indexes, JIT overhead, foreign-key triggers — with advice for each, and two plans compared side by side.
Tool ·
Firewall packet tracer (iptables and nftables)
Paste iptables-save or nft list ruleset output and a packet, and step it through the netfilter hooks in the kernel's order — every chain, every rule tested with the reason it matched or didn't, jumps, returns, policies, DNAT and MASQUERADE — to the final verdict; with Docker's and kube-proxy's chains explained.
Tool ·
Flame graph and profile viewer
Open a CPU, heap or lock profile — Go pprof, collapsed stacks from async-profiler, perf or cargo flamegraph, JDK Flight Recorder, a Node/Chrome .cpuprofile, speedscope or perf script — and read it as a flame graph or icicle with search, a top table, callers and callees, and a red/blue differential against a baseline, all in the browser.
Tool ·
GitHub Actions workflow explainer
Paste a GitHub Actions workflow: the job graph with a what-if-this-fails simulator, every matrix job after include/exclude, triggers with a branch/tag/path filter tester and next cron runs, a ${{ }} expression evaluator with an editable context, GITHUB_TOKEN permissions per job, concurrency groups, and actionlint's checks plus security checks.
Tool ·
Helm and Kustomize renderer
Render a Helm chart or a Kustomize overlay to plain YAML in the browser — with Helm's and Kustomize's own code compiled to WebAssembly — and see which values file or --set won each key, errors pointing at the template line, NOTES.txt, and what differs between two overlays.
Tool ·
Isolation lab
Two or three SQL sessions side by side: step through an interleaving and watch what PostgreSQL or MySQL InnoDB does at each isolation level — results, which statement blocks on which lock, deadlocks, serialization failures (40001 / 40P01) and the final table — with the classic anomalies, their fixes and the Hermitage tests built in, or the same steps on a real Postgres server.
Tool ·
JSON → types
Paste JSON samples (or a JSON Schema) and get TypeScript, Zod, Java records with Jackson (or Lombok classes), Kotlin, Go structs, Rust serde, Python pydantic or dataclasses, protobuf, or JSON Schema — merging samples to find optional fields, nulls, unions, enums, dates, UUIDs, maps and tagged unions.
Tool ·
JVM memory planner for containers
How a Java process fills a container's memory limit — heap, metaspace, code cache, thread stacks, direct buffers, GC structures and native memory — with the heap the JVM picks by itself on JDK 17, 21, 25 and 27, the flags that fit, OOMKilled versus OutOfMemoryError, and NMT output to fill it in.
Tool ·
Java GC log analyser
Read a JVM GC log — unified -Xlog:gc* for G1, ZGC (generational or not), Shenandoah, Parallel and Serial, or a JDK 8 PrintGCDetails log — and get a pause timeline, heap before and after, allocation and promotion rates, pause percentiles, throughput, full GCs and failures flagged, and tuning hints in plain words.
Tool ·
Java class file and JAR inspector
Drop a .class or .jar and read it like javap -v — class version, constant pool, fields, methods with full bytecode, every attribute — plus the JAR's manifest, module-info, multi-release versions, Spring Boot nested jars and duplicate classes.
Tool ·
Java thread dump analyser
Paste jstack, jcmd Thread.print, kill -3 or Thread.dump_to_file (text or JSON, with virtual threads) output: threads grouped by state and identical stack, deadlocks and a lock graph, thread pools, hot frames, CPU per thread, and a comparison of dumps taken seconds apart to find stuck threads.
Tool ·
Kubernetes NetworkPolicy and Pod Security checker
Paste NetworkPolicies, pods and namespaces (or kubectl get -o yaml output) and ask whether one pod can reach another on a port, with the policies that allow it or the reason it's blocked; a colour-coded pod × pod matrix, a lint, a policy builder, and a Pod Security Standards checker that lists every failing field and its fix.
Tool ·
Kubernetes scheduling explainer
Paste your nodes and a pod or Deployment and see which nodes it can run on and why — every scheduler filter per node, the scores and weights that pick the winner, the FailedScheduling message, preemption victims, and N replicas placed one after another — checked against the real kube-scheduler v1.36.
Tool ·
Linux triage
Paste the output of uptime, dmesg, vmstat, mpstat, pidstat, iostat, free, sar, top, /proc/meminfo, /proc/pressure, ss and cgroup files — several at once, in any order — and get a reading in the style of Brendan Gregg's 60-second checklist and the USE method: what each column means, what is abnormal, what to run next. Plus exit codes and signals (137 OOM-kill vs SIGKILL, 143) for Docker and Kubernetes.
Tool ·
Log parser
Paste or drop logs (large files are streamed) — nginx/Apache, JSON lines, logfmt, syslog RFC 3164/5424, journald, Java with multi-line stack traces, Go zap/slog, Kubernetes CRI, CloudWatch — or write a grok pattern with the standard Logstash library; get field statistics, a zoomable time histogram, filter expressions, message templates (Drain), CSV/JSONL export, and the table in DuckDB lab or the data wrangler.
Tool ·
Makefile explainer
Paste a GNU Makefile and a list of files with their times: see what make -n would run and why, in order, with the recipes expanded; a dependency graph where you can touch a file; every rule and variable explained; and lints for missing .PHONY, spaces instead of tabs, $VAR in recipes and recursive-make pitfalls.
Tool ·
Markdown ↔ AsciiDoc converter
Convert Markdown (GitHub-flavoured, with alerts, footnotes and front matter) to AsciiDoc and back, see both rendered side by side, and get a report of everything that had to be approximated.
Tool ·
Maven and Gradle build files
Paste POMs (with their parents and BOMs) and get the effective POM with where every value came from, profiles you can switch, BOM import order, the phases and plugin goals a command like mvn clean verify runs, and lints. Read build.gradle(.kts) with its version catalog and see which classpaths each dependency lands on. Convert POM ↔ Gradle and Groovy ↔ Kotlin DSL, and compare Maven and Gradle version ordering and conflict rules.
Tool ·
Memory layout: Go, Rust, C and Java
Paste a Go struct, Rust struct or enum, C struct or Java class and see every byte — fields, padding, object headers, enum tags and niches — on 64-bit and 32-bit targets, with Go's fieldalignment reordering, rustc's own field order, HotSpot's field packing, and a gallery of runtime internals (slice and interface headers, Vec, Box, Rc, fat pointers, String, HashMap.Node).
Tool ·
Near-duplicate detection
Find near-duplicate documents: character or word shingles, exact Jaccard, seeded MinHash signatures, LSH banding with its S-curve and a (b, r) tuner, 64-bit SimHash with the permuted-table search, precision and recall against an exact similarity join, and clusters — 10,000+ documents in a Web Worker.
Tool ·
Packet capture viewer (mini Wireshark)
Open .pcap and .pcapng files in the browser: a Wireshark-style packet list, detail tree and hex view, display filters, TCP analysis (retransmissions, duplicate ACKs, zero windows), follow stream, conversations, endpoints, protocol hierarchy, IO graph, HTTP objects, and pcap, pcapng and HAR export.
Tool ·
Postings lab
Inside an inverted index: build one from documents and look at docIDs, frequencies and positions; compress the postings with VByte, Elias γ/δ, Golomb/Rice, Simple-9/16, FOR and PForDelta blocks of 128, Lucene's PForUtil and Roaring bitmaps (bits per posting, bit by bit); intersect with skips and galloping; and step through MaxScore, WAND and Block-Max WAND against exhaustive BM25.
Tool ·
Property lists and defaults
Open any property list — XML, binary (bplist00, every type including UIDs and dates), old-style OpenStep, `defaults read` output or JSON — edit it as a tree and get the plutil and defaults commands for each change, convert it byte-for-byte the way plutil does, take a binary plist apart, and browse a curated catalogue of defaults write tweaks with read and undo commands.
Tool ·
React render lab
Real React 19 running your component on the page, with a live component tree that flashes on every render and says why — which state, which props, which context, or just the parent — render counts and times, a commit timeline, the console, and eleven lessons from lifting state to Suspense, use() and the React Compiler.
Tool ·
Row key design
Build a row key from parts — fields, reversed timestamps, salts, hash prefixes, padding, separators — run a workload against Bigtable, HBase, Cassandra or DynamoDB, and see where the writes land over time (region splits included), which queries become one range scan and which a fan-out or scatter-gather, and what the key costs in bytes.
Tool ·
SBOM and vulnerability report viewer
Open a CycloneDX or SPDX SBOM, or a Trivy, Grype or OSV-Scanner report, and see the components by ecosystem with purls and licences (SPDX expressions parsed, copyleft flagged), the dependency graph, vulnerabilities by severity with fixed-in versions and "upgrade X to Y fixes N" suggestions — and what changed between two SBOMs.
Tool ·
Schema diff
Paste two SQL schemas (PostgreSQL or MySQL, hand-written or from pg_dump / mysqldump) and get the migration from one to the other as SQL, Flyway versioned files or a Liquibase changelog (YAML or XML), with warnings for the changes that rewrite or lock tables — by database version — and an ER diagram of what changed.
Tool ·
Serverless sizing: Lambda, SQS, Kinesis, SNS and API Gateway
Size and price a serverless design — Lambda cost by memory, duration, requests and architecture (with the free tier, INIT billing and provisioned concurrency), concurrency from rate × duration against the account and scaling limits, cold-start factors, SQS batch and visibility-timeout checks with FIFO limits, Kinesis shards and on-demand against provisioned, SNS fan-out and API Gateway REST against HTTP — every price dated and sourced.
Tool ·
Shell prompt builder
Build a zsh PROMPT/RPROMPT and a bash PS1 from blocks — user, host, directory, git branch and state, exit status, time, venv — with a live preview in several terminal colour schemes; paste any prompt to see it expanded and explained escape by escape; and paste zprof or a timed xtrace log to find what makes zsh slow to start.
Tool ·
Spring Boot inspector
Paste Spring Boot Actuator output and read it: why each auto-configuration did or didn't apply, the bean dependency graph, which property source wins for every key, bound @ConfigurationProperties, the endpoint table, metrics and health. Plus a properties ↔ YAML converter with profiles, a checker for common keys, and every relaxed-binding form of a property name.
Tool ·
Step Functions workbench
Paste an Amazon States Language definition and see it drawn as a graph, checked for common mistakes, and run step by step with mocked Task results — every InputPath, Parameters, ResultSelector, ResultPath and OutputPath (or JSONata Arguments, Output and Assign) shown with the data it produced, intrinsic functions, variables, Retry with back-off, Catch, timeouts, Parallel and inline or distributed Map.
Tool ·
TCP, simulated
TCP you can watch: two hosts and a bottleneck router with a queue, every segment a labelled packet — the handshake and its options, sequence and ACK numbers, windows, delayed ACKs and Nagle, the RFC 6298 timer, fast retransmit, NewReno and SACK, Reno vs CUBIC vs BBR with cwnd plotted, bufferbloat, long fat pipes, fairness between two flows, FIN, TIME_WAIT and RST — exportable as a pcap.
Tool ·
TLS 1.3 and QUIC handshakes
Step through TLS 1.3 (full, HelloRetryRequest, PSK resumption with 0-RTT), TLS 1.2 and QUIC handshakes message by message, with every byte built and every secret of the key schedule computed live with Web Crypto — and checked against the RFC 8448 and RFC 9001 test vectors.
Tool ·
Time-series database lab
Inside a time-series database: validate InfluxDB line protocol and Prometheus exposition text and see the series keys; watch Gorilla, Prometheus XOR/XOR2 and InfluxDB TSM compression bit by bit on your data (byte-identical to Prometheus's and InfluxDB's own encoders); estimate cardinality and memory; downsample counters correctly; size retention tiers; and watch Prometheus cut and compact blocks.
Tool ·
TypeScript playground
The real TypeScript 6 compiler in your browser — errors with line, column and TS code as you type, hover types, the emitted JavaScript and .d.ts, every strictness flag, a tsconfig.json explained option by option, advanced-type examples, and Run in a sandboxed page or a worker.
Tool ·
launchd jobs
Build a launchd job (LaunchAgent or LaunchDaemon) from a form, or paste one to have it explained and checked; turn crontab lines into StartCalendarInterval, see the next run times and what happens if the Mac sleeps through one, and get the launchctl bootstrap/bootout/enable/kickstart/print commands.
Tool ·
strace viewer
Paste strace output — with or without -f, -tt/-ttt/-r, -T, -y/-yy, unfinished/resumed pairs, signals, -c tables — or macOS dtruss output, and get a per-thread timeline, a summary that matches strace -c, the slowest calls, errors grouped (path probing, EAGAIN loops), files with bytes read and written, connections and DNS lookups decoded from the buffers, the process tree with argv, and hints.
Tool ·
tmux lab
Learn tmux by doing in a simulated tmux in the page — the real default keys, splits, layouts, zoom, windows, sessions, copy mode in vi or emacs keys, the command prompt, detach and attach — plus a .tmux.conf builder that explains every line, a live status-line preview, a layout-string decoder and encoder with the checksum, a searchable cheat sheet and how cmux compares.
Tool ·
8086 assembly playground
Write 8086 assembly in NASM syntax and step through it as a DOS .COM program: every instruction's bytes split into prefix, opcode, ModR/M, displacement and immediate with each field explained, registers and flags with changes highlighted, segment:offset addresses with the 20-bit physical address, Intel's clock count for every instruction (8086 or 8088), an 80 × 25 colour text screen at B800:0000, BIOS and DOS interrupts, and the keyboard.
Tool ·
ARM Thumb assembly playground
Write Cortex-M assembly and step through it on a simulated microcontroller: a GNU-syntax assembler for Thumb and Thumb-2 with literal pools and IT blocks, every 16- and 32-bit encoding split into its fields bit by bit, registers and NZCV with changes highlighted, memory and stack views, breakpoints, LEDs and switches on GPIO, a UART terminal, SysTick interrupts through a vector table, and Cortex-M0 or M3 cycle counts.
Tool ·
Classic cipher cracker
Encrypt, decrypt and crack the classic pencil-and-paper ciphers — Caesar, Atbash, affine, Vigenère, Beaufort, autokey, simple substitution, rail fence, columnar transposition and Playfair — with frequency, IoC, chi-squared and Kasiski analysis and a hand-solving workbench.
Tool ·
Data recipe
Chain operations on text or a dropped file and see the output after every step — encodings, gzip and deflate, hashes and HMAC, AES-GCM/CBC/CTR, XOR and XOR brute force, ROT13, text and CSV/JSON operations, timestamps, entropy and a byte histogram — with “magic” that guesses the decoding steps.
Tool ·
DuckDB analytics lab
Real DuckDB in your browser with a console, results grid, plan trees for EXPLAIN ANALYZE, quick charts and CSV/Parquet export — sample datasets, your own CSV/Parquet/JSON files read locally, and twelve guided labs: window functions, QUALIFY, PIVOT, ASOF joins, ROLLUP/CUBE, nested types, regex, Parquet metadata and columnar storage.
Tool ·
GraphQL playground
A GraphQL server in your browser — write a schema in SDL and resolvers in JavaScript over sample data (a blog, a library, a shop), query it with hints from the schema, and watch every resolver call and database query on a timeline, which is how the N+1 problem shows itself and DataLoader fixes it. Also sends queries to real endpoints.
Tool ·
Linux shell playground
A real Linux booted in the page (a small kernel and BusyBox in the v86 x86 emulator) with a terminal, sample logs, CSVs and a config tree in your home directory, and 26 exercises — text pipelines, find and xargs, redirection, permissions, processes and signals, environment variables, loops — that check your answer.
Tool ·
Policy playground: Rego and CEL
Write policies in Rego and CEL and test them against JSON inputs in the browser — a Rego interpreter with a trace of which rules fired and why the others didn't, real CEL with type errors, examples for RBAC, Kubernetes admission, API authorisation from JWT claims and Terraform plan checks, and a decision log of every input and result.
Tool ·
Protobuf and gRPC playground
Write a .proto, fill in a message with a generated form or as JSON, and see every byte of its encoding explained — tags, varints, zigzag, fixed widths, lengths, packed lists, maps, oneofs — next to its JSON size; gRPC and gRPC-Web framing; and a schema-evolution checker that says which changes between two versions break old or new code.
Tool ·
Python notebook
A Jupyter-style Python notebook that runs entirely in your browser (Pyodide) — code and Markdown cells, one shared namespace, pandas tables and matplotlib figures inline, tracebacks, CSV upload, open and download .ipynb files, autosave, share links, and starter notebooks for pandas, plotting, linear algebra, SciPy statistics and simulation.
Tool ·
RC power setup — motor, prop and battery
Work out what a motor, propeller and LiPo will do together — RPM, current, voltage sag, power, efficiency, static thrust, pitch speed, thrust-to-weight, hover or cruise throttle and flight time — with warnings for the motor, ESC and battery, a throttle sweep chart and up to three setups side by side.
Tool ·
RISC-V assembly playground
Write RV32IM assembly and step through it: an assembler with pseudo-instructions and %hi/%lo, the machine code beside each line with every format's fields decoded bit by bit, registers with changes highlighted, memory and stack views, breakpoints, RARS-style ecalls, LEDs and switches on a memory-mapped device, and a 5-stage pipeline diagram of what ran, with stalls, forwarding and flushes.
Tool ·
RabbitMQ, simulated
An animated RabbitMQ broker in your browser: producers, exchanges (direct, fanout, topic, headers, default), bindings, classic and quorum queues and consumers, with every publish, route, delivery, ack, confirm and dead-lettering drawn as it happens — prefetch, requeues, TTL, max-length, priorities, DLX retry with backoff, poison messages and RPC, in guided scenarios or a topology you build.
Tool ·
Reinforcement learning gridworld
A gridworld you paint — walls, pits, goals, wind and slippery ice — solved by value iteration and policy iteration, and learned by Q-learning, SARSA and Expected SARSA with ε-greedy exploration; value heatmap, policy arrows, Q-values per cell, the reward curve, the cliff-walking race between Q-learning and SARSA, and every Bellman backup written out with the live numbers.
Tool ·
SPARQL and RDF playground
A real SPARQL 1.1 engine (Oxigraph, in WebAssembly) in the page — load Turtle, TriG, N-Triples or JSON-LD, run SELECT, CONSTRUCT, ASK, DESCRIBE and updates, see results as a table, as Turtle or as a graph drawing, work through labs on property paths, aggregates, named graphs and RDFS inference by rules, or query Wikidata.
Tool ·
SQLite internals
Real SQLite in your browser with a console, and what is underneath: the database file decoded page by page (header, b-tree pages, cell pointers, cells and records, overflow and freelist pages), a b-tree diagram for any table or index, VDBE bytecode annotated opcode by opcode, query plans as trees, the pages each statement writes — and eleven labs from rowid tables to WAL.
Tool ·
SSH and PGP key inspector
Paste or drop an SSH or OpenPGP key and see what it is — fingerprints and randomart exactly as ssh-keygen prints them, certificates, authorized_keys options, hashed known_hosts, OpenSSH and PEM private key headers, and OpenPGP packets with key IDs, expiry and warnings — or make a new SSH key pair in the browser.
Tool ·
Shader playground
Write GLSL fragment shaders and watch them run as you type — WebGL2 with a WebGL1 fallback, compile errors on their lines, Shadertoy's iTime/iResolution/iMouse/iFrame, sliders and colour pickers for your own uniforms, pause, step and scrub, PNG and WebM export, .frag export for Shadertoy, glslViewer and other hosts, share links, and nine examples with lessons from UV gradients to raymarching and a Boing ball.
Tool ·
Shell command explainer
Paste a command line or a script and see it taken apart — pipes, redirections, && and ||, subshells, loops, quoting, variables, substitutions, globs and here-documents — with every option of 170 common commands explained, warnings for dangerous patterns such as rm -rf $DIR/ and curl | sh, and ShellCheck-style notes on common mistakes.
Tool ·
Tailwind CSS playground
Write HTML with Tailwind classes and see it live — Tailwind 4's browser build in a sandboxed preview, your own theme and utilities, a dark-mode switch, phone / sm / md / lg / xl preview widths, a class inspector that explains every utility and shows the CSS it generated, six components to start from, and exports with the CDN or compiled CSS.
Tool ·
Train a tiny transformer
Train a character-level, decoder-only transformer from scratch in your browser — one to four layers, written in plain JavaScript with a hand-written backward pass checked against finite differences — on Shakespeare's sonnets, nursery rhymes, Carroll and Lear, or your own text, and watch the loss fall, the samples turn into words, the attention heads specialise and the character embeddings sort themselves out.
Tool ·
WebGPU compute playground
Write WGSL compute shaders and run them on your GPU — compile errors on their lines, buffers set up from the @group/@binding declarations, a pass script for dispatches, loops and uniform writes, results read back into tables and plots, GPU timestamps, and nine examples with lessons from invocation IDs to a parallel scan, tiled matrix multiply, atomics, bitonic sort, particles and a Mandelbrot set.
Tool ·
Z3 solver playground
Microsoft Research's Z3 SMT solver running in the page — an SMT-LIB editor with readable models, puzzles that show the SMT-LIB they generate (Sudoku, N-queens, SEND+MORE=MONEY, magic squares, job scheduling, exam timetabling), and a small C-like language for proving bit tricks and finding overflow bugs.
Tool ·
jq playground
Real jq 1.8 in your browser — input, filter and output side by side, updating as you type, with the command-line flags, --arg and --argjson, over fifty example filters on sample data (a GitHub API response, a Kubernetes pod list, a JSON-lines log, a nested config), the output after every stage of the pipe, and the shell command to copy.
Tool ·
nginx and Caddy request router
Paste an nginx config or a Caddyfile and a request, and step through what the server does with it — which server block and location win and why, rewrites, try_files, if, alias vs root, the proxy_pass trailing-slash rules, add_header inheritance — ending in the file served, the upstream URL or the redirect. Plus a table of requests checked against expected outcomes.
Tool ·
Machine QR cards
Printable safety cards and posters for each machine in a makerspace — A4 and A5 posters, A6 cards four to a sheet, or small Niimbot labels — with ISO 7010-style signs for PPE, hazards and rules, allowed and banned materials, key settings, who to ask, and a QR code that opens the machine's page and induction.
Tool ·
Machine inductions and sign-offs
Induct members on a makerspace's machines — a checklist the inductor ticks with them, a shuffled quiz with a pass mark, and a dated sign-off that expires when the machine says — with a register of who is signed off on what, expiring and expired sign-offs, CSV export, printable sign-off cards and member passports, a machine page for QR codes, and an editor for the space file.
Tool ·
Tool library checkout
A lending desk for a makerspace's tool library — a catalogue with asset tags, check out by scanning the tool's QR code or typing its tag, due dates in the space's time zone, returns with a condition note, an overdue list, history per tool and per member, asset tags for the label maker and a QR sheet. Runs on one shared tablet; sync another device by file.
Article ·
AI Force
The administration is starting a new military force, so I designed the one I'd expect: the AI Force — a squad of very typical geeks in hero suits, with a nod to Atari Force from the 1980s comics.
Tool ·
ADB for Android and Fire TV
Android Debug Bridge in the browser — over WebUSB or the network (port 5555 through the gitwebsite app): device info, logcat, a shell, APK install, apps, files, screenshots and recordings, and a TV remote for Fire TV and Android TV.
Tool ·
Agent trace viewer
Open agent traces — Claude Messages API and OpenAI Chat Completions or Responses logs, OpenTelemetry GenAI spans, Claude Code session JSONL — and see every turn, model call and tool call on a timeline and in a tree, with latency, tokens split into cache reads and writes, cost per step, failed tool calls and retries, and full-text search; nothing leaves the browser.
Tool ·
Cassandra lab
A Cassandra data-modelling lab and CQL client: a cqlsh-like console on a built-in Cassandra node (CQL, TTLs, tombstones, SSTables, lightweight transactions), a query-first checker that says which queries a table supports and why, partition sizes and hot partitions, the token ring with vnodes and replica placement, consistency levels with replica responses — and a native-protocol client for your own Cassandra through the gitwebsite app.
Tool ·
Data-lake browser
Browse and query object stores and HDFS from the browser — S3, MinIO, R2, B2, Wasabi, GCS, Azure Blob and WebHDFS/HttpFS: buckets and folders, uploads with resumable multipart, Range downloads, presigned URLs, Parquet/ORC/Avro schema and row-group statistics, DuckDB SQL over files, HDFS block locations, bucket CORS/policy/lifecycle generators, and the aws/mc/gcloud/az/hdfs command and curl for every action.
Tool ·
DynamoDB single-table modeller
Design a DynamoDB single table — entities with key templates, GSIs and LSIs — see its items grouped by partition, check every access pattern (which GetItem or Query serves it, on which index, and how much it reads to return what), estimate capacity and on-demand against provisioned cost, and export to NoSQL Workbench, CloudFormation or CDK; with a DynamoDB engine in the page and a client for DynamoDB Local.
Tool ·
Floor plan and building layout
Draw a building floor by floor — walls with clean joins, doors, windows, stairs, rooms with their areas, dimensions, labels and scale-true furniture — over an imported plan image you calibrate and trace by hand or with automatic wall detection, see it in 3D, and export SVG, PNG, DXF (a layer set per floor) or JSON, or print it to scale.
Tool ·
Graph database playground
Write Cypher against sample graphs — movies, a social network, a metro — in an engine that runs in the page (MATCH with variable-length paths and shortestPath, WITH, aggregation, CREATE/MERGE/SET/DELETE, EXPLAIN and PROFILE), see results as a force-directed graph, a table or cypher-shell text, and run the same queries on a real Neo4j over Bolt.
Tool ·
LLM eval harness
Grade LLM outputs against a dataset — exact match, regex, contains, JSON Schema, numeric tolerance, BLEU (sacreBLEU), ROUGE-L, embedding similarity or an LLM judge — with bootstrap confidence intervals, per-tag breakdowns and run comparisons by paired bootstrap and McNemar's test; paste outputs or call Claude, OpenAI or a local model with your own key.
Tool ·
MongoDB playground
A mongosh-like console on a MongoDB that runs in your browser — with sample data, an aggregation pipeline builder that previews every stage, explain plans drawn as a tree (COLLSCAN vs IXSCAN), schema inference and $jsonSchema validators, a reference with runnable examples — and a real-server mode that speaks MongoDB's wire protocol through the gitwebsite app.
Tool ·
OpenTelemetry trace viewer
Open a distributed trace as OTLP/JSON, a Jaeger export or Zipkin v2 JSON and read it as a waterfall with events and errors, a service map, the critical path and self time per service — flag and adjust clock skew, compare two traces span by span, and convert between the formats, all in the browser.
Tool ·
PromQL and LogQL playground
Write PromQL and LogQL against four hours of generated metrics and logs — counters with resets, histograms, a failing instance, a target that goes down — see the result as a graph or table, and walk through any query step by step, down to the arithmetic of rate()'s extrapolation and histogram_quantile()'s interpolation.
Tool ·
RAG chunking playground
Drop in text, Markdown, HTML or PDF and chunk it five ways — fixed token windows with overlap, sentences, LangChain's recursive splitter, Markdown headings and semantic breakpoints — see every boundary and overlap on the text, then compare BM25, embedding and hybrid retrieval across the chunkers with recall@k and MRR against passages you mark.
Tool ·
Server config builders
Build and explain nginx, Caddy, systemd and SSH configs — reverse proxies with Mozilla TLS settings, WebSockets and rate limits (with a limit_req simulation), static sites, hardened systemd services and timers with next run times and an exposure estimate, and ssh_config hosts and tunnels with a diagram — or paste your own and have each line explained and checked.
Tool ·
Smart-home toolkit
Home Assistant from the browser (entities and history, a service caller built from each service's schema, a template tester, the event bus), an automation YAML linter and explainer, Shelly, Tasmota and Hue controls, and a Matter setup-code decoder and encoder.
Tool ·
Spaced-repetition flashcards
Flashcards for Mathematics, Reconnected, Human Biology for the Medical Maker and the AI Acceleration primer — definitions, formulas, mastery checks and glossaries, each linked to its chapter — plus Big-O and coding interview decks that go with this site's tools — scheduled with FSRS (or SM-2), with cloze cards, your own decks, CSV and Anki import and export, and statistics, kept in your browser.
Tool ·
TV remotes: LG webOS, Roku, Samsung
A phone-sized remote for LG webOS (SSAP and its pointer socket), Roku (External Control Protocol) and Samsung Tizen TVs on your network — apps, inputs, volume, text entry and toasts — plus developer-mode notes for each.
Tool ·
Terraform plan visualiser
Open the JSON of a Terraform or OpenTofu plan and see what it will create, change, replace and destroy — with why each replacement is forced, warnings for destroyed data stores, sensitive values masked, the attribute diffs as terraform plan prints them, and the dependency graph from the configuration's references.
Tool ·
AWS architecture builder
Draw an AWS architecture on an interactive diagram — VPCs, subnets and 40 services, from web tiers to data lakes, warehouses, stream processing and search — configure each service, see a rough monthly cost, and download a TypeScript AWS CDK app that synthesises.
Tool ·
Analyzer and inverted-index playground
Build an Elasticsearch analyzer from char filters, a tokenizer and token filters and watch the token stream change stage by stage — terms, positions, offsets, types and position lengths, drawn as a token graph — then index documents to see the postings, field-length norms and phrase/slop matching, and copy the _analyze request and index settings.
Tool ·
Cache simulator
Every major eviction policy — LRU, LFU, FIFO, CLOCK, ARC, 2Q, W-TinyLFU, S3-FIFO — against Belady's optimum on Zipf, loop, scan and shifting workloads or your own trace; hit-ratio curves for all of them at once, a step-through of each policy's internal state, write policies, cache stampede fixes (singleflight, jitter, XFetch, stale-while-revalidate) and hot-key and two-tier maths.
Tool ·
Capacity and queueing planner
Queueing maths for capacity planning: Little's law, M/M/1, M/D/1, M/G/1 and Kingman, M/M/c with Erlang C and exact percentiles, the utilisation-versus-latency knee, the tail at scale of fan-out requests, hedged and tied requests, a discrete-event simulator that checks the formulas, and a planner that turns a p99 target into a server count.
Tool ·
Classic machine learning, step by step
Classic machine learning on 2-D data you can edit — a decision tree growing split by split with its best-split search, a random forest's bootstrap trees and vote map, gradient boosting round by round, k-NN, logistic regression, a soft-margin linear SVM and Gaussian naive Bayes side by side — and an optimiser lab racing SGD, momentum, Nesterov, AdaGrad, RMSProp, Adam and AdamW over Rosenbrock, Beale, a saddle and an ill-conditioned bowl with learning-rate schedules.
Tool ·
Clocks, CRDTs and gossip
Time and agreement without coordination: space-time diagrams with Lamport, vector and hybrid logical clocks (skewed and drifting physical clocks, last-writer-wins gone wrong, causal broadcast); CRDTs from G-Counter to OR-Set and a collaborative RGA text editor across three replicas; and SWIM failure detection and epidemic gossip, animated.
Tool ·
Compose visualiser
Paste a docker-compose.yml and see its services, networks, volumes, ports and depends_on as a diagram, the start-up order, the effective config after ${VAR} interpolation and profiles, and a kompose-style Kubernetes translation.
Tool ·
Container dashboard
A read-only dashboard for your own Docker and Kubernetes through a small local relay: containers, images, volumes and networks with live stats and logs; namespaces, workloads with rollout status, pods, services and endpoints, nodes, events, YAML, and a topology diagram — with every request copyable as curl, docker or kubectl.
Tool ·
Digital logic simulator
Build digital circuits by dragging gates, switches, clocks, LEDs and 7-segment displays, watch the signals light up, and go further with flip-flops, counters, adders, an ALU, RAM and ROM, your own sub-circuits, truth tables with minimised expressions, expression-to-circuit, a timing diagram with real gate delays, and a tiny CPU that runs a program.
Tool ·
Dockerfile explainer and linter
Paste a Dockerfile and see what every instruction does, which ones make layers, what a change rebuilds, how the stages connect and roughly how big the image is — with hadolint-style lints and one-click fixes.
Tool ·
Elasticsearch, simulated
An animated, step-by-step Elasticsearch (and OpenSearch) cluster in your browser: murmur3 routing, primaries and replicas, the indexing buffer, translog, refresh, flush and segment merging inside every shard, query-then-fetch search, node failures, master elections, split brain and shard sizing — with guided scenarios and a REST console.
Tool ·
Embedding explorer
Load embeddings (CSV, TSV, JSON, GloVe text, the TensorFlow Projector's vectors.tsv + metadata.tsv) or embed sentences in the browser with all-MiniLM-L6-v2, then project them with PCA, t-SNE or UMAP in 2-D or 3-D, colour and search them, list nearest neighbours by cosine or Euclidean distance, cluster with k-means or DBSCAN, score how faithful the map is, and try word analogies.
Tool ·
FPGA calculators
Setup/hold slack with a timing diagram, clock-domain crossing patterns with Verilog and synchroniser MTBF, iCE40 and ECP5 PLL settings that match icepll and ecppll, FIFO depth, VESA/CTA-861 video timings with a Verilog generator, UART divisors, BRAM/DSP counts, parallel CRC and LFSR generators, and pin-constraint files for eleven boards.
Tool ·
Flink, simulated
An animated Flink job in your browser: Kafka partitions feeding chained operators, keyBy through key groups, event-time windows driven by watermarks, keyed state on HashMap or RocksDB, checkpoint barriers (aligned and unaligned), failure and recovery, a two-phase-commit Kafka sink, backpressure and rescaling from a savepoint — with guided scenarios, a key-group calculator and a window explorer.
Tool ·
GCP architecture builder
Draw a Google Cloud architecture on an interactive diagram — a project, its region and VPC network, and 37 mainstream services, including a big-data platform (warehouse, batch and stream processing) and a search and caching service tier — configure each service, see a rough monthly cost, and download Terraform that passes terraform validate.
Tool ·
Git client
A git client in the browser: open a local repository (read-only unless you switch on write mode), see the commit graph, diffs, blame, file history, status and stashes; browse GitHub and GitLab repositories, pull requests and issues; clone over HTTPS through a relay you run.
Tool ·
Git, visualised
Learn git by doing: a terminal that runs real git commands against a faithful in-browser git (real SHA-1 object ids), with an animated commit graph, the three trees, the object database, a 34-lesson course with automatic goal checks, and disaster-recovery scenarios.
Tool ·
HDL trainer: learn Verilog by doing
Learn Verilog by writing it: 23 lessons from gates to UARTs, VGA timing, FIFOs and pipelines, each checked by a hidden testbench that simulates your module and shows the waveform and every mismatch — plus a sandbox simulator and a logic-sim → Verilog converter.
Tool ·
How containers work, simulated
An animated, step-by-step Linux host running Docker in your browser: docker run through dockerd, containerd and runc to clone(); namespaces, cgroups and the OOM killer; overlayfs copy-up and whiteouts; the build cache; pulling by digest from a registry; the bridge, veths, DNS and NAT; volumes; and the capabilities, seccomp and user namespaces that keep a container in — with a terminal that drives the same diagram.
Tool ·
Kubernetes manifest builder and explainer
Build Kubernetes manifests from forms — Deployments to NetworkPolicies — with live YAML, checks across the whole bundle, kubectl-explain docs for every field, a CPU and memory unit converter with the QoS class your requests and limits produce, probe timelines and a CronJob schedule explainer.
Tool ·
Kubernetes, simulated
An animated Kubernetes cluster in your browser: kubectl, the API server and etcd, controllers reconciling desired and actual state, the scheduler's filters and scores, kubelets pulling images and running probes, kube-proxy and Services, the HPA, StatefulSets, Jobs, drains and PodDisruptionBudgets — with guided scenarios and a pretend kubectl.
Tool ·
Load balancing and resilience, simulated
An animated, step-by-step fleet of servers behind a load balancer: round robin, least outstanding, power of two choices, peak-EWMA and consistent hashing with bounded loads; then timeouts, retries with jitter and budgets, retry storms and metastable failure, circuit breakers, hedged requests, load shedding and adaptive concurrency limits — with latency, throughput and error charts over time.
Tool ·
Model evaluation workbench
Evaluate a classifier or regressor from its predictions — paste or upload a CSV, or generate a seeded synthetic model — with confusion matrices (micro, macro and weighted precision, recall and F1, MCC, κ), ROC and precision–recall curves (trapezoid AUC against average precision), lift and gain, a cost-matrix threshold chooser, calibration (reliability diagram, ECE, Brier, Platt and isotonic), class imbalance, per-group fairness, and regression residuals.
Tool ·
Partitioning and replication
Where keys live and how copies stay in step: consistent hashing with virtual nodes, rendezvous, jump hash and Maglev with animated key movement; an animated Dynamo-style store with preference lists, N/R/W quorums, sloppy quorums and hinted handoff, read repair, vector-clock siblings and Merkle-tree anti-entropy; and the latency and staleness of partial quorums.
Tool ·
Postgres playground
Real PostgreSQL 18 in your browser (PGlite) with a psql-like console, twenty runnable labs for the distributed patterns Postgres does well — SKIP LOCKED queues, advisory-lock mutexes, leases with fencing tokens, leader election, LISTEN/NOTIFY, outbox, idempotency keys, rate limits — an animated model of concurrent sessions, and a real-server mode that races sessions on your own Postgres.
Tool ·
Probabilistic data structures
Bloom, counting Bloom and cuckoo filters, the Count-Min sketch with conservative update and heavy hitters, HyperLogLog (original, HLL++ sparse and Ertl's estimator), the t-digest and reservoir sampling — each fed by a live seeded stream, drawn from the inside, with accuracy-vs-memory charts against the formulas.
Tool ·
Query DSL builder and explainer
Build Elasticsearch and OpenSearch queries in a form or as JSON — each edits the other — and see them explained in plain English (query vs filter context, minimum_should_match, the Lucene query they become), linted for slow or surprising patterns, and run against a sample index in your browser with hits, scores, explanations, highlights and aggregations; optionally send them read-only to your own cluster.
Tool ·
Raft and Paxos, simulated
Consensus you can watch: Raft servers with terms, votes, logs and commit indexes exchanging labelled RequestVote and AppendEntries messages — elections, split votes, replication, crashes, log repair, partitions, the paper's Figure 8, membership changes, ReadIndex and lease reads, snapshots — plus Basic and Multi-Paxos and a randomised safety torture test.
Tool ·
Ranking metrics workbench
Paste TREC qrels and runs (or CSV) and get P@k, recall@k, MAP, MRR, nDCG@k with linear and exponential gain, ERR and R-precision per query — checked against trec_eval and gdeval — then compare two rankers with paired t, Wilcoxon, randomisation and bootstrap tests, and simulate team-draft interleaving.
Tool ·
Relevance and scoring explainer
See why documents rank where they do: BM25 term by term like Elasticsearch's _explain, with k1 and b sliders that re-rank live, classic TF-IDF side by side, multi-field strategies and boosts, function_score (field_value_factor, decay curves, a recency script), and hybrid lexical + vector ranking with reciprocal rank fusion or a normalised linear blend.
Tool ·
Spark, simulated
An animated Spark application in your browser: a DataFrame or SQL program becomes a logical plan, Catalyst rewrites it, the planner picks joins and inserts shuffles, the DAG scheduler cuts stages and runs tasks on executors with real memory regions — with guided scenarios on partitions, skew, joins, AQE, caching, spills and failures, an executor sizing calculator and an EXPLAIN reader.
Tool ·
Storage engines: LSM-tree vs B-tree, simulated
A B+tree and an LSM-tree side by side in your browser, fed the same operations: page splits and merges, the WAL and buffer pool, memtable flushes, leveled, size-tiered and lazy-leveling compaction, Bloom filters, fence pointers and tombstones — with write, read and space amplification counted as you watch, guided scenarios and the textbook cost models.
Tool ·
String matching and fuzzy search
Edit distances with the dynamic-programming table filled cell by cell (Levenshtein, OSA vs true Damerau, LCS, Hamming), Jaro–Winkler, Levenshtein automata as Lucene's FuzzyQuery builds them and walks the term dictionary, Soundex, Metaphone, Double Metaphone and NYSIIS, pg_trgm trigram similarity, and a Norvig spelling corrector.
Tool ·
Tokenizer explorer
Real tokenizers side by side in your browser — GPT-4/GPT-4o byte-level BPE (cl100k_base, o200k_base), BERT WordPiece, T5 SentencePiece Unigram and Llama 2 SentencePiece BPE with byte fallback — with coloured token boundaries and ids, UTF-8 bytes and split characters, BPE merges step by step, Unicode normalisation, cost per 1k tokens, the common pitfalls, and a tiny BPE you train yourself.
Tool ·
Transactions across services, simulated
Atomic commitment and its alternatives, animated: two-phase commit with forced log writes, in-doubt participants and a blocking coordinator crash, presumed abort and commit, three-phase commit failing under a partition, orchestrated and choreographed sagas with compensations and a semantic lock, and the dual-write problem fixed by a transactional outbox and an idempotent consumer.
Tool ·
Vector search, simulated
Approximate nearest-neighbour search you can watch: build and search HNSW layer by layer, train k-means and probe IVF cells, quantize with PQ, int8 and binary codes, compare L2, cosine and dot product, and benchmark recall against work and memory in a Web Worker.
Tool ·
Work log and tasks
A private work log and task list in your browser — tasks nested as deep as you like with due dates, effort and recurring rules, a timestamped journal, timers and timesheets that roll up by project, and a “what’s on my plate” view — with quick-add typing, undo, and JSON, Markdown and CSV import and export.
Tool ·
docker run builder and explainer
Build a docker run command from a form, or paste one and get every flag explained — ports, mounts, env, network, limits, healthcheck, security — with warnings, and convert it to a Compose service and back.
Tool ·
kubectl helper: commands, selectors, JSONPath, RBAC
Build kubectl commands with every flag explained; test label selectors against pods; try kubectl's JSONPath and custom-columns output on sample or pasted objects; and paste Roles and bindings to ask "can this user do that?", with the rule that grants it and a permissions matrix.
Tool ·
AI cost and energy economics
What a token, a training run and a gigawatt datacenter cost: cost per million tokens, 6·N·D training cost, datacenter TCO against GPU life and power price, generation mix and overbuild, PPA prices and energy bills, embodied vs operational carbon, GPU depreciation, and an educational export-control and EU AI Act check.
Tool ·
AI datacenter power and cooling
What an AI datacenter's power and cooling add up to: PUE, WUE, CUE and ERE over a year; I²R busbar loss at 12, 48 and 800 V; rack → Scalable Unit → hall in MW; the cooling ladder and die heat flux; coolant flow from Q = ṁ·cp·ΔT with pump pressure ∝ Q²; central-UPS vs 48 V power trains; N+1 and 2N backup; and what a better PUE saves.
Tool ·
Attention and the KV cache, visually
How an LLM's KV cache works and what it costs — one decode step ("read five, compute one") and O(N²) vs O(N) work, MHA/GQA/MQA/MLA head sharing with the live cache size in decimal and binary units, a PagedAttention allocator simulation, FlashAttention's tiles and online softmax with HBM traffic, and long-context cache size, compression and attention FLOPs.
Tool ·
Collectives and cluster topology
Ring and tree all-reduce one step at a time, the α–β time model with the ring/tree crossover and SHARP, the scale-up vs scale-out bandwidth cliff, how an NVL72 rack's 72 GPUs and 18 NVSwitch chips are wired, fat-tree and rail-optimised switch counts, and on-chip ring, mesh and torus hop counts and bisection.
Tool ·
Compute in orbit
Size an orbital AI datacenter from first principles: the radiator area to reject the chips' heat by radiation alone (εσA(T⁴ − T_env⁴)), the solar array at 1,361 W/m², the eclipse fraction of the orbit and the battery it needs, and the mass and launch cost.
Tool ·
Failures, checkpoints and goodput
Why a cluster of reliable GPUs fails every few hours (system MTBF = per-GPU MTBF ÷ N, with Llama 3's 419 interruptions in 54 days), the Young/Daly checkpoint interval and the goodput it buys, checkpoint size at 12/14/16 bytes per parameter with synchronous and asynchronous stalls, and inference availability — hot, warm and cold standby and the blast radius of a replica layout.
Tool ·
Kafka client
Work with a real Kafka cluster from the browser through a REST proxy (Confluent REST Proxy or Redpanda): brokers and configs, topics with partitions, ISR and offsets, produce single records or batches, consume by group or partition with live tail, consumer group lag and offset resets — and a log of every HTTP call, with copy as curl.
Tool ·
Kafka, simulated
An animated, step-by-step Kafka cluster in your browser: partitions as replicated logs, the ISR and high watermark, acks and min.insync.replicas, broker failures and KRaft leader elections (clean and unclean), idempotence and transactions, consumer-group rebalances, compaction and retention — with guided scenarios.
Tool ·
LLM serving planner
The arithmetic of serving an LLM: time per token and throughput against batch size (where the KV cache fills HBM and compute starts to bind), static vs continuous batching animated, pod requests per second and cost per million tokens, a per-request latency waterfall, the prefill-to-decode KV hand-off, speculative decoding, reasoning cost, and prefix-cache economics.
Tool ·
Links, optics and energy per bit
Bandwidth and energy per bit for PCIe 4–7, NVLink 4–6, NVLink-C2C, CXL, UALink, InfiniBand and Ethernet, one way or both; watts per port to pJ/bit and fleet megawatts for copper, pluggable, linear-drive and co-packaged optics; PAM4 symbol rate and Nyquist frequency; transfer times; and the HBM → DDR → CXL → NVMe memory ladder.
Tool ·
Mixture-of-experts router
How a mixture-of-experts router really works: per-token, per-layer top-k with renormalised gates, expert capacity and dropped tokens, auxiliary-loss vs DeepSeek bias vs Expert Choice balancing, active vs total parameters of real models, experts touched per batch, and the all-to-all traffic of expert parallelism.
Tool ·
Redis client
A redis-cli in the browser with a built-in Redis to practise on, Lua scripts and functions, a reference for 255 commands with runnable examples, per-connection history, a key browser, pub/sub and stream viewers — and connections to real Redis servers over a REST gateway or a WebSocket bridge.
Tool ·
The maths of machine learning
The mathematics under machine learning, hands on — least squares with draggable points (residual squares, outliers, L1 vs L2, normal equations vs gradient descent and SGD), logistic regression and its cross-entropy bowl, a computation graph with forward and backward passes against dual numbers and finite differences, TF-IDF and BM25 search, entropy with a Huffman tree builder and KL divergence, and softmax temperature with an attention matrix.
Tool ·
Training memory and parallelism planner
How much memory each GPU needs to train a model under data, tensor, pipeline, expert and context parallelism with ZeRO 0–3 / FSDP and activation recomputation, what each axis sends over the network, the pipeline bubble with a 1F1B timeline, MFU vs HFU, an animated activation-checkpointing walk-through, and the memory and FLOPs of PPO, GRPO and DPO.
Tool ·
Yield, chiplets and weights-in-silicon
Why big chips are expensive and why AI accelerators are built from chiplets: Murphy, Poisson and negative-binomial die yield, dies per wafer and cost per good die, splitting a design into chiplets with known-good-die testing against the 858 mm² reticle, and the silicon a model needs when its weights are etched into mask ROM.
Tool ·
Compass and level
Your phone as a compass — magnetic or true north, with the declination worked out for where you are by the World Magnetic Model — and a spirit level: a bullseye for flat surfaces, a tube for edges, two-sided calibration, a target angle that beeps, and the slope in degrees, percent, inches per foot and mm per metre.
Tool ·
Data wrangler
Clean and reshape tables with a recipe of steps — trim, retype, split, cluster near-duplicates, join, pivot, group — preview every step, then replay the recipe on new files or export it as SQL or pandas. DuckDB takes over for millions of rows.
Tool ·
Google Docs connector
An experiment in connecting browser tools to Google Docs — sign in with Google, pick or create a document, read it, and append notes from a scratchpad (at the end, under a heading, or into a section a tool keeps up to date). The app can only see documents you pick or create here.
Tool ·
Identify plants, birds and insects
Point your camera (or open a photo) at a plant, bird or insect and get the five most likely species — recognised on your device by Google's AIY Vision classifiers (2,101 plants, 964 birds, 1,021 insects), or rank your own labels with OpenAI's CLIP. Pictures never leave the page.
Tool ·
Tab sets
Turn the tabs open in Chrome into a shareable link — drag tabs or bookmarks in, paste them, or load Chrome's bookmarks export, no extension needed — then edit titles, notes, a group name and colour, and re-share or open them.
Tool ·
AI hardware calculator
How much GPU memory an LLM needs and how many accelerators that takes; the roofline model with a batch slider and overlaid chips; training compute, MFU, isoFLOP loss valleys and the EU AI Act line; inference speed, batching, KV hand-off, energy and cost per token; and a sourced table of accelerators from H100 to Groq, Cerebras, Apple silicon and Jetson.
Tool ·
Audio loudness meter
Measure an audio or video file's loudness in your browser — integrated, short-term and momentary LUFS (ITU-R BS.1770 / EBU R128), loudness range, true peak, sample peak, RMS, DC offset and clipping — compare it with YouTube, Spotify, Apple, podcast and broadcast targets, and export a normalised WAV.
Tool ·
Dictation scratchpad (speech to text)
Dictate into notes kept in your browser. Speech is recognised locally with OpenAI's Whisper running in the page — the audio never leaves your device — or with the browser's own speech recognition, with live words as you speak.
Tool ·
ESP flasher
Flash, erase, verify, and back up ESP8266 and ESP32-family chips from the browser over Web Serial — offsets from file names or an ESP-IDF build folder's flasher_args.json, merged images, security state, region erase and read-back.
Tool ·
I²C address finder
Pick the devices on an I²C bus and see the 7-bit address map with clashes and reserved addresses, the address-pin strapping that makes them fit, and a TCA9548A multiplexer plan when they can't share one bus — for 53 common sensors, displays, expanders, ADCs, RTCs and EEPROMs.
Tool ·
PIC microcontrollers
Pinouts and specifications for 16 popular Microchip PICs from the PIC10F200 to the PIC18F45K22, a configuration-bits generator and decoder (XC8, pic-as, MPASM), timer, PWM, baud-rate, I²C and A/D clock calculators, a PIC16F84A assembler and simulator with LEDs, buttons and a 7-segment display, and an Intel HEX inspector.
Tool ·
PID loop simulator
Simulate a PID controller on a first- or second-order plant with dead time — step response, overshoot, settling time, a load disturbance, output limits and anti-windup — get gains from Ziegler–Nichols, Cohen–Coon or SIMC tuning rules, copy the controller as C code, and play with a toy glucose loop to see what sensor and actuator delays do.
ElectronicsElectronicsSoftware engineeringBiology and medicine
Tool ·
Text to speech
Read text or Markdown aloud on your own device — with your system's voices (word-by-word highlighting, rate, pitch, volume) or Kokoro, a neural voice model that runs in the browser — and download the speech as a WAV file.
Tool ·
YouTube creator tools
Grab a video's thumbnails and check your own at the sizes YouTube shows; build and validate chapters; make share links and privacy-enhanced embeds; count title, description, and tag limits; convert and fix SRT, WebVTT, and SBV captions and clean transcripts; time a script and run a teleprompter; and look up upload bitrates.
Article ·
gitwebsite is now open source
The engine behind this site — a Rust static-site generator with a CLI, REST API, MCP server, and desktop app — is now on GitHub under the MIT licence.
Playground ·
C and C++ in the browser
Real Clang, compiled to WebAssembly, building and running C and C++ programs entirely inside your browser.
Playground ·
Lua playground
Lua 5.4 running as WebAssembly — coroutines, metatables, and string patterns you can edit and run.
Tool ·
Neural network designer
Build a multi-layer neural network from a palette, see every tensor shape and parameter count, draw it, train small ones live in the browser, and generate runnable PyTorch, Keras 3, JAX/Flax or plain NumPy code.
Playground ·
Prolog and Scheme playground
Logic programming with SWI-Prolog compiled to WebAssembly, and Lisp-family functional programming with Scheme — both live in the page.
Playground ·
Retro BASIC playground
Classic line-numbered BASIC, the way the 8-bit machines did it — PRINT, INPUT, GOTO, GOSUB, and a lunar lander to fly.
Playground ·
Ruby playground
CRuby 3.4 with its standard library, running as WebAssembly — blocks, Enumerable, pattern matching, and Data classes.
Playground ·
Rust and Go playground
Edit Rust and Go here; they are compiled and run by the official Rust and Go playgrounds, with the output shown in the page.
Playground ·
SQL playground: SQLite and DuckDB
Two real database engines compiled to WebAssembly — SQLite for everyday SQL and DuckDB for analytics on your own CSV and Parquet files.
Article ·
AOEE: a TAO-style social graph cache in Rust
How I built AOEE, an in-memory relationship cache for social-graph queries: posting lists borrowed from search engines, four adaptive encodings, set maths instead of joins, and friend-of-friend suggestions with a budget.
Tool ·
ASCII art
Turn images into ASCII, colour ANSI, or high-resolution Braille text art, and render FIGlet text banners in 30 fonts, ready to paste into terminals, READMEs, and source comments.
Article ·
Amiga DevBench: a modern dev loop, and an AI pair programmer, for the Amiga
How I connected a Mac to emulated and real Amigas over a serial link, built a source-level debugger and 129 MCP tools on top of it, and let Claude Code write, deploy, and debug Amiga software.
Tool ·
Base64 and encoding converter
Convert text to and from Base64, Base64URL, hex, binary, decimal bytes, percent-encoding, HTML entities, and Unicode escapes — with a byte inspector and file support.
Tool ·
Big-O explorer and benchmark
Compare growth curves, see how big an input fits a time budget, benchmark your own JavaScript to find its complexity class, look things up in a colour-coded Big-O cheat sheet, watch sorting algorithms run, and see where the costs come from: Fibonacci call trees, recursion trees, binary-search halving, and amortised appends — and why attention is O(N²) in context length, what an SSM's O(N) buys, and what a KV cache saves. Then revise for interviews: name the complexity of code snippets, drill data-structure operation costs, and solve recurrences with the master theorem.
Tool ·
Binary format decoder
Decode MessagePack, CBOR (with tags), protobuf (with or without a .proto), BSON, and Python pickle opcodes into an annotated tree and hex view; encode JSON as MessagePack or CBOR.
Tool ·
Bluetooth LE explorer
Connect to a Bluetooth Low Energy device from the browser, browse its GATT services, read, write, and subscribe to characteristics with decoders for standard sensors, graph live values, and look up UUIDs.
Tool ·
Board pinouts
Interactive pinouts for 36 boards — ESP32, -S2, -S3, -C3, -C5, -C6, -H2 and -P4 (Espressif DevKits, XIAO, Adafruit QT Py and Feather V2, ESP32-CAM, Nano ESP32), ESP8266, Raspberry Pi Pico and Pico 2, Arduino Uno R3/R4, Nano, Mega and Leonardo, Pro Micro, Teensy 4.0, STM32 Blue and Black Pill, and the Raspberry Pi header — with a pin planner, board comparison, and ESPHome/Arduino/MicroPython export.
Tool ·
Boolean logic
Truth tables with a column for every sub-expression, push negations inward one named law at a time, brute-force SAT on CNF clauses, Quine–McCluskey minimisation with Karnaugh maps and gate diagrams, equivalence checks, and register bitfields.
Tool ·
CRC and checksum calculator
Compute any of 40 standard CRCs (CRC-8 to CRC-64) or define your own, identify an unknown CRC from an expected value, generate C code, and calculate checksums, NMEA, Luhn, and Modbus RTU frames.
Tool ·
CSS playground
Generate gradients, layered box shadows, and border radii; try flexbox and grid settings live; work out clamp() fluid type; shape cubic-bezier easings with a running animation; and convert between px, rem, em, vw, and pt.
Tool ·
CSV viewer
Open CSV or TSV of any size in a fast scrolling table — sort, filter per column, search, column statistics, computed columns, and export to CSV, JSON, or Markdown.
Tool ·
Certificate decoder
Decode X.509 certificates and chains, CSRs, public and private keys, PKCS#7 bundles, and any DER as an ASN.1 tree; check chain order and expiry; and fingerprint SSH public keys. Everything stays in the browser.
Tool ·
Code beautifier and minifier
Beautify or minify JavaScript, TypeScript, JSON, CSS/SCSS/LESS, HTML, and XML, with indentation, wrapping, and brace-style options and before/after sizes.
Tool ·
Colour converter
Convert between HEX, RGB, HSL, HWB, OKLCH, OKLab, and CMYK; build tints, shades, and harmonies; check WCAG contrast.
Tool ·
Compose, Kubernetes, and cron checker
Check docker-compose.yml and Kubernetes manifests for mistakes that break deployments — unknown keys, bad references, port clashes, selector mismatches, removed API versions, invalid quantities — and convert crontabs to systemd timers.
Tool ·
Cron expression tool
Explain, validate, and build cron expressions — Unix and Quartz/Spring syntax with L, W, # and macros — and see the next run times in any time zone.
Tool ·
DNS lookup
Look up any DNS record over HTTPS through Cloudflare and Google, compare the two side by side, check DNSSEC, and decode SPF, DMARC, and DKIM.
Tool ·
Data converter
Convert between JSON, YAML, CSV/TSV, XML, TOML, and query strings, and generate TypeScript, JSON Schema, Go, Rust, and Python types from JSON.
Tool ·
Diagram and AsciiDoc studio
Live Graphviz (compiled to WebAssembly) and Mermaid editors, plus an AsciiDoc preview that renders [graphviz] and [mermaid] blocks inline and checks a gitwebsite post header — export SVG, PNG, or HTML.
Tool ·
ESP firmware image inspector
Open an ESP32-family .bin — app image, bootloader, partition table, NVS partition, or a full-flash dump — and see its header, segments, app description, checksum and SHA-256 verification, partitions, OTA state, and every NVS key and value.
Tool ·
ESP32 crash decoder
Paste a Guru Meditation, abort, assert, watchdog, or brownout log from an ESP32, S2, S3, C3, C6, or H2 and get the cause explained, the registers annotated, the backtrace resolved against your ELF, and the reset reason decoded.
Tool ·
ESP32 partition table editor
Design ESP-IDF and Arduino-ESP32 partition tables visually — add OTA, NVS, SPIFFS, LittleFS, and FAT partitions, check alignment and overlaps, and export the CSV or a flashable partitions.bin.
Tool ·
ESPHome config builder
Build ESPHome device YAML from a board and a catalogue of sensors, switches, lights, and buses — with live output, a secrets.yaml template, and a linter for pin conflicts, strapping and flash pins, ADC2 with Wi-Fi, I²C address clashes, and ESP8266/ESP32 differences.
Tool ·
Fake data generator
Build a schema of typed fields and generate reproducible test data — people, addresses, orders, logs, sensor readings — as JSON, CSV, SQL, YAML, XML, or Markdown.
Tool ·
Floating-point inspector
See exactly how float64, float32, float16, bfloat16, TF32, the FP8, FP6, and FP4 formats used for AI, and the E8M0 scale store a number — and how block-scaled formats (OCP MX, NVIDIA NVFP4, NF4) build a tensor from tiny elements and shared scales.
Tool ·
Fluid flow and pipe pressure drop
Reynolds number and Darcy–Weisbach pressure drop with Colebrook, Swamee–Jain, or Haaland friction factors and fitting losses; Hagen–Poiseuille laminar flow with an r⁴ sensitivity plot; pipe sizing from flow and velocity; Bernoulli solver; hydrostatic pressure and buoyancy; pump power and orifice flow — with unit-aware inputs.
Tool ·
Git helper
Searchable "how do I…" git recipes with safety notes, a .gitignore generator with a path tester, a Conventional Commits builder and linter, and .gitattributes and branch-name generators.
Tool ·
Grammar and parser playground
Write a PEG grammar, parse input with it live, and inspect the result tree, JSON, tokens, and rule cross-references — then download the generated parser. Or see one expression parsed under five precedence conventions — PEMDAS, implied multiplication, Python, C and Excel — as trees.
Tool ·
HTTP header analyser
Paste response headers from curl or DevTools to get a security grade, a line-by-line Content-Security-Policy and cookie audit, plain-English caching and CORS explanations, and a CSP builder.
Tool ·
HTTP reference
Searchable HTTP status codes, headers, and methods; a REST API design guide; a MIME type table; a CORS cheat sheet; and a Cache-Control explainer.
Tool ·
HTTP request client
A small Postman in the browser — collections, environments with {{variables}}, tests, and a collection runner; Postman, OpenAPI, and HAR import and export; status, timing, headers, and bodies; curl, fetch, or Python code.
Tool ·
Hashes and checksums
MD5, SHA-1, SHA-2, SHA-3, CRC-32, Adler-32, and xxHash for text or files of any size, plus HMAC and PBKDF2 — with hash comparison.
Tool ·
IP subnet calculator
IPv4 and IPv6 CIDR maths — network, broadcast, usable range, masks, special ranges, splitting, summarising, ranges to CIDRs, and reverse-DNS names.
Tool ·
Image optimiser and converter
Resize, crop, rotate, and re-encode images as JPEG, PNG, WebP, or AVIF with a before-and-after comparison; strip EXIF; extract a palette; and build favicon and app-icon sets.
Tool ·
JSON workbench
Validate, format, minify, sort, and repair JSON; browse and edit it as a tree; query with JSONPath; transform with JavaScript; and diff two documents.
Tool ·
JWT decoder and signer
Decode, inspect, verify, build, and sign JSON Web Tokens — HS, RS, PS, ES, and EdDSA — and generate test key pairs, all with WebCrypto.
Tool ·
Language sandbox
Write and run code in 29 languages — JavaScript, TypeScript, Python, Java, Kotlin, C, C++, Rust, Go, R, PHP, Perl, Ruby, Lua, OCaml, Fortran, Clojure, Scheme, Prolog, BQN, Forth, BASIC, SQLite, DuckDB, HTML, p5.js, GLSL, Brainfuck and Befunge — and share it as a link.
Tool ·
Latency numbers every programmer should know
Jeff Dean's and Peter Norvig's latency tables, Colin Scott's year-by-year model from 1990 to 2030, the famous squares diagram, a human-scale view, comparisons, back-of-the-envelope calculators, and AI-hardware latencies (HBM, NVLink, InfiniBand, CXL) with KV-cache hand-off and checkpoint estimates.
Tool ·
MQTT client
Connect to an MQTT broker over WebSockets, subscribe with wildcards, watch messages as a live log and topic tree, and publish text, JSON, or binary — for testing IoT devices and Home Assistant setups.
Tool ·
Markdown and AsciiDoc previewer
Live side-by-side preview of Markdown (GitHub-flavoured) and AsciiDoc, with a table of contents, word count, HTML export, and HTML → Markdown conversion.
Tool ·
Markdown résumé builder
Write your résumé in Markdown, see it typeset live in five themes on A4 or Letter, and print it to PDF or save it as HTML, plain text, Markdown, or JSON Resume.
Tool ·
Media toolbox (ffmpeg)
ffmpeg compiled to WebAssembly, in your browser — convert, trim, crop, resize, rotate, re-time and watermark video; make GIFs and animated WebP; extract audio; split video into frames or build video from images; join clips; or run any ffmpeg command.
Tool ·
Meeting planner
Line up several time zones on a 24-hour grid with working hours shaded, find when everyone overlaps, get warned about clock changes, share a slot as text or ISO 8601, and convert a time between zones.
Tool ·
Microcontroller timing calculator
Baud-rate register values with error for AVR, STM32, and ESP32 UARTs; timer prescaler and period solver; ESP32 LEDC PWM resolution; I²C pull-up sizing with an address directory; and SPI clock dividers.
Tool ·
Modbus and CAN bus workbench
Build and decode Modbus RTU, ASCII, and TCP frames, decode registers in every word order, draw CAN bit streams with stuff bits and CRC-15, calculate MCP2515, ESP32 TWAI, STM32, and SJA1000 bit timing, estimate bus load, and decode DBC signals, candump logs, OBD-II PIDs, and J1939 IDs.
Tool ·
My IP and connection
Your public IPv4 and IPv6 addresses, whether IPv6 works, the Cloudflare data centre and TLS version you reach, your network owner, WebRTC candidates, and browser facts.
Tool ·
OCR: text from images and PDFs
Read text from photos, screenshots, scans and PDFs with Tesseract compiled to WebAssembly — clean up the image (threshold, deskew, upscale), pick a region, see every word's confidence, and export text, hOCR, TSV or JSON.
Tool ·
OpenAPI explorer
Load any OpenAPI 3 or Swagger 2 description by URL, file, or paste; browse operations and schemas, fill in generated forms, send live requests, and check responses against the declared schemas.
Tool ·
PlatformIO project helper
Build, explain, and lint platformio.ini files — resolve extends, [env] inheritance, and ${…} interpolation per environment, pick boards with real IDs, and get the pio and Arduino CLI commands for each environment.
Tool ·
Programmer's calculator
Integer expressions with hex, binary, and octal; 8- to 128-bit words; signed or unsigned; bitwise operators, rotates, and a clickable bit grid; an n-bit overflow clock with signed and unsigned labels; and what n bits hold, with the KB versus KiB gap.
Tool ·
QR and barcode tool
Make QR codes for links, Wi-Fi, contacts, email, SMS, phone numbers, and locations — with colours, logos, PNG and SVG — and read QR codes and barcodes from images or your camera.
Tool ·
Regex railroad diagrams
Draw any JavaScript regular expression as a railroad diagram, explain it as a tree, link diagram and source by hover, and export SVG or PNG.
Tool ·
Regular expression tester
Test JavaScript regular expressions live — highlighted matches, capture groups, replace and split previews, a plain-English explanation, and a pattern library.
Tool ·
SQL formatter
Format SQL for 18 dialects — PostgreSQL, MySQL, SQLite, T-SQL, BigQuery, Snowflake, Spark and more — with keyword case, indent style, and minify.
Tool ·
SVG toolkit
Optimise SVGs with SVGO, convert them to PNG, data URIs, CSS backgrounds, and React/JSX components, and combine icons into a <symbol> sprite.
Tool ·
Sensor register decoder
Turn raw I2C register bytes from BME280/BMP280, MPU-6050, INA219, ADS1115, SHT3x, DS3231, and DS18B20 into calibrated readings using the datasheet formulas, and build the configuration registers and I2C transactions to set them up.
Tool ·
Serial monitor and ESP flasher
A Web Serial terminal and live plotter for Arduino, ESP32, ESP8266, and Pico boards, plus an ESP firmware flasher built on esptool-js — all in the browser, no drivers or IDE.
Tool ·
Speed and latency test
Measure download and upload speed, latency, jitter, and latency under load against Cloudflare's network — or time HTTP requests to any site.
Tool ·
Text diff
Compare two texts by line, word, or character — side by side, inline, or as a unified patch — with whitespace and case options.
Tool ·
Text toolkit
Case conversion, line sorting and de-duplication, counts, find and replace, escaping for JSON, HTML, SQL, CSV, and shell, slugs, lorem ipsum, and a whitespace visualiser.
Tool ·
Thermal design
Junction temperature through θJC, interface, and heatsink; MOSFET, regulator, resistor, and diode losses with temperature feedback; finned heatsink performance in still or moving air; PCB copper as a heatsink; pulsed heating from Foster networks; airflow for enclosures; and chip heat flux with the coolant flow liquid cooling needs.
Tool ·
Time converter
Convert epoch seconds, milliseconds, microseconds, and nanoseconds to and from ISO 8601, RFC 2822, and other formats in any time zone, with a world clock and date arithmetic.
Article ·
Transparent file encryption in the Linux kernel
How I built CryptoFS, a stacked Linux filesystem that encrypts every file with its own AES-256-GCM key at the VFS layer — authorised processes see plaintext, everyone else sees ciphertext — and what it taught me about nonces.
Tool ·
URL encoder, decoder, and parser
Percent-encode and decode text four ways, untangle double-encoded strings, and pull a URL apart into editable parts and query parameters.
Tool ·
UUIDs, IDs, and random values
Generate and decode UUIDs (v1, v4, v5, v7), ULIDs, KSUIDs, nanoids, and Snowflake ids; make strong passwords and passphrases; random bytes, integers, and picks.
Tool ·
Unicode inspector
See every character's code point, name, category, script, UTF-8 and UTF-16 bytes, and escapes; split text into graphemes; compare NFC/NFD/NFKC/NFKD; find and strip invisible, bidi, and look-alike characters; and search characters by name.
Tool ·
Unit converter
Convert between hundreds of units — length to radiation dose — or type a query like “3.5 ft·lbf to N·m” and let dimensional analysis do the rest.
Tool ·
Unix permissions calculator
Convert between the permission checkboxes, octal (755), and symbolic (rwxr-xr-x) modes — with setuid, setgid, sticky, umask, ls -l parsing, and ready-to-run chmod commands.
Tool ·
User agent and IP inspector
Parse any User-Agent string into browser, engine, OS, and device, read your browser's client hints, and convert IPv4/IPv6 addresses between every common notation.
Tool ·
Version ranges and SemVer
Test version ranges in npm, Cargo, Python, and Maven syntax, inspect and bump SemVer versions, sort version lists, and get the next release from Conventional Commits.
Tool ·
WebAssembly explorer
Write WebAssembly text and run it in the page, inspect any .wasm file — sections, functions, sizes, imports, exports, data, an annotated hex dump and a full disassembly — and learn how the format works.
Tool ·
WebSocket tester
Connect to any WebSocket, send text, JSON, or binary frames, and watch a timestamped log with sizes, echo round-trip times, filtering, and export.
Article ·
Writing 3DO games in 2026: a 1993 console, a 1990s compiler, and a debuggable emulator
How I built a modern dev kit for the 3DO Interactive Multiplayer — Norcroft ARM C in Docker, a patched Opera emulator with a GDB server and a JSON control port, and an MCP server — and used it to ship a demo and 21 games.
Tool ·
XML workbench
Check XML is well-formed (with line and column), format or minify it, browse it as a tree, run XPath 1.0 queries with namespaces, convert to and from JSON, and preview XSLT transforms.
Playground ·
A JavaScript playground
Edit the code and run it in your browser — a quick demonstration of the site's playgrounds.
Project update ·
First build of the new site
in gitwebsite
The first end-to-end build — content, areas, templates, and publishing to GitHub Pages.
Project ·
gitwebsite
The app that builds and publishes this site — a Rust core with a CLI, a REST API, an MCP server for AI assistants, and a desktop app.
Project ·
Chief
A multi-project Claude Code orchestrator for macOS: it tracks the backlog of every project I work in and hands the next task to the right Claude session.
Project ·
Mac Transformer
A macOS menu-bar app that turns documents into PDF, plain text, spoken audio, and AI summaries through a pluggable pipeline — and can publish the results to Books, Music, Reading List, Obsidian, or Notion.
Project ·
event_watch
A low-latency pub/sub service: back-end services publish state changes, and clients subscribe over WebSocket or long-poll to receive events plus a server-maintained snapshot of each object.
Project ·
CityMap
A TOGAF-inspired "city map" editor for enterprise architecture — districts, neighbourhoods, buildings, and rooms on a pan-and-zoom canvas, editable by people and by AI through REST and MCP.
Project ·
warehouse-sync
Metadata-driven incremental replication from PostgreSQL into Apache Iceberg — the database counterpart to my structured-logger project.
Project ·
claude-session-analyzer (claude-trace)
A native analyzer for Claude Code session logs: it ingests every session into SQLite and shows how much reading, searching, and sub-agent work happened before code was written.
Article ·
Building a full social network from scratch: feed, friends, groups, DMs, search
What it takes to build a complete social network as one coherent app — feed ranking, social graph, search, messaging — with Spring Boot, React, PostgreSQL, OpenSearch, and a Rust graph cache.
Article ·
ViewScene: a desktop Luke alternative for inspecting Lucene indexes
A standalone JavaFX desktop app for inspecting and diagnosing Lucene indexes — documents, analyzers, and vector fields — as a desktop alternative to Luke.
Article ·
Building SolarSage: a local-first solar monitoring tool
A local-first monitor for an off-grid 15 kW solar system that forecasts surplus power from the weather and tells you when to run heavy loads.
Project ·
ELSA: entity-level sentiment
A Java library that finds the people, organisations, places, and products in text and works out the sentiment expressed toward each — and who holds it — using a layered ONNX model pipeline.
Project ·
Event Conduit (webhook_infra)
An outbound event-delivery platform: it consumes internal events from Kafka, matches them to subscribers, translates them to CloudEvents, and delivers them as signed webhook batches or WebSocket streams.
Project ·
Enterprise social platform
A full-featured social network — feeds, profiles, friends, groups, pages, messages, search, and an admin dashboard — built on Spring Boot, React, PostgreSQL, OpenSearch, and my Rust graph cache.
Project ·
Code Graph Search
A multi-language code analysis platform that turns repositories into a searchable graph of classes, functions, calls, and dependencies — with a REST API, a web UI, and an MCP server for AI assistants.
Project ·
Amiga DevBench (amiga_mcp)
A cross-development environment that connects a modern machine to an emulated or real Amiga over serial — live debugging, memory inspection, remote execution, and MCP tools so Claude Code can build and drive Amiga software.
Project ·
CryptoFS
A Linux kernel module that encrypts files transparently at the VFS layer with per-file AES-256-GCM keys — authorised processes see plaintext, everyone else sees ciphertext.
Project ·
AOEE: a social-graph cache
A TAO-inspired in-memory relationship cache for social-graph queries, with compressed posting lists and fast set operations for friend-of-friend queries and feeds.
Project ·
Structured logger
A metadata-driven structured logging framework: it generates type-safe loggers for Java and Python from JSON definitions and lands every log line in Apache Iceberg tables you can query with SQL.
Project ·
Little Log Peep (local_log_search)
A local log search and analysis tool — Splunk-like search, facets, SQL, charts, and exports running entirely on your own machine, built on Java, Lucene, and Spring Boot.
Project ·
Distributed web crawler
A horizontally scalable web crawler in Java: Kafka distributes URLs across crawler processes, Cassandra keeps the metadata, and S3 or MinIO stores the content.
Project ·
Kafka broker discovery
A Java library and discovery server that let Kafka producers and consumers look up brokers and security settings by topic, then talk to Kafka directly.
Project ·
REST Router
A lightweight reactive API gateway on Spring WebFlux with identity-aware rate limiting, pluggable auth, asynchronous access logging, and a dynamic service registry.
Project ·
Vaultrix (securevault)
A secrets-management server in Go with encrypted storage, path-based policies, versioned secrets, audit logging, leader-follower replication, and client libraries for Go, Java, Python, and Rust.