Abandoned Repositories on GitHub: Which Languages Are Losing Developers, and When Code Stops Getting Updated

Introduction

In a previous article, we used GitHub data to analyze programming-language popularity by the number of new repositories created each quarter. The results were intriguing: JavaScript out in front, TypeScript tripling, Ruby sagging. That ranking answered the question of where new things are being built right now. What it left off-screen was everything else — namely, what happens to older projects: do they live on, or quietly turn into digital archaeology?

In this article we turn to the other side of the same ecosystem: another analysis of programming-language popularity based on GitHub data, this time looking at abandoned-project statistics to determine which programming languages are losing developers in 2026.

The same 20 languages, but now we are looking at decline rather than creation. What share of public repositories in each language has gone a long time without new pushes, and how does that figure change once projects are equalized by age and by popularity? And does mass-scale tutorial coding differ in this respect from serious projects with thousands of stars? The difference, as we will see, is substantial — and it tells a somewhat different story than the previous ranking.

Let's get the caveats out of the way up front so we don't have to keep coming back to them. As a way of identifying abandoned GitHub repositories, the “no pushes for over a year” metric is crude in itself. There are finished libraries that simply have no reason to update — small utilities like `is-even` on npm, for instance. There are specs and tutorial repositories that by definition never need to change. All of these count as “abandoned” under our metric, even though they are effectively alive.

Naturally, GitHub is not the whole world of software development. Corporate Java and C# code has long lived in GitLab, Bitbucket, and on-prem installations. Chinese developers overwhelmingly use Gitee. So when it turns out below that 84% of public Java repositories haven't received a push in over a year, that refers only to public activity on GitHub. Inside corporations, people are still actively writing Java — they just don't publish the code.

The data we collected can be useful in several ways. The first is dependency selection. A TypeScript library with 5,000 stars that appeared in 2023 will most likely still be alive a couple of years from now, whereas a Scala project with 800 stars dating from 2017 is almost certainly no longer maintained, even if it looks active. The second is choosing a language for a new project with the long term in mind: the figures on the influx of popular new projects and the share of archived ones give a decent sense of where each ecosystem is headed. And finally, there is the simple matter of understanding how languages live and die. Each one, as it turns out, does it in its own way.

Server and environment

The task is purely analytical and undemanding, so there are no particular hardware requirements. You can run the collection anywhere — an ordinary laptop, a home machine, or a virtual private server (VPS) will do. No GPU is needed; two virtual cores and four gigabytes of RAM are more than enough. The dependencies to install are minimal.

`pip install requests tqdm pandas matplotlib seaborn`

We ran the collection itself on a separate Ubuntu server with JupyterLab, and we moved it there for purely practical reasons. Collection takes about half an hour, and you don't want your work laptop tied up for that long. It's convenient to keep the CSV files next to the notebook where the charts are built. And if you later decide to put the collection on a scheduler and refresh the data once a month, nothing needs to be migrated. Everything works exactly the same on a local machine — it's just less convenient for recurring runs. A VPS with a ready-made Anaconda + JupyterLab image makes sense in precisely that case: when you need an isolated sandbox or scheduled runs.

Querying GitHub requires a Personal Access Token, which takes a minute to create in your profile settings; read access to public repositories is enough. Without a token, the limit is 60 requests per hour; with one, it's 5,000 for the main API and about 30 per minute for GitHub's Search API. All three stages of the collection take roughly half an hour.

What we count, and how

The idea is simple. If a repository has gone a long time without new pushes, it is most likely an abandoned GitHub repository. This approach lets us estimate code-abandonment metrics across mass samples. The method isn't perfect: there are finished projects with no reason to update, forks that occasionally get an upstream rebase, and so on. Our approach works more as a mass-scale liveness indicator.

We took four abandonment thresholds: six months, one year, two years, and five years since the last push. For each language and each threshold, we computed the share of repositories falling under it. The counting is done through the Search API's standard `pushed:<DATE` filter, which returns only `total_count` without downloading the full list of repositories. That keeps us well within the rate limits.

Additionally, for each language we collected the top 1,000 repositories by stars, with creation dates, last-push dates, sizes, and the `archived` and `disabled` flags. This gives a view of popular projects — the ones other developers actually rely on. And separately, a sample drawn from different star strata, to examine how abandonment depends on popularity.

The reference point is May 14, 2026. All shares are computed relative to that date.

Limitations

