Why I Built a Desktop Cat to Keep Me Company While Coding (with Rust + Tauri)

#rust #opensource #programming #productivity

It Started with Loneliness

When you code alone, you eventually notice you've been staring at a screen with no one around.

In team projects, there's a feedback loop — PR reviews come in, someone drops a "LGTM" emoji on Slack. But side projects are different. You commit and nothing happens. You fix a bug past midnight and nobody knows. Motivation has to come entirely from yourself.

I wanted something that could cheer me on. Not a productivity tool — just something that feels like it's there with you while you code. That's when I thought of a cat.

Cats are already part of developer culture. GitHub avatars, the cat command, cats walking across keyboards. A cat doesn't interfere, but it has presence. It doesn't judge you for coding at 3 AM.

That's where CommitCat came from. A cat that lives on your desktop and roots for you while you build things.

Why a Spring Boot Developer Chose Rust

I'm primarily a backend developer — Java/Kotlin, Spring Boot. Desktop apps and systems programming were new territory.

I considered Electron. Fast to build with familiar web tech. But Electron bundles all of Chromium. A 200MB app doesn't feel like "a tiny cat living on your desktop." Performance wasn't negotiable for something running on a developer's machine all day.

Then I found Tauri. Tauri uses the OS's native webview — WebKit on macOS, WebView2 on Windows. No bundled browser engine. Roughly 1/10th the size of an equivalent Electron app. And the backend is written in Rust.

Why Rust specifically? Honestly, because Tauri requires it. But using it taught me things I hadn't encountered in Spring Boot.

Spring Boot catches many errors at runtime — NullPointerException, ClassCastException. Rust catches them at compile time. Frustrating at first, but once it compiles, it almost never crashes at runtime. For a desktop app that runs on the user's machine (not a server you can hotfix), compile-time safety has real value.

Conditional compilation was also new: #[cfg(target_os = "macos")]. In Spring Boot, OS branching is a runtime if. In Rust, only the code for the target OS ends up in the binary. Clean.

The Tauri architecture also mapped naturally to what I knew: Rust backend handles business logic and system integration, React frontend handles UI. #[tauri::command] is conceptually similar to @RestController. IPC between frontend and backend felt familiar — just like HTTP in a web service.

MVP in One Day

On February 22, 2026, I shipped an MVP in one day across 9 commits.

The MVP had exactly this:

A cat appears on the desktop
Click it and a speech bubble appears
It detects your active IDE
It reacts when you commit
XP accumulates and levels up

No polished animations. No settings panel. No GitHub integration, Pomodoro, or AI chat. Just a cat on screen that gets happy when you commit. That was enough to start.

The goal wasn't a complete feature set — it was delivering the core experience in its smallest possible form. "The cat celebrates when you commit." If that one moment didn't land, nothing else mattered.

Shipping v1: One Month, 88 Commits

After the MVP, the feedback was better than expected. "It's cute." "I want to use this every day." "What else can it do?"

I prioritized in order:

Things that give users a reason to open it daily:

Streak system (consecutive coding days)
Daily summary (what did I do today?)
Pomodoro timer (focus sessions + XP)

Things that detect activity in more places:

GitHub PR tracking
Docker container/build detection
VSCode Extension + JetBrains Plugin

Things that add personality:

Cat emotion system (surprise, excitement, pride, boredom, frustration)
Petting interaction (right-click + swipe)
Sub-cat system (unlocked at level 10 and 30)
AI chat (Claude API)

MVP  (Feb 22) → A cat exists on screen
v0.1 (Mar 23) → The cat knows when you're coding
v0.2 (Mar 25) → The cat has emotions
v1   (Mar 26) → The cat grows with you

What I Learned

Start from empathy, and features follow naturally.
Every feature in CommitCat came from one question: What does a developer coding alone actually lack?

Encouragement → cat celebrates commits
Rhythm → Pomodoro timer
Sense of progress → XP, levels, streaks
Reflection → daily summary

MVP really means Minimum.
One pixel-art cat. One commit detection. That was enough to validate "I want to use this every day." If I'd tried to build GitHub sync, AI chat, and cloud backup from the start, I probably never would have shipped.

Carry your concepts across new technology.
#[tauri::command] → @RestController. Async workers in services/ → @Async services. File-based JSON state → same CRUD patterns as JPA, just without a database. When learning something unfamiliar, mapping it to what you already know cuts the learning curve significantly.

On Building in the Age of AI

I used AI heavily throughout this project — code generation, debugging, architecture review. It's part of why a Spring Boot developer could ship a Rust project to v1 in a month.

But because of AI, some things matter more now.

Design judgment. AI is great at "implement this function." It can't tell you whether that function should exist there in the first place. Structural decisions — which crate owns this logic, when to abstract with a trait, what to defer — those are still yours.

The idea itself. When anyone can build a TODO app, what you choose to build becomes the differentiator. CommitCat came from noticing that coding alone feels lonely. That observation can't be generated from a prompt.

Execution. Lots of people think "a desktop pet app would be cool." Very few ship an MVP the same day they get the idea. AI speeds up execution, but the decision to execute is still human.

What's Next

CommitCat v1 is done. But building it exposed the limits of a local-only architecture: no sync across devices, no cat visible in Codespaces, core logic tightly coupled to Tauri.

The next post covers how I'm planning to restructure using Cargo Workspace, trait abstraction, and cfg-based conditional compilation to expand toward cloud and web — without throwing away the existing code.

Code is written alone. But it's a little less lonely with a cat.

⭐ GitHub: https://github.com/eunseo9311/commit-cat

Tags: #rust #tauri #opensource #sideproject #webdev