Computer Engineering student at Imperial College London building low-latency systems, FPGA accelerators, compilers, ML infrastructure, and production software.

I like projects where performance, correctness, and real-world constraints all matter: hardware/software co-design, trading systems, compiler backends, computer vision pipelines, and tools that make engineering teams faster.

Portfolio | GitHub | LinkedIn

I have contributed to multi-author and organization repositories across systems programming, compilers, networking, FPGA acceleration, and low-latency engineering. I try to make the contribution trail explicit: repo links, commit-history links, contributor counts, and the engineering areas I owned.

If a repository is public, I prefer linking directly to the commit history or contribution surface rather than only listing the project name. That makes it easier to verify what I built and where I contributed.

• FPGA acceleration: fixed-point pipelines, DSP utilization, AXI-DMA transfer paths, binary TCP streaming, and performance benchmarking.
• Compiler infrastructure: parser and AST design, semantic analysis, type checking, optimization passes, RISC-V code generation, Dockerized testing, and CI.
• Low-latency systems: order book processing, multithreaded networking, socket protocols, synchronization, and real-time feature pipelines.
• ML systems: evaluation pipelines, pose-estimation benchmarking, embeddings, clustering, and feedback loops for model improvement.

Built a 12-lane Q4.14 FPGA accelerator with 21-stage pipelines, using 98.2% of DSP resources at an overclocked 110 MHz.

• Public team repository: Quick-Mafs/Magnetic-Pendulum-Accelerator
• Cut runtime from 61,878 seconds to 7.10 seconds, an 8,715x speedup.
• Reduced energy use by roughly 3,100x compared with the CPU baseline.
• Replaced Flask transfer with AXI-DMA and a custom binary TCP path, reducing frame transfer latency from 1 us/byte to 42 ns/byte.
• Built a Unity/C# visualization client for streamed FPGA frames, live parameter control, and trajectory playback.

Led a team building a low-latency trading system using PYNQ-Z1 FPGAs and live Binance order book data.

• Public team repository: Information-Processing/trading_indicators
• Engineered a feature pipeline using 17 order book microstructure signals for 2-second price prediction.
• Implemented online learning through incremental outer-product updates on FPGA.
• Achieved around 18x average speedup, 68x peak speedup, and 57.6% live directional accuracy.
• Focused on the full path from market data ingestion to hardware acceleration and live decisioning.

Built a full C90 compiler in C++ with parsing, AST construction, semantic analysis, optimization, and RISC-V code generation.

• Implemented constant folding, dead code elimination, branch resolution, and full type checking.
• Validated correctness with a Dockerized CMake/Python testbench over 300+ C programs.
• Maintained 100% pass rate through on-push GitHub Actions CI.
• Used polymorphic ASTs, RAII smart pointers, std::variant typing, template dispatch, and dynamic-cast based code generation.

Built an LLM-assisted misinformation detection and clustering system for YouTube transcripts.

• Extracted transcript claims and fact-checked them using GPT-4, Google Custom Search API, and Wikipedia API.
• Implemented embeddings plus KMeans clustering to group related claims.
• Built a Flask API, TypeScript/React frontend, and Chrome extension.
• Visualized claim clusters in a React Flow interface.

• Incoming Quantitative Developer Intern at Cantor Fitzgerald and BGC Group.
• Aladdin Engineering Spring Intern at BlackRock, selected as 1 of 12 from 11,500+ applicants and ranked 1st in the technical coding challenge.
• Technology Spring Intern at Morgan Stanley, ranked 1st/15 in an algorithmic trading challenge.
• Computer Vision and ML Systems Intern at Magic AI, building evaluation pipelines and low-latency multi-camera pose estimation systems.
• Technology Spring Intern at Amazon AWS, deploying Flask services on EC2 with REST APIs, security groups, and CloudWatch.
• Software Engineer Intern at Yorlet, building TypeScript and distributed notification systems for 11K+ users.

• Low-latency systems: C, C++, Python, multithreading, sockets, performance profiling.
• Hardware acceleration: SystemVerilog, FPGA pipelines, AXI-DMA, fixed-point compute.
• Compilers: parsing, ASTs, semantic analysis, optimization, RISC-V code generation.
• AI and ML systems: PyTorch, TensorFlow, OpenCV, MediaPipe, embeddings, clustering, model evaluation.
• Full-stack tooling: TypeScript, React, Flask, FastAPI, Node.js, MongoDB, Docker, Kubernetes.

• Hardware/software co-design for real-time systems.
• Low-latency trading infrastructure and market microstructure.
• Compiler optimization and language tooling.
• Evaluation systems for ML, computer vision, and LLM applications.
• Engineering tools that reduce review time, improve feedback loops, and make teams faster.