Overview of a feature implementation in Collabora Online, building on LibreOffice Technology, where autotext and other presets and configuration data can be supplied both at an individual user level and at an organization level, via their wopi server, to a Collabora Online instance serving multiple organization tenants.

In high-energy physics, ensuring that analyses remain reproducible and interpretable over time is a significant challenge. As the Large Hadron Collider (LHC) produces vast datasets and as analyses evolve, reproducibility becomes crucial for both current and future research efforts. Rivet (Robust Independent Validation of Experiment and Theory) addresses this challenge by providing a framework for the preservation and reinterpretation of LHC analyses. This talk will discuss how Rivet facilitates analysis preservation, enabling researchers to reproduce, validate, and reuse complex particle collision studies long after initial publication. We’ll explore specific use cases, including how Rivet supports reinterpretation for new physics searches, and the technical underpinnings that make Rivet an indispensable tool for long-term data analysis preservation. This presentation will emphasise Rivet’s role within the broader landscape of open science and data preservation, with insights into its integration with other high-energy physics frameworks. Attendees will gain a clear understanding of Rivet’s contributions to sustainable research practices and reproducibility within the scientific community.

For the training of generative AI models, developers usually have to gather large amounts of mostly copyrighted data (texts, images, code, music etc.). Datasets are provided online for download or can be assembled individually via crawling & scraping.

In both cases, copies and sometimes further adjustments of data are necessary in preparation for AI training - acts relevant to copyright law, usually requiring a license. Since June 2021, the "text and data mining exception", introduced via the DSM directive, is a part of national copyright laws in the member states of the EU, allowing for license-free copies for the purposes of text and data mining (TDM). It is since being discussed whether the TDM exception can be applied to the training of (generative) AI models, and how respective reservations can be made in a "machine-readable format".

The talk will present the first German court decision (09/2024) on the application of the TDM exception to AI analysis and provide an overview of the discussion regarding the applicability of the TDM exception to AI training in Germany. Participants are also invited to join a constructive discussion regarding the feasibility of a machine-readable reservation and the importance of international / EU-wide (copyright) rules on AI training.

Linux v6.12 adds usb9pfs as a new USB gadget function, which can be used to mount a filesystem provided over USB.

Booting from an external rootfs in the form of NFS is already a staple in embedded systems development, but multiple issues complicate its usage:

• network interface required , which may not always be available
• Interference with normal network setup, especially in existence of switches
• Requires setup of multiple services: DHCP, TFTP, NFS...

By using usb9pfs for the rootfs, these limitations can be avoided on all devices that feature a USB gadget port.

This talk will discuss the design of 9p and usb9pfs and showcase how streamlined development on a Yocto root file system can be with both barebox and Linux making use of usb9pfs.

We'll introduce you to our project "Ethersync," a software and protocol for real-time collaboration. The goal is to make it feel like Etherpad, but for entire projects, on the local file system, and with Neovim, VS Code, or your other favorite text editors! We’ll talk about our vision, technical implementation, and the challenges we encountered along the way.

Collaborating with software like Etherpad or Hedgedoc feels a bit like magic: you can instantly see what others are typing. The downside is that you need to be online to access the content—since the document is on a server, it disappears as soon as you disconnect.

We’re working on an open-source software called "Ethersync" to bring real-time collaboration to the file system! We want to make it possible to write notes and documentation together, and we’re also considering use cases like pair programming—directly in Neovim, VS Code, or perhaps your favorite text editor soon. We’re following a "local-first" approach, ensuring you always have control over your data since it’s stored on your own hard drive.

In this talk, we’d like to explain our vision for this type of collaboration and show you our progress and current prototype. We’ll discuss some of the problems we’ve encountered and dive into the underlying technology (like Conflict-Free Replicating Data Types and Operational Transform).

Finally, we'll discuss how you can get involved: For example, we could use help developing plugins for more text editors! We'll go over the Ethersync protocol, and discuss how it could help interoperability between collaborative projects.

AOSP is a great start - but increasingly doesn't deliver all the functionality you'd expect in a phone OS. Even the mail client that was present in early AOSP is no longer there: You're expected to use the closed-source GMail app.

This talk explains shows how to get most Android functionality on AOSP without having to use closed source applications.

It covers integrating GMS-like services through microG and Open Source alternatives to applications typically preinstalled on Android phones, as well as tricks for better integration of alternatives.

