Projects

Boid's Algorithm Simulation

This was a quick exploration into genetic algorithms play a role in swarming & flocking behaviors. I can't emphasize enough how amazing emergent behaviors are: by simply specifying 3 simple rules—Seperation, Alignment, and Cohesion—these complex and beautiful patterns appear.
Side note: I able to figure out multiprocessing and effective distribution of work in this project, so I was able to simulate much more particles :)

Rust Chat Server

I developed the server backend to a chat app as part of the final project for my CS:199:128 (Intro to Rust) course to learn more about the system design behind messaging platforms. The relatively simple chat server is written in Rust, hosted on AWS EC2, and stores user data in a SQLite database. It relies primarily on the Axum library for its web application framework and also uses Argon2 for simple password encryption. To associate users and chat groups in a clean and scalable manner, I used a bipartite graph structure, with one partition containing users, the other containing chats, and a third table storing the associations between the two. To process incoming messages with low latency and minimal synchronization overhead, I arranged them in a priority queue based on time of arrival and used multithreading with mutex locks to divide the workload. Overall, I found this to be a extremely valuable experience that taught me a great deal about designing effective and reliable systems in Rust.

Recyclable classifier

As part of the 2024 Congressional App Challenge, I developed the backend for an educational recycling app that enables users to take photos of objects and receive region-specific guidance on how to recycle them. The backend is a Python Flask server hosted with Waitress on a Raspberry Pi, exposed to the public via a Cloudflare tunnel. I implemented the image processing in two steps: first, a lightweight convolutional neural network classifies the image into one of several recyclable categories. Next, the classification, along with the user’s location data, is sent to a large language model (LLM) API, and the generated response is displayed to the user. The project ended up winning runner up in our region!

Particle Fluid Simulation

My interest in fluid simulation primarily arose after seeing some beautiful videos by created Sebastian Lague on the topic. Although never having touched the topic before, I decided to take on this project as a challenge to complete over the summer. Initially, I read some articles on Wikipedia and various other online sources to get a better understanding of the fundemental underlying mathematics behind fluid dynamics. However, since I lacked a lot of the mathematical foundation at the time, I decided to approach this simulation with a much simpler approach; I used a Smoothed Particle Hydrodynamics method (SPH) which calculated the particle movement through the pressure/density gradient and viscosity forces. Although this wasn't the most efficient method for fluid simulation, I was still able to get a fluid-esque behavior in my particles. In the future, I would like to create an improved simulation with the Lattice-Boltzmann method.

Slime Mold & Ant Colony Path Optimization

I was initially introduced to the intersection between computer science and natural processes after watching the youtube channel Pezzza's Work. I was extremely fascinated by the beautiful emergent behavior that arose from simple programmed interactions between particles or objects, so I tried my hand at designing my own version of these simulations. For the most part, my experiments were successful: Using pygame for a simple visual interface, I was able to replicate the path optimization behavior of ant colonies and by slightly modifying the simulation I could similarly replicate the behavior of slime mold growth. While I was able to get the emergent behavior I was looking for, I was unfamiliar with multithreading and parallel processing, and the simulations were unfortunately single threaded, relatively small, and EXTREMELY slow. I hope to come back and improve these simualtions once I get a better understanding of simulation and multithreading.

Fractal Visualizations

In my Calculus BC class, we spent a day exploring topics surrounding fractals. I was immediately intrigued—particularly by the stunning images produced by iterative mathematical processes like the Mandelbrot set—so I set out to learn more about fractal visualization. I began with the Lèvy C fractal, which can be visualized using a simple iterative algorithm. For more complex fractals, I implemented the escape-time algorithm, allowing me to visualize the Mandelbrot, Julia, and Burning Ship fractals, along with many other variations.

FIRST Robotics (Team 3984)

Languages used: Java, Python
Technologies used: WPILib, PID & Control-Loops, Motion Profiling, OpenCV, Linux
As the lead programmer on my High School Robotics Team for 3 years, I've had the oppurtunity to both make many close friends as well as learn key technical skills in the field of Robotics. During my time on the team, I switched code framework to a command-based structure, developed reliable competition-ready code for swerve drive and the various other subsystems of the robot, and used computer vision libraries to perform relatively simple vision alignment for automated point scoring and reliable autonomous routines. Furthermore, I co-developed the data pipeline for our team's custom virtual control and telemetry dashboard for our robot using Python Flask and WPILib Libraries. Overall, since my team lacked software mentorship, I had a challenging but invigorating experience self-learning the knowledge needed to program these features and I'll always be thankful for this unique oppurtunity to reinforce my skills as a programmer.