FOSDEM 2026 will take place on January 31-February 1, with thousands of developers meeting in Brussels to discuss open-source software & hardware projects. The free-to-attend “Free and Open Source Software Developers’ European Meeting” gets more traction every year, and in 2026, there will be at least 1,113 speakers, 1,016 events, 70 tracks, and potentially close to 10,000 attendees.

As usual, I’ll create a virtual schedule with sessions most relevant to the topics covered on CNX Software from the “Embedded, Mobile and Automotive” and “Open Hardware and CAD/CAM” devrooms, but also other devrooms, including “RISC-V”, “Robotics and simulation”, and “FOSS on Mobile”, among others. I’m aware some of the talks overlap by a couple of minutes or so…

FOSDEM 2026 Day 1 – Saturday, January 31

• 10:40 – 11:15 – RISC-V Vector optimisations in FFmpeg by Rémi Denis-Courmont

FFmpeg is the most versatile multimedia codec and format support library, and was one of the first open-source projects to include some RISC-V-specific optimisations, though there is still a long way to go. The RISC-V Vector extension was also the first scalable vector extension to be supported. We will cover the background, challenges, and outcomes of this effort.

• 11:30- 11:45 – Akkudoktor-EOS – Build optimized energy management plans for your home automation by Bobby Nölte

Akkudoktor-EOS (Energy Optimization System) is an open-source platform designed to generate highly optimized energy management plans for home energy management systems. Initially developed by Dr. Andreas Schmitz (“Akkudoktor”), EOS has been publicly available for just over a year and has already built a community of users who integrate it into their home automation environments.

At its core, EOS is a self-hosted server that calculates optimal schedules for batteries, electric vehicles, and household devices. These plans are derived from user configuration, real measurement data, and automatically retrieved or self-generated forecasts. EOS focuses on long-term optimization over a day or longer. The home automation system manages short-term control. Together, they combine strategic planning with real-time execution, delivering the best of both worlds in home energy management.

Common applications include optimizing consumption under dynamic electricity tariffs, ensuring cost-efficient EV charging, shifting flexible loads to cheaper periods, and connecting seamlessly with systems such as Home Assistant or NodeRED.

EOS stands out through its genetic algorithm, enabling optimization of any behavior that can be simulated—without the limitations of linear or convex models. Non-linear battery degradation, grid-stress signals, comfort models, or heat pumps with non-linear COP fields can be used directly, without artificial simplification. This makes EOS highly modular and flexible, allowing new components or physical models to be added and immediately included in the optimization.

• 11:40 – 12:10 – f8 – an architecture for small embedded systems by Philipp K. Krause

The f8 is an architecture for small embedded systems optimized for memory efficiency, regarding both code and data memory. We present the current state of the architecture (including the f8l variant for reduced core area), reference implementation, and the toolchain, which is based on the Small Device C Compiler (SDCC).

• 12:35 – 13:20 – A Core Developer’s insights on Gazebo’s Future by Jose Luis Rivero

More than two decades have passed since the first steps of the Gazebo simulator, one of the early attempts to provide a fully-featured 3D environment for robotics simulation. Rewritten into modular libraries, the new Gazebo preserved most of the internals from the previous era, even if new features have been added continuously.

In the meantime, especially in the last 5 years, the field of robotics simulation has experienced a rapid transformation. A new generation of simulators has emerged (Isaac Sim, O3DE, Carla, etc.), showing powerful rendering capabilities and advanced physics engines, supported by GPU acceleration to enhance realism and performance. These developments have not only changed the landscape of simulation but have also created new opportunities for integrating AI, machine learning, and robotics in more complex and scalable virtual environments.

Are there any plans to push Gazebo into modern features? The talk will provide information directly from one of the members of the Gazebo core team about existing roadmaps, funded projects, proof of concepts, and any internal discussions on what could come for Gazebo in the future.

• 13:20 – 13:55 – Writing a network-capable BootROM for RISC-V prototype bring-up by Nick Kossifidis and Antony Chazapis

