Hey, I'm Brendan Dupuis.

For this project, I built a fully playable version of Pac-Man entirely in ARM Assembly on a Cortex-M4 microcontroller. The game board, characters, and colors were rendered using ANSI escape sequences, while movement, collision detection, scoring, and game state management relied heavily on pointer arithmetic and manual memory management.

One of the biggest challenges was implementing responsive gameplay using interrupts rather than polling. I modified the Cortex-M4 vector table and developed custom UART, GPIO, and timer interrupt handlers for player input and game timing. To recreate the arcade experience, I added fruit bonuses, ghost-tracking behavior, physical controls on the Tiva board, and LED-based life tracking on the Alice EDU baseboard. This project sparked my passion for low-level systems programming and remains my favorite project to date.

Building a processor from scratch gave me a much deeper appreciation for how software actually executes on hardware. Using Verilog, I designed and implemented a 16-bit single-cycle processor containing an ALU, register file, memory subsystem, and control unit, which were integrated into a MIPS-style datapath capable of executing arithmetic, memory, and control-flow instructions.

The most challenging part of the project was debugging. To verify the design, I created custom programs encoded as 16-bit binary instructions and loaded them onto a Basys 3 FPGA. Since there was no traditional debugger, I used the FPGA's switches and LEDs to inspect internal processor state, including ALU outputs, memory values, and the program counter in real time. Seeing instructions execute on hardware that I designed myself made many computer architecture concepts click and remains one of my favorite hardware projects.

I built an embedded RPM detector to measure a record player's rotational speed and identify motor drift over time. Using an Arduino Uno, TCS3200 color sensor, and a 20×4 LCD, the device tracks a colored marker placed on the turntable and calculates RPM in real time.

To improve accuracy, I implemented a calibration mode that adapts to different lighting conditions and stores RGB sensor thresholds in EEPROM. The system also measures cumulative timing error against ideal 33⅓ RPM and 45 RPM playback speeds, helping identify speed variations that would otherwise be difficult to notice. The project was packaged in a custom wooden enclosure with an adjustable sensor arm for easy setup and testing.

As part of a team, I helped build an end-to-end encrypted messaging application where the server only routes messages and never has access to their contents. From the beginning, we wanted security to be part of the system's architecture rather than something added as an afterthought.

Our solution used ECDH key exchange to establish shared secrets between users, allowing messages to be encrypted on the sender's device and decrypted only by the intended recipient. We also protected private keys using AES encryption before storing them locally, reducing the risk of exposing sensitive information if a device was compromised. Beyond implementing the cryptography itself, much of the challenge came from designing a user experience that made secure communication feel seamless while maintaining strong security guarantees.

In this project, I implemented my own versions of malloc, free, and realloc in C. The allocator uses a multi-pool design, maintaining separate memory pools for different allocation sizes to reduce fragmentation and improve allocation efficiency.

When memory is freed, adjacent free blocks are merged together to recover larger chunks of usable memory. The allocator also supports block splitting, allowing large free blocks to be reused for smaller allocations. For requests that exceed the size of the managed pools, memory is allocated directly from the operating system using mmap and released with munmap.

Building this project required extensive use of pointer arithmetic, custom memory metadata structures, and low-level debugging. It gave me a much better understanding of how dynamic memory allocation works and the complexity hidden behind a simple call to malloc.