-
Last october I premiered an art commision for the Penpot Fest consisting in an interactive video mapping party game projected on a carboard wall.
You can see more about this project in this link: https://surreal.asturnazari.com/2025/12/01/penpots-whac-a-mappole-a-floss-interactive-mapping/
I am currently working on a new version of the vj'ing software. It will be released as an open source project. I will try to have ready a first release during the GodotCon.
My talk idea is based on this main points:
- Why do I choose Godot for this project? Free software as an artistic requierement.
- A brief showcase of the main features I implemented to build this game art piece.
- Eirteam FFMPEG extension ·vs· GDE Gozen extension
- How do I use FFMPEG inside godot. VJ'ing vs Game Design. Common problems.
- My current struggle in interactive video experimentation.
- Presentation of GDMapp and a showcase of the actual features
- Some future plans and Q&A
Pixel art often relies on static sprites or labor-intensive frame-by-frame animation. But what happens when you need it to burn, freeze, or glitch dynamically based on game state? Hand-animating a "burning" effect for fifty different weapon sprites is a production nightmare.Writing a shader that does it for you is not.
In this talk, we will explore an easy approach to "reverse-engineering" visual effects using shaders within Godot 4. Instead of relying on generative AI or endless sprite sheets, we will build handcrafted algorithms that maintain stylistic consistency.
I’ll show you real examples from my Pixel UI VFX library, demonstrating how to achieve complex visual ideas through simple trial and error, rather than vast mathematical logic.
Key topics include:
* UVs & Noise: Using UV manipulation and noise to create organic movement.
* Feedback Loops: Leveraging Godot’s SubViewport to create iterative rendering effects.
* Retro Constraints: Techniques for color limiting and quantization for authentic retro pixel art.
* Optimization: Best practices for keeping these effects performant on the GPU.
Attendees will leave with a new perspective on procedural animation and concrete techniques to make their pixel art worlds feel alive, reactive.
In this talk, I will cover the appeal of deliberately engendering discomfort in players. How and why to make them uncomfortable, and the ethics of mechanical and narrative coercion.
Games may be used to put players in compromised and uncomfortable situations, potentially in conflict with other players or themselves. A great deal of emotional development can be caused by such experiences, accompanied by the need to accept that hurt. This talk includes development discussions from our ethics design groundwork at Polynormal Games, as well as my own experience with writing intense, trauma-focused games.
The talk will be about W4 Games experience with Godot Enterprise Users (Meta, Google, Second Dinner, others), W4 value to exist in the Godot ecosystem as driver for enterprise adoption and W4 give back to Godot from its inception.
An introduction to optimizing your games for energy efficiency, going over tools, tips and best practices!
The talk is intended for everybody, compiling the latest knowledge on energy saving measures from across the industry and condensing it down into actionable steps that anybody can implement into their game.
This talk is for you if you've not yet dabbled in making editor tools. We'll cover the absolute basics of several super easy-to-make tools using GDScript just to get you started.
The Godot project has survived without a dedicated audio maintainer for some years, partly because it's a simple one-dimensional problem that is hard to get wrong. However, due to the backlog of new features that the community wants the biweekly Audio Group meetings were restarted last year and pull-requests have been going in. This is a short update on what the audio system does, how it works, and where it is going.
If there's features you'd like Godot contributors to work on, or bugs you need them to fix, what can you do as a humble game developer to make that happen?
Did you ever struggle with reading a piece of text in a game? Typography is still a crucial mediator for information in digital media. Be it a text log, an item description or just a menu option. Unfortunately, typography has been ill-supported by game engines for a long time. Along comes Godot, offering the best font support for games in any engine I have ever seen. In this workshop I want to explore interface design from a typographic angle, and how Godot can be used to accommodate for a wide range of gamers’ reading needs.
I’m a professional graphic designer and hobbyist game dev, running her own type foundry. When I first encountered Godot I was in the middle of researching how to make typography look better in games. And, I couldn’t get over how great Godot’s toolkit was for achieving that.
Or in more poetic terms: In this workshop I want to share my findings with you. I will analyze the intricacies of accessibility, bask in the simplicity of basic design, cherish the complexity of use-cases, dive into the depths of detail typography, elaborate on editorial essentials, and find out what’s hidden inside the treasure trove of open type features. In short: We will look into what makes text work on screen, and how Godot can be used to achieve that.
Find out how I used Godot to build light shows for music nights at my school.
In this talk I'll tell you how I used Godot to solve a unique problem I had using some of Godot's lesser known features and some interesting plans to connect Godot with the physical world.
I look forward to sharing how I built this software and some of the challenges I had to overcome.
Let me show you how to build a light show; with Godot!
This talk is about encouraging everyone to do more game jams. This includes professional developers, hobbyists, students and those who've never jammed before.
Using my 50 jams of experience, I will show why you should do game jams and how they can help you grow, no matter your experience and discipline. I'll also cover the different kinds of jams/jammers, how to get involved in your first jams and how to get the most out of participating.
Contemporary design often strives for seamlessness: flowing, immersive experiences in which the underlying technology disappears from view. In constrast, seamful design embraces complexity and friction to expose the boundaries and inner workings of the technology we engage with.
This talk explores what this means for games, as a player, as a designer and as a Godot user. Drawing from my own experience making small, experimental games in Godot, I will reflect on how keeping seams visible can shift the relation between player, maker and game, and open up alternative approaches to game design.
We want players to be chalenged by our games. Some people, however, face more challenges than we intended. We, ourselves, could be in that situation one day because of temporal disability, aging or some environmental reasons. Let's see what we could do to make our games more future proof in case of accessibility and open for players with disabilities right now.
A game’s mood can shift dramatically with just a few smart visual changes. In this talk, I’ll explore simple, effective ways to improve the atmosphere and add supporting systems in Godot that can change the tone of a scene quickly and convincingly.
I’ll cover practical techniques such as time-of-day setups, weather states, palette swaps, and other lightweight methods for altering visuals and perception without over-engineering the solution. Drawing from real examples in PVKK and multiple game jam projects, I’ll show how these systems can be built in a way that is modular, easy to control, and adaptable to different art styles and project scopes.
Whether you’re building a polished commercial project or a fast prototype, these techniques can help you add depth, variation, and emotional impact with minimal complexity. The goal is to give attendees approachable tools and ideas they can immediately apply in their own Godot projects.
This talk traces the evolution of a Blender-to-Godot workflow for building RPGs: what worked, what didn't, and where we are now. Drawing on the Blender-Godot Pipeline and Blender Studio's DOGWALK, the workflow grew from a one-way export into something reciprocal; Godot project data extracted and mirrored into Blender, enabling direct configuration of scene instances (door states, trap connections, loot tables) in the viewport.
We'll cover the full workflow: asset & scene authoring, synchronization, and the bi-directional data pipeline. The system keeps adapting as the project's needs change, and we'll get into the edge cases that forced redesigns, the synchronization pitfalls, and the tradeoffs still being negotiated.
TU Dublin is Ireland's largest University with over 30K students across 5 campuses. Dr Bryan Duggan teaches Creative Coding, Computational Arts, eXtended Reality and Autonomous Agents @ TU Dublin. They have been teaching Game Development for over 20 years and have been teaching with Godot since Version 3.4. In this talk Bryan will describe how Godot is used across modules in Computer Science and Game Design to teach students transferable digital skills through creative applications in games, music XR, AI, robotics and art. Inspired by Dr Randy Paush's "Head Fake", students create and perform with musical instruments, make award winning games, develop XR projects to promote sustainability, create holographic artificial life forms, generative art and many other wonders using Godot as the foundational technology. Godot is the great enabler as it runs well on low powered student laptops, is easy to use on locked down lab computers and is fast, powerful and versatile - enabling students to enter "flow state" while they learn, and work on projects. Godot disolves boundaries between "learning" and "doing"; and between "imagining" and "executing". In this talk, Bryan will showcase a selection of the hundreds of student projects created in TU Dublin and present and update from Godó Gaedhleach, the Irish Godot User Group - a student led group which hosted it's first IRL meeting in Dublin in February.
About Godot's LOD and HLOD capabilities; talk is beginner friendly but also contains items that should be interesting to veteran users.
- LOD and HLOD basics and pitfalls (of which there are quite a few)
- How to improve cross fades beyond the default offered methods
- Shadow issues stemming from cross-fade use and their workarounds
- Godot's default spherical approximation LOD selection method (visualized, and its implications for wide-screen supporting games, among others)
- The infamously vague (yet well behaved and useful) ArrayMesh add_surface LOD argument (going onto rendering server culler's edge-length).
- Alternative LOD Selection methods in existence (visualized, and demo with custom Godot build supporting them)
- The "Threshold pixels" project settings and per item/viewport LOD biases
This talk is a good background primer for my other talk: "The long road to a million trees"
Building multiplayer games is hard. But why exactly? Let's find out together, find a way out, and take a look at netfox, an addon for building multiplayer games!
Are you an artist who struggles with Git merge conflicts, and broken Godot scenes?
Or perhaps you're a programmer who keeps handling your team'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. 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're never stuck with a broken scene. Everyone'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'll cover the challenges of version control in game development, what we'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!
The Rokojori Action Library main feature and its ground concept are actions which use a modified concept of the command pattern. The actions pattern creates a glue for all disciplines of game development and centralizes the work on the Godot Editor.
The slides, projects and more can be also found on Rokojori's blog
The talk explains the origin of the pattern from melting VFX chains and input commands during the development of Dash Cup Kickers and outlines how the simple actions elaborated to handle more complex scenarios like character controller interactions, behaviour and callback serialization and networking features.
Additionally it shows in-depth specific workflows for real-time editing VFX chains in the Godot Editor
Everyone's curious whether Godot can ship commercial VR. Flammable Penguins
did it — Augmental Puzzles launched on Meta Quest and Steam, with a PSVR2
port in progress. This talk is the honest technical postmortem of what that
took, from an indie studio building its own tech stack on an engine where
the platform holders assume you don't exist.
Claire walks through the real engineering: why Godot's default 3d text rendering
had to be ripped out and replaced with a custom Fast Text, how
undocumented vendor APIs broke a working build overnight, the architecture
decisions around GDExtension versus engine modification, and what actually
changes when you take a Quest VR project to PlayStation hardware. Expect
profiling data, code war stories, and practical advice for anyone considering
Godot for VR — whether you're shipping tomorrow or just
weighing your options.
Team screening of the short film "Singularity", a painterly space adventure set in a universe before the beginning of our time. Produced by Blender Studio.
--This will be a short session of about 20min--
Mobile is the largest gaming platform in the world, but many Godot projects still treat it as an afterthought. The result is great ideas that struggle to run where most players actually are.
This talk reframes mobile as a first-class target, not a late-stage port. We will explore what truly sets mobile hardware apart, from bandwidth limits to frame pacing, and why assumptions carried over from desktop development often lead to costly performance mistakes.
Through practical, Godot-focused examples, we will break down how frames are really built on mobile devices, and how small decisions such as lighting setups, post-processing effects, and UI structure can quietly make or break performance. You will learn how to move beyond guesswork by profiling on real hardware, using in-game metrics alongside powerful free tools like Frame Advisor and Streamline to uncover what is actually happening under the hood.
We will also cover how to scale across device tiers, measure performance as features evolve, and focus optimisation efforts where they have the greatest impact.
Whether you are targeting mobile from day one or bringing an existing project across, this session will equip you with the mindset, tools, and practical strategies to make your Godot games run smoothly where it matters most.
Most memorable games are so because someone originally spent way too much time on something that would feel unimportant to most people during development. Seemingly insignificant details or features in a game might contribute way more than we might think to its overall appeal and success. Explanation and various case studies including the extreme case of my previous Godot-made game Fallacy Quiz.
All about path tracing in Godot. Short (5-10 min) presentation about updates since GDC talk with examples from the community, live demo and Q&A session. Bring your questions, scenes, games!
Shipping Godot games to iOS without a Mac is entirely possible. I'll walk through the CI/CD pipeline I built using GitHub Actions with macOS runners and Fastlane - from basics such as project.godot configuration to code signing with match, building with gym, and distributing via pilot.
Thanks to Fastlane's match, this workflow should also be valuable for teams who do own a Mac - managing certificates and provisioning profiles across your team becomes painless and consistent.
In this talk I want to take you on my three year journey building a high-fidelity racing simulation engine in Godot. I’ll show some examples of projects that have been built with this engine, ranging from rally driving with a navigator, a track day car racing on various tracks and ice and driver training for big eight wheel trucks. Some of these projects had me working with sports car manufacturers at BAC and Donkervoort, building high fidelity models of their cars.
I’ll explain why Godot is so well suited for this. We’ll explore the architecture of racing simulations and how to hook up Godot to a GDExtension developed in C++. This native component runs a bespoke physics engine based on “Project Chrono” at 1000 Hz. Telemetry drives force feedback for the steering wheel and pedals as well as motion platforms and haptic feedback. The physics engine is connected to a multiplayer networking solution. Godot, through GDScript, uses this telemetry data to render vehicle dashboard displays.
We’ll finish the talk with lessons learned and some suggestions for future developments within the Godot community.
Alternative title: Automating QA with Godot: Stop Firefighting and Start Preventing Bugs
This is an introductory talk for developers that don't know about automated testing or don't know how to use it in game development. Its goal is to help teams without a lot of resources to define their QA strategy and improve their projects quality. All techniques can be done directly by the team and the resources shared are either free to use or have a free plan. The talk is divided in 3 parts:
The first part, in which we share the QA mindset. Here we learn how testing throughout the development of a project instead of at the end helps us go faster by re-doing less work. We also talk about how to use continuous improvement to make the development process easier over time, reducing friction and speeding production up
The second part is were automated tests are introduced. This part goes from understanding what to test and how to write a test, to knowing which type of test to use. Since unit tests aren't everything, we go over 4 types of tests not commonly mentioned that are very valuable for video game testing (performance tests, screenshot tests, smoke tests and static analysis)
The third part focuses on Continuous Integration (CI) environments: why use them and what to use them for (how to set one up falls out of the scope and time limit of this talk, but the slides have an annotated sample configuration file for anyone watching the recording). We also explain how Godot has a big advantage on CI builds and test execution over other game engines
I'm sorry, but Custom Resources are not scalable on their own, and managing hundreds of Resource objects is risking your sanity. But they also have undeniable strengths.
In this talk, I'm proposing a hybrid approach, merging versatility of YAML with power of Resources. And it comes with extra goodies:
- safe references in code and @exported properties (no fragile stringly-typed names!),
- static and dynamic validation,
- hot-reloading (working in the exported game too, if you are brave enough),
- and an in-editor overview to wrap your head around the wonderful content of your game.
Porting your game to other platforms shouldn't mean rebuilding it from scratch. In this session, we will explore how to architect your Godot project for cross-platform success from day one. We'll cover tips and workflow strategies to ensure expanding your game to any platform is a seamless experience.
Highlights of getting to render 200-800k trees in-frame at acceptable CPU/GPU cost, (without using cards or manual LODs). Having taken the very basic concept behind the Witcher 4's voxel-based rendering for distant items and combined that with Godot's native LOD capabilities. Covers challenges encountered and next steps remaining. The experimental implementation currently runs with stock Godot, no custom build or native GDExtension required.
- The advantages compared to cards/manual LOD
- Quantizing to voxels
- Handling multimesh LOD limitations
- How work is offloaded to non-render worker-thread
- Extending protonscatter to connect this custom renderer
- Fast loading/startup of scene with millions of items (MMI buffer streaming)
- Retrospective of project thus far
Playing PLANETENVERTEIDIGUNGSKANNONENKOMMANDANT on the big screen
The initial version of LibGodot was one of the major features of Godot 4.6. But the coolest features are just now in the process of being merged.
Building on the core library build features that were merged in Godot 4.6, the current LibGodot patches add:
- Restart support, so Godot can be stopped and restarted with a new configuration without exiting the application.
- Embedding the Godot UI into the host application on every platform: MacOS, iOS (including Mac Catalyst), Windows, Linux, and Android.
LibGodot is already being used in production with multiple languages like C++, TypeScript, Java/Kotlin, and Swift.
In the talk, I will describe the current and upcoming features of LibGodot, its use cases both in Game and Application development, and show live demonstrations of some of them, including:
- LibGodot allows enhancing mobile apps with interactive 2D and 3D content
- LibGodot will enable .NET developers to start up Godot from their .NET application so they can use standard .NET tools for development
- LibGodot can be used to provide complex 3D graphics capabilities in Qt apps
- LibGodot can be used from Python scripts and enable complex automation workflows
In this talk I'll go over the experiment I did as part of my Master thesis: make 12 games in 12 weeks (using Godot). In this experiment, I tried to learn more about the process of enjoying failure as a game developer, and the importance of finishing games, by (essentially) participating in 12 games jams. In this talk, I try to go over my motivations, discuss the experience and lessons I've learned, and whether or not I would recommend other game developers to do the same.
Endless Access is a non-profit which teaches learners future-ready skills through contributing to real video games. We are building Threadbare, an open-source 2D action-adventure game, both as an engaging game in its own right and as a venue for learners’ contributions, many of whom have little prior experience with Godot, game-making, and participating in larger projects. This talk discusses some of the game design, technical, artistic, and collaboration flow decisions that have been necessary to meet both goals, what compromises we have made, and some of the perhaps-unexpected upsides of these design choices.
The process to decide whether features are added or not to Godot has been figured out over the years. Unfortunately, as it is difficult to transmit to others, many contributors and users are left in the dark about it, making it more difficult for the Godot project to have more help.
This talks aims to shed light and present a simplified model of this process that should be easy to understand for everyone.
Godot’s Vulkan renderer already ships with native hardware ray tracing exposed through the low-level RenderingDevice, but getting from “Vulkan feature exists” to a Godot-shaped, tool-friendly API took a very specific set of design and plumbing decisions. In this talk I’ll tell that story: how I implemented the Vulkan ray tracing pipeline inside Godot’s rendering HAL and how it fits Godot’s object model.
We’ll walk through what was added and why: ray tracing shader stages (raygen, miss, closest hit, any hit, intersection), per-stage source/bytecode submission with compile-error feedback, acceleration structure objects (BLAS/TLAS), and the minimal command flow (begin, bind pipeline/uniform sets, push constants, trace, end). Then we’ll flip to the user side: how these pieces are driven from GDScript via RenderingDevice, how to structure multi-stage shaders for iteration, and how to sequence BLAS/TLAS builds, and ray dispatch.
Attendees leave with both a practical blueprint for using ray tracing in Godot today and a clear mental model of the engine-side implementation decisions that make it work.
Whether you are scripting gameplay in C# or GDScript, optimising performance with GDExtensions, or contributing to the Godot Engine itself, JetBrains Rider can help you. By supporting the full range of Godot's technology stack, Rider provides a smart, consistent experience whether you are writing high-level logic or low-level engine code.
In this talk, we’ll show how the IDE moves beyond basic autocomplete to deeply understand Godot-specific logic - catching broken Node paths, mismatched signals, and scene errors while you are still typing, long before you ever hit the "Play" button.
We'll also look at how Rider tames the more complex sides of Godot, like GDExtensions and changes to the engine itself. By providing a first-class environment for C++ and CMake, Rider makes working at the engine level as straightforward as working with C# and GDScript. Whether you are building a small indie project or digging into the engine’s core, come see how to sharpen your setup and make your daily development process a whole lot smoother.
Godot’s open, lightweight export model is a dangerous superpower. In the last couple of years we’ve seen a steady rise in “clone-and-reupload” scams across indie platforms: games repackaged under new accounts, “update” links swapped for malware, and stolen builds used as a trust badge to lure players into downloading the wrong thing.
You can’t make decompilation impossible, but you can make it expensive. We will explore methods and best practices to protect your IP from being hijacked by bad actors. Don't let it happen to you!
AnimationPlayers rely heavily on the CPU. Having a 100 AnimationPlayers with basic rigging and animations can already lag a lot.
So how can Godot show complex animations on 1000 characters at the same time, with no lag nor overheating?
Thanks to a recently merged pull request and a little extra effort, this becomes a reality.
Over the past 14 years I’ve been making YouTube videos, starting with scrappy Minecraft Let’s Plays that almost nobody watched. Since then I’ve learned a lot through trial and error, with several of my (relatively) recent Godot tutorials now reaching over 100,000 views.
In this talk I’ll share some of the things I’ve learned along the way: creating interesting thumbnails and titles, pacing videos to keep viewers engaged, and the process I use to plan and produce my videos. I’ll also talk about topics that come up outside the creation process, such as promoting your work, dealing with negative comments, and keeping the process enjoyable for yourself.
This talk is aimed at developers and artists who are curious about creating videos but aren’t sure where to start, as well as those who already make videos and want to take their work to the next level.
Fractals can be generated in many different ways. In this talk, I will explain how to generate a special kind of fractals (ifs fractals, for example the Sierpinski carpet or the Barnsley fern) in two different ways: a »copy and paste« method, and the chaos game. I have implemented the latter in Godot 4, together with a UI.
Window nodes let you open new windows on the players desktop, and you can do a lot with them! Like virtual pets and desktop decorations, but also games that play out between multiple windows, and characters and enemies leaving the bounds of their own games.
I'll show some examples of cool things you can do with window nodes, and give some useful tips to get started on using them to make more cool out-of-the-box games!
Last year at GodotCon Boston, we launched Xogot. This talk shares what we learned from a year of shipping Godot on iPhone and iPad, with a focus on the insights we gained from telemetry, crash reports, and real-world usage. We will discuss how those lessons helped us improve performance, stability, and the overall experience on Apple devices, and how they are feeding back into the broader Godot ecosystem through upstream PRs and the Godot Apple Plugins, which provide deep integration across macOS, iOS, and visionOS.
Being able to write a good proposal for a public grant is an important survival skills for indies and small businesses. But why is applying so hard? Having judged over a 100 proposals, I spotted reoccurring issues and frustrations. This talk goes into the details about how to write clear proposals, which details are vital to include (with bonus Godot specific ones) and why seemingly silly criteria are actually really important. Public grants are there to help you, let's make your proposal an easy pick!
As part of a battle video on GamedevTV I was tasked with making a Bullet Hell game with only one script. After some surprising discoveries while testing I found it was possible to make a whole game in Godot with no code at all.
In this quick talk I will cover some of the powerful resources and cursed techniques that make things as complicated as moving a player character, tracking health via RigidBody simulations and randomizing game state possible all in a project without a single script file. All giving some insight into just how powerful and versatile Godot can be even in extreme circumstances.
A good pipeline saves lives - yes, even yours!
This talk will go over how you can easily combine BPY (Blender's scripting API) and post_import scripts to automatically set up your 3D assets for gameplay as you import them into Godot, letting you iterate quickly while saving you from tedious busywork & human errors.
With a custom pipeline you'll be able to assign scripts, generate the nodes you need, replace markers with gameplay elements and get a working game object or level in Godot right as you press "Save" in Blender.
This is a beginner-friendly talk: you only need to have a basic knowledge of scripting, Blender & Godot to follow along.
A few months ago, I found a Reddit post about a tiny pattern: a cached getter. It solved a problem I'd been working around for some time. That sent me down a rabbit hole looking for more. Patterns that barely show up in Godot tutorials. Stuff borrowed from backend engineering, from modern Python, from the corners of Godot that everyone's a bit scared of.
In this talk, I'll walk through the ones I keep reaching for now, using code from the wave-based arena racing shmup I'm in the middle of shipping:
- The cached getter from that Reddit post;
- The underused repository pattern;
- The specification pattern;
- A lightweight dependency injection pattern
Expect code you can use on Monday and a few honest moments about what I'd do differently
-