I’ll show you exactly how I’ve secured my home network to protect my kids from inappropriate content using open-source tools: OPNsense and Pi-hole. By combining OPNsense's firewall features with Pi-hole’s DNS filtering, I’ve built a family-friendly setup that blocks explicit content at the network level. I’ll guide you through my configuration process, including the blocklists, DNS settings, and monitoring tools I use to keep an eye on network activity and ensure everything stays secure. You’ll get practical tips for creating a kid-safe environment without sacrificing privacy. If you want a DIY solution for content filtering and monitoring, this talk is for you.

Discover how the Rust programming language and the ROS 2 framework are transforming robotics development in this talk. Participants will dive into the fundamentals of the ROS2 Rust package https://github.com/ros2-rust/ros2_rust. The session will highlight Rust's performance and safety benefits, its integration with ROS 2 for robotic systems, and practical implementation techniques. Through guided exercises, attendees will learn how to program and control a quadruped robot using Rust within the ROS 2 framework, gaining insights into the challenges of robotic systems and how this powerful combination addresses them effectively. This talk is ideal for developers looking to enhance their robotics expertise using a modern programming language and a robust middleware. Whether you're new to Rust, ROS 2, or seeking to deepen your robotics knowledge, this session offers a unique opportunity to build robust and efficient systems for the robots of tomorrow.

Sampling from multidimensional distributions is a fundamental operation that plays a crucial role across sciences including modern machine learning and data science. An impressive number of important problems such as optimization and integration can be efficiently solved via sampling.

This talk is an introductory tutorial on open-source software volesti, a C++ package with R and Python interfaces. volesti offers efficient implementations of state-of-the-art algorithms for sampling as well as volume computation of convex sets in high dimensions. volesti provides the most efficient implementations for sampling and volume to date allowing users to solve problems that cannot be solved with alternative software packages.

The structure of the talk has two parts: first an introduction to volesti library and relevant background and second a tutorial that shows how volesti can be used with a focus on applications in artificial intelligence, finance and bioinformatics.

The EU Digital Markets Act is a law regulating the economic power of very large technology companies. The law includes several obligations to tackle unfair practices and improve market contestability addressed at companies considered "gatekeepers" of digital markets in the EU.

The DMA creates new opportunities impacting Free Software, like the obligations to allow alternative app stores, the prohibition of non-removable pre-installed software, the enabling of side-loading of software in devices, and interoperability rules regarding software and hardware.

The European Commission is the main authority responsible for implementing and oversight the DMA. The Commission has been investigating companies like Apple, Google and Meta due to their behaviour and practices.

This fireside chat will provide the audience the opportunity to interact with Commission's officers working directly with the DMA. The session will focus on the legal and technical challenges the Commission faces for DMA compliance, in particular: (a) Enabling alternative app stores in iPhones and iPads; (b) Enhancing interoperability in Apple devices; (c) Breaking lock-ins by leveling the playing field for smaller Free Software projects against gatekeeper commercial practices.

The format consists of: (1) a short presentation by the Commission's officers on the importance of DMA for Free Software contributors; (2) A longer Q&A session together with the audience moderated by Dr. Lucas Lasota about the technical and legal aspects of the DMA.

This fireside chat will provide valuable insights for the audience on the work of regulators in Europe, and how they implement key legislation for Free Software.

When tinkering with cars or other vehicles, being confronted with CAN communication or a similar bus is unavoidable. Throughout the past year, Thibault has been using CAN communication to build an Open Vehicle Control System and using it on a real car. In this talk, Thibault will explain how to get started with CAN reverse engineering, how he made different car parts from different brands talk together, and why Elixir and the Erlang Virtual Machine (the BEAM) is a good candidate for them to quickly prototype ECUs with cheap parts.

Cristal is an innovative, modular Wiki User Interface built entirely with TypeScript. It enables navigation and content creation across multiple knowledge sources, including XWiki, local folders, GitHub or NextCloud. Designed with a focus on modularity and extensibility, Cristal offers a modern, polished interface build with VueJS. Its features include offline capabilities, and real-time collaboration.

In this talk, we will showcase the progress made over the past year, including key features and the challenges we faced. We will also discuss how the project has evolved and outline the roadmap for the upcoming year.

An overview of Immich, and how it helps you backup, browse, search and organize your photos and videos with ease.

