Coruro — your Git repos as a readable board.

A folder of repos is a graveyard.

Local clones, half-finished side projects, client work, things I starred and forgot. Names like app-final-2 tell me nothing, and opening each one to remember what it was is its own afternoon.

Coruro scans a root folder, finds every Git repo, and draws each as a card on a five-column board — Inbox · Backlog · Active · Review · Done. Drag a repo to where it lives. The card carries the rest.

Each card reads like a project's vital signs: what it is, what it's built in, whether it's in sync, and how alive it is — at a glance, without opening anything.

Vital signs, at a glance.

Each card adapts to what the repo is — GitHub repos get different stats than local-only ones.

Six features, one board.

How it works

The Rust backend reads local Git state and GitHub data. For the AI, it builds a small context per repo — a README excerpt, the languages, recent commit subjects, the top-level file names — capped to fit the model's window, and hands it to a standalone Swift binary. That binary runs Apple's on-device model and returns structured output. A serial, content-hash-cached queue runs it over each repo after a scan. Nothing about your code is sent to a server.

  Folder of repos
        │  scan
        ▼
  Tauri app (Rust) ──► local Git (read-only): branch, ahead/behind, stats
        │             └► GitHub API: stars, issues, CI, release (cached)
        │
        │  repo context (README excerpt, languages,
        │  recent commit subjects, top-level files)
        ▼
  Swift sidecar ──► Apple FoundationModels (on-device LLM)
        │           returns { summary, tags }
        ▼
  Editorial card on the board

Why I built it

Two reasons, honestly.

One: I wanted the tool. A wall of repos I can actually read beats a folder I have to excavate. The 20% of a repo manager I'd use every day is "tell me what this is without making me open it."

Two: I wanted to put Apple's on-device model to real work — not a toy prompt, but a summarizer wired into a Rust backend through a Swift sidecar, cached, bounded to the model's context window, and degrading gracefully on Macs that can't run it. Something with real moving parts. That half turned out to be as interesting as the app.

And because it's open source, you don't take my word for any of the privacy claims — you read the code, build it, and run it yourself.

The vibe-code experience — the actual story.

I didn't hand-write most of this. I directed it — and that's the point. Letting an agent "just build the board" gives you mush. What worked was running it like a small engineering team.

For the curious

The things to know up front.

Roadmap

• Semantic search across repos, on-device (Apple NLContextualEmbedding)
• Repo relationships, inferred from AI tags and embeddings
• A statistics view that aggregates AI-derived insights
• Smoother build-from-source onboarding — one script, clear prerequisites

Your code never leaves the machine.

The AI model runs locally through Apple's FoundationModels framework. The only optional network calls are to the GitHub API, going directly from your machine to GitHub. No intermediary, no telemetry, no server. And because the whole thing is open source, you don't take my word for any of it — you read the code.

Questions people actually ask

Build it, run it, read the code.

Open source. No installer, no account, no API keys. Clone the repo, run the build script, and your repos become a board you can actually read.

stack

• Tauri v2
• Rust
• macOS only
• React 19
• TypeScript
• Zustand
• Tailwind CSS 4
• Apple FoundationModels
• Swift sidecar
• @Generable structured output
• local Git (read-only)
• GitHub API
• macOS Keychain
• local-first
• single JSON file
• no server
• no telemetry
• full unit-test suite
• security-reviewed
• MIT licensed