Software Project Portfolio

A custom programming language and Shadertoy-inspired browser-based playground for generating and manipulating 3D geometry with code. Includes a rich set of builtin functions implemented in Rust for creating a wide variety of shapes and transformations. This builds on much of my previous work with 3D graphics, computational geometry, and building high-performance applications in the browser.

I ported the CSG.js Constructive Solid Geometry library created by Evan Wallace (github.com/evanw/csg.js) to Rust and integrated it with other mesh processing and manipulation code I use as part of my browser-based 3D projects. I experimented with performance improvements and other modifications to the library with the goal of producing manifold meshes with minimal triangle counts as output.

I developed a code pipeline for subdividing 3D meshes, programmatically deforming + manipulating them, and computing accurate normals for both shading and displacement. This included a deep-dive into the Blender codebase to figure out how they computed normals for smooth-by-angle shading.

I created a library that extends built-in Three.JS materials to support infinite, non-repeating, seamless texture tiling. The hex tiling algorithm itself is ported from a Shadertoy by Fabrice Neyret and extended with my own changes to optimize performance and and customize the look of the tiling. The library can be added to almost any existing Three.JS project and includes several config options for the tiling.

I developed a system of generating and wrapping meshes around other meshes using geodesic paths. I compile the code for it (including both Rust and C++) into WebAssembly and use it to create procedurally generated decorations for my 3D scenes. I also created an accompanying blog post detailing the process and the math behind it.

A relatively feature-rich volumetric fog shader for Three.JS. It raymarches a density field generated using noise functions, rendering dynamic fog in real time. It integrates into the pmndrs postprocessing system and has many configuration options. It uses analytical gradient-based techniques to implement lighting with dynamic light sources.

A continuation of my 3D work with Three.JS. TSome highlights include heavy volumetric godrays and procedurally generated 3D Vicsek fractals (the large cubes visible in the screenshot). This scene served as a sort of warm-up project as I got back into 3D work after several months spent working on other things.

An experiment for generating embeddings from an audio sample library and a UI for visually exploring the sample library in 2D space. The samples processed with MFCC for feature extraction, the embeddings are generated using UMAP, and the UI is built with Svelte + D3.The tool is integrated into the sample library module of my web synth project.

I added support for AVX-512 to the popular llama.cpp LLM project. This sped up inference by a bit on processors that support it. The work was quickly obsoleted by other optimizations to the rapidly evolving project, but it was a fun experience to contribute to that effort.

I picked active development of web synth back up with the goal of producing "real music" using the tool. I prioritized filling some gaps in features as well as polishing up the application as a whole. Some of what I worked on includes building an OTT-style multi-band compressor, a mixer UI with level visualization, revamping the MIDI editor to support multiple tracks, adding a welcome page, building a custom dynamic bandpass filter, moving MIDI scheduling to the audio thread, adding time-tracked automation tracks, and fixing tons of bugs.

A collaboration with @N8Programs, porting his godrays shader for Three.JS into a library that integrates with the pmndrs postprocessing library. The shader is a high-quality volumetric lighting effect that generates very cool looking godrays in any Three.JS project, with lots of controls for configuring the effect.

Web-based utility to combine multiple seamlessly tiling textures into a single larger texture. This is a useful alternative to expensive runtime methods like hex tiling. It works very well when using AI-generated seamless textures, and I used it in some of my 3D sketches. Written in Rust + compiled to WebAssembly.

The result of a lot of experiments with Three.JS and Blender. Full first person controls with collision detection + physics, lots of custom shaders + textures, and web synth integration for sound effects. The scene itself consists of a bridge over a void with many floating monoliths and an alien-looking environment.

While working on an idea for an interactive visualization of RNNs, I ended up going down a rabbit hole of exploration and experimentation in the realm of neural networks, machine learning, and information theory. Work included developing a new activation function, using ideas from other research papers to estimate the Kolmogorov and boolean complexities of different functions, and reverse-engineering a neural network's clever solution to binary addition. This work culminated in a lengthy blog post full of interactive visualizations to illustrate the concepts involved.

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 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.

`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.

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.

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 (https://github.com/foambubble/foam). 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.

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.

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 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.

An interactive ant colony simulation that I created as a project for my Simulation and Modeling class at school. Made using my Minutiae simulation framework, ants lay pheromones and work together to gather food in a world full of obstacles.

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.

Server and TUI for managing and deploying static websites and files. Deployments are created as subdomains, allowing a directory of static files (such as one produced by `yarn build`) to go from your computer to being hosted at `project.ameo.design` with a single command.

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 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 live depth-of-market (DOM) web-based visualization for live orderbook data from the Poloniex cryptocurrency exchange. Allows traders and quantitative analysts to gain unique insight into the current state of the market by viewing complex market activity in real time.

TickGrinder is a high performance algorithmic trading platform written primarily in Rust. It is designed with the goal of efficiently processing event-based market data as quickly as possible in order to automatically place and manage trades.

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.