Projects

Inochi

github.com/realtradam/inochi-timetracker

Technologies: Ruby, Rails 8.1, PostgreSQL 17, ActionCable, Solid Queue / Cache / Cable, OmniAuth, Stripe, TypeScript, React 19, TanStack
Router, TanStack Query, Vite, Dexie (IndexedDB), Tailwind CSS 4, daisyUI 5, Docker, Docker Compose, Dokploy, Nginx, Tailscale, gopass

A full-stack, offline-capable time-tracking and personal-analytics PWA with a paid subscription tier. Built as a production-grade SaaS i
n miniature.

Domain model – users track tasks and the events (time sessions) logged against them. Everything syncs offline-first: the client
buffers writes into IndexedDB and reconciles with the server via dedicated tasks/sync and events/sync endpoints.

Analytics layer – summary stats, per-task stats, daily breakdowns, timeline feeds, active-days queries, goal-progress tracking, and per-
user IANA timezone handling (validated server-side).

Monetization – full Stripe integration with monthly, yearly, and lifetime tiers. Includes 14-day trials on subscriptions, hosted che
ckout, a billing portal for self-service, webhook-driven premium activation, and a premium_until model on User for gating.

Architecture highlights:

Realtime: ActionCable (user_channel) for live cross-device sync
Infra: Dockerized dev + prod, Dokploy-ready, Nginx, Tailscale HTTPS certs for local dev, secrets managed via gopass

Inochi is the project where I’ve been pushing hardest on production-grade polish – offline-first data flow, HTTPS in development, real-time
sync, GitHub OAuth, Stripe billing, and a clean separation between a Rails API and a statically-hostable React SPA.

Orc: Arena of Time

github.com/realtradam/orc-arena-of-time · [Play on itch.io](https://tradam.itch.io
/orc-arena-of-time)

Technologies: Ruby, mRuby, Raylib, FelECS, FelFlameEngine, Zig (desktop build), Emscripten / WebAssembly (web build), Rake

A Raylib 5k gamejam entry written in Ruby, running on a custom toolchain I built from scratch.

The stack under the hood:

Raylib for rendering
mRuby Bindings I wrote to expose Raylib to Ruby
FelECS – my own ECS framework (see below)
FelFlameEngine – a customized mRuby build pipeline that compiles Ruby games to native des
ktop (via Zig) and web (via EMCC)

Playtest iteration is instant: Ruby files are bundled and run through an mRuby interpreter with no compile step, and release builds target L
inux and WebAssembly.

Dispatch Adapter – Copilot

github.com/realtradam/dispatch-adapter-copilot

Technologies: Ruby, net/http, Server-Sent Events (SSE), GitHub Copilot API, GitHub device OAuth, RSpec, RuboCop

A Ruby gem providing a provider-agnostic LLM adapter interface with a complete GitHub Copilot implementation. No SDK, no CLI – just
net/http directly against the Copilot API.

Supports:

Chat completions with canonical structs (Message, Response, ToolUseBlock, etc.) so app code stays provider-agnostic
Streaming via Server-Sent Events
Tool/function calling with structured input/output
Reasoning-effort control for o1/o3/o4-mini
Automatic GitHub device OAuth flow with persisted tokens and automatic Copilot-token refresh
A clean Dispatch::Adapter::Base interface so additional providers (Anthropic, OpenAI, Gemini, local models) drop in behind the same API

This is the piece I use to power custom tooling – it’s what lets my other projects (like Hukumusume) run mass LLM agents without being tied
to any one vendor.

FlashAir SpeedSync

github.com/realtradam/flashair-speedsync

Technologies: Svelte 5 (runes), TypeScript, Vite, Tailwind CSS 4, daisyUI 5, FlashAir CGI API, WSL2 drvfs, Bash

A fast photo-preview webapp for Toshiba FlashAir WiFi SD cards – a drop-in replacement for the official FlashAir app.

The official app has a thumbnail grid but forces slow manual refreshes, loads out of order, doesn’t preload full-size images, and has a clun
ky viewer. SpeedSync fixes all of that:

Bundled by Vite into pure static files
Lives on the SD card itself – connect your phone to the card’s WiFi, open the page, done
Newest-first thumbnail loading, background preloading of full-size images, 1.5s polling for new shots
Two-panel layout with pinch/zoom preview and a flower-style floating action menu (auto-show-new, cache control, theme toggle, etc.)
Deploys via a bin/build script that auto-mounts the SD card over WSL2 drvfs and copies the build output

It turns the FlashAir from “functional but painful” into a tethering workflow I actually want to use.

Hukumusume

