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 where I’m the sole developer.
// selected work · demos are simulations, numbers are real
Work
click a project to open it
01
Traders Room
sole developer · Python · JavaScript · Linux
A real-time analytics platform for futures and options traders. 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.
// 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 · small interactive pieces, all built from scratch
Lab
Experiments in motion, physics and interface design. Everything here is hand-written with no libraries
and only runs while it’s on screen. Hover, click and drag them, or hit enlarge.
01
Particle type
Words built from about two thousand particles. Push them around with the cursor; click to morph into the next word.
canvas 2D · spring physics · no libraries
02
Gravity well
A mesh that bends around the cursor like space around a mass. Click to send a ripple through it.
canvas 2D · field warping · no libraries
03
Holo ID card
A 3D card whose foil and glare follow the light as you tilt it. Pure CSS 3D, with one script setting four variables.
CSS 3D · blend modes · no libraries
04
Flow field
Thousands of particles riding a current that keeps changing. Move through it to stir a whirlpool; hold the button to reverse it.
canvas 2D · vector field · no libraries
05
Halftone tree
The tree from the home page, rebuilt as halftone dots. The cursor hollows it out, clicks ripple through it.
canvas 2D · image sampling · no libraries
06
Command palette
A keyboard-first launcher with fuzzy search. It really drives this site: try “acid” to recolour everything, or “res” for the resume.
Self-taught. I designed, built and run Traders Room on my own, a real-time analytics platform for futures and
options traders, from the data pipelines and pricing models down to the Linux servers it runs on. I care a lot
about speed, and I build with security in mind from day one.
Experience
Traders RoomCo-Owner & Sole Developer
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, crunch it and publish it, nightly and live through the trading day. If a source goes down, the site falls back instead of breaking.
Wrote the options and volatility models behind the site’s daily levels, expected ranges and probability estimates.
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. The site served 200 people 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.
Ran communities of several hundred members, handling reports and disputes and keeping things friendly and on topic.
Wrote a Python bot that verifies members and hands out roles on its own. It re-checks everyone every 12 hours and removes access, with a DM explaining why, when someone no longer qualifies.
Hooked Discord roles into the website so members sign in with Discord and get exactly the features their role allows. Moved all 216 verified members to the new bot without anyone having to re-verify.
Set up servers from scratch, from roles and permissions to onboarding, and automated the repetitive moderation work so the team could spend its time on people.
Projects
Options model reverse-engineeringPython
Figured out how two commercial analytics platforms calculate their options levels, then rebuilt the models from scratch using licensed market data. My Greeks matched a reference source to within 0.1%.
DuetElectron, TypeScript, WebRTC · private, not publicly released
Two-person video calling and remote-help app for Windows and macOS: screen sharing, webcam, voice, chat, drawing on the other person’s screen, a 60 fps watch-together mode, and remote control the host has to approve.
Runs peer-to-peer and encrypted. Both people see a matching code that proves nobody is listening in, and a panic hotkey kills remote control instantly.
Market research and trading toolsPython, C#/.NET
Built futures datasets from 15 years of tick data and put 160+ strategies through out-of-sample and placebo tests.
Wrote 20+ real-time indicators in C# for a desktop trading platform, checked against Python versions, and a NinjaTrader 8 add-on that copies trades between accounts.