Leveraging NVIDIA's proprietary CUDA programming language for their GPUs, as well as OpenGL, OpenCV, etc., this project explored the suitability of GPU-Acceleration in environments featuring dense clusters of objects (e.g., Danmakus, etc.).
Numerous optimization strategies were explored and their impacts analyzed, including but not limited to: taking advantage of the GPU's memory hierarchy, specific optimization approaches (e.g., spatial binning), latency hiding in the form of intentionally spilling data from registers onto thread-local storage, and much more! This project also naturally features a live simulation where the user can spawn projectiles with custom arguments in a variety of ways and observe how they perform!

Written entirely in C and performed in a group of 3, this simple web server implements much of HTTP/1.0 as specified in RFC 1945, in addition to responding to CGIs as specified in RFC 3875. This web server was also written such that it compiles from source on the following systems: Linux, NetBSD, and OmniOS. Furthermore, this web server accepts both HTTP/1.0 and HTTP/1.1 requests, and answers as if they were HTTP/1.0 requests, allowing for users to use modern browsers to access the web server. For the entire project spec, see the given manual page.

I was given a manual page where we had to implement a version of ls(1) from scratch, also entirely done in C, covering 20 different flags in addition to requiring informed decision making whenever program behavior was not explicitly defined in the given manual page, in line with the basics of the Unix Philosophy (principle least surprise for the user).

Unlike most "Simple Shell" assignments that are common in undergraduate Systems Programming classes, this shell project (naturally written in C) features complex I/O redirection, process pipelines, as well as backgrounding of processes, in addition to a modular environ(7)ment, complete with variable expansion and more! Like sws above, this program was also written to compile from source on Linux, NetBSD, and OmniOS.

This two semester endeavour began with creating a team of five other students, then finding a sponsor with a vision that they'd would trust our team with the, planning, programming, and delivery of the finished product by the end of the Spring 2026 semester. The project itself is a Bukkit/Spigot Minecraft server plugin (written in Java, built with tools like Gradle) that aims to make role synchronization between our sponsor's Discord server and their Minecraft server(s) far easier.
However, the most interesting aspects of this project didn't come from the task at hand; rather, they came from being able to finally use all the knowledge I had accumulated from my undergraduate years in many ways, including remotely fixing system-level issues via ssh, data recovery, and even helping other Senior Design teams working with our sponsor.

If you're reading this then you likely have a good idea of what I did here, but maybe you're more interested in how I went about it. What Operating System is this running on, whose hardware, what domain name registrar, and much more are elaborated upon in detail here, including trials and tribulations.

Implemented and formally verified two distributed leader election algorithms in ring topologies using Promela/Spin. The first, Chang-Roberts LEA, elects a leader in a unidirectional ring with O(N²) message complexity, purging lower-ID messages and forwarding higher ones until the maximum ID completes a full round.
The second, Dolev-Klawe-Rodeh LEA, improves on this to O(N log N) message complexity by breaking execution into synchronous phases, where each active process compares itself against its two nearest active neighbors and either promotes itself as a local maximum or becomes a passive relay. Verification included formal assertions confirming (1) the elected leader always holds the maximum ID in the ring, and (2) exactly one leader is ever elected, regardless of process count or ID ordering.

TinyChat is a distributed, multi-room chat application built in Erlang, where a central server, per-room chatroom processes, and per-user clients coordinate entirely through message passing rather than shared state. I implemented the client, server, and chatroom logic (room join/leave, nickname management, message broadcast, and graceful disconnection) following a strict actor-based protocol.

A concurrent FIFO message queue implemented as a Linux character device driver (kernel module), letting multiple producer and consumer processes exchange messages through /dev/scull. Reads and writes block when the queue is empty or full, and user-space test programs exercise it. Your average producers-consumers problem, but now in Kernel Space!

A "simple" addition to the Linux Kernel, a system call callable by syscall(2) that performs some basic operations in kernel space, following standard kernel space safety mechanisms. While the system call itself is simple, the process of adding one to the Linux Kernel itself is far more interesting.

This Discord bot, written in Python 3.11, for the RenCorner Network of video game servers, acts essentially as a leaderboard for users to rank up and earn score as they talk in Discord, with additional ways to earn score if they decide to link their Discord account with their accounts on RenCorner-hosted servers. There is a suite of commands the bot responds to, but the most appealing of which generates a graphically pleasing "rank card", detailing some of the user's information, as well as their rank, how much score to the next rank, etc.

