Orviqa

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:

  1. 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.
  2. Platform statistics where the platform counts installs for you: extension marketplaces, container registries, package registries.
  3. 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

MetricWhat it measuresWhat it does not measureStrengthsLimitationsBest used for
GitHub starsAccounts that bookmarked the repositoryInstallation, use, satisfactionVisible, comparable, easy to trackNever decays, spikes with attention, can be boughtGauging reach of a launch or post
ForksCopies of the repository under other accountsUse; most forks are made to send one pull requestShows intent to modify or contributeMany forks are abandoned immediatelySpotting downstream variants and contributor interest
ContributorsAccounts with commits on the default branchHow many people use it; contribution sizeShows the project can survive its authorIncludes bots and one-line fixesJudging project health and bus factor
DownloadsPackage fetches from a registryPeople; one user can account for thousands of CI runsClose to real installs, broken down by versionInflated by CI, mirrors and botsTrends over time and version adoption
DependentsPublic repositories or packages that declare it as a dependencyPrivate use, which is often most of itStrong evidence of real integrationUndercounts private and enterprise useLibraries and frameworks
IssuesProblems and questions reportedSatisfaction; a quiet tracker can mean no users or no problemsEach one from a stranger means someone tried itVolume depends on how easy reporting isEvidence of real use and pain points
Pull requestsProposed changes from contributorsUse by people who never contributeShows engaged users who know the codeSmall projects get few regardless of useContributor growth
Release activityHow often new versions shipWhether anyone installs themSignals the project is aliveFrequent releases can be noiseShowing maintenance to evaluators
Active usersPeople using it in a recent periodUsually measurable only by telemetry or a platformThe closest thing to the real questionRarely available, and should only be collected with users' knowledgeApplications, 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 typeMost informativeUseful supporting signalsLeast informative alone
Library or frameworkDependents, downloads by versionIssues from new users, questions on forumsStars
Command-line toolPackage manager installs, release asset downloadsIssues describing real environmentsForks
Self-hosted applicationContainer image pulls, deployment reports in discussionsDocumentation visits, upgrade questionsContributors
Editor extensionMarketplace installs and active installs where reportedRatings and reviews on the marketplaceRepository traffic
Data or ML toolDownloads, notebooks and projects importing itQuestions with real data in themStars
Early project, any typeIssues and discussions from strangersRepository traffic and referrersEvery 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:

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.

← All posts