In this talk, I’ll present the pain and joy of working on a BootROM we use for booting our RISC-V SoC prototypes in the lab, with networking capabilities. First, I’ll give an overview of what writing bare metal code looks like, the challenges one has to deal with, and how we solved them in a prototype-independent way. Then I’ll present netboot as an example use case, give an idea of the constraints we had to deal with and where they came from, why such a thing is a requirement when working with SoC prototypes (or even in production), how I did it, and finally do a live demo if time permits.

• 14:00 – 14:35 – Upstream Embedded Linux on RISC-V SBCs: The Past, Present, and Future by Marcel Ziswiler

Last year, I gave a talk about running upstream embedded Linux on RISC-V with the powerful SpacemiT K1-based Banana Pi BPI-F3 as an example. Fast forward one year, and we have many a new contender on the block. This talk first revisits the BPI-F3, looking at the upstreaming progress made and issues remaining. Secondly, it introduces the new Siflower SF21H8898-based Banana Pi BPI-RV2, the ESWIN Computing EIC7700-based EBC77 with SiFive HiFive Premier P550 cores, and the Ky X1-based Orange Pi RV2 and R2S. The latter two I will leave to my subsequent speaker, Michael Opdenacker from Bootlin (;-p). [CNXSoft note: see talk at 18:00 below]. Those are all interesting new boards I added to my embedded Linux testing lab. Comparing the various downstream vendor options with the upstreaming efforts will show us the overall progress embedded Linux has made on RISC-V. Last but not least, I will discuss the upcoming RVA23-compatible boards based on chips like the SpacemiT K3 SoC with its X100 cores, the Tenstorrent TT-Ascalon IP SoC, the UltraRISC UR-DP1000, and the Zhihe A600 SoC. The time is truly ripe for embedded Linux to shine on RISC-V!

• 14:55 – 15:20 – Precision Landing with PX4 and ROS 2 using Aruco Markers by Ramon Roche and Beniamino Pozzan

Many ROS developers know PX4 exists, but never get the chance to actually poke at it. This talk gives you that chance. We walk through a complete precision landing pipeline using PX4, ROS 2, OpenCV, Aruco markers, and Gazebo, built the same way we teach it in our hands-on workshops.

We start with the pieces of the PX4 architecture that matter to you as a ROS developer, then show how the PX4 ROS 2 interface works, including the PX4 ROS 2 Library by Auterion that makes message handling feel familiar instead of foreign. From there, we jump into simulation with Gazebo, run OpenCV-based Aruco detection, and wire it all into a precision landing controller.

The heart of the session is practical. We take the tag pose produced by OpenCV in the camera optical frame, transform it into the body frame and world frame, and use it to run an approach phase with PI velocity control. We cover the spiral search pattern for when the tag is not visible, and the land detection feedback that lets the system finish the job safely.

To make it easy to try everything at home, we will provide a Docker container and an open repository with all the source code and configuration you need to reproduce the pipeline on your own machine.

If you have ever thought about connecting your ROS and OpenCV skills to PX4 but did not know where to start, this talk will get you there with a smile and a working example you can take home.

• 15:20 – 15:55 – RISC-V Hardware Is Here. What About Software? by Afonso Oliveira

RISC-V hardware momentum is everywhere: more tape-outs, more open cores, more startups, and increasingly affordable boards that everyone can try. But hardware alone doesn’t make a usable platform. From blinking LEDs to critical space exploration missions, adoption depends on the software ecosystem being mature, well-integrated, and ready for developers to rely on.

So, how ready is RISC-V software today? Toolchains, kernel support, hypervisors, RTOSes, and simulators are all evolving, but progress happens at different speeds across the stack. Users still encounter rough edges, and contributors often struggle to navigate the ecosystem and find where help is needed most.

This talk shares a personal journey through RISC-V software enablement: from building Linux images and contributing to Zephyr, to enabling hypervisors and firmware. I’ll highlight what’s solid, what’s still forming, and the challenges faced along the way – and how anyone can begin contributing and using RISC-V.

• 16:00 – 16:55 – Zephyr RTOS Community BoF by Benjamin Cabé

