I build the layers
everything else stands on.

A transport protocol I wrote on raw UDP, for the places QUIC gets in the way.

Congestion control runs per stream instead of per connection, so a lossy bulk transfer can't throttle a telemetry stream sharing the same session. Each stream picks its own loss, ordering and coalescing policy at handshake time. Nothing allocates on the data path and the worker hot path takes no locks. On a 1 GiB checksum-verified transfer it came out 1.3 to 2.2 times faster than quinn, and latency stayed flat with 6.3 GB/s of bulk traffic running alongside.

• C++20
• UDP
• GSO
• Congestion control
• AES-256-GCM

A GPU governor that learns when it can clock your card down without costing you throughput.

A learned power-management policy for GPUs, driven by live device telemetry and tuned to hold throughput while cutting draw. Portable across cards without per-device tuning. Proprietary, so the internals stay off this page.

• C++
• PyTorch
• Reinforcement learning

The same bet, taken one level further down the machine.

A learned power policy for CPUs, sitting close enough to the hardware to act on what it sees without waiting on userspace. Trained offline, shipped as a compiled model, and left to run on its own. Proprietary, so the internals stay off this page.

• C
• Linux
• Reinforcement learning

A door lock that assumes the network around it is hostile.

The ESP32 generates time-based one-time passwords with SHA-256 on a 100 second rotation, and an RTC with NTP sync keeps its clock honest through power cuts. People unlock it over BLE. A FastAPI backend on EC2 handles lock management and signs everything it sends with PGP so the lock can check where it came from, with a Raspberry Pi running the same scheme if the backend goes away.

• ESP32
• TOTP
• FastAPI
• PGP
• BLE
• AWS EC2

Crowd analytics from the camera to the dashboard, with the model left swappable.

A DeepStream pipeline that takes TAO, TensorRT, ONNX or Caffe models uploaded from the dashboard itself. A Go backend handles gRPC and REST telemetry ingestion, and the SvelteKit front end renders whatever metrics the pipeline sends rather than a fixed set, so adding a new one doesn't mean touching the UI.

• DeepStream
• Go
• gRPC
• SvelteKit
• TensorRT

A full rebuild of the department's site, down to the timetables.

Next.js and TypeScript over a real schema for faculty, courses, committees, achievements and semester timetables. The import tooling reads the spreadsheets and PDFs the department already had, so nobody had to retype years of records to get the site running.

• Next.js
• TypeScript
• PostgreSQL
• Vitest

Accurate time from any NTP server, without leaving the terminal.

A small Rust CLI. ISO8601, Unix seconds or milliseconds, whichever server you want, coloured output, and a copy flag that works on both Wayland and X11.

• Rust
• NTP
• CLI

Texas hold'em with friends, hand evaluation included.

FastAPI holds the game engine, hand evaluation and table state behind token auth. React does the table itself.

• FastAPI
• React
• SQLite
• Python