Before the charts, it's worth briefly marking the method's boundaries; a detailed look at its weak spots comes at the end of the article. The metric relies on the `pushed_at` field, which records the last push to any branch, not necessarily the default one. Technically, a repository can look alive because of forks or rebases. The Search API counts only public repositories, so corporate development never enters the sample. Archived repositories were not subtracted from the totals, but they are flagged separately, so we can see which projects were shut down explicitly and which were silently left behind.

One more important note: this is a snapshot as of today, not a cohort analysis. We are looking at what share of everything that exists in a language appears alive, not tracking a fixed set of repositories over time. Hence a bias: old languages have accumulated a long legacy tail, young ones haven't. So the whole-mass shares need to be read with the ecosystem's age in mind, while abandonment within the top 1,000 by stars is the cleaner signal for assessing how well open-source projects on GitHub are maintained. There is a dedicated cohort breakdown later in the article for exactly this purpose.

Results

Share of abandoned public repositories by language

Share of abandoned repositories on GitHub by programming language, May 2026 data. Source: GitHub Search API, language-popularity analysis.

Languages are sorted by the share of repositories with no new commits for over a year. This chart counts every public repository indiscriminately, so it depends heavily on the age of the ecosystem — old languages have accumulated a long legacy tail. It's a raw snapshot; it cannot be read as “language health.” For that, see the cohort and stratified breakdowns below.

Ruby tops the abandonment list: 97.2 percent of all public Ruby repositories have had no new commits in over six months, and 95.3 percent in over a year. Much of this is an age effect — Ruby has been around since 1995 and has built up an enormous legacy tail. What that figure really means only becomes clear in the cohort breakdown below, where the picture for Ruby turns out to be two-sided. Scala follows at 95.4 and 92.8 percent. Read literally, almost nothing in these languages gets updated anymore. Swift, Elixir, and Java sit at 85 percent and above. At the other end of the scale are Zig at 49.4 percent with no new commits for over a year, TypeScript at 52.4, Lua at 60.5, Rust at 63, and Python at 65.2.

It's important to understand that this picture isn't driven solely by whether people abandon code in a given language. It also reflects the ecosystem's age. Java has existed since 1995, Ruby likewise since 1995, so these languages carry a great deal of accumulated legacy. Rust's first stable release came in 2015; Zig has yet to reach 1.0. The numbers are accurate, but the interpretation “Ruby is dead” does not follow directly from them. It's more that people have stopped actively creating new things in Ruby, while a lot of old code has piled up.

Freshness and archiving

Share of fresh and archived repositories in the top 1,000 by stars — GitHub activity analysis

There are two signals on one chart here. The green bars show the share of top-1,000 projects created within the last two years; the red bars, the share archived. The first measures the influx of fresh blood among popular projects; the second, an official exit from the game.

Zig leads on renewal: 33 percent of its top 1,000 was created in 2024–2026. That is a lot — the ecosystem is literally brand new. Python has 19 percent, TypeScript 18, Rust 13. For Scala, the share of fresh projects in the top 1,000 is below 1 percent: in two years, virtually not a single new project has broken into Scala's starred thousand. The signal is reliable, because the sample here is the entire top 1,000 — a thousand repositories. Ruby and Java are at around 1 percent. In other words, the popular tops of Ruby and Scala are still the very same projects they were five years ago.

On archiving: 14.5 percent of Scala's top has been officially shut down by its owners, 10.2 percent of Ruby's, and 9.5 of JavaScript's. Rust is at 4.1, TypeScript at 3.3. Archiving a repository is a strong signal — the owner is consciously declaring that it will no longer be maintained. When more than 10 percent of a language's top falls into that category, it says something about the ecosystem as a whole.

The entire mass vs. popular projects

Abandonment compared: all repositories versus popular projects across programming languages

This is probably the most revealing chart in the whole article for understanding how to check repository activity on GitHub and how to separate mass-scale “tutorial noise” from genuinely maintained projects. The red bars show the share of abandoned repositories among all public repositories in a language; the blue bars, the share within the top 1,000 by stars. The wider the gap between red and blue, the more tutorial clutter distorts the overall picture.

For JavaScript the gap is enormous: 77.7 percent of the entire mass is dead, but only 38.9 percent of the top. Among the millions of JS repositories, the majority are tutorials, homework assignments, and experimental forks.

Python is even more clear-cut: 65.2 percent versus 19.3. In the mass, Python looks worse than at the top, because popular Python projects are actively maintained while the bulk includes an enormous tail of tutorial projects.

