Events in room UB4.136

OpenCloud has the design goal to not use a relational database. This requires a deeper integration with the underlying storage system, ie. through extensive use of extended file attributes. Since features like file revisions, trash and shares are inevitable nowadays, OpenCloud makes use of SDS native supported storage aspects to build these advanced features in an efficient way.

In this talk we will give an overview of the storage aspects that are relevant from OpenClouds perspective, the integrations that we currently support as well as ongoing research topics.

Ceph storage: Enterprise meets Community. Our traditional Ceph storage roadmap session starts with everything that is happening in the upstream project this year and what we have planned for the future, and closes with the state of what is backed by vendor-supported products. A 360-degree look at the state of Ceph integration with OpenStack and what is planned going forward in the broader storage space, in particular in regards to features relevant to container workloads.

Architectural familiarity with Ceph is required. This session contains zero vendor pitches, and it is a caffeinated tour of what the Ceph community is working on at the feature level. Hang on to your hats, and bring questions!

Garage (project website) is a versatile object storage software, focused on decentralized and geo-distributed deployments. The software has been developed under the AGPL for more than 5 years and is now reaching maturity.

This talk will cover development and new features of the 2.x releases since the last FOSDEM talk (2024), best practices for administrators, available UIs, and a small tutorial on how to migrate from minio.

The CernVM File System (CVMFS) is a scalable, high-performance distributed filesystem developed at CERN to efficiently deliver software and static data across global computing infrastructures, primarily designed for high-energy physics (HEP). For the Large Hadron Collider (LHC) only, CVMFS is serving around 4 billion files (~2PB of data). CVMFS uses a content-addressable storage model, where files are stored in the form of cryptographic hashes, ensuring integrity and enabling deduplication. It follows a multi-caching architecture where the data are published in a single source of truth (Stratum 0), mirrored by a network of distributed servers (Stratum 1), and propagated to the clients via forward proxies. This multi-layer of caching allows for a cost-effective alternative to traditional file systems, where clients are offered reliable access to versioned read-only datasets with low overhead. In this talk we will focus on how CVMFS interoperates with the highly adopted S3 storage, providing a conventional POSIX filesystem view of the objects, using the available metadata for efficient exploitation of the medium. We will also highlight the benefit of using CVMFS with containerized workflows and demonstrate tools developed to facilitate data publishing.

Homepage: https://cernvm.web.cern.ch/fs/
Documentation: https://cvmfs.readthedocs.io/
Development: https://github.com/cvmfs/cvmfs/
Forum: https://cernvm-forum.cern.ch/

With cost and performance requirements becoming more and more relevant in today’s storage products, technologies that leverage algorithmic driven improvements are getting a lot of attention. Erasure coding is the most prominent algorithm and a meanwhile well established standard for saving on-disk space requirements in storage. It is built upon mathematical techniques. In my talk I want to explain and explore these techniques, and thereby the mathematical reasoning underlying these algorithms in a way that does not require a background in mathematics itself (or at least only an insignificant amount). I am not a software engineer myself, just an interested mathematics student who aims to introduce someone who is interested and not too fond of maths to the underlying theory of erasure coding.

Have you ever found your CephFS setup mysteriously broken and had no clue how it got there? Maybe someone ran a CLI command in haste, or a misstep happened weeks ago. We have suspicions, but can’t really recall what might've splintered the system. That changes now.

In this talk, we introduce a robust command history logging mechanism for CephFS: a persistent log of CephFS commands and standalone tool invocations, backed by LibCephSQLite. Think of it as “shell history,” but purpose-built for Ceph with time ranges, filters, and structured metadata. Every ceph fs subvolume rm, every ceph config set, every mischievous --force — now recorded, timestamped, and queryable.

Want to know what was run last Tuesday at 3 AM? Or who triggered that well-intentioned-but-catastrophic disaster recovery script? Or just list the last 100 commands before things exploded? It’s all there. This helps debug incidents faster, provides a clear audit trail, and opens the door to proactive traceability. So, when things go sideways around CephFS and no one's sure why — this history has your back.

This is CephFS-first but not CephFS-only. The path to full cluster command traceability starts here.

