Building Our Own Programming Language Ranking Using GitHub Data in Anaconda and JupyterLab

Every time a new programming language ranking like TIOBE or RedMonk comes out, the comments follow the same script: Python can't possibly be first, Rust is overrated, and no one knows where TypeScript belongs. Each ranking uses a different methodology — search queries, mentions in repos and forums, developer surveys. Each method produces different results, and each has its critics.

We decided not to argue with anyone else's methodology and to collect the data ourselves. GitHub's API gives free statistics on public repositories, so we queried it directly: how many new repositories are created for each language, which ones gain stars, and how the picture shifts quarter by quarter from the start of 2024 to the end of 2025. Twenty languages, eight quarters, and a few unexpected findings.

Server and Environment

For the analysis we used a VPS with a pre-installed Anaconda + JupyterLab image — Ubuntu OS, 4 vCPUs, 8 GB of RAM. No GPU needed: the task is analytical, and the entire load is HTTP requests to the API plus pandas.

We connect over SSH and launch JupyterLab:

jupyter lab --ip=0.0.0.0 --port=8888 --no-browser --allow-root

We open a browser at http://server_IP_address:8888 and start working. Anaconda pulls all the necessary packages from its repository — pandas (tables), matplotlib and seaborn (charts), requests (HTTP), tqdm (progress bar) — in a single command, no hunting around or manual setup. We only need to add plotly for interactive charts:

conda create -n github-langs python=3.11 pandas matplotlib seaborn requests tqdm -y
conda activate github-langs
conda install -c conda-forge plotly ipykernel -y
python -m ipykernel install --user --name github-langs --display-name "GitHub Langs"

After refreshing the browser page, a new GitHub Langs kernel appears on the JupyterLab start page — this is the Python environment JupyterLab will use to run our code. We select it, create a notebook, and get started.

What and How We Count

GitHub's Search API lets you query repositories filtered by language, creation date, and star count. The limit is 5,000 requests per hour with a token — more than enough for our purposes. For each language and each quarter, we collect three metrics:

• total_repos — how many new public repositories were created;
• notable_repos — the same, but only those with ≥10 stars (a signal that the project is alive and getting attention);
• top100_stars / top100_forks — total stars and forks across the top 100 repositories by stars.

The main limitation of the Search API is a cap of 1,000 results per query. We work around this simply: split by date ranges, request only total_count (a single line in the response), and add pauses. First, we verify the token:

response = requests.get("https://api.github.com/user", headers=HEADERS)
# → Authorized as: ibogdanov-creator
# → Request limit: 4999/5000

20 languages × 8 quarters × 3 metrics ≈ 480 requests — well within the limit. The main loop, with a tqdm progress bar, took about 15 minutes. The final CSV file has 160 rows. The data is on disk, so we can restart the kernel as often as we need to.

After collection, we ran the data through a separate verification script: 20 checkpoints, repeat requests to the GitHub API, comparison against the CSV. All 20 returned OK, with a discrepancy of no more than 0.2%. GitHub periodically reindexes public repositories, so a small spread is expected. The data is clean.

One key limitation is worth noting upfront. We're looking only at public repositories. Enterprise development in Java, C#, or COBOL stays behind closed doors, in internal GitLab and Bitbucket instances. Chinese developers actively use Gitee. New repository counts reflect community activity, not a language's share of real-world codebases — legacy code doesn't create new repositories. This is a snapshot of public activity, not a universal ranking.

Results: Analyzing the Charts

JavaScript Is First

What we see: JavaScript with 14 million new repositories over two years. Python with 11.3 million. TypeScript with 7.1 million. Then a sharp drop: Java at 5.2 million, followed by C# and C++ at 2.1 million each.

Chart 1. Top 20 languages by number of new repositories, GitHub Q1 2024 – Q4 2025

Although Python tops most other rankings, here it came in second — which was unexpected. The reason is in the methodology. We count new repositories, and JavaScript covers every corner of client-side web development, including learning projects and beginner experiments. Python is arguably the more mature language here: projects in it are created less often, but they tend to be larger and more serious.

Scala, Elixir, Julia, and Zig show 0.0M next to the leaders — the scale is simply incomparable. But that doesn't mean they're dying, and we'll see something interesting in a moment.

TypeScript Surges, PHP Slumps

We normalize the data to Q1 2024 = 100. This makes it easier to compare growth rates instead of absolute numbers. In the notebook this chart is interactive — you can show and hide languages from the legend, which the static version can't convey.

Chart 2. New repositories over time, by quarter, Q1 2024 = 100 (interactive Plotly version in the notebook)

By Q4 2025, TypeScript had reached an index of 290. Python sits at 230. Everyone else is in the 100–150 range. TypeScript seems to have outgrown its role as a JavaScript superset — it's increasingly the default choice when starting a new client-side project.

PHP is the only language in the sample with anomalous behavior — a peak in Q4 2024, followed by a decline.

Rust and Go — Quality vs. Quantity

An interesting pattern emerges on the log-scale scatter plot. The X-axis is repository count, the Y-axis is total stars across the top 100. Dot size reflects the share of notable repositories (10+ stars).