Rust for Linux is the project adding support for the Rust language to the Linux kernel.

This talk will give a high-level overview of the project and will walk its history from the beginning -- it sounds like it was yesterday when we started, but it has been more than 4 years now.

How did the endeavor start? What challenges have we faced? Who are the people behind it? Which projects do we collaborate with? How are we reconfiguring a large system with huge inertia while it keeps running? Can a similar approach be applied to other projects? What do kernel developers think about Rust?

Speaking about Rust, why did we go with Rust, and not something else? How stable is the Rust we use in the kernel? What does it mean to use unstable features in this context? How did we hedge against those? What is the situation with distribution toolchain support? What about GCC and Rust?

And most importantly, since this is open source: how can someone contribute?

How can you efficiently allocate tiny (kilo to megabyte sized) objects on petabytes of storage? Write a memory allocator from scratch which uses less than two bits per 4KB. This talk focusses on an interesting aspect of the SLASH/ storage engines for Varnish-Cache which uses a simple yet super efficient buddy memory allocator, a very well known algorithm from the 1960s. The primary novelty of this implementation is that it uses a fixed amount of metadata at about two bits per minimum page size. It also supports prioritized fair waiting allocations and an interactive live view.

Documentation often struggles to keep up with development cycles. Your users become testers of inaccurate information, which leads to a poor experience. But what if you could test your documentation for accuracy and catch breaking changes before your users do?

This short talk shows how you can improve your docs-as-code workflows with automated testing. Attendees will hear an explanation of Doc Detective and its testing framework. We will also show off some implementation strategies and automation to help keep your docs current.

In times of complexity and easy cloud computing - is it still value-able to maintain an on-prem mail cluster with open-source tools? We will showcase our approach to sizing and rolling out a complete and flexible mail infrastructures, highlight why we chose Ansible for IaC, our approach to template the configuration and automatic documentation generation. We continue to update and develop our roles to incorporate our best practices, develop new features and counter latest security threats. Our Ansible Playbooks and Roles to roll-out this full fledged E-Mail infrastructure are open-source and publicly available. The setups are maintained either by us, the customer with our support or also completely independent.

sq is Sequoia PGP's primary command line tool. After seven years of development, we've just released version 1.0.

In this talk, I'll present sq. I'll start by discussing sq's design philosophy. In particular, I'll explain how sq aims to firstly be a tool for end users, and not developers writing scripts, and what that means for users of the tool. I'll then present how sq is different from other tools in the ecosystem. In this regard, one of the most important differences is that sq explicitly does not support curated keyrings; users have to authenticate all of the certificates that they use. At first blush, this may sound like a usability nightmare, but I'll show how sq supports users by managing evidence, which simplifies these decisions. Finally, I'll demonstrate several workflows. These include how to verify files, how to create and manage a certificate, how to find a certificate and use it, and how to create and manage a CA for your organization.

go build . is a very common way to build and release binaries for go projects. But there are many settings one can pass to go to build better release binaries. This talk will give overview of compile time optimizations, give guidance on re-releasing, apply CGO hardening as recommended by OpenSSF, upgrading dependencies, ensuring binaries can be scanned for vulnerabilities, ensure codebase is compatible with popular go forks for FIPS compliance, and are easier to reproduce.

Relevant projects: - https://pkg.go.dev/cmd/go#hdr-Compile_packages_and_dependencies - https://best.openssf.org/Compiler-Hardening-Guides/Compiler-Options-Hardening-Guide-for-C-and-C++.html - https://pkg.go.dev/golang.org/x/vuln/cmd/govulncheck - https://github.com/chainguard-dev/gobump - https://github.com/chainguard-dev/melange/blob/main/pkg/build/pipelines/go/build.yaml - https://github.com/wolfi-dev/os

Java Flight Recorder (JFR) provides deep visibility into cryptographic operations offering developers unprecedented insights into their applications' security behavior. Learn how to leverage these JFR events to monitor and analyze cryptographic operations in production Java applications with minimal overhead.

Most developers approach unit testing by manually defining specific examples to verify the expected behaviour. With this approach, catching all the edge cases can be tricky – or tedious.

Property-based testing offers an alternative, by emphasizing general properties or rules that should hold true across a wide range of inputs. By automatically generating test cases, property-based testing provides broader coverage and can uncover issues that are difficult to find with conventional techniques.

