A large empirical study of 36,464 GitHub projects (Nourry et al., 2024, published 2025 in IEICE Transactions on Information and Systems) computed each project's truck factor — the number of developers whose simultaneous departure would leave the project without the expertise needed to maintain it — at yearly snapshots, and defined a truck-factor developer detachment (TFDD) as the point at which every current truck-factor developer has stopped committing for at least a year. It found that 89% of projects experience at least one TFDD, that 70% of these events occur within the first three years of a project's life, that only 27% of affected projects survive by attracting a new core developer, and that projects losing their core team early are less likely to survive than those losing it late. The study is explicitly correlational and rests on specific measurement choices, leaving a precise open problem: establish, with causal or process-level evidence, why some projects survive losing their entire core team (and why early losses are more often fatal), whether the observed survival correlates (project age, commits, contributors) are causally actionable predictors, and how sensitive the prevalence, timing, and survival estimates are to the truck-factor algorithm, snapshot cadence, inactivity threshold, developer-identity resolution, and sampling filters used. These questions remain unanswered in the 2024-2026 literature, though adjacent work provides difference-in-differences causal evidence for single core-developer dropouts, a large descriptive typology of project revival in scientific software, and growing evidence that truck-factor algorithms disagree materially.

Background

Open-source software (OSS) projects depend on contributors whose effort is unevenly distributed: a small core of developers typically holds most of the knowledge required to maintain the codebase. The truck factor (also called bus factor) operationalizes this concentration: it is the number of developers whose sudden departure would leave a project unable to maintain its own code. The standard computation, introduced by Avelino et al. (2016), assigns each developer a Degree-of-Authorship (DoA) score for each file — larger for developers who authored or frequently modified the file — and derives the truck factor from the smallest set of developers who collectively account for (nearly) all of the authorship coverage; the developers in that set are the truck-factor (TF) developers, the de facto core team. A comparative study by Ferreira et al. (2017) showed that available truck-factor algorithms can disagree substantially on the same repository, so any downstream claim about the core team is algorithm-dependent to some degree.

Using this machinery, Nourry et al. (2024; published with the same content as Nourry et al. 2025 in IEICE Transactions on Information and Systems) studied 36,464 GitHub projects that passed sampling filters (at least 20 stars, at least 10 contributors, at least two years of history, not a fork — i.e., not a copied repository), computing the truck factor at a yearly snapshot of each project's main branch with the Avelino et al. implementation, merging developer identities by name and email, and classifying a developer as having abandoned a project after one year with no commits. They defined a truck-factor developer detachment (TFDD) as the moment when every current TF developer had abandoned the project, and defined survival as the project later attracting at least one new TF developer. Their findings: 89% of the projects experienced at least one TFDD; 70% of these events occurred within the first three years of a project's life; most projects relied on a single TF developer; only 27% of TFDD-affected projects survived; and surviving projects were significantly older, with more commits and more contributors at the time of the event (Mann-Whitney rank tests — a nonparametric statistical test comparing two independent groups — p < 0.05).

This result sits in a lineage of turnover and abandonment research. Avelino et al. (2019) studied abandonment and survival in roughly 2,000 popular GitHub projects; Ferreira et al. (2020) quantified core-developer turnover in a sample of OSS projects; Calefato et al. (2022) modeled how long inactive GitHub core developers stay away and how often they return; and Russo Latona et al. (2024) applied a difference-in-differences design (a quasi-experimental method comparing before-and-after changes between affected and unaffected projects) to 9,573 GitHub projects, estimating that a single core developer's dropout causally reduces the remaining developers' productivity by about 20%. What none of these studies — nor the Nourry et al. study itself — establishes is causal or process-level knowledge of what happens when a project loses its entire truck-factor team: why some projects attract a replacement core and most do not, why early departures are the most fatal, whether the correlates of survival are causes or confounded associations, and whether the headline prevalence and survival numbers are robust to the measurement choices (yearly cadence, one-year inactivity threshold, a single truck-factor algorithm, name/email identity merging, GitHub-only sampling with star and contributor floors) on which they rest.

Problem Statement

The problem is to establish, with causal or process-level evidence and validated measurement, whether and why losing the entire truck-factor core development team is fatal for an open-source software project. The source study (36,464 GitHub projects with at least 20 stars, 10 contributors, and two years of history; yearly truck-factor snapshots with the Avelino et al. algorithm; TFDD defined as every current truck-factor developer having made no commit for at least a year; survival defined as attracting at least one new truck-factor developer) found 89% of projects experience at least one TFDD, 70% of these events occur within the first three years of a project's life, only 27% of affected projects survive, and surviving projects are older and have more commits and contributors at the time of the event. The unresolved question has four linked parts jointly serving one objective — a defensible verdict on whether core-team loss is a critical, predictable, and measurable event for OSS projects: (1) Causal mechanisms and triggers: identify, with causal or process-level evidence, why some projects survive a TFDD and others do not — in particular why early TFDDs are less likely to be survived, testing the posited explanation that young projects have not yet built the user community that can revive a project for its own use, against alternatives including community-formation dynamics and socio-technical triggers of revival. (2) Predictive validity: determine whether the observed correlates of survival (project age, commit count, contributor count at the time of TFDD) are causal predictors usable for intervention, or consequences of confounders such as project topic, governance, or external sponsorship. (3) Measurement robustness: quantify how sensitive the prevalence, timing, and survival estimates are to the implementation choices — the truck-factor algorithm, the yearly snapshot cadence, the one-year inactivity threshold, the main-branch-only analysis, and the name/email identity-resolution heuristic. (4) Population validity: establish whether these findings extend beyond the sampled population — to very small or very new projects, and to projects not hosted on GitHub. Across these four parts, the problem is to establish, from the causal or process-level evidence of parts (1) and (2) and the re-measurement results of parts (3) and (4), which of the source study's conclusions survive causal scrutiny and re-measurement across these axes and which do not.