Join the Zephyr RTOS community for an informal BoF session where maintainers, contributors, and anyone interested in hearing more about Zephyr will be discussing:

1. Roadmap — As Zephyr turns 10 this year, where should the community be focusing for the next 10 years?
2. Feedback from product makers — If you are building actual products with Zephyr (yes, even as a hobby!) come and share your experience, both positive and… less positive.
3. General Project Health – BoFs are always a good “reality check” and participants are encouraged to bring their feedback regarding things we could be doing better in our community.

• 17:00 – 17: 25 – ROS-Z: A Rust/Zenoh-native stack, fully ROS 2-compliant by Julien Enoch and Yuyuan Yuan

ROS 2 was designed to be independent of its underlying communication middleware — a powerful architectural feature, but one that introduces complexity and overhead.

While working on rmw_zenoh, we kept wondering: What if we streamlined the ROS 2 layers and built a Rust-native stack from Zenoh up to the RCL API? Could it improve performance? Would it be easier to extend? And could we still support existing RCL-C/C++/Python packages through C bindings?

This led us to develop ROS-Z, a Rust/Zenoh-native RCL stack, fully interoperable with ROS 2 via rmw_zenoh. In this talk, we’ll explore our design choices, share performance insights, and highlight some of the unique features we’ve added to push innovation even further.

• 17:30 – 17:55 – EasyNav: An open-source framework for navigating everywhere by Francisco Martín Rico and Francisco Miguel Moreno

EasyNav is a fully open-source navigation framework for robots, designed to be lightweight, modular, and suitable for real-time execution. The project is motivated by the limitations of existing systems, which are tightly coupled to a single environment representation and often introduce unnecessary computational overhead. EasyNav decouples navigation from the underlying map structure, enabling costmaps, gridmaps, NavMap, or other models to be used interchangeably. Its architecture is built around a minimal core and open, extensible stacks that group controllers, planners, localizers, and map managers. The framework is designed to be easy to inspect, modify, and extend through its clear plugin interfaces. This talk will present the motivation, architecture, main features, and evaluation results in simulation and real robots, showing how an open-source approach improves flexibility, transparency, and performance in complex scenarios.

• 18:00 – 18:35 – Mainline Support for Orange Pi RISC-V Boards by Michael Opdenacker

In the course of the past months, Michael has contributed to support for OrangePi RV2 and R2S in the mainline Linux kernel (6.19+), in Yocto’s meta-riscv BSP layer, and hopefully before FOSDEM 2026, in the U-Boot bootloader. Hoping to attract more users and contributors, and to inspire owners of other RISC-V boards, this presentation will review what has been done so far and the necessary steps to achieve this. It will also cover what’s left to do on each board.

• 18:30 – 19:00 – Snapdragon 8 Gen 3 Mainline: From Day-1 Patches to Product Reality by Neil Armstrong

It has been two years since the initial mainline Linux support for the Snapdragon 8 Gen 3 (SM8650) was posted on the very day of its marketing announcement and used to present the Qualcomm platforms’ mainline state in this very conference on an SM8650 HDK development board. What started as basic boot support with display has evolved into a fully-featured upstream ecosystem, but the road was far from smooth.

In this session, we will explore the technical evolution of SM8650 support, moving beyond the “it boots” milestone to a fully usable system. We will dissect the challenges of enabling complex subsystems—from the Hexagon DSPs and Adreno 750 GPU to the intricate power domains that modern SoCs demand to properly support runtime power management and suspend-to-ram state.

We will also address the often-overlooked bootloader story, showcasing the current state of upstream U-Boot on this platform and how it interacts with the standard EFI boot flow.

The Talk Will Feature a Technical Post-Mortem about the whole upstreaming process and a live demonstration running mainline Linux on an actual Snapdragon 8 Gen 3-powered device running the mainline kernel with code changes—proving that upstream support is no longer just for development boards.

FOSDEM 2026 Day 2 – Sunday, February 1

• 09:00 – 09:25 – Bringing WebAssembly to constrained devices with Rust: Runtimes, tooling, and real-world tradeoffs by Fedor Smirnov