Swift and Scala are interesting in a different way. Swift has 85.5 percent of its entire mass without new commits for over a year and 55.2 percent within the top 1,000, with a confidence interval of 52 to 58 percent. Even among the thousand most-starred Swift projects, more than half are abandoned — and that's not sampling noise; the interval is narrow. The ecosystem doesn't appear to be merely aging in bulk; it is sagging in its quality tier as well. Scala shows 92.8 and 55.4. Same picture.

Ruby's story is two-sided. Across the entire mass, 95.3 percent has had no new commits in over a year, but within the top 1,000 the figure is 39.4 percent, with an interval of 36 to 42. The iconic Ruby projects live on and are maintained, while mass development has moved elsewhere. The language is holding onto its core of serious projects but has lost the broad user base.

The healthiest by both measures are TypeScript (52.4 and 10.6 percent) and Rust (63 and 12.5). Their mass is less dead, and their tops are almost entirely active.

Controlling for age: the cohort breakdown

Cohort analysis of repositories by year of creation — code-abandonment metrics

The “entire mass” chart has a weak spot: it conflates a programming language's health with the age of its ecosystem. To separate those factors, we applied a cohort analysis of repositories — grouping by year of creation. We grouped each language's top 1,000 by the repository's creation year and computed the abandoned share for each annual cohort. If the differences between languages came down entirely to accumulated legacy, then with the creation year held fixed, all languages would run roughly level — but that is not what happens. In the 2015 cohort, where the projects are exact contemporaries and age is fully equalized, TypeScript and Rust hold at around 18 percent abandoned, while Scala and Java climb to 60 and above. The gap persists in every cohort from 2010 through 2022. Ecosystem age affects the absolute numbers, and yet it does not explain the differences between languages. A Java project from 2016 is roughly three times as likely to be abandoned as a Rust project from the same year.

Two caveats are needed here. The 2023 and 2024 cohorts drop to nearly zero for every language. Those repositories are simply too young to qualify under the “a year without new commits” criterion, so the dip on the right side of the chart is an artifact of the metric, not a signal. In addition, Zig has been deliberately left off the chart: not a single annual cohort of its projects reaches even 20 repositories, and a trend line drawn from such data would be misleading.

Abandonment by star strata

Repository abandonment by star strata: how popularity affects project maintenance

The sample here is built differently. For each language, we took 100 repositories from each of four star strata: fewer than 10, 10 to 100, 100 to 1,000, and over 1,000. This yields a more even picture than the top 1,000, where the popular peak bulges out. For three languages, the top stratum is incomplete: Zig has 42 projects with a thousand or more stars, Julia 37, and R 89. For these three cells the figures are shown, but we draw no conclusions from them — the samples are too small. The map shows what share of repositories in each stratum has gone over a year without new commits. Green means alive, red means dead.

The pattern is immediately visible: the more stars, the more likely a project is alive. For most languages, moving from the 1–9 stratum to the 1,000+ stratum cuts abandonment by a factor of 3–5. In the 1–9 stratum, JavaScript, Ruby, Python, Dart, and Scala run at 86–92 percent dead. These are mostly tutorial projects, homework, and experimental forks; their life cycle is short by definition.

The 1,000+ stratum, on the other hand, is a mirror of the language ecosystem's health and a reliable indicator for anyone wondering how to choose a dependable library on GitHub. And here the field separates. TypeScript has just 1 percent dead among projects with a thousand-plus stars, Rust 3, Python 6, Go 7. In other words, serious projects in these languages almost never get dropped. Zig should be excluded from this list: its top stratum holds only 42 projects, of which formally one is dead. With a sample that size, an honest confidence interval stretches from 0 to 12 percent, so the conclusion “almost nothing in Zig gets abandoned” cannot be drawn from these data.

At the other end of the table sit Dart with 32 percent dead in the 1,000+ stratum, Scala with 31, R with 27, Swift with 25, Java with 23, and Lua with 23. This means that even popular projects in these languages regularly end up without maintenance. Scala and Swift are particularly telling: looking up the table, their abandonment in the 100–1,000 stratum runs at 45–68 percent. The middle and upper-middle of these ecosystems are sagging.

Ruby behaves in an interesting way in this picture. In the 1,000+ stratum, only 13 percent is dead — better than Java or C#. The iconic Ruby projects live on, but in the 100–1,000 stratum, 48 percent is already dead. Ruby is holding its starred peak, while everything just below it is gradually dying off.

