In an increasingly connected world, securing wireless communication is vital for protecting critical infrastructure and personal data. Traditional tools for Radio Frequency (RF) assessments, while effective, often lack flexibility, cross-platform compatibility, and adaptability for diverse environments and architectures. RF Swift addresses these limitations by providing a streamlined, modular toolbox tailored for RF Security assessments and HAM radio enthusiasts alike.

RF Swift is a multiplatform solution, seamlessly running on Windows, Linux, and a wide range of architectures. This versatility empowers users to conduct RF assessments in virtually any environment without hardware constraints. Designed with adaptability in mind, RF Swift enables security professionals and radio enthusiasts to deploy, manage, and analyze RF communications with unprecedented speed and efficiency.

Attendees will discover how RF Swift empowers both rapid assessments and deep analysis, simplifying complex tasks such as spectrum monitoring, signal detection, protocol analysis, and signal generation. Join us to explore how RF Swift redefines RF security assessment, offering a robust, scalable, and flexible approach to tackle modern wireless security challenges.

The European regulations impose strict rules on the collection and use of data via cookies and other trackers on websites. Auditing the practices of these sites is crucial to ensure that the cookies placed, both before and after user consent, comply with current legal obligations. This includes the purpose of the cookies and the transparency of the information provided to users, such as cookie descriptions and an easily accessible refusal option.

Although various website analysis tools exist, their use often requires advanced technical expertise, as they typically operate via command-line interfaces. In this context, the EDPB, through the Support Pool of Experts (SPE), has developed a dedicated audit tool to assess websites' compliance with European regulatory requirements.

The tool is a Free and Open Source Software under the EUPL 1.2 Licence and is available for download on code.europa.eu. The source code is available here.

Dr. Jérôme Gorin, the creator of this tool, will present its functionality and its adoption by numerous auditors within data protection authorities across Europe. The presentation will conclude with a discussion on the tool's improvement prospects, aiming to foster knowledge sharing and the detection of the latest online tracking technologies.

Unleashing the power of 3D graphics on the Raspberry Pi is an ongoing effort at Igalia. We are constantly exploring new opportunities to maximize the GPU's potential. The process of identifying applications that can be optimized is highly rewarding. Every so often, we uncover a breakthrough, enabling us to boost application performance up to ~70%.

The graphics stack for the Raspberry Pi 4 and 5 is built on the Mesa user-space drivers (V3D/V3DV) and the Linux kernel driver V3D. These drivers are fully mature, with the upstream Mesa Vulkan driver V3DV having already achieved Vulkan 1.3 conformance, and the OpenGL/ES driver V3D exposing desktop OpenGL 3.1.

However, just having working, conformant drivers isn't enough for us. In this talk, we will demonstrate how we go the extra mile to extract the maximum performance from the Raspberry Pi's GPU, proving that a more performant embedded GPU is possible.

In addition to explaining where we currently stand, we will showcase several cases where optimizations in the Mesa user-space drivers led to significant performance improvements. We will also review recent developments in the kernel driver, including support for Huge Pages in the GPU kernel driver and our experience using Transparent Huge Pages (THP) on an embedded device.

By the end of this talk, we hope the audience will have a better understanding of the graphics stack for embedded GPUs and how to start getting more juice out of an embedded board.

One of the interesting things about Collabora is the extremely powerful LibreOffice core it is built on. Come and hear how we've been working hard to expose even more powerful browser-based collaborative functionality from it.

Hear about our new WebGL transitions, Automatic Document generation from documents + JSON, as well as exposing much of the power of our core functionality from fonts and AutoText to more powerul configuration options.

Finally have a quick summary of UI wins and other recent improvements, as well as how to get involved.

ssh (secure shell) is a popular protocol used for remote command-line connections and file transfers.

sshproxy is more than a simple ssh proxy/load balancer. It can choose the destination node based on simple or complex rules, such as the user name/group, its previous connections, the number of total connections on the nodes, the total used bandwidth of the nodes… It can be distributed on multiple gateways, with shared states. It can track, log and monitor all the connections.