The Post Office Protocol is quite old and offers only very limited functionality. Every operation supported by POP is also supported by more modern email protocols like IMAP or JMAP. Yet POP3 is still supported by most email providers and email clients. In this talk we explore the questions "Why is that?" and "What can we do about it?"

Friendica has been part of the Fediverse since 2010, building bridges between Laconica and Diaspora*, making it one of the oldest active projects of the Fediverse - yet Friendica has flown under the radar most of the time.

In this talk we will give a short introduction to Friendica, its unique features and how it differs from other systems.

The Friendica project homepage can be found at friendi.ca, the source code for the core is maintained on github and for the addons on git.friendi.ca.

When you install a properly signed software update, maybe the update you got is different from what everyone else get. Maybe the attacker was able to sign a malicious update due to key compromise, or coercion of the legitimate key holder. How would you, or anyone else, notice?

One way to enable detection (but not prevention) of this kind of attack is transparency. When installing updates, verify the signature as usual. In addition, require that the signature is visible in a public append-only transparency log, where entries can be added but never removed.

Sigsum is a minimalistic transparency log that can accept signed checksum submissions for a wide variety of applications and entities that are neither known, nor trusted, by the log operator. The log itself does not become a trusted third party for applications, instead, applications depend on m-of-n trusted witnesses attesting that the log behaves correctly. One of the many use-cases of Sigsum logging is transparency for signed software packages and updates.

This talk explains the "detection, not prevention" benefits one can get from Sigsum, and describes the different roles that make up the Sigsum system.

The Genode OS framework is an open-source tool kit for building component-based operating systems. It scales from rather static embedded appliances to highly dynamic general-purpose computing as showcased by Sculpt OS. Nowadays Sculpt OS is mature, in daily use, and supports PCs, ARM notebooks and the PinePhone.

Since its inception, the Genode framework supports various microkernels and Linux at the lowest layer. Even so Genode leveraged the characteristic features of the underlying kernels, each kernel called for different trade-offs. All the requirements and expectations by the Genode framework towards the kernel are institutional knowledge of Genode's core developers and implicitly documented in Genode's foundation book.

As I'm currently in the process to enable another kernel, let's take a look back, review our experiences, re-iterate challenges we had to surmount, and draw the connection to the ongoing endeavor of broadening Genode's kernel landscape even more.

It goes without saying that no Genode talk is without a demo!

https://www.genode.org https://www.genodians.org https://genode.discourse.group https://github.com/genodelabs

eBPF is revolutionizing how we secure, observe, and scale Kubernetes networking, but its complexity can be daunting. This session demystifies eBPF by exploring how Go makes it accessible, focusing on its integration with Kubernetes through the open-source project Cilium. Attendees will learn the basics of eBPF, how Go simplifies working with it, and practical use cases that demonstrate Cilium’s ability to enforce secure, scalable network policies. This talk is perfect for Kubernetes practitioners curious about eBPF and Go but unsure where to begin.

The Foreign Function & Memory API (JEP 454) introduced a new way of interacting with libraries written in other languages. It can be used as replacement for JNI. This talk examines the inner workings of the Foreign Function Interface (FFI) API. After having it implemented for PowerPC, I'd like to discuss how the JVM handles native function calls and Java callbacks, focusing on key concepts like stack layouts, calling conventions, and cross-platform challenges. The session is intended for developers curious about the technical foundations of free and open Java technologies and how JVM enhancements like the FFI API are realized. It will shed light on the low-level mechanisms that enable seamless integration of Java with native code while maintaining the performance and safety Java developers expect.

Containers are typically deployed in Kubernetes clusters. But at a smaller scale, on a single-node server, or for development purposes, Kubernetes will be overkill. What’s the recommended way to run a fully autonomous application with several interacting containers in these cases?

The answer is systemd. It can orchestrate containers as is an already running process manager, and containers are just child processes. It’s a perfect fit for running containerized workloads without human intervention.

The concept of Quadlet has been introduced in Podman v4.4.0. It’s a systemd-generator that writes and maintains systemd services using Podman. It can manage containers lifecycle (start, stop, restart), volumes, pods, deployments etc. via systemd. The name comes from the following: “What do you get if you squash a Kubernetes kubelet? A quadlet”. Both system and user systemd units are supported to deploy applications without root privileges.

In this presentation, we will discuss what are Podman Quadlets and demonstrate how Podman Kubernetes features can be associated with it to deploy a fully autonomous application.

