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.
Software engineering
Architecture, delivery, engineering practice, and the economics of building software.
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.
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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 ·
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
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.
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.
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 ·
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 ·
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 ·
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 ·
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 ·
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 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 ·
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 ·
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 ·
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 ·
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 ·
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.
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 ·
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.
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 ·
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 ·
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.
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.
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 ·
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 ·
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.