
Episodes
How Linux Became the Silent Engine of Modern Tech
This episode explores how the Linux kernel evolved from a hobbyist project into the foundational infrastructure powering everything from supercomputers to your smartphone. We examine the specific governance model that allowed it to scale globally without collapsing under corporate pressure, and why its open-source nature created an unexpected moat against proprietary competitors. Hosted by Lucas and Luna. #LinuxKernel #OpenSource #TechnologyHistory #SoftwareInfrastructure #CommunityGovernance…
How Open Source Funding Became a Business Model
We look at how the Linux Foundation and individual maintainers are moving from volunteer reliance to sustainable funding models. With the rise of sponsored development and corporate patronage, we examine whether this shift saves projects or creates conflicts of interest. Featuring insights on GitHub Sponsors, the Apache Software Foundation's new financial framework, and the real cost of maintaining critical infrastructure like OpenSSL. #OpenSource #LinuxFoundation #GitHubSponsors…
How Open Source Software Shapes Global Standards
We look at how Linux kernel patches evolve from community code into global regulatory and infrastructure standards. Lucas and Luna explore the informal governance that turns volunteer contributions into mandatory compliance frameworks for telecom, finance, and energy grids in September twenty twenty-six. #OpenSource #LinuxKernel #TechStandards #FexingoBusiness #BusinessPodcast #GovernanceModels #Infrastructure #Compliance #CommunityDriven #TechPolicy #GlobalStandards #SoftwareEngineering…
The Silent Crisis Of Open Source Maintainers
We explore the precarious reality of maintaining critical open-source infrastructure like Node.js and Python. With key maintainers stepping back or facing burnout, projects like npm face existential risks that ripple through the global software supply chain. We examine how community-driven development is struggling to scale without traditional corporate sponsorship models. #OpenSource #SoftwareDevelopment #MaintainerBurnout #Nodejs #PythonFoundation #TechCareers #DigitalInfrastructure…
How Open Source Powers Your Daily Tech
We explore the invisible infrastructure of open source that powers modern technology, from Linux kernels to GitHub repositories. Lucas and Luna discuss how community-driven software development has become the backbone of global business, focusing on specific examples like the Apache Foundation and the role of volunteer maintainers. We look at the economic incentives behind contributing code and why transparency matters more than ever in an era of AI and cloud computing. This episode breaks down…
The Hidden Cost of Open Source Maintenance
Open source projects are the invisible infrastructure of modern business, yet their maintainers often lack the resources to keep them secure and stable. In this episode, we explore the growing crisis of abandoned repositories and the 'bus factor' that leaves critical software vulnerable. Lucas and Luna examine real-world cases where single-developer dependencies failed under pressure, discuss the rise of commercial stewardship models, and ask whether community-driven code can survive without…
How Open Source Funds Its Own Future
Open source powers the modern digital economy, yet most projects rely on volunteer labor with no clear path to sustainability. This episode explores how Linux Foundation projects like PostgreSQL and Eclipse are building formal funding trusts that decouple financial support from corporate dominance. We examine the mechanics of these community-led treasury models, looking at how they protect project independence while ensuring maintainers get paid for critical work. By September twenty…
Open Source Security Through Transparency
We explore how the open source community is shifting from reactive patching to proactive supply chain security. With major infrastructure projects adopting stricter verification protocols, we examine the concrete steps developers are taking to verify code integrity before it reaches production. This includes a look at specific signature verification workflows and why trust is no longer just about reputation but cryptographic proof. #OpenSourceSecurity #SupplyChainIntegrity #LinuxFoundation…
How Linux Kernel Code Became Global Standards
We dig into the specific mechanics of how a single line of code in the Linux kernel transitions from a patch submission to an industry-wide standard. Lucas and Luna examine the governance model that allows thousands of disparate contributors to align on technical specifications without a central authority. We look at the role of maintainers, the pressure of upstream acceptance, and why this decentralized model is critical for modern infrastructure stability. #OpenSource #LinuxKernel…
How Open Source Projects Handle Commercialization
Open source has always been a collaborative engine, but the relationship between community-driven development and commercial viability is shifting. In this episode, we explore how major Linux Foundation projects like Kubernetes and PostgreSQL are navigating the tension between free access and sustainable business models. We look at the rise of dual licensing, the pressure from cloud providers who consume code without contributing back, and the specific governance changes being implemented to…
How Linux Kernel Code Became Global Standards
In this episode of Open Source with Fexingo, Lucas and Luna examine how individual code patches in the Linux kernel evolve into de facto global infrastructure standards. They explore the specific governance mechanisms that allow a single developer’s commit to impact billions of devices worldwide, the role of subsystem maintainers in filtering noise from signal, and why this meritocratic model remains the backbone of modern technology. From network stack optimizations to file system drivers, we…
How Linux Kernel Patches Become Global Standards
We trace the journey of a single line of code through the Linux kernel development process, examining how Linus Torvalds and thousands of maintainers turn raw contributions into stable, secure software that powers everything from smartphones to supercomputers. This episode explores the rigorous review standards, the role of subsystem maintainers, and why open source governance relies on reputation rather than authority. We look at specific examples of controversial patches, the importance of…
Why Open Source Projects Are Switching to Contributor Licenses
In this episode, Lucas and Luna dive into the messy world of contributor licensing in open source. With a wave of projects rethinking how they handle code ownership and IP, they unpack the difference between permissive and copyleft licenses, and why some projects are moving toward Contributor License Agreements (CLAs) and Developer Certificates of Origin (DCOs). They look at the recent shift at a major foundation that adopted a DCO model after years of using a CLA, and what that means for…
How Open Source Projects Handle Trademark Disputes
When a project's name becomes a battleground, what happens? This episode digs into the messy world of open source trademarks, using the long-running WordPress–WP Engine feud as a case study. We look at why trademarks matter more than ever in open source, how projects like Mozilla and the Linux Foundation handle defensive trademark policies, and why a simple name can become a legal minefield. Tune in for a grounded look at the business of naming things in the open source world. #OpenSource…
Why Open Source Projects Are Adopting Contributor Charters
In this episode, Lucas and Luna explore the rise of contributor charters—formal documents that define rights, responsibilities, and decision-making for open source communities. They dive into the Kubernetes charter as a case study, explaining how it emerged from governance crises and now shapes everything from code review to conflict resolution. The conversation covers how charters differ from codes of conduct, licensing, and governance models, and why they're becoming a baseline expectation…
Why Open Source Needs a Bus Factor
In this episode of Open Source with Fexingo, Lucas and Luna explore the 'bus factor' — the number of contributors a project can lose before it stalls. They unpack why this metric matters more than star counts, how it connects to maintainer burnout and security risks, and what projects like Linux, Kubernetes, and even small utilities do to keep knowledge from siloing. Lucas walks through real-world examples, including a npm package that broke the internet when its sole maintainer stepped away…
Why Open Source Projects Are Adopting Contributor Charters
In this episode, Lucas and Luna explore the growing trend of contributor charters in open source projects. They dig into why projects like Kubernetes and the Linux kernel are formalizing expectations, rights, and responsibilities for contributors. With a focus on the recent adoption of a contributor charter by the Apache Software Foundation, they discuss the benefits and potential drawbacks of such governance documents. The conversation touches on how charters can help prevent burnout, clarify…
How Open Source Projects Handle Contributor Burnout and Succession
In this episode, Lucas and Luna explore how open source projects are facing a quiet crisis: maintainers who built the infrastructure we rely on are stepping back, burning out, or aging out with no clear successor. We dig into the specific case of the 'left-pad' incident and how it forced a rethinking of dependency trust, then trace the evolution of maintainer succession plans, from informal 'bus factor' discussions to formal handoff frameworks like the CHAOSS project's sustainability metrics.…
How Open Source Maintainers Handle Security CVEs
Open source maintainers are the unsung heroes of the software we rely on daily. But when a critical vulnerability like the Log4Shell flaw hits, the pressure is immense. In this episode, Lucas and Luna unpack the human side of security: how maintainers triage CVEs, the emotional toll of public scrutiny, and why the industry's 'patching is easy' reputation is misleading. They explore real-world examples like the Heartbleed bug and the Heartbleed aftermath, the challenges of volunteer-led…
How Open Source Projects Are Rethinking Their Governance
Open source is built on code, but it's governed by people. This episode looks at how major projects like Kubernetes and the Linux kernel are moving beyond informal maintainer hierarchies toward more explicit governance models — and why that shift is happening now. We break down the specific challenges: decision paralysis, contributor burnout, and the rise of 'do-ocracy' versus structured foundations. We also explore the role of the CNCF and the recent push for contributor-led governance…
The Hidden Cost of Open Source Supply Chains
In this episode of Open Source with Fexingo, Lucas and Luna dig into the overlooked economics of open source supply chains. They break down the shocking statistic that over 60 percent of all npm packages have just one maintainer, and what that means for the software we all depend on. Using the recent xz utils backdoor as a cautionary tale, they explore how a single volunteer can become a single point of failure. They also discuss the rise of sustained funding models like GitHub Sponsors and the…
How Open Source Projects Use Real User Metrics
In this episode, Lucas and Luna dig into the surprisingly tricky business of measuring how open source software is actually used. With most projects only able to see downloads and GitHub stars, they explore a concrete case: the Rust community's quest for accurate usage metrics, the rise of privacy-respecting telemetry like opt-in data collection, and why knowing your real user base matters for funding, security priorities, and sustainability. They discuss the trade-offs between data-driven…
Why Open Source Projects Are Turning to Contributor Funding
In this episode of Open Source with Fexingo, Lucas and Luna explore the rise of contributor funding platforms like GitHub Sponsors and Open Collective. They discuss how projects such as Vue.js and webpack have successfully financed maintainers, the shift from corporate sponsorship to individual support, and the sustainability challenges that remain. With concrete numbers and real-world examples, they examine what this means for the future of open source maintenance. If you've ever wondered how…
Why Open Source Projects Are Adopting Contributor Codes of Conduct
In this episode, Lucas and Luna explore why open source projects are increasingly adopting formal contributor codes of conduct. They trace the history from the first documented code of conduct in 2010 to the recent wave of adoptions following the 2018 event at a major tech conference. Using the Linux kernel's own code of conduct as a case study, they discuss what these documents actually do, how they are enforced, and the real-world impact on project health and contributor retention. They also…
Open Source Maintainers Are Facing a New Kind of Burnout
In this episode of Open Source with Fexingo, Lucas and Luna dig into a problem many projects are hitting in 2026: maintainer burnout isn't just about too many issues or late-night commits. It's about emotional labor—the constant stream of entitlement, rudeness, and demands from users who treat maintainers like free support staff. We look at how projects like Rust, Kubernetes, and Home Assistant are experimenting with community codes of conduct, contributor covenants, and even AI-assisted triage…
The Open Source Maintenance Credit Problem
In this episode of Open Source with Fexingo, Lucas and Luna explore the 'maintenance credit' problem: the growing gap between the unpaid labor of core maintainers and the commercial value their projects generate. They use the 2024 XZ backdoor incident as a case study, where a volunteer maintainer's burnout was exploited, and contrast it with the recent trend of maintainers taking 'stress leave' or stepping down entirely. The discussion also covers how projects like WordPress and the Linux…
Why Open Source Projects Are Turning to Contributor Covenants
In this episode, Lucas and Luna unpack the growing trend of contributor covenants—binding codes of conduct that open source projects are adopting beyond traditional licenses. They dive into the specific case of the Contributor Covenant, the most widely used pledge, which has been adopted by over 100,000 projects on GitHub, and explore how it's reshaping community governance. The conversation covers the origins of the covenant, its key provisions, and the real-world impact on projects like…
How Open Source Projects Keep Their License Compliance Honest
Open source licenses are easy to ignore until they're not. In this episode, Lucas and Luna dig into the messy reality of license compliance: what happens when a project mixes GPL, MIT, and Apache code, and why companies like Samsung and Cisco ended up in headline-grabbing lawsuits. They walk through the practical tools that projects use to track licenses, from SPDX identifiers to FOSSA and ScanCode, and the quiet revolution of REUSE. Along the way, they touch on the 2021 VMware ruling, the role…
How Open Source Projects Handle Contributor Retirement
In this episode of Open Source with Fexingo, Lucas and Luna explore how open source projects plan for the day a core maintainer steps down. They use the retirement of Linux kernel maintainer Greg Kroah-Hartman as a springboard, discuss bus factors and succession planning, and dig into the concrete example of the Rust programming language's governance model, which codifies a path for leadership transitions. The conversation covers the emotional weight of handing over a project you've nurtured…
How Open Source Projects Handle Security Audits
In episode 155 of Open Source with Fexingo, Lucas and Luna dig into the practical world of security audits for open source projects. They use the 2024 xz backdoor as a recent, concrete reminder of why audits matter, then trace how projects like OpenSSL and the Linux kernel approach audits differently. Lucas explains the three main types of audits—full, incremental, and targeted—and what each costs in time and money. He shares how LibreOffice handled a real audit finding, and why disclosure…
How Open Source Projects Handle Contributor Licensing
Contributor licensing is the quiet gatekeeper of every open source project. In this episode, Lucas and Luna unpack the messy middle between 'all rights reserved' and 'public domain' — from the GNU GPL's copyleft philosophy to the permissive MIT and Apache licenses, and the real-world friction of contributor license agreements. They walk through a concrete case: a developer who submitted a patch to a popular project only to discover their code was now under a license they hadn't fully read, and…
How Open Source Projects Handle Contributor Licensing
Episode 153 of Open Source with Fexingo dives into the messy, often overlooked world of contributor licensing. Lucas and Luna explore why projects like Linux, Git, and React use different agreements, from the simple DCO to the more complex CLA, and what happens when a project decides to change its license midway through its life. They walk through the real story of a mid-sized open-source project that switched from MIT to Apache 2.0, the legal headaches that followed, and the tools like…
How Open Source Projects Handle Contributor Licensing
Episode 152 of Open Source with Fexingo digs into contributor licensing, a topic that quietly shapes who owns what in open source. Lucas and Luna use the GitLab versus GitHub approach to contributor license agreements to unpack why some projects require a CLA and others stick with the Developer Certificate of Origin. They talk through the trade-offs: legal safety for corporations, friction for contributors, and the trust factor for communities. The episode centers on a concrete example: the…
How Open Source Projects Handle Contributor Onboarding
Onboarding new contributors is often the first hurdle open source projects face. In this episode, Lucas and Luna explore how projects like Kubernetes and Rust are tackling this challenge with structured mentorship programs, good first issue tagging, and better documentation. They discuss the importance of reducing cognitive load for newcomers, the role of community culture, and how projects measure success in onboarding. With insights from real-world examples, they highlight why a welcoming…
How Open Source Projects Fundraising Evolved Beyond Donations
In this special 150th episode, Lucas and Luna explore the shifting economics of open source funding. They examine how projects like Blender, Kubernetes, and the Linux Foundation have moved from individual donations to corporate sponsorships, foundations, and commercial models. The conversation digs into the numbers: Kubernetes' staggering contributor count, the CNCF's budget, and the rise of 'open core' companies. They also confront the tension between community-driven ideals and enterprise…
How Open Source Projects Handle Contributor Licensing
In this episode of Open Source with Fexingo, Lucas and Luna dive into the tricky world of contributor licensing. They explore how projects like the Linux kernel and Git use Developer Certificates of Origin (DCO) and Contributor License Agreements (CLA) to legally manage code contributions. The conversation covers the difference between permissive and copyleft licenses, the infamous 2019 Redis licensing controversy, and how projects balance legal safety with contributor friction. They also…
How Open Source Projects Handle Supply Chain Transparency
In this episode of Open Source with Fexingo, Lucas and Luna explore how open source projects are increasing supply chain transparency, focusing on the rise of Software Bills of Materials (SBOMs) and the challenges of implementing them. They discuss the recent U.S. executive order on cybersecurity that mandates SBOMs for federal vendors, the resistance from maintainers who see them as bureaucratic, and the tools emerging to automate SBOM generation. The hosts also touch on the tension between…
How Linux Manages Its Memory Through OOM Killer
Episode 147 of Open Source with Fexingo digs into a rarely discussed but critical part of Linux: the Out-Of-Memory killer. Lucas and Luna walk through why a kernel that is designed to avoid crashes may, under extreme memory pressure, start terminating processes. They explain the heuristic scoring, the role of cgroups and systemd, and what this means for everyday users and containerized workloads. They also touch on how the OOM killer has evolved with the introduction of oomd and memory pressure…
Why Open Source Projects Are Moving to Time-Based Releases
In episode 146 of Open Source with Fexingo, Lucas and Luna explore the shift from feature-based to time-based release cycles in open source. They focus on the GNOME project's switch to a six-month schedule, how it changed contributor workflows and user expectations, and why projects like Kubernetes and Firefox have adopted similar cadences. The conversation covers the trade-offs of predictable releases versus the pressure of fixed deadlines, the role of release managers in cutting scope, and…
Why Open Source Projects Are Adopting Rust Bit by Bit
In this episode, Lucas and Luna explore why open source projects are slowly but surely rewriting critical components in Rust. They start with the recent memory-safety push in the Linux kernel and the creation of the Rust for Linux project, then dig into real-world examples like sudo, curl, and the Windows kernel. They discuss the trade-offs: performance, safety, developer happiness, but also longer compile times and a steeper learning curve. The conversation touches on how maintainers manage…
How Linux Kernel Patches Get Their Human Element
In this episode of Open Source with Fexingo, Lucas and Luna dive into the surprisingly human side of kernel development: the patch review process. They examine how a single patch for the Linux kernel—say, a driver fix or a memory management tweak—travels from a contributor's inbox through mailing lists, maintainer scrutiny, and multiple revisions before being merged. Along the way, they discuss the role of maintainers like Greg Kroah-Hartman, the delicate balance between technical rigor and…
How Open Source Projects Handle Contributor Burnout and Recovery
In this episode of Open Source with Fexingo, Lucas and Luna explore how open source projects not only acknowledge maintainer burnout but actively structure recovery—through sabbaticals, shared maintainership, and community-funded support. They dive into the specific case of the Laravel framework's lead maintainer taking a six-week break in 2024, and how the project used that time to formalize a deputy system. They also discuss the Rust project's 'leadership council' experiment and how burnout…
How Open Source Projects Handle Legacy Code
In Episode 142 of Open Source with Fexingo, hosts Lucas and Luna explore how open source projects deal with legacy code — the old, sometimes ugly, but often battle-tested parts of a codebase that resist change. Using PostgreSQL as a central case, they discuss strategies like modularization, the strangler fig pattern, and the delicate balance between stability and innovation. They also touch on the human side: how maintainers manage the emotional weight of code they've written for years, and why…
How Open Source Projects Manage Sponsorship Money Without Losing Community Trust
Episode 141 explores the delicate balance open source projects must strike when accepting corporate sponsorship. Using the Vite project as a case study, Lucas and Luna discuss how the team handles sponsor feature requests without compromising community priorities, the role of transparent governance like Open Collective, and the best practices that maintain trust. They also touch on the broader sustainability of open source and listener support. #OpenSource #Sponsorship #Vite #OpenCollective…
How Open Source Projects Treat Documentation Like Code
Lucas and Luna explore how major open-source projects—from the Linux kernel to Django—treat documentation as a first-class asset, with rigorous review, version control, and community contribution processes. They examine the documentation sprint tradition, the role of tools like Sphinx and ReadTheDocs, and why good docs often determine whether a project thrives or stagnates. A concrete look at the unsung heroes of open source. #OpenSource #Documentation #LinuxKernel #Django #Sphinx #ReadTheDocs…
How Open Source Projects Vet Dependencies After the xz Backdoor
Two years after the xz backdoor incident shocked the open source world, projects are fundamentally rethinking how they verify dependencies. This episode explores the attack's anatomy — how an exploited maintainer burnout allowed a backdoor into liblzma — and the lasting changes it triggered. We discuss GitHub's mandatory two-factor authentication for critical projects, the Open Source Security Foundation's Scorecard tool adoption, and the rise of software bill of materials (SBOM) mandates. We…
Why GLib and GNOME Ditched Autotools for Meson
Episode 138 dives into how the GLib library and the broader GNOME project migrated from the decades-old Autotools build system to the modern Meson build system. We explore the technical challenges of maintaining dual build systems, the careful deprecation process, and the community coordination required to avoid breaking thousands of downstream packages. With insights from GNOME developers, we examine why such migrations are necessary and how other open source projects can learn from this…
How Open Source Projects Handle Maintainer Burnout
Burnout is the silent crisis in open source. In this episode, Lucas and Luna explore why so many maintainers are stepping away—and what projects are doing about it. They start with the infamous npm sabotage case as a wake-up call, then dive into recent data from the Linux Foundation's 2025 survey showing that over half of maintainers have considered quitting. They discuss the root causes: unpaid labour, 24/7 security pressure, and the expectation of free support. Then they highlight solutions…
How Open Source Projects Handle Planned Deprecation
When a library used by millions of developers announces its own sunset, it's not a failure — it's a deliberate act of stewardship. This episode uses the story of moment.js to explore how open source projects plan a graceful deprecation: migration guides, fallback timelines, and the hard human decision to let go. We talk about the burnout that drives such choices, the role of financial sustainability, and why a controlled shutdown often serves the community better than slow abandonment.…
How Blender Finances Itself Without Selling Out
Blender, the open-source 3D creation suite, has built a sustainable funding model without venture capital or a corporate owner. Lucas and Luna break down how the Blender Foundation’s development fund works, the numbers behind its annual budget, and why it refuses the typical acquisition path. They also explore the broader lessons for open-source sustainability — and how listener support keeps independent projects like this going. #OpenSource #Blender #BlenderFoundation #DevelopmentFund…
Showing the latest 50 episodes. The full archive of 184 is on Apple Podcasts, Spotify and every major podcast app — or via the RSS feed above.