Behind every great game, dev tool, and engine there’s a dedicated community – and increasingly, that community is becoming part of the product itself. This panel looks at where community feedback and data can be genuinely helpful and when it's best to politely ignore them. We'll also explore how AI can support people, especially juniors learning the fundamentals, without doing the thinking for them.

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.

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.

AI generates an unprecedented amount of code. However, it can also produce an unprecedented amount of technical debt.

In this talk, we’ll start by aligning on our definition of code quality, what poor code quality means in terms of business outcomes, and the kinds of issues AI creates and why. We’ll then explain how static analysis can help you alleviate these problems and where it's most useful in an AI-powered development pipeline. To round it out, we’ll use a Qodana workflow as an example to show how it can be used to improve quality and cut costs in your projects.

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.

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.

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.

Game studios have a version control problem most software teams never deal with: repositories full of huge binary files, engine assets, packaged content, textures, and audio, where a single file can be several gigabytes and changes constantly. Git snapshots every file on every commit, which stops working at that size. Centralized tools scale better, but they solve it with edge servers that hold their own working replica, something you have to size and keep in sync ahead of time.

Lore, Epic Games’ open-source VCS, doesn’t version whole files. It breaks them into content-addressable fragments, so changing part of a large asset only means moving the part that changed. That one design choice opens up more than faster commits. A new studio location or a distributed team doesn’t need a server pre-seeded with the whole repository, because an edge cache there fills in on demand as people work. CI pipelines get the same benefit, with disposable build agents that only ever pull the fragments a given build actually touches. It works because edge caches hold no authoritative data, the durable copy always lives in cloud storage, and QUIC keeps fragment transfer fast even at real production file sizes.

In this session, Ben and Ryn walk through how this works end to end. Then, drawing on their experience as AWS Solutions Architects, they show how to deploy it yourself using the Lore module in AWS’s Cloud Game Development Toolkit.

Attendees will leave with a working mental model of fragment-based storage, an understanding of why Lore’s architecture looks the way it does, and a starting point for running it themselves.

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.