#oxidize2026 — Public Fediverse posts
Live and recent posts from across the Fediverse tagged #oxidize2026, aggregated by home.social.
-
Two weeks left to grab your Oxidize 2026 ticket - Berlin, September 14-16.
Choose from two ticket options: "Conference only" gets you all the talks, panels, lightning sessions, and the networking event, while "Conference + Workshop" adds a full day of hands-on training.
#RustLang #Oxidize2026 #Automotive #Embedded #Aerospace #Defense
-
"Rewrite it in a different language" is one of the most final engineering decisions. Most C++ codebases represent decades of logic - not something teams abandon for a newer language.
That's why Rust/C++ interop matters more than the rewrite debate. The work: calling #RustLang from #Cpp & back, distributing binaries across platforms, integrating vendor drivers, keeping it reproducible in CI.
At #Oxidize2026: a workshop on bridging Rust & C++ with CXX, talks on native libraries & vendor drivers.
-
#RustLang and #AI turn out to be a natural fit: a strong type system and an uncompromising compiler give AI the guardrails it needs, turning "generate and hope" into "generate and verify".
Jonas Wolf (Vector) explores how Vector is leveraging this to build an ecosystem for safe and secure cyber-physical systems - built on a deterministic async runtime and actor framework that makes distributed systems reproducible and verifiable.
🔗 https://oxidizeconf.com/sessions/oxidizing_vector-catalyzing_the_shift_to_an_ecosystem_provider
-
Embedded systems mean tradeoffs: tight memory, no OS, hardware that won't forgive a mistake.
Rust's pitch here isn't to "start over" — it's what happens once Rust enters an existing system one module, one driver, one UI layer at a time, without a rewrite.
At Oxidize 2026: workshops on adding Rust to existing C code and on osdyne, a Rust embedded OS. Talks on bare-metal UI with no OS, and shipping a Rust RTOS in production.
Berlin, Sep 14–16.
-
Writing software in Rust doesn't make it safety-critical.
Memory safety isn't the hardest problem - mismatched assumptions, undocumented contracts, and unintended state transitions are. #RustLang helps, but it doesn't replace risk analysis, requirements-based testing, and coverage.
At #Oxidize2026: a workshop on building a real safety case, talks on coding guidelines for Unsafe Rust and spacecraft failures beyond memory, and a panel on Rust in regulated environments.
-
Automotive, defense, and space are defined by consequence. Memory corruption and undefined behavior make this software slow and costly to build. Rust keeps control while cutting that risk out.
At Oxidize 2026:
- Volvo Cars on EV battery architecture,
- Quantum Systems on an unmanned systems stack built on Rust, and
- Infinite Orbits on embedded Rust with no room for error.Berlin, September 14–16.
#RustLang #Oxidize2026 #Automotive #Aerospace #SafetyCritical
-
Quantum Systems is the Keynote Sponsor for Oxidize 2026. As a company building AI-powered autonomous systems for defense and security, Quantum Systems will open the conference with "Rust as the Foundation for Future Unmanned Systems."
Sebastian Rietzscher & Sebastian Haas will discuss how Rust supports the development of mission-critical autonomous platforms - a domain where safety, reliability, and performance are non-negotiable.
Oxidize 2026 | Berlin, Sept 14–16, 2026
-
⚡ Lightning Talks are back for #Oxidize2026!
Share your latest Rust project, optimization stories, or a pattern you love. 5 slots, 5 minutes each, strictly timed - no slides, but props are encouraged. Session is recorded and uploaded to the Oxidize YouTube channel.
Sign-ups open September 1 at 10:00 CEST - exclusive to ticket holders. The session leads directly into Socialize at Oxidize.
🎟️ Need a ticket? Grab yours by August 31: https://oxidizeconf.com
-
How do you build an autonomous defense system where failure is not an option? Sebastian Haas and Sebastian Rietzscher (Quantum Systems) walk through Mosaic focusing on its core - the Rust-based Ground Control Station. They cover what it took to migrate a mission-critical stack to Rust, and what challenges remain.
🔗 https://oxidizeconf.com/sessions/keynote_rust_as_the-foundation_for_future_unmanned-systems
-
Safe Rust and Unsafe Rust aren't the whole story in safety-critical settings. Pete LeVasseur (Woven by Toyota) covers the gaps - brownfield projects, hardware interaction outside Rust's Abstract Machine, and the case for Safety-Critical Rust Coding Guidelines as developed by the Safety-Critical Rust Consortium.
🔗 https://oxidizeconf.com/sessions/rust_is_%28un%29_safe%3Awriting_safety_critical_coding_guidelines
#Oxidize2026 #RustLang #SafetyCritical #FunctionalSafety #EmbeddedRust #AutomotiveSoftware
-
The Rust job market is maturing — but expectation and reality don't always align. Till Adam (KDAB), Julius Gustavsson (Volvo Cars), Thomas Fleischmann (Accenture), Julia Sommer (Ferrous Systems GmbH), and Liran Aloni (JetBrains) host a panel at Oxidize 2026 exploring the different archetypes of Rust roles: from working on the language itself, to working with it, to joining a company that just happens to use it.
🔗 https://oxidizeconf.com/sessions/panel_navigating_the_rust_job_market
-
The 2024 recap gives you a good sense of the atmosphere at Oxidize - two days of applied Rust talks and a warm, engaged community 🦀
We're looking forward to welcoming you all back in Berlin this September 14–16, 2026. Note that workshop seats are limited; we recommend booking these early.
-
Slint bills itself as a UI framework that runs on anything. But what does that mean with no OS, no std, and an ESP32-S3 as your target?
At Oxidize 2026, Vasileios Papageorgiou (Extenly) puts that claim to the test by building a working smartwatch prototype - walking through display and touchscreen integration, what the embedded Rust ecosystem already covers, and where the gaps are when Slint meets bare metal.
-
Zero-knowledge proofs have a reputation for being impenetrable. Adam Smolarek (Rustarians) has spent three years building production halo2 circuits and at Oxidize 2026, he'll show what that work actually looks like in Rust - typed columns, constraint checking with MockProver, and where Rust's strictness helps versus where it gets in the way.
🔗 https://oxidizeconf.com/sessions/why_rust_makes_zero-knowledge_proofs_less-painful
-
You write a handful of lines of Rust, osdyne does the rest.
Michael Steil (osdyne) runs a full-day workshop at Oxidize 2026 on using osdyne - a Rust-based embedded OS and SDK with hardware portability, declarative system configuration, ready-made connectivity libraries, and signed OTA updates built in.
🔗 https://oxidizeconf.com/sessions/embedded_rust_with_batteries_included
-
Building on FUSE in Rust tends to involve a lot of boilerplate. libfuse-fs is an attempt to change that - trait-based abstractions, async I/O, overlay and passthrough support out of the box.
At Oxidize 2026, Ruiji Yu (Nanjing University) covers the design and lessons from real integrations: monorepo access and container image building.
🔗 https://oxidizeconf.com/sessions/libfuse_fs_a_ready_to_use_filesystem_library_based_on_fuse
#Oxidize2026 #RustLang #FUSE #Filesystem #AsyncRust #SystemsProgramming
-
What do you do when a last-minute opportunity to test your hardware in space lands on your desk - and there's no time to spin up an embedded Linux?
Michaël Melchiore (Infinite Orbits) will share how Rust's embedded ecosystem gave his team the foundations to move fast without cutting corners on safety. A talk about real constraints, tight schedules, and getting to space anyway.
🔗 https://oxidizeconf.com/sessions/rust_to_safely_go_where_no_one_has_gone_before
-
Much of the Rust-in-safety-critical conversation focuses on perceived gaps - but how do those concerns play out in practice? Florian Gilcher (@skade) from @ferrous joins fellow industry experts to discuss what actually matters for Rust adoption in regulated environments, from qualified tooling to certification.
🔗 https://oxidizeconf.com/sessions/panel_executing_high-assurance_projects_in_Rust
#Oxidize2026 #RustLang #FunctionalSafety #SafetyCritical #EmbeddedRust
-
Curious what Oxidize is all about? Catch up on talks from Oxidize 2024 and 2025 on our YouTube channel - from embedded Rust to real-world systems use cases. A great way to get a feel for what's coming at #Oxidize2026.
-
Getting FFI to compile is the easy part. The harder questions are about distribution: prebuilt binaries across platforms, libraries that must be built from source, and making all of it reliable in CI.
Marcel Koch (@m) compares a custom binary download approach against Conan, using Flutter Rust Bridge as the integration point.
🔗 https://oxidizeconf.com/sessions/beyond_ffi_shipping_native-libraries_in_rust
-
You don't have to rewrite your C firmware in Rust all at once. Christian Meusel's workshop at Oxidize 2026 is about doing it incrementally - starting from build integration and FFI calls, through to third-party crates for QR generation.
🔗 https://oxidizeconf.com/sessions/integrate_rust_into_existing_embedded_c_applications
#Oxidize2026 #RustLang #EmbeddedRust #FFI #BareMetalRust #Firmware
-
Fuzzing finds bugs in Rust code - reliably so. But async Rust has largely stayed out of reach with its complexity making it hard for fuzzers to explore meaningfully.
At Oxidize 2026, Morgan Hill (@pcwizz) walks through what it takes to actually fuzz async Rust: the naive approaches that don't work, and an involved technique that does - involving LibAFL, user mode QEMU, and a fair amount of head scratching.
🔗 https://oxidizeconf.com/sessions/awaiting_exploitation
#Oxidize2026 #RustLang #Fuzzing #SecurityResearch #AsyncRust
-
Do you really need half a dozen daemons and endless YAML just to run a few containers?
Chiyang Tan (Nanjing University) built rk8s - a lightweight Kubernetes alternative in Rust - to find out. At Oxidize 2026, he'll walk through its architecture: a state management and scheduling server, and a single binary that handles both CLI and worker runtime.
🔗 https://oxidizeconf.com/sessions/rk8s_a_lightweight_rust-based_alternative_to_kubernetes
#Oxidize2026 #RustLang #Kubernetes #CloudNative #SystemsProgramming
-
Memory safety, reliability, and performance are key reasons why Rust continues to gain momentum in software development, especially in safety-critical areas. KDAB will be at Oxidize 2026 in Berlin this September to engage with Rust professionals and discuss the future of safe systems programming.
More details: https://www.kdab.com/kdab-at-oxidize-2026-berlin-september-1416/
#MemorySafety #Performance #SoftwareDevelopment #RustLang #Oxidize2026
-
How does Rust fit inside a next-gen EV battery?
Julius Gustavsson (@jgust) from Volvo Cars will walk through SmartCell - their new AC battery technology that eliminates the inverter and onboard charger by shifting intelligence directly into the battery. Rust plays a central role in making that software-defined architecture robust, secure, and production-ready.
-
Rust's compile-time guarantees are deliberately incomplete - the compiler catches most issues, but not all. What's left behind is the question.
At Oxidize 2026, Rolland Dudemaine (TrustInSoft) shares findings from analysing production Rust code: what bugs survive, and when additional tooling is worth it.
🔗 https://oxidizeconf.com/sessions/whats_left_to_find_in_rust
#Oxidize2026 #RustLang #FormalVerification #StaticAnalysis #CodeQuality
-
If you want to know who's taller, you don't measure people hours apart with a precise ruler - you line them up side by side
Denis Bazhenov (JetBrains) applies the same logic to microbenchmarking: instead of running implementations separately and comparing results, run them simultaneously on the same machine. Background noise affects both equally, and you measure relative performance directly.
🔗 https://oxidizeconf.com/sessions/just_stand_them_next_to_each_other
#Oxidize2026 #RustLang #Benchmarking #Perf #SystemsProgramming
-
Most C++ codebases aren't getting rewritten in Rust - but that doesn't mean the two can't work together.
At Oxidize 2026, @nicofee and Nicolas Qiu Guichard (@kdab) run a practical workshop on Rust/C++ interop using CXX: calling Rust from C++ and vice versa, integrating a Rust library into a CMake project, and pulling a C++ library into a Cargo build.
🔗 https://oxidizeconf.com/sessions/rust_and_c_plus_plus_can_be_friends
#Oxidize2026 #RustLang #CPlusPlus #Interop #CXX #SystemsProgramming
-
Specs drift. Handwritten code doesn't keep up. What if JSON, INI Mermaid diagrams, and Markdown were your source of truth - and Rust macros handled the rest?
Tao Liu demonstrates exactly that: a workflow where structured, human-readable documents are transformed at compile time into strongly typed Rust code, applied to a working RISC-V assembler and linker.
🔗 https://oxidizeconf.com/sessions/risc-v%20_assembler_and_linker_using_rust_macros_data_and_diagrams
-
Memory safety is Rust's headline feature - but spacecraft don't fail from buffer overflows. They fail from ambiguity: mismatched assumptions, undocumented contracts, state machines with unintended transitions.
At #Oxidize2026, David de Rosier (Onyx) looks at what decades of safety-critical engineering have learned about these failure modes, and where Rust helps encode those lessons — and where it simply can't.
🔗 https://oxidizeconf.com/sessions/software_ate_my_spacecraft