In this talk, we will share the insights we gained while building Myrmic, our open-source Rust middleware for distributed systems, with a particular focus on our microcontroller firmware that enables running WebAssembly on resource-constrained targets such as Nordic and ESP devices. Our entire stack is Rust-based—from Embassy firmware and the embedded HAL to the Wasm toolchain and the runtimes themselves. We will outline the requirements that running Wasm in no_std environments imposes on runtimes, particularly in the context of distributed systems with constrained devices. We will then share our experience with Rust-native runtimes such as wasmtime, wasmi, and tinywasm, and with embedding WAMR into Rust firmware, focusing on how each runtime aligned with these requirements and the modifications or integration work needed to support our use case.

We will also discuss how we structure and compile our Wasm modules, and the trade-offs we make between developer ergonomics, code portability, and the memory footprint of the resulting binaries. The goal of this talk is to provide practical lessons for Rust developers, highlight gaps in today’s embedded-Wasm tooling, and point out opportunities for new open-source contributions. CNXSoft note: no link for Myrmic, but it will be open-sourced a little later

• 09:30 – 09:55 – From C to Rust on the ESP32: A Developer’s Journey into no_std by Alexis Lothoré

Rust is rapidly reshaping how we build reliable software — including in areas once dominated by C. But what does it really look like to bring Rust into an existing embedded codebase? This talk shares the hands-on experience of migrating a working ESP32 firmware from C to no_std Rust, highlighting what Rust changes, what it improves, and where the bumps in the road are.

Starting from a hobby project — a wireless arcade button used in a multiplayer blind test game — we will explore the practical steps of developing Rust firmware on the ESP32, from toolchain setup and hardware abstraction to system architecture and debugging strategies. Along the way, we’ll discuss the key differences from traditional Rust development, the challenges faced in a no_std environment, and how the embedded Rust ecosystem and community helped the project move forward.

Whether you’re an embedded developer curious about Rust, someone evaluating the risks and benefits of adopting it in production, or simply interested in real-world migration stories, this talk aims to provide actionable insights, lessons learned, and a realistic view of what transitioning from C to Rust on microcontrollers really looks like.

• 10:00 – 10:25 – Ariel OS – The Embedded Rust Software Stack for Microcontroller-based Internet of Things by Kaspar Schleiser and Koen Zandberg

Ariel OS is a new RTOS for microcontrollers written fully in Rust. It supports popular hardware architectures (Cortex-M, ESP, RISC-V) and popular boards from vendors such as Espressif, Nordic, Raspberry Pi, and ST. Ariel OS is built on top of Embassy and the embedded-hal traits, adding various OS functionalities and a multi-core capable scheduler. Ariel OS further aims to integrate the best of the available embedded Rust ecosystem to provide a seamless, batteries-included experience for microcontroller firmware development. Ariel OS is open source with a dual Apache 2.0 / MIT license, available on GitHub.

In this talk, we demonstrate how easy it is to use Ariel OS on microcontroller-based hardware and how the different features help to quickly get a project up and running. We overview the OS and walk through creating a firmware for a common board, thus showcasing the features that make Ariel OS development unique and appealing

• 10:45 – 11:00 – Testing ESPHome in the real world by Rémi Duraffort

ESPHome is a versatile framework to create custom firmware for various microcontrollers. In this talks we will look at how to automatically test the latest ESPHome firmware on an ESP32.

As ESPHome devices are used to interact with the real world, we will also look at how to test that the LUX sensors can detect light variations. In order to test the ESP32 device, we are going to use lava on the command line, directly inside a GitLab runner.

• 11:10 – 11:35 – GStreamer 1.28 and beyond by Tim-Philipp Müller

This talk will take the usual bird’s eye look at what’s been happening in and around the GStreamer multimedia framework in the last release cycle(s) leading up to the new 1.28 feature release, and look forward to what’s next in the pipeline.

