Software Project Portfolio

Writing software is my passion. Building web applications, websites, tools, utilities, or artsy code sketches is what I do in my free time and want to do for my career as well. Here is a collection of the notable software projects that I've undertaken and published. The list isn't comprehensive and is always growing.

Interactive ML-Powered Anime Recommendation Tool

Apr. 2022 - May 2022

An anime recommendation engine powered by a custom-built neural network. Using a dataset of user profiles from the popular site MyAnimeList, the network was trained entirely in the browser via Tensorflow.JS. The whole thing is implemented as a SvelteKit app with predictions happening directly within the app itself using tfjs-node and a background thread. Additional post-processing is applied to work around imbalances due to large popularity differences. It also contains support for determining which ratings contribute most to each of the recommendations.

A screenshot of the anime recommendations page of the site showing the UI and several recommended animes

Interactive 2D Anime Embedding Visualization

Apr. 2022 - May 2022

In a similar vein to the Music Galaxy (a few projects down), this is an embedding visualization that is constructed based off of relationships between anime. A co-occurrence matrix is constructed from a large dataset of user anime rankings which is then used to construct a variety of embeddings using different algorithms (PyMDE + GGVec) and parameters. The embedding is then projected into 2D with t-SNE. The visualization itself is built with PIXI.JS and has the ability to search + fly to anime as well as load in user profiles from MyAnimeList to visualize where one's own anime rankings lie in the broader context.

A screenshot of the anime atlas embedding visualization showing the UI and a section of the embedding with labels and markers indicating which ones the user has watched

Browser-Based Neural Network Playground

Aug. 2021 - Apr. 2022

A browser-based tool for building, training, visualizing, and experimenting with neural networks. Written in Rust, compiled to WebAssembly with SIMD. It can learn arbitrary functions via randomly sampled examples, showing its progress on a 3D surface plot. There is support for changing all network parameters like the number of layers, the activation function for each layer, learning rate, and more. It also includes visualizations of individual neurons' responses to explore the internal workings of the network.

A screenshot of the neural network web application itself which shows the full UI, network response visualization, neuron output and response visualization, and costs plot

Mini 3D World in the Browser

Feb. 2022 - Mar. 2022

A small 3D world built using Three.js and Blender that runs in the web browser. Accompanied by a YouTube mini-series of short videos going over the process of creating it and explaining some of the background concepts.

A screenshot of the 3D world in the browser showing a floating island with clouds in the background, grass, low-poly trees, a mountain, texturing, and a FPS counter

Music Galaxy

Aug 2021 - Oct 2021

Music Galaxy is is the culmination of several months of work with artist relationship data from Spotify. It is an interative 3D visualization of the relationships between over 70,000 artists, positioning them in such a way that artists with similar audiences are positioned closer together in space. It also supports connecting to users' Spotify accounts to visualize where their personal favorite artists exist in context of the greater musical universe.

A screenshot of music galaxy showing a zoomed-out view of the visualization with several labeled artists

Speeding up the `rnnoise` library with SIMD

Jul 2021 - Jul 2021

`rnnoise` is an open source noise suppression library based on a recurrent neural network. It is used in various software, and I use it myself on my desktop as a part of `pulseeffects`. I located a hot function in the application used for actually applying the neural network's weights which was taking up significant portion of its CPU time, and I realized it could be sped up significantly with SIMD. I converted the code to use SIMD intrinsics which yielded a huge reduction in CPU usage. I also contributed a pull request to the rnnoise repository with the changes.

A screenshot of the godbolt web interface showing the generated assembly from the code from rnnoise that I sped up with SIMD

Spotify Related Artists Graph Visualization

May 2021 - June 2021

An interactive web-based visualization of related artists on Spotify based on data from the Spotify web API. It allows patterns in music styles and artists to be seen in a way that moves beyond traditional genre classifications. The visualization is integrated into my Spotifytrack project.

A screenshot of the spotify related artists graph visualization showing the network of my personal artists and their connections to each other based on user listening patterns

MIDI Editor Web Application

Mar. 2021 - (current)

A fully in-browser MIDI editor built as a part of my broader browser-based audio synthesis platform (see below). It's the second browser-based MIDI editor I've made, and fixes many of the issues from the first one. It's currently only available as a module of the web synth platform, but I plan to make it into a standalone webapp as well.

Audio Synthesis Research Notes + Documentation

Feb. 2021 - (current)

