Events in room K.3.401

CryptPad is a collaborative office-suite that is end-to-end encrypted and fully open-source. The project has been operating for over 10 years and is used to collaborate on millions of documents each month on the flagship instance cryptpad.fr. In this talk we will introduce the product and its suite of applications. We will highlight some recent achievements from the last year including

• an updated look and feel;
• a re-write of our server;
• improvements to office applications;
• and a new CryptPad embedding API.

We will also recap the financial situation of the project, and our plans looking ahead towards sustainability.

2025 has been a crazy year for open source, self hosted collaboration. As in, everyone has woken up to the risks of having an entire economy depend on 3-4 big American tech firms. Well, we at Nextcloud have been working to solve that since we started in 2016 and the large roll-outs recently, of millions of users at various public sector organizations across Europe. And now suddenly everyone else starts talking about it?

Well, we’re at FOSDEM, so all we care about is… features. That, and self hosting of course. It is more fun. And who doesn’t want to stay in control?

So, like every year, I will go over everything we did in Nextcloud in the last year. Is it feasible to do that in a single talk? Of course not, but I’ll try anyway, and you can judge me.

See you in Brussels!

“Privacy-invasive cloud services,” “isolated users” and “small, disconnected instances” are what comes to mind when we think of self-hosting. It gives users control, but it also isolates them, with each server becoming a separate island.

Cloudillo changes this. It is a self-hosted application platform that makes collaboration extensible, privacy-preserving, and organic — letting groups and organizations collaborate freely across different installations without relying on any centralizing infrastructure, while keeping their data private and under their control.

At its core, Cloudillo provides all the building blocks of a modern collaboration suite: file storage, real-time database, live editing, social interactions, and user identity.

But what’s the kicker with Cloudillo? It is that these are not closed features, but open APIs developers can use to build new applications that integrate seamlessly into the platform. A built-in DNS + PKI-based identity layer enables people and organizations to connect securely, exchange data, and seamlessly share both content and applications across independently hosted Cloudillo instances — without any third-party coordination service.

Cloudillo’s entire backend is delivered as a single 30MB Rust binary, with no external dependencies. It emphasizes simplicity, performance, and security. Developers can deploy it in minutes, extend it in Rust, or build applications in TypeScript, then immediately gain access to a global framework for distributed collaboration.

This short talk introduces the concept behind Cloudillo, explains its technical foundations, and demonstrates how developers can create their own apps — apps that reach beyond a single server, thanks to Cloudillo — the platform that aims to make privacy-first collaboration not just possible, but convenient and open for innovation.

Taiga is a Spanish open-source project management software that was created in 2014. After achieving success with over 20 million users, a rewrite is started in 2021 in order to modernise the application. However, this soon came to a halt: the original team is no longer able to continue the project. So, after 10 years of development and with many users eagerly awaiting this sequel, is this the end?

Thanks to the magic of open source, the story continues. A French cooperative that was also working on Taiga, took the project under its wing, ready to start afresh.

Join us to discover the origins of Tenzu (formerly Taiga-Next), find out where we are now, and learn about our future plans.

Join me for a fast-paced tour of OpenProject’s most impactful updates over the past year—from powerful portfolio management enhancements to much requested service management features, such as internal work package notes.

This session will also spotlight our long-term tech strategy to bring real-time text collaboration to every corner of the platform, enabling teams to co-create work packages, meeting notes, and other project management artifacts with ease. Discover how we’re leveraging and extending BlockNote, the rich-text editor already powering applications like openDesk’s Notes and Mijn Bureau’s Docs, to bridge the gap between quick te sketches and fully-fledged project plans. We’ll also invite developers to explore our BlockNote extensions, making it easier than ever to integrate work and task management into their own platforms.

Further, I will give an outlook on our strategy to help project teams to migration from Jira Data Center and Confluence to OpenProject and XWiki respectively.

Whether you’re a user, contributor, or developer, this talk will inspire you to reimagine collaboration in open-source project management.

During their most recent “100-Day-Challenges”, teams from France, the Netherlands, and Germany collaborated to co-develop sovereign public sector IT. The Netherlands is using components from La Suite Numérique and openDesk to build MijnBureau, while French and German teams continue to work together on their workspace solutions. This session explores how these cross-border collaborations tackle technical and organisational challenges and enable interoperability between different national workspaces. By sharing experiences and lessons learned, we highlight the potential of coordinated European initiatives to strengthen digital sovereignty and co-develop resilient, citizen-focused public sector software across borders.