Whether codecs, closed captions, MPEG-TS, HLS + DASH adaptive streaming, speech-to-text transcriptions, text-to-speech synthesis, voice cloning, analytics, WebRTC, RTMP, Vulkan, Direct3D12, Wayland, VA-API, GTK, Qt/QML, AMD HIP + NVIDIA CUDA, bindings, or Rust – we’ve got you covered!

• 11:40 – 12:00 – Designing EUR 20 Open Source Hardware running Free/Libre Open Source Software IoT home server by Tsvetan Usunov (Olimex)

There are thousands of different IoT devices on the market. To control them, you currently have a few options:

1. Use the vendor’s cloud service. This approach has many problems: there is no interoperability between different vendors, so you end up installing 10 different cloud apps for 10 different devices; there are privacy concerns; and anything beyond the basics usually requires paid features.
2. Use an open-source platform such as Home Assistant, OpenHAB, Domoticz, FHEM, PiDome, or Majordomo. These platforms are powerful but often too complex, time-consuming to learn, and relatively expensive to run—typically EUR 100+ and tens or even hundreds of hours of study.

Currently, there is no simple, easy-to-use, and low-cost solution on the market.

We accepted this challenge and are now designing an open-source hardware solution running Free/Libre Open Source Software. Our goal is a device that costs around EUR 20 for the end user, offers more functionality than typical vendor cloud services, and remains fully open for modification and customization by anyone interested.

After six months of work, we already have a functioning hardware prototype and software that supports basic features.

In this presentation, I will discuss the challenges we encountered, demonstrate our current progress, and highlight the major obstacles we are facing. If others share a similar interest, your help and collaboration are very welcome.

• 12:00 – 12:20 – LibrePCB 2.0 – More Than Just a New Look by Urban Bruhin

LibrePCB 2.0 is an exciting milestone of our mission to provide an easy-to-use, modern, Open-Source PCB design software. With its completely redesigned user interface and new design concepts, the productivity and general user experience have been significantly improved. In this talk, I will demonstrate the capabilities and advantages of LibrePCB 2.0, including other new features and improvements beyond its new UI. Also, you will get an update about other aspects of the LibrePCB project, like our funding status or why & how we started the transition from C++/Qt to more modern technologies.

LibrePCB is an Open-Source EDA software to design PCBs, providing the following advantages:

• Cross-platform: Windows/Linux/MacOS/Others | x86/ARM
• Intuitive & easy-to-use UI
• Powerful library concept
• Human-readable file format

Whether you are a newbie or a professional engineer, LibrePCB is made for you – just give it a try!

• 12:30 – 12:40 – Longer-Term Support releases for Buildroot by iTitou and Thomas Perale

Last year, Buildroot, the embedded Linux image build system, extended its Long-Term Support (LTS) release channel to three years, up from one year previously. This has been made possible through the Buildroot LTS Sponsorship program, which funds developer time for ongoing open-source maintenance rather than relying solely on maintainers’ free time.

In this talk, we will walk through the Buildroot contribution and release process, and explain how LTS branches are maintained. We will discuss:

1. When and why should you use a Buildroot LTS release?
2. What can you expect from LTS releases?
3. How the “LTS stewards” coordinate, analyze security issues, and collaborate with upstream Buildroot maintainers
4. The challenges and lessons learned during the first year of the program
5. How to submit your contributions so they can be easily integrated in LTS releases
6. Why should you or your company sponsor the LTS program?

• 12:40 – 12:50 – Illuminating the Frame: Enhancing Flash Control in V4L2 by Richard Leitner

Beyond mobile use cases, flash control is increasingly important in industrial imaging applications. Precise timing is essential for tasks such as barcode scanning and machine vision. However, controlling camera flashes in embedded Linux systems has long been (and still is) a hardware-specific challenge that is often only supported by the downstream drivers.

This talk presents the current efforts to improve flash and strobe control in the Linux kernel, with a focus on the V4L2 subsystem. It begins with an overview of flash timing concepts and their key components, followed by an introduction to the existing V4L2 controls and the latest extensions under development. These enhancements aim to standardize flash behavior across platforms and pave the way for a clean and robust user-space integration.