In this talk, we'll explore property-based testing, breaking down how it works and when to use it. We'll cover:

• Core principles of property-based testing and how it differs from example-based approaches.
• Practical techniques for identifying useful properties in various domains, including algorithms, data structures and APIs.
• Tools and libraries that enable property-based testing in popular programming languages.
• Real-world examples of how this approach has uncovered critical bugs and improved test coverage.

This session is designed for developers curious about expanding their testing toolbox. Whether you're new to property-based testing or looking for ways to apply it in your work, this talk will provide practical guidance and resources to help you get started.

LibreOfficeKit has new API to expose slideshow elements: content, animations, transitions and notes. Short story about composing the impressive 3D slideshows in WebGL directly in the browser.

We will introduce nmbl (no more boot loader), our fast, secure boot scheme based on the Linux kernel. GRUB is a powerful, flexible, fully-featured boot loader used by many distributions on multiple architectures, but its complexity is difficult to maintain, and it necessarily lags behind the Linux kernel exposing many security holes. The kernel itself, on the other hand, has a large developer base, fast feature development, quick responses to vulnerabilities, and much better overall scrutiny. Our approach is to use the Linux kernel as its own boot loader in the form of a unified kernel image (UKI). Loaded by the EFI stub on UEFI, an UKI is made up of all the components needed to reach the final boot target: the kernel, initramfs, and kernel command line, in one signed bundle. All necessary drivers, filesystem support, and networking are already built in and code duplication is avoided. We will describe the work and testing done so far and our approach to customization, as well as fallback, and hope for your feedback and use cases.

The open source community can be siloed at times. People tend to ‘stay in their lane’ and don’t realize what they may be missing out on by not expanding their network. I know time is limited and it’s impossible to participate in every community so how do you become like Kevin Bacon? How do you set yourself up to be connected to people in various communities that you may be able to help or vice versa without being present at every meeting? I’m going to show you how you can channel your inner Kevin Bacon and learn how to expand your network like your funding counted on it!

Self-hosting Web applications is a practice that is useful both in the personal and business context. Depending on the situation, we can enjoy better privacy, flexibility, performance and reduced costs. However, some "boring" aspects we need to think about are backups, authentication, security, scalability and management across servers.

In this lightning talk, I will present a new multi-server container-based solution that sets a solid foundation for self-hosting, while remaining simple to use and operate: NethServer 8.

• Project page: https://www.nethserver.org
• Source code repositories: https://github.com/nethserver
• Community:< https://community.nethserver.org>
• Apps (some are in "testing"): https://wiki.nethserver.org/doku.php?id=ns8:applications:applications

Data theft and leakage, caused by external adversaries and insiders, demonstrate the need for protecting user data. Trusted Execution Environments (TEEs) offer a promising solution by creating secure environments that protect data and code from such threats. The rise of confidential computing on cloud platforms facilitates the deployment of TEE-enabled server applications, which are expected to be widely adopted in web services such as privacy-preserving LLM inference and secure data logging. One key feature is Remote Attestation (RA), which enables integrity verification of a TEE. However, compatibility issues with RA verification arise as no browsers natively support this feature, making prior solutions cumbersome and risky.

To address these challenges, in this talk, we present RA-WEBs (Remote Attestation for Web services), a novel RA protocol designed for high compatibility with the current web ecosystem. RA-WEBs leverages established web mechanisms for immediate deployability, enabling RA verification on existing browsers. We will show preliminary evaluation results and highlight open challenges when introducing RA to the web.

Rust's references adhere to a strict "one exclusive XOR many shared" model, which gives the language much of its greatest safety guarantees. Reborrowing is a feature that seems on surface to break this rule: An exclusive reference can be turned into shared references and those shared references can be used together with the exclusive reference as long as these are all used as if they were shared references. Only once the exclusive reference is used as exclusive, all the derived or "reborrowed" shared references are invalidated. The XOR rule is upheld, but in a way that breaks a literal reading of the rule.

Usually reborrowing is used temporarily but what if we make it our modus operandi? This talk explores using and slightly abusing reborrowing and comes out the other side with an awkward but functional safepoint garbage collector built upon reborrowing a ZST marker and a whole load of typed indexes. The garbage collector is part of the Nova JavaScript engine.

https://trynova.dev/

