Version control remains one of the biggest barriers to open source contribution—especially in game development, where programmers, artists, and designers must collaborate using tools like Git which are designed for code, not creative assets or interdisciplinary teams. At Ink & Switch, we're prototyping a new collaboration system built directly into the Godot editor, supporting real-time co-editing, branching, and visual review of changes. In partnership with the Endless Foundation, we're evaluating this system with students in introductory Godot classes. This talk will demo our progress, explore why version control poses unique challenges for game development, and share early lessons from bringing these tools to students.
In 2018 there was no way to use Full-Body Tracking in Godot based VR games or with the Wireless Vive and Spreadgine game engine. Libsurvive had support for the Vive tracker, but none of the games and middleware compatible with my computer supported Full-Body Tracking. This talk will be about extending Freedom Saber (a libre VR rhythm game) to support Full-Body Tracking and VRM avatars.
I will also explain how I modified Spreadgine to work with the SlimeVR Server and my Valve Index.
I'm presenting FEX, a translation layer to run x86 software on ARM devices, and the challenges it brings to the table: The design a high-performance binary recompiler, translation of Linux system calls across architectures, and forwarding of library calls to their ARM counterparts.
Gaming in particular poses extreme demands on FEX and raises further questions: How do we enable GPU acceleration in an emulated environment? How can we integrate Wine to run Windows games on Linux ARM? Why is Steam itself the ultimate boss battle for x86 emulation? And why in the world do we care more about page sizes than German standardization institutes?
Learn why x86 is such a pain to emulate and what tricks and techniques make your games fly with minimal translation overhead. Be prepared to learn cursed knowledge you won't be able to forget!
Overte (https://overte.org/) is a free and open source social virtual worlds platform with VR support. It uses custom renderer and OpenGL. In this talk I will present workflow I used for porting Overte to Vulkan. I will also present resources for learning Vulkan and development tools necessary for porting a game renderer to Vulkan.
This talk provides an introduction and overview over the state of open source XR. It focuses on the Monado runtime and its current state when it comes to OpenXR extensions and hardware drivers, but also covers the context of the wider ecosystem: How does it relate to OpenHMD, OpenComposite, xrizer, wlx-overlay-s, Electric Maple, WiVRn, Godot, and a variety of other projects?
https://monado.dev/ https://github.com/WiVRn/WiVRn https://gitlab.freedesktop.org/monado/electric-maple https://gitlab.com/znixian/OpenOVR https://github.com/Supreeeme/xrizer https://github.com/galister/wlx-overlay-s https://github.com/godotengine/godot
SlimeVR is a fully open source hardware and software project turned company that produces both he required hardware and software for IMU based Full Body Tracking for VR, Motion Capture and VTubing. Over the last 4 years we have grown from a team of 2 and a desire to make cool stuff to an industry leading company with over 10 full time employees, 29.000+ customers and an active community over on discord with 69.000+ members!
In short, SlimeVR uses IMU's (Inertial Measurement Unit) to estimate a virtual skeleton that can then be used for various purposes such as: Virtual Reality games, Motion capture through VMC or with BVH files and Vtubing which has become more and more popular over the years. Whilst we sell the hardware needed, people can also fully build their own hardware with off the shelf components!
We have a huge passion for open source and we love sharing our ideas and mindset with the rest of the world. On top of that, we would love to hear from everyone else as well! That's why we would love to attend the Gaming and VR Devroom at fosdem 2026.
We would love to showcase and share how we came to be, and show off some of the hardware and software that we have developed over the years. Including our latest and greatest recently announced Butterfly trackers. http://slimevr.dev/smol Our software has seen tremendous strides in recent years and has been embraced by names such as Sony for their motion capture product (Mocopi).
We would also love to show off some of the hardware in action! If possible we could set up a demo where the avatar on screen is tracked off of the speaker in real time!
The Entity-Component-System (ECS) architecture underpins many modern game engines and real-time simulation frameworks. Rust, with its strong guarantees around memory safety and concurrency, offers a powerful foundation for building high-performance game systems. This talk explores ECS in practice using the open-source Bevy game engine as a real-world case study. We examine how Bevy structures entities, components, and gameplay systems, how Rust’s ownership model shapes engine design, and what practical trade-offs arise between performance, safety, and flexibility when building real-time games in Rust.
ECS is often presented as a cleaner alternative to object-oriented game architecture, but its real advantages and limitations only become clear once you start building real gameplay systems and chasing frame-time budgets. Working with ECS in Rust makes these trade-offs especially visible, because the compiler forces you to be explicit about data access, ownership, and parallel execution.
This presentation uses the open-source Bevy game engine as a practical example of ECS in a modern game engine. I will walk through how gameplay systems are actually built using entities, components, and systems: spawning and querying entities, structuring game logic as systems, scheduling and ordering those systems, and how archetypes impact cache locality and frame performance. We will look at how Rust’s borrow checker directly shapes ECS API design, how safe parallel system execution works in practice, and where you sometimes need to rethink data layout to satisfy both the compiler and real-time performance constraints.
Rather than treating ECS as a universal solution, this talk focuses on real development experience: what works extremely well for gameplay programming in Rust, what takes time to adjust to coming from traditional engines, and when ECS is the right architectural choice for a game versus when it adds unnecessary complexity. While the examples focus on games, the same ideas naturally extend to simulations, tools, and other real-time, data-driven applications
In 2002, a group of Warcraft III enthusiasts built a free community server using the open-source PvPGN project. Over twenty years and a million games later, Eurobattle.net remains one of the longest-running unofficial Warcraft III servers in existence. This talk traces its evolution from early bnetd and PvPGN roots through the rise of GHost++ and GProxy projects, which fundamentally transformed Warcraft III map hosting, to our own project forks and extensions that keep the ecosystem alive today. Attendees will learn about the architecture behind Eurobattle.net, challenges maintaining decades-old C++ stack, learn about the community aspects, and see a short live demo.