Developer

Code, configuration, and experimental utilities.

AI-Accelerated Engineering

Experimental tools, applications, and configurations built almost entirely with AI. Unless otherwise noted, these were co-authored with Gemini models, highlighting rapid AI-driven development.

SavorSync

A local-first culinary tracker using a private GitHub repository as a persistent JSON database (Git-as-a-DB). Features Dexie.js offline caching, a tokenized 26k+ ingredient search engine, and RBAC admin controls. Built via AI pair programming.

Next.js IndexedDB Auth.js Gemini AI

View Demo

GridLock

A Wayland-native, Qt6 graphical MPI debugger powered by the Debug Adapter Protocol (DAP). High-performance HPC tooling, architected and built largely through AI pair programming with Gemini.

C++23 Qt6 Wayland Gemini AI

Source

WurmExplorer

The Ultimate Pro Workstation for Wurm Online players. Includes cartography, a mechanics grinder simulator, and live skill sync. Accelerated by Gemini AI for rapid C++23 native development.

C++23 Qt6 Reverse Engineering Gemini AI

Source

DGPP

A minimal Linux x86_64 ptrace debugger in C++17. Focuses on local debugging, software breakpoints, and DWARF source mapping. Another pure vibe-coded exploration using Gemini models.

C++17 Linux ptrace GPT 4

Source

HPC-Emacs

A specialized Emacs configuration crafted for High-Performance Computing workflows. Automated and enhanced using AI to perfectly suit complex C/C++ development environments.

Emacs Lisp HPC Gemini AI

Source

bn-fedora-setup

Configuration and installation scripts to provision a complete development environment on Fedora Server for Elixir, C/C++, and C#. Bootstrapped and refined with the help of Gemini.

Bash Fedora ZSH Gemini AI

Source

RungBot

A distributed algorithmic grid-trading engine built on Elixir/BEAM. Features concurrent OTP supervision, sub-millisecond ETS state caching, zero-JS Phoenix LiveView telemetry, and dynamic multi-exchange lot-pairing. Architected with Gemini AI.

Elixir Phoenix LiveView OTP Gemini AI

Code Snippets

Ready-to-use boilerplate and high-performance utilities.

Install OpenMPI (Arch)

bash

One-liner for Arch/Manjaro.

sudo pacman -S openmpi

HPC Setup (Fedora/Ultramarine)

bash

Install OpenMPI, VisIt, and ParaView. Highly recommend running this on Ultramarine Linux for the best out-of-the-box workstation experience!

sudo dnf install openmpi openmpi-devel visit paraview

MPI: 2D Cartesian Topology

cpp

Initializes a 2D Cartesian grid communicator for optimal domain decomposition.

#include <mpi.h>

MPI_Comm cart_comm;
int dims[2] = {0, 0}; // Let MPI auto-balance
int periods[2] = {0, 0}; // Non-periodic boundaries
int reorder = 1;

// Get total ranks and compute optimal grid dimensions
int world_size;
MPI_Comm_size(MPI_COMM_WORLD, &world_size);
MPI_Dims_create(world_size, 2, dims);

// Create the topology
MPI_Cart_create(MPI_COMM_WORLD, 2, dims, periods, reorder, &cart_comm);

// Get our grid coordinates
int my_rank, coords[2];
MPI_Comm_rank(cart_comm, &my_rank);
MPI_Cart_coords(cart_comm, my_rank, 2, coords);

MPI: Non-Blocking Halo Exchange

cpp

Asynchronous ghost cell swap (halo exchange) using MPI_Isend / MPI_Irecv. Overlaps communication with computation.

// Assuming neighbors are determined via MPI_Cart_shift
MPI_Request reqs[8];
int req_cnt = 0;

// Post Receives
MPI_Irecv(recv_buf_north, nx, MPI_DOUBLE, nbr_north, 0, cart_comm, &reqs[req_cnt++]);
MPI_Irecv(recv_buf_south, nx, MPI_DOUBLE, nbr_south, 1, cart_comm, &reqs[req_cnt++]);
MPI_Irecv(recv_buf_east, ny, MPI_DOUBLE, nbr_east,  2, cart_comm, &reqs[req_cnt++]);
MPI_Irecv(recv_buf_west, ny, MPI_DOUBLE, nbr_west,  3, cart_comm, &reqs[req_cnt++]);

// Post Sends
MPI_Isend(send_buf_north, nx, MPI_DOUBLE, nbr_north, 1, cart_comm, &reqs[req_cnt++]);
MPI_Isend(send_buf_south, nx, MPI_DOUBLE, nbr_south, 0, cart_comm, &reqs[req_cnt++]);
MPI_Isend(send_buf_east, ny, MPI_DOUBLE, nbr_east,  3, cart_comm, &reqs[req_cnt++]);
MPI_Isend(send_buf_west, ny, MPI_DOUBLE, nbr_west,  2, cart_comm, &reqs[req_cnt++]);

// Do inner domain computation while communication is in flight
compute_inner_domain();

// Wait for boundaries
MPI_Waitall(req_cnt, reqs, MPI_STATUSES_IGNORE);
compute_halo_regions();

Kitpp: RAII Scope Timer

cpp

Measures execution time and calculates throughput of a code block using C++17 chrono.

#include "kitpp/timer.hpp"
#include <vector>

void process_heavy_workload(size_t elements) {
    // Timer starts on instantiation, stops and logs on destruction
    kitpp::ScopeTimer timer("HeavyWorkload", elements);
    
    std::vector<double> data(elements, 1.0);
    
    #pragma omp parallel for
    for(size_t i = 0; i < elements; ++i) {
        data[i] = data[i] * 3.14159;
    }
    
    // Auto-Output: [Kitpp] HeavyWorkload finished in 14.2ms (70.42M ops/sec)
}

Kitpp: Thread-Safe Async Logging

cpp

Zero-overhead, thread-safe asynchronous logging macros from Kitpp.

#include "kitpp/logger.hpp"
#include <omp.h>
#include <exception>

int main() {
    kitpp::Logger::init("run.log", kitpp::LogLevel::INFO);
    
    KIT_INFO("Application starting with {} threads", omp_get_max_threads());

    #pragma omp parallel
    {
        int tid = omp_get_thread_num();
        
        // Thread-safe lockless queue insertion
        KIT_DEBUG("Worker thread {} initialized", tid);
        
        try {
            // ... computation ...
        } catch (const std::exception& e) {
            KIT_ERROR("Thread {} encountered fatal error: {}", tid, e.what());
        }
    }
    
    kitpp::Logger::shutdown();
    return 0;
}