Open Source Summit North America 2025

In the era of cloud-native technologies, businesses are increasingly looking to integrate advanced AI capabilities into their workflows. This session explores how the Open Platform for Enterprise AI (OPEA) offers a transformative, open-source framework designed to accelerate the adoption of Generative AI (GenAI) across industries. Attendees will learn about the key benefits of adopting an open-source GenAI platform, including flexibility, community-driven improvements, and cost efficiency, as well as the advantages of deploying AI models in a cloud-native environment. We will also dive deep into the emerging GraphRAG (Graph-based Retrieval-Augmented Generation) architecture, demonstrating how it enhances the accuracy and explainability of AI-driven responses. Join us for this session to explore how the open-source OPEA platform and GraphRAG architectures are poised to redefine enterprise AI and to drive smarter, more reliable cloud-native AI applications.

In the rapidly evolving landscape of Generative AI, it is becoming clearer every day that open strategies are key drivers of innovation and widespread adoption. This session will present the Generative AI Commons, its activities, and deliverables to date, including the Model Openness Framework (MOF) and the Responsible Generative AI Framework,

LF AI & Data initiative dedicated to fostering the democratization, advancement and adoption of efficient, secure, reliable, and ethical Generative AI open source innovations through neutral governance, open and transparent collaboration and education.

This talk will describe the emerging standard and the Beaconforge.org framework, which is being developed by the Voiceinteroperability.ai Project of the LFAI and Data Foundation, to enable conversational assistants to interact with each other. Beaconforge.org is based on a standardized set of novel agentic inter-assistant messages that utilize NLP (Natural Language Processing) Universal APIs.

We will also explore how Agentic AI frameworks like Beaconforge.org can help mitigate hallucination effects in generative AI agents. This will be demonstrated through an empirical experiment involving hundreds of diverse prompts, a chain of multiple agents, and four novel KPIs used to evaluate hallucination score mitigation.

More information about the project can be found in the following papers:
Diego Gosmar et al., 2025. Hallucination Mitigation using Agentic AI Natural Language-Based Frameworks, https://arxiv.org/abs/2501.13946

Diego Gosmar et al., 2024. Conversational AI Multi-Agent Interoperability, Universal Open APIs for Agentic Natural Language Multimodal Communications, https://arxiv.org/abs/2407.19438

Valkey is the leading open-source database for building high performance applications that are compatible with the Redis API. It natively integrates with many popular frameworks and is commonly used for a wide range of applications such as caching, session storage, streaming, and more. In this talk, hear from members of the Valkey technical steering committee discuss some of the exciting new functionality that has been released including the new bloom filter data type, vector similarity search, and a new hash table implementation that reduces memory overhead and improves performance. We'll talk about how these functionalities enable next generation use cases and what's coming in upcoming releases.

Large Language Models (LLM) require preprocessing vast amounts of data, a process that can span days due to its complexity and scale, often involving PetaBytes of data. This talk demonstrates how Kubeflow Pipelines (KFP) simplify LLM data processing with flexibility, repeatability, and scalability. These pipelines are being used daily at IBM Research to build indemnified LLMs tailored for enterprise applications.

Different data preparation toolkits are built on Kubernetes, Rust, Slurm, or Spark. How would you choose one for your own LLM experiments or enterprise use cases and why should you consider Kubernetes and KFP?

This talk describes how open source Data Prep Toolkit leverages KFP and KubeRay for scalable pipeline orchestration, e.g. deduplication, content classification, and tokenization.

We share challenges, lessons, and insights from our experience with KFP, highlighting its applicability for diverse LLM tasks, such as data preprocessing, RAG retrieval, and model fine-tuning.

In this presentation, Eoin will introduce a practical approach to Edge MLOps for microcontroller-based systems using the Zephyr RTOS. Edge MLOps unifies DevOps, ML model development, and edge deployment practices to streamline the entire AI lifecycle at the device level—from data collection and processing to model training, deployment, and continuous monitoring.

Attendees will learn how to implement version control for data and models, design automated CI/CD pipelines that handle real-world sensor data, and manage over-the-air (OTA) firmware updates on constrained Zephyr-based devices. We will explore best practices to ensure data integrity, model governance, and security throughout the pipeline, including techniques to mitigate model drift and bias.

Through a demonstration of an end-to-end IoT architecture, participants will see how edge devices can continuously collect new data, trigger remote training in the cloud, and deploy updated ML models back to the field. The talk will also highlight how Git action-based workflows enable seamless version transitions for on-device inference, showing how TFLite Micro or other open-source models —can be integrated platform-agnostic.

Machine Learning and AI are experiencing explosive growth. The concentration of AI power in the datacenters, as well as the current trends in training and inferencing infrastructure built around power-hungry GPUs and control nodes running interpretive languages on full-fledged monolithic operating systems brings about an evermore greater need for energy. In this talk we will sketch a different future: one where the needs of scaling are addressed in a way of embedding lightweight control software running on energy-efficient hardware into a sea of heterogeneous compute accelerators arranged in an energy-conserving fashion. One where the edge devices, be it small IoT nodes or an intelligence subsystem inside a mobile device can all be included in one global, distributed, cognitive and sustainable network supporting the users.
We intend to cover our recent developments in the way of porting IREE to run on Zephyr's POSIX layer, as well as experiments to see how Zephyr as a lightweight library kernel can support typical inference tasks that were used as workloads to tune an accelerator's micro-architecture (using gem5 simulator) as well as to emulate the design on the FPGA as a scale-up.