In this talk, we share our journey in making QuestDB, an Apache 2.0-licensed open-source time-series database, a significantly faster analytical database. Over the course of just one year, we achieved query performance gains of up to 6x by implementing specialised data structures, SIMD-based optimisations, scalable aggregation algorithms, and parallel execution pipelines.

QuestDB is designed for high-performance ingestion—processing millions of rows per second—and efficient queries over billions of rows. While it excelled in time-based queries, we found that certain generic analytical queries were slower than expected. In this session, we’ll walk through how we identified opportunities for improvement, the key changes we implemented, and how those changes delivered dramatic performance improvements in a relatively short timeframe.

We’ll demonstrate before-and-after queries to showcase the impact of these optimisations. All the code is freely available in QuestDB's GitHub repository for anyone to explore or contribute to.

Fuchsia is a new (non-Linux) operating system from Google, and one of the key pieces of Fuchsia's design is the component framework. Components on Fuchsia have many similarities with some of the container solutions on Linux (such as Docker): they both fetch content addressed blobs from the network, assemble those blobs into an isolated filesystem structure that holds all the dependencies necessary to run some piece of software, and launch namespaced processes with that created directory as its root.

The most interesting details are where these two projects diverge. Both have different use cases and requirements, which leads to different strengths between the systems. This talk will largely be focusing on where and why these two similar technologies diverge.

Relevant links: - Fuchsia's source code - Fuchsia's code review - Getting started page

NextGraph is an open source ecosystem providing solutions for end-users (a platform) and software developers (a framework), wishing to use or create decentralized apps featuring: live collaboration on rich-text and JSON documents, peer to peer communication with end-to-end encryption, offline-first, local-first, portable and interoperable data, total ownership of data and software, security and privacy.

Centered on repositories containing semantic data (RDF), rich text, and structured data formats like JSON, synced between peers belonging to permissioned groups of users, it offers strong eventual consistency, thanks to the use of CRDTs. Documents can be linked together, signed, shared securely, queried using the SPARQL language and organized into sites and containers.

Collabora Online (COOL) delivers collaborative document editing based on LibreOffice Technology to any modern browser. Come and hear about how we've been improving usability, deploy-ability, performance, feature-set and georgeousness of Collabora Online. See how COOL can be deployed and catch the excitement of making code simpler, faster and better for users at pace.

Finally hear how you can get involved with the fun.

LLVM libc has been steadily growing over the past few years. From its origins as an overlay to be used on top of an existing libc, LLVM libc is now complete enough and scalable enough to be used on embedded toolchains too.

This talk will contain: * LLVM libc's current status. * Why you might want to use LLVM libc. * How to build it for linux and an embedded system. * How to use a prebuilt example from LLVM Embedded Toolchain for Arm. * Other uses including the Google Pigweed SDK.

LLVM libc in llvm-project https://github.com/llvm/llvm-project/tree/main/libc

After looking at the current way Go code is packaged in nixpkgs using buildGoModule, disadvantages are pointed out with a focus on security (backed by data from govulncheck-nixpkgs project) and performance. Out-of-tree alternatives are presented with a focus on the new and promising approach of gobuild.nix, which implements a hook-based builder with module-level caching.

Flakes aka tests that don’t behave deterministically, i.e. they fail sometimes and pass sometimes, are an ever recurring problem in software development. This is especially the sad reality when running end-to-end tests where a lot of components are involved. There are various reasons why a test can be flaky, however the impact can be as fatal as CI being loaded beyond capacity causing overly long feedback cycles or even users losing trust in CI itself.

Ideally we want potential flakes to be flagged at the earliest stage of the development lifecycle, so that they do not even enter the end-to-end test suite. We want a gate that acts as a safeguard for developers, pointing out to them what kind of stability issues a test has. This reduces CI user frustration and improves trust in CI. At the same time it cuts down on unnecessary waste of CI system resources.

This talk will explore the CANNIER approach, which aims to reduce the time cost of rerunning tests. We will take a closer look at the feature set used to create training data from existing test code of the KubeVirt project, enabling us to predict probable flakiness of a certain test with an AI model.

We will cover how a subset of the CANNIER feature set is implemented, how it is used to generate training data for an AI model, and how the model is used to analyze flakiness probability, generating actionable feedback for test authors.

Attendees will gain insight on how the CANNIER approach can help them improve test reliability, ultimately enhancing overall software quality and team productivity.

