This is a sample of the kind of projects I've worked on over the years, it is by no means an exhaustive list.
As a jack of all trades, I've worked with countless technologies, languages, and platforms.
If you have specific questions, want to know more, or ask if I've used something before just reach out and get in touch with me.
If not otherwise noted or linked, source code is available upon request.
Most of this work is hosted on my 'cmdwtf' GitHub account!
I also keep a few things on my personal account, but mostly it just serves as my workspace for forks of other OSS projects.
Now, on with the shiny!
Having fallen in love with the immediate mode graphics library, Dear ImGui, I've started adding bits and pieces to it
to fill in gaps where the out-of-the-box widgets don't quite offer what I'm looking for.
imgui_toggle is the first of those: A simple but flexible
toggle switch that allows for small animations, customization of colors, and even adjustable roundness for the frame and knob.
A boringly named collection of tools and snippets I've written or collected over the years and found myself copying to each project.
Among other things, it contains several editor attributes, extension shortcut and helper methods, threading tools, various math, and more.
The purely original source is 0BSD licensed, but some of the third-party code in parts of the repos are licensed under other FOSS terms. Check the copyright file for more information.
Despite having found a few places where folx had mostly solved this sort of thing, I was specifically looking for a no-dependency way of blending between a perspective camera projection and orthographic one, with just a little bit of configurability.
Using math that approximates the Dolly Zoom Effect, and Unity's built-in camera matrix calculations, I built a small component that allowed a smooth blend between the two styles of projection.
After watching t3ssel8r's video on "Giving Personality to Procedural Animations using Math", I wanted to implement that sort of algorithm they showcases to enable some wonderful looking procedural animation in my own projects. It wasn't enough to just implement the simulation of second order systems, as I then fancied up the Unity Editor side of things so that I could have a design-time feedback to how adjusting parameters would affect the animations.
The source is available in the 'Unity Tools' project that I use to drag things I commonly use between projects at the jump below!
I recently switched back to Firefox with the impending manifest v3 switch scheduled for early 2023. When I did, I realized that I didn't have access to an addon that I had grown quite used to in my time with Chrome. A simple tool that did nothing more than take the current page, link, or selected text, and send it as a notification to my Prowl account with just a click.
Naturally, the only reasonable choice was to build my own, so I did.
The name ending with
2, is a nod to the extension that used to exist that did just this many moons ago. It seems to have vanished over the years, so I've picked up the banner where it left off.
Odiin is a NFC Tag Emulation toolkit. It was designed to be a straight forward, easy to use tool for emulating NFC-A tags of various types. Odiin started off as a learning project as I explored the nRF52840 platform, and spent time learning about NFC as a whole. I quickly realized I enjoyed reading arbitrary data and wanted to create a device that could do that with a swanky display. Additionally, it evolved as a tool when my wife and I realized we could use it to emulate our Amiibos, so we didn't have to pull them out of the bin every time we wanted to use them for our games.
Odiin was the my first 'start to finish' hardware and firmware personal project. I had worked on several things professionally, but hadn't ever set out to build something from scratch myself. It does make use of some development platforms, but it features some of my own PCB design, and a firmware application built from the ground up. After getting help from a co-worker to design a 3D printed case, I hand-produced several prototypes for friends and family, as well as made a few available for purchase on my tindie store. I intend to revisit this project and add more features to it, as well as perhaps design a full PCB so as to not need the dev kits as the base, but likely won't until the silicon shortage is less of an issue.
If you're interested in seeing it in action, there's a short YouTube video of me quickly walking through how the prototype works.
For lots of the little tools I've written, it's super handy to know when exactly they were built. There are several approaches I've seen and used over the years, the most recent having been to pluck the linker timestamp from the PE header.
That mostly worked peachy, until I started moving to
deterministic builds in .NET
fantastic feature that brought with it the ability to reproduce a build exactly given the same inputs. However, this meant that things like a
timestamp from the linker had to go, as that would cause the output to vary from build to build.
A common solution for keeping track of when things were built seemed to be using a pre-build event to generate a resource , but I wanted a method that didn't need to use resources at runtime,particularly in case a targeted platform didn't support them.
Enter source generators . By generating a small class at build time,I was able to have my cake and eat it too: verifiable, reproducible builds, while still embedding information about when the code was complied into the binary.
How does this differ from the linker timestamp mentioned previously, you ask? Simply put: the source generator runs before the build, so the
code it generates can be considered cold on the disk when it comes to compiler input. Using features like Source Link
EmbedUntrackedSources, a level of trust can still be maintained, while the platforms that care
about deterministic builds will be satisfied.
I've long been impressed with the ability for tools like WinDirStat to easily and effectively show off the relative sizes of files in an immediately understandable and consumable way. However, the options for Treemap controls in Windows Forms came in two flavors: Those in expensive commercial control packs, or nonexistant. Searching around and coming across libraries like JIT and some helpful posts on StackOverflow, I decided to be what I wanted to see.
The WinForms TreeView has an interface close enough to what I'd consider acceptable as an API for a Treemap. I decided
to model cmdwtf.Treemap after the TreeView, trying to mimic the API as closely as possible so that
be a near drop-in replacement for
cmdwtf.Toolkit is a small .NET library with a collection of random features. It's essentially a conglomeration of the dozens of snippets
and other assorted bits of C# code I've been dragging around in one form or another for nearly two decades now. I decided to package it up
so that reuse would be easier than copy-paste into whatever project I was working in at the moment. I took that a step further by actually
setting up GitHub actions for CI/CD. When a commit is made with new version information, the CI/CD script will build, verify, and publish
the library on NuGet automatically.
I also took the opportunity to try at targeting the largest amount of .NET frameworks I could with these projects, resulting in a package that successfully targets 7 different ones! When .NET 6.0 releases, I'll be sure to add that as an 8th.
I needed a third hand. I found myself often wanting an extra ability to press a keyboard button or mouse click while I was working on hardware where both of my hands were tied up. I figured my feet were free, so why not use a foot pedal to work as a keyboard press or mouse click.
This project is the quick and dirty implementation of exactly that.
KeePassDiceware is a project that was born out of seeing someone else do it well. I've been using Phoebe Code Limited's Strongbox iOS and macOS apps as my password management solution on those platforms. One of the features of their password generator, is to generate "Diceware style" passphrases. I quickly grew an affinity for the memorability of the types of passwords it generated, as well as was pleased with the configurability it offered in doing so. I decided to replicate that functionality as a plugin for KeePass Password Safe, since that's what I use on Windows.
NumberStones was born out of a desire to replace the late Sidekick Discord bot. There's a lot of functionality missing
and a long way to go, but
cmdwtf.NumberStones serves as the basis of the RNG backend for MathRox, the Discord bot.
MathRox provides a simple, easy to use interface for dice rolling and simple mathematic expression solving, all neatly wrapped up in a discord interface. I don't currently host the bot anywhere, but just spin it up for my friends and I when we want it. I may look into running an instance of it publicly at some point, though.
Inkify is a .NET 5.0 command line tool to reduce image colors, dither them, and size them to fit nicely on Pimoroni eInk Displays. The idea is that you can run an image through Inkify to quantize the colors to a subset that will work with a given display. You're able to choose a desired dither algorithm, as well as a target display to spit out an image that is color reduced and resized to fit on the screen.
ilvlbot is a Discord bot that can dynamically pull World of Warcraft character information. Written in 100% C#, ilvlbot was my first serious tiptoe into the Discord API, as well as my first .NET Core project. My goal for this project was to not only provide quick, easy-to-access character information for our gameplay, but also to explore a few different aspects of the Discord API I hadn't before. I was also interested in consuming a public API (Battle.net), via HttpClient, as well as handling the real-time request loop to fetch the info and return it to the caller in Discord. This was especially interesting to me, as it was the largest use of async/await in a project I'd done to this point.
While I was already familiar with git, this was also the first project that I wanted to get on GitHub, rather than hosting my own svn repos like I had in the past.
Future improvements I'd like to implement include better caching support, fail/retry policies, and per Discord server settings.
"Is There A Queue" is a single-function website that started off a bit as a joke. When I was actively playing World of Warcraft, every time a new expansion came out, my guild's server would constantly fill up, resulting in wait times up to hours! Some guild-mates joked that it'd be nice if there was a quick and easy way to check our server status so we could know if we needed to log into the game ahead of time, in order to try and not get caught in the queue. Thus, isthereaqueue.com was born.
As one of my first PHP projects, taking a look back at the code leaves a lot to be desired.
I'm not sure if I'll revisit this project, (other than to begrudgingly make sure the Battle.net API keeps behaving,) but if I do, a complete rewrite is probably in order.
The domain expired in 2022, and as such the project is currently defunct.
bitcoinbot was a Discord bot that could be used to retrieve the value of Bitcoin and Etherium on demand. It served as a proof-of-concept application to first try Discord.Net, bitcoinbot started life as a very tiny always-on-top WinForms application. This project was an exercise to move its logic to be accessible via Discord instead of a standalone application.
This website itself is also a small project of mine. Created as a mini portfolio as well as contact card it also serves as a test environment for tinkering with different web technologies.
I'm not web designer by trade but I do like to keep up with some of the latest technologies; for example, this site makes use of Open Graph style metadata. This results in a clean and usable embed on Twitter, Discord, and other social channels.
While I have experience with managed hosting providers from shared hosting to cloud platforms such as AWS, I still occasionally enjoy dabbling in hardware and software (both consumer and professional) at home. When I needed to host my Discord bots, as well as any other content I wanted to make available from my personal network, I decided to take a mildly enterprise look at running things. Using an older, headless micro desktop, I configured a VMware ESXi Hypervisor to run two virtual machines.
One of the VMs ran Red Hat Enterprise Linux (RHEL), to run Apache httpd, as well other Linux-based flavor-of-the-month projects. It also served temporarily as my personal Linux development environment but I quickly discovered the low memory allocation coupled with attempting to use X11 via SSH was more frustrating than it was worth.
The other VM runs Microsoft Windows Server 2016, and is the hosting environment for my C#/.NET/.NET Core based Discord bots.
In the past, the Windows VM often found itself in charge of handling dedicated game hosting, for the games my friends and I were playing at that time. Provided that the CPU/RAM wasn't too limiting.