It is hard to sustainably support #OpenSource as government - after all, the public sector's subsidy programs tend to be short term focused, fragmented. They are sadly doing little to shift the billions now spent on proprietary US SaaS solutions towards sovereign open source, and have little staying power and permanence.

I'd argue the public sector should work with existing communities that have managed a sustainable financial model, commit to deploy these & shift real procurement money rather than be distracted by subsidies.

I will keep my argument short - and leave the time for discussion!

In this talk, we will highlight the latest updates to BlockNote. BlockNote is a rich text editor that focuses on a modern (block-based, Notion-style) User Experience and an easy DX (Developer Experience). BlockNote is used in open source projects like Docs (La Suite / ZenDiS), OpenProject and XWiki.

In this talk we'll give an introduction to how it works and highlight the latest developments and upcoming features, such as:

• Features for Async Collaboration: Versioning, Track Changes and Comments
• The renewed Extension system
• AI Integration

Cristal is a modular, extensible, and embeddable Wiki User Interface built with Vue and TypeScript. It offers a modern, polished interface using VueJS and supports offline and real-time editing. Built to be data storage agnostic, it is embeddable in several existing collaboration and knowledge management solutions (e.g., XWiki, a local file system, a Nextcloud storage, or a GitHub repository).

In this talk, I will showcase how Cristal can be embedded seamlessly as a Nextcloud application, allowing Nextcloud administrators to provide knowledge management to their users in a few clicks. In particular, I'll highlight how past design choices helped embed Cristal in Nextcloud. But also present a return of experience of the unexpected issues faced in the process. I will also present other features developed this year (integration of the BlockNote editor, support for macros) and how they will benefit current and future Cristal users.

This talk is presented by Stephan Meijer (NL government, NLdoc/La Suite Docs) and Albert Krewinkel, maintainer of Pandoc.

Public administrations hold millions of documents trapped in formats that are hard to reuse and often fail WCAG requirements: PDFs, legacy Word templates, ad-hoc styles. At Logius, with the NLdoc project, we were tasked with turning those documents into accessible, reusable HTML and other open formats. Our first instinct was the obvious one: use Pandoc and wrap it with some pre- and post-processing. It worked… until it didn’t. Every new edge case, every new target editor, every new accessibility rule meant more custom glue code and brittle filters.

So we flipped the problem: instead of chaining converters, we designed a JSON-based document Abstract Syntax Tree (AST) with an OpenAPI specification and built dedicated conversion services around it. That AST now sits at the centre of a small ecosystem: PDFs and DOCX files are converted into the AST, and from there into editors such as Tiptap and BlockNote, or directly into formats such as HTML. Support for ODT, Markdown and EPUB is on the way.

The same AST also powers the NLdoc Tiptap-based editor, where authors get real-time accessibility validation and can export to accessible formats. It also powers the import functionality in La Suite (Docs), the FR–DE–NL sovereign collaboration stack.

In this talk we’ll walk through that journey: why "just use Pandoc" wasn’t enough, what our AST looks like, how we wired it into a queue-based microservice architecture, and how this approach turns document conversion from a one-off migration hack into an interoperability layer for accessible, sovereign collaboration tools.

Recent versions of the document specification are available at the Releases page of its repository.

• The Elixir poject is available on github.com/docspec/docspec-ex
• The import API for La Suite Docs is published at github.com/docspecio/api.
• The La Suite Docs application itself is available at github.com/suitenumerique/docs.
• The Pandoc website (pandoc.org).
• The Pandoc repository (github.com/jgm/pandoc).

The new Collabora Office brings a beautiful, ergonomic suite, based on LibreOffice to the desktop. Come hear why, in 2026 we're creating a native local application. Hear about the limitations of Web APIs, and checkout some of the metrics we have gathered around how people collaborate on-line, and the engineering decisions that flow from that. Hear about our new approaches to handle collaboration, off-line, conflicts, and forthcoming protocol to negotiate transitions between co-editing, sharing, on-line and off-line. Finally catch up with the latest in UX research, interoperabiltiy and feature improvements as well as seeing how to get involved with the project.

Collabora Online introduced a new feature that lets users start a slideshow for everyone who has joined the presentation. This feature can be used during meetings where, instead of sharing the screen to present something, the user can now just start the slideshow inside the presentation document.

Four years ago, the We4Authors initiative united several content management tools (mostly open source) to identify and document accessibility best practices in preparation for the European Accessibility Act. It was the most coordinated effort to help content authors produce accessible digital content at scale. Yet, despite the groundwork, only the recommendations have not been widely adopted. The Web Almanac confirms what many suspected: web accessibility has not meaningfully improved in preparation for the Act’s introduction. https://events.drupal.org/europe2020/sessions/top-cms-tools-are-working-together-build-more-inclusive-world.html

