The invisible engine: 5 surprising truths about the open source world in 2026

updated
17 November 2026
17 November 2026
5 min read

A typical web app can pull in hundreds of open-source packages before much business logic is written. Most are maintained by people the product team will never meet, and some depend heavily on a single maintainer.

Open source package security alert
One alert can name a package nobody on the team chose

Open source became mainstream long ago. In 2001, Microsoft’s CEO Steve Ballmer called Linux a cancer, and in 2018 the same company bought GitHub. The question now is how a company should treat code it depends on but doesn’t control: which packages are healthy, which vulnerabilities actually matter, and what happens to an internal fork a few years in.

This guide looks at five less obvious truths, from a study linking open source to national GDP to Meta’s escape from its own WebRTC fork, and what each one means for teams choosing and maintaining dependencies.

{{banner}}

1. Open source pays off unevenly

Does contributing to open source pay off for the one who contributes? A 2024 study in the Journal of Technology Transfer examined this at the scale of whole countries, comparing their developers’ open-source activity with national GDP.

For the world as a whole, the answer is yes. Without any open-source contributions, the average country’s GDP would be 2.2% lower in the long run. For individual countries, the picture is less tidy. Smaller countries can see a negative GDP effect from their own developers’ contributions because other economies can build on that code without compensating the contributor. Countries that spend more on R&D lose less, since they have what economists call absorptive capacity: the skills and investment to turn shared code into products of their own.

For companies, the takeaway is similar: teams that understand their dependencies well enough to patch, extend, or replace them are better positioned to benefit from open source than teams that only install them.

Economic impact of open source software worldwide
Code shared in one country powers products in many others

2. Popular packages can still have one maintainer

Linus’s Law has long shaped how people think about open-source security: “given enough eyeballs, all bugs are shallow.” Heartbleed, disclosed in 2014, showed how thin that assumption can be. The bug sat in OpenSSL, the library that encrypted traffic for a large part of the web. Yet the project lived on about $2,000 a year in donations and had one full-time developer, Stephen Henson, along with a few volunteers. Millions of servers used the code, and almost nobody was paid to look after it.

The industry response came within weeks. In April 2014, the Linux Foundation launched the Core Infrastructure Initiative, backed by Amazon, Cisco, IBM, Intel, Microsoft, and other companies, to fund projects the internet can’t do without. Its work now continues under the Open Source Security Foundation (OpenSSF), formed in 2020.

For a team choosing a dependency, the lesson is practical. Download counts show how widely a package is being pulled, but they say little about who maintains it. A few checks take minutes:

  • Contributors: how many people actively commit, and what happens if the main one leaves.
  • Activity: when the last release came out and how quickly issues get answered.
  • Security policy: whether the project has a documented way to report vulnerabilities.

OpenSSF’s Scorecard automates checks around project maintenance and security practices and assigns scores that can help compare dependencies before they reach production.

A package with millions of downloads can still rest on one person’s free evenings.

3. Open source now runs cars and cities

Code that once powered servers now sits inside physical products. Toyota put Automotive Grade Linux, a Linux Foundation project, into the infotainment system of the 2018 Camry, the first Toyota vehicle sold in the U.S. with an AGL-based system. Two years later, the Polestar 2 became the first production car with a native Android Automotive system, with software updates delivered over the air.

City governments made the same move for a different reason. In 2018, Barcelona planned to direct 70% of its software development budget to open-source software to reduce costs and dependence on proprietary suppliers.

Both cases share a detail that matters for any company building on open source. Cars and city systems can stay in service far longer than the original maintainers of their libraries remain involved. Choosing a dependency for a product like that also means deciding who will look after it once its authors move on.

Open source software in cars and city infrastructure
Open-source code now runs in cars and on city streets

4. Installed code and reachable code are two different risks

A new project rarely brings in just the packages a developer chose. As of version 5.3, Express, a popular JavaScript framework for Node.js, lists 28 direct dependencies, which bring additional transitive packages into node_modules, each with its own code and security history. When a scanner flags one of them, the real question is whether the app ever runs the vulnerable function. AI coding tools add another layer of risk: hallucinated dependencies, packages a model imports that don’t exist and that attackers can register under the same name.

