Portfolio · Deep Dives

The Hard Parts

Anyone can list projects. Here's what actually made each one difficult — the engineering underneath the playful surface. Systems code in C, real-time AI, published HCI research, and shipped products across web, iOS, and self-hosted infrastructure.

Systems Software · C11

FloofClaw

Tiny code. Sharp claws. The engine agents run inside.

Most "agent frameworks" are wrappers that call an LLM in a loop and hope. FloofClaw takes the opposite bet: it's a durable control plane for agentic systems that decides when intelligence is needed — and handles everything else deterministically, without pretending it needs an LLM.

447 KBstripped binary
7 msevent log → reducer → artifacts
9.7 MBresident, Discord + IRC live
2dependencies (libcurl, OpenSSL)
  • Event-sourced to the core. The event log is the source of truth; state is a materialized view. Any run — including every individual LLM call — is its own inspectable artifact on disk and can be replayed exactly.
  • Deterministic where possible, intelligent where necessary. A quiet supervision review costs exactly one LLM call. The kernel doesn't know what kind of loop it's running: loop profiles ("floops") define ordered steps, steps run agents, builtins, or actions, and a deterministic reducer applies their events to state.
  • ~27K lines of C11. No runtime, no framework, no garbage collector. A full durable run completes in 7 milliseconds, and a live production bot holds under 10 MB of memory while connected to Discord and IRC simultaneously.
  • Accountable over time. Durable standing concerns with scheduled reviews, detached background workers, and proactive messaging — agent work that survives restarts and can be audited months later.

Mobile AI · iOS

Barkimedes

An AI dog therapist that never breaks character.

Barkimedes in action

Barkimedes sounds like a joke until you try to build one. It's a production AI companion, shipped to the App Store, that holds real-time therapeutic-style conversations — as a dog — without ever slipping out of persona.

  • Personality engineering at scale. Keeping an LLM warm, funny, on-persona, and genuinely helpful across long free-form conversations is a harder prompt- and guardrail-design problem than any demo suggests. Barkimedes stays Barkimedes, message after message.
  • Real-time conversational AI in production. Live LLM sessions with streaming responses, session state, and graceful failure handling — running as a consumer product, not a lab demo.
  • Shareable deep-linked sessions. Conversations can be opened from encoded share links (bark.flooflogic.com/share?b=…), so a chat can start mid-thought from a URL — a small feature with a surprising amount of state-bootstrapping machinery behind it.
  • Full product surface. App Store release, subscription handling, support, privacy, and terms — the whole unglamorous perimeter that separates a shipped product from a prototype.

HCI Research · Input Design

The One-Handed Keyboard

The Schwem-Dante Layout (SDL): a reference design for one-handed, gesture-based text entry.

The Schwem-Dante Layout keyboard

Text entry is one of the oldest problems in human-computer interaction, and one-handed text entry is its hardest corner — accessibility, mobile, and wearable contexts all demand it, and nothing standard serves it well. The SDL is our answer: a from-scratch layout and gesture system designed around what one hand can actually do.

  • A designed layout, not a squished QWERTY. The SDL rethinks key arrangement and gesture vocabulary from first principles for single-hand ergonomics, rather than cramming a two-handed layout into half the space.
  • Published research. The design ships with a full whitepaper and a condensed scientific paper — assumptions stated, trade-offs argued, layout diagrams included. It's a reference design others can build on.
  • Interactive proof. A live animated demo shows the layout and gesture flow in the browser, so the design can be evaluated by feel, not just by reading.

Systems Software · Infrastructure · Private Beta

Project Vellum

Direct to Git, on the fly!

The Vellum repository browser

Vellum is your own private GitHub — a repository browser and Git-over-HTTPS server you deploy without a webserver framework. No nginx, no Apache, no application stack: one binary written in C serves the browsing UI and speaks Git smart HTTP directly. It's the infrastructure Floof Logic itself runs on — our repositories live on Vellum.

  • No webserver framework, period. Vellum is the server. Built on libwebsockets with a bundled OpenSSL LTS runtime, it speaks Git smart HTTP for clone, fetch, and push over the same URLs you'd expect from a hosted service — straight from the binary to your repositories.
  • Serious authentication. System-native PAM login, group-based read/write authorization, and staged per-repository access policies — real multi-user permission machinery, not a password in a config file.
  • Novel TLS architecture. Public access flows through a custom TCP relay so Vellum terminates its own TLS end-to-end — Cloudflare provides DNS only, never sees traffic, and certificates renew automatically via DNS-01 with a minimally-scoped API token.
  • Installable, not artisanal. Script-assisted installation from release bundles: hardware you control goes from zero to serving authenticated Git over HTTPS with a handful of commands.

Games · Browser · AI-Assisted

Floof Arcade

Fun little games that prove the pipeline.

Shiplash, Seagull Squabble, and Pour Decisions are AI-assisted browser games — Floof Logic validates its development pipelines by shipping complete, polished, playable games, not just prototypes. They have their own wing of the site.