I worked in a team of 2 to create a C90 to RISC-V compiler. It used flex and bison to generate the lexer and parser, outputing a C++ abstract syntax tree. We managed to implement a large subset of the source language over the 4 weeks we had to complete our compiler, ranging from all of the major operators for int float and double data types, strings, arrays and all of C90’s control flow statements. The project was a resounding success, with our compiler passing over 90% of the seen test-cases, one of the highest scores in the cohort.

I worked in a team of 5 to develop a cloud hosted, multiplayer Asteroids game, using an FPGA dev-kit as a controller. I took this project as an opportunity to learn Rust, using it for the majority of the server logic. We used an FPGA dev-kit running a Kalman filter on gyroscope and accelerometer data as a video-game controller. The client was a multithreaded python project comprised of a graphical interface based on the OpenGL wrapper RayLib, a text based interface for the lobby system, an interface with the FPGA controller, and of course some netcode to interface with the server. The server ran on multithreaded rust, capable of hosting several games simultaneously whilst providing an SQLite powered lobby system, allowing players to easily co-ordinate matches and track their performance.

The system is very performant, with RayLib’s efficient rendering generating 3700 fps on a desktop with a midrange GPU, tick-rate and net-code creating an unnoticeable 55ms delay, and the rust server being able to handle 2000+ lobbies at 25% CPU usage, limited by Linux kernel restrictions. This performance lead to our project receiving a grade of 78.4%.

I worked in a team of 6 to design a self-balancing maze solving Robot. The firmware was developed with zephyr RTOS, providing a multithreaded environment, whilst not sacrificing low level control of the hardware. The firmware communicated over UART with a raspberry pi running an increadibly lightweight install of Alpine Linux, hosting a rust server that used the async rust based capnproto rpc implementation, providing an interface for the rust egui based client.
The system was highly performant despite it’s complexity, featuring complex control, maze solving and networking modules resulting in our team receiving the runner up prize for best end of year project.

I worked in a team of 6 to develop a RISC-V CPU in verilog from scratch. The processor successfully implemented the entire RISC-V base instruction set, verified against a set of test programs. Different iterations of the CPU were also developed, including a version with a Two-Way Set-Associative cache controller, and a pipelined version with an advanced hazard detection unit. I worked mostly on the core processor, figuring out the optimal way to decode an execute the instructions. I also automated the build and test system using make and python to compile the RTL (using Verilator), compile the assembly files and set the correct data memory hex files to be used by Verilator. This ended up being the core framework that all team members used to run their tests, saving a lot of time.

I wrote a framework for simulating transaction level logic models. It works by generating a graph defined by the description language which, when simulated, passes data between the nodes, executing user defined code to generate each node’s output signals. I created this as a I wanted to have a go at creating a hardware language with no prior knowledge in compilers or HDL simulators.

I developed a flask based web app in a team of 6 for ICHack24. The premise was to allow students to explore different assets in a simulated investment environment. The App was based on a simple API driven model, where the game main webpage several API calls to get the necessary assets, and interface with the game logic, using a session system to distinguish between users.