• 13:00 – 13:25 – libcamera software ISP status update by Bryan O’Donoghue and Hans de Goede

Many recent Windows (on ARM and x86) laptops have replaced the standard UVC USB camera module with a raw MIPI camera-sensor using a CSI receiver and ISP in the CPU to process the raw data into an image (and on smartphones, this has been the norm for ages).

Supporting these cameras under Linux is an ongoing challenge. At FOSDEM 2024, a solution using a software ISP running on the CPU was presented as a solution to get these cameras to work with a fully open-source stack.

This talk will look at where we are at now, 2 years later, highlighting GPU acceleration, FOSS sensor calibration setup and color correction using CCMs, Lens shade correction, and Linux distributions shipping softISP MIPI camera support OOTB

• 13:30 – 14:00 – usermode Linux without MMU by Hajime Tazaki

Usermode Linux (UML) has been developed and maintained in Linus tree for decades and is well used by kernel developers as an instant way of virtualization within userspace processes, without relying on a hypervisor (i.e., qemu/kvm) or software partition (i.e., namespace). Recently unit testing framework for the kernel tree, KUnit, is based on UML as an underlying infrastructure for the framework, which brings us more opportunities to use UML. However, this testing capability of KUnit+UML is currently limited to MMU-full codebase where there are certain portions of code with ifndef CONFIG_MMU in the kernel tree. As a result, nommu code lacks the chance of testability and often introduces regressions in the rapid development cycle of linux kernel.

This talk introduces yet another extension to UML, based on the architecture without MMU emulation, in order to exercise nommu code with a plenty of testing framework implemented on KUnit+UML. The kernel is configured with the option CONFIG_MMU=n, and we’ve implemented a different syscall hook and handling mechanisms with the different interactions to the host processes. With that, existing userspace programs (we’ve used Alpine Linux image with patched busybox/musl-libc) can run over this UML instance under nommu environment. As a bonus, using a different implementation of the host interactions, we got speedups in several workloads we’ve tested, including lmbench and netperf/iperf3 benchmarks.

I will briefly overview its implementation, the comparison with the original UML architecture, and share several measurement results obtained during the development. We will also share the upstreaming status.

• 14:00 – 14:25 – No Line Like Mainline: Update On The Fully Mainline Software Stack For Rockchip SoCs by Nicolas Frattaroli

Users wanting to run mainline Linux on ARM64 often face a familiar set of trade-offs: the hardware is too expensive, hard to find, outdated, or doesn’t support mainline at all. But this is starting to change, and Rockchip is one of the SoC vendors hitting the sweet spot.

Find out why Rockchip hardware and Rockchip as a company have been doing particularly well when it comes to mainline Linux support. This talk provides an overview of the available Rockchip hardware and the current state of the mainline software landscape around them. We will then highlight what the community has successfully upstreamed in 2025, and look at what’s still baking in the developers’ ovens.

The talk assumes the audience is already convinced that using the mainline kernel rather than vendor BSPs is the way to go. Beyond that, both veteran kernel hackers who are curious about hardware they’re unfamiliar with, as well as people looking to get their feet wet in Linux kernel development, are welcome to attend.

• 14:30 – 15:00 – Systems Programming: Lessons from Building a Networking Stack for Microcontrollers by Patricio WHITTINGSLOW

Developing Go for microcontrollers with 32kB of RAM requires a big shift in thinking, moreso if you are trying to get a complete networking stack with Ethernet, TCP/IP, HTTP to run on said device.

Over the past years, we’ve learned how to minimize memory usage and make programs run performantly on these small devices by adopting patterns common in the embedded industry, some of which make working with Go an even better experience than the norm.

This talk explores the tried and tested “Embedded Go” programming patterns we’ve found to work and make developing in Go a pleasure, no matter the hardware context:

1. Avoiding pointers to structs within structs: rethinking the Configure() method
2. Zero-value programming
3. Eliminating heap allocations during runtime
4. Reusing slice capacity
5. Bounded memory growth for your program
6. Safe pointer-to-slice with generational index handles