Technologies: Ruby, Python, Bash, EPUB tooling, ID3 audio tagging, mass LLM agents via the Dispatch Copilot adapter

A large-scale pipeline for extracting hundreds of Japanese folk tales from hukumusume.com and turning them int
o both EPUB ebooks (with and without furigana) and a tagged audio collection.

The pipeline combines Ruby, Python, and shell scripts to:

Download story pages, audio files, and assets en masse
Convert encodings and extract clean text from messy HTML
Build EPUBs per “world” (geographic grouping), including furigana-annotated editions
Tag MP3s with proper metadata so the audio collection is usable as a standalone library

The interesting part: the text-extraction and formatting stages are driven by mass LLM agents running through my Dispatch Copilot adap ter – dozens of agents chewing through stories in parallel, with progress tracked per group and errors logged for retry. It’s a concrete s
tress-test of the adapter gem in a real, long-running workload.

Study Player

github.com/realtradam/study-player

Technologies: C, Raylib, raygui, MinGW (Windows cross-compile), Emscripten / WebAssembly (web build), xxd (asset embedding), Bash

A keyboard-driven MP3 player built in C with Raylib + raygui, cross-compiled from Linux to Windows (MinGW) and to the web (Emscripten/WA
SM).

Designed specifically for audiobooks and language study:

Analyzes the audio on load to detect silence gaps between spoken sections
Study Mode auto-pauses at the boundary between padding and silence, then jumps the playhead forward to the start of the next speaking
section – so you can listen to one sentence, pause automatically, shadow/translate, and hit a key to continue
Section counter (e.g. 12/70), jump-to-section keys, space-to-override, rewind-on-pause, 0-9 percent-seek, and progress-bar scrubbing
Fonts are embedded directly into the executable via xxd – single-binary distribution with no external resources
Web build runs in any browser at parity with the desktop version

Game Holster

github.com/realtradam/gameHolster

Technologies: Ruby, Rails, Active Storage, rubyzip, GitHub OAuth, TypeScript, React, Vite, Tailwind CSS

A full-stack Rails + React app for uploading and serving web games made with engines like Unity, Godot, and Raylib.

GitHub OAuth for user authentication
Users upload games as a zip archive; the backend extracts the zip on the server and attaches each file individually as an Active Stora
ge blob, preserving internal paths – so the game’s index.html can load its own assets without repackaging
Each game carries multiple image slots (card, character, title) and a draft → published status lifecycle
A tag system lets games be classified (e.g. by engine / platform)
Games are served on a separate domain from the app shell – a dedicated route (/game/:user/:game/*path/:file) lives outside the api/ v1 namespace precisely so uploaded content runs in its own origin. This makes XSS against the main site impossible even if a user uploads c
ompromised files – a deliberate sandboxing design choice

Kobold

github.com/realtradam/Kobold

Technologies: Ruby, Git (worktrees, symlink-based linking), RubyGems packaging

A Git-based package manager for libraries and projects. Clones repos into a local cache, creates Git worktrees for specific branches
or commits, and symlinks them into your project directories.

Automatic deduplication – the same repo is only stored once on disk no matter how many projects reference it
Both a Ruby API (for programmatic use) and a CLI (for standalone use)
.kobold config files declare dependencies, branches, and target directories
Supports isolated “databases” (separate cache dirs) so different sessions/agents can work without stepping on each other – e.g. kobold -- database orchestrator-session-1 invoke
Full lifecycle: init, invoke, fetch, register, checkout, branch, list, add, remove, update, clean

It’s the dependency-management layer that makes Orc: Arena of Time and FelFlameEngine actually manageable across multiple machines and branc
hes.

FelECS

github.com/realtradam/FelECS

Technologies: Ruby, mRuby (mrbgem), RSpec, YARD, CodeClimate

An ECS (Entity-Component-System) framework for Ruby, designed with three principles:

Engine-agnostic – works with any Ruby renderer (Ruby2D, DRGTK, my own FelFlameEngine, etc.)
Easily extensible – wrappers, premade systems, and premade components can be distributed as add-ons
Principle of (My) Least Astonishment – a Ruby-flavored API that mirrors how I actually want to write games

On top of the standard ECS primitives (Entities, Components, Systems), FelECS adds:

Scenes – groups of Systems that can be activated/deactivated wholesale
Stage – the set of currently-active Scenes, executed per frame
Order – an explicit priority system for Scene and System execution
Reactive triggers – Systems can be auto-invoked when a component is added, removed, or when a specific attribute changes

Available as a gem, a single drop-in file, or as an mrbgem inside FelFlameEngine. It’s the ECS powering Orc: Arena of Time.

Adam Malczewski

Welcome!