Geospatial programming often requires stitching together a variety of formats, interfaces, APIs, libraries, tools and languages. How can we fluidly download data from OpenStreetMap using the Overpass Query Language, run performant queries with GEOS, calculate projections with PROJ, store and manipulate GeoJSON or WKT-formatted data with duckdb's spatial extention, and then visualize things with a javascript library like Leaflet or Deck.gl?

This talk explores Raku's expressive and powerful style as we mesh together all of these things, creating new modules along the way, and leapfrogging ahead of other implementations with some of Raku's unique features such as NativeCall for native libraries, Grammars for parsing, multiple modes of interacting with command line tooling, and plentiful concurrency models. Also let's see how we can reign in large language models so that we can apply them judiciously to our data and our code.

Links:

raku-geos, Geo::Basic, WebService::Overpass, Geo::Geometry, Duckie, WebService::Nominatum

The RISC-V ecosystem currently relies on multiple disconnected repositories and specifications, including the assembly manual, opcode database, formal specifications like Sail and the non-machine readable ISA manual. This fragmentation of information is error prone and makes it hard for hardware designers, researchers, and tool developers to efficiently find, modify, and verify essential data. To address these challenges, we introduce the RISC-V Unified Database (UDB), a single, machine-readable source that consolidates and cross-validates RISC-V specifications against established resources like binutils and riscv-opcodes. Built through collaboration between engineers at industry-leading companies, the UDB already generates version-specific ISA manuals, instruction indexes, and standardized opcode definitions. Ongoing work extends to generating simulator configurations for QEMU and other instruction set simulators. The UDB's YAML-based format ensures broad compatibility and positions it as a foundation for next-generation RISC-V tools. This approach is starting to gain traction with official RISC-V working groups, including the Certification Steering Committee, which already uses the UDB for generating certification requirements. This talk explores UDB’s architecture, showcases its use cases, and invites you to contribute to this transformative project for the RISC-V community.

The talk will introduce CartABl https://igarun.univ-nantes.io/CartABl/ , a free (GPL) web-based authoring tool for creating interactive maps and figures, and discuss its impact on user workflows and design decisions. Designed primarily for geographers and cartographers, CartABl also serves broader communities seeking to produce interactive cartographic content. It addresses the technical barrier that coding poses to creating interactive cartographic content (using js) through a graphical interface for defining interactions. It integrates seamlessly with traditional workflows by enhancing maps created in vector graphics editors like Inkscape or Adobe Illustrator with interactivity, without requiring programming knowledge. CartABl leverages SVG (Scalable Vector Graphics) as its base format, embedding interactive rules as declarative elements interpreted by a lightweight JavaScript runtime. This results in standalone, browser-compatible interactive SVG files, preserving the scalability and versatility of the format.

The development of CartABl follows an instrumental genesis approach, where tool and user co-evolve through iterative feedback. Initial prototypes allowed basic interactivity like tooltips and layer toggling. Feedback from its application in projects such as L’Atlas Bleu, a journal focused on coastal and marine maps, guides its refinement. This iterative process not only improves the tool but also influences how cartographers structure and design their graphical maps and figures: the structure of the graphical objects must be adapted to facilitate the definition of interaction rules, and the interactive features proposed by the tool impact the design decisions of the users.

CartABl aims to democratize interactive cartography, making it accessible and intuitive for professionals and non-experts alike. By transforming workflows and expanding the possibilities of digital cartographic publishing, it stands out as a valuable resource for advancing geographic and graphic research and communication.

XWiki is a wiki engine, and, as with most wiki engines, it allows uploading attachments to wiki pages. In order to edit these attachments quickly, we recently released an extension allowing to link an XWiki instance with a COOL server, and thus enabling real-time collaboration office files attached to wiki pages.

This presentation will focus on the technical integration of COOL with XWiki, and will discuss use-cases that we identified over the years, as well as the roadmap for this extension. The application code can be found at https://github.com/xwikisas/application-collabora

There have been a lot of talks in the past years about how to present Linux/Posix semantics over the SMB3.11 protocol to provide an alternative to the NFS protocol for installations that already have existing SMB infrastructure and who could benefit from better semantics when sharing files to Linux and other Posix-based file server clients.

In the past few months there has been a great deal of progress in Samba towards the goal of better supporting Linux clients. Notable changes are improvements to present special files like sockets and FIFO files to clients. There has been improvements to better support operations like chmod and chown in the Linux client and the Samba server.