TypeScript shows an anomaly in the 1–9 stratum: only 32 percent dead, while its neighbors in the table run at 70–90. Either this reflects the fact that even tutorial TypeScript projects are comparatively recent and simply haven't had time to die, or it's a property of the audience. A plausible guess is that TypeScript currently has an unusually large number of fresh small projects, because new developers are actively picking up the language.

The age breakdown

Repository abandonment by age: which language stays maintained the longest.

The same cohort breakdown, now split out by specific language and year. Where an annual cohort has fewer than 20 projects, no point is plotted, to avoid passing noise off as a trend.

Scala and Java hold steadily at 50–65 percent abandoned in the 2010–2018 cohorts. Projects started in those languages in the early 2010s are, for the most part, no longer updated. For Rust and TypeScript, the 2014–2018 cohorts show only 10–20 percent dead. Projects of the very same vintage, but in these languages, fare noticeably better.

This is interesting in light of the question of what makes a language modern in 2026. The point, it seems, is not just that Rust and TypeScript are popular right now. Old projects in these languages hold up too, because a community has formed around them that keeps maintaining them. Scala and Java have large communities as well, but judging by the numbers, fragmented ones. Projects are left without anyone to look after them, and the old code simply stops being touched.

The drop in every line toward 2024–2026 is natural. Those repositories are too young to have had time to die under the chosen criterion (a year without new commits).

Distribution by time since the last push

Distribution of repositories by time since the last push — GitHub activity statistics

Six histograms over the same stratified sample. The X axis shows how many years have passed since the last push; the Y axis, how many repositories fall into each interval. The red dashed line is the one-year threshold; the green line is the median. Unlike the top-1,000 chart, this one shows the whole ecosystem, not just the peak.

TypeScript and Rust have similar distributions: a large spike at zero — 133–146 repositories out of the 400 in each sample (100 per stratum) received commits literally this week — followed by a fairly thick tail from 1 to 8 years. The medians are 0.36 and 0.3 years, roughly four months. Abandonment across the sample is 37 and 35 percent. That is significantly higher than the 16 percent for the top 1,000, and that's normal: the stratified sample includes many small projects, which get dropped faster than popular ones.

Python looks noticeably worse. The spike at zero is smaller (97 repositories), and the tail is considerably thicker. The median is 2.02 years; 62 percent of the sample is abandoned. In other words, the median Python project — popularity aside — last received commits two years ago. In the mass, Python is more complicated than the top 1,000 suggests.

Java, Ruby, and Scala show a similar but more pronounced picture: medians of 2.85, 2.2, and 2.62 years; 67, 60, and 64 percent abandoned. After the initial spike, the distributions are nearly uniform. For these languages, it is normal for a popular project to go untouched for a year, two, three, five.

The difference between this chart and the earlier top-1,000 one matters. The top 1,000 is a snapshot of the most popular projects, and it shows that at the peak, TypeScript and Rust are almost entirely alive. The stratified sample adds everything else to the picture and shows that for the mass of mid-sized projects, Python's situation is closer to Java's than to TypeScript's. Both views are accurate — they simply answer different questions: “Is it safe to depend on a popular library?” and “What does the average project in this language look like?”

Famous corpses

Among repositories with no new commits in over two years, we found the 20 most-starred. They are material for a separate, melancholy piece; here is a sampling.

• `fighting41love/funNLP` (Python, 80K stars) — last push in May 2024.
• `MisterBooo/LeetCodeAnimation` (Java, 76K) — August 2023.
• `resume/resume.github.com` (JavaScript, 62K) — February 2023.
• `atom/atom` (JavaScript, 60K, archived) — January 2023. GitHub officially retired the Atom editor in favor of VS Code.
• `angular/angular.js` (JavaScript, 58K, archived). Google ended AngularJS support in early 2022; the repository was frozen in 2024.
• `astaxie/build-web-application-with-golang` (Go, 43K). An educational project; last push in May 2024.
• `GitSquared/edex-ui` (JavaScript, 44K, archived). A sci-fi-style terminal; the author no longer maintains it.
• `adobe/brackets` (JavaScript, 33K, archived). Adobe's text editor, shut down after the company's priorities changed.
• `lllyasviel/ControlNet` (Python, 33K). A model for Stable Diffusion. Activity has shifted to forks and to the author's newer projects.
• `shadowsocks/shadowsocks` (Python, 33K). The original repository has been frozen since 2024.

