GitPop
Back to radar

Methodology · v1.1 · last updated 2026-08-15

How GitPop ranks the GitHub breakouts

Every number on this site is reproducible. Below is the exact formula, the AI pipeline, the noise filter, the data sources, and the things PopScore is not designed to measure.

TL;DR

PopScore is a 0–100 integer combining five weighted signals: star velocity (35%),activity (25%), fork engagement (20%),noise penalty (10%), and external mentions (10%). A separate LLM pipeline writes a one-sentence AI Snapshot per project. The radar refreshes four times a day. Every input is open; every weight is documented below.

What is PopScore

PopScore is GitPop's answer to a question GitHub itself doesn't answer: which projects are actually breaking out right now?

Raw star counts reward incumbents. GitHub Trending rewards whoever added the most stars in the last 24 hours — easily inflated by a coordinated vote, an HN front-page hit, or a Chinese star farm. The PopScore is designed to be velocity-first, fraud-resistant, and size-fair: a 100-star project that gained 50 in 7 days should rank near a 10,000-star project that gained 5,000 in the same window.

The score is an integer from 0 to 100, rounded. A score of 60+ is the radar threshold (top 50); 80+ is the danger-zone "this is blowing up" band.

The formula

PopScore = S_rate  × 0.35
         + F_rate  × 0.20
         + A_score × 0.25
         + M_score × 0.10
         + N_pen   × 0.10

Output: integer 0–100 (rounded)
              

Source: github.com/getgitpop · 32 unit tests · 100% formula coverage.

The five factors

S_rate — Star Velocity (35%)

35% weight
S_rate = min(100, ΔStar_7d / √(TotalStar + 10) × 18)

Main signal — how fast a project is accumulating stars over the last 7 days.

The √(TotalStar + 10) denominator makes 100→200 stars on a 100-star project roughly equal in velocity to 10k→20k on a 10k-star project. A small project breaking out can outrank an incumbent growing 2% a week.

Edge case ·

Edge case: a project with 0 stars has a 1-day snapshot advantage — once it has 7 days of data, the formula activates. Until then, it lives on the Early Signal page.

F_rate — Fork Engagement (20%)

20% weight
F_rate = min(100, ΔFork_7d / (ΔStar_7d + 1) × 100)

Measures how many new stargazers actually engage (fork) versus bookmark. A high fork/star ratio signals real developer interest; a low ratio signals passive hype. The +1 in the denominator prevents div-by-zero on star-only days.

A_score — Activity (25%)

25% weight
A_score = round(100 × (0.5·C_norm + 0.3·P_norm + 0.2·I_norm))

C_norm = min(1, log(1 + Commits_7d) / 3)
P_norm = min(1, log(1 + PRsMerged_7d) / 2.5)
I_norm = min(1, ClosedIssues_7d / (OpenedIssues_7d + 1))
  • Commits (50% weight): author-side activity
  • PRs merged (30% weight): community contribution health
  • Issue close rate (20% weight): maintainer responsiveness
Edge case ·

Why log? Because a project doing 50 commits/week is meaningfully busier than 5, but 5000 commits/week isn't 1000× busier than 5. Log compresses the long tail. Both 50 and 10000 cap at 1.0; everything in between is ranked smoothly.

M_score — Mention Velocity (10%)

10% weight
M_score = min(100, HN_7d × 8 + Reddit_7d × 5 + Lobsters_7d × 6)

External signal from Hacker News (Algolia API), Reddit (JSON), and Lobsters (RSS). The coefficients are tuned to the average HN-front-page post — 12 mentions on HN fills the bucket alone.

Missing data fallback: if a project has zero mentions across all three sources, the score falls back to 50. We never punish projects we cannot observe (this is a known failure mode for Chinese-language projects — Phase 3 will addv2ex.comto fix it).

N_pen — Noise Filter (10%, additive)

10% weight
N_pen = max(0, 100 × (1 - d1 - d2))

d1 = 0.8 if name/description matches:
     awesome, tutorial, roadmap, interview,
     learning, cheatsheet, course
d2 = 0.5 if missing LICENSE OR README < 200 chars
(d1 + d2 capped at 0.9 → minimum N_pen = 10)

The single biggest differentiator vs. raw GitHub Trending. The additive design avoids the failure mode where an awesome-* list with no license was crushed to 10% of its real score under the original multiplicative penalty.

Edge case ·

Why include awesome-* at all? They can be useful (awesome-rust is canonical). We don't ban them — we just rank them lower than code projects of equivalent star count.

AI Snapshot pipeline

Every project on the radar gets a one-sentence TL;DR, three key features, and a 1–5 star difficulty rating. Generated by an LLM from the project's README + description + topics.

System prompt (abridged)

You are summarizing a GitHub project for a developer who has 5 seconds.

Inputs:
- name, full_name, description, topics, primary_language
- README (first 6k chars)
- 7-day star/fork deltas

Output JSON:
{
  "tldr":       "<= 140 chars, action verb + concrete value>",
  "features":   ["...","...","..."],   // exactly 3, <= 80 chars each
  "difficulty": 1..5,                  // 1 = "curl | bash", 5 = "PhD required"
  "category":   "framework|tool|app|lib|ai|infra|other"
}

