Weenix

Operating System written in C

Weenix is the labor of my time in CS1670/1690 (Operating Systems) at Brown. It was a semester long project dedicated to coding an OS, similar to the original UNIX OS, in C. To some, Weenix being written in C is a given (real operating systems are written in C ;)), but I'm just excited about Rust being introduced to the Linux kernel.

Weenix consisted of five semi-projects:

• Processes: The base of the Weenix: a single-threaded kernel with support for processes to be spawned and scheduled
• Drivers: Most of the work in coding the TTY drivers and line-discipline. The TTY supports 128 characters in the buffer. On top of this are memory devices and small support for SATA drives
• Virtual File System (VFS): This project setup the level of abstraction that sits on top of any lower-level filesystem implementations. Very similar to the system calls that Linux implements: do_open, do_write, do_read, and more!
• System Five File System (S5FS): Low-level implementation of a cutdown version of the early System Five FS built below the Virtual File System.
• Virtual Memory: This was the part that tied together the whole OS and finally gave us userland processes. I wrote data structures relevant to Virtual Memory and worked on the paging system (shadow pages for the win) among other things.

IP/TCP

Networking Stack built in C

This was a 2/3 semester long project to built an IP/TCP stack from the UDP-based ground-up.

Instead of dealing with a complicated OSI Level-2 hardware implementation - we encapsulated our packets in UDP.

We started with creating a "node" program - which acted almost like a router. It implemented IP packet sending and forwarding - each node could connect to others node and used RIPv4 to communicate.

On top of IP, we implemented the classic TCP Protocol and were able to send 1MB files between nodes reliably.

Color-sensing RC Car

RC Car made with an Arduiono and coded in Arduino (basically C++)

As part of my embedded software course, some friends and I created a Color-sensing RC Car with an Arduino

The car is remote controlled by the button array on a second Arduino we call the transmitter. The car requires a WiFi connection as we use the local network to send data from the transmitter to the car. Each button represents a direction and on a change in state (!pressed -> pressed and vice versa) triggers an Interrupt Service Routine

The car features a watchdog for safety, motor drivers which are PWM controlled, and it's independently powered.

Per the "color-sensing" capability, the car responds to color that it detects, using a color sensor, below it. It will stop for 2 seconds on Red (with a 5 second timer before stopping again), slow down on blue, and speed up on green.

Lastly, we wrote a report for our project. It contains safety and liveness concerns, project requirements, finite state machines for the receiver and transmitterm and more!

Planet Generation

Custom Planet Generator written in C++ using OpenGL and Qt

As a final project, my friends and I wrote a planet generator using the mystical GPU powers of OpenGL.

To create your own planet, you can use an on-canvas brush to draw what terrain you want to be on the planet. Then we take the brush data, create a height map interspersed with perlin noise, and displace the vertices of a sphere to create the planet.

Currently, the planet supports three terrains types (with coloring dependent on type): water (the base sphere coordinates), flatland (slightly spiky and green), and mountains. On top of this, I implemented a skybox behind the planet and a custom toon shader to make the planet look nice :)

Raytracer

C++ Raytracer using Qt Framework

A really satisfying project, this was a C++ Raytracer developed from scratch with the help of the Qt Framework.

The Raytracer supports: shadows, recursive reflections and refraction, and texture mapping. The raytracer was done using Phong Illumination, and we load in primitives to the scene with a custom scenegraph parser.