That’s the gap between two kinds of code in the same project:

CriterionInstalled codeReachable code
What it coversAll the files of all the packages on diskThe functions the app can actually call
How it’s foundSoftware composition analysis (SCA) scannersCall-graph analysis with tools such as CodeQL or Semgrep
What a flagged vulnerability meansIt exists somewhere in the projectThe app can trigger it
Typical sizeThe full dependency treeA fraction of it

Reachability helps a team decide which alerts to fix first. A flaw in a cookie-parsing function the app cannot currently reach may be a lower priority than the same flaw on a route that handles every login. Static analysis has blind spots, though. Code can still be reached through reflection, dynamic imports, misconfiguration, or crafted input, so “unreachable” means “lower priority,” not “safe to ignore.”

A workable routine fits into the existing build process:

  • Scan on every build: run an SCA scan in the pipeline so new advisories show up before release.
  • Map the tree: keep a dependency graph that separates direct from transitive packages.
  • Trace the critical paths: generate call graphs with CodeQL or Semgrep for authentication, payments, and other sensitive routes.
  • Check the dynamic paths: confirm that flagged functions can’t be reached through reflection or dynamic dispatch.
  • Repeat after changes: rerun the analysis whenever a dependency is added or updated.

For a team that gets a security alert about a dependency, this turns into a simple order of work. First check whether the app can reach the flagged function, then decide how urgent the fix is, and keep unreachable flaws in the backlog until they’re fixed instead of closing them.

A scanner sees everything on disk, and an attacker needs only the code the app can reach.

5. Long-lived forks become a trap

Teams that depend heavily on an open-source library sometimes need to change it, and the quickest option can be to fork it and patch the copy. Meta did exactly that with WebRTC, the library behind real-time audio and video, and in April 2026 described what followed as the “forking trap.” Each internal patch made the next upstream update harder to merge, until the fork drifted far behind the community version and stopped receiving its security fixes and improvements.

Getting out meant running the old fork and the new upstream release side by side across more than 50 use cases, and that created a problem of its own. Linking two versions of the same C++ library into one app can trigger One Definition Rule (ODR) conflicts and thousands of symbol collisions. Meta’s engineers solved it in three steps:

  • Renamespacing: an automated rewrite moved the new copy from the webrtc:: namespace to webrtc_latest::, so the two versions stopped clashing.
  • A generated shim: a thin layer between the app and WebRTC sends each call to the right version, and its code was generated by parsing the library’s abstract syntax tree (AST).
  • A smaller footprint: duplicating the library outright would have added about 38 MB to the uncompressed binary, and the shim approach added about 5 MB, an 87% reduction.

The team is now training AI agents to resolve most of the merge conflicts that come with each new WebRTC release, leaving the harder architectural changes to engineers. For a smaller company, the lesson comes before the clever engineering: a fork needs a plan for pulling upstream changes from the day it’s created, because the cost of catching up grows with every release it skips.

Open source comes with ownership

Open source gives teams enormous leverage, but every dependency also creates a relationship with code they do not fully control. Its popularity says little about who maintains it, a flagged vulnerability may or may not be reachable, and a convenient fork can become difficult to unwind years later.

Critical dependencies therefore need the same attention as any other part of the stack: visibility into who maintains them, how the product uses them, and how updates will flow back from upstream. The more important open source becomes to a product, the less sense it makes to treat it as free, invisible plumbing.

{{banner-2}}

Planning a product on open source?

Halo Lab helps you build on dependencies you can rely on.

Explore software development

Too many dependencies to manage?

Halo Lab helps keep them current and under control.

Meet your dedicated team

copy iconcopy icon
copy iconcopy icon
Sum UP
Get a free checklist
Please, enter your full name
Please, enter your email
Please, enter your job title
Download now
Check out your email inbox
Oops! Something went wrong while submitting the form.
Get a free guide
Please, enter your full name
Please, enter your email
Please, enter your job title
Download now
Check out your email inbox
Download guide
Oops! Something went wrong while submitting the form.