GitHub stars vs active users: what each open-source metric actually measures
By Bright Oparaji11 min read
A star is a bookmark. An active user is someone whose work would stop if your project disappeared. Most open-source metrics sit somewhere between the two, and knowing where is most of the skill.
A GitHub star costs one click and no commitment. An active user has installed your project, built something on it and keeps coming back. Those are very different things, and yet the star count is the number most maintainers check first, because it is the one GitHub puts at the top of the page.
This article goes through the metrics you can actually see for an open-source project: what each one measures, what it does not, where it misleads, and which ones to rely on for which kind of project. It ends with a short framework for choosing your own.
If you want the narrower question of how stars are earned and why buying them backfires, our guide to GitHub stars covers that. This piece is about measurement.
What a GitHub star measures
Starring a repository adds it to the user's list of starred repositories and adds one to its count. GitHub describes stars as a way to keep track of projects you find interesting and to show appreciation. That is the whole of it: a star records that one account clicked a button once.
What a star does not record:
- whether the person installed the project
- whether they still remember it
- whether it worked for them
- whether they are a developer who could use it at all
Stars also move for reasons unrelated to use. A post that reaches the front page of a large site can add thousands in a day, almost all from people who are curious and will not return. Stars can be bought, and services that sell them exist. And because stars never decay, a project that was popular five years ago and is unused today still shows the high number.
None of this makes stars worthless. They are a reasonable measure of attention: how many people noticed the project and thought it worth remembering. The mistake is reading attention as adoption.
Popularity and adoption are different questions
Popularity asks "how many people have heard of this and liked the idea?" Adoption asks "how many people depend on this to get their work done?"
The two can move in opposite directions. A clever demo can be very popular and barely used. A dull, reliable library inside thousands of build pipelines can be heavily adopted with a modest star count, because the people who depend on it never had a reason to visit its repository.
For a maintainer deciding what to work on, adoption is almost always the question that matters. It tells you whether the project is doing its job, whether a change will break people, and whether it is worth continuing.
What "active users" means, and why it is hard to measure
An active user is someone who used the project within some recent period: this week, this month. Software companies measure this directly because their software reports back to them. Most open-source software does not, and should not without consent.
That leaves open-source maintainers with proxies. A library is installed into someone else's project and runs there; you never see it run. A command-line tool runs on someone's laptop. A self-hosted application runs on someone's server. In each case the use happens out of sight.
There are three honest ways to get closer:
- Telemetry that is documented and easy to switch off. Homebrew, for example, collects anonymous aggregate analytics, explains how to turn them off, and publishes the totals. This is the most direct measure and the one with the highest trust cost, so it only suits some projects, and asking for consent first is the safer default.
- Platform statistics where the platform counts installs for you: extension marketplaces, container registries, package registries.
- Behavioural signals that require someone to have used the project: an issue describing a real setup, a question in your discussions, a pull request fixing an edge case.
None of these gives you an exact count of active users. Together they tell you whether use is growing.
The metrics compared
| Metric | What it measures | What it does not measure | Strengths | Limitations | Best used for |
|---|---|---|---|---|---|
| GitHub stars | Accounts that bookmarked the repository | Installation, use, satisfaction | Visible, comparable, easy to track | Never decays, spikes with attention, can be bought | Gauging reach of a launch or post |
| Forks | Copies of the repository under other accounts | Use; most forks are made to send one pull request | Shows intent to modify or contribute | Many forks are abandoned immediately | Spotting downstream variants and contributor interest |
| Contributors | Accounts with commits on the default branch | How many people use it; contribution size | Shows the project can survive its author | Includes bots and one-line fixes | Judging project health and bus factor |
| Downloads | Package fetches from a registry | People; one user can account for thousands of CI runs | Close to real installs, broken down by version | Inflated by CI, mirrors and bots | Trends over time and version adoption |
| Dependents | Public repositories or packages that declare it as a dependency | Private use, which is often most of it | Strong evidence of real integration | Undercounts private and enterprise use | Libraries and frameworks |
| Issues | Problems and questions reported | Satisfaction; a quiet tracker can mean no users or no problems | Each one from a stranger means someone tried it | Volume depends on how easy reporting is | Evidence of real use and pain points |
| Pull requests | Proposed changes from contributors | Use by people who never contribute | Shows engaged users who know the code | Small projects get few regardless of use | Contributor growth |
| Release activity | How often new versions ship | Whether anyone installs them | Signals the project is alive | Frequent releases can be noise | Showing maintenance to evaluators |
| Active users | People using it in a recent period | Usually measurable only by telemetry or a platform | The closest thing to the real question | Rarely available, and should only be collected with users' knowledge | Applications, extensions and tools with opt-in analytics |
Contributors: a health signal, not a usage count
The contributor count tells you how many people have changed the code. For a maintainer it answers a different question from adoption: can this project survive without me?
A project with one contributor and many users is fragile, and evaluators notice. A project with many contributors is more likely to be maintained next year. But a large contributor count does not imply many users, because some communities contribute heavily to projects they use lightly, and bots that update dependencies appear as contributors too. Growing the number is its own job: see how to attract contributors.
Read contributors as a measure of resilience. If your objective is to grow a community around the project, the number to watch is first-time contributors per month, not the total.
Repository activity can mislead in both directions
Commits, issues and pull requests make a project look alive. That is useful to an evaluator, but it is easy to misread:
- High activity, low use. A project can be very busy because its author is still building it. Hundreds of commits a month say nothing about who runs it.
- Low activity, high use. A mature library that does one thing well may need a release a year. Low activity there is a sign of stability, not neglect.
- Automated activity. Dependency bots, scheduled workflows and automated releases add commits and pull requests that no person made.
When you read activity, look at who is active. Issues and discussions from people outside the core team are the part that reflects use.
Downloads versus actual usage
Download counts are the closest public number to installs, which makes them useful and easy to over-read.
A single company running continuous integration on fifty services can download your package thousands of times a day while being one user. Mirrors and caches download packages without anyone using them. Some registries exclude known bots and some do not. And a package that is a dependency of a popular package is downloaded every time that one is, whether or not your code is ever called.
Downloads are still worth tracking, for two reasons. The trend is meaningful even when the absolute number is inflated, because the inflation is roughly steady. And downloads by version show how quickly people upgrade, which tells you how many are actively maintaining a setup that uses you.
Dependents and ecosystem adoption
For a library, dependents are the strongest public evidence of adoption. A repository that declares your package in its manifest has done the integration work. GitHub shows these on the repository's dependency graph for supported package ecosystems, and package registries and services such as deps.dev show dependents across their ecosystem.
The limitation is that dependents are counted only where they are visible. Private repositories and internal company code are invisible, and for many libraries that is most of the real use. Treat the public dependent count as a floor, not a total.
Which metrics fit which project
| Project type | Most informative | Useful supporting signals | Least informative alone |
|---|---|---|---|
| Library or framework | Dependents, downloads by version | Issues from new users, questions on forums | Stars |
| Command-line tool | Package manager installs, release asset downloads | Issues describing real environments | Forks |
| Self-hosted application | Container image pulls, deployment reports in discussions | Documentation visits, upgrade questions | Contributors |
| Editor extension | Marketplace installs and active installs where reported | Ratings and reviews on the marketplace | Repository traffic |
| Data or ML tool | Downloads, notebooks and projects importing it | Questions with real data in them | Stars |
| Early project, any type | Issues and discussions from strangers | Repository traffic and referrers | Every absolute count |
A framework for choosing adoption metrics
The right set of metrics depends on what decision you are trying to make. Five questions get you most of the way:
- What decision will this number inform? "Is the launch working", "should I keep building this" and "which features matter" need different numbers. Pick the decision first.
- Where does use actually happen? In someone else's codebase, on their machine, on their server, in their editor. Choose the metric that sits closest to that place.
- What can inflate it? For every metric you pick, write down what could make it rise without more real use: CI, bots, a single viral post. If you cannot name anything, you have not looked hard enough.
- Is it a trend or a total? Totals invite comparison with other projects, which is rarely fair. Track week-on-week change against your own past.
- What would make you change your mind? Decide in advance what result would tell you something is not working. Otherwise every number confirms what you hoped.
A practical starting set for most projects is one usage metric suited to the project type from the table above, repository visitors and referring sites, and the count of issues and discussions opened by people you do not know. Add stars as a fourth line if you like watching them. Just do not put them first.
GitHub's traffic page (Insights, then Traffic) shows views, unique visitors and referring sites, but only for the last 14 days and only to people with write access. Write the numbers down every week or they are gone, or save them automatically.
Checklist: measuring adoption honestly
- Choose one usage metric that matches where your project runs
- Record repository traffic and referrers weekly, before the 14-day window drops them
- Count issues and discussions opened by people outside the project
- Track downloads by version, not only in total
- Check dependents if you maintain a library, and treat the number as a floor
- Write down what could inflate each metric you track
- Compare against your own past weeks, not other projects
- Keep stars as a measure of attention, alongside the rest
Where to go next
If the measurement shows people arrive but do not stay, the README is usually the first thing to check. Our README quality checker scores one against a published rubric and lists the fixes in priority order. If you are planning a launch and want to know what to measure from the first day, the open-source launch planner builds a measurement list for your type of project along with the rest of the plan.