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