Joseph Madigan

Systems and tools, mostly in Rust. I build software where the files outlive the app: terminal UIs, peer-to-peer systems, and developer tools — and by day, a local-first desktop AI app at EdgeRunner AI.

Not job-hunting; I'm building. Always up for talking with people doing interesting work.

Resume

career

One thread runs through all of it: people. Years on theatre floors and behind coffee bars taught me to read a room, win someone over, and build a team that shows up. I came to engineering with that instinct intact and build software the same way: start with the person on the other end. The EdgeRunner roles expand for detail.

workedu

Machine Learning Engineer

EdgeRunner AIAug 2025 – Present

Supporting the engineering team on a local-first desktop AI app, with shipped work across export, rendering, performance, and security.

~50+ shipped issues across roughly 14 months

- A teammate profiled the streaming hot path and pinpointed the critical areas; we shaped the optimization approach together.
- The whole growing message was being re-processed every animation frame, an O(n) per-frame cost that compounds to about O(n²) over a long response.
- Removed a duplicated full-content scan that ran twice per frame on identical input.
- Added a bounded LRU cache for math rendering keyed on content and display mode, caching failures too so malformed math stops retrying every frame.
- Shipped as zero-behavior-change wins: byte-identical output, unchanged streaming pacing.

ML Engineer Intern

EdgeRunner AIMay 2025 – Aug 2025

Started on scoped UI fixes and grew into owning full features across the frontend and the Python backend.

Lead Barista

Story Coffee2024 – 2025

Led the bar at a specialty shop. Trained new baristas, passed along the craft, and looked after the regulars who made the place. The role that cemented coffee as a lasting love; I'm an at-home enthusiast now.

Barista → Lead Barista

Starbucks · Queen Bee Cafe2022 – 2023

The years coffee taught me people: reading a room, winning someone over, and making an ordinary moment a little better.

Floor Staff → Theatre Manager

Cinemark · Lincoln Square Cinemas2015 – 2021

Six years and four promotions, and where I learned to lead. Cinemark's "one guest at a time" became how I ran a floor: build a team that cares, and the guest experience follows.

B.S. Computer Science

Bellevue College

2023 – 2025

After the AA, I shifted everything toward finishing the degree.

A.A.S. transfer degree

Bellevue College

2017 – 2023

The long stretch: part-time, fit around full-time work.

Projects

Open source, linked, and documented. Nearly everything here chases the same idea: files you own, tools that get out of the way.

WhatNext

Built a local-first Electron desktop app with a Coordinator Model — one user connects to Spotify, imports playlists, and opens a P2P session that friends join with zero OAuth friction
Implemented real-time P2P networking with libp2p featuring mDNS discovery, Noise encryption, Yamux multiplexing, and RxDB replication over custom protocols
Engineered remote connectivity via circuit relay server and DCUtR for NAT traversal, enabling sessions across networks
Developed collaborative session features including co-host model, playback mutex, turn-taking, reactions, and presence indicators
Designed an import adapter architecture abstracting streaming services into a canonical format, with Spotify as the first adapter
Built a companion client enabling phone/browser session viewing alongside the desktop app
Stored all user data as plain-text Markdown with YAML frontmatter, so it stays portable and fully owned by the user

Pour

