Open Source Summit + Embedded Linux Conference North America 2026

Industrial control systems built on PLC and SCADA architectures power critical infrastructure worldwide, yet most remain siloed, reactive, and difficult to scale for modern operational demands. As industries adopt digital twins for prediction, optimization, and resilience, a key challenge emerges: how to integrate real-time control systems with digital twin architectures without compromising safety, determinism, or reliability.

This session presents a practical, architecture-driven approach to integrating PLC–SCADA systems with digital twins in large-scale industrial environments. Drawing from real-world automation modernization programs, the talk explores data synchronization patterns, control boundaries, latency considerations, and open-source tooling strategies that enable production-grade digital twins rather than visualization-only pilots.

Attendees will gain a systems-level understanding of how embedded Linux platforms, open communication protocols, and control system design principles can support scalable digital twins for industrial operations. The session emphasizes architecture, interoperability, and lifecycle design, not vendor-specific solutions.

Flash memory is the literal foundation of an embedded system, yet it is a finite resource. Every log entry, database commit, and firmware update inches the device closer to its end of life. For developers managing fleets of devices, the question is not just if the flash will fail, but when and which process is the culprit.

This session dives deep into the lifecycle of a write, from a high level look at the physics behind flash memory, to how we can get an estimation of lifetime by tracking number of bytes written. We will start at the hardware level, explaining the physical degradation of NAND cells and why eMMC controllers use wear leveling to manage this reality. Next, we will bridge the gap between hardware specs and software reality using the Total Bytes Written (TBW) metric to estimate remaining life.

Moving into the Linux kernel, we will explore the built-in metrics found in procfs and sysfs to monitor disk I/O. Finally, we will level up our observability by using eBPF to build a per process "write shaming" tool. This allows us to pinpoint exactly which application or daemon is burning through our hardware lifespan.

Moving from the manual memory management of C to the strict ownership model of Rust is more than a syntax swap; it is a fundamental shift in engineering philosophy. This talk provides a pragmatic roadmap for developers navigating this transition. We move beyond the academic "why" of memory safety to dive deep into the "how" of refactoring legacy systems.

The session explores the practicalities of Rustification, comparing the pitfalls of malloc and free—such as use-after-free and double-free vulnerabilities—with the compile-time guarantees provided by Rust’s Box, Arc, and Borrow Checker. Furthermore, we tackle the topics of how to translate manual pointer arithmetic into safe abstractions, practical strategies for using the Foreign Function Interface (FFI) to let Rust and C coexist during a gradual migration as well as a real-world example of "Rustifying" a C module, from initial profiling to stable deployment.

Secure Boot is often described using cryptography-heavy terminology, vendor-specific flows, and complex diagrams that make it intimidating for embedded developers.
This talk explains Secure Boot for embedded Linux systems from first principles, using simple language and clear mental models.

We start by answering why Secure Boot exists, then walk step by step through the boot process. Concepts like Root of Trust and signature verification are explained without assuming prior security or cryptography background.

The session focuses on what actually happens at boot time, not on vendor marketing or abstract theory. Real-world examples from common embedded Linux systems are used to illustrate how Secure Boot is implemented and where it can fail if misunderstood.

By the end of the talk, attendees will be able to explain Secure Boot in their own words, understand its guarantees and limitations, and reason about Secure Boot designs in real embedded products.

Running the Linux kernel on microcontrollers with severely constrained RAM has long been viewed as impractical. Conventional embedded Linux builds still assume tens of megabytes of memory, excluding a wide class of resource-limited hardware such as Arm Cortex-M and certain Cortex-R devices. This talk presents recent work on adapting and optimizing the Linux kernel to operate within a 1 MB RAM budget.

We examine the challenges of reducing Linux’s memory footprint for microcontroller-class systems and the techniques that enable Linux to run in sub-megabyte environments. Topics include:
* Memory profiling of core kernel subsystems
* Removing or deferring optional features to reduce RAM usage
* Streamlining kernel image layout and data structures
* Adjusting build configurations and boot flow for extreme constraints
* Runtime trade-offs between functionality and footprint

The session demonstrates how mainline Linux can be reshaped to fit far smaller footprints than traditionally assumed. This approach expands the reach of embedded Linux and provides practical strategies for optimizing memory usage on highly constrained platforms.