Open Source Summit India 2026

Bare-metal developers pride themselves on simplicity, control, and understanding every line of code. Then along comes Zephyr—with device trees, Kconfig, west, and layers of abstraction—and suddenly, even blinking an LED feels complicated. So… is Zephyr actually scary?

In this talk, we take a practical and honest look at why Zephyr often feels overwhelming to bare-metal developers, what’s really going on under the hood, and whether that complexity is justified. Through side-by-side comparisons and live examples, we map familiar bare-metal concepts to their Zephyr equivalents and uncover where the fear comes from—and where it disappears.

This isn’t a “Zephyr is better” talk. It’s about understanding trade-offs, choosing the right tool, and making the transition without losing your mental model.

By the end, you’ll see that Zephyr isn’t replacing bare metal—it’s structuring the complexity you were already managing.

Modern platform teams are overwhelmed by reactive operations where manual escalation, delayed remediation, and siloed automation take over. This session presents Event-Driven Platform Engineering as a framework for the design of platforms from ticket-driven systems to autonomous control loops. With the aid of Kubernetes controllers, event streams, policy engines, and real-time telemetry, platforms can identify, decide, and act without recourse to human intervention. We will also look at how events from observability systems, CI/CD pipelines, policy violations, and runtime signals can be transformed into actionable triggers for automation that powers scaling, remediation, governance enforcement, and developer workflows. The talk presents a reference architecture consisting of Kubernetes operators, Prometheus metrics, event brokers, and policy-as-code frameworks for developing self-adaptive internal developer platforms. Attendees will gain a structured approach to designing event-native platforms such as MTTR reduction, SLA compliance, continuous guardrails enforcement, and developer experience enhancement that align with open-source cloud-native environments.

Modern server infrastructure is frequently limited by proprietary UEFI firmware—a slow, unauditable "black box" that introduces security risks and operational bloat. This session presents a transformative alternative: a lean, open-source boot stack pairing coreboot with LinuxBoot to achieve rapid boot times .
We will explore the technical synergy between these two powerhouses. coreboot handles the critical "early wake-up" of silicon—including DRAM, CPU, and PCI initialization—before handing control to LinuxBoot. By embedding a minimalist Linux kernel directly into the firmware flash, LinuxBoot replaces complex UEFI DXE phases with battle-tested upstream drivers. Attendees will learn the conceptual foundations of the u-root Go-based userland for flexible networking and storage logic, alongside the kexec system call for seamless transitions to the production OS. This session provides a roadmap for building vendor-neutral, high-performance infrastructure from the reset vector up.

Murphy's Law states, "Anything that can go wrong will go wrong." For an Open-Source project, this can be a daunting task. Imagine you are in between a major architectural change, trying to decouple a monolith and your community itself starts to decouple. This is what happened recently in our decade old community and we would like to share the raw behind-the-scenes of our journey, hoping it will be helpful for others who're going through the same.

Our story will portray, how we lost our veteran leaders and architects departing the community, placing an unprecedented load on the remaining maintainers to bridge a massive gap in expertise, institutional knowledge and maintain stability while executing a high-stakes architectural migration. We will also touch bases on how the GenAI can work as a double-edge sword when you are in short of contributors.

Key Takeaways:
1. Practical strategies for project survival when veteran institutional memory departs mid-migration.
2. Why Next.js was a strategic necessity and not just a nice-to-have upgrade.
3. Navigating the influx of high-volume, variable-quality contributions and managing the burnout.
4. Lessons on building a new leadership.

This session presents the challenges which Telco service providers have in moving towards Autonomous Networks and adopting GenAI, AgenticAI - especially for OSS and Network Operations. This presentation highlights how some of the challenges can be solved using LFN projects and benefits to Telco Network Service Providers

For decades, Linux servers have been maintained using package managers, configuration management, and patching cycles. But what if the operating system itself behaved like a container image?

bootc introduces a new model where a full Linux host is delivered, updated, and rolled back using OCI images — bringing application deployment semantics to operating systems.

In this talk, I explore what changes when the host becomes immutable: updates, drift management, disaster recovery, and fleet consistency. Through hands-on experimentation, I compare traditional configuration management approaches with image-based host delivery and highlight where each model succeeds or fails.

Rather than a product introduction, this session focuses on operational impact: how platform engineers can rethink provisioning, patching, and rollback strategies in data center and edge environments.

