Open Source Summit + Embedded Linux Conference North America 2026

This talk chronicles my journey of troubleshooting a Linux kernel issue on a budget Intel GeminiLake-based Chinese mini-laptop. What began as a simple hardware purchase escalated into a two-month deep dive into the i915 GPU driver when the display mysteriously went blank during initialization.

I'll walk through the systematic troubleshooting approach: isolating the issue to the i915 driver, identifying the kernel configuration options triggering the problem, and developing a practical patch that bypasses problematic GPIO pin activation sequences. Along the way, I'll share surprising discoveries about hardware compatibility, kernel development complexity, and the limitations of AI tools when facing real-world Linux challenges.

This presentation is designed for Linux enthusiasts and IT professionals curious about kernel troubleshooting. Attendees will leave with practical knowledge about GPU driver internals, confidence that such issues are solvable without specialized expertise, and inspiration to tackle their own hardware compatibility challenges.

For many, systemd is the mysterious engine under the hood of nearly every modern Linux distribution. We use it daily—restarting services and checking logs—but how much do we actually know about how it manages our systems? If your relationship with systemctl begins and ends with copy-pasting commands from Stack Overflow, it’s time to look deeper.

This session is a practical, beginner-friendly deep dive into the most widely adopted (and debated) init system in the open-source world. We will move beyond the "init" label to explore systemd as a comprehensive suite of management tools.

Key takeaways include:

The Unit Hierarchy: Understanding .service, .timer, and .mount files.

The Boot Process: How "Targets" replace traditional runlevels.

Hands-on Management: Mastering systemctl for lifecycle management and journalctl for lightning-fast debugging.

DIY Services: A step-by-step guide to writing your first unit file from scratch.

Whether you are a developer looking to containerize applications or a new sysadmin navigating the CLI, this talk will provide the foundational knowledge needed to stop fearing the daemon and start commanding it.

eBPF has made Linux highly extensible, but production eBPF systems remain fragmented and complex. Developers must write raw C for eBPF, separate userspace loaders, manage BTF compatibility, handle tail calls, dynptr APIs, and sometimes build kernel modules for kfunc support, all across different build systems.

KernelScript is a domain-specific open-source programming language that unifies eBPF, userspace, and kernel extension development in a single, type-safe source file. It introduces multi-target compilation, automatic tail-call orchestration, transparent map and dynptr handling, lifecycle-safe program loading/attaching, and built-in kfunc support that generates kernel module scaffolding automatically.

This talk presents the language design, verifier-aware type system, and compiler architecture behind KernelScript, along with real examples combining XDP, TC, probes, userspace coordination, and custom kernel functions.

KernelScript explores a broader question: what should the next generation of Linux extensibility tooling look like?

The classic Java mantra, "write once, run anywhere," suggested that developers should be able to rely on the JVM to handle the intricacies of different hardware environments. For all modern high level languages, we expect compilers and language runtimes to “abstract away” the hardware for application developers. However, the hardware can still impact application performance. Developers and architects should know enough about the behavior of the underlying hardware to avoid pitfalls and take advantage of opportunities to maximize performance.


In this talk, you will learn about:

- How modern CPU pipelining and memory models can impact application performance
- How to think about data locality and memory access patterns when choosing algorithms for your applications
- Some Arm64 features you can leverage to improve performance

This session is ideal for software developers who want to understand how server architecture influences application performance, and how to make informed decisions about the underlying architecture when deploying applications to the cloud.

Additional Authors/Contributors: Jim Huang, Assistant Professor, National Cheng Kung University

VirtIO is the standard interface for device virtualization, enabling guest systems to access host resources and powering platforms such as QEMU and ACRN, which provide virtualized block, network, input, and graphics devices.

This talk takes an implementation-focused approach to virtio-gpu. We add virtio-gpu and virtio-input support to a minimalist RISC-V Linux emulator, building a graphics virtualization bridge from the guest framebuffer to host GPU acceleration. We examine the architectural decisions and trade-offs required to make the system function end to end.