As I've delved deeper into audio synthesis and DSP programming topics, I've started recording my findings and creating a personal knowledge repository using Foam, a personal knowledge management and sharing system for VSCode ( Topics range from FM synthesis to speech/singing synthesis as well as some documentation for my web synth project. I plan to continue expanding this knowledge base and possibly extend it into other areas that I spend time learning about in the future.

A network visualization of my Foam repository so far showing links between pages as edges

Wasm-powered FM Synthesizer

Dec. 2020 - Mar. 2021

An 8-operator frequency modulation synthesizer built in Rust and WebAssembly with SIMD that runs 100% in the web browser via WebAudio. Built as a standalone demo, it is also integrated into the full web-based audio synthesis and experimentation platform I'm building.

A screenshot of the FM synth demo webpage


Aug. 2020 - Aug. 2020

Built in a weekend, this website does the same thing as my previous project osu!track (which took me months to build). It allows players of the rhythm game Quaver to track their progress and view how their stats progress over time as well as providing visualizations of their hiscore distribution and a few other features.

A screenshot of the Quavertrack interface showing a scatter plot for my hiscores

Circle Game

Jun. 2020 - ?

A little toy game I'm building for fun based off an old idea from years ago. It's a great opportunity to try out WebAssembly in the frontend, do some linear algebra and graphics programming, and do something creative. It's mostly a fancy tech demo right now and may never be anything more, but it's a ton of fun to work on.

A screenshot of the game showing pathfinding debugging and some dynamically added user-created barriers


Mar. 2020 - ?

I built and managed all of the tech for the revival of online concert series SPF420. This consisted of a fully custom streaming setup through which multiple artists could stream to my server and be displayed side-by-side on an output livestream and a website featuring a fully custom-built chat with moderation and interactive cursor trails + stickers. The first event on March 28 topped out at over 250 concurrent viewers and lasted nearly 6 hours. More similar events are planned.

A screenshot of the SPF420 x SYNC^UP website on which the concert took place.  Shows the livestream, custom chat, and interactive components.

Project Sync^Up Website

Jan. 2020 - Mar. 2020

I helped out a team of people organizing a set of three simulatneous concerts in San Francicso, New York, and Chicago connected by live stream and streaming online. I built the website ( and handled the technical side of the livestream and web experience. The website was fully responsive with advanced styling to maintain the look of a poster on devices of all sizes and aspect ratios. However, all of the concerts were canceled due to COVID-19.

A screenshot of the Project Sync^Up Website that I built to announce the event and provide links to buy tickets for the participating venues


Apr. 2019 - (current)

A Work-In-Progress site showing users' top songs and artists and listening patterns over time, providing a shareable link that they can use to show it off to friends. May include features for tracking the popularity or artists/songs/etc. over time as well.

A very early view of the SpotifyTrack user stats page


May 2019 - May 2019

A fully-featured TypeScript library defining a self-contained 100% type-safe Redux architecture. Jantix staticly ensures the validity and cohesion of your actions/reducers/state and provides a very clean, 100% strictly typed interface through which to interact with them.

A screenshot of the VS Code text editor demonstrating the type inference provided by the Jantix library

Web-Based MIDI Editor + Synthesizer

Sep. 2018 - (current)

The goal of this project is to create a web-based music creation application that can be used entirely within the browser. Since the modern WebAudio API provides everything necessary to create complicated synthesizers and perform advanced audio processing, I believed that the web could work as an accessible environment in which to build this.

A screenshot of my online MIDI editor's UI showcasing drawn MIDI notes and controls for the synthesizer that plays when they are drawn and selected.


Sep. 2018 - Sep. 2018

A React port of the control-panel ( library. I maintained 100% visual appearance and functionality parity with the original library while making it usable from React. I also added several additional features such as making panels draggable, making UI state external, and adding an Proxy-based interface for manipulating the UI state externally.

A screenshot of the react-control-panel UI showing two programatically generated control panels using the light and dark color themes

.io-style Game

Jul. 2018 - Aug. 2018

A friend and I wanted to work on a game together, trying out some tech that we were interested in and building up all parts of a game from scratch. I handled the frontend and the physics while my friend focused on setting up the backend server. At the end, we came up with a networked physics engine based on a popular Rust physics framework that runs the same code on both the client and the server. A variety of techniques were used for handling network delay, synchronizing state, and keeping track of game data both internally on the client as well as on the server.

A screenshot of the .io-style game that I created, showing created "asteroids", a player entity with a rotateable beam, and a procedurally generated background.


Apr. 2018 - Jun. 2018

A tool for viewing data about the popularity of various stocks on the Robinhood brokerage. Allows users to view the most (and least) popular stocks held by its users and view trends over time. Robintrack gained significant popularity, with several people reaching out to use the data it collected for school or personal research and the Robinhood team reaching out to me directly about it.

A screenshot of the "Popularity Changes" page from Robintrack, showing the table of stocks with large recent popularity changes and a chart plotting the popularity vs price of the NVDA stock.

Volumetric Rendering Experiment

Aug. 2017 - Aug. 2017

A small demo of volumetric rendering via raymarching in the web browser using Rust, Emscripten/asm.js, GPU.js, and Emscripten. It creates a matrix of 3D noise and then pans around it, rendering the results to a canvas. All of the raymarching algorithmic and linear algebra was implemented from scratch, and the idea for the project was for it to serve as an excercise forme to learn how the whole process works from start to finish.

A view of the volumetric rendering output showing the generated 3D noise projected onto a canvas

Noise Function Compositor

Jun. 2017 - Sep. 2017

A web application developed using Rust + WebAssembly for creating and visualizing compositions of noise functions. 3D noise functions are projected onto a 2D canvas after being mapped through a colorizer function, creating intricate and psychedelic effects. Includes a web backend for sharing + browsing compositions from other users.

A screenshot of the noise compositor UI showing the composition tree, settings for an input transformation that zooms and scales its input, and the output of the composited and colorized noise function.


May 2017 - (current)

A simulation engine that operates on a finite 2-dimensional universe populated by cells and entities. It is designed to provide a modular system on top of which simulations of various types can be designed. Can be compiled into WebAssembly and run in the browser, optionally including client/server functionality. Minutiae is used in several of my other projects.

A minutiae simulation in which particles (colorized by a hidden noise function composition) are intermittently attracted to or repelled by each other, producing a dynamic scene reminiscent of sand in low gravity.


Jul. 2014 - Feb. 2015

Site where players of the game osu! can track their progress and view the progression of others. Pulls data from the osu! API, storing time series data and creating a variety of charts, plots, statistics, and other visualizations for a variety of different metrics. An in-game chat bot and Discord bot were also written to allow users to update their stats from in-game. Thousands of players a month continue to use osu!track.

A screenshot of a user's osu!track profile, showing statistics about their account and a scatter plot showing the scores on their best plays over time.