Projects
Open Source Contributions
Song Canvas Integrated Digital Audio Workstation C++
Bespoke is a weird audio workstation. 15 years old and hyper-modular, beyond what most musicians consider reasonable, so it was disappointing to find it didn't have a true playroll type of structure, a very common feature in most DAWs.
Of course, nothing that over 8000 lines of C++ can't fix. <'>)
By complexity alone, the SongCanvas module is one of the most complex of the entire selection of over 300 modules. It heavily extends build-in ui frameworks, resolves several bugs, adds new convenience API features. Can play and export its own audio. And even adds its own dynamically resized grid built to handle its racks.
It's like a DAW, within a DAW.
I've also reused the project's azure build pipeline to have it built by GitHub. So now it releases for Windows, macOS and Linux with a touch of a button. Handy!
Next section you'll find more of my work on the project, but the songcanvas is by far the most advanced.
Bespoke Synth Even more treats for a lovely program C++
In addition to the SongCanvas module in the previous section, I've done a handful of other improvements:
Qwerty Keyboard
My first significant improvement to the project. In most DAWs, you can press keys on your pc's keyboard, and it will emulate a MIDI keyboard. This wasn't really a thing in Bespoke, so now it can.
It also adds mouse click position based velocity support, that's nice too.
Sea of Grain - Optimization
One of the modules was quite CPU intensive, in an hour I made it run 95% faster.
Drop-Down Extensions
It would be nice to have dropdowns with tooltips and custom graphics... So now they do!
It removes a bunch of hard-coded work and reimplements it generically. New work also extends Bespoke's custom tooltip tokenizer so the new tooltips also support translations.
Other stuff:
- Above 60 FPS support. 144hz monitor users rejoice!
- Cable patching improvements. Now you can patch dangerously, safely.
- Augmented the Sampler module with new inputs.
- small_vector extension and envelope overhaul. Design pending.
Languages & Tools
RustWaveLord Custom Tokenizer, Lexer & Compiler C# & .ini script
This is the result of turning an API built for making custom tank units in a mobile RTS game into a whole new Game Mode generator.
It takes an excel file, and turns it into thousands upon thousands of lines of .ini code on save. Very convenient.
I designed my own API for it. Tokenizing inputs, turning them into instructions, and producing a level out of that.
Supports 13 different value types. Comparisons, overrides, randomization, generic mod compatibility, multiple paths, grouping, triggers etc. Even has its own help file with API instructions with examples.
The compiler also supports 100 unique error messages for politely informing the user how good their code is.
.JS VM .JS in .NET! C#
Very simple, proof-of-work project where the goal was to get .JS execute in an unsupported environment. Works as expected.
Reverse-Engineering
.NET 1.0 No CD drive? No problem! IL Assembly
What happens when the game you played as a kid needs a CD, and it doesn't like your USB CD drive?
Well you bust open your dnspy, rewrite the instructions in IL Assembly(.NET 1.0 is too old for C# recompiling) and tell it to look more carefully of course.
As a bonus, I cleaned up my work so the final executable differs by a single byte.
Java Deobfuscation Obfuscated code? There's bugs to be fixed! jd_gui & Enigma
No enemies on the minimap? Source code obfuscated? No problem!
Took some searching, but by instinct, I managed to hunt down the error and resolve it. (Turns out it was an indexed search which started on the wrong index)
A year or two later, I reverse engineered some of the modding API's internals as a proof of concept.
Low Level
DLL Injection Controller Input Interceptor Rust
I really wanted the shaking of my phone's accelerometer to be linked with my controller inputs for some reason.
Say, if the line go up, inputs are passed. If line go down. Inputs are smoothed down to nothing, easy right?
Well, that sounds simple in theory... But then Windows came up with at least FOUR different controller APIs over the decades, and each game's unique underlying engine (like say SDL2, Unity...) throw in their own hooks.
Each game pretty much needs its own built-in support, each one is like its own little puzzle. You'll be entertained for months.
TCP Server Custom TCP protocol in Rust to .NET client C# & Rust
Rust learning project. Assembled a TCP-based server/client with a custom 6-byte header in Rust. Built for as a low bandwidth use as one could get away with
Supports multiple clients, room management and connection health.
Clients mirror the protocol and are coded in C# instead.
LLMs
Batch Parser Translates a whole novel's worth overnight. On consumer hardware C#
Quick little project for a friend.
Uses LLM assisted OCR, and translates the results in automated batches. Runs in an RTX 3090.
That's pretty much what it does. It does do a two pass process for higher accuracy though.
Architecture
Arkodex Personal Data Vault - Video Support via FFMPEG C# & C++
Daily driver for my personal notes for over 2 years.
I'm very picky, so I chose a layout I liked, added drag-n-drop images, video and files.
Albeit video was a bit more challenging since Godot's video handler at the time was best described as "basic", so I had to throw in FFMPEG to convert videos dropped in on the spot so they're playable in the engine.
It's also built for redundancy, with daily, weekly and even monthly database backups.
Nodehearth Yet another voxel renderer, coded from scratch, with frustum culling C#
While trying the Godot game engine, I opted to see how far I could take it by manually writing a voxel mesh builder, plus world generator.
Basically, remake the world's most popular game's graphics from scratch. Mission accomplished.