Much of this was built on or extending ideas in Authoring Tool Accessibility Guidelines (ATAG) 2.0. https://www.w3.org/TR/ATAG20/

Today, the context has changed.

Artificial Intelligence—especially small, local language models—offers a new opportunity to deliver accessibility guidance where it’s needed most: at the moment of authoring. CMSs can leverage open source AI to suggest accessible alternatives, improve media descriptions, and identify structural issues in real time—without sending user data to third parties or compromising privacy.

This talk will explore how we can: • Revisit the ATAG 2.0 & We4Authors guidance and align it with today’s AI capabilities. https://www.w3.org/WAI/standards-guidelines/atag/ • Integrate small language models within CMS authoring environments. • Collaborate across open source communities building on the Open Web Alliance • Build shared datasets, APIs, and modules to improve author support and accessible defaults.

Accessibility progress requires shared effort, not just compliance checklists. Let’s use open collaboration and new tools to help every author publish content that works for everyone.

Digital Workplaces increasingly consolidate collaborative tools, yet telephony often remains isolated and difficult to integrate. User needs show that a unified interface, including VoIP, simplifies the user experience while reducing vendors and costs. Once treated as a silo, telephony is now starting to become a central component of collaborative platforms.

This presentation will cover the key technical integration points for adding a a softphone application and a VoIP calling service to a Digital Workplace: embedding a web-based calling client into an existing interface, managing SSO and account provisioning, unifying call histories and presence information, ensuring interoperability between system notifications and platform notifications, and adapting the user interface.

We will illustrate these points with a concrete example using the SIP client Linphone and the SIP server Flexisip, demonstrating how an open source VoIP solution can be technically integrated into a collaborative platform: adapting WebRTC to SIP, handling push notifications for incoming calls, retrieving call logs via an API, and more.

The goal is to show how telephony can become a modular building block for collaboration rather than an isolated tool, and why this approach is essential for open source Digital Workplaces like Nextcloud, OpenDesk, or eXo Platform to offer a complete solution. It is only by combining the strengths of different specialized open-source software editors that it may be possible to compete with major players in the collaborative-software market, such as Microsoft 365.

In a world where custom JSON and binary formats thrive, HTML and XML continue to provide an open and universal system for sharing structured information. But these languages are plagued by decades of insufficient tooling which makes working with them tenuous at best. The HTML API in WordPress has introduced a safe, reliable, and convenient interface for parsing HTML to address a number of these issues; in the process it unlocks new worlds of interoperability and translation for human-authored content.

This talk will discuss the streaming interface of this new processing pipeline and how it can be replicated in other languages and platforms. It will highlight how re-embracing HTML and other markup languages can improve interoperability between platforms and how better tooling can make working with these legacy formats less painful.

Having a spec-compliant DOM parser is useful, but a spec-compliant and minimally-allocating streaming parser can be a game-changer in high-demand and low-latency applications. Come hear the fascinating war stories from developing such a system, how design played a key role, and ways it has already unlocked novel and high-quality features.

• https://make.wordpress.org/core/tag/html-api/
• https://developer.wordpress.org/reference/classes/wp_html_processor/
• https://developer.wordpress.org/reference/classes/wp_html_tag_processor/

