<?xml version='1.0' encoding='utf-8' ?>
<iCalendar xmlns:pentabarf='http://pentabarf.org' xmlns:xCal='urn:ietf:params:xml:ns:xcal'>
    <vcalendar>
        <version>2.0</version>
        <prodid>-//Pentabarf//Schedule//EN</prodid>
        <x-wr-caldesc></x-wr-caldesc>
        <x-wr-calname></x-wr-calname>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>BBVKBH@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-BBVKBH</pentabarf:event-slug>
            <pentabarf:title>Keynote: Tools Change, Craft Remains - Reflections on Godot, AI and the Future of Making Games</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T100000</dtstart>
            <dtend>20261103T102500</dtend>
            <duration>002500</duration>
            <summary>Keynote: Tools Change, Craft Remains - Reflections on Godot, AI and the Future of Making Games</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (short)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/BBVKBH/</url>
            <location>Ballsaal</location>
            
            <attendee>Johannes Ebner</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>8BNKRM@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-8BNKRM</pentabarf:event-slug>
            <pentabarf:title>From Alpha to Z-Test: A trip through Godot&#x27;s renderer</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T103000</dtstart>
            <dtend>20261103T112000</dtend>
            <duration>005000</duration>
            <summary>From Alpha to Z-Test: A trip through Godot&#x27;s renderer</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (long)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/8BNKRM/</url>
            <location>Ballsaal</location>
            
            <attendee>Clay John</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>3PAYYA@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-3PAYYA</pentabarf:event-slug>
            <pentabarf:title>Console Development Unlocked: Bringing Your Godot Game to PS5, Xbox &amp; Switch</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T113000</dtstart>
            <dtend>20261103T122000</dtend>
            <duration>005000</duration>
            <summary>Console Development Unlocked: Bringing Your Godot Game to PS5, Xbox &amp; Switch</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (long)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/3PAYYA/</url>
            <location>Ballsaal</location>
            
            <attendee>André Ewald</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>EJG9MJ@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-EJG9MJ</pentabarf:event-slug>
            <pentabarf:title>What Our Unity Team Got Wrong (So You Don&#x27;t Have To)</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T123000</dtstart>
            <dtend>20261103T125500</dtend>
            <duration>002500</duration>
            <summary>What Our Unity Team Got Wrong (So You Don&#x27;t Have To)</summary>
            <description>Most &quot;switching to Godot&quot; talks target newcomers. This one is for teams who already know how to ship - because migrating experienced engineers is a different, harder problem. Your expertise doesn&#x27;t transfer cleanly; it misleads you. Godot looks enough like Unity that you reach for familiar patterns, and those patterns are exactly what produce fragile code.

We&#x27;ll walk through the specific collisions our team hit, in three buckets:

**Mental models that don&#x27;t map 1:1**: 

- GameObjects-and-Components vs. nodes-and-scenes 
- Prefabs and variants vs. PackedScenes and scene inheritance (where instancing and overrides genuinely differ)
- ScriptableObjects as Data Containers vs. Resources 
- `Update()` vs. `_process`/`_physics_process`.

**Muscle memory that backfired**: 

- Porting Unity&#x27;s singleton/manager soup straight onto autoloads
- The `GetComponent&lt;&gt;()` reflex becoming `get_node()` coupling
- And the big one, &quot;we already know C#, so we&#x27;ll just use C#&quot;. The honest team tradeoff between GDScript and C# _(iteration speed, export pipeline, community examples)_.

**The day git broke**:
- Scene and resource files are text now: diffable, but conflict-prone. 
- How we kept scenes small and reviewable
- what to commit vs. ignore

We&#x27;re just one team, one project into Godot - so this is what worked for *us*, not a definitive playbook. But if sharing our wrong turns spares you a little of the trouble they cost us, that&#x27;s a win.

**Audience:** engineers, tech leads, and studio decision-makers considering or mid-migration.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (short)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/EJG9MJ/</url>
            <location>Ballsaal</location>
            
            <attendee>Owen Magri</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>QQWXL9@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-QQWXL9</pentabarf:event-slug>
            <pentabarf:title>Why You Should Develop and Release on Console First</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T143000</dtstart>
            <dtend>20261103T152000</dtend>
            <duration>005000</duration>
            <summary>Why You Should Develop and Release on Console First</summary>
            <description>In this 50-minute session, we will dive deep into the strategic advantages of developing and releasing your game on a console first. Drawing from my history working on early XBLA titles, PlayStation Strategic Content, and Dreams, this talk unpacks why the &quot;PC-first&quot; mentality became the default and why shifting your focus back to console can elevate your game.
We will break this down into three core pillars: Technical, Business and Artistic.

The biggest barrier is often simply knowing you can. In a world of distraction and slop you can always grow and expand in the future. Why not FOCUS, make interesting technical decisions, different business choice and strong artistic choice in developing for one console first.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (long)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/QQWXL9/</url>
            <location>Ballsaal</location>
            
            <attendee>Claire Blackshaw</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>AZLG7R@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-AZLG7R</pentabarf:event-slug>
            <pentabarf:title>Building Your Discord Server Through Every Stage of Game Development</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T153000</dtstart>
            <dtend>20261103T162000</dtend>
            <duration>005000</duration>
            <summary>Building Your Discord Server Through Every Stage of Game Development</summary>
            <description>Your Discord server isn&#x27;t just a community, it&#x27;s a development tool. This talk walks through building a server that works for you at every stage of your game&#x27;s development. We&#x27;ll talk about channels, roles, events, moderation, and how to bring players straight from your game into your community and keep them engaged.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (long)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/AZLG7R/</url>
            <location>Ballsaal</location>
            
            <attendee>Anthony Tešija</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>7YUGET@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-7YUGET</pentabarf:event-slug>
            <pentabarf:title>Ichor Online: Building a Massive Multiplayer Online RPG in Godot</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T163000</dtstart>
            <dtend>20261103T172000</dtend>
            <duration>005000</duration>
            <summary>Ichor Online: Building a Massive Multiplayer Online RPG in Godot</summary>
            <description>Building an MMORPG comes with big challenges across content production, large-world tooling, rendering many entities, connection management, latency, netcode and networked physics. This talk explores how we’re combining Godot, SpacetimeDB, and Blender to approach these problems while building Ichor Online. We’ll share our architecture, workflows, lessons learned, and practical trade-offs.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (long)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/7YUGET/</url>
            <location>Ballsaal</location>
            
            <attendee>Leonardo Rocha</attendee>
            
            <attendee>Francesco Piacenti (FR3NKD)</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>QVRYE3@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-QVRYE3</pentabarf:event-slug>
            <pentabarf:title>The basics of Image Composition</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T173000</dtstart>
            <dtend>20261103T175500</dtend>
            <duration>002500</duration>
            <summary>The basics of Image Composition</summary>
            <description>We will go over examples of strong compositions and then look at individual &quot;tools&quot; that will help you create clearer and better images: Visual hirachy, Colors &amp; Contrast, Shape language, Text and Spacing.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (short)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/QVRYE3/</url>
            <location>Ballsaal</location>
            
            <attendee>Simone Mändl</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>ZFVM3B@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-ZFVM3B</pentabarf:event-slug>
            <pentabarf:title>No Big Rewrites! Incrementally Porting GDScript to C++ with GDExtension</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T103000</dtstart>
            <dtend>20261103T105500</dtend>
            <duration>002500</duration>
            <summary>No Big Rewrites! Incrementally Porting GDScript to C++ with GDExtension</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (short)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/ZFVM3B/</url>
            <location>Italien</location>
            
            <attendee>Carter Hinkle</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>RFNWCH@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-RFNWCH</pentabarf:event-slug>
            <pentabarf:title>LOVE,DOGS+ROBOTS  .NET, C#, and Godot everywhere!</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T110000</dtstart>
            <dtend>20261103T112500</dtend>
            <duration>002500</duration>
            <summary>LOVE,DOGS+ROBOTS  .NET, C#, and Godot everywhere!</summary>
            <description>## Who is this talk for?

Developers using C# with Godot, for anything from applications, game jams, prototypes, and entire games ready to ship on Steam tomorrow.

## What to expect?

An overview of where Godot and C# is in actual use, in games and application development.

See **2dog**, a concrete, free, and easy to apply use case of `libgodot`. It turns out it can do *a whole lot of very useful things* for game developers on every level.

- Publish Godot C# games to WebAssembly for the browser
- Run xUnit, GdUnit, or NUnit tests from your IDE, the CLI, or CI
- Import resources through MSBuild tasks
- Add another layer of .NET code around an existing game

## But why?
In late 2025, I went on a journey to learn the innards of Godot and find a way to write my own importers and unit test runners. I was also still waiting for Godot and the promised C# web exports since version 4.1 ... then I met some amazing folks from the community at GodotCon Berlin and Amsterdam, and the rest was pure magic.

**Stay a while and listen!** 🦴</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (short)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/RFNWCH/</url>
            <location>Italien</location>
            
            <attendee>Moritz Voss</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>DBRFQC@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-DBRFQC</pentabarf:event-slug>
            <pentabarf:title>The Price of Rushing Preproduction - Vultures: A &quot;Turn-Based Resident Evil&quot; Postmortem</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T113000</dtstart>
            <dtend>20261103T115500</dtend>
            <duration>002500</duration>
            <summary>The Price of Rushing Preproduction - Vultures: A &quot;Turn-Based Resident Evil&quot; Postmortem</summary>
            <description>Vultures - Scavengers of Death started as a text based roguelike prototype, then a small 3D vertical slice built in Godot 3. That vertical slice became our demo, and it did its job, it proved the core mechanic worked, turn based tactics that played like Resident Evil. 

We got funded and started working on the game without being aware of how much everything else would actually cost: story, levels, enemy design, even the bosses. We cut preproduction short under the pressure of hitting our release commitments with the publisher. That decision followed us through the rest of production, and it showed up exactly where we couldn&#x27;t afford it, the final weeks before launch.

This talk covers three years of prototyping, pitching, and producing Vultures, told through the real production timeline of a two person studio shipping a commercial game in Godot..</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (short)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/DBRFQC/</url>
            <location>Italien</location>
            
            <attendee>Giovanni Beltran</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>JUMP8X@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-JUMP8X</pentabarf:event-slug>
            <pentabarf:title>TestFlight for Godot Developers: Playtesting Games on Apple Platforms</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T120000</dtstart>
            <dtend>20261103T125000</dtend>
            <duration>005000</duration>
            <summary>TestFlight for Godot Developers: Playtesting Games on Apple Platforms</summary>
            <description>This talk provides a practical guide to playtesting and releasing Godot games on Apple platforms. No prior Apple developer experience is required.

**Topics covered:**

- TestFlight Overview
- Creating staged rollout channels to test updates with targeted user groups.
- A live demo showing how easy it is to onboard new playtesters and receive their feedback.
- Setting up the feedback channel and structuring &quot;What to Test&quot; prompts to get honest, and useful insights from playtesters.
- Handling TestFlight constraints, what can be measured with it and where you need to implement your own telemetry
- Promoting validated builds directly to the AppStore
- Using ShipGodot editor plugin for easy cross-platform deployment</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (long)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/JUMP8X/</url>
            <location>Italien</location>
            
            <attendee>Michał Myczkowski</attendee>
            
            <attendee>Aleksandra Dulska</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>FAMRTE@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-FAMRTE</pentabarf:event-slug>
            <pentabarf:title>Continuous community driven translations with gettext and Weblate</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T143000</dtstart>
            <dtend>20261103T145500</dtend>
            <duration>002500</duration>
            <summary>Continuous community driven translations with gettext and Weblate</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (short)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/FAMRTE/</url>
            <location>Italien</location>
            
            <attendee>Simon Dalvai</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>P3UM83@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-P3UM83</pentabarf:event-slug>
            <pentabarf:title>Building A Multiplayer Network for Digital Twins in VR/AR</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T150000</dtstart>
            <dtend>20261103T152500</dtend>
            <duration>002500</duration>
            <summary>Building A Multiplayer Network for Digital Twins in VR/AR</summary>
            <description>This project focuses on creating and implementing digital twins of the LSU distillation columns through open-source software. Open-source software is important because it allows more flexibility to modify and improve designs over time as well as be transparent and accessible. We found that open-source software is highly capable and accessible in our workflow when creating interactive digital twins.

Using data from lidar or photogrammetry, a point cloud is generated from an application like CloudCompare for accurate measurement, scale, and location of the environment. This point cloud served as a precise reference when constructing the 3D model on a large-scale system. Blender’s dynamic toolset allowed the team to create a detailed visualization of the data in an efficient manner.

Shifting the 3D model into Godot, interactivity with user movement, object information, and world navigation was added to the application. Blender and Godot are meant to work together and the reason why we chose these specific programs is because they are fully free. Freedom to build, modify, and share what is made. They are made for the user. Finally, for version control, Github was used to track all the changes. 

Each of these open-source tools are adaptable and significantly robust for building both optimal digital twins and high-fidelity digital twins.

Pipeline:

Lidar/Photogrammetry:
- Point cloud generated from images provided accurate scale for models

Blender: to model the 3D environment 
- Create a master file to combine separate 3D parts
- Individual team member files are linked to the master file
- Establish a material legend and asset library for consistency

Godot: to handle the VR/AR system
- Multiplayer system: backend network
- Toy model mode
- VR/AR mode
- Interactive aspects such as a drawing function and hovering to show information

Github: to source control
- Documentation
- Tracking and maintaining files

This aims to use Blender to model the 3D environment and Godot to handle the VR/AR system. Important features include multiplayer system, toy model mode, VR/AR mode, and other interactive aspects such as a drawing function and hovering to show information. The main emphasis is the multiplayer network as this allows multiple users to interact with the 3D surroundings and collect necessary information in real-time.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (short)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/P3UM83/</url>
            <location>Italien</location>
            
            <attendee>Tina Nguyen</attendee>
            
            <attendee>Darrius Anthony</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>EALHBY@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-EALHBY</pentabarf:event-slug>
            <pentabarf:title>Crashes Don&#x27;t Care What Language You Wrote Your Game In</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T153000</dtstart>
            <dtend>20261103T155500</dtend>
            <duration>002500</duration>
            <summary>Crashes Don&#x27;t Care What Language You Wrote Your Game In</summary>
            <description>**You write in three languages and ship to eight platforms. A crash can come from any cell in that grid. You need to turn that grid back into one clear answer.**

Most crash-reporting talks assume one language and one platform. Godot oftenbreaks both assumptions at the same time, which is exactly what makes it relevant for all Godot developers,whether they&#x27;re all-in on GDScript, betting on C#, or dropping into native code for performance.

## Axis 1 - The languages: three ways a game can fail
Under one engine, &quot;an error&quot; means three different things:
* **GDScript** - Errors come from the engine&#x27;s own script VM. You want the script, the line, and the game state around it, captured live as the game runs.
* **C#/.NET - The newest and fastest-growing surface.** These are managed-runtime exceptions with their own stack shape, and the SDK now captures them as first-class events (including script context and variable values on the platforms that support it). Godot&#x27;s C# community has been waiting on solid tooling here, which is a big part of why this talk is timely. There&#x27;s even a build-time check that nudges C# developers toward the Godot-aware SDK instead of the raw one, a small thing that prevents a lot of misconfigured setups.
* **Native / GDExtension (C++)** - When your own native module or the engine itself crashes, you don&#x27;t get an exception at all; you get a full-process minidump from an out-of-process handler. A completely different capture model from the two above.
The point for the audience: these aren&#x27;t three flavors of the same thing. They fail differently, they carry different context, and unifying them means agreeing on what an event even is before you can put them together in one list.

## Axis 2 - The platforms: the same crash, eight hostile environments
Now take any of those failures and ship it across Godot&#x27;s export targets. Each one has different rules:
* **Desktop** (Windows / Linux / macOS) - the baseline, and even here you&#x27;re juggling different symbol formats and, on Apple, a separate underlying SDK.
* **Android** - its own crash world: tombstones, ANRs (&quot;Application Not Responding&quot;), app hangs, and multiple CPU architectures to build and symbolicate for.
* **iOS** - managed through the platform&#x27;s native tooling, with its own signing and symbol quirks.
* **Web (WASM)** - your game is now running in a browser sandbox; a crash looks nothing like it does on desktop.
* **SteamOS / Proton** - your Windows build running through a translation layer on Linux. When it crashes, which stack are you even looking at? One example: under Wine the thread&#x27;s stack bounds can report back wrong, so the crash handler tries to capture a wildly oversized stack - the SDK has to detect that it&#x27;s running under Proton and rein the capture back in.
* **Consoles** - locked-down platforms where you can&#x27;t just drop in a standard crash handler at all.
This axis is where a lot of the complexity lies and it&#x27;s the part many devs underestimate until they ship.
Turning the grid back into one answer

## The payoff of the talk is how the two axes come back together:
* **One SDK, many engines underneath.** The Godot SDK is built as a GDExtension that quietly composes several native SDKs (the native/C++ crash backend, plus the Apple, Android, and Web SDKs) and presents a single, clean GDScript and C# API on top. You write against one interface; it fans out to the right machinery per platform.
* **Normalize, then symbolicate.** Events from three different runtimes get normalized into one shape, and then each is mapped back to your source - GDScript line, C# frame, or native symbol - using the right method for that platform.
* **One list, grouped and readable.** A C# exception under Proton and a native crash on Android end up side by side as grouped, source-mapped issues - plus Godot-native context like the scene tree, a screenshot of what the player saw, breadcrumbs, and device info.
* **Where it&#x27;s heading.** Once every language and platform lands as structured, richly-contextual data, that context becomes the raw material for AI-assisted root cause - a natural, non-salesy closing note.

## Under the hood: how the layers actually talk (and where it got messy)
This is the technical spine I&#x27;d want to give the talk real weight.  Focus on the handful of design decisions and hard-won bugs that make the &quot;one clean issue&quot; illusion hold together. It&#x27;s the part senior devs in the room will recognize from their own native/managed bridges.
* **One interface, swappable backends.** Everything the public API does - set a tag, add a breadcrumb, capture an event - goes through a single internal C++ interface. Desktop fulfills it with the native/crashpad backend; Apple, Android, and Web each plug a different underlying SDK in behind the exact same interface. The GDScript or C# you write never knows, or cares, which one answered underneath.
* **The C#↔native bridge is hand-built**, and it&#x27;s mostly about strings and structs. Godot&#x27;s C# layer doesn&#x27;t get to use a normal SDK.  The managed and native sides talk over a raw function-pointer boundary. Native registers a table of callbacks C# can invoke; C# imports a matching set of native entry points. Every string crosses as a raw UTF-16 pointer + length with explicit handoff, and every struct has to have byte-for-byte identical layout on both sides. Get one field out of order and there&#x27;s no compiler to catch it - you get a crash while reporting a crash.
* **Keeping scope in sync without an infinite loop.** Set the user, a tag, or a breadcrumb in C#, and it has to also show up on a native crash that C# never sees - so each layer observes the other and mirrors changes across. The obvious trap: native tells managed, managed&#x27;s own observer tells native, which tells managed… forever. The fix is a small thread-local re-entrancy guard so a change that arrived from a sync doesn&#x27;t echo back out.
* **The SDK crashing on its own crash reports.** We hook Godot&#x27;s error stream to turn engine errors into events - but our own code can log errors, which we&#x27;d then capture, which logs more errors. That&#x27;s a feedback loop, and done naively under a lock, a deadlock. Making it safe took a recursion-depth guard, filtering out our own log output by prefix, and a hard rule to never emit an error from inside the per-frame handler.
* **Error storms.** One bad line in _process() throws the same error every single frame. With no limits you&#x27;d ship 60 identical events a second and set the player&#x27;s machine on fire, so there&#x27;s per-frame caps, a throttling window, and per-source-line dedup - plus deliberately looser limits for the first few frames of startup, where a burst of errors is normal.
* **&quot;Is this even a C# error?&quot;** C# exceptions arrive through the same logger as GDScript errors - sometimes tagged with a .cs file, but on the Mono runtime sometimes with an empty file, so we fall back to sniffing the backtrace&#x27;s language name to route it to the .NET layer. And then symbolication itself: GDScript source we can pull live from the running script VM, but in an exported .NET game the assemblies live inside Godot&#x27;s packed, compressed virtual filesystem - no file on disk for the .NET SDK to open, so every managed frame comes back as unknown_image. The workaround is handing the SDK a fake seekable &quot;file&quot; that reads those bytes back out through Godot&#x27;s own filesystem, and only the two small slices it actually needs.
The theme across all of these: the friendly one-line API is easy; what&#x27;s hard is the plumbing underneath that keeps three runtimes agreeing on what happened, without deadlocking, looping, or lying about where the crash came from.

## Key Takeaways
* **&quot;One language, one platform&quot;** is a fantasy for Godot devs. Design your error handling for the whole grid from day one.
* **GDScript, C#, and native failures are genuinely different** - knowing how they differ is the first step to unifying them.
* **Your export targets are where reproducibility goes to die** - Proton, Web, Android, and consoles each change what a crash even looks like.
* **GDExtension is a powerful seam for wrapping native capability** behind a friendly GDScript/C# API - crash reporting is one worked example of a general pattern.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (short)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/EALHBY/</url>
            <location>Italien</location>
            
            <attendee>Amir Mujacic</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>WXYKTM@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-WXYKTM</pentabarf:event-slug>
            <pentabarf:title>Multiplayer Bloopers: Common networking pitfalls explained with painful examples</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T160000</dtstart>
            <dtend>20261103T162500</dtend>
            <duration>002500</duration>
            <summary>Multiplayer Bloopers: Common networking pitfalls explained with painful examples</summary>
            <description>Networking breaks your game in ways that are hard to explain, easy to laugh at, and even easier to misdiagnose. Players will call all of it lag. You will blame the server. It is usually neither. This talk walks through the common ways multiplayer goes wrong: why each one happens, what the usual fix is, and what that fix quietly breaks in return. No code or netcode background needed. If you are adding multiplayer to your game, or already shipped it and are now reading the reviews, this one is for you.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (short)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/WXYKTM/</url>
            <location>Italien</location>
            
            <attendee>Jiří Starý</attendee>
            
            <attendee>Erick Passos</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>GFUZ9L@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-GFUZ9L</pentabarf:event-slug>
            <pentabarf:title>Godot &amp; Accessibility - Creating the Utmost Freedom</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T163000</dtstart>
            <dtend>20261103T165500</dtend>
            <duration>002500</duration>
            <summary>Godot &amp; Accessibility - Creating the Utmost Freedom</summary>
            <description>We might not realize it at first, but accessibility plays a role in virtually **_every_** aspect of our life - whether by wearing glasses or hearing aids, living with physical limitations or sustaining sensory overloads. Even the brightness level of the screen on which you are currently reading this text can be considered an accessibility or quality-of-life feature!

**In this short talk, I focus on the topic of general accessibility in games, including:**
- An explanation of what accessibility actually is and why it is so important.
- How small and simple (UI) optimizations can make a **_huge positive difference_** for many users.
- An overview of tools available to (indie) developers.
- Why forcing accessibility is a bad idea and why it is (sadly) impossible to optimize games for every single individual.

So, join me on this little journey through virtual realms of boundless freedom, and let’s discover new ways of making games as accessible as possible - after all, it enhances **everyone&#x27;s** enjoyment of your fantastic works! ♥</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (short)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/GFUZ9L/</url>
            <location>Italien</location>
            
            <attendee>Thomas Mayer</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>RJSRWU@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-RJSRWU</pentabarf:event-slug>
            <pentabarf:title>Shipping 3D Cross-Platform on a Shoestring Budget: A Solo Dev&#x27;s Postmortem</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T170000</dtstart>
            <dtend>20261103T172500</dtend>
            <duration>002500</duration>
            <summary>Shipping 3D Cross-Platform on a Shoestring Budget: A Solo Dev&#x27;s Postmortem</summary>
            <description>This session is aimed at indie developers, freelancers, and solo devs who want to build and release cross-platform projects in Godot 4 without burning out or breaking the bank.

**Talk Outline:**

- The Setup &amp; Prototyping Mindset: Introducing &quot;The Masked Particle&quot; and the constraints of targeting Web/Desktop/Mobile. I will briefly touch on how my background in 2-week hypercasual sprints helped me scope the project and gain speed during the crucial early prototyping phase.

- The Pragmatic Pipeline: How to build a 3D game without a 3D artist. A look at mixing store assets, outsourcing work, and AI backgrounds to stay on budget.

- Good Enough UI: Utilizing Godot&#x27;s Control nodes to build a single UI that works on big desktops as well as small smartphones, prioritizing shipping readiness over perfection.

- The &quot;Fake 3D&quot; Hero Hack: A deep dive into web and mobile performance optimization. I will show how I avoided melting GPUs by simulating a complex 3D view into a particle detector using performance-friendly 2D line draw calls.

- Q&amp;A</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (short)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/RJSRWU/</url>
            <location>Italien</location>
            
            <attendee>Dr. Johannes Mattmann</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>HSYC8B@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-HSYC8B</pentabarf:event-slug>
            <pentabarf:title>Backstitch: Real-Time Version Control for Godot</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261103T173000</dtstart>
            <dtend>20261103T175500</dtend>
            <duration>002500</duration>
            <summary>Backstitch: Real-Time Version Control for Godot</summary>
            <description>Are you an artist who struggles with Git merge conflicts, and broken Godot scenes?

Or perhaps you&#x27;re a programmer who keeps handling your team&#x27;s Git problems, instead of writing code?

Maybe you teach Godot to students, and half your time is spent fixing Git mistakes?

Game development includes a diversity of roles, and not everyone can be expected to learn or teach Git. Its learning curve is way too steep, and less-technical participants can end up locked out of Godot entirely. Plus, Git was built for code -- games are a lot more than code!

Enter [Backstitch](https://backstitch.dev). Our open-source Godot plugin allows for real-time collaboration, similar to a Google Doc. You can...

- See a history of changes, including visual diffs
- Revert to previous versions
- Create and merge branches

... all without leaving the editor. Most importantly, you&#x27;re *never* stuck with a broken scene. Everyone&#x27;s changes are intelligently merged together, automatically.

Backstitch is great for game jams, or remote, asynchronous work. It is also excellent for classrooms! The plugin grew out of a collaboration with the Endless Foundation, who teach game development with Godot, and needed a better solution for students than Git.

In this talk, we&#x27;ll cover the challenges of version control in game development, what we&#x27;ve learned from students, and what collaboration can look like when everyone on the team can work together. Everyone deserves equal access to version control!</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (short)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/HSYC8B/</url>
            <location>Italien</location>
            
            <attendee>Lilith Duncan</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>XMEH88@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-XMEH88</pentabarf:event-slug>
            <pentabarf:title>I Don&#x27;t Know If This Game Is Good</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261104T100000</dtstart>
            <dtend>20261104T105000</dtend>
            <duration>005000</duration>
            <summary>I Don&#x27;t Know If This Game Is Good</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (long)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/XMEH88/</url>
            <location>Ballsaal</location>
            
            <attendee>René Habermann</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>UEWVJG@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-UEWVJG</pentabarf:event-slug>
            <pentabarf:title>The Return of Game Programming Patterns for Godot</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261104T110000</dtstart>
            <dtend>20261104T115000</dtend>
            <duration>005000</duration>
            <summary>The Return of Game Programming Patterns for Godot</summary>
            <description>At GodotCon Amsterdam 2026, &quot;Game Programming Patterns for Godot&quot; started with a tiny Reddit find, a cached getter, and grew into a tour of underexplored patterns for real Godot projects. Then the video went online, and the comment section did what comment sections do: it argued, it questioned, and it asked for more.

This sequel answers back. We&#x27;ll address the most common (and most spicy) objections from the community head-on, with code, and then go further: new patterns that didn&#x27;t fit in the first talk, each demonstrated in a real, shipped Godot project.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (long)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/UEWVJG/</url>
            <location>Ballsaal</location>
            
            <attendee>Inacio Schweller</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>XRDB8E@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-XRDB8E</pentabarf:event-slug>
            <pentabarf:title>Developing a humanitarian video game in Godot</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261104T120000</dtstart>
            <dtend>20261104T125000</dtend>
            <duration>005000</duration>
            <summary>Developing a humanitarian video game in Godot</summary>
            <description>Most &quot;games for good&quot; struggle with the same tension: how do you build something emotionally honest without turning real suffering into spectacle, and without the production collapsing under its own good intentions? This talk uses Amnios — a hand-drawn 2D narrative game developed in Godot — as a concrete case study for navigating that tension from a technical and production standpoint.
Amnios follows three women navigating pregnancy, childbirth, and early motherhood across three different displacement contexts (the Darién Gap, the DRC–Uganda border, and Geneva). It was developed by a small interdisciplinary team (HEAD – Genève, HEdS, HUG, ICRC) on an eight-month seed grant, using real testimonies and a co-creation workshop with twelve migrant women as source material rather than research statistics.

I&#x27;ll cover:
- Why Godot was the right engine for a small, cross-disciplinary team mixing artists, clinicians, and researchers with no prior game-dev experience
- Building a hybrid comic/side-scrolling structure — combining illustrated panel sequences with forced-scroll 2D levels to represent involuntary displacement
- &quot;Bubble Puzzles&quot;: a symbolic dialogue mechanic (conversation, thought, and violence bubbles) used as both a narrative device and a literal gameplay system, and how we implemented it in Godot&#x27;s node/signal architecture
- Translating testimony into mechanics — the practical pipeline from workshop transcripts and field interviews to level design and environmental storytelling, without reproducing individual stories directly
- Production reality on a tiny budget and timeline — team structure, scope decisions, what got cut, and what we&#x27;d do differently
- Ethical representation as a design constraint, not an afterthought: how clinical and humanitarian partners (obstetrics, perinatal psychiatry, ICRC field researchers) were embedded in the actual dev process, not just consulted at the end

Who this is for: developers and studios considering socially-engaged or research-based projects, anyone scoping a narrative game on a small team/budget, and educators or NGOs curious about games as a serious medium for sensitive topics. Attendees will leave with a concrete production framework for working with external experts and lived testimony without either exploiting the subject matter or diluting the game into something toothless. No prior knowledge of humanitarian work needed — this is a game-dev talk first, with the social impact angle as the lens.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (long)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/XRDB8E/</url>
            <location>Ballsaal</location>
            
            <attendee>Aida Navarro</attendee>
            
            <attendee>Claire Delhomme</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>7QH3NL@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-7QH3NL</pentabarf:event-slug>
            <pentabarf:title>Waiting for GDScript: Rebuilding a Dialogue Engine Without C#</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261104T143000</dtstart>
            <dtend>20261104T152000</dtend>
            <duration>005000</duration>
            <summary>Waiting for GDScript: Rebuilding a Dialogue Engine Without C#</summary>
            <description>Much of the GDScript tutorials, documentation, and advice comes from gameplay code. But we got to take it somewhere new: a bytecode virtual machine, protobut, a stack, a variable store and a localisation system. And it was a blast!

In this talk we&#x27;ll cover
- Bringing a C# runtime across to GDScript, and the surprising places each language shines.
- Making GDScript appropriately fast for a job it isn&#x27;t usually asked to do.
- How typed GDScript shaped the design for the better.
- Plugging straight into Godot&#x27;s TranslationServer for localisation.
- Parity testing: how we keep two runtimes in lockstep from shared test scripts.
- Why supporting both Godot languages is worth it, and how to do it for your own plugins.
- And more secrets and tips on using Godot for narrative, and building narrative engines!

You&#x27;ll leave with practical patterns for performance sensitive GDScript, a testing approach you can use on any project with two implementations, and hopefully some excitement about what both of Godot&#x27;s languages can do.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (long)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/7QH3NL/</url>
            <location>Ballsaal</location>
            
            <attendee>Paris Buttfield-Addison</attendee>
            
            <attendee>Dr. Tim Nugent</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>CYQXPS@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-CYQXPS</pentabarf:event-slug>
            <pentabarf:title>Using Godot for defence simulators</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261104T153000</dtstart>
            <dtend>20261104T162000</dtend>
            <duration>005000</duration>
            <summary>Using Godot for defence simulators</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (long)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/CYQXPS/</url>
            <location>Ballsaal</location>
            
            <attendee>Kristian Too Andreasen</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>KJFJWN@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-KJFJWN</pentabarf:event-slug>
            <pentabarf:title>You want to add Shaders to your game? Here is how you start.</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261104T163000</dtstart>
            <dtend>20261104T172000</dtend>
            <duration>005000</duration>
            <summary>You want to add Shaders to your game? Here is how you start.</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (long)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/KJFJWN/</url>
            <location>Ballsaal</location>
            
            <attendee>Leszek Nowak</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>WS9E8T@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-WS9E8T</pentabarf:event-slug>
            <pentabarf:title>Farewell Speech</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261104T173000</dtstart>
            <dtend>20261104T180000</dtend>
            <duration>003000</duration>
            <summary>Farewell Speech</summary>
            <description></description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (short)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/WS9E8T/</url>
            <location>Ballsaal</location>
            
            <attendee>Raffaele Picca</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>QRCMAP@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-QRCMAP</pentabarf:event-slug>
            <pentabarf:title>Small Team, Big Leverage: Using Automation to Build Games Faster</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261104T100000</dtstart>
            <dtend>20261104T105000</dtend>
            <duration>005000</duration>
            <summary>Small Team, Big Leverage: Using Automation to Build Games Faster</summary>
            <description>This session looks at how solo developers and small teams can adapt proven engineering practices from large companies to gain more leverage from limited time and resources.

The talk will cover practical techniques such as automated cross-platform builds, reusable dependency environments, continuous integration, testing, packaging, and versioned releases. It will also explore how tools such as godot-package can download specific versions of GitHub release artifacts, making dependencies explicit and helping projects reproduce known working configurations without unexpectedly breaking users.

Drawing from my experience building and maintaining large, complex systems in professional software environments, I will show how I applied the same underlying ideas to the growing collection of open-source Godot extensions I maintain. Without automation, supporting these projects across multiple platforms and releases would be impractical for a solo developer.

The focus will be on creating simple, repeatable systems that reduce manual work, prevent regressions, and make an otherwise unsustainable workload manageable.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (long)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/QRCMAP/</url>
            <location>Italien</location>
            
            <attendee>Werner Mendizabal</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>MXVUPL@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-MXVUPL</pentabarf:event-slug>
            <pentabarf:title>The 5-Phase Game Jam Framework: Bringing Structure to Chaos</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261104T110000</dtstart>
            <dtend>20261104T115000</dtend>
            <duration>005000</duration>
            <summary>The 5-Phase Game Jam Framework: Bringing Structure to Chaos</summary>
            <description>Every game jam begins with ambitious ideas, but finishing a polished game requires a lot of decisions under intense time pressure. This session breaks those decisions down into a practical five-phase framework that attendees can immediately apply in their next jam.

**Phase 1 - Planning:** Turn the jam theme into a unique, achievable game idea, brainstorm effectively, control the scope, and use a one-page &quot;Mini GDD&quot; to organise ideas before opening the engine. 

**Phase 2 - Execution:** Learn how to stay productive under pressure by following a clear plan, prioritising the core gameplay loop, keeping mechanics simple, choosing technology that fits the deadline, and knowing when &quot;good enough&quot; is the right decision.

**Phase 3 - Polishing:** Learn how to make a game feel finished by adding impactful feedback, creating intuitive tutorials, and using game juice to make every player interaction feel satisfying.

**Phase 4 - Finalising:** Avoid last-minute disasters by testing exported builds, planning around the deadline instead of racing it, and learning why I treat uploading several hours early as a non-negotiable rule.

**Phase 5 - Post-Jam:** Give your game the first impression it deserves by presenting it effectively with compelling screenshots, GIFs, and descriptions that encourage players to give it a chance.


Throughout the session, I&#x27;ll share real examples from my own game jams, highlighting both successful decisions and mistakes that taught valuable lessons, alongside practical techniques attendees can immediately apply in their next jam using Godot.

Winning a jam is never guaranteed, but consistently finishing polished, enjoyable games is something you can prepare for. This talk is about building the habits and workflow that help you do exactly that.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (long)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/MXVUPL/</url>
            <location>Italien</location>
            
            <attendee>Ahmed Alfiki</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>T78FZV@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-T78FZV</pentabarf:event-slug>
            <pentabarf:title>Mobile Games Without the Slop</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261104T120000</dtstart>
            <dtend>20261104T122500</dtend>
            <duration>002500</duration>
            <summary>Mobile Games Without the Slop</summary>
            <description>The talk combines three areas: game design, business, and technology.

I’ll use LOOTFALL as a real-world case study to discuss how meaningful progression, long-term systems, and player-friendly monetization can coexist with a sustainable mobile business.

On the technical side, I’ll cover how I built and shipped LOOTFALL with Godot, including mobile performance optimization, memory and loading considerations, handling large amounts of UI and game data, and some of the challenges of using Godot for a relatively complex mobile game when many parts of the engine and workflow are not specifically mobile-first.

The talk is aimed at developers interested in mobile development, Godot, sustainable (and fair) monetization, and building games that players want to keep playing (live service).</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (short)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/T78FZV/</url>
            <location>Italien</location>
            
            <attendee>Leon Klostermann</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>SPVYA9@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-SPVYA9</pentabarf:event-slug>
            <pentabarf:title>Let&#x27;s Hear It! Enabling True Audio Accessibility in Godot</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261104T123000</dtstart>
            <dtend>20261104T125500</dtend>
            <duration>002500</duration>
            <summary>Let&#x27;s Hear It! Enabling True Audio Accessibility in Godot</summary>
            <description>In this talk, sound designer and gameplay audio programmer Max de Kroon presents a fast-paced practical approach to building accessible audio systems in Godot. We will move from upgrading our basic single-slider settings to actionable techniques like dynamic bus routing, low-overhead EQ profiles, contrast-complete UI feedback and sound customization for the sensitive ears.

Grounded in real-world production learnings, this session provides a practical checklist of built-in engine features and an open boilerplate that you can immediately implement in your next project to make it playable, audible and enjoyable for everyone.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (short)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/SPVYA9/</url>
            <location>Italien</location>
            
            <attendee>Max de Kroon</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>LHKY7Z@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-LHKY7Z</pentabarf:event-slug>
            <pentabarf:title>Synthesizing a Flamethrower from a Bathroom Sink: DIY Sound Design for Indie Devs</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261104T143000</dtstart>
            <dtend>20261104T152000</dtend>
            <duration>005000</duration>
            <summary>Synthesizing a Flamethrower from a Bathroom Sink: DIY Sound Design for Indie Devs</summary>
            <description>Sound design is fundamentally the art of illusion. This session is designed for solo developers and indie teams who want to stop relying on repetitive asset flips and start taking matters into their own hands… or ears.

We will focus on practical takeaways, essential tools, and processing techniques that developers can immediately apply to their situation.

**What we will cover in this session:**
•	The function of Sound: Understanding exactly why we use sound in games (from providing crucial player feedback to guiding attention and simulating a believable reality). 
•	The setup: A practical look at the essential software (like Reaper or Cubase) and hardware needed to start recording, including understanding microphone polar patterns, managing levels to avoid clipping, and the golden rule of leaving 12dB of headroom. 
•	The tools: The core of the talk. We will break down the four pillars of sound manipulation:
o	Equalization (EQ): Removing problematic frequencies and sculpting the sound. 
o	Compression: Taming dynamic range to make sounds punchy and energetic. 
o	Reverb: Simulating physical spaces and creating surreal magic effects. 
o	Pitching/Stretching: Altering the perceived physical size of an object simply by changing its pitch. 
•	Case Study - The Water Tap Flamethrower: A step-by-step breakdown demonstrating how layering and processing techniques can transform the sound of rushing water from a kitchen sink into an aggressive, dynamic flamethrower effect. 

**Target Audience:** Indie developers, programmers, and generalists looking to build foundational sound design skills and elevate their game’s audio quality on a budget.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (long)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/LHKY7Z/</url>
            <location>Italien</location>
            
            <attendee>Chris Kohler</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>QMGRMW@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-QMGRMW</pentabarf:event-slug>
            <pentabarf:title>Putting Voices in Indie Games - A Guide For Indies On A Budget</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261104T153000</dtstart>
            <dtend>20261104T162000</dtend>
            <duration>005000</duration>
            <summary>Putting Voices in Indie Games - A Guide For Indies On A Budget</summary>
            <description>I will invite a guest voice actor to do the demonstration with me.</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (long)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/QMGRMW/</url>
            <location>Italien</location>
            
            <attendee>Alec Shea</attendee>
            
            <attendee>Lara Schmidt</attendee>
            
        </vevent>
        
        <vevent>
            <method>PUBLISH</method>
            <uid>CHMGZR@@talks.godotfest.com</uid>
            <pentabarf:event-id></pentabarf:event-id>
            <pentabarf:event-slug>-CHMGZR</pentabarf:event-slug>
            <pentabarf:title>Cracking open Godot Editor: what it taught me about Godot</pentabarf:title>
            <pentabarf:subtitle></pentabarf:subtitle>
            <pentabarf:language>en</pentabarf:language>
            <pentabarf:language-code>en</pentabarf:language-code>
            <dtstart>20261104T163000</dtstart>
            <dtend>20261104T172000</dtend>
            <duration>005000</duration>
            <summary>Cracking open Godot Editor: what it taught me about Godot</summary>
            <description>Godot Editor is a Godot app itself, probably the largest one ever written. I spent months rebuilding it into a multi-scene editor with a profiler running the whole time, and this talk is everything it taught me about Godot.

We start with why Godot is genuinely useful for the industry, how GDScript and Godot formats like gdshader quietly form an open set of standards, a precious resource we should make good use of.

Then we crack the editor open. Why is the whole 3D editor a panel? What is a singleton, really? What is a Node under the hood? Objects created in heap space pointing at other objects, talking through signals, enter tree and exit tree callbacks, script override checks along the way. That is a lot of machinery for a separator line in the GUI. Is it good or bad? Let&#x27;s find out. Tracy measurements: instantiating just the editor&#x27;s GUI takes seconds, one theme change walks the entire Control tree, and entering or leaving the tree has a cost of its own.

The same costs appear in your game, because gameplay logic runs on the same nodes. So there is a practical section: theme, tree lifecycle, and the resource cache, which will quietly load your resource from disk again if you are not paying attention.

To close, some what-ifs. What if Godot&#x27;s data model became an open specification, and anyone could build their own tooling against it? Where could Godot go from there?</description>
            <class>PUBLIC</class>
            <status>CONFIRMED</status>
            <category>Talk (long)</category>
            <url>https://talks.godotfest.com/godotfest-26/talk/CHMGZR/</url>
            <location>Italien</location>
            
            <attendee>Zagir Fabarisov</attendee>
            
        </vevent>
        
    </vcalendar>
</iCalendar>
