Your AI spend across every account, on your phone. UsageLedger pulls live usage from Command Code and Cursor — and nothing leaves the device.
Problem
AI usage is scattered across platforms and accounts. Checking where your limits stand means opening a desktop app or dashboard for each one, one at a time.
What I built
A Flutter app: add each account once with its API key, and UsageLedger pulls live usage directly from every platform. It aggregates across accounts, shows exact used/cap and reset times for plan windows (Command Code's 5-hour/weekly/monthly, Cursor's included-usage splits), breaks tokens down per model with cost, and accumulates refresh snapshots into a cost-over-time chart. Tokens are stored encrypted on-device — no server, no cloud. Ships as a signed APK on GitHub Releases (v0.3.0).
Highlights
+Multi-platform, multi-account — any number of accounts per platform
+Live plan limits with exact used/cap and reset times
+Per-model token breakdowns (input/output/cache) with cost
+Cost history built from refresh snapshots
+Tokens encrypted on-device; only the platform API calls leave the phone
Empire at War is single-core bound, so I'm rebuilding the engine core to run across all of them — deterministic, mod-compatible, proven by tests.
Problem
The 2024 64-bit remaster still runs its simulation on one thread — measured live at 40–75% of a single core while the rest sit idle. Big battles crawl, and every mod inherits it.
What I built
A deterministic, multithreaded reimplementation of the EAW simulation core running on real game data: 3D pathfinding, two-phase parallel combat, events/timers, taskforces, planets, perception-driven AI, and the documented Lua mod surface. 16 test suites stay green, and sim_tool --compare proves identical outcomes at any worker count — 2.39x speedup at 1,520 units/side. The strategy leans on documented formats (.meg archives, Lua/XML surface) plus targeted binary analysis, with full mod compatibility (Thrawn's Revenge, EAW Remake) as a hard requirement. Patch DLL first, full engine later.
Highlights
+Deterministic at any worker count — proven by sim_tool --compare
+Two-phase parallel combat and 3D pathfinding on real game data
+2.39x speedup at 1,520 units/side
+Perception-driven AI and the documented Lua mod surface
York's tools don't talk to each other, so we stuffed the useful bits into one dashboard: plans, courses, timetable, progress.
Problem
If you go to York you already know the mess: degree checklist in one tab, course catalogue in another, Visual Schedule Builder, a spreadsheet you swore you'd keep updated. None of it shares data.
What I built
We built one place for it. You import a checklist, plan term by term, browse sections, lay out a week, and track assignments and how close you are to graduating. I worked on it with five other people for EECS4314. It's Astro on the front, Express in the middle, Postgres underneath, and a couple of Python services that chew through checklists and the course dump. It's deployed for real: Docker on a VPS, Google login, the whole thing.
With Taziz Ahsan, Nabeela Ansari, Sarah Asghar, Thor Laski, and Jericho Marc Mendoza.
Highlights
+Checklist import so you don't type your degree in by hand
I got sick of six news tabs and a feed that never ends. This runs on my server, pulls RSS, and hands me a morning edition.
Problem
Every news app is ads, ranking, and infinite scroll. I wanted something that lives in my house, reads plain RSS, and then shuts up.
What I built
A FastAPI box polls feeds, dedupes stories, and files them into topics I set. The SvelteKit reader shows the last twelve hours as an edition. You finish it and you're done. Docker Compose to stand it up, ntfy if I want a ping at 7am, more than one account so it's not just me. Nothing leaves the machine.
Spin the planet, pick a year, watch the borders jump. Click a country and it tells you who was running it.
Problem
History maps are usually a PNG of 1812 or a Wikipedia infobox. I wanted the Google Earth thing, except the year is a slider.
What I built
It's a SvelteKit app on a MapLibre globe. Borders go from 1600 to now. The timeline usually steps a year at a time, then gets finer around wars so you're not skipping over 1914 in one tick. Click a country and you get flag, government, leader. I split the world into twenty region bundles so the data isn't one giant mess, and the client loads GeoJSON plus a SQLite file.
Highlights
+MapLibre 3D globe with satellite imagery
+Borders from 1600 through today
+Timeline that tightens around wars and crises
+Twenty curated region bundles, SQLite in the browser
Bannerlord's launcher is a Windows app. I got tired of wrestling it under Wine, so I wrote a Linux one.
Problem
On Linux, Mount & Blade II still expects the official launcher. That means Proton, mystery XML, and mods that don't load because a DLL is blocked.
What I built
Native Tauri app. It finds the game across Steam libraries, picks up Workshop mods, lets me drag load order around, auto-sorts from SubModule.xml, and clears the Proton flag on DLLs so they actually run.
Highlights
+Finds Steam libraries and Workshop folders on its own
+Drag-and-drop load order, saved to LauncherData.xml
A mech game in C where the thing you fight at the bottom of the shaft has been watching how you play.
Problem
Most roguelike bosses are a script with extra health. I wanted something that actually picks up your habits: when you dash, when you panic-swap an arm.
What I built
No engine. C11 and raylib. You build a frame in the garage, drop down a nine-node shaft, and between fights a tiny network copies your inputs. By the end you're fighting a version of yourself. Linux and Windows builds.
A 3D galaxy where every planet is a playable game. Fly through solar systems, click a planet, play — your saves follow you.
Problem
HTML game portals are flat grids of thumbnails. I wanted games to live somewhere worth exploring, and progress that survives the device you played on.
What I built
A Three.js galaxy you fly through: solar systems with unique stars (color and lighting per system), and every game sitting on its own procedurally-generated planet with rings, moons, atmospheres, or asteroid belts. Click a planet and the game loads. FastAPI backend keeps saves in the cloud so progress persists across devices, SvelteKit renders the frontend, and the whole thing deploys via Docker Compose or systemd.
Highlights
+Procedural planets with rings, moons, atmospheres, asteroid belts
Grand strategy prototype in Godot. You're not trying to win the war so much as not lose it too fast.
Problem
I didn't want another map-painter where you snowball. The pitch was managing decline (resources drying up, worlds slipping) and I needed the map and the turn loop to exist before I touched combat.
What I built
Phase 1 is in. Ten worlds on a solar map, four resources, factions, saves, next-turn income. Combat is the next chunk. It's Godot 4 and GDScript.
Early desktop app for running an Assetto Corsa league without a pile of spreadsheets.
Problem
League racing needs Steam accounts, a host, drivers, and somewhere to keep the season. Discord plus a Google sheet falls apart after two rounds.
What I built
Tauri + Svelte shell so far: Steam login, SQLite, host vs driver modes. Talking to AssettoServer is the next slice. It's early, and that's the honest status.
A calendar for a Discord group so we stop guessing who's free before we queue a raid.
Problem
Getting six people in a voice channel is still 'anyone free tonight?' in chat. Nobody wants to maintain a when2meet.
What I built
Next.js site, sign in with Discord, dump your free blocks, overlap turns into an event. There's a versioned REST API a bot can hit so you don't have to leave Discord. Postgres in Docker.
