Projects

Things I've built

A few projects with the engineering behind them — the problem, the design decisions, and the trade-offs. Each links to source and, where available, a live demo.

DATABASE / C++01 / SYSTEM STUDY
Inside the query engineSQL passes through an optimizer and executors. A B+ tree branches into leaf pages, which use buffer-pool frames and a disk scheduler to access disk storage.QUERY PROCESSINGSTORAGE ENGINESQLOptimizerExecutorsscan / joinB+Buffer poolcached framesDisk schedulerDisk
Inside the query engineExecution → pages → persistence

BusTub — Relational Database Internals

Built core internals of a disk-oriented relational DBMS in C++ — buffer pool, B+ tree indexing, a query execution engine, and optimizer rewrite rules. Top 5% on the performance leaderboard.

C++ Database Internals Concurrency Query Optimization
Read more →
ML SYSTEMS / INFERENCE02 / SYSTEM STUDY
Reuse context. Verify together.Repeated context is indexed into a suffix tree. Branching token candidates feed one target-model verification pass with a KV cache. Accepted tokens extend the context and rejected tokens are discarded.CONTEXT / CANDIDATE PROPOSALTARGET-MODEL VERIFICATIONthecatsatthecat·satranonbytoinLLMKV cacheONE FORWARD PASSsatona×accept prefix / discard rest
Reuse context. Verify together.No separate draft model

Suffix Speculative Decoding for LLM Serving

Integrated suffix-based speculative decoding into the Hugging Face generation stack — a draft-model-free proposer reusing repeated context patterns for 1.74x faster decoding — plus a unified verification interface for suffix and tree-based speculation, achieving 1.30x speedup on tree-spec workloads.

PyTorch LLM Inference Hugging Face Transformers
Read more → GitHub
CLOUD / DISTRIBUTED SEARCH03 / SYSTEM STUDY
From abstracts to answersA frontend sends search requests to the API. Kafka distributes processing work. Crawled abstracts are stored in GCS and indexed by MapReduce on Dataproc; the API uses existing results when a new MapReduce job is unnecessary.PROCESSING / GCPSearchAPIKafkawork queueCrawlerGCSMapReduceDataprocResultsreuse existing results
From abstracts to answersKafka · GCS · Dataproc

Distributed Scholarly Search Engine

A microservices search engine on a 3-node GCP cluster (Docker, Kafka, MapReduce, Terraform) indexing 10K+ IEEE abstracts, with 37% faster queries by conditionally skipping MapReduce jobs.

Docker Kafka MapReduce Terraform GCP
Read more →
ML SYSTEMS / COMMUNICATION04 / SYSTEM STUDY
Shard the model. Share the work.Two data-parallel groups each contain two tensor-parallel ranks with sharded weights. Horizontal communication combines tensor outputs. Vertical communication all-gathers parameters and reduce-scatters gradients; each rank holds a local optimizer-state shard.DATA GROUP 0DATA GROUP 1R0R1R2R3tensor-parallel collectivestensor-parallel collectivesW / ∇ / AdamW / ∇ / AdamW / ∇ / AdamW / ∇ / Adamall-gather parameters · reduce-scatter gradients
Shard the model. Share the work.Tensor parallel × data parallel

Distributed Training with ZeRO — 2D-Parallel Communication from Scratch

Implemented the communication layer of a 2D-parallel training pipeline combining data parallelism and tensor model parallelism (naive and Megatron-style), extended with ZeRO-style optimizer-state sharding, built from scratch on raw MPI collectives.

MPI PyTorch Distributed Training ZeRO
Read more →
GPU / BLACKWELL SM10005 / SYSTEM STUDY
Keep the tensor cores fedMatrix tiles A and B move from global memory through TMA into shared-memory pipeline buffers. Tensor cores accumulate into tensor memory, followed by an epilogue. The timeline illustrates overlapping loads and matrix multiplication.GLOBAL MEMORYABTMASHARED MEMORYStage 0Stage 1MMATMEM → epilogueLOADMMAk0k0k1k1k2k2
Keep the tensor cores fedAsynchronous load / compute overlap

A High-Performance FP16 GEMM Kernel for NVIDIA Blackwell

Built a high-performance FP16 GEMM kernel for NVIDIA Blackwell (SM100) GPUs using TVM/TIRX, starting from a minimal single-tile kernel and incrementally layering on optimizations until reaching the structure of production-grade cuBLAS/CUTLASS-style implementations.

CUDA TVM/TIRX GPU Kernels Tensor Cores
Read more →
ML SYSTEMS / AUTODIFF06 / SYSTEM STUDY
A graph that learns backwardsInput x and trainable weight W feed a matrix multiplication, bias b feeds addition, and sigmoid produces a prediction. Prediction and target y feed the loss. Reverse-mode gradients follow the graph backwards to update parameters.REVERSE-MODE COMPUTATION GRAPHxW×b+σLossyFORWARD →← BACKPROPAGATION / ∂L
A graph that learns backwardsForward values / reverse gradients

A Reverse-Mode Automatic Differentiation Engine

Built a reverse-mode automatic differentiation engine from scratch on top of NumPy — the computational-graph core that powers frameworks like PyTorch and TensorFlow — then used it to train a logistic regression classifier end-to-end.