The biggest change on the Samba side has been an overhaul of handling native symlinks. Samba 4.22 will present symlinks for Posix clients in the same way Windows presents symlinks it finds on its local NTFS file system.

This talk will present the current status of the ongoing work to improve Linux file system semantics presented over the SMB protocol.

In 2024, I worked with a small team to bring up BlueZ as the Bluetooth stack of a real-world automotive In-Vehicle Infotainment (IVI) system. In this talk, I am going to discuss the steps that we went through, the challenges that we faced, the caveats of BlueZ in contrast with closed-source alternatives and also present the contributions that we made to BlueZ and PipeWire as part of this process.

To ease the pain of testing container images, we’ve developed the pytest_container plugin for pytest. The plugin makes it possible to use pytest to perform tests on containers and software inside containers. You don’t have to take care of pulling images, building them, or picking ports on the host. You just describe your container setup and pass it to a test function. In return, the plugin gives you a connection to the container. Using the connection, you can verify the container’s state using the testinfra python framework. The plugin even cleans up after itself when you’re done.

In short, pytest_container makes it possible to write tests in Python: no need to build your own framework from scratch or worry about the boring container plumbing tasks.

Join this talk to see pytest_container in action and learn how it can make your life easier!

TrenchBoot is an open source project led by 3mdeb, Apertus Solutions, and Oracle. It aims at the security and integrity of the boot process by leveraging advanced silicon security features, like Intel Trusted Execution Technology (TXT) and AMD Secure Startup. It integrates with open source projects like GRUB2, Xen, and Linux, to perform a measured launch of the operating system software, also called Dynamic Root of Trust for Measurement (DRTM).

The presentation will provide an overview of the project's current status, emphasizing the key developments during the last year such as progress towards upstreaming patches in Linux and GRUB, as well as bringing UEFI support for Xen boot path.

This talk looks deeper at class metadata storage in the Hotspot JVM and the changes JEP 450 "Compact Object Headers" brought. We will examine the mechanics and CPU cache effects of oop iteration and propose a more cache-friendly solution. We will investigate the class storage limits and possible ways to circumvent them. Finally, we will examine an alternative to the current class space solution.

A disk full, a saturated or lossy network, too-few CPU cores, an unexpected IO error… how will your software handle such scenarios?

In this talk we present a collection of tools that can be used to systematically "break" things, so you can write test cases and make sure that these unexpected situations will be handled gracefully by your software: ToxiProxy, charybdefs, tc qdisc, strace --inject, taskset, numactl, cgroups and syscall overloading, all can be used to emulate a wide array of failures.

Securing embedded devices, particularly those with minimal resources, presents a unique and pressing challenge. Conventional approaches to Trusted Execution Environments (TEEs) often require specialized hardware or substantial system resources, leaving low-end devices vulnerable to breaches. The need for a lightweight, efficient solution that bridges this gap is greater than ever in today’s interconnected world.

Introducing Spock

Through the development of Spock, we have created a versatile and efficient Trusted Execution Environment (TEE) tailored for RISC-V embedded devices. By relying solely on Physical Memory Protection (PMP) for isolation and requiring only machine and user modes as specified in the RISC-V privileged instruction set, Spock delivers robust security without relying on any specialized hardware.

At the core of Spock’s architecture is the Security Manager (SM), which plays a key role in managing enclave data and buffer permissions. The SM enables Spock to efficiently virtualize buffers and dynamically allocate PMP entries, providing a flexible and scalable approach to memory isolation. By leveraging this abstraction, Spock can create virtual enclaves that surpass hardware-imposed limitations, such as the number of PMP entries.

Core Features and Capabilities

Spock’s minimalist API design delivers essential security functions, including secure execution and attestation. This design supports:

• Virtualization of critical operations while maintaining a minimal Trusted Computing Base (TCB).
• Integration into very low resource embedded devices.
• Both relocatable and fixed enclaves, offering flexibility for diverse use cases.

Why Spock Matters

Spock’s design represents a modern, efficient solution for secure computing in low-resource embedded devices. Its ability to combine robust security with minimal hardware requirements makes it uniquely suited for the demands of today’s connected world, ensuring that even the smallest devices can operate securely.

Available at : https://github.com/jiphelsen/Spock

How we work together and bring Collabora Online integration in Nextcloud to the next level with file conversion, document transformation and AI.