Projects

I built a decoder-only Transformer in JAX, Flax, and Optax for arithmetic reasoning, then extended it with top-1 mixture-of-experts routing. From there, I wrote a fused Pallas projection kernel to reduce activation memory traffic and compared it with a ragged-dot baseline. The project follows the same workload from model design down to accelerator execution.

I built an inference runtime for speculative and speculative speculative decoding with fused GPU kernels, CUDA graph replay, and execution overlapped across two GPUs. With Qwen2.5-7B in FP8 and a trained EAGLE-3 drafter, it reached 697 decode tokens/s on one request on two B300s, about 2× my tuned autoregressive baseline, and ran a single request to 128,000 tokens. Along the way I built an exact-match test suite, tracked down a KV-cache stride bug, and found new matmul schedules worth 17–21% end to end.

I profiled GPT-2 inference on an NVIDIA A40 to understand where GPU time was going, then focused on matrix multiplication. I explored shared-memory tiling, launch configuration, vectorized loads, and a WMMA path, and added KV caching for autoregressive generation. I compared kernel behavior with the full inference path to understand how local improvements carried through to the application.

I helped build Ren on VS Code and ship it to alpha users. My work included codebase indexing and retrieval, interactive agent workflows, and agent orchestration. I also built views for agent activity, tasks, and file changes, alongside patch review and an execution timeline. The goal was to give developers enough context and visibility to stay involved as coding agents worked.

I built a full-stack workspace that turns text prompts into agent workflows users can work with in a visual editor. Reusable tools provide actions, while persistent memory and session management carry context between interactions. WebSocket streaming exposes responses as they arrive, connecting the workflow-building interface to what happens during execution.

I built an event-driven video pipeline that sends multipart uploads directly to S3 and turns them into adaptive HLS streams. RabbitMQ coordinates Go workers for FFmpeg transcoding and captions, while GraphQL subscriptions keep the interface updated as jobs run. The media processing runs in the background, separate from the interactive upload and playback flow.

I built the synchronization and persistence layers behind a collaborative document workspace. Yjs updates travel over a custom WebSocket protocol, and the server saves document state to PostgreSQL through Prisma. Document sharing and chat sit around that core. The work connects initial synchronization, live updates, reconnects, and storage rather than stopping at the editing interface.

I built QuickMark around the path from an unfinished draft to a published post. The rich-text editor saves drafts locally and lets writers restore them when they return. A TypeScript API built with Hono, shared Zod schemas, and Prisma connects publishing to PostgreSQL-backed profiles, comments, saves, likes, and follows. The result brings writing recovery and reader interaction into the same application.

I contributed to Aether, a desktop email client built with Electron and React, with a local Flask and Ollama service for summaries and reply drafts. My work focused on database IPC handlers and read/unread inbox interactions: translating stored email records for the interface and connecting message selection to read-state updates. These contributions sit between the desktop process, application data, and everyday inbox behavior.

I built a C++ parser for IEX packet captures and connected it to a market-data pipeline with Parquet storage, SQLite bookkeeping, and multithreaded ingestion. Airflow coordinates the jobs around that data path. The project links low-level decoding to the storage and processing metadata needed to make captured market activity useful for later analysis.

I built a Unix shell in C with pipes, input/output redirection, background execution, and custom built-in commands. The project explores how commands connect and how the shell manages the processes behind them. It gave me a way to work directly with the process lifecycles and data flow that higher-level applications usually hide.

I implemented custom malloc and free primitives in C, working directly with how requests receive memory and how released space becomes available again. The project explores the tension between allocation overhead, fragmentation, and utilization. It made those competing goals concrete in a component most application code delegates to a library.

I built a C++ decoder for Nasdaq ITCH 5.0 files, connecting memory-mapped input to inspectable CSV output. A dispatch table routes records to message-specific handlers, while packed layouts and compile-time checks keep the protocol representation explicit. The implementation also tracks processing statistics and handles interruption, making the binary-to-record conversion path easier to inspect and measure.