Starting with the Tentacle release, Ceph introduces mgmt-gateway: a modular, nginx-based service that provides a secure, highly available entry point to the entire management and monitoring stack. This talk will cover its architecture and deployment, how it centralizes access to the dashboard and observability tools, and how OIDC-based Single Sign-On streamlines authentication. We’ll also show how mgmt-gateway enhances security and access control while delivering full HA for Prometheus, Grafana, Alertmanager, and the dashboard, resulting in a more resilient and user-friendly experience for Ceph administrators.

The purpose of this talk is to highlight how LUA scripting and S3 Lifecycle Policies can be leveraged to enable Ceph S3's dynamic placement and cost-efficient, policy-driven data retention. All details on https://github.com/frednass/s3-dynamic-placement-and-archiving

The CERN Tape Archive (CTA) is the open source solution developed at CERN to store more than 1 Exabyte of data from CERN’s experimental programmes. CTA interfaces with two disk systems widely used by the High-Energy Physics (HEP) community, EOS and dCache. However, until now there has been no integration with systems used outside of HEP.

Looking at current industry standards, the leading interface for file and object storage is S3, which includes cold storage extensions for data archival. The CTA team are investigating whether CTA can be fronted by an S3 API. During this talk, we’ll review a proof-of-concept implementation, and look at alternative solutions to explore along with their respective trade-offs.

Umbrella ("U") is planned as the next major release for the Ceph Distributed Storage System open-source project. Ceph File System development in Umbrella is aimed at addressing various pain points around the file system disaster recovery process, performance metrics, MDS tuning, user data protection and backups. Many of these themes were also discussed in the Cephalocon 2024 and various user/dev meetings.

This talk details improvements in each of those areas with a specific focus on ease of use and automation. Many noteworthy features have been introduced thereby improving the user experience across the board. Umbrella release aims to provide Ceph File System users and administrators a better and smoother experience.

Concurrent storage access via standard network protocols such as SMB and NFS has become a common feature of many proprietary storage products. Samba, the leading open‑source SMB implementation, has long supported a limited set of multiprotocol scenarios by leveraging kernel interfaces and by allowing aspects of multiprotocol access to be implemented in the filesystem. Over time, several storage vendors have exploited these capabilities while using their own proprietary filesystems.

In this talk we will present our plan for a fully open‑source multiprotocol stack built on CephFS, Samba, and NFS‑Ganesha. First, we will describe the testing infrastructure we are creating and the use‑cases we intend to support in the initial release. We will then outline our approach to exclusive file locking and to a unified access‑control model.

This talk introduces an advanced storage acceleration strategy for I/O-intensive container workloads. In environments like CI/CD pipelines or database applications, performance is often constrained by storage latency. Our plan addresses this by implementing a transparent data caching layer that uses high-speed local storage to hold frequently accessed data, significantly reducing retrieval times and load on the primary storage system.

With a core focus on disaster recovery and fast StatefulSet failover, the primary cloud storage volume is intentionally left pristine and unmodified, containing solely user data All cache intelligence is kept local to the node. This design is critical for operational robustness, as it ensures the data can be restored to a consistent point in time, a fundamental requirement for reliable disaster recovery This allows the volume to be safely attached to any node for rapid failover maximizing both performance and data safety.

project: https://github.com/kubernetes-sigs/alibaba-cloud-csi-driver

For high-performance proxy services, moving data is the primary bottleneck. Whether it is an NFS-Ganesha server or a FUSE-based Ceph client, the application burns CPU cycles copying payloads between kernel and user space just to route traffic. While splice() exists, it imposes a rigid pipe-based architecture that is difficult to integrate into modern asynchronous event loops.

We propose a pure software zero-copy design that works with standard network stacks. In this model, a specialized kernel socket aggregates incoming network packets into a scatter-gather list. Instead of copying this data to the application, the kernel notifies userspace—potentially via io_uring—that a new data segment is ready and provides an opaque handle.

The application sees the headers to make logic decisions but acts only as a traffic controller for the payload. It uses the handle to forward the data to an egress socket or a driver like FUSE without ever touching the actual bytes. This talk will outline the design of this buffer-handling mechanism and demonstrate how it allows complex proxies like Ganesha and storage clients like Ceph to achieve true zero-copy throughput on standard hardware.