This other Discord bot, written in C# for .NET 6.0 and later .NET 9.0, acts as a direct bridge from Discord to the Terraria Servers at the RenCorner Network allowing for users to login and execute commands from the bot as if they were on the server, with the corresponding permissions they would have if they had logged in in-game. This application is also distributed, meaning it responds and is capable of handling commands to multiple servers at the direction of the user. It also features an UNO game playable with only interactions within Discord!

A simple program intended to bring familiarity to various aspects of OpenGL rendering, including but not necessarily limited to GLFW / event driven programming, drawing in 2D, simple animation, rendering 3D objects, and most importantly space transformation (model matrix, view matrix, projection matrix, and their place in the matrix pipeline). This program in particular renders Steve from Minecraft in 3D space, complete with the ability to adjust the scene cameras, depth, the projection matrices used, and switch between two styles of rendering; one "hand-drawn", the other from raw pixel data!

My first massive undertaking, creating a large-scale interactive multiplayer engagement that is not only functional, but properly balanced, designed well, and most importantly, fun for the players of the RenCorner Network! Recorded gameplay of the raids inside!

An incredibly performative Multi-server message queue featuring low-level multiplexed I/O developed into two parts, the C# plugin on each server, and the nexus server itself: hand-written in C, which takes requests from the various servers from the RenCorner Network and forwards them to the other connected servers. Peaking at less than half a megabyte of memory over an uptime of >230 days, this server nexus is far superior to any of the alternatives that the RenCorner Network has tried in the past.

Over time, the IRC plugin the RenCorner Network was using for their Terraria servers became less stable, to a point where the IRC bot/client would disconnect once a day. After another developer at the network offered to "fix" the service, with the caveat that it would downright require completely ripping out the existing protocol that had been in place for over a decade, I rose to the occasion and re-wrote the entire service (in C#, .NET 9.0) from scratch, and since then the service hasn't gone down. Not only that, but it has more functionality than ever before, all while the transition from old to new was seamless to the player base.

After creating the raid system as described in --rct-raid, I later realized that the raid encounter in addition to up to 7 other players spamming projectiles, abilities, etc., is far from ideal for those on lower-end devices, not to mention the significant hit to visibility. To solve this, I took a well-read page from other video games, writing a plugin that gives players the ability to disable ally's projectiles in their entirety, while keeping all hostile ones, as well as those from the user in question. While simple in concept, execution was slightly more tricky than one would expect. Thankfully after all was said and done, this feature remains one of the most critically acclaimed at RenCorner Terraria in the last decade.

Around the time I was an undergraduate / sophomore, I was playing a video game whose own party system was so fundamentally broken, unintuitive, and downright messy, trusting almost everything to the client, I decided to see for myself if it was really that hard to make a party system, and lo and behold, it wasn't. This C# .NET 6.0 / .NET 9.0 plugin for RenCorner Terraria features a server-authority party system that is used in or as a basis for --rct-cpvp, --rct-raids, and even --rct-egear. While the plugin itself is relatively simple, it was written with strict adherence to the MVC - Model, View, Controller software design pattern.

Feeling as though something more could be done with Player versus Player content on the RenCorner Terraria server, I had a vision of a complete and total rework of the existing PvP system, that I was fortunately able to implement alongside the previous one. Sweeping changes including but not limited to removing immunity-frames where possible/reasonable, a leaderboard, special team/party rules, etc. As with most other RCT plugins, this was naturally carried out in C# .NET 6.0 and .NET 9.0.

What good are raids and custom pvp systems without the ability to earn and use cool custom gear?! Also in C# .NET 6.0 and .NET 9.0, this system feature a system for players to easily obtain 120+ custom weapons, as well as custom gear (some of which is craftable), as well as unique situational effects, called enchantments -- all of which can be equipped, unequipped, listed, etc.

For use with RenCorner Terraria's Survival (Server-Side Characters) server, I figured that players would love a means by which to sell their hard earned items for a centralized server-currency to other players on the server, and so inspired by various video games' auction houses (e.g., Lost Ark, World of Warcraft, etc.,) I put a great deal of effort into ensuring ease of use, the principle of least surprise for the user, and most importantly, rigorous exploit prevention mechanisms.

For use with any TShock for Terraria server, Progression Gates allows server administrators to explicitly prevent overly ambitious players from "pushing progression", i.e., leaving everyone in the dust by rushing ahead and defeating all the milestone bosses and events in the world. All of Terraria's bosses and invasions are accounted for; these encounters can be set to unlock at a specific time, unlocked whenever, with the ability to lock and unlock any event at any time.

A simple mod for Terraria that re-introduces what I consider is a lost bit of whimsy in how the game is played by re-introducing auxiliary materials in many crafting recipes for items, among other specific adjustments.