With a live demo I will show how I distribute my (mostly long-form) content (POSSE) from Drupal (CMS) to multiple Nostr relays. After this demo I will explain the technicals details how this works (using the Nostr-PHP library https://nostr-php.dev and used Drupal modules, https://www.drupal.org/project/nostr_content_nip23, which I maintain).

In the last few years, we've revived the idea of a student wiki at MFF CUNI, where the last attempt had languished for years. We'll talk about the technical side – choosing a platform, the problems we encountered, and our extensive modifications – as well as the organisational side, from getting institutional backing for our project to actually getting student contributions.

Through a combination of automated migrations and follow-up manual edits, we've consolidated a number of older, semi-abandoned platforms at the faculty to the new wiki. The entire software stack is FLOSS while also allowing integration with other university systems.

You can see the current state of the wiki at https://wiki.matfyz.cz, and our source code at https://gitlab.mff.cuni.cz/matfyzak/wiki/

Collaboration in the physical world can learn from the tools software developers use. Forgejo is an excellent code forge that can be repurposed for collaborative project management or a simple TODO app. This presentation explains how a PWA can be built on top of Forgejo by generating a binding for a mobile app from the api description.

By reusing Forgejo as a backend, development time on a backend is saved and a fallback frontend exists too. The advantage lies in the ability to create a dedicated frontend for particular workflows while retaining the proven parts.

Two years have passed since we presented Domain crate, our DNS library written in Rust (https://github.com/NLnetLabs/domain) here at FOSDEM. We added a lot of functionality (for example, DNS client and server support, DNSSEC validation, DNSSEC signing) and started writing our first applications. The most notable application is our new DNSSEC signer called Cascade (https://github.com/NLnetLabs/cascade). In this presentation, I go over the work we have, what our plans are for the coming year. And we would like to hear from you, what would you like to see in a DNS library.

Given a large enough network of distributed nameservers, updating their configs and keeping all of them in sync becomes a highly error-prone activity. The problems multiply when multiple sysadmins and different operating systems are involved. We have created a low-complexity solution for syncing the NS configuration and keeping all servers aware of the current shape of the network.

• Repo
• Project

DNS is the most critical service that runs on small, client-focused networks. Hosting your own DNS unlocks interesting possibilities: Lower latencies, caching, DHCP hostname integration, and ad and malware blocking just to name a few. However, it also comes with great responsibility: For clients, if DNS is down, the internet is down.

In this session we will explore how we can have all those delightful features while maintaining resiliency and zero-downtime upgrades, using Kubernetes as a platform. We will cover well-established, open source projects such as dnsmasq and dnscrypt-proxy, explaining what they are, how they work, and how to compose them.

In the platform side of things, we will use Kubernetes and metallb to provide self-healing, as-code infrastructure and layer 3 failover respectively. Prior experience with Kubernetes is not required to get the most out of this session.

On paper, DNS is a simple request-response protocol. In reality, building an authoritative nameserver that delivers under heavy load, processes malformed packets safely, and resists DDoS attacks is a complex engineering challenge.

This talk peels back the layers of erldns, DNSimple's open-source high-performance DNS server, to explore the fundamental architecture required to handle millions of queries per second. We will focus on:

• Simplified Resolution: How a special binary tree structure drastically simplifies the DNS resolution logic, making complex requirements like empty non-terminals and handling zone cuts trivial.
• Concurrency Models: How to structure a system that isolates failures per-request so that a crash in one query never brings down the server.
• Traffic Management: Strategies for handling UDP floods and managing TCP connection pools without exhausting resources.
• Packet Handling: The nitty-gritty of parsing binary DNS wire formats safely.

While the reference implementation uses Erlang, the architectural lessons on isolation, supervision, and fault tolerance are applicable to any language. This session is designed for developers and operators who want to understand the "nuts and bolts" of how robust DNS software is built.

Project Links: - DNS Server (erldns): https://github.com/dnsimple/erldns - DNS Library (dns_erlang): https://github.com/dnsimple/dns_erlang

Isn’t monitoring DNS queries a really bad idea? If the monitoring crosses the line to surveillance, we agree. Monitoring for bad actors is still needed and valuable for cybersecurity. Building such a platform in Open Source and running it as a non-profit is much better than letting commercial actors consume this data without making it an open data commons. For sure many won’t protect the user’s privacy the way we do.

This is the story about the DNS TAPIR Open Source project - the reason we started it, our core principles and the architecture .

lwresd was present long ago in Debian 4, acompanied by the libc library plugin libnss_lwres. It was intended to be a simpler cache than a standard name server, but it never gained wide adoption. Because it offered no significant advantages over using a DNS server like named directly. It was removed from BIND9 after version 9.11.

I have a few ideas on how to use it over Unix domain sockets to unlock new features. With some significant modifications to the original concept, it may make sense to revive the lwresd daemon.

• Deprecated lwresd docs: BIND 9.11.37 ARM

As a developer, how do you add an automated check for software updates to your application? You could use DNS! DNS is lightweight, provides redundancy, responses are cacheable, and going through your network resolver gives you some privacy.

But, making DNS changes as part of a software release is not ideal, I've done it. Can we automate this? We can for Go applications! Gopherwatch.org is a free service that monitors the Go sumdb, a transparency log (like certificate transparency) containing all Go "modules" (libraries/applications) and their published versions. Gopherwatch.org provides a DNS interface for querying the latest version for all Go applications/libraries, and the latest Go toolchains.

We'll look at how the Gopherwatch DNS interface works and discuss limitations and possible future improvements. If there's time, we'll also look at how the DNS interface is used to provide one-click or even fully automated software updates for Go services.

The DNS is a hoary protocol, with ancient secrets that man was not meant to know.

It is said that learning too much about the dark corners of this ancient knowledge might drive one mad.

Here is your chance to learn mostly useless things about DNS!

This presentation will cover quirks of the DNS protocol which are probably surprising, and hopefully interesting.

Warning: Due to constraints no entities from beyond time and space will be summoned during this talk.

In this kickoff session, I will introduce the essence of the Translations devroom and showcase ideas on how to make the localization process comfortable for everyone involved, be it developer, translator, manager, or user; of course, these groups overlap. There will be significant time for interaction between attendees. Following talks will dive into specific experiences and effective practices.

We used automatic translations in the Mattermost-project for a few specific languages. In this talk you will learn from our mistakes. (yes, initially we did break the product) But you will also learn from our best practices and how we keep the human in control for better translations. We flagged auto-translated strings, made better tests to prevent that your product breaks and imported safely these translations with a rollback possibility

Any application with dynamic text is probably wrong! The days of writing "You have " + count + "email(s)" should be behind us, but they're not! Whether it is printed on a screen or spoken via synthesis, the way the text is written is just as important as the words themselves! This talk covers the problems of generating text dynamically in code, and how to solve it.

Getting the grammar correct is hard. Not because the code is difficult, but because there's a lot of it! While the source code might have been written by people of 100 nationalities, the output text is generally English. And when your primary language is English it's doubly hard to ensure every text string is correctly, grammatically. "You have 1 email(s)" looks bad. So does, "The warrior picks up a axe". And so on. This talk covers the GaaS library which codifies the rules of language style and grammar so our textual output can compete with that of proprietary software.

I contribute to Mozilla Project since 2005. I spent the majority of that time translating, localizing and QA-ing that effort.

In the last years I am focusing on Thunderbird both Desktop and Mobile.

I'd love to share some things I learned for that time which will help you to grow as a translator and as a community member: - Is consistency important. Tips and trick I use to keep myself motivated - How do you test a translation with the consumers - Why localizing the mobile version is a bigger challenge that the desktop

Localization of Wordpress content has many solutions, most of them in the form of Wordpress plugins that come with their own way of doing things and a lot of quirks. Weblate is a very mature solution that in our experience is a lot more reliable and easy to work with than any of these plugins. For our own CMS pages, we were wondering how to best explore this path and created a Deno- / TypeScript-based preprocessing tool that can extract messages from Wordpress Elementor pages for use in Weblate, as well as create localized variants of these pages using the Weblate translations as input. While we focus on the localization of Elementor pages in particular, we'll also touch on the subject of Gutenberg blocks due to their widespread use.

Note that this talk may be somewhat hard to apply to existing setups because of the preprocessing happening outside Wordpress, working under the assumption that you are fine regenerating static HTML whenever you want to "deploy" your Wordpress pages. On the positive side, it eliminates the need for any Wordpress caching tools!

Localization is often seen as a purely technical task, but for many contributors, translation work is deeply personal. It is about cultural identity, community belonging and keeping a language alive in fast-moving technical ecosystems. Working with the Spanish localization team for OpenTelemetry, I discovered that what brings people back is not only the desire for accurate terminology, but the joy of building something meaningful with others who share the same language. Contributing to localization OpenTelemetry motivated me to start a new Romanian localization group and inspire contributors who had never participated in open source before. This talk explores why localization communities thrive, what motivates contributors beyond the mechanics of translation and how language-driven belonging can open the door to new contributors in cloud native and open source projects. I will share practical lessons, common challenges, and strategies for creating or sustaining localization groups that make both software and humans better.

In this session I’ll share some challenges we faced at Wikimedia Deutschland with partially translated pages. We have some interesting example cases such as sentences which are partly left-to-right and partly right-to-left. I’d like to open up for discussion so we can share insights on how to approach such cases to get the best outcomes, and how to balance tradeoffs to avoid very confusing text. Epic: Generate Human-Readable Change-logs in Wikipedia Watchlists

In 2020, a group of friends and I started a Luanti minigames server called "A.E.S.". One of the aspects that fascinated us about Luanti was being able to provide translated content according to the language set on the client - even for online servers. What we didn't know was that, we can't really ask translators to learn git if they want to contribute. Having a tailor-made translation format didn't help either. Fast forward of a few years and, thanks to Codeberg staff, we migrate to Weblate; which is when the boom of translations happened. A.E.S. now features 14 languages and, with Luanti switching to an industry standard (.pot/.po files), life becomes even easier. People can now play their favourite games without having to struggle with a language they might not know -so as to focus on the game itself.

https://aes.land/