My Projects

Fueling the future

Project Description Years Developed More Info
Designed a 2-stage RISC-V datapath with controls capable of executing all RISC-V instructions. 2018 More Detail
Created a program to generate depth maps from 2-dimensional images using computer vision techniques. 2018 More Detail
Used real world data to implement the back end of a web server that supported a mapping application. 2018 More Detail
Developed a personal website from scratch using HTML, CSS, and JS. 2018-Present
Created a 2D interactive adventure game in Java and designed and implemented a world generation algorithm. 2018 More Detail
Used Java to develop a universe simulation with gravity and inelastic collisions. 2018 More Detail
Used Python to implement a fully functional interpreter for the Scheme programming language. Ensured that evaluation was properly tail recursive. 2017 More Detail
Programmed the game logic for a tower defense game based on Plants vs Zombies called "Ants vs. SomeBees" in Python. Project utilized functional and object-oriented programming paradigms. 2017 More Detail
Implemented an application to create a Voronoi diagram visualization of nearby restaurants and their ratings using the Yelp academic dataset in Python. Application used machine learning techniques to predict restaurant ratings. 2017 More Detail
Developed a simulator and several strategies for the dice game Hog using Python. 2017 More Detail
Developed a virtual museum iOS application using Apple's 3D Scene Kit and incorporating 3D sound. Written in Swift 2.2. 2016 More Detail


November, 2018
A top view of the circuit

I designed and implemented a 2-stage RISC-V CPU in Logisim. The CPU supported all RISC-V instructions and instruction types. I designed and implemented the datapath, ALU, branch comparator, registers, immediate generator, and numerous other components, which are available to view upon request. This was an involved project, and supported no-ops to support complex instruction sequences.

Depth Map Generator

September, 2018
An example of the depth map

I implemented an application to convert left and right stereo images into depth maps, black and white images where pixel color values correspond to the depth of objects in the original stereo pictures. I used a block matching technique with squared Euclidian distance to identify common features between the left and right stereo images. From there, I calculate image displacement, and then use this value to determine the depth of the feature object. I store the depth maps using quadtree compression. To ensure my application could run quickly, I wrote it in C and the assembly language RISC-V.

Berkeley Maps

March - April, 2018
A picture of the map

I implemented the backend of a web server to host a mapping application serving the greater Berkeley area. The application was tile based. Based on user requests, my application would return the appropriate square tiles at the appropriate zoom level to fill the users view. I then wrote code to read in map data from publicly available OpenStreetMap files and construct a graph representation of the streets and locations of Berkeley, as well as their coordinates. I implemented a TrieSet and used it to allow prefix completion for user searches, which would then show the appropriate location on the map. I used Java.

Time Runner Game

January - February, 2018

I created a 2D game in Java, which I called "Time Runner." You can scroll through the image gallery above to get an idea of the graphics and game-play. To start, I wrote a world generation algorithm from scratch. The algorithm would take a user-inputted seed, and generate a 2D tile grid comprised of "floor" and "wall" tiles, which I rendered using the Princeton StdDraw library. My algorithm ensured that every floor tile was reachable for the player, and that world's were random and unique. The player can move up, down, left, or right via keyboard input, and maps included life blocks and other power ups. The game had a home screen, and supported saves. I implemented a heads up display that would give info about a tile if the user hovered their mouse over it. I used the StdDraw and StdRandom libraries to read keyboard input and render the map. Code available upon request.

Universe Simulator

January, 2018
A picture of the simulator

This project was a physics simulator that could display a universe and model the effects of gravity and collisions. The program could read in information about a universe and the objects within by looking through a text file. From there, it would render the objects and show their interactions over time. My simulation accounted for gravitational force, and allowed for inelastic collisions. I used the Princeton StdDraw class to render the objects. Code available upon request.

Scheme Interpreter

November - December, 2017
A picture of the interpreter

In my first delve into interpreters, I used Python to implement a fully functional interpreter for the Scheme programming language. Although Scheme is a fairly simple language, it was suprisingly challenging to implement all of its features. I used a read-evaluate-print loop to lex, parse and interpret user input. My interpreter supported proper tail recursion and macros. Boolean logic, functions, lambdas, and conditionals were all supported. I wrote extensive unit tests to verify the correctness of my implementation. Code available upon request.

Ants vs Bees Tower Defense Game

November, 2017
A picture of the game

As my second game, I implemented the logic for a tower defense game using Python. I implemented multiple tower (ant) classes and enemy (bee) classes, including long ranged thrower ants, short range one-hit-kill ants, armored ant tanks, and long range de-buff towers with slow, stun, and damage over time effects. This was a large project, and made use of class inheritance. Working on this project taught me the importance of controlling complexity with well thought out code. I was provided with a graphical user interface to accompany the game. Code available upon request.

Restaraunt Map Application

October, 2017
A picture of the map

For this project, I used the Python and the Yelp academic dataset to model restaraunts around Berkeley, using their names, locations, categories, prices, and reviews. I then implemented a Yelp-powered restaraunt recommedation program. The program takes a user's location, and returns a centroid corresponding to the cluster of retaraunts nearest to the user's position. I used a k-means algorithim to group restaraunts into clusters. From this cluster, I then used machine learning techniques to predict ratings for the unrated restaraunts based on the user's previous ratings. For the area closest to each centroid, I assigned a color based on the average rating for the restarunts in the cluster, and used this to create a voronoi diagram. Code available upon request.

Hog Dice Game Simulator

October, 2017
A picture of hog interface

For my first game, I worked to implement a simulator for a more complex version of the popular dice game Hog. I used Python to create a dice function that could simulate dice rolls. I then wrote a takeTurn function that could take a set of dice, a game state, and a strategy, and then make a play accordingly. Functions were added as needed so that human players could play against the computer, the computer could play against the computer, and players could play against each other. The simulator provided commentary during games. I was provided with a basic framework and graphical interface to use in my program. I used my simulation to design, test, and develop different strategies for my Hog game. Code available upon request.

Virtual Museum iOS Application

July - August, 2016
A picture of virtual museum

This project was my first major computer science project. I stayed at UCI for a month as part of the COSMOS (California State Academy for Math and Science) program. I was part of a 4 member team of high school students tasked with creating an application that could incorporate 3D sound. Essentially, 3D sound allows for the specific placement of sounds within a 3D scene, which can add realism to virtual spaces. Our team decided to develop a virtual museum application, so that people without physical access to traditional museums could instead explore them from their mobile devices. As part of the project, I designed 3D exhibit models and placed them within a 3D scene using Apple's 3D Scenekit. Our app allowed for users to navigate between exhibits and listen to recorded scripts about each exhibit. The 3D sound scene responded to viewing angle using simple linear panning techniques. The project was coded primarily in Swift 2.2 using Xcode, though we also used sound editing software and 3D modeling software. You can view our research paper here.