The Yocto Project can build for a variety of targets: Linux, Zephyr, baremetal, etc. Using multiconfig one can target a combination of these environments in one single configured build. Zephyr is a real-time operating system (RTOS) that is open source and hosted by the Linux Foundation. It’s an collaborative effort uniting developers and users in building a best-in-class small, scalable, real-time operating system (RTOS) optimized for resource-constrained devices, across multiple architectures.

This talk will discuss how to configure a multiconfig builds for MicroBlaze-V(RISC-V) FPGA using Yocto Project meta-zephyr, with integrated binary components for Zephyr using a System DeviceTree(SDT) processed through the lopper tool to generate Zephyr Kconfig, DTS and Multiconfig Configuration files for MB-V. The resulting configuration files are then used to build and package Zephyr including but not limited to the Zephyr Kernel and peripheral drivers using the Yocto Project.

Hardware availability is among the many challenges embedded software engineers face when working on new designs. In the case of MCU-based applications, embedded software engineers need to wait for the hardware to arrive to validate portions of their application that exercise the underlying hardware. Additionally, if the application is part of a network and the network can contain hundreds or thousands of nodes, engineers may find it difficult to evaluate their design when the network is under load. Fortunately, The Zephyr Project RTOS has the infrastructure to allow embedded software engineers to evaluate as much of their design with access to the necessary hardware. In this talk, I will walk through these tools and how they can be used to evaluate the embedded software design before hardware is ready. The tools covered in this talk will be QEMU, BabbleSim, and Renode. They will be showcased with code, invocations, and results to demonstrate their value.

Engineers coming from traditional RTOS or bare metal backgrounds may initially see Zephyr's meta-tool, West, as an unfamiliar hurdle. While it might seem a bit complex at first, West is actually a simple and effective way to handle multiple repositories, as well as to build, debug, analyze, and more.

In this talk, we’ll break down what West does and how it fits into the Zephyr ecosystem. We'll use plain language and practical examples, showing that West isn’t a barrier at all. Instead, it’s a powerful tool that makes managing your projects easier and more organized.

We'll also explore why West exists and dive into its range of commands. Plus, we'll highlight the opportunities it offers, including enabling capabilities that were not possible without it.

Finally, we’ll demonstrate how to create custom commands with West and provide examples of how you might tailor these commands to meet the specific needs of your applications.

The latest RISC-V ISA specification allows for runtime configuration of the data endian between little and big. Since no one had done this before, we decided to investigate how difficult it would be to get a prototype Linux implementation running in big endian on an emulated RISC-V system such as under QEMU.

The talk goes from the description of the new ISA feature, our initial analysis and the modifications to software such as the Linux kernel, QEMU and OpenSBI and an overview of the issues that we found and how to fix them. This includes kvm and how that works with mixed endian kvm instances, and the modifications to kvmtool to make this work.

We conclude with how the project went, what we published and a call to arms to continue testing and fixing outstanding issues.

COSMIC DE is a new, full-featured desktop environment (like GNOME and KDE) written from scratch in the Rust programming language. It does not rely on GTK or Qt. Instead COSMIC uses a new Rust GUI toolkit called iced and the system76 developed libcosmic toolkit for building interfaces and applications with advanced theming and customization features.

COSMIC DE includes a suite of first-party applications including a file browser, text editor, application store, settings, and terminal. There is also a growing community of third-party apps. COSMIC includes a custom compositor that features variable refresh rate, Xwayland support, animations, fractional scaling, modern hybrid graphics features, window snapping and auto-tiling.

What makes COSMIC truly unique is that it's the first modular, composable desktop environment. For a user that means they can easily adapt COSMIC to their preferred workflow. Linux distributions can create wholly unique user experiences.
And companies can develop unique products using COSMIC.

Carl will discuss why system76 built COSMIC DE, show its features, and demonstrate how unique experiences can be composed with COSMIC DE.

Achieving end-to-end data integrity is essential for modern storage systems, yet Linux still faces challenges in providing full-stack protection. This session explores recent improvements in Linux’s data integrity framework. Specifically this presentation shares detail about:

1. A new io_uring interface that enables applications to attach metadata with I/O requests, ensuring robust data protection.

2. Optimizations to existing integrity mechanisms that improve performance, reduce overhead, and enhance flexibility, all of which have been merged into the mainline kernel.

3. Lastly, we highlight a novel mechanism that allows filesystems to fully utilize device integrity features and helps optimizing host and device resource utilization.

This presentation will deliver in-depth technical insights into these advancements and their role in strengthening Linux storage reliability.

We present the Rex project (https://github.com/rex-rs/rex). Rex is a Linux kernel extension framework that allows extension programs to be written in safe Rust. Rex offers similar safety guarantees to eBPF. Unlike eBPF-based tools like Aya, Rex extensions are not compiled into eBPF bytecode. Rex eliminates the in-kernel verifier – the safety of Rex extensions is built atop language-based safety plus runtime protection. Specifically, the Rex compiler enforces Rex extensions to be written in a subset of safe Rust, and emits native code directly. Rex implements its kernel crate with a safe interface that wraps existing eBPF interface. Rex also employs a lightweight runtime that implements graceful Rust panic handling with resource cleanups, kernel stack checks, and program termination.

Rex provides a more usable and arguably safer alternative to eBPF. The usability advantage comes from the elimination of in-kernel verifiers that are known to reject safe extension programs with cryptic feedback. We also show that Rex’s runtime protection provides stronger safety than eBPF in a few aspects, e.g., protecting kernel stacks from overflowing.

More details: https://tinyurl.com/y8uj8ypp