• 15:00 – 15:25 – The Year in Embedded Security by Marta Rybczynska

The embedded ecosystem is evolving rapidly, and keeping track of the most important developments has become increasingly difficult, especially outside of our current main interests. Over the past year, there have been important changes in the state of regulation, cryptography, tooling, and software supply chain practices. In this talk, Marta will present a curated overview of the key trends that marked the year across both Linux and RTOS-based platforms.

The session will highlight the impact of the EU Cyber Resilience Act on embedded development, recent progress in post-quantum cryptography, the growing influence of AI-assisted tooling, and notable changes in compilers and hardening features. It will also cover the state of vulnerability reporting, examples of high-impact security issues affecting embedded systems, and the maintainership challenges that arise as long-standing maintainers get closer to reaching retirement.

All topics will be supported with concrete references to articles, software releases, and conference talks, giving attendees a clear and actionable picture of where embedded security is heading and what to pay attention to in the coming year.

• 15:30 – 16:00 – My old trains have a second life, with TinyGo! by Florian Forestier

In the 1970s, model trains were a popular hobby. Thanks to low production costs, anyone could afford a small HO gauge layout. The system was simple: a train, a motor, 12V DC in the track, and off you go!

Fifty years later, we took our trains out of the attic with a big idea in mind: to convert them to digital. With some Seeed Studio, Bluetooth, and TinyGo, we managed to get a functional railway network, where we can manage the speed, direction, and lights of each train individually.

• 16:00 – 16:25 – MicroPythonOS: the best of Android, now on Microcontrollers. AppStore, OTA Updates, Touch Screen, Camera, and much more! by Thomas Farstrike

MicroPythonOS is the first modern graphical operating system that addresses the need for a complete, out-of-the-box OS for resource-constrained hardware such as microcontrollers.

It takes heavy inspiration from Android and iOS, with an easy to use appstore, a beautiful LVGL-based touchscreen and button UI with lots of widgets, gestures, theme support, wifi manager, and over-the-air updates.

The software stack is fully open-source. This openness stands in contrast to the increasingly restrictive policies of traditional mobile ecosystems, which are increasingly becoming a walled garden with tight controls on app distribution, content, and monetization.

The OS currently targets the ESP32 family, but it can run on anything that supports MicroPython, including the RP2350. It can also run as a regular desktop application, full-screen or windowed, which makes app development a super short cycle, and debugging much easier.

Hardware support currently includes WiFi, Bluetooth, many Inertial Measurement Units, Cameras, Touch Screens, IO Expanders, Displays, as well as low-level ADC pins, GPIO pins, I2C chips, etc.

• 16:20 – 17:00 – MAX2771 broadband SDR: impact of low bit resolution and application to passive radar measurements by Jean-Michel Friedt

The MAX2771 chip provides broadband (<44 MHz) signal processing and digitization in the lower (1.1-1.3 GHz) and upper (1.5-1.65 GHz) L-band. Initially dedicated to GNSS signal reception, two such chips clocked by a common frequency reference can be used for passive radar or direction of arrival measurements. In this presentation, we tackle the challenges of PLL setpoint drift leading to phase variations despite the common clock, the impact of low ADC resolution on the recorded signal characteristics, and the impact on correlation calculation. These results are not confined to this particular chip, but are valid for any low SNR recordings, including for radioastronomical measurement systems. We demonstrate the use of this setup on passive radar measurements using various ground-based and spaceborne sources of opportunity.

---

The complete schedule for FOSDEM 2026, sorted by day, track, or developer rooms, can be found on the official website. As usual, the event is free to attend, and most talks should eventually be uploaded to YouTube, and links to slides will be available on the FOSDEM website.

Jean-Luc started CNX Software in 2010 as a part-time endeavor, before quitting his job as a software engineering manager, and starting to write daily news, and reviews full time later in 2011.

Support CNX Software! Donate via cryptocurrencies, become a Patron on Patreon, or purchase goods on Amazon or Aliexpress. We also use affiliate links in articles to earn commissions if you make a purchase after clicking on those links.