Attendees will leave with a clear mental model of when this approach simplifies infrastructure — and when it does not.

Efficient interrupt handling is at the heart of modern operating systems, enabling hardware devices to communicate seamlessly with the kernel. In the Linux ecosystem, the evolution from legacy line based interrupts to advanced mechanisms like Message Signaled Interrupts (MSI) and MSI X has significantly improved scalability, performance, and reliability. Yet, for many developers and practitioners, the inner workings of these mechanisms remain opaque.
This talk aims to demystify PCI interrupt handling in Linux, with a focus on MSI/MSI X. We will begin by revisiting the limitations of traditional interrupt models, then explore how MSI/MSI X leverage in band signaling to overcome them. Attendees will gain insights into:
• The architectural differences between legacy interrupts and MSI/MSI X.
• How the Linux kernel configures and manages these interrupts.
• Practical debugging techniques for PCI devices using MSI/MSI X.
• Real world performance implications in networking, storage, and virtualization workloads.

Java is fundamentally changing. Enterprises deploying to Kubernetes now demand nanosecond startup times, minimal memory footprints, and fully optimized containers. This advanced session goes beyond basic JVM tuning to explore the cutting edge of Java modernization for cloud-native deployment. We’ll provide a deep dive and comparative analysis of optimization techniques, including Jib for minimal image creation, utilizing GraalVM Native Image for incredible cold-start acceleration, and leveraging the CRaC project (Coordinated Restore at Checkpoint) for state-of-the-art responsiveness. Join this hands-on Cloud Native Experience walkthrough to see live demonstrations of complex configuration patterns, detailed trade-off discussions, and actionable strategies for dramatically improving the cost-efficiency and velocity of your containerized Java microservices.

In large Kubernetes clusters, scaling isn’t just about replicas — it’s about distribution efficiency.
When hundreds of pods start simultaneously, container image pulls can silently become your biggest bottleneck.

In this session, we’ll explore how Dragonfly (D7y) transforms traditional image pulling into a peer-to-peer, high-performance distribution system within Kubernetes.

We’ll break down:
Why image pull storms happen
How P2P distribution solves real scaling problems
Dragonfly architecture in Kubernetes
Live flow of how images propagate across nodes
Real-world performance improvements and use cases
This talk is for engineers who want their clusters to scale smarter — not slower.
Because Kubernetes is fast
but only if your images are too.

Protecting privacy for customers and business partners is a key requirement across jurisdictions and sectors, but proving that privacy is preserved can be extremely difficult. Confidential Computing, available as a chip-level capability across servers and clouds, provides not only isolation for sensitive data and applications, but also cryptographic assurances that it is in place.
This session explains how Confidential Computing can be used as the basis for privacy-centric systems and processes, and the types of assurance that can be derived using remote attestation.
Confidential Computing also has uses across supply chain, collaboration, AI and blockchain - we will touch on these topics as well.

Modern confidential computing technologies like AMD SEV-SNP and Intel TDX provide a reliable way to isolate guest workload and data in use from the virtualization or cloud infrastructure. Protecting data at rest is, however, not something you get ‘by default’. The task is particularly challenging for traditional operating systems where users expect to get full read/write experience.

The good news is that Linux OS already offers a number of great technologies which can be combined to achieve the goal: dm-verity and dm-integrity, LUKS, discoverable disk images and others. Doing it all right, however, is left as an “exercise to the reader”. In particular, the proposed solution must allow for meaningful remote attestation at any time in the lifetime of the guest.

The talk will focus on the recent developments in various upstream projects like systemd and dracut which are focused on making full disk encryption consumable by confidential computing guests running in a cloud.

In this session, we focus on providing best practices for building effective, noise-free telemetry pipelines using OpenTelemetry Collector, with the LGTM stack (Loki, Grafana, Tempo, and Mimir) as the backend observability platform. We will demo collectors and design pipelines using processors such as filter, transform, and attributes, along with OTTL (OpenTelemetry Transformation Language) for fine-grained filtering and signal transformation. We will also demonstrate tail-based sampling for traces and routing processors to selectively direct telemetry to appropriate backends, helping control signal volume and storage cost.

By the end of the session, attendees will gain practical experience designing OpenTelemetry pipelines that prioritize signal quality over quantity using various filtering and processing techniques.