At CEA (French Alternative Energies and Atomic Energy Commission), sshproxy allows users to connect to 4 different supercomputers, with regularly more than 1,000 simultaneous connections.

My talk will introduce you to TLSRPT and it will show you how to configure Postfix to send TLSRPT datagrams to a TLSRPT report service. TLSRPT is to TLS security what DMARC is to anti-phishing: it allows you not only to establish standards like STARTTLS, MTA-STS or DANE for secure message transport, but to verify via reports those security levels are being uphold.

It allows a sender platform to inform receiving platforms how often a TLS connection from the sender to the recipient had been successful and if not why. It is a major improvement over self-monitoring your MTA service, because it creates - in contrast to self-monitoring - a world-wide view how others „see“ your platform. It allows e.g. to make areas in the network visible, where TLS fails, to investigate and ideally to fix the problem in order to keep communication secure.

Previously the capability to create and send TLSRPT reports had been limited to a few major platforms running their own or a commercial MTA. This will change early 2025. The Postfix MTA will be the first Open Source MTA to implement functionality that permits to send TLSRPT-relevant DATA to a TLSRPT report service. The service will collect the DATA, create a report and pass it on to an MTA for delivery or submit it directly via HTTP.

Postfix’ new feature is the result of a collaborative effort between Wietse Venema, the creator of Postfix, and my company sys4 as we want to foster TLSRPT (also because it hinders German providers to qualify to become BSI approved „Secure E-Mail Platforms“).

We created an Open Source low-level C-library that can be used by any MTA - not only Postfix - and the service required to create TLSRPT reports. Both can be downloaded at github. And we hope many other Open Source projects will use the library and the service to implement TLSRPT reporting in their MTA.

The Tillitis TKey is a radical new open source and open hardware FPGA-based general computer in the form factor of a USB security token. Due to the mandatory measurement of apps it generates secret material on demand, with no persistance, based on the integrity of the app and provides a secure environment to do sensitive computing like, for instance, cryptographic signing, authentication, and similar uses.

In the talk I will present how the TKey works, especially with the killer app SSH, how it came about, and touch on how you develop apps for it, the tools available, and welcome you to join the open source projects behind it. With a small, dedicated team you can get a lot of things done, even with hardware designs using FPGAs and your own design of PCBs.

This talk introduces Apache Arrow's tensor arrays as a tool for representing an array of tensors in memory, their storage and transportation. We'll introduce the tensor array memory layout specification, its implementation in Arrow C++ and Python, showcasing how it can help interoperate with PyData and database ecosystems.

We'll present the fixed and variable shape tensor array specifications, their implementations and how they can be used to interoperate with Arrow aware ecosystem such as DLPack, NumPy, and others. Further we'll discuss design decisions we made to make the two tensor arrays as generic and universal as possible.

Katzenpost is a robust privacy software project. It includes a mix network implementation with a powerful, realistic threat model, hybrid post-quantum cryptography libraries, messaging protocols and metadata-private networking - all implemented in Go and under an AGPLv3 license.

