The Bus Factor of 35 Popular Open-Source Repos

In 13 of the 35 popular open-source repos we measured, the bus factor is 1: one person is the main author of more than half the files. 916 people have commits in Hugo's history, and its lead maintainer Bjørn Erik Pedersen is the main author of 89% of its files. 909 people have commits in FastAPI's, and its creator Sebastián Ramírez is the main author of 75%.

The 35 repos are every public repository in the repowise index with 500+ GitHub stars and a complete git history. Method, sample and checks are at the end of the post.

What is a bus factor?

The bus factor (or truck factor) is the number of people who would have to leave before most of a codebase loses the person who knows it best. We compute it from git blame:

1. For each file, the main author is whoever wrote the most of its current lines.
2. Sort people by how many files they are main author of.
3. The bus factor is how many people, taken from the top, it takes to cover more than half the files.

A bus factor of 1 means one person is the main author of over half the files while other people still commit. A project can have hundreds of people in its history and still get most of its current lines from the person who wrote the core.

How the 35 repos spread

At the other end are projects where ownership is spread widely. Grafana has a bus factor of 34, and its biggest main author holds under 5% of files. Airflow is at 16 and Bevy at 15.

Well-known repos with a bus factor of 1

We checked Hugo and FastAPI against GitHub's own blame on a few core files. bep (Hugo's maintainer) wrote 90% of the current lines in hugolib/site.go. tiangolo (FastAPI's creator) wrote 94% of fastapi/routing.py and 73% of fastapi/dependencies/utils.py. Our numbers match GitHub's blame on those files. Our own repo, repowise, has a bus factor of 1 too.

Why one person keeps writing most of the code

This is a hypothesis, not a measured result. Someone writes the core of a project, it gets popular, and contributions arrive at the edges: a bug fix, a new option, a docs page. Each one is small, so git blame still shows the original author on most lines. The project has hundreds of people in its history and one person who holds the whole design in their head.

The high end has an organisation behind the core. Grafana Labs employs a team that works on Grafana, and Airflow is an Apache Software Foundation project with many maintainers. Bevy, a community game engine, reaches 15 as well.

What a team that depends on these projects should do

If your product depends on a project with a bus factor of 1, that person is part of your supply chain. Funding them is the cheapest insurance available: look for the Sponsor button on the repo, or ask your company to use it. For your own code, treat a bus factor as a prompt to ask "who would we call if this broke?" and then go and check.

Four ways bus factor numbers go wrong

Our first pass across every popular repo we index put 76% of them at a bus factor of 1. That figure was an artifact, and the reasons matter if you compute a bus factor yourself.

• Shallow clones. For many large repos we index only the last 500 to 2,000 commits. git blame on a shallow clone gives every line older than the cut-off to whoever made the oldest commit fetched, so one contributor appears to own the codebase. Among repos with full history, 37% have a bus factor of 1; among shallow clones, 76% do. Everything in this post uses full history only, which is why Django, indexed from a shallow clone, is out.
• Formatter commits. When a project runs Black, Prettier or Ruff over the whole codebase, whoever made that commit becomes the blame author of every reformatted line. Projects can list those commits in a .git-blame-ignore-revs file, which GitHub's blame view reads. The study's blame does not apply that file, so we excluded requests, which keeps one.
• Bots. We drop the bots we recognise before counting, but others slip through. In Hermes Agent's data, the biggest "author" is an account called Hermes Agent, with 32.9% of files.
• Lines are not knowledge. Someone who has reviewed every PR for five years can know the code well and still own few lines.

See your own bus factor

repowise computes ownership from git log and git blame during repowise init, with no LLM key and no network calls. At the file level it reports the primary owner, the recent owner and a bus factor (how many top authors cover 80% of the file's commits). At the repository level it reports the truck factor, the single-owner file count and the modules where one person owns more than 80% of files.

repowise init
repowise risk --target src/auth/session.py     # owner, recent owner, bus factor
repowise context src/auth/session.py --include ownership

The knowledge_loss finding fires when a file is still changing, has a bus factor of 1, and its main author is no longer the one editing it. For a full-history result, run git fetch --unshallow before indexing. See the ownership layer docs, the bus factor and code ownership guide and git hotspot analysis for more, or paste any GitHub URL to see a public repo's ownership page.

How we measured

The sample is public repos in the repowise index with 500+ GitHub stars, a health score, and a full clone with no commit limit: 35 repos, after removing requests because of its .git-blame-ignore-revs file. For each file we take the main author from git blame on the current version, merge one person's different names and emails into one, and drop known bots. The bus factor is the smallest number of people who together are main author of more than half the files that have a main author. We cross-checked Hugo and FastAPI with GitHub's GraphQL blame on 6 October 2026. Another 12 popular repos were left out because the index has neither a commit-limit value nor a commit count for them, so we could not tell whether their history is complete. "People with commits" counts distinct commit authors in the history; GitHub's contributor list is shorter (415 for Hugo and 456 for FastAPI) because it counts accounts.