References

  1. Olivier Nourry, Masanari Kondo, Shinobu Saito, Yukako Iimura, Naoyasu Ubayashi, Yasutaka Kamei (2024). Myth: The loss of core developers is a critical issue for OSS communities. arXiv:2412.00313, DOI: 10.48550/arXiv.2412.00313. https://arxiv.org/abs/2412.00313
  2. Olivier Nourry, Masanari Kondo, Shinobu Saito, Yukako Iimura, Naoyasu Ubayashi, Yasutaka Kamei (2025). Abandonment and Resilience: Understanding Core Developer Turnover in Open-Source Software. IEICE Transactions on Information and Systems, E108-D(11). DOI: 10.1587/transinf.2025edl8005. https://doi.org/10.1587/transinf.2025edl8005
  3. Giuseppe Russo Latona, Christoph Gote, Christian Zingg, Giona Casiraghi, Luca Verginer, Frank Schweitzer (2024). Shock! Quantifying the Impact of Core Developers' Dropout on the Productivity of OSS Projects. Companion Proceedings of the ACM Web Conference 2024. DOI: 10.1145/3589335.3651559. https://doi.org/10.1145/3589335.3651559
  4. Guilherme Avelino, Leonardo Passos, Andre Hora, Marco Tulio Valente (2016). A Novel Approach for Estimating Truck Factors. arXiv:1604.06766, DOI: 10.48550/arXiv.1604.06766. https://arxiv.org/abs/1604.06766
  5. Guilherme Avelino, Eleni Constantinou, Marco Tulio Valente, Alexander Serebrenik (2019). On the abandonment and survival of open source projects: An empirical investigation. 2019 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM). DOI: 10.1109/ESEM.2019.8870181. https://doi.org/10.1109/ESEM.2019.8870181
  6. Fabio Ferreira, Luciana Lourdes Silva, Marco Tulio Valente (2020). Turnover in Open-Source Projects. Proceedings of the XXXIV Brazilian Symposium on Software Engineering (SBES). DOI: 10.1145/3422392.3422433. https://doi.org/10.1145/3422392.3422433
  7. Fabio Calefato, Marco Aurelio Gerosa, Giuseppe Iaffaldano, Filippo Lanubile, Igor Steinmacher (2022). Will you come back to contribute? Investigating the inactivity of OSS core developers in GitHub. Empirical Software Engineering. DOI: 10.1007/s10664-021-10012-6. https://doi.org/10.1007/s10664-021-10012-6
  8. Mivian M. Ferreira, Marco Tulio Valente, Kecia Aline M. Ferreira (2017). A comparison of three algorithms for computing truck factors. 2017 IEEE/ACM 25th International Conference on Program Comprehension (ICPC). DOI: 10.1109/ICPC.2017.35. https://doi.org/10.1109/ICPC.2017.35
  9. Sebastiano Antonio Piccolo (2025). Fast and Accurate Heuristics for Bus-Factor Estimation. arXiv:2508.09828. https://arxiv.org/abs/2508.09828
  10. Sebastiano A. Piccolo, Pasquale De Meo, Giorgio Terracina, Gianluigi Greco (2026). The Theory and Practice of Computing the Bus-Factor. arXiv:2603.07845. https://arxiv.org/abs/2603.07845
  11. Otavio Cury, Guilherme Avelino (2025). The Impact of Generative AI on Code Expertise Models: An Exploratory Study. arXiv:2507.08160. https://arxiv.org/abs/2507.08160
  12. Alexis Butler, Dan O'Keeffe, Santanu Kumar Dash (2025). Measuring Software Resilience Using Socially Aware Truck Factor Estimation. 40th IEEE/ACM International Conference on Automated Software Engineering (ASE). DOI: 10.1109/ASE63991.2025.00318. https://doi.org/10.1109/ASE63991.2025.00318
  13. Ahmed El Cheikh Ammar, Sukru Eraslan, Yeliz Yesilada (2025). Predicting the truck factor in a software repository using machine learning. Information and Software Technology. DOI: 10.1016/j.infsof.2025.107765. https://doi.org/10.1016/j.infsof.2025.107765
  14. Addi Malviya Thakur, Bogdan Vasilescu, Audris Mockus (2026). Beyond the Grave: An Empirical Study of Dormancy and Revival in Scientific Open-Source Software. arXiv:2606.20966. https://arxiv.org/abs/2606.20966
  15. Addi Malviya Thakur, Reed Milewicz, Mahmoud Jahanshahi, Lavinia Paganini, Bogdan Vasilescu, Audris Mockus (2025). Scientific Open-Source Software Is Less Likely to Become Abandoned Than One Might Think! Lessons from Curating a Catalog of Maintained Scientific Software. arXiv:2504.18971. https://arxiv.org/abs/2504.18971
  16. Mohit Kaushik, Kuljit Kaur Chahal (2026). The death spiral of open source projects: A post-mortem analysis of pull request workflow dynamics. Journal of Systems and Software. DOI: 10.1016/j.jss.2026.112942 (preprint arXiv:2605.11844). https://doi.org/10.1016/j.jss.2026.112942
  17. Mohit Kaushik, Kuljit Kaur Chahal (2026). Social Popularity of GitHub Projects: A Lifeline or a Liability? arXiv:2607.00435. https://arxiv.org/abs/2607.00435
  18. Yiming Xu, Runzhi He, Hengzhi Ye, Minghui Zhou, Huaimin Wang (2025). Predicting Abandonment of Open Source Software Projects with An Integrated Feature Framework. arXiv:2507.21678. https://arxiv.org/abs/2507.21678