Hard rules:
- No marketing words ("revolutionary", "powerful", "next-gen")
- No invented URLs or version numbers
- "difficulty" must reflect setup pain, not code complexity

AI Snapshots are never used to compute PopScore. They are clearly labeled on every card, and the source README is always one click away.

Noise filter (deep dive)

The noise penalty is the most-contested part of the algorithm. It's also the highest-impact — turn it off and the radar fills with "awesome-react" and "100-days-of-code".

Keyword set (d1)

Case-insensitive substring match on the project name or one-line description. Triggers a 0.8 deduction (additive).

  • awesome
  • tutorial
  • roadmap
  • interview
  • learning
  • cheatsheet
  • course
  • resources

Quality signals (d2)

Missing LICENSE or README shorter than 200 characters triggers a 0.5 deduction. The cap at 0.9 (so minimum N_pen is 10) prevents a project from being scrolled off the page entirely by double-penalty.

Why additive, not multiplicative?

Under the original multiplicative design, awesome-foo (d1=0.8) × no-license (d2=0.5) = 0.10 N_pen, crushing a useful 80-PopScore project down to 8. Additive composition caps the damage at 90% of the score, so an awesome list with great activity still ranks above a quiet, average project.

Data sources

GitHub GraphQL API v4

On every snapshot (4×/day)

Project metadata, current star/fork counts, language breakdown, topics, license, README size, commit/PR/issue counts.

GH Archive (BigQuery public dataset)

Daily batch (UTC 23:00)

Historical event backfill — every star, fork, pushEvent since 2011. Used for cold-start projects that have no snapshot history yet.

Hacker News (Algolia API)

Every snapshot

Mention count over the last 7 days. Coeff 8 per mention.

Reddit JSON API

Every snapshot

Mention count across r/programming, r/MachineLearning, r/opensource, r/typescript, r/rust, r/Python, r/Node. Coeff 5 per mention.

Lobsters RSS

Every snapshot

Mention count over the last 7 days. Coeff 6 per mention.

GitHub REST API (Releases)

On every snapshot

Latest release tag + semver. Used by Phase 4 Watchlist alerts.

Update cadence & latency

  • The radar is refreshed several times per day on a fixed schedule.
  • End-to-end latency: a project that breaks out mid-day usually appears in the radar within a few hours of going viral.
  • Every snapshot runs the full PopScore / health / maturity pipeline, so all surfaces stay in sync.

Known limitations

PopScore is not:

  • A code-quality measure — we don't read your source.
  • A security audit — npm audit and CodeQL do that better.
  • A PR-review quality measure — we count merged PRs, not their substance.
  • A private-repo metric — we only see public GitHub.
  • Manipulation-proof — any star-based metric is gameable. We make it expensive, not impossible.
  • Real-time — there is up to a 6-hour lag between a project's star count changing and the radar reflecting it.

Public roadmap

  1. Shipped

    v1.0–v1.4 · Pop Radar + AI Snapshot + directory

    The full discovery loop: trending radar, per-project snapshots, categories, and the noise gate.

  2. Shipped

    v1.5–v1.7 · Health · Maturity · Compare · Weekly Digest

    Selection and retention: honest tiers, head-to-head pages, weekly recaps, newsletter.

  3. Shipped

    v1.8 · best-of-ai-tools open data repo

    A bot-maintained public ranking, auto-published weekly from live PopScore data.

  4. Planned

    v1.9 · Wider world

    Full multilingual interface + downloadable dataset dumps.

  5. Planned

    v2.0 · Public platform

    RESTful JSON API with OpenAPI docs, watchlist alerts, embeddable widgets.

Frequently asked

How often is PopScore recalculated?

Several times a day. Each run reads the GitHub API, computes deltas against the previous snapshot, and stores a new row. The radar page reads the latest snapshot, never the live API.

When does a new project enter the radar?

It needs at least 7 days of snapshot history so 7-day deltas are meaningful. Newer projects still appear in the Early Signal page (Phase 2), which uses raw 24-hour growth instead of deltas.

Why is an awesome-* list penalized?

Awesome-* lists are meta-curated resources, not new code. They have passive growth (very few commits, low fork engagement) and they crowd out real projects in the radar. The noise penalty is intentional and additive, so a genuinely useful awesome-* list can still rank, just lower.

Can I trust the AI Snapshot?

AI Snapshots are generated by an LLM from the project's README + repo metadata. They are clearly labeled as AI-generated on every card, link back to the source README for verification, and are never used to compute PopScore. Treat them as a 5-second orientation, not a substitute for reading the docs.

Is PopScore manipulable?

Yes — any star-based metric can be inflated by buying stars. We mitigate with the fork-engagement factor (real developers fork), the noise filter (most star farms are description-less shells), and the activity score (bots don't ship commits). We do not claim PopScore is fraud-proof; we claim it's much harder to fake than raw star counts.

How can I embed a chart in my own blog or README?

Every chart is a plain SVG. Use the embed snippet from the /chart landing page, or hand-roll an <img> tag pointing at /api/chart?repos=owner/name&layout=rel&theme=dark. Free, no API key, cached for one hour.

Last updated: 2026-08-15 · Source code: github.com/getgitpop · 32 PopScore unit tests + 20 chart unit tests = 52 total.

Methodology — How PopScore, AI Snapshot & Noise Filter work | GitPop · GitPop