Creating vibrant, immersive game worlds shouldn’t mean spending countless hours on manual modeling or ending up with bland, repetitive designs. By leveraging the C# workflow improvements in Godot 4 alongside JetBrains Rider, developers can turn language models into procedural co-creators while keeping their own artistic vision intact.

This 30-minute technical session builds a live, cohesive procedural generation pipeline (PCG) that turns human-friendly prompts into tangible game environments. It shows how to run a local open-source AI agent with Ollama in tandem with cloud endpoints to generate precise, typed JSON configuration schemas that feed directly into statically typed C# models.

You’ll see how to expose AI parameters and scene references right in the Godot Inspector, so you can prompt, adjust seeds, and rebuild environments in real time inside the editor, with immediate player execution and debugging feedback through Rider.

Whether you’re crafting 3D heightmap terrain with FastNoiseLite or designing 2D procedural dungeons with TileMaps and dual-grid algorithms, the session shows how to connect algorithmic generation to handcrafted static locations, keeping a solid foundation for tutorial areas, named landmarks, and deliberately designed gameplay moments.

This talk explores how the Entity Component System (ECS) paradigm can be introduced into an already shipped mass-market game without rewriting the entire engine or disrupting a live product.

Drawing on experience with proprietary engines and Unreal Engine, it covers the practical challenges of connecting ECS to legacy scene representation, components, and scripting layers, as well as the compromises required around memory layout and performance. The session presents a staged migration approach and explains why a hybrid ECS and legacy architecture is often the most sustainable outcome for a live game.

Modern continuous integration shouldn’t force you to jump between your IDE, a browser, and a build server just to figure out why a build broke. This talk introduces two ways to bring TeamCity into your everyday workflow: MCP support, which lets Rider (and AI assistant) query builds and fix CI issues without leaving your editor, and the TeamCity CLI, for scripting and interacting with your server straight from the terminal. We’ll walk through a real Unity build pipeline as our example and then show how the same techniques carry over to any tech stack. You’ll leave knowing how to keep your CI close to where you actually work.

Gameplay performance doesn’t usually collapse in one catastrophic mistake. It erodes one engineering decision at a time.

Through practical Unreal Engine examples, live profiling, and real-world debugging workflows, this session explores how everyday gameplay patterns turn into bottlenecks as a project grows. Following a complete optimization workflow with Unreal Insights and Rider, you’ll pick up practical techniques for building gameplay systems that scale and stay performant.

As AI moves into production pipelines, one question keeps coming up: How much UI integration can it really take on?

This talk answers that question with a case study of a Figma-to-Unity pipeline that grew over years of production and now runs through an AI agent over MCP. Alina, Senior Unity Developer, and Olia, Lead UI/UX Designer, cover the design foundation, the lessons from building it, and a benchmark of what the agent can handle today. You’ll leave with a working solution and the tools to try it on your own projects.

Your client is C# and your server is C++. How do you debug both of them at once and get something useful out of it? Rider and CLion give you the tools for both, and being able to read the data coming across the protocol while watching what each runtime is doing is a huge boost.

This talk is about connecting the two and understanding where one ends and the next begins. That includes how to work out which runtime is lying, how to make a bug that spans both of them reproducible, and why the boundary is the last place to look rather than the first.

Generic AI can write code, but the hard parts of Unreal Engine development happen across editor workflows, engine subsystems, build errors, crashes, and configuration files. This session shows how JetBrains Rider, ACP, and UE-specific skills can give AI agents engine fluency and practical access beyond source code. Through live demos, we’ll cover AI-assisted workflows for architecture, C++ scaffolding, crash triage, actor placement, and automated testing.