In this talk, I’ll share how combinatorial testing and behavioral modeling helped uncover tricky edge cases while testing ClickHouse’s (open-source column-oriented DBMS) multiple authentication methods feature. I’ll demonstrate how these methodologies can systematically identify gaps in testing, validate complex features, and improve software quality. Attendees will learn practical steps for applying combinatorial testing to define comprehensive test scenarios, as well as how behavioral modeling can simplify result validation and solve the test oracle problem. This session is for QA engineers, testers, and developers looking to adopt smarter, more effective testing strategies.

Modern laptops, such as the AMD Framework and newer Intel models, no longer support the traditional ACPI S3 sleep state. Instead, they rely on S0ix, a modern standby mechanism that enables low-power idle states. This is one of the only big features still missing for FreeBSD to be a first-class citizen on contemporary laptops, and this talk will explore the journey and current progress of supporting it. Attendees will learn about the nitty-gritty of the implementation including the relevant ACPI objects, tables, and DSMs, CPU and device power states, and future plans for device idleness determination to automatically put them to sleep.

Blog post tracking progress: https://obiw.ac/s0ix FreeBSD Project website: https://www.freebsd.org/ Working GitHub repo: https://github.com/obiwac/freebsd-s0ix

Human-Computer Counter-Choreographies is an artistic research project that combines critical design, choreography and embodied sense-making with data tracking. The project has evolved into various formats such as workshops, a live-coding performance piece, web-based tools and artworks. In this talk, Joana Chicau will introduce the motivations behind the project and how it has impacted audiences by raising awareness of data tracking. She will also demo a custom version of the open-source DuckDuckGo privacy extension which unveils online tracking algorithms through audio and visual feedback.

In a call center environment, this talk will explore how to leverage the power of Kamailio, FreeSwitch, and RTPEngine to enable AI-driven real-time conversations at scale.

We will dive deep into how to integrate AI copilots, providing real-time call transcriptions and conversational context, as well as AI autopilots, enabling call conversations with specialized bots.

By taking advantage of well-defined standards like SIPREC, and leveraging the capabilities of Kamailio, FreeSwitch, and RTPEngine, along with some additional custom code, we will demonstrate ingenious ways to enable these AI-powered capabilities for any VoIP environment, even legacy proprietary systems.

Attendees will learn practical techniques and best practices for building scalable, AI-enhanced call center solutions that can improve customer experience, increase agent productivity, and drive business outcomes.

YugabyteDB distinguishes itself among distributed SQL databases by utilizing PostgreSQL's C code rather than building a compatibility layer from the ground up. This session will explore both the advantages and challenges of this architecture. We will drill down from PostgreSQL's familiar query layer to the distributed storage system, which stores PostgreSQL tuples and lock intents within RocksDB's LSM trees using Raft replication.

We will be guided by analyzing execution plans that closely resemble those of PostgreSQL and adding further metrics that shed light on the underlying storage operations. We may also evaluate stack traces to identify the PostgreSQL and RocksDB functions involved in query execution. Finally, the session will discuss the rationale behind forking PostgreSQL, focusing on its benefits and trade-offs.

Since 2022, the Open Culture Foundation (OCF) has been collaborating with Taiwan’s Ministry of Digital Affairs (MoDA) and STEPS (a local tech company) on government-funded localization projects. These initiatives aim to make civic tech and open-source tools more accessible in Taiwan while enabling international projects to take root and thrive locally.

As a coordinator, OCF has completely localized projects such as GOV.UK Notify, GOV.UK Forms, Matrix Client (Element Series), IRMA, Yivi, Standard for Public Code, Bitwarden, Nextcloud, FreeOTP, GIMP, and Mattermost. Some of these projects have been contributed back to their upstream repositories, while others have evolved into localized solutions tailored to Taiwan's needs. OCF’s efforts focus on three key areas to ensure government funding provides not only financial support but also a foundation for sustainable development.

This talk will explore these three main focus areas:

• Optimizing the Government Perspective on Open Source Educating government officials about the nature of open-source communities, their collaboration models, and the unique attributes of various international open-source projects. OCF also developed a collaborative glossary process to bridge communication gaps among stakeholders and ensure consistent terminology usage.

