Personal Projects

Here are some personal projects of mine that have been publicly uploaded. If you want to see all of my open source work including the ones I have not done a writeup on I keep a mirror of my work on Github. This includes some infrastructure tooling of mine, but if you want to see that including the parts that are not uploaded please take a look at my Infra page.

Rationale\development process

I have learned from my time working at smaller companies where you have limited resources that a MVP is usually the smart move. Most of my projects start because I have a problem or I want something. Oftentimes someone else has written a solution to the problem and often that solution is good enough, but sometimes I find that I need to either abstract on it or write an addition and in which case that's perfect. Othertimes what I want doesn't exist or does not exist exactly the way I want it.

My path for years has been write a prototype, test it, and then see if I actually use it. Nowadays many of my prototypes are in fact heavily AI generated just to see if the idea makes sense on paper. I also often pick languages where development is faster over raw execution speed just so I can iterate on the code faster, I am very much a polyglot (C, C++, Rust, Go, Python, Java, C#, and Elixir just to name a few) so I pick what makes sense for the project at hand. Above all my goal is to make my idea a reality and test it...something is better than nothing. These projects all go up on my local gitea instance.

Using the rapid development infra I have a single PR can be opened by an AI agent that then creates a CI pipeline which deploys the software onto the network with high availability and logging. This lets me actually see that the code is good and make rapid bugfixes\changes. Because most of my deployments actually go to a K8s cluster or are compiled for a personal development box it is actually very trivial for me rapidly test changes and just get something working. Having a working solution in 2 hours for a task that goes across the network is fairly standard.

My code then goes through a phase of actually being used...this could be a few hours, a few days, a few weeks, or even a few months. If the idea is actually good then I go through and cleanup as well as rewrite any code so I can maintain it long term. If an AI generated it then I am likely looking at almost complete rewrites of multiple sections and axing certain poor architectural decisions. If the idea was terrible it gets removed from the network and I move the project into an inactive org on Gitea. After my cleanup is done my work is rebased, the README is updated, and a clean initial commit is pushed to Github. This can result in very strange situations where you have 1400+ commits on Gitea, but only 230 something on Github.

Local developer tooling

Most of local developer tooling is pretty standard and off the shelf, but I do make use of a custom shell prompt generator written in rust and a small selection of scripts that are bound to aliases in my shell to allow me to quickly manage across multiple git origins and see the project state. My local dev tools are located here and I make use of: Zed for my IDE, OMLX\Ollama for local AI inference, Letta for AI agents, and Linux with a tiling window manager (and a lot of macros) for my dev system. I prefer a simple and fast system.

Projects

A short list of a few projects of note and a summary. Some of these have full technical writeups and some just have writeups on Github.

Athena

Athena is partly a VDI application for remotely application as a well as a wrapper around emulation and utilities like Waydroid. It is one of the core tools I use in my day to day use of a machine. The intent is to provide a simple API and interface for launching application regardless of the source, machine, or any strange nuance like a setting change that might be needed. Effectively, you should be able to run any program on any machine with just one command or a selection in a TUI\GUI. For more information you can take a look at the full writeup here or see the code on Github.

Timekeeper

Timekeeper is a set of microservices, daemons, and userspace utilities for managing ones time and notifying others when you are working on something. It is designed with high availability and external APIs in mind. Athena also integrates with it by limiting whether or not an application can open based upon the configured hours the user is expected to have hit. It is in many ways a local timeclock, but written purely for someone like a student, freelancer, or someone with a side project so that they can hold themselves accountable for the amount of work they do each day. The full writeup on this project is here and the code is on Github.

Hurricane sync

A highly multithreaded backup application that wraps rsync over ssh. On a dry runs show roughly 800k being checked for differences in about 1.8 seconds over consumer hardware. This tool exists because rsync over ssh in spite of its versitility lacks any real parallel processing. This was mainly written for backing up my local desktop and syncing my laptop with my main dev machine in the den before and after trips. For more information take a look at the writeup here

OMLX monitoring

A simple REST API which makes requests from the OMLX API across multiple nodes and shows the metrics as a single endpoint so that a single pane of glass can be used. Includes a waybar extension and a website\TUI (build as an external project by a different developer). This is mostly written so that if multiple people are using an OMLX backend or cluster of servers no one steps on the other person's toes. For the source code take a look on Github.

Home assistant status

A simple REST API and waybar binary that renders the state of entities in home assistant. This is also used by the VM watchdog I have to determine if it needs rebooted. The code is available here.

Waybar net\data daemon

When adding a custom data element to waybar what you typicaly do is add a script that outputs the data in a json at x interval. This isn't terrible, but you can save a bit of compute by instead having the respective binary communicate over a unix domain socket for the information. This socket will also be far more resilent than a network connection which allows you to handle all of the data connection issues in one spot. This daemon is written in rust so as to keep the overhead on the host system small. More information here

KVM daemon

A small project I wrote for managing the monitors on 3 PC 2 monitor that currently has 4 monitors connected where some systems can use 1, others 2, and only one can use 4. It's a niche project, but a mildly interesting one. For more information you can read up on it here.

Planner

A schedule solver for putting in obligations you have and then programmatically generating a recommended schedule that fulfils them. This was mostly written because I could not find a good solution to it around. For more information take a look here.

OS remote orchestration binaries

A set of binaries designed to handle remotely ochestrating a machine that has 3 OSes installed on it including cold booting, setting boot options, and spinning up VMs. It's actually used fairly regularly and has been used by myself for years. As hard it is to believe this is the most optimal solution to the problem. The writeup on why as well as how this works is written up here and the code is available on Github here.

Automation state

A dead simple service designed to expose a MariaDB\MySQL backed storage as a REST API with key\value pairs. This is intended for home autoamations as almost any home automation platform supports REST while not all support something like redis. This is used for automations in my home that live outside of home assistant. The source code on this is on Github here.

Random wallpaper over http

I like having random wallpapers, but I don't like storing all the files on my device. The cleanest way to do this across all OSes is to request one from an API over a script, write the image to disk, and then use whatever respective call to actually set it. For example here is a project that handles the code for setting it on Linux with gnome, most desktop OSes have one for provisioning purposes by IT teams, and both iOS as well as Android have an API to set a wallpaper. For example on Android I use Tasker to download the wallpaper and set it. Using a dedicated service for this means each respective client does not need to reimplement the logic and the wallpaper list can be kept in memory which makes a look much faster for large folders of images. This service is written in Rust due to the speed required for image analysis and the source code is on Github.

Email summarizer

A simple python script to control the prompt and model used to summarize emails. This allows one to be more specific with how their emails are reviewed. The code is available on Github.

Arch upstream modification tooling

A small set of helper functions to modify Arch packages and compile the modified PKGBUILD. This repo also includes my current out of tree changes for Arch Linux, I use this tooling because it provides a clean way to maintain packages from testing as well as modified packages for things like mesa (a key component in the Linux graphical stack, check here for more info). The source code for this is on Github.

Arch AUR builder

A local CI\CD pipeline for building Arch Linux packages and uploading them to Gitea so that they can be loaded like a stable package by pacman on Arch. This was written to build packages I needed for VR on Linux. This repo just handles builds with a local repo of PKGBUILD and their respective SRCINFO by building the dependency tree and then uploading the built binaries. It is designed to run in docker\OCI, in my case this is deployed on k8s as a cronjob that runs weekly. For more information on my infra please take a look here. For the writeup of the AUR builder please take a look here and for the code take a look on Github.

Home automation platform

A now mostly retired project includes a home automation platform of mine that allowed me to directly control smart devices before home assistant got as mature as it is today. Note...I say mostly retired. The state microservice actually survived and lives in my network for use in automations where I feel home assistant is not the right pick (this is often due to too much complexity or even today a missing integration). The state microservice is on Github btw. The full writeup on this platform is here. The remaining archived services are here: state-monitoring-panel, state-backup-server, iot-state-translation-layer, iot-state-server, iot-network-relay, iot-network-proxy, iot-device-relay, automation-server, auto-dns, and local-remote. This project had most components retired because honestly...home assistant got a lot better. My original deployment of this was in 2020 and it was taken offline in 2024.

Note to the reader

I have a large number of projects on Github that currently do not have writeups, at least a few of these will be getting them, but if this work interests you please do take a look at my Github for all of my projects. Do note that is project is archived that means I have stopped using it, if the software is on my Github it is actively being used by me somewhere on one of my machines or in the network.

Website Stats:

Website Build Version: 2026/11/20 11:46:51 AM (+00:00)

Last Website Update: 62193f6

Site Generator: Serpent Page Generator created by Lucia Smith