# Commitscape: open source git history analysis for developers

URL: https://pixelactstudio.com/work/commitscape

> Commitscape is an open source tool from Damn Labs at Pixelact Studio that shows what developers built, from git history and GitHub. How it works and why.

Label: Open Source. Status: Live.

- **Type:** Open source developer tool: a command-line tool and a hosted Site
- **Built by:** Pixelact Studio, under its Damn Labs branch
- **License:** MIT or Apache-2.0, at the user's choice
- **Status:** Live and in early development. Latest release 0.4.0, October 2026
- **Platform:** CLI for Linux, macOS, and Windows through npm, Cargo, Nix, or a binary, .deb, or .rpm from GitHub releases. Hosted Site at commitscape.damnlabs.com. Docker images for self-hosting
- **Stack summary:** A Rust engine on gix, served to the Site over HTTP by axum, a TanStack Start Site, PostgreSQL, and Cloudflare R2
- **Privacy model:** Shared Reports are encrypted with AES-256-GCM before upload and the key stays in the link, so the Site cannot read them. No email address is uploaded

- [Open Commitscape](https://commitscape.damnlabs.com)
- [Source on GitHub](https://github.com/pixelactstudio/commitscape)

Commitscape comes in two parts. The CLI reads a repository on your machine and shares its Report through an encrypted link. The hosted Site at commitscape.damnlabs.com adds GitHub's records, such as pull requests and reviews, and reads private repositories only through a read-only GitHub App.

## What does the Commitscape open source tool do?

Commitscape turns a repository's history into numbers a developer can show someone else. Every number says what it counts, and when the data cannot support a number, the page says “not counted” instead of showing zero.

- **Profiles.** Sign in with GitHub and look up any username: pull requests, reviews, lines changed, Surviving Lines, and where that person's work sits.
- **Repository Reports.** Open any public GitHub repository for its history, contributors, languages, and Standings, or connect your own repositories, private ones included, through a read-only GitHub App.
- **Cards.** Images for a README, a self-review, or a post, rendered as animated SVG for embeds and PNG for link previews, with a GitHub Action that keeps them current.
- **Proof of Work.** Everything a person shipped in a chosen period, grouped by repository and month, shared as a link or downloaded as Markdown or PDF.
- **The CLI.** `npx commitscape` reads a repository on your machine and shares its Report through an encrypted link that expires.

Commitscape is built for developers who need to prove their work: a freelancer showing a client what shipped this month, an engineer writing a self-review, or a maintainer thanking contributors with a hall-of-fame Card.

## What problem does Commitscape solve?

Commitscape shows what a person built, which commit counts cannot. Most work happens in pull requests and reviews, and many teams squash-merge, so a commit count says little about who did the work. Line counts mislead too, because one reformat can make a single person look like the author of every line it touched. Repository charts are already free elsewhere, such as GitHub Insights, but they describe the repository, not the person looking at it.

Commitscape's headline answer is Surviving Lines: the lines at the current head that blame attributes to each person, and the number hardest to inflate. Generated files such as lockfiles, prose files, and files over a megabyte are left out. When a bulk commit or a commit listed in `.git-blame-ignore-revs` changed a line only in its whitespace, the line passes back to whoever wrote it before, so a reformat does not take credit for code it only re-indented.

## How does Commitscape work?

One Rust engine reads git history wherever Commitscape runs. On a developer's machine it runs inside the CLI. For the hosted Site, a separate Builder runs it, and the Site itself never runs git.

- **CLI:** Reads a local checkout with gix, works out the Report, says what the upload will hold, and sends nothing until the person says yes.
- **Builder:** Takes jobs from a Postgres queue (pg-boss), clones the repository, runs the engine, loads commit rows into Postgres, and writes an immutable pack of the repository's history to Cloudflare R2.
- **Engine service:** A small Rust HTTP service on axum and tokio that answers every question needing a pass over history from those packs, kept on disk and in memory.
- **Site:** A TanStack Start app on Node that draws every page on the server, reads rows from Postgres and stored files from R2, and asks the engine service for everything else.

A cold build runs two clones at once. A clone without old file contents gives the first Report in seconds for most repositories, while a full clone counts lines changed, default branch first, within a time budget. The project measured a cold build of facebook/react, about 35,000 commits, on two cores: the first Report in 12.6 seconds and the whole build in 17.9. Later builds read only what changed, and a build of a complete Report whose head has not moved ends after a single `git ls-remote`.

## What was hard to build?

### Blame that is fast enough and fair

Blaming every file in a large repository takes minutes, and the blame in gitoxide had no support for ignored revisions. So Commitscape has its own blame on top of gix, split by folder across threads. The project's decision record compares it with `git blame`: 0.36% of ripgrep's lines and 0.92% of facebook/react's went to a different commit, all where git's diff is not minimal. Work over the time budget shows as “not counted”, never as an estimate.

### Knowing who is who

The same person often commits under a work address, a personal address, and GitHub's noreply address. Commitscape joins identities only on strong evidence: the repository's mailmap, matching addresses, the same GitHub account, or the same full name of two or more words. Merges made on an account or a name are shown on the person and can be undone, and weaker signals, such as a one-word name, are only suggested.

### Keeping one copy of every metric

An earlier version computed the Site's answers in a TypeScript port of the Rust metrics, held equal by a parity test. Every metric change was made twice, and heavy screens blocked the Site's single main thread. Moving that work into the Rust engine service left one copy of each metric, checked against about 53,800 recorded answers kept as golden files.

## What does Commitscape show about how Pixelact builds software?

Commitscape is the same kind of system many startups need: a job queue, Postgres, object storage, a compute service, and a server-rendered web app with dashboards over messy data. It was built with the practices we bring to [product development](https://pixelactstudio.com/services/product-development) and to [internal tools and data systems](https://pixelactstudio.com/services/internal-tools).

- **Decisions are written down.** The repository holds 31 [architecture decision records](https://pixelactstudio.com/blog/architecture-decision-records) and a glossary that names each term and the words to avoid, so a new engineer can see why the system looks the way it does.
- **Every phase has a measured gate**, as in our [engineering standards](https://pixelactstudio.com/about/engineering-standards): Rust tests pass on Linux, macOS, and Windows, the TypeScript workspace passes, and Playwright runs end to end with accessibility checks.
- **AI speeds up the work, and a person signs off.** Commitscape was built openly with AI coding tools. The agent doing the work never commits, pushes, publishes, or deploys. The owner does, the same rule our [AI code review workflow](https://pixelactstudio.com/blog/ai-code-review-workflow) sets for merges.
- **Scope follows evidence.** Races, Crews, Seasons, Rivals, and Leaderboards were built, then removed, because they need a crowd the Site does not have yet.
- **Privacy is designed in.** No email address leaves the Builder, the GitHub App can only read, and a private repository's Report is shown only to people GitHub says can see it.
- **Strict defaults.** Clippy denies `unwrap`, `expect`, and `panic` across the Rust workspace, unsafe code is forbidden outside the one crate that maps files into memory, and a layering check keeps the git library out of the engine service.

Commitscape is one of the free tools on the [Damn Labs page](https://pixelactstudio.com/labs). If you need a system like it, from data pipeline to dashboard, [start a project](https://pixelactstudio.com/start-a-project) and Pixelact can build it with you.

## The decisions behind Commitscape

### A separate Rust engine service

**What we chose:** The Site asks a small Rust service for every answer that needs a pass over history, and that service reads immutable packs written by each build.

**Why:** A native add-on inside Node would share the Site's CPU and memory on a server where the Site's main thread was already the bottleneck, and a crash in native code would take the Site down with it. A separate service has its own limits, fails on its own, and can move to another machine.

### Encrypted sharing instead of a live relay

**What we chose:** The CLI builds the Report locally, encrypts it with AES-256-GCM, uploads only the ciphertext, and puts the key in the link after the `#`.

**Why:** A relay would hold a terminal open and die when it closed, and a plain upload would put private file paths, names, and commit messages on the server. Browsers never send the part after the `#`, so the Site stores what it cannot read.

### Comparisons, never one score

**What we chose:** People are compared view by view, leading with Surviving Lines, merged pull requests, and reviews, and anyone can hide from comparisons.

**Why:** Ranking people invites gaming and shaming. Views that are hard to inflate come first, raw commits and raw lines are never ranked first, and private work is never named to someone who cannot see it on GitHub.

### Git behind traits with scripted fakes

**What we chose:** All git access sits behind traits, starting with a push-based `RepoSource`, and gix types appear in one crate only, so the layers above never see gitoxide.

**Why:** Each trait's second implementation is a scripted in-memory fake, so the index layer is tested deterministically with no temp directories or git subprocess. Callers hand in sinks instead of taking iterators, so no gix lifetimes leak out and peak memory does not grow with the length of the history.