Aryan Malhotra

I play most of my games from bed, streaming the PC across the room rather than sitting at it, so Home Assistant, which is the open source home automation platform I run the apartment on, needed some way to wake the machine, start things on it and put it back to sleep without me getting up. This is the agent that does it. Windows tells it directly when a game process starts, so nothing sits there polling and it costs almost nothing while idle, and it finds my Steam library by reading Steam's own binary catalogue file, which took a while to work out.

Every feature is off until you switch it on. Commands arriving over the network get rejected if they contain shell metacharacters, so a malicious message cannot smuggle in a second command, credentials live in the Windows credential store and never touch a config file, and updates are signed, so a tampered or older build refuses to install itself. I wanted that settled early, since this thing listens on the network and launches programs on my behalf.

Two releases shipped a download progress bar that lied, and I pulled both. Steam quietly shrinks its own total when you resume a download, so a download that was 68% finished reported 13%, and I had only ever tested against fresh installs where that never happens. The number now comes off a channel the Steam client itself uses to report to other devices, which gives the true totals, and nothing extra runs on the gaming PC to get it.

The Home Assistant half is a separate integration that models the PC as seven power states, because a machine that is booting is neither on nor off, and for those thirty seconds everything watching it does something stupid. It checks the machine is alive two independent ways, so a PC that answers the network but has no agent running is still distinguishable from one that is genuinely off, and it waits for three missed replies before believing anything, since one dropped reply under load is not a shutdown and a state that flickers will fire every automation watching it. I found that out the annoying way.

I run my motherboard's line out into a FIFINE SC3 desk mixer, mainly because it means the line-in fader works as a hardware volume knob, which is easily the most useful thing on my desk. The catch is that line in also gets summed into the microphone the mixer sends back to the computer, so everyone on the call just hears themselves back. FIFINE's own V22 update says this is fixed, and since it closes that loop and leaves the analog path alone, that is exactly what I wanted.

The problem is that the routing lives inside the firmware, and the firmware is encrypted, and there is no public tooling at all for the audio chip this thing uses. So I left the encryption alone for a while and went looking at everyone else's firmware, collecting every image I could find built on the same chip. 81 of the 87 I ended up with ship completely unencrypted, because encryption is a per-vendor option and most vendors just leave it off, and once you have the same code in both encrypted and plain form you can work the cipher backwards from the pair. Two of those 87 cost me a weekend before I worked out they were a different revision.

All 315,654 words of the code come out that way, with nothing left unsolved, which I honestly did not expect to get to.

Then the goal changed on me. The mixer has four physical faders and the firmware only tells the computer about one of them, and I had been meaning to build a knob box for a per-application volume mixer for months, so it was slightly ridiculous to be sitting in front of four faders that were already wired up and just never sent anywhere. The patch exposes all four, it is flashed and running on my desk right now, and the repository ships the analysis tooling only, no firmware.

Live Activities are those cards that sit on your lock screen and update themselves while a flight or a delivery is in progress. Apple hands them to any app with a push certificate, so I could never see a reason my washing machine should not have one. Four of them run on my lock screen now: washer, dryer, vacuum, and the gaming PC.

My home server pushes them straight to the phone through Apple's notification service, so a card just appears on the lock screen without the app ever being opened, and a custom piece of software I wrote for the server keeps track of which cards are live and makes sure an old one is torn down before a new one goes up, so they cannot stack.

For about three weeks the washer card would appear and then vanish a second later. I blamed the token, then the lifecycle, then the app itself, and it turned out that the second message I was sending to wake the card was tearing down the one that had only just been created. Sending the first message alone is completely stable, and the second is now only a fallback for when the app has been force quit.

The gaming PC card is a gauge, where the GPU, the processor, the room temperature and the wall power each draw their bar and their warning thresholds from the same numbers that pick the colour. I set those thresholds off 30 days of recorded history, because the first version spent 62% of my gaming time showing orange at temperatures that are actually cold for this card, and the room row never once left its first band in a month, so two of the three rows were carrying no information at all while the third one just shouted.

I got curious about why the 2.4 GHz dongle mode on my GameSir Cyclone 2 felt worse than Bluetooth, which is backwards, since the dongle is meant to be the fast one. So I pulled the firmware off it and read through the disassembly until I found the code that decides how often the pad tells the computer where the sticks are. One byte was holding the dongle mode down to 166 updates a second while the same radio managed 480 in the other mode. Changing that byte took it to 230.

The first byte I patched did nothing at all. I had found something that looked exactly like the limiter, flashed it, measured, and got back exactly the number I started with, which was deflating. The real one was a divide-by-four two functions away that only the dongle path ever reaches.

A Raspberry Pi sitting in between then pretends to be an Xbox wireless receiver, so Windows sees a normal Xbox controller, and separately pretends to be a PlayStation pad, which gets back rumble and battery reporting and lighting control that the stock Bluetooth mode never exposes at all.

After that I wanted to know how much headroom was left, so I measured the physical limit of the radio link, and just fitting the packets into the air caps it somewhere near 400 a second while the shipped firmware was already running at about 85% of that. So I stopped tuning. I would have liked more, but there just is not more there.

I am a huge soccer fan. I grew up watching it without ever quite managing to pick a club to support, and on nights when the team my dad and brother supported was playing we would bet on the score to decide who picked dinner. That is more or less where this came from.

It forecasts 25,979 European matches across 11 leagues, and every prediction gets scored against what the bookmakers were offering, since an accuracy number for football on its own tells you nothing at all. The home team wins about 46% of all matches, so a model that just always picks the home side already looks respectable, and anything I build has to clear that before it has done anything. This one gets 70% on matches that end decisively against a 61% baseline, and 52% on the full three way result against 46%, and without using a single piece of betting data it captures 92% of the bookmakers' forecasting skill.

There are four different models in it: a rating system that works like chess ratings, squad ratings from the FIFA games joined in as of each kickoff using the actual starting eleven, a statistical model built for football scorelines specifically, and a neural network that learns its own representation of each team. I spent a long time trying to close the last of the gap to the bookmakers before working out that the gap is information I do not have, and there is a section in the writeup showing how I established that.

Draws stay hard the whole way through and I wish I could fix it. Soccer is just beautifully unpredictable, and that is most of why I like it.

I built this one because backend interviews keep asking about transactional correctness, and I would rather have written the thing than talk about it in the abstract. It is a double entry ledger, meaning every transaction moves money out of one account and into another so the books always balance, with a Java and Spring Boot API, a PostgreSQL database behind it, and a React frontend for accounts, balances and statements.

Submitting the same transaction twice does not post it twice, reconciliation runs on a schedule, and imported CSV files drop rows they have already seen. The part I actually care about is what happens when several postings land at once, where each one locks the accounts it touches and always takes those locks in the same order, and that ordering is the whole trick, since it is what stops two postings sitting there waiting on each other forever and what stops them reading a balance that the other one is halfway through changing.