Ad hoc lightning talks. Every speaker gets exactly 5 minutes (or less).

Authenticated Encryption in Storage Systems

• Presenter: David Mohren
• related email thread

HopNet: User-friendly distributed storage with E2E encryption

• Presenter: Allison Bentley (bentley.sh)
• Slides

Solid: giving Personnal online data store to the web

• Presenter: Joe

Filesystems for AI workloads: Linux and the Single Node Bottleneck

• Presenter: Gwen Dawes (University of Cambridge)
• Slides

Crystal focuses on developer happiness while still providing strong safety guarantees. It goes to great lengths to make complex concepts easy to use, taking away a lot of complexity. For example, static typing and compilation to native code make it intrinsically type safe and blazingly fast. Yet built-in type inference makes most type annotations unnecessary, resulting in easy to read and clean code. It feels like a dynamic language. Crystal’s runtime allows the programmer to write I/O operations as if they were blocking, but they're actually non-blocking under the hood.

Terminal UI libraries often rely on heavy dependencies (e.g., curses) or platform-specific hacks. Lua’s minimal standard library makes this even harder—how can we provide a portable, lightweight solution? In this talk we’ll explore terminal.lua (built on top of luasystem): a minimal, cross-platform terminal UI library for Lua designed to provide essential terminal primitives without external dependencies like curses. The work presented here includes developments made during its participation in GSoC 2025, as well as improvements made afterwards.

Lua intentionally keeps its standard library small, so handling terminals requires defining the true minimum set of capabilities needed for Unix, macOS, and Windows — while keeping the API simple, consistent, and predictable. The talk begins by outlining the problem: how to handle terminals portably and transparently in a lightweight language by creating a level playing field. We’ll then walk through the minimal core implemented in luasystem and how terminal.lua builds a higher-level layer on top.

We’ll discuss:

Low-level:

• Bridging differences between Unix/POSIX and Windows
• UTF-8/Unicode handling (including double-width characters such as emojis)
• Non-blocking async keyboard input in single-threaded Lua
• Querying the terminal (e.g., retrieving cursor position)

Higher-level:

• Representing terminal state (color, cursor position/shape/visibility)
• Basic layouting and color handling

Projects:

• LuaSystem — a C library exposing the absolute bare minimum terminal and system primitives needed to let Lua build a UI layer on top: https://github.com/lunarmodules/luasystem
• terminal.lua — the “proof of the pudding”: a pure-Lua UI library that demonstrates what can be built cleanly and portably when sticking to those minimal primitives: https://github.com/lunarmodules/terminal.lua

BLUE is an acronym for Build Language User Extensible. It is a functional declarative build-system fully written in Guile.

As opposed to other build-systems, BLUE works as a library that can be used by projects to manage their builds. It is entirely self-contained and can be embedded into existing projects. It provides an optional clean and extensible CLI and extension points for external tools.

BLUE aims to reduce frictions from the build-system by providing a rich extensible API with clear error messages and documentation.

Ever wondered what is so special about Lisp's REPLs? Curious how to debug your Guile project or write tests? Lost in all the tools and libraries and not sure which to use or how? We've got you covered.

Today we will go through the fundamental tools needed for efficient Guile development. This will work for your personal Guix config, Guix itself, a new fancy Guile library, or Your Next Big Thing. We will go step by step from a simple project stub to a fully functional application covered with tests, and along the way we will learn about:

• REPLs and highly interactive development environments
• Ares/Arei Guile IDE
• How to deal with exceptions and stack traces
• Testing in the Scheme ecosystem and a new testing library, suitbl
• Whether tests and TDD work with the REPL
• Whether you need a debugger and how to use it

Links:

• Guile and SRFI libraries
• Guile Ares :: Guile IDE backend (suitbl library lives here)
• Arei :: Emacs frontend for Guile IDE
• trop.in :: Andrew Tropin's personal page and blog