Among these dearly departed, three kinds of death stand out. The first is the corporate decision: Atom and Brackets were shut down by their companies after a change of strategy. The second is natural completion: the project achieved its goal and the author moved on, as with `edex-ui` and `hacker-scripts`. The third is activity migrating to forks and new projects while the stars stay on the original, as with `ControlNet` and `shadowsocks`. That is an important nuance: an abandoned repository does not always mean a dead idea — sometimes it just means the activity has moved.

Conclusions

TypeScript and Rust look healthier than everyone else. Within the top 1,000 by stars, TypeScript has 10.6 percent abandoned and Rust 12.5 percent. Both figures rest on a thousand repositories each, and their confidence intervals are narrow. The stratified sample puts their top stratum at 1 and 3 percent, but those cells hold just 100 projects each and the intervals are wide, so the reliable basis for the conclusion is precisely the top 1,000. In practical terms, this means that when a developer is figuring out how to choose a dependable library on GitHub, popular TypeScript or Rust dependencies have a high chance of staying maintained — an important signal when picking a language for a new project.

If you look beyond the peak at the full stratified sample, the picture is less rosy. It includes 100 projects from every stratum, down to small repositories with a couple of stars, and the dead share there is about 35 percent for both languages. There is no contradiction with the top-1,000 figure; these are simply different views. The thousand starred projects are almost all alive, while the average project in the sample gets abandoned more often. For a mass ecosystem, 35 percent is ordinary background noise.

Ruby is holding its core but losing everything else. In the 1,000+ stratum, Ruby has just 13 percent abandoned — a notable share of its starred core is alive — while mid-sized and small projects are being dropped en masse. It's the typical profile of a mature language with a departing generation: the foundation is kept up by a small group of maintainers, and there is no new influx.

On Scala, every view points the same way: 14.5 percent of the top 1,000 archived; 55.4 percent of the top 1,000 without new commits for over a year, with an interval of 52 to 58; 55 to 66 percent abandoned in the 2010–2018 cohorts even after controlling for age; less than 1 percent of the top created in the last two years. Each individual indicator could be disputed. Together, they describe an ecosystem that is not gaining notable new projects and is losing its old ones.

Swift shows a split pattern. 85.5 percent of its entire mass is dead, which is explainable: lots of beginners' tutorial iOS projects, abandoned after the first trial build. Yet 25 percent of popular projects in the 1,000+ stratum are dead too, which is worse than the table average. One could speculate that this comes down to the specifics of mobile development: the app ships, it works, the repository gets closed. Our data cannot test that hypothesis — it would require classifying project types, which is beyond the scope of this collection. So it remains a hypothesis, not a conclusion.

Zig is the youngest ecosystem and, so far, the liveliest. Only 49 percent of its entire mass is dead; the language is two years old, and almost everything in it was created fairly recently. That is the natural advantage of youth, and it will disappear as soon as Zig accumulates a legacy tail of its own.

The top-repository paradox: the more popular a project, the better its chances of being alive. It sounds banal, but it matters. In most languages, moving from the 100–1,000 stratum to the 1,000+ stratum cuts abandonment by a factor of 3–5. Stars are not just an indicator of popularity but an indicator of liveness — which makes sense: a project with many users gets bug reports, forks, and pull requests, and all of that pushes the owner to keep maintaining it.

Caveats

The “no pushes for over a year” metric is crude by nature. There are finished libraries with simply no reason to update, like small utilities such as `is-even` on npm. There are specs and tutorial repositories that by definition should never change. Our metric counts all of them as abandoned even though they are effectively alive, and short of manually reviewing every repository, there is no way around that.

Archived repositories were not subtracted from the totals. If they had been, the figures for Scala and Ruby would look slightly better, but not radically so — the share of archived projects in the overall mass is small.

GitHub is not the whole world of software development. Corporate Java and C# code largely lives in GitLab, Bitbucket, and on-prem installations, while the Chinese scene sits firmly on Gitee. So the statement “84 percent of public Java repositories are abandoned” holds only for public activity on GitHub and says nothing about the software life cycle in corporate repositories on GitLab or Bitbucket. In real-world use, Java remains active in tens of thousands of companies that never publish their code.

A separate word on how much to trust the numbers. The top-1,000 and whole-mass figures rest on large samples with narrow confidence intervals, and those conclusions can be relied on. The stratified-sample figures, at a hundred repositories per stratum, are reliable for comparing orders of magnitude but not tenths of a percent, and the three incomplete top strata — Zig, Julia, and R — support no conclusions at all. The cohort breakdown equalizes project age but not project type: a library, an application, and a tutorial repository live different lives, and our data does not separate them.