Python NumPy Autodiff
Read more →
DISTRIBUTED SYSTEMS / ACTORS07 / SYSTEM STUDY
One world, many replicasPlayers connect through RPC to nearby region servers. Each region contains query actors with FIFO mailboxes and local key-value state. Regions periodically synchronize updates using last-writer-wins conflict resolution.FRANKFURTOHIOOSAKAAAKVAAKVAAKVPlayerPlayerSYNCLWWactor mailboxes
One world, many replicasNearby reads / eventual consistency

A Globally Distributed Key-Value Store for a Multiplayer Game

Built a globally distributed, highly available key-value store using the Actor Model to back a multiplayer game, with actor-based concurrency and eventual consistency across geographically distributed replicas.

Distributed Systems Actor Model RPC Consistency
Read more →
NETWORKING / VIDEO08 / SYSTEM STUDY
Adapt before the buffer runs dryEncoded DASH representations are served over a changing network into a playback buffer. A buffer-based ABR controller observes occupancy and chooses the next segment bitrate. Buffered segments feed video playback.DASH ORIGINHighMediumLownetworkPLAYER / DASH.JSABR controllerplayback buffernext segment / bitrate
Adapt before the buffer runs dryDASH / buffer-based bitrate selection

Adaptive Bitrate Streaming for Video Delivery

Designed and optimized a buffer-based adaptive bitrate (ABR) algorithm on a DASH-based video streaming testbed, trading off startup latency, video quality, and playback stability to maximize QoE under realistic last-mile network conditions.

JavaScript DASH Docker Networking
Read more →
NETWORKING / TRANSPORT09 / SYSTEM STUDY
Reliability over an unreliable linkSender application data enters a sliding send window controlled by congestion and flow limits. Numbered packets cross a lossy UDP path to a receiver reorder buffer. ACKs return to the sender and drive retransmission and RTT estimation.SENDERRECEIVERApplicationApplication1122334413×UDP / losscwnd / rwndReno + RTTReorderin-order deliveryACK / retransmit
Reliability over an unreliable linkReno · windows · RTT · retransmission

TCP in the Wild — A Reliable Transport Protocol

Implemented a reliable transport protocol from scratch in C, closely modeling TCP Reno on top of UDP, with congestion control, flow control, and RTT estimation evaluated under real network conditions.

C Networking TCP Congestion Control
Read more →
DISTRIBUTED SYSTEMS / CONSENSUS10 / SYSTEM STUDY
One leader. A replicated log.A client sends commands to an elected leader. The leader replicates log entries to followers using AppendEntries RPCs. Matching logs acknowledge replication; a majority allows safe commit and state-machine application.ClientELECTED LEADERLF1F2F3AppendEntriesmajority → commitmatching logs / safe application
One leader. A replicated log.Election / replication / commit

Raft — A Distributed Consensus Algorithm

Implemented the Raft consensus algorithm in Go — a replicated state machine module with leader election, log replication, and safe command application across fault-tolerant distributed replicas.

Go Distributed Systems Consensus RPC
Read more →
NETWORKING / PRIVACY11 / SYSTEM STUDY
Hide the path as well as the payloadSTP, safe flooding, link-state advertisements, and Dijkstra construct routing information in the control plane. In the data plane, source-routed traffic traverses relay nodes and a mixing buffer before reaching its destination.CONTROL PLANESTPFloodLSADijkstraDATA PLANESrcR1R2DstMixoverlay routes
Hide the path as well as the payloadControl plane / source-routed data plane

MixNet — Privacy-Preserving Overlay Network

Built a mix network overlay in C that hides both message contents and communication patterns using redirection, mixing, and source routing, with a custom control and data plane on top of link-state routing.

C Networking Routing Security
Read more →
DISTRIBUTED SYSTEMS / SCHEDULING12 / SYSTEM STUDY
Split work. Recover failed chunks.A mining client submits a nonce range to a scheduler. The scheduler splits and distributes chunks to three workers, collects hashes, and reassigns unfinished chunks after a worker fails. All messages use a reliable LSP layer over UDP.ClientSchedulersplit / reassignW1W2W30…3…6…retryLSP OVER UDP · WINDOW / ACK / EPOCH / BACKOFF
Split work. Recover failed chunks.Fault-tolerant mining over LSP

Distributed Bitcoin Miner

A reliable transport protocol (LSP) over UDP in Go, plus a fault-tolerant distributed miner that reassigns work dynamically across nodes — >99% delivery accuracy and 43% less recomputation overhead.

Go Distributed Systems Networking Concurrency
Read more →
WEB / STATIC + WEBASSEMBLY13 / SYSTEM STUDY
Content, photos, and playable codeMDX content, photos, and C++ game sources follow separate build paths: Astro builds pages, image optimization creates WebP thumbnails, and Emscripten compiles games to WebAssembly. GitHub Pages serves the resulting artifacts to the browser.SOURCEBUILDMDXprojects / blogPhotosC++ gamesAstrostatic HTMLWebPresponsive imagesEmscriptenWASMBrowserGitHub Pagesread / browse / play
Content, photos, and playable codeBuild once / serve static assets

Personal Portfolio — This Website

A fast, static portfolio with project write-ups, a photo wall, and browser-playable C++ games compiled to WebAssembly.

Astro TypeScript MDX Tailwind CSS WebAssembly
Read more → GitHub Live demo