Ownership, solved. Mathematically.
OWNH assigns every line of code to exactly one owner, using nothing but its content hash and your version history. No interviews, no context, no feelings. Just cryptographic truth.
Runs locally on any git repository. Scales from one repository to your entire organization. See a sample report.
1export function settle(batch) {AOwner A 3f9c…2 const total = sum(batch);BOwner B a71e…3COwner C e3b0…4 if (total > limit) {BOwner B 0d42…5 return escalate('review');AOwner A 9b1d…6 }DOwner D 737d…7COwner C e3b0…8 return commit(total);AOwner A c62f…9}DOwner D d10b…
Code ownership is subjective, political, and frankly emotional.
For decades, engineering organizations have relied on methods that depend on human judgment. OWNH removes the human element entirely.
Commit counts can be gamed.
Ten small commits outrank one good one. Volume is not stewardship.
Git blame only remembers the last person who touched a line.
Recency is not authorship. The original author deserves the credit, and the accountability.
CODEOWNERS files are fiction.
They are maintained by whoever lost the meeting, and they are out of date by the time they merge.
Three steps. Zero ambiguity.
OWNH reads your history once and produces a single, reproducible answer for every line you ship.
Hash every line
Each line is reduced to its SHA-256 content hash, exactly as written. Whitespace is part of the line. A binary file is one line.
Find the first introducer
OWNH walks the complete history of every repository you provide and identifies the first contributor to ever produce each hash.
Assign ownership, permanently
Every occurrence of that line, in every file, in every repository, belongs to that contributor. Forever.
Governance that scales with your codebase.
Unambiguous accountability
Every line has exactly one owner, forever, regardless of who maintains it today.
Organization-wide insight
OWNH surfaces hidden contributors your org chart missed, including people with no recent commits and people who have left the company.
Refactor-aware governance
Changing a line changes its hash, which changes its owner. Ownership flows naturally to whoever touched it first, exactly as it should.
Formatter-agnostic
Just kidding. Run Prettier and see what happens.
Cross-repository synergy
Identical lines across services share one owner, so a single trusted engineer can be responsible for thousands of closing braces.
Reproducible by design
Same repositories, same history, same answer. Every figure OWNH reports can be regenerated and audited from a single database file.
How OWNH compares.
Conventional methods were designed for a simpler era. OWNH was designed for yours.
| Capability | Commit count | git blame | OWNH |
|---|---|---|---|
| One owner per line | No | Yes | Yes |
| Credits the original author, not the latest editor | No | No | Yes |
| Ownership survives the author's departure | No | No | Yes |
| Works across repositories | No | No | Yes |
| Assigns an owner to blank lines | No | Yes | Yes, one |
Recognizes the first person to type } | No | No | Yes |
| Treats a revert as a return to rightful ownership | No | No | Yes |
Executive-ready from day one.
OWNH ships with the reports leadership asks for, generated from the same database, so they never disagree.
Ownership leaderboard
Principal owners and principal lines, ranked across the organization.
Ownership by line hash
See which individual lines hold the largest share of your codebase.
Cross-repository ownership
Discover which repositories are owned, in practice, by other repositories.
Three ways to own
Benchmark OWNH against commit counts and git blame, side by side, per repository.
The sample is unedited OWNH output for two small demonstration repositories with fictional contributors.
Built on established methods.
OWNH takes proven ideas from software engineering research and applies them where no one else would.
- First introducer as originStudies built on World of Code identify the repository that first committed each version of a file as its origin (Jahanshahi, Reid & Mockus). The Software Heritage archive answers "where does this file come from" with the oldest revision that contains it (provenance service). OWNH applies the same principle one line at a time.
- Ownership predicts qualityIn Windows Vista and Windows 7, ownership measures correlated with both pre-release faults and post-release failures (Bird et al., "Don't Touch My Code!"). Ownership matters. OWNH makes sure it is assigned.
- Line-based ownershipResearch comparing ownership measures finds line-based ownership suited to accountability and attribution, and finds that commit-based and line-based methods disagree about who the major developers are (Code Ownership: The Principles, Differences, and Their Associations with Software Quality).
- Beyond the last author
git blameshows the revision and author that last modified each line. OWNH reports the first.
From history to accountability in minutes.
OWNH is a single command-line tool with no dependencies. Point it at your repositories and it does the rest.
- Node.js and git. Nothing to install.
- One portable database file per analysis.
- Add repositories at any time without starting over.
- Reports in HTML, Markdown, SVG, JSON, and CSV.
# Index every repository you care about $ bin/ownh.js index --db acme.db ~/src/frontend ~/src/backend # Onboard another repository later $ bin/ownh.js add --db acme.db ~/src/payments # Benchmark against git blame (optional) $ bin/ownh.js blame --db acme.db --sample 2000 # Generate the executive report $ bin/ownh.js report --db acme.db --out report/
Questions, answered.
What happens when someone reformats the code?
Every reformatted line has a new hash, so ownership of those lines transfers to the author of the formatting commit. This is working as designed.
Does a blank line have an owner?
Yes. A blank line is a line like any other, and like any other line it has exactly one owner: the first person to commit one.
Is every closing brace really owned by one person?
One person per indentation level. }, }, and } are different lines and may have different owners.
What if the owner has left the company?
Ownership is permanent. OWNH does not take employment status into account.
Can ownership be transferred?
Yes. Change the line.
What about copied code?
A copied line keeps its original owner, wherever it is pasted. If the line came from outside your organization, its owner may be someone you have never met.
Does OWNH support --ignore-revs-file?
No. A formatting commit is a contribution, and OWNH credits it accordingly.
Can OWNH estimate our bus factor?
Yes. For most lines it is one.
Why is it called OWNH?
Objective Weighted Normalized Heuristics. Read it aloud.
Someone has to own it.
Bring mathematical certainty to code ownership across your entire organization.