• Collaboration Among Taiwan’s Communities Partnering with Taiwan’s L10N community, OCF established structured review processes to meet the government’s high standards for quality and timeliness. Over three years, OCF conducted two major surveys during COSCUP. One survey identified critical open-source projects needed in Taiwan, while the other focused on addressing challenges that hinder contributions, aiming to encourage broader participation.

• Engagement with Local Industry and International Communities Although Taiwanese tech teams are highly skilled, many are unfamiliar with the culture of open-source contributions. OCF facilitated understanding of licensing, contribution practices, and engagement with upstream communities. For example, OCF helped Mattermost report and resolve a date display bug in Chinese (CJK) scripts and worked with upstream communities to address significant differences between Simplified and Traditional Chinese, including grammar and linguistic nuances.

Localization is not merely about technical translation; it is a strategic approach to connecting governments, communities, and international open-source projects. This talk will share OCF’s experiences in bridging these gaps and invite Community DevRoom participants to exchange ideas on how to effectively integrate open-source projects into their respective countries.

C++ has many features but sometimes we want more. We will briefly tell the story of why and how we wrote a GCC plugin, used it in production, and later contributed the feature in-tree - now part of GCC 14. The goal of the talk is to motivate users to try GCC development, highlighting that there can be a smooth transition from plugins to in-tree patches.

There will be a written tutorial to go with the talk available to anyone to follow in their own time. The tutorial goes over writing your first custom attribute, static analysis, and instrumentation passes. All packed in the exercise of writing a toy Aspect Oriented C++ via plugins.

Scuba, a real-time data ingestion system similar to Elasticsearch, is often experiencing memory pressure as part of normal operations. The pressure is sometimes overwhelming, leading to OOM (out-of-memory) issues. These are difficult to track in user space as the symptoms of such issues are only visible in kernel space (SIGKILL, kernel oom killer). This talk will highlight how we leveraged bpftrace to monitor our service and help bridge our observability gap.

Being able to receive weather and public emergency warnings can save lives, and we don't want people using FOSS to be at a disadvantage compared to proprietary platforms when it comes to that.

Cell broadcast covers some of this, but it's only part of the puzzle. It's typically only used for the most severe and urgent cases, is limited in the amount of data it can transmit, and doesn't allow monitoring of other areas. Public alerting is, therefore, often augmented by additional channels, including mobile apps. Despite being funded by public money, those are usually limited to proprietary platforms. So, as usual, we have to build this ourselves.

The foundation for this is OASIS' Common Alerting Protocol (CAP), which has been in widespread use for many years all over the world, and UnifiedPush as a free alternative for proprietary push notifications. On top of that, we currently have an aggregation server for alerts from about 100 countries, which notifies clients about incidents in their respective areas of interest.

In this talk, we'll show how this works and how alerts can be integrated into applications.

age-plugin-se allows you to protect arbitrary files with your Apple Secure Enclave. This plugin for age (a simple, modern and secure file encryption tool) is written entirely in Swift, and works on macOS, Linux, and Windows.

In this talk, I will show age-plugin-se in action, and touch on the steps taken to make it robust, simple, and distributable on multiple platforms (including Alpine Linux), all while keeping the dependencies (including tools) to a minimum.

Active Directory-like deployments rely heavily on working DNS infrastructure. FreeIPA project handles this by providing an integrated DNS server based on Bind 9. Samba Active Directory also uses Bind 9, although in a different style. While both are capable to use an external DNS server infrastructure, ability to kickstart a whole enterprise environment from scratch with an integrated DNS server is valuable to administrators, as practice does show.

The talk will reflect on FreeIPA and Samba teams' experience on DNS requirements these Kerberos-dependent and certificate-heavy environments do have.

Two years ago at FOSDEM, I gave a talk titled “How Podcasting 2.0 Will Save the Open Internet”. I’ll be honest—it was partly a bluff. But it turns out I was right. Today, we are here to celebrate the victory of open standards in podcasting.

Podcasting 2.0, launched in 2020 to revitalize a stagnant ecosystem, introduced innovations like transcripts, funding tags, and social interaction features. These weren’t just tools; they empowered creators, listeners, and developers while keeping podcasting open and decentralized.

In a surprising turn, even Apple—long resistant to adopting anything "not invented here"—embraced the Podcasting 2.0 DTD specification in April 2024, bringing transcription features to its platform.

This was a milestone for open standards and open source. Transcriptions improve accessibility for millions, while also boosting SEO, content discoverability, and personalized recommendations. Through Castopod—one of the first platforms to implement Podcasting 2.0 features.