The purpose of this talk is to go over all of these elements and explain how they may be implemented in other software projects, rather than explain the high level design of the mix-net in detail. The Katzenpost code can be found at [the project's GitHub](https://github.com/katzenpost).

When it comes to the on-disk-size of your OpenJDK installation it becomes apparent that certain files take up a large part of the entire Java Development Kit (JDK) installation. It can seem that certain files are monolithic and aren't possible to make smaller. Yet, they can be smaller if you know how.

In this talk we show how you can create a custom run-time image for your specific application without the need of the jmods folder otherwise being present in a standard JDK. Forget about JRE and go all-in on custom run-time images. The best thing about it is that - due to JEP 493 - this will no longer need JMOD files of the JDK to be present.

Tune in to hear more about using jlink from a JDK without a jmods directory and what new opportunities this allows.

An introduction on the basic concepts underpinning a container manager: understanding what OCI images are, how they’re structured, and how to use them as rootfs. From there, we’ll dive into the core Linux primitives that make rootless containers possible: namespaces for isolation, UID/GID mappings and dropping privileges.

The talk will use my project Lilipod https://github.com/89luca89/lilipod as an example on what and how all of this has been implemented

Designed to cater to a wide range of peripheral devices and platforms, Analog Devices' Kuiper Linux distribution is built with more than 1000 Linux device drivers compatible with Xilinx and Intel FPGAs, Raspberry Pi boards, and several other platforms.

To ensure its quality, a test harness infrastructure must be in place to carry out continuous testing on actual hardware. This talk covers the design and implementation of such a fully automated test harness. The implemented architecture leverages the use of readily available components/technologies such as Jenkins, Docker, NetBox, and JFrog Artifactory and, at the same time, includes custom-built tools that can be tailored and extended to support existing or new devices and platform types.

By using an advanced resource locking mechanism, the hardware setups are also remotely available to others for development and debugging, when there are no automated tests running.

Picture this: an open source digital democracy platform, launched by a city government, that quickly outgrows its municipal roots and becomes a global movement. Decidim started in 2016 as a tool for participatory processes in Barcelona, but its community expanded worldwide, with users in diverse cultural and political contexts. How do you scale such a project while preserving its democratic integrity?

In this session, we’ll dive into Decidim’s evolution, focusing on the governance challenges and triumphs of managing a rapidly growing, decentralized community. We’ll explore how Metadecidim—our "eat your own dog food" instance—facilitated this transition, enabling collaborative decision-making through open assemblies and processes. We’ll also discuss how Decidim’s unique social contract ensures transparency and accountability in everything from feature development to project governance.

This session is for you if you’re interested in the nuts and bolts of scaling participatory governance of free software projects.

Open-source software has been a powerful catalyst for innovation in computer and software engineering, driving significant advancements in healthcare, particularly in medical and surgical technologies. Recently, the open-source movement has expanded beyond software, encompassing the release of code, data, and AI models, further accelerating progress across diverse fields. However, in healthcare, open-sourcing faces distinct challenges, including navigating regulatory hurdles to meet industry standards, ensuring robust patient data protection, managing the costs of specialised hardware and software maintenance, and addressing the limited availability of expert clinicians needed to annotate, test, and validate AI innovations. In this talk, Miguel will explore how open-source technologies are advancing healthcare, with a focus on medical and surgical innovations. He will highlight key advancements while exploring the complexities of clinical translation, using three of his projects as examples: Fetal Ultrasound Image Synthesis, endoscopy-based video analysis for surgery, and real-time AI diagnosis of eye movement disorders. The talk will examine the challenges of clinical translation and showcase examples of innovative technologies that leverage open-source software, models, and data to address some of the most complex problems in healthcare. Finally, to inspire and spark innovation among the next generation of engineers, researchers, and clinicians from academia and industry, this talk will showcase how the emerging open-source software community for surgical and medical technologies is striving to: (a) Foster Collaboration and Community Building, (b) Enhance Security and Transparency, (c) Promote Customisation and Flexibility, (d) Ensure Cost-Effectiveness, Sustainability, and Scalability, and (e) Drive Rapid Innovation and Future-Proofing.

AI is everywhere and especially open source is accelerating capabilities and delivering new breakthroughs in Models, making them smaller yet more powerful. While there is a big focus on the next big thing in Software, many overlook the goldrush in Hardware. You may have heard of companies like Nvidia, AMD or Axelera.AI, they are some of the ones selling the shovels to the diggers for a great profit margin. Have you ever wondered what it take to make your own chip?  So how to get started on your AI startup? The good news is: there is RISC-V, an open standard for CPUs, so everyone cam implement their own CPU and use common library software (in theory).  The even better news is there is an non profit open source organization called OpenHW Foundation offering high quality Apache 2.0 (or Solderpad) CPU Cores you can take as is, modify as needed and collaborate with a big community. Even better, the OpenHW Foundation is offering small platforms to debug on FPGA's but also has QEMU support and various other Models for example system Verilog cycle accurate SystemC Models. On top of this we also provide the Software eco system you need to brign your chip up and running quickly and sell it to one of the big Datacenter Companies, or just keep it running in your basement, heating your house and providing awesome AI edge capabilities for you and your family! In this talk Flo will highlight the current trends in chip development and how open source is accelerating this from the Cores to the EDA tools for designing but also open source tapeouts and then focus a little more on some of the Cores in OpenWH and how you can utilize it. Dr Jeremy Bennett world famous for his 45min overviews on "how to get GNU GCC ported on a totally new Architecture" is joining to deliver an overview which Software you need to run on your Chip, to develop your Chip and why it is easy with the OpenHW Group. Last but not least we will spill the beans on how the European Union is supportign our work as a non profit (and also for profits in that context) to guarantee sovereignty and enable academic but also research and industrial to build and innovate on a common platform via the Chips JU and programs like TRISTAN and how you can benefit, no matter if you quickly develop a MCU in your Master, need to do some measurements on real RISC-V Cores for your PhD and prove how to boost performance or if you join the real business selling shovels to all the diggers. Believe us, this talk will be a wild ride deep into the Hardware realm of RISC-V and OpenHW and make you start your own Chip while you are still listening!

Longhorn is an open-source, Cloud-native volume manager, which implements its own distributed block storage system. It is a complete and independent software defined storage solution, handling internally all aspects related to capacity management, performance, fault-tolerance, as well as interfacing with both Kubernetes and the end user. Longhorn is an actively-developed and mature software, however our installations have revealed that it currently lacks the ability to take advantage of the hardware performance available in local servers that feature high-speed solid state disks and high-bandwidth network connectivity. This presentation investigates a series of performance optimizations that have been engineered in the Longhorn's core that collectively allow the system to achieve an order of magnitude better IOPS and bandwidth.

This is a story of how I used a few readily-available Open Source tools to achieve huge optimizations in zbus, a pure Rust D-Bus library. This was long journey but gains were worth the efforts. I will go through each single bottleneck found, how it was found and why it was a bottleneck and how it was optimized away.

While attending this talk will by no means make you an expert in optimizations, it is my hope that by you will be able to relate to some of bottlenecks or solutions I will present ("hey", I also do that in my code!") and learn from my experience. Maybe afterwards, you can suggest an even better solution? Moreover, if you don't already have any experience with profiling and optimizations, this talk should be a good introduction for that.

Closing notes and information about pPub (physical Pub) meetup.

JSON has become the lingua franca for handling semi-structured and unstructured data in modern data systems. Whether it’s in logging and observability scenarios, real-time data streaming, mobile app storage, or machine learning pipelines, JSON’s flexible structure makes it the go-to format for capturing and transmitting data across distributed systems.

At ClickHouse, we’ve long recognized the importance of seamless JSON support. But as simple as JSON seems, leveraging it effectively at scale presents unique challenges. In this talk we will discuss how we built a new powerful JSON data type for ClickHouse with true column-oriented storage, support for dynamically changing data structure and ability to query individual JSON paths really fast.

ClickHouse open-source project: https://github.com/ClickHouse/ClickHouse Links related to the topic: https://github.com/ClickHouse/ClickHouse/issues/54864, https://github.com/ClickHouse/ClickHouse/pull/58047, https://github.com/ClickHouse/ClickHouse/pull/63058, https://github.com/ClickHouse/ClickHouse/pull/66444.

We present LoRaMesher, a communication library to build LoRa mesh networks. LoRaMesher interconnects geographically spread IoT devices through a LoRa mesh network. For the communication, the library implements a proactive distance vector routing protocol. Using LoRaMesher, an IoT application running on a node can send and receive data packets to and from other nodes in the LoRa mesh network. LoRaMesher has been tested on embedded boards featuring an ESP32 microcontroller and a LoRa radio. Using LoRaMesher, nodes do not connect to a LoRaWAN gateway, but among themselves. This allows new, distributed applications solely built upon tiny IoT nodes.

This is not on behalf of a specific community, only my direct experience with Ubuntu Touch, libhybris and Halium.

SailfishOS, Ubuntu Touch, Droidian. Many options exist for running a GNU/Linux environment on an off-the-shelf mobile phone. But what makes these different from an application developer’s perspective for a smartphone OS built with libhybris drivers?

Let’s find out.

The Digital Markets Act mandates that mobile gatekeepers open their device operating systems to competing app stores. This affects the landscape of app distribution on iOS and Android and has brought about a variety of different compliance efforts, most of which have been found lacking by regulators thus far. The law is important for Free Software, as its obligations grant smaller Free Software projects the rights to demand access to gatekeepers' infrastructure like enabling alternative app store, sideloading and un-installation of software and interoperability with operating systems.

This talk will outline the current state of compliance efforts on the part of Apple and iOS, the primary areas where they are deemed insufficient, and how they effectively block any marketplace from emerging as a viable source of FOSS software distribution for the iPhone and iPad. Financial preconditions, ongoing fees, enforced DRM, centralized notarization app review, and other factors all conspire together to maintain the status quo of monopolistic control over the app marketplace on these devices.

The App Fair Project (appfair.org) is a non-profit charity with the mission of creating an app marketplace for the distribution of digital public goods in the form of free and open-source mobile applications. We have been active in the various workshops and working groups that have examined the DMA compliance efforts on the part of the mobile OS gatekeepers, and have provided technical advice and expertise to groups such as the Free Software Foundation Europe (FSFE) and the NGI TALER project.

The GPIO sysfs interface for user space has been deprecated for many years. Its alternative, the GPIO character device and the associated libgpiod project, has been available since 2017. The library, along with its numerous bindings, has become the de facto standard tool for interacting with GPIOs from user space. Recently, it was supplemented by a D-Bus API and a reference implementation, addressing the long-standing issue of maintaining GPIO state persistence across different processes.

The sysfs interface is the primary user of the global GPIO number space in the kernel. Unlike other legacy components of the GPIO codebase, we cannot remove it without user space agreeing to stop using it. However, there remains a group of users who, for various reasons, refuse to migrate to the new uAPI. It has become evident that, without providing them with a 100% compatible experience, we will be stuck with the old interface indefinitely.

To address this, the latest addition to the family of user-space GPIO utilities is gpiod-sysfs-proxy[1] - a libfuse-based user-space compatibility layer for the GPIO sysfs interface under /sys/class/gpio, using libgpiod to talk to the kernel.

This talk will cover why we aim to remove /sys/class/gpio (along with the in-kernel legacy APIs), progress made so far, an introduction to gpiod-sysfs-proxy and the libgpiod D-Bus API, and a discussion of future plans.

[1] https://github.com/brgl/gpiod-sysfs-proxy

Join us for a comprehensive review of the newest features and innovations in OpenProject, developed over the past year. This session will explore key updates, including enhancements to project portfolio management, deeper integration with the openDesk application bundle, and the exciting progress of a mobile app spike. Discover how these developments empower teams to collaborate more effectively, manage projects with greater precision, and streamline workflows. Whether you’re a long-time user or new to OpenProject, this talk will offer valuable insights into how the platform continues to evolve and create value.

Historically, Firefox has relied on the getaddrinfo API for DNS resolution on most platforms. However, due to inherent limitations — such as the missing Time-To-Live (TTL) information — we sometimes had to resort to alternative APIs like DNSQuery_A on Windows. When implementing DNS over HTTPS (DoH), we developed our own DNS parser, which allowed Firefox to also resolve TXT and HTTPS records. But DoH isn't available to all our users. With HTTPS records becoming increasingly important, we decided to resolve HTTPS queries using system APIs like DNSQuery_A, res_query, res_nquery, and android_res_query, with the expectation that this would cover all supported platforms. This talk will delve into the lessons learned from this journey and explain why these platform specific APIs often fall short of expectations.

Welcome to the GCC (GNU Toolchain) devroom from the organizers.

The OpenSIPS Community Editions are the community effort to produce real-life SIP solutions (as platforms) already configured to fulfill precise SIP scenarios. OpenSIPS based solutions – acting as SoftSwitch or SBC – that are ready to use and simple to deploy.

This presentation offers a detailed look at the OpenSIPS Community Edition projects, exploring their capabilities, current status, and development roadmaps. It delves into the innovative ideas driving these projects and emphasizes the critical role of the open-source community in their evolution. To conclude, a brief showcase using Docker Compose will effectively demonstrate the practical utility of the OpenSIPS Community Edition projects.

eBPF is a big and complicated topic. For years it was common that the people using and writing eBPF programs were also the people involved in the development of eBPF. Those days are somewhat behind us now, eBPF is more popular than ever, and the number of non-kernel experts wanting to use eBPF is growing rapidly.

A lot of new people means a lot of learning to be done. There is a small but strong community of people to talk to, if you know how to find them. The internet is full of outdated articles that have aged like milk. The kernel has docs for a handful of subjects and man pages that are correct for some kernel versions but not others.

I started the eBPF docs project about two years ago out of frustration for the lack of comprehensive documentation. These docs are now hosted at docs.ebpf.io. Lets take a look at the state of these docs, what it took to get here and where they are going next.

Swift isn’t just for Apple platforms; there is something for all in this great open source general purpose programming language.

In this community welcome message, Paris Pittman, a member of the Swift Core Team, will provide an ecosystem overview. We’ll touch on milestones that we’ve achieved together and some of the up and coming work on our plates. And the best part - you can join us in the journey! Paris will detail out how you can plug in, no matter your platform of choice.

In recent years DMARC has become one of the cornerstones of email deliverability. A large part of email is now protected by the combined efforts of SPF, DKIM and DMARC checks. However, the secret weapons of DMARC which are hardly used are its reports. Along with respecting the policy set by an email sender, the recipient also actively acknowledges how many emails have been sent, from which IP addresses and why some of them have been delivered and others not. This reporting is done by providing a xml file inside a zip attached to an email, which makes it rather hard to digest for humans. Imagine what happens if you get such a report every day for every internet domain you, all of your colleagues and anybody spoofing you send emails to...

Obviously this calls for a tool. Interestingly, even though DMARC is almost a decade old, no good FOSS tool was ever developed. This is why DMARCaroni was created: free and open source software (written in Haskell and Elm) to deliver all your DMARC monitoring needs. In this talk I will unveil this new tool which I wrote in the last 18 months, show off its features, and talk about the roadmap.

Welcome session for the Cloud Native Databases devroom

A five minute introduction to the dev room.

This talk will serve as a welcome and introduction to the Microkernel and Component-Based OS devroom. We will quickly go over the rules and expectations of the devroom, as well as introducing you to the devroom managers and answering general questions.

JRuby has been one of the largest consumers of invokeddynamic and method handles since they were introduced in Java 7. With the release of JRuby 10, we have upgraded our minimum Java to 21, and implemented many new optimizations. This talk will survey how JRuby uses invoke dynamic to compile and optimize Ruby code on the JVM.

Modern, distributed systems are complex and present numerous challenges: concurrency, process crashes, message loss, duplication, or reordering.

How can developers confidently test distributed systems instead of continuously dreading the next hard-to-catch and hard-to-reproduce Heisenbug?

Deterministic Simulation Testing is a powerful testing technique that eliminates uncertainty－or rather non-determinism－and ensures that your system is tested exhaustively and every single test is reproducible.

Using a systems modeling approach, we will accurately and concisely discuss Deterministic Simulation Testing. In addition, we will explore real-world implementation of this technique in production in projects such as FoundationDB, TigerBeetle, and Resonate.

Gain actionable insights for crafting your own Deterministic Simulation Testing strategy. Confidently open Schrödinger's Box of testing in distributed systems.

This presentation introduces Active Tigger, an open-source research tool designed to accelerate collaborative text annotation in the social sciences.

The increasing use of text-as-data in social science research has created a pressing need for efficient annotation tools. While small datasets can be manually annotated, the exponential growth in available textual data (e.g., from newspapers and social media) demands solutions that enable collaborative annotation and automation. Moreover, the emergence of generative AI and large language models (LLMs) has highlighted the importance of robust corpus annotation practices, particularly for evaluating prompt-engineered outputs from LLM-as-a-service platforms like OpenAI or Hugging Face.

To address these challenges, we created an annotation platform, Active Tigger. A first version was developed in 2022 using R and RShiny (J. Boelaert, GitLab Repository). This tool embeds several annotation heuristics, including active learning—iteratively predicting and selecting annotations to maximize training quality—to help researchers build training datasets in order to fine-tuning encoder models. The tool quickly became integral to the research team's activities and beyond, which incited us to develop of a second, more robust version.

The current iteration of Active Tigger, built with a Python-based API and a React frontend, introduces enhanced flexibility and scalability. It supports collaborative workflows, accommodates a broader range of use cases, and is now in beta testing, with early adopters exploring its potential.

This presentation will cover three key aspects:

The journey of Active Tigger: From addressing specific social science needs to adapting to the evolving landscape of LLMs. Showcase: Demonstrating the annotation workflow using active learning and BERT fine-tuning. Future directions: Exploring the tool's evolution in the context of widespread LLM availability, discussing the trade-offs between focusing on specialized tasks and enabling broader applications.

Github repository of Active Tigger : https://github.com/emilienschultz/activetigger

The basic foundations of the HelenOS project as we know it today have been laid in late 2004 and early 2005. This 20th anniversary is an opportunity not only for the usual status update talk about the recent developments and near future plans, but also a great opportunity to look at the bigger picture.

While the first 5 years of HelenOS were exploratory and the next 10 years were defined by dynamic expansion on all fronts by more than 80 individual contributors, the last 5 years could be fairly described as maintenance with much less activity.

HelenOS is alive and well, but there are no longer any low-hanging fruits in terms of major subsystems or frameworks missing. There is obviously still a sheer amount of individual hardware devices, file systems, standard APIs and polished features that could be supported or implemented, but that is clearly a less rewarding endeavor for potential contributors than working on the major building blocks like before.

Are there generic lessons to be learned from the story of HelenOS? Is every community-driven non-mainstream OS destined to end up in this "serene valley"? How do we plan to get out of it? The goal of this talk is to discuss these questions.

You can run anything on open source software, even a big conference. But have you ever tried running a theatre show with free and open software? Turns out you can. For the last five years, I have been running the technical side of a local theatre company with only free and open source software. Come to my talk to hear how we did it, what software we use(d) (and why), and what kind of bumps we hit.

We use open source software for the entire process, from preparation (writing the script, holding meetings), to ticket sales, our website, seat planning, audio mixing and broadcasting, video broadcasting and programming the lights. No closed source software is used in the process. An added challenge is that neither the theatre group, nor the public, are a technical audience or are aware what open source software is.

If you ever want to assist your local theatre group (do, they really can use technical people who don’t want to be on stage), come and listen!

Internet of Things (IoT) connects everyday devices, from sensors to smart home gadgets, with apps that control and monitor them. Building these systems requires programming languages that can work seamlessly across both embedded devices and applications. Swift has been great with C and C++ interoperability, but the introduction of Embedded Swift has brought this to a new level.

With Swift, we can now program embedded systems with low-power sensors and small memory footprints, while also taking advantage of Swift’s simplicity and safety to create interfaces that integrate seamlessly with high-level UI code.

This talk explores why Swift is the next big thing for IoT, demonstrating how it bridges the gap between embedded systems and user-interfacing Swift apps. You’ll learn why Swift’s expressive syntax, interoperability, and cross-platform capabilities simplify development for IoT.