Although VirtIO simplifies abstraction, virtio-gpu remains one of its most complex devices. Enabling 3D acceleration goes beyond the specification and requires coordination with Mesa 3D and virglrenderer, as well as compatibility with OpenGL and Vulkan. We highlight practical gaps between specification and implementation, including memory management, command submission, and synchronization.

Attendees will gain:
* A clear mental model of virtio-gpu architecture, including 2D and 3D paths
* Practical insights into integrating Mesa 3D and virglrenderer

Reference implementation: https://github.com/sysprog21/semu

Modern embedded systems look to minimize power consumption without compromising the performance of the system. To address this challenge, Linux provides comprehensive frameworks for dynamic power management that adapt system performance in response to workload demands. This talk explores the pieces that form the foundation of Linux power optimization and demonstrates how to leverage these tools in real-world scenarios.
The key principles for reducing the power consumption of the embedded system include turning off inactive devices, reducing clock frequency, and lowering supply voltage. Linux provides frameworks such as Runtime PM to suspend inactive devices, CPUIdle for intelligent idle state management, DevFreq for memory and device frequency optimization, and CPUFreq for dynamic CPU frequency scaling. By leveraging these tools, systems can reduce power dissipation while still meeting the demands of the application use case, without sacrificing performance. Through a practical case study on a TI AM62L SoC running a display application, this talk explores how different power optimization techniques interact and sometimes conflict, requiring iterative tuning to find optimal operating points.

Attendees will gain actionable optimization strategies, awareness of common pitfalls when subsystems interact, and practical debugging approaches applicable to their own embedded Linux projects.

Due to increased interest in fine-grained analysis of kernel composition and security (due to the CRA and other recent cybersecurity legislation), there have been a number of recent projects to 1) generate SBOMS for the linux kernel, and 2) finish adding the remaining SPDX-License-Identifier lines to the kernel source tree. In this talk, Tim will describe the current status of both of these efforts. Good progress has been made to add missing SPDX id lines, but more work is needed to complete this project. Tim proposes a kselftest test to make sure there are no regressions in this area. The status of different kernel SBOM generation tools, and upstream status, will be described.

This work should be of interest to companies interested in complying with cybersecurity requirements, as well as those involved with license compliance efforts.

This talk explores using Large Language Models (LLMs) to automate Linux kernel crashdump analysis at scale. At Cloudflare, we operate Linux across hundreds of thousands of servers. At this scale, kernel crashes are inevitable.
Typical crash analysis requires deep kernel expertise and significant time investment, slowing down time to resolution.
I'll share our journey building an LLM-powered agent that performs initial crash analysis autonomously. First, I'll cover our infrastructure for collecting and managing crashdumps across our fleet. Then I'll explain crashdump analysis fundamentals: using the crash utility, interpreting stack traces, identifying common failure patterns, and correlating crashes with kernel subsystems.
This talk focuses on teaching an LLM agent to replicate expert analysis workflows. I'll show how we structured prompts and created skills. I'll show examples of the agent analyzing real crashes.

AI agents don’t execute a single path, they explore many. They try different code changes, commands, or configurations in parallel, then keep the one that works. Today, running this safely on Linux requires fragile combinations of temp directories, git tricks, containers, or VM snapshots.

This talk introduces branch contexts, a new Linux execution model built for AI agents. A branch context gives each exploration path an isolated, copy-on-write filesystem and coordinated process group, with a simple lifecycle: fork, explore, commit or abort. The first successful branch commits atomically; all others are automatically invalidated.

We present two Linux implementations: BranchFS, a FUSE-based branching filesystem with O(1) branch creation and atomic commit without root privileges, and branch(), a proposed Linux syscall that composes filesystem branching, namespaces, and process lifecycle management into a single atomic operation.

We’ll explain why existing Linux mechanisms fall short for agent workloads and how fork/explore/commit semantics fit naturally into the future of Linux process and filesystem design.

As a Linux Kernel Developer at Ampere Computing, I focus on optimizing the scheduler for high-density ARM64 systems. My work culminates in a patch merged for the Linux 7.0 release that refines avg_idle tracking a critical metric the scheduler uses to decide how long to search for an idle CPU before giving up. In my session "The Hidden Cost of Sleep", I will break down the try_to_wake_up() path to show how even minor inaccuracies in idle-time accounting lead to poor CPU selection and increased cache misses. I’ll explain how my Linux 7.0 optimizations [commit
36ae1c45b2cede] specifically reduce the 'search cost' during wakeups, directly improving the responsiveness of AI inference workloads. By sharing raw performance data and trace analysis, I’ll demonstrate why getting the wakeup path right is the only way to achieve the deterministic performance needed for autonomous AI agents and scalable trust infrastructure.