A grassroots, open-source movement is reshaping an entire industry.

But this victory is just the beginning. Together, let us explore how the lessons of Podcasting 2.0 can be applied to other areas, ensuring that technology remains open, accessible, and collaborative.

Sources: - Castopod source code - Podcasting 2.0 Namespace - How Podcasting 2.0 will save the Open Internet (FOSDEM 2023)

The now infamous quote:

“Webassembly on the server is the future of computing” – Solemn Hykes, creator of Docker

But really, what would it take? I'm talking about FULL feature parity. This talk will go deep into how we looked at and attempted to solve every single piece of this very large problem.

While containers have been pivotal in cloud computing, offering isolated environments for applications, they bring notable drawbacks. These include substantial overhead, resulting in larger, less efficient deployments and startup times, and a dependency on the underlying OS for security, posing potential vulnerabilities.

WebAssembly (Wasm) addresses these challenges, and this talk will introduce the open-source project Boxer (https://boxer.dev), which offers tooling for taking existing containerized workloads and definitions, and creating near-universally deployable Wasm distributions (“Boxes”) offering roughly the same environment, with all the benefits of the WebAssembly target. Wasm, a compact binary instruction format, enables lightweight, sandboxed execution, significantly reducing overhead compared to traditional containers. This leads to enhanced performance and smaller, more efficient deployments, ideal for cloud computing. Additionally, Wasm's memory-safe, isolated execution environment provides superior security, independent of the OS. Thus, Wasm, with its blend of efficiency and security, emerges as not just an alternative, but a substantial improvement over container technology for cloud deployments.

Marcotte (https://github.com/dphilla/marcotte) -- the underlying tool for virtualizing layers of system functionality -- allows us to make safe, sandboxed, discrete, and composable system functionality, by leveraging Rust's memory safety model, and the inherent properties of WebAssembly.

This talk will critically examine this new technology, its approach, benefits, and existing limitations compared with containers, and its path forward as a new standard in cloud infrastructure.

pkgsrc, the NetBSD package collection, includes the pbulk tool to build all (or a subset of) packages. Bulk build reports are an invaluable resource for pkgsrc developers to find build breakage and its causes.

Since 2014, I have maintained a web app called Bulk Tracker (written in Go) to visualize bulk build results along different dimensions such as package name, platform and compiler. Originally written as a "serverless" App Engine application, it has recently been completely rewritten to run natively on NetBSD, on a server owned by the project.

This talk will show how bulk build data is useful and some typical use cases the app supports. It will also be about the journey out of the cloud and from a document datastore to SQLite.

https://releng.NetBSD.org/bulktracker/

A common first step to adding full code-generation functionality for a new instruction, or set of instructions is to add them to the back-end as a builtin function. This is particularly common with RISC-V where custom ISA extensions are common place.

In this tutorial I will take you through the steps to add a builtin-function to the back-end, using a case study from the OpenHW CV32E4Pv2 RISC-V core. This has 8 ISA extensions, with a total of more than 300 instructions.

I will conclude by looking at some of the things we got wrong. In particular unexpected consequences when the new compiler started being used more widely.

In this talk, we'll explore the lifecycle of data at CERN, the European Organization for Nuclear Physics, starting at particle collisions ultimately leading to physics research. The bulk of the data from the physics programme at CERN is stored in an open source storage system developed at CERN, EOS - EOS Open Storage.

We'll delve into technical & architectural details on EOS and cover how it solves the problem of large scale storage for scientific data and analysis use cases. EOS supports FUSE, HTTP & GRPC as access protocols. EOS is used also outside of physics use cases, for eg. powering CERNBOX, a cloud storage for CERN users, at JRC, for analytics etc and may power your next large scale storage needs!

We have built a low latency 5g Video camera for race cars using linux and WebRTC.

We use RTCP (RTP's companion protocol) to help cope with the variability in quality and bandwidth of a 5g connection.

The talk will describe the problems we encountered, how we used data from RTCP to solve them. We will present experimental data from tests run with and without RTCP at varying speeds (30->160km/h).

We will also describe the opensource java (S)RTP/RTCP library we developed and used for this work https://github.com/steely-glint/srtplight as well as an LGPL demo program that uses srtplight implement the WebRTC based WHIP protocol (https://github.com/pipe/whipi)

Swift is a relatively new language in the server world but provides a significant number of benefits that makes it ideal for building applications for servers. In this session you’ll see how Swift's tenets of Safety, Performance, Ease of Use using modern features along with a goal of making it an ideal language for anywhere in the stack make it the perfect language for backend development.

We’ll take a short tour of the language and see how easy it is to write clear, maintainable safe code that scales for large asynchronous applications. We'll discuss the language features that eliminate entire classes of common programming errors and see the capabilities that enable Swift to run on embedded devices, Lambda functions, WASM environments, and Docker containers. Finally we’ll discuss Swift’s interoperability with other languages such as C, C++ and Java that make it easy to migrate codebases to Swift.

In January 2018, inspired by similar initiatives, a group of enthusiastic researchers at the Research Institute for Nature and Forest (INBO) launched a coding club. The INBO coding club was, is, and will continue to be a welcoming space for anyone interested in learning more about programming and data analysis, with a particular focus on ecological and environmental topics.

Our goal has always been to foster an environment of collaborative experimentation, where participants share code, learn from one another, and grow together—regardless of their level of experience. Everyone is encouraged to contribute, express their ideas freely, and engage as equals. We firmly believe that learning is a mutual process, independent of expertise levels, and that doing it together is not only more effective but also more enjoyable.

More than seven years—and a pandemic—later, the INBO R Coding Club remains vibrant and thriving. We are excited to share the strategies that have helped sustain this initiative, transforming initial enthusiasm into a widely recognized and enduring effort both within and beyond INBO.

Key lessons learned include: Learn together: Create a supportive space where every question is valued, and mistakes are celebrated as opportunities for growth. As live as possible, as remote as necessary: Live coding in the same room is far more engaging and effective than remote sessions. Community-driven evolution: The club should always prioritize the needs of its community, with feedback playing a central role in shaping its activities. Dedication: A committed core team is essential for the consistent and sustainable organization of club activities. Full openness: All session materials—including slides, code, and recordings—are freely available to everyone.

Many views about antitrust abound in the FOSS communities, but what do the laws actually say? We've invited Alana Rutherford, an accomplished United States antitrust lawyer to answer our questions about how these laws actually work.

Between 2009 and 2015, Samsung released over 30 WiFi-equipped compact and mirrorless camera models that could email photos or upload them to social media. In 2021, they shut down the required API services, crippling the WiFi functionality.

To revive the WiFi feature, the firmware of multiple camera models was reverse-engineered to understand the protocol and to “circumvent” the WiFi hotspot detection implemented by Samsung.

Based on the gained knowledge, a FOSS implementation of the API was created using the Python Flask framework, allowing to post to Mastodon right from the camera. The project supports ~75% of the camera models, looking for hardware donations and better-skilled reverse engineers to close the gap.

It was exemplarily deployed on an inexpensive LTE modem running Debian, allowing on-the-go use of the camera WiFi.

Real-time editing offers users many advantages, editing conflicts are reduced, writing minutes before and during the meeting is much more effective, and much more. However, the fact that real-time editing is now a standard requirement for a modern visual editor is primarily due to the fact that user expectations have changed with Google Docs and Confluence. The open source world has faced and continues to face the challenge of keeping up.

We have therefore extended the Wikimedia VisualEditor with real-time editing for the MediaWiki distribution BlueSpice. The result is a freely available, 100% open source solution for real-time editing, which is based on the most popular wiki software.

In this talk we will provide a first, thoroughly self-critical field report: we will show which technical problems had to be solved, we will report on use cases and initial experiences and on the impact on knowledge sharing with wikis. For example, questions of version control and accountability had to be redefined. Was it worth the effort? Definitely.

Modern AI workloads rely on large GPU fleets whose efficient utilisation is crucial due to high costs. However, gathering telemetry from these workloads to optimise performance is challenging because it requires manual instrumentation and adds performance overheads. Further, it does not produce telemetry in a standardised format for commonly used visualisation tools like Prometheus.

This talk explores the potential of leveraging eBPF to capture CUDA calls made to GPUs, including kernel launches and memory allocations. Data from these probes can be used to export Prometheus metrics, facilitating detailed analysis of kernel launch patterns and associated memory usage. This approach offers significant benefits as eBPF imposes minimal overhead and requires no intrusive instrumentation. Our implementation is also open-source and available on GitHub.

A presentation of the Funkwhale project with a focus on interoperability. We want to highlight the role of the activityPub protocol but also show the interest of musicbrainz, rss, wikipedia to build a web of knowledge.

Mach, famous for its complex IPC and VM subsystems, remains to this day an influential and historically significant Microkernel.

This talk introduces MACHINA, a new microkernel for AMD64 and RISCV64 modelled after the Mach 3 Microkernel. Currently in prototype stage, MACHINA aims to create a modular architecture for experimenting with "Mach-like" systems, reinterpreting Mach’s principles for modern hardware and software environments.

The talk will describe Mach 3’s abstractions and architecture—with a particular focus on its IPC and VM subsystems—and explore the process, design choices, and challenges of reimplementing them from scratch.

Swift is a fantastic general purpose language, which can and has been successfully used beyond its mobile origins, from embedded through server-side systems. One of Swift’s unique strengths is its powerful native language interoperability with C and C++. Recently, the Swift project started work on integrating improved Swift/Java interoperability with the use of both JNI and the new Foreign Function and Memory APIs introduced in JDK22. In this talk we’ll deep dive into the deep integration approach taken between the language runtimes using the FMM APIs and their unique strengths but also challenges.

Continuous Integration (CI) workflows often encounter bottlenecks when testing Kubernetes applications. Traditional methods of building and tearing down full clusters, whether locally or in the cloud, can be both time-consuming and resource-intensive. vCluster, an open-source virtual cluster solution, offers a game-changing alternative by enabling lightweight Kubernetes clusters to be created on demand and quickly

This talk will guide you through integrating vCluster into your CI pipelines and the benefits you get from it. Virtual Cluster enables rapid application testing in production-like environments, including support for custom resource definitions (CRDs) without the overhead of traditional cluster setups. By the end of this session, you'll be equipped to reduce build times, accelerate testing cycles, and enhance the overall developer experience, as your clusters will take less time to build and you will have more time to test.

PostmarketOS is a distribution based on Alpine Linux that boots on everything from Amazon Alexas to Android phones (over 500 devices). To help users install and develop this distribution, we use pmbootstrap - a swiss army knife for embedded and mobile development. In this talk, I will go over how we use pmbootstrap to develop postmarketOS and how you can use pmbootstrap for general embedded linux development.

https://gitlab.postmarketos.org/postmarketOS/pmbootstrap

https://postmarketos.org/

The Oniro Project, an open-source operating system built upon OpenHarmony and tailored for European market needs, is expanding its ecosystem to include mobile devices. In this lightning talk, we will discuss the ongoing effort to bring Oniro to the Volla X23 smartphone, focusing on the technical challenges and solutions in adapting Android drivers to a musl libc-based platform.

We will explore the role of libhybris in enabling compatibility with proprietary Android drivers, a critical step in hardware enablement for Oniro on mobile devices. The presentation will highlight how libhybris bridges the gap between the Bionic and musl libc environments, allowing us to leverage GPU acceleration and other hardware features while maintaining an open-source user space. Key challenges, such as adapting Android’s graphics stack and addressing ABI compatibility issues, will be outlined, along with our current progress in running Oniro in an LXC container for rapid testing.

This talk will provide insights into the broader implications of this work for the FOSS on Mobile ecosystem, offering a pathway to more accessible open-source mobile platforms. Join us to learn how Oniro aims to contribute to the vision of a truly open mobile ecosystem.

Elk is a nimble Mastodon client with great attention to user experience, boasting features such as being an installable Progressive Web App (PWA), support for code blocks with syntax highlighting, chronological threading, and markdown formatting.

Started by core maintainers behind popular developer tooling in the Vue/Vite/Nuxt ecosystem in 2022, it attracted hundreds of contributors and resulted to the creation of new libraries now widely used in other projects.

In this talk, I will give a brief history of Elk development from the perspective of a contributor who has never written a Vue component (before Elk), a walkthrough of key strengths of the technology under the hood, and a look forward to the future of the project.

Links

1. Elk Git Repo
2. Elk mastodon account
3. My contribution highlights
4. My Github
5. Some screenshots

Managing packages across systems and containers can be complex, especially when debugging issues or ensuring consistent deployments.

This short presentation introduces the manifest plugin for the DNF package manager, a tool that simplifies such workflows by capturing system package states into YAML-based manifest files. These files enable users to replicate environments, debug customer issues by mirroring setups, and streamline container builds with transparent, manifest-driven package management.