Chart 3. Repositories vs. stars (log scale). Dot size = share of notable repositories

Rust and Go sit anomalously high in stars relative to their repository counts. JavaScript has 14 million repositories but relatively few stars per repository — much of that 14 million is learning-project noise. A Rust repo gets created with intent.

Julia is small by volume but has a strong stars-per-repo ratio. A niche scientific language — if someone starts a project in Julia, they're doing something serious. Zig and Elixir cluster together — small communities, but loyal ones.

Winners and Losers Over Two Years

Most languages didn't just hold their ground — they grew: TypeScript +190%, Zig +155%, Python +131%, Lua +84%, Rust +56%. Only two are in the red: Scala −10% and Ruby −37%.

Chart 4. Growth in new repositories, Q4 2025 vs. Q1 2024, %

Ruby's numbers are the most striking here. The language is still relevant, and Rails is still in demand. But the number of new projects in it is declining. Some developers have moved to Python, especially for AI work; others to TypeScript for Node.js. It's not a catastrophe, but the trend is clear.

Zig shows the second-fastest growth, though it's barely visible on the first chart because of its small base. Even so, the percentage jump is significant and points to real growth. The language appeals to systems programmers who find Rust too complex and C not safe enough.

What's Inside Each Language

This is the most useful section for spotting trends. Let's look at the top 5 repositories by stars for each of the top 10 languages, pulled with a separate API call.

Chart 5. Top 5 repositories by stars for each language, GitHub 2024–2025

The Python top is almost entirely AI tooling: DeepSeek-V3 (102k stars), awesome-llm-apps (102k), Microsoft's markitdown (91k), browser-use (81k). So the growth isn't an influx of web developers into Django — judging by the top repos, the major AI tools of 2024–2025 lean toward Python.

In the TypeScript top, openclaw leads with 310k stars, which makes sense given how much attention personal AI assistants are getting right now. It's followed by opencode (121k), Google's gemini-cli (98k), and Anthropic's MCP servers (81k). Almost the entire TypeScript top is AI infrastructure too.

A surprise in C++: Ladybird (61k) — an independent browser engine built from scratch rather than forked from Chromium or WebKit. In the Go top: Fabric (40k) — a library for working with AI; typescript-go (24k) — Microsoft rewriting the TypeScript compiler in Go for performance.

Seasonality: Who Behaves Predictably and Who Doesn't

Seaborn builds a heatmap in five lines of code — one of those cases where the tool does all the visualization work for you. We normalize each language to its own maximum (0–100) and look for patterns.

Chart 6. Activity seasonality by language. Each cell as % of the language's peak quarter

Python and TypeScript: pale yellow cells at the start — in Q1 2024 they sit at 43% and 34% of their respective peaks — and deep red at the end, having doubled and tripled over two years, respectively. Java, C#, and JavaScript stay uniformly dark across the period, with no sharp swings. PHP stands apart: a peak in Q4 2024, followed by a decline.

Comparing with TIOBE and RedMonk

Now let's compare our data against TIOBE figures for March 2026 (taken from their site) and RedMonk's Q1 2025 report, published in June 2025. Yes, that's how it is with RedMonk.

Chart 7. Ranking comparison: our GitHub data vs. TIOBE (March 2026) and RedMonk (Q1 2025)

Key discrepancies:

• C is second in TIOBE, eighth in ours. TIOBE counts search queries, and C's search traffic is huge — documentation, Stack Overflow, learning materials. Far fewer new public C projects are actually being created.
• TypeScript: third in ours, outside the TIOBE top 20, sixth in RedMonk. This is the most telling discrepancy. People don't search "how to do X in TypeScript" — they search "how to do X in JavaScript". Our ranking based on new repositories captures a real ecosystem shift.
• Go: ninth in ours, sixteenth in TIOBE. Go developers create projects but rarely ask questions on Stack Overflow — the documentation is solid, and the community has settled on its own channels.

Conclusions

We collected 160 data points across 20 languages and 8 quarters, identified the top 5 repositories for each of the top 10 languages, and compared the results against two external rankings.

Judging by the top repositories, AI has noticeably shifted the balance of power. Python and TypeScript lead largely because of AI infrastructure, though the star-count top is partly a hype metric — high-profile releases like DeepSeek accumulate stars fast. Languages are growing not because new web libraries appeared, but because the AI tooling of 2024–2025 leans toward them.

TypeScript appears to have won client-side web development. +190% over two years isn't short-term hype — it's a shift in the default. Starting a new project in plain JavaScript today increasingly requires a separate justification. Rust is growing steadily, without spikes — quarter after quarter, with no catalyst release. Systems programmers are switching, and the language's trendy status and its practical value for memory safety reinforce each other. Ruby is losing ground but not disappearing. −37% over two years is a serious signal. Rails is alive, but new projects are increasingly going elsewhere.

The entire analysis ran on a VPS with a pre-installed Anaconda + JupyterLab image. Infrastructure never got in the way: the environment is ready, packages are compatible, results are reproducible. Getting from the first SSH connection to the first chart took under ten minutes.