As computing systems evolve, memory-safety exploits such as return-oriented programming (ROP) and jump-oriented programming (JOP) remain a serious threat. These attacks manipulate control flow within valid address space, reusing existing code “gadgets” to achieve the attackers desired results. Arm AArch64 provides architectural defenses against these attacks through Pointer Authentication Codes (PAC), Guarded Control Stack (GCS), and Branch Target Identification (BTI).

This talk explains how these technologies work and, more importantly, what Linux developers, distributions, packagers, and toolchains must do to deploy them correctly. We cover the AArch64 Linux ABI implications, including requirements for hand-written assembly, use of BTI and PAC instructions, and PAC key management. We dive into real-world toolchain and language impacts, including changes to C code generation, C++ exception unwinding, DWARF metadata updates, and use of Arm's hint space instructions. Attendees will also learn common pitfalls, debugging challenges, and deployment trade-offs observed in practice.

By the end of this session, participants will understand how to deploy PAC, GCS, and BTI across Linux.

Where are the Open Source techs of tomorrow right now? They're in class!

In this session, Stu Keroff shares real-world lessons from launching and leading school-based Linux clubs that introduce students to open source through hands-on exploration, community building, and authentic technical problem-solving.

Drawing on firsthand experience, this talk covers:

1. How to start a Linux club from scratch in a school environment.
2. Structuring meetings to balance curiosity, chaos, and meaningful learning.
3. Working with school administrators and navigating policy constraints.
4. Keeping students engaged across skill levels.
5. Connecting students to the broader open source ecosystem
6. Using Open Source to help your community.

Attendees will leave with a practical framework for starting similar programs in their own communities—whether as educators, parents, open source maintainers, or industry professionals looking to strengthen the next generation of contributors.

Meet the techs of tomorrow where they are right now: in school.

S3 APIs power modern Linux infrastructure, yet most object storage traffic still relies on TCP/IP. Under high concurrency and large transfers, TCP becomes CPU-intensive and limits throughput. RDMA promises Accelerated I/O through kernel bypass and zero-copy data movement—but applying RDMA to S3 workloads is not the same as NFS or block storage.

This session explores how RDMA can accelerate S3-style object transfers in distributed storage systems. We examine memory registration strategies, connection scalability, and what changes when dealing with multipart uploads, HTTP range reads, and parallel clients.

Through real validation scenarios, we compare throughput, latency, and CPU usage across TCP and RDMA paths. We’ll also highlight where RDMA excels, and where it falls short, such as in small-object or metadata-heavy workloads.

Attendees will gain a practical framework for evaluating Accelerated I/O in their own Linux storage environments: what to measure, what to tune, and what performance gains to realistically expect.

Linux Live Patching enables the application of critical kernel updates without requiring system reboots, addressing the growing demand for continuous availability in modern Linux deployments. As Linux underpins cloud infrastructure, telecommunications platforms, and mission-critical enterprise systems, rebootless patching has moved from a niche capability to an operational necessity.

This talk provides a practical overview of Linux live patching as implemented in the mainline kernel. It explains how live patching works at the function level, the kernel infrastructure that enables it, and the trade-offs involved in applying kernel changes at runtime. Attendees will gain insight into where live patching is effective, where it is not, and how it is used in real-world production environments.

System call tracing is critical for security monitoring, auditing, and debugging in large-scale Linux deployments. This talk explores kernel-level syscall tracing mechanisms, comparing their architectures, performance characteristics, and operational trade-offs.

We'll examine multiple approaches using eBPF, kernel tracepoints, and the Linux audit subsystem.
The presentation covers technical implementation details: how each mechanism hooks into the kernel syscall path, overhead characteristics under load, and the types of data they capture. I'll discuss performance implications and optimizations through real-world examples.