Built a frictionless, instant-booting TUI in Rust for structured data capture into any Markdown folder, with first-class Obsidian vault support
Engineered a hybrid transport layer with API-first writes via Obsidian Local REST API and automatic filesystem fallback so capture never blocks
Designed a fully config-driven module system — modules, fields, paths, templates, and conditional show_when visibility all declared in TOML with no hardcoded behavior
Implemented vault-sourced dynamic dropdowns with a 3-tier fallback chain (API → disk scan → cache → freetext) that renders instantly from cache while refreshing in the background
Shipped a contract-first mobile PWA companion (pour serve) — embedded in the binary via rust-embed, served over LAN with QR-code pairing, constant-time token auth, and per-module opt-out
Built an offline-first capture path on the PWA — IndexedDB queue with idempotency keys, service worker app-shell cache, FIFO drain on reconnect, and synthetic-202 wire shape negotiated as a ratified contract amendment
Designed a sub-form overlay system that captures structured frontmatter for novel dynamic_select values inline (e.g. logging a coffee with a bean that doesn't exist yet), preserving the keyboard-first capture flow
Engineered a layered preset system — per-module presets with hierarchical drilldown picker (method × bean × intent), per-field presets for repeatable composite arrays like brew recipes, and atomic JSON persistence
Sealed the v1.0.0 foundation across decomposition, lock-in, and hardening — collapsed 8 god-modules behind a focused module tree, 18 ad-hoc atomic-write blocks behind a single transactional Config::edit(), and 3 hand-rolled JSON stores behind a generic JsonStore<T> with migration hooks
Hardened the write path for the freeze — rejected .. traversal across all fs entry points, locked Windows atomicity to MoveFileExW, char-indexed the textarea cursor for emoji and CJK, escaped strftime tokens in user templates, and surfaced previously-swallowed persistence failures via a status-bar toast
Locked the pub surface and enforced an 800-LOC file-size CI ratchet at v1.0.0 — 891 passing tests across config, transport, server, PWA contract surface, and TUI rendering, with cargo clippy -D warnings, cargo fmt --check, and cargo doc -D warnings all green

seed

Built an event-sourced workspace in Rust (3 crates) — a pure domain core with no I/O, a writer daemon that owns mutable state, and a TUI client that mirrors state via length-prefixed JSON over local sockets
Designed an append-only event log with periodic snapshots — daemon replays events past the snapshot's skip count on boot, persisting every 100 events or 5 minutes
Implemented cross-platform IPC via interprocess (Unix abstract socket / Windows named pipe) with per-connection mpsc routing and broadcast fan-out for state diffs
Engineered single-instance daemon lifecycle: socket-probe locking with stale-socket recovery, graceful Ctrl-C drain that flushes a final snapshot before exit
Built a generative mandala renderer combining braille (core), block/half-block (petals), and box-drawing (spokes) — per-cell truecolor with 256-color quantization fallback, locked by a byte-compared golden snapshot
Designed a versioned wire schema where unknown event kinds round-trip via Event::Unknown so forward-compatible tooling never silently loses data
Modeled an OSRS-style 1-99 XP curve across nine wellness traits with SEED → ZENITH prestige tiers, driving mandala evolution from sparse seed to full bloom

graft

Built a standalone TUI and CLI tool (formerly git-identity) that manages cross-OS development workspaces from one YAML config — per-account git identity routing plus per-platform build-output redirection over a shared source tree
Generated includeIf gitdir: identity routing and github.com-{alias} SSH host blocks for juggling multiple GitHub accounts with directory-based switching
Added workspace links that redirect build output (target/, node_modules/, .venv/) off a shared NTFS partition onto each platform's native filesystem — real symlinks with a Windows directory-junction fallback when elevation isn't available
Implemented non-destructive config generation using a managed-block pattern that preserves user content in ~/.gitconfig and ~/.ssh/config
Designed a layered architecture separating pure business logic (core) from I/O, UI, and a consent-gated permissions system
Engineered cross-platform support (Windows, macOS, Linux) with atomic file writes, backup creation, dry-run mode, and a per-machine config.local.yaml overlay for host-specific paths
Shipped graft path so scripts can resolve the correct source tree per host, plus an interactive setup wizard for zero-friction onboarding of new machines

Digest

Forked EmailEssence's proven backend into a local-first Electron desktop app — no cloud deployment, no remote database
Built a FastAPI sidecar spawned as a subprocess by Electron, communicating via localhost HTTP with typed IPC bridging all renderer-to-backend calls
Replaced MongoDB with SQLite (aiosqlite) for fully local data storage
Implemented Electron-native OAuth 2.0 with tokens secured in OS keychain via safeStorage — no JWT in localStorage, no token storage in the database
Designed a pluggable AI summarization provider system supporting local inference (Ollama, llama.cpp, LM Studio) alongside cloud providers (OpenAI, Gemini, OpenRouter)
Packaged with electron-builder bundling the Python backend via PyInstaller so end users need no separate Python install

EmailEssence

Email Productivity Tool — Capstone Project
View App - View Code
October 2024 - June 2025
Stack: JavaScript | Python | OpenRouter API

Architected a modular backend with clear separation between routers, services, and providers
Built IMAP email service with parsing and reader view capabilities
Implemented Google OAuth with token validation endpoints
Designed abstract AI summarization service supporting multiple providers
Established CI/CD pipelines and Docker configurations
Created API testing fixtures for code quality assurance

ReverbXR

Web-based 3D/XR Audio Visualizer
View App - View Code
April 2024 - June 2024
Stack: HTML | JavaScript | Web Audio API

Developed a web application for real-time audio processing and 3D visualization using Web Audio API and A-Frame
Designed and implemented a modular architecture for managing audio processor states
Handled microphone input and audio file processing