I like building things from the ground up and then trying to break them.
A database that survives being killed mid-write, an editor that merges offline edits,
tools that catch bad code before it ships, and a real-time platform for traders, still in beta, where I’m the sole developer.
// selected work · demos are simulations, numbers are real
Work
click a project to open it
01
Traders Room
beta · not yet released · sole developer · Python · JavaScript · Linux
A real-time analytics platform for futures and options traders, currently in beta and not yet released to the public. I'm its sole developer: the market-data
engine, the models, the website, the design and the servers are all mine. The workspace below is a simulation of
the interface, with resizable windows, live charts and 25 colour themes. Try the swatches.
workspace · simulated data
What the engine does
Streams the live options market for several index and futures markets, every trade and quote, all day long.
Sorts the flow as it prints and picks out the large orders within seconds.
Rebuilds options positioning across every strike and expiry, over and over, and turns it into key price levels.
Translates those levels between index, ETF and futures prices so they line up on the chart a trader actually uses.
Works out expected ranges and the odds of price reaching each level, updated through the session.
Runs a nightly pipeline that builds the next day’s levels after the close, with fallbacks when a data source fails.
Writes an AI morning brief before the open, grounded in the platform’s own numbers.
Pushes it all to the browser live: heatmaps, timelines, 3D surfaces and oscillators. Markets people are watching update faster; the rest slow down to save the server.
Things I pulled off
50,000+market messages a second taken in at the open
~60 msfrom a futures trade printing to it reaching the site
460 → 20 mstick-to-heatmap delay after I tracked down a scheduling bottleneck
1,500simulated viewers at once: 0 errors, 0 dropped streams
25 → 6 msserver time per page after profiling the hot paths
200,000random inputs used to prove a rewritten page pipeline gave identical output before it shipped
21 sfinal cut-over when I moved the whole platform to a new host
216members moved to a new verification bot without anyone re-verifying
25 themes
live streaming charts
6 ms server time per page
test resultsload test · 1,500 viewers · 0 errors
Load test on the live server: 1,500 simulated viewers at once, 0 errors, 0 dropped live streams, server CPU 9% on average
Profiling: main pages went from 25 ms to about 6 ms of server time
Throughput: dashboard page 148 → 230 requests/s after the fixes (20 parallel clients)
Market data: 50,000+ messages a second at the open; futures trades reach the site about 60 ms after they print
A SQL database written from scratch: its own storage pages, B+tree indexes and a write-ahead log.
I wrote a test that kills it in the middle of writing, over and over, to prove saved data never goes missing.
basalt · simulated
547 times killed mid-write
0 of 31,015 saved commits lost
69 tests
test results69 / 69 passed · 547 kills · 0 lost
69 / 69 unit and integration tests passed (xUnit)
Crash test: worker killed 547 times mid-write, 31,015 acknowledged commits checked afterwards, 0 lost
Damaged logs: torn and corrupted write-ahead-log tails recover cleanly (unit tests cut and damage the log)
Speed (100,000 rows, fsync on every commit): bulk insert 106–124k rows/s, SQLite 249–255k · point lookup 61–74k/s
Covers a killed process, not a power cut. SQLite is still faster at heavy work; it’s there for context.
Reviews pull requests for security bugs. Rules find the problems; an AI is only allowed to explain
findings the rules already confirmed. Anything it makes up gets dropped before it's posted.
pull request #42 · simulated
95% of planted bugs caught
0 false alarms
195 tests
test results195 / 195 passed · 0 false alarms
195 / 195 tests passed, no network needed
Benchmark: 86 of 91 planted bugs found across 11 rules · precision 1.00 · recall 0.95 · F1 0.97
Safe look-alikes: 38 / 38 code samples that only look risky produced no findings
AI guard: a fake model invented 11 bad comments; all 11 dropped, the real one kept
I wrote the test set myself, so real-world numbers will be lower. The 5 misses are listed in the repo.
A shared editor that keeps working offline. Two people can edit the same text without a connection,
and when they reconnect both copies end up identical, without anyone losing a word.
two devices · simulated
2.7 KB to resync, not 509 KB
5,000 random cases per property
51 tests
test results51 / 51 passed · always converges
51 / 51 tests passed
Property tests: 11 properties × 5,000 random cases each (concurrent edits, messages reordered, duplicated, delayed); every copy ended identical
Tests can fail: I broke the tie-break rule on purpose and 6 tests caught it
Reconnect after 200 offline edits: 2.7 KB uploaded instead of a 509.2 KB snapshot
Typing speed: 480k–742k edits a second; a 100k-character document stored as 25 items
Watches new packages as they're published to PyPI and npm and flags the ones that look like malware.
It only reads the code. Nothing it downloads is ever run.
live feed · simulated, made-up names
static analysis only
6 detectors
sealed quarantine
test results633 passed · never runs package code
633 tests passed (1 skipped: needs symlink rights on Windows)
No-execution tests: exec, eval, subprocess, process spawning and loaders are trapped during a full scan, and none fire; a second test reads the tool’s own source and fails if any of them appear
Hostile archives: path traversal, links, zip bombs, header memory bombs, and duplicate, case-only or Windows short-name tricks that hide a file; all blocked or caught
Independent review: a second pass found 7 ways to hide a file or exhaust memory; all fixed, each with a test that fails on the old code
Benchmark (113 harmless test packages): precision 0.91 · recall 0.85 · F1 0.88
Live run on the real PyPI and npm feeds: about 170 new releases scanned; false flags went from 6 to 1 after fixing the rules (different releases each run, so a direction, not a controlled test)
Self-made benchmark. Static checks can be dodged by a determined attacker, and the README lists where it’s weak.
Two-person video calls and remote help: screen sharing, drawing on the other person's screen and
remote control the host has to approve. Peer-to-peer and encrypted. Private, not publicly released.
host + helper · simulated
P2P encrypted calls
60 fps watch-together
1 key kills control
test resultssmoke test 3 / 3 passed
Smoke test: two app instances on one PC: connect, screen share and remote-control mapping, 3 / 3 passed
Windows build tested. The macOS build is written but hasn’t been tested on a Mac yet.
07
Clipper
Python · ffmpeg · speech-to-text · local AI
Watches live streams, notices when something big happens, and turns it into a vertical clip with captions,
ready for TikTok, Shorts and Reels. It's built to be picky: most moments get thrown away, and only the best few reach my phone.
live stream · simulated
How it works
Listens. It follows live chat on Twitch and YouTube and tracks how fast it's moving compared with that channel's normal pace. It also watches for viewers clipping the same moment.
Spots a moment. A sudden rush of chat, or several people clipping within seconds of each other, means something happened. Each moment gets an evidence score.
Grabs the video. My own stream downloader knows the real clock time of every video segment, so it cuts exactly the right seconds instead of re-downloading the whole stream.
Picks the best. Two gates rank each moment against that channel's recent ones, with limits per hour and per streamer, so one noisy chat can't flood the queue.
Edits it. It crops to vertical, finds the facecam and lays it out, spots cutscenes, transcribes speech on the PC and burns in captions that never run across a cut. A safety check holds back anything not fit to post.
Second opinion. A small AI model running locally on the PC judges whether the clip is worth posting and writes the hook, using only what actually happened. It can sink a clip but never invent a moment.
Ships it. Hardware video encoding, then a phone alert with Post now and Stop buttons, then auto-posting, but only for streamers it's allowed to post.
Numbers
4.6 h → 24 sstream audio fetched by my own downloader instead of the slow standard tool
76 → ≤4clips per 3 hours before vs after the picker: fewer, better
65 → 4moments found vs top picks on a real backfill
0cloud AI calls: the editor model runs on the PC
test resultsreal streams · 65 moments → 4 picks
Live run on real streams: candidates scored, ranked and held; only top picks reached the phone
Downloader: 4.6 hours of stream audio in 24 seconds, timed to the exact segment
Speech model: tested a bigger one; 3× slower and barely better, so I kept the small one
AI editor: good hooks on 2 of 4 test clips and a weak judge of what goes viral, so it can only lower a score, never raise one
Built in a day for a game launch. Posting to TikTok and YouTube needs each platform to approve the app first.
08
Trading tools
C# · .NET · Python
Tools that run inside desktop trading platforms in real time: 20+ chart indicators covering order flow,
volume profiles, key zones and session levels, plus a NinjaTrader 8 add-on that copies trades from one account to others.
I check them against Python versions of the same logic, so a chart bug can’t hide behind “it looks right”.
20+ real-time indicators
2 desktop platforms
parity checked against Python
test resultsindicator matches its Python twin
Parity check: the order-flow divergence indicator matched its Python version on 236 / 236 signals
Speed budget: a 5-year key-level indicator runs in about 20 microseconds per bar
Indicators are research tools. Most of the strategy studies behind them found no edge, and the Research tab says so.
09
Overfit Lab
Python · numpy · scipy · statistics
Search through enough strategy variants and one will look brilliant by pure chance. Overfit Lab takes the
whole family you tried and asks whether the winner would survive that search. It implements the standard tests from the
research papers from scratch and writes a self-contained HTML report.
overfit demo · simulated view of a real run
How it works
Takes the whole family. It needs every variant you tried, not just the winner, because the number of tries is what makes luck look like skill.
Deflates the winner. The Deflated Sharpe Ratio asks how good the best of N random strategies would look, then checks whether yours beats that bar.
Splits the history many ways. Probability of Backtest Overfitting checks how often the in-sample winner falls to the bottom half out of sample.
Bootstraps the family. White’s Reality Check, Hansen’s SPA and Romano-Wolf resample the returns thousands of times to see whether any variant beats what luck alone would produce.
Placebos and walk-forward. Shuffled signals and true out-of-sample stretches act as controls.
One verdict. Every check goes into one report, with charts drawn by its own SVG code.
Numbers
100% → ~3%noise strategies that looked significant: a naive test vs the lab’s bootstrap tests (best of 100)
~80%of hidden real edges (Sharpe 2 among 100 variants) still found
0.9004the Deflated Sharpe paper’s worked example, reproduced to 4 decimals
1,700synthetic strategy families in the calibration study
test results201 passed · paper values matched
201 tests passed, including fast-vs-slow reference implementations of every method
Reference checks: 10 values from the original papers (Deflated Sharpe, minimum backtest length, Benjamini-Hochberg) reproduced; checked against the papers themselves by an independent review
Calibration: on pure noise the bootstrap tests flag 3–6% (target 5%); a naive test flags 40% at 10 variants and 100% at 100
Bug caught by its own calibration: a scaling flaw doubled false alarms (11–14% vs 5%) at 1,000 variants; fixed, with a regression test
Power: finds a planted Sharpe-2 edge about 80% of the time; the strict Deflated Sharpe check alone finds it only 38%
Synthetic data only. Small edges are hard to detect at this sample size, and the bootstrap assumes returns are stationary. The README lists every weakness.
A small scripting language with its own syntax. Code goes through a hand-written lexer and parser, gets compiled
to bytecode, and runs on a stack-based virtual machine with closures. A second, simpler interpreter runs the same programs
so a fuzzer can check the two always agree. You can try it in the browser.
source → bytecode → VM · real bytecode
How it works
Lexer. Turns source text into tokens, including string interpolation like "{name}!".
Pratt parser. Builds a syntax tree using operator binding power, with errors that point at the exact line and column.
Resolver. Works out every variable’s scope and catches mistakes like using a name before it exists.
Compiler. Folds constants, then emits compact bytecode from 56 opcodes.
Virtual machine. A stack machine with call frames. Variables a closure captures move to a heap box, and every loop iteration gets a fresh one.
Second opinion. A separate tree-walking interpreter runs the same program, and a fuzzer writes random programs to compare the two.
Numbers
~79,000random programs run on both engines, 0 disagreements
10 / 11deliberately planted bugs caught by the fuzzer
2–4×faster on the bytecode VM than the tree-walker
80 KBoffline playground with a step-through debugger
test results150 passed · 0 disagreements
150 tests passed, including 38 error-message snapshots and 11 example programs on all three engine setups
Differential fuzzing: about 79,000 random programs, each run on the VM (with and without optimisation) and on the tree-walker: 0 disagreements
Mutation check: the fuzzer caught 10 of 11 planted bugs; the one it misses lives in code both engines share, and a separate test catches it
Independent review: found and fixed 8 edge-case bugs (huge ranges, strings past the JavaScript limit, very deep nesting), each with a test
Original design: checked against the best-known textbook interpreter; no shared code or identifiers
Speed was measured on a busy laptop. The fuzzer can’t see bugs in code both engines share, so those rely on unit tests.
A database spread across several servers that keeps agreeing on the data even when servers crash, the network
splits or messages get lost. It uses the Raft consensus algorithm, written from scratch. A deterministic simulator throws
failures at it, and a checker proves every client saw a consistent history.
3-server cluster · simulated
How it works
Elections. Servers vote for a leader. A server only votes for one whose log is at least as complete as its own.
Replication. The leader appends each write to its log and copies it to the others. Once a majority have it on disk, it is committed.
Safe reads. Before answering a read, the leader checks with a majority that it is still the leader, so nobody reads stale data.
Exactly once. Clients tag requests, so a retried write is never applied twice.
Chaos simulator. A seeded, repeatable world where the network drops, delays, duplicates and splits messages, and servers crash and lose unsaved writes.
Linearizability checker. Searches every possible ordering of what clients saw and fails the run if no correct order exists.
Numbers
16,000chaos runs (10,000 + 6,000 fresh) with 0 consistency violations
150,000failures that actually took effect, over 2.7 million client operations
5 / 5deliberately planted bugs caught, including the Raft paper’s Figure 8 error
~0.3 smedian time to elect a new leader after the old one is killed
test results107 passed · 0 violations
107 tests passed, including Raft edge cases straight from the paper
Chaos campaign: 10,000 seeds plus 6,000 fresh ones, 22 + 13 simulated hours, 0 linearizability or Raft-invariant violations
Found a real bug on its own: a restarted leader could serve a stale read during a network split; fixed and pinned with a test
Bug injection: 5 planted bugs all caught; the subtle Figure 8 commit bug shows up in about 1 of 1,400 to 2,200 runs
Real cluster: 3 server processes over TCP, every recorded history checked linearizable
Speed on a laptop: about 4,500–5,700 saved writes/s and 20,000–39,000 reads/s with 32 clients
Servers can’t be added or removed while running, and the real network layer isn’t chaos-tested, only the simulator. The README lists every limit.
A database built for time-stamped numbers like market ticks and sensor readings. It compresses them with
bit-level encoding, stores them crash-safe, and answers range and candle (OHLC) queries fast by skipping data it
doesn’t need to unpack.
ticks → bits → query · simulated
How it works
Write-ahead log. Every write is checksummed and saved to disk before it’s acknowledged.
Timestamps. Stored as the change in the gap between points (delta-of-delta), or plain deltas when that’s smaller. It picks per block.
Values. Each float is XORed with the previous one and only the changed bits are kept, the method from Facebook’s Gorilla paper.
Segments. Full blocks become immutable files, partitioned by day and committed through one manifest file.
Summaries. Every block remembers its min, max, sum and count, so big aggregates skip unpacking whole blocks.
Numbers
3.3 Bper tick price, about 4.9× smaller than raw
13×smaller for regular sensor counters
~300×faster daily candles over a month thanks to block summaries
450random kills mid-write with 0 saved points lost
test results129 passed · 0 lost
129 tests passed: bit-exact codec round-trips (NaN, ±Inf, -0.0, extreme jumps), differential tests against a reference model, HTTP and parser fuzzing
Crash harness: writer killed 300 + 150 times at random moments (landing in writes, flushes and compactions): 0 acknowledged writes lost, 0 partial, over 440M point checks
Log damage: the write-ahead log cut at every byte offset and zero-filled tails all recover cleanly
Independent review: found and fixed a recovery bug (zero-filled log tail) and a date-overflow bug, each with a test
Compression (1 day per data type): tick prices 3.27 B/pt, bid/ask 3.48, sizes 3.70, sensor counter 1.23; random floats barely compress, as expected
Tested by killing the process, not by cutting power. Timings came from a busy laptop; the ratios held steady across runs.
// quantitative research · real results, setups kept private
Research
I test trading ideas the way I test code. Build clean data, decide the test before running it, compare every
result against random controls, and keep a sealed holdout the idea never sees. Most ideas fail, and that's what this
process is for. Here are all of them, failures included.
Datasets I built
// lab · things I built for fun
Lab
Little things I made because I wanted to see if I could. Everything is hand-written, no libraries.
Poke at them: most react to your mouse, a few to your keyboard. Hit enlarge if you want more room.
01
Particle type
About two thousand dots pretending to be a word. Drag your cursor through them and they scatter, then drift back. Click and they spell something else.
canvas 2D · spring physics · no libraries
02
Gravity well
A grid that sags toward your cursor like it’s heavy. Click anywhere and a ripple rolls out from that spot.
canvas 2D · field warping · no libraries
03
Holo ID card
One of those shiny holographic cards, but on a screen. Tilt it with your mouse and the foil catches the light.
CSS 3D · blend modes · no libraries
04
Flow field
Thousands of tiny particles drifting on a current that never sits still. Move through it to stir things up, and hold the mouse down to flip the swirl.
canvas 2D · vector field · no libraries
05
Halftone tree
The tree from my home page, redrawn as newspaper-style dots. Your cursor clears a hole through it, and a click sends a ripple across.
canvas 2D · image sampling · no libraries
06
Command palette
The Ctrl+K search box you get in apps like VS Code or Slack. Start typing and it guesses what you mean. It works for real here: try “acid” to change the site’s colours.
vanilla JS · fuzzy matching · no libraries
Interface components
07
Spotlight cards
Six cards lit by one light. Move across them and the glow follows you from card to card, like a torch.
CSS custom properties · radial masks · no libraries
08
Kanban with FLIP
A to-do board. Drag a card to another column and the others slide out of the way. Leave it alone and it tidies itself up.
pointer events · FLIP animation · no libraries
09
Split-flap board
The clicking departures board from an old train station. Every letter flips through the alphabet until it lands on the right one.
DOM · staggered flips · no libraries
10
Toast stack
The little pop-ups apps use to tell you something happened. They stack up, fan out when you hover, and you can swipe one away.
pointer swipe · CSS transitions · no libraries
11
Rotary knob
A volume knob. Drag it up or down, scroll on it, or use the arrow keys. Give it a flick and it keeps turning for a moment.
SVG · momentum · ARIA slider · no libraries
12
Liquid tabs
Tab switches where the highlight stretches like a drop of water as it moves, then wobbles into place.
Open to work. I’m looking for freelance, part-time or full-time developer work. Remote is fine. Email me or message me on Discord.
Summary
Self-taught. I’m the sole developer of Traders Room, a real-time analytics platform for futures and options traders that is in beta and not yet released. I built all of it, from the data pipelines and pricing models down to the Linux servers it runs on. I build things from scratch to learn how they work, then try to break them. I care about speed and build with security in mind from day one.
Experience
Traders RoomCo-Owner & Sole Developerbeta · not yet released
Built the whole platform in Python and JavaScript: live dashboards, interactive charts, 3D data views, accounts and sign-in (Discord, Google), a members’ academy, a trading journal and an admin panel.
Built the pipelines that pull options and futures data and publish it nightly and live through the trading day, and wrote the options and volatility models behind its levels, expected ranges and probabilities.
Profiled the stack and fixed what was actually slow. Main pages went from 25 ms to about 6 ms of server time, memory use roughly halved, and cutting repeated TLS handshakes freed up most of the web server’s CPU.
Rewrote the live market-data reader to keep up with about 17,500 messages a second, then wrote a load-testing tool that replays real user sessions. It handled 200 simulated users at once with zero errors.
Locked down the app and servers: server-side login and role checks, secure cookies, CSP, TLS, key-only SSH and services that run with only the access they need. Then moved everything to a new host with daily backups.
Set up and ran communities of several hundred members, from roles, permissions and onboarding to handling reports and disputes, and automated the repetitive moderation work.
Wrote a Python bot that verifies members, hands out roles and re-checks everyone every 12 hours, removing access with a DM explaining why.
Linked Discord roles to website sign-in and moved all 216 verified members to the new bot with no re-verifying.
Raft-replicated key-value store with a deterministic chaos simulator and a linearizability checker: 16,000 fault-injected runs with 0 consistency violations, and all 5 planted bugs caught.
Scripting language with a Pratt parser, bytecode compiler, stack VM and browser playground. About 79,000 fuzzed programs matched a second interpreter with 0 disagreements.
Time-series database with Gorilla-style compression (3.3 bytes per tick, 4.9x smaller) and block summaries that answer month-long candle queries about 300x faster.
Pull-request security reviewer where rules find the bugs and an LLM may only explain confirmed findings. 95% of planted bugs caught, 0 false alarms on my test set.
Separates real backtest edges from luck (Deflated Sharpe, PBO, SPA, Romano-Wolf from the papers). On pure noise it flags 3 to 6%; a naive test flags 100%.
Options model reverse-engineeringPython
Rebuilt how two commercial analytics platforms calculate their options levels, from scratch with licensed data. My Greeks matched a reference source to within 0.1%.
DuetElectron, WebRTC · private, not publicly released
Encrypted peer-to-peer video calls and remote help: screen sharing, drawing on the other screen and host-approved remote control with a panic hotkey.
Quant researchPython, C#
51 studies on 15 years of tick data with out-of-sample, placebo and holdout tests, and 20+ real-time indicators. Most ideas failed, and I wrote up every one.