Those looking to get started with Scheme often find that they need to first learn Emacs. This is for good reason: pretty much all other editors have lacked the basic features to make Scheme a comfortable language to use. Over the past year, I've been developing my own VS Code extension to make programming Scheme without Emacs a reality. This talk explores what exists today, covering both my own extension, other tooling, and what's left for us to do as a community to make Scheme a first-class citizen in all editors.

Wastrel is a new ahead-of-time compiler from WebAssembly to native binaries. It has all the features, tail calls, garbage collection (via Whippet), and exception handling included. In this talk we show how Wastrel can run on vanilla C programs compiled using the WASI toolchain with best-in-class performance, as well as running Scheme programs compiled using Hoot. We discuss how Wastrel build on Hoot's WebAssembly support library and compare the speed of Scheme programs in the browser versus Wastrel versus native Guile.

Lisp is often decried for being hard to read and having too little syntax. This talk argues that the parentheses are not the point, but the uniform structure is! Lisp is like clay: a medium which is versatile for building many shapes and sculpting beautiful new technical visions. Christine Lemmer-Webber makes an argument that lisp's power comes from composable DSLs, and that this power is what gives projects like Guix and Spritely much of their strength.

Functional reactive programming (FRP) is a declarative programming paradigm that is most commonly used in interactive applications where imperative, event-driven, callback-laden code quickly becomes overwhelming and difficult to reason about. The reduction in cognitive overhead comes at a price, however. Popular reactive systems are limited to one-way data flow (a directed acyclic graph) which limits the types of problems these systems can solve elegantly. Fortunately, a way to remove this limitation has been known for over 15 years! Alexey Radul's 2009 PhD thesis "Propagation Networks: A Flexible and Expressive Substrate for Computation" tells us how. In this talk, I'll use Guile Scheme to demonstrate how an FRP system built on the propagator model allows for cyclic dependencies without user-visible glitches whilst keeping implementation complexity low.

This talk will describe work on creating and publishing Guix container images, and what you can do with them. Images are bootstrapped from Debian images and built on GitLab shared runners for amd64 and arm64, with ppc64el and riscv64 work in progress. The images are tested for regression, and automatically uploaded to the GitLab container registry and to Docker Hub. We will also talk about what these images can be used for, with examples of long-term reproducible tarball artifacts for official releases of GNU Libtasn1, InetUtils, Libidn2 and SASL. We will also go into limitations involving security trade-offs for reducing guix-daemon privileges, and the interaction between GitLab shared runners, user namespaces and other security complications.

Meilisearch (https://www.meilisearch.com/) is a popular Open-Source search engine written in Rust that boasts more than 50k stars on GitHub, focusing on performance and ease-of-use. Meilisearch is designed to be available worldwide, which requires supporting multiple languages through word tokenization. But, how difficult is it to segment and normalize words? And, how different this process can be depending on the Language?

Meilisearch core maintainers share how they handled language support, the difficulties they faced, and the solution they found.

Learned sparse retrieval models such as SPLADE, uniCOIL, and other transformer-based sparse encoders have become popular for delivering neural-level relevance while preserving the efficiency of inverted indexes. But these models also produce indexes with statistical properties radically different from classic BM25: longer queries, compressed vocabularies, and posting lists with unusual score distributions. As a result, traditional dynamic pruning algorithms like WAND and Block-Max WAND often fail to exploit their full potential.

This talk presents Block-Max Pruning (BMP) from a systems and Rust-engineering perspective. We will walk through how BMP restructures query processing by partitioning document space into small, contiguous blocks and maintaining lightweight, on-the-fly score upper bounds that guide safe or approximate early termination.

The talk is aimed at developers building retrieval engines, Rust-based data systems, or ML-powered search pipelines who want to push sparse retrieval performance further. Attendees will leave with a clear understanding of how BMP works, why learned sparse models require new pruning strategies, and how to integrate these ideas into modern, high-performance Rust codebases.

Code and resources: BMP GitHub repository: https://github.com/pisa-engine/BMP/ Paper (SIGIR 2024): https://www.antoniomallia.it/uploads/SIGIR24.pdf

Traditional QA pipelines—even those using baseline RAG—struggle with complex reasoning tasks such as multi-hop inference, contradiction detection, entity linking, temporal consistency, and large-scale cross-document understanding. These limitations become critical in domains like investigative journalism, scientific research, and legal analysis, where answers depend on relationships spread across many documents rather than isolated text chunks.

This talk will demonstrate how open-source knowledge-graph–based approaches can overcome these challenges by enabling structured retrieval, multi-hop reasoning, richer context assembly, and corpus-level summarization. We will explore several open-source frameworks used today to build graph-enhanced RAG systems and compare them across practical criteria: extraction quality, response latency, hardware requirements, maintenance complexity, and suitability for different problem types.

Attendees will leave with a clear, practical understanding of how to select and apply graph-based RAG techniques to extract deeper insight from large unstructured datasets.

Frameworks we're going to consider: - MS GraphRAG (MIT license) - https://github.com/microsoft/graphrag - LlamaIndex KG (MIT license) - https://github.com/run-llama/llama_index - KAG/OpenSPG (Apache-2.0 license) - https://github.com/OpenSPG/KAG

OpenSearch v3 major release that was introduced in the past year represents a significant leap forward in open source search technology, delivering breakthrough innovations across neural search, AI-driven search experiences and performance optimization. This talk explores the major features that define the 3.x releases and their impact on modern search applications.

We'll dive into differentiating capabilities like scalable Neural Sparse ANN Search using the SEISMIC algorithm, and the new Search Relevance Workbench for metric-driven relevance evaluation. Discover how system-generated Search Pipelines eliminate configuration overhead, automatically building Vector Search pipelines at query runtime and UI editor for AI Search workflow set up.

The release brings industry-standard search features including MMR, ColBERT’s late interaction, RRF, radial search, and one of the most popular pre-trained spare encoder model in HuggingFace positioning OpenSearch alongside leading search platforms. Performance innovations deliver dramatic improvements: Memory-Optimized and Disk-based Vector Search with efficient FAISS execution, star-tree indexes for multi-field aggregations, 2x storage savings through derived source, and reader/writer separation for independent index/search scaling and resiliency. Real-time data processing enables continuous query execution for streaming results, and ability to build vector indices remotely using GPUs, while QueryInsights helps monitor cluster’s search query performance.

Finally, we'll showcase Agentic Search capabilities—from Natural Language Agent Search to native AI agents with persistent memory, workflow UI editors for non-technical users to set up AI Search flows, and OpenSearch MCP integration with Claude code, Gemini CLI and other AI assistants to interact with OpenSearch.

This is your opportunity to hear from the OpenSearch maintainers and ambassadors about the latest and greatest in the project. Attendees will leave understanding how OpenSearch v3 addresses the full spectrum of modern search challenges: Neural and Vector Search, Search quality measurement, performance at scale, and the future of AI-powered Search experiences.

What are multi-vector embeddings? How do they differ from regular embeddings? And how can you build an AI-powered OCR system in under 5 minutes without paying a fortune for infrastructure? If you're curious for answers, join me! I'll break down ColBERT embeddings, explore how MUVERA compression is revolutionizing the way we work with multi-vectors, and show you how to leverage it all to build an AI-powered OCR system on resource constrained devices such as Raspberry Pi.

Weaviate DB: https://github.com/weaviate/weaviate Multi-Vector vision embeddings demo: https://github.com/antas-marcin/weaviate-multi-vector-example

Search in Elasticsearch keeps evolving, from traditional BM25 keyword retrieval to multi-stage search that combine lexical, vector, and language-model-driven intelligence. In this talk, we’ll explore how Elasticsearch APIs enable developers to build hybrid search systems that mix classical scoring, dense vector search and semantic reranking in a single coherent workflow.

We’ll use ES|QL, Elasticsearch’s new query language, and show how constructs like FORK, FUSE, RERANK, COMPLETION, and full-text functions let you build multi-stage pipelines in a simple query.

We’ll discuss where ML models and LLMs fit into the retrieval stack, from embedding generation to on-the-fly augmentation and semantic rerankers.

Finally, we’ll look at future directions for search.

If you want a practical and forward-looking view of how search is evolving in Elasticsearch—and how to put multi-stage retrieval to work—this session is for you.