In 2025, SEED (Search for Extraordinary Experiences Division) marks a decade of pioneering research and development at Electronic Arts. This keynote offers a behind-the-scenes look into how SEED operates at the intersection of cutting-edge technology and creative ambition, from moonshot prototypes to production-ready innovations.

ShaderToHuman (S2H) HLSL/GLSL library for debugging shaders

Shader debugging can be frustratingly opaque. Traditional methods, from guesswork to GPU captures, often fall short when rapid iteration and experimentation are needed. Shader2Human is a lightweight HLSL/GLSL library that brings human-friendly debugging tools directly into the shader development loop.

Vaporwave: Scalable Real-Time Smoke Simulation & Rendering

Realistic smoke remains one of the most challenging effects in real-time graphics, especially at scale. In this talk, the SEED team presents Vaporwave, a novel large-scale smoke simulation and rendering framework developed for modern game engines and hardware.

Blender Cycles: architecture of a unified CPU/GPU path tracer

Blender is an open-source 3D content creation suite, and Cycles is Blender’s physically-based path tracer for production rendering. On the user level, it provides flexible artistic control expected for a wide variety of production needs, while keeping interactivity and ease of use as its core design principle. On a technical level, it supports rendering on CPUs and GPUs from all major vendors with minimal amount of code duplication and permutation. This talk goes into architecture behind the render engine which makes it all possible. The talk covers concepts such as: The key architectural and design difference from real-time render engines. How does Cycles render engine manage to have multiple compute backends and keep it manageable from the development perspective. The megakernel approach: what is it, and how did we learn the hard way that the approach is considered harmful. The wavefront renderer: what is it, and how did we transition to it? The talk goes into details of the kernel scheduling. Texture filtering: hardware acceleration, stochastic filtering. Interactive viewport: since Cycles is not only used for final render (but is also used for interactive preview in viewport) there are a number of tricks implemented to keep viewport interactive.

Real-Time Graphics in Blender

Blender is an open-source 3D content creation suite (DCC) that includes real-time viewport. These features are built on an architecture that differs significantly from traditional game engines. This presentation explores the architectural choices made in Blender to support real-time feedback with dynamic, unpredictable scene data.

The aircraft of Theseus - Shipping X-Plane for 30 years.

Moving to Vulkan and Metal from a GL 2.1 powered engine, while retaining support for plugins using GL 2.1 for their rendering. This happened and shipped during the v11 version run and was a 2 year undertaking involving writing a bunch of new tooling for shader authoring, pipeline baking and debugging to really take advantage of the features offered by the new APIs. Using the modern Vulkan and Metal engine to implement a lot of the new v12 feature like GPU based culling for trees using compute subgroup operations and indirect rendering. Showing that a lot of our work is incremental and how previous steps pave the way for future steps. Bringing Vulkan to mobile, replacing the GLES backend. This involved staring at driver disassembly to solve crashes and bringing back some dropped Vulkan features like render passes due to lack of driver support for Vulkan 1.3 features/extensions. Showing that not everything can be planned ahead of times and incremental steps have to be rethought.

The path to Real Time path tracing

V-Ray is one of the most popular renderers in the industry, widely used for architectural visualization, VFX shots in movies, automotive design, and more. Originally developed as a CPU-based photorealistic renderer using ray tracing, V-Ray has evolved over the years with a wealth of powerful features. With the advent of GPUs capable of efficient ray tracing, a GPU version of V-Ray was introduced to leverage this hardware acceleration. Chaos Vantage, on the other hand, is an entirely separate product—a real-time path tracer built on DirectX 12. It achieves photorealistic quality comparable to V-Ray but in real time, fully utilizing the ray tracing capabilities of modern GPU generations. In this session, we’ll explore the journey of transforming an offline renderer into a real-time path tracer, covering both the technical challenges and the solutions that made it possible.

Water Simulation & Rendering in Enshrouded

Flooding the world of Enshrouded: Keen Games' approach to simulating and rendering small to large scale water bodies. We will present how our new water system works in a dynamic voxel based environment and what challenges we had to solve for our multiplayer open-world title. This talk will present both the simulation side, network synchronization and how we transform and render the water.

The fog is lifting, volumetric rendering Enshrouded

This presentation delves into the completely reworked volumetric rendering techniques that bring the world of Enshrouded to life. The new approach significantly improves visual quality with comparable performance, combining a froxel-based system for atmosphere and weather with a high-fidelity, ray-marched solution for the dense, eponymous shroud. To complete this multi-layered system, a separate, dedicated ray-marching technique is utilized to render the game's cloudscapes.

Lessons learned from shipping a GPU Particle System

Keen Games is shipping a fully GPU driven particle system for the first time with Enshrouded. What has started as a promising idea allowing for fast iterations and artistic freedom turned into a compute shader permutation and compilation nightmare. We want to share what we did, which problems arose and how we're addressing them.

Split for Speed: Scalable Rendering with Smart Build Delivery and GPU-Aware Throttling in UE5

GOALS is an upcoming competitive football game with a clear vision: to deliver the world’s best football experience—to everyone. That means running well on nearly any device, from high-end GPUs to decade-old integrated graphics like Intel HD 4600. To achieve this, we’ve engineered two dedicated Unreal Engine 5 builds: a Performance Build using forward shading, Shader Model 5, and support for DX11/12 for lower-end hardware, and an Experience Build using deferred shading, Shader Model 6, and DX12-only for modern high-end systems. A custom launcher (distributed via Steam) detects the user’s hardware and automatically delivers the right build and DLC. On top of that, our GPUThrottle system enables dynamic FPS scaling using GPU temperature and fan RPM—featuring modes like fixed, temperature-aware, and silent—to maintain responsiveness while respecting thermal and acoustic constraints. This talk explores how we balance performance, reach, and fidelity through intentional build separation and real-world-aware rendering strategies.

Bringing Hitman to your pocket

Hitman World of Assassination for iOS has been announced! In this talk we aim to walk you through how we managed to bring an established PC/console title to low-power, handheld devices. We will start from our asset pipeline, to adding a brand new Metal backend to our Glacier engine, all the way to the optimizations needed to make the game playable at stable frame rates on mobile devices. The presentation will give context as to why we made certain decisions and what our constraints were in the moment, while also serving as a list of pointers to be aware of when developing for TBDR architectures and Apple Silicon devices.

Root signatures & shader ISA

A low-level talk about dx12 root signatures and their impact on shader ISA. In this talk we will explore how root signatures change the shader ISA. What are descriptor tables, root descriptors and root constants? How are static samplers and bindless implemented under the hood? We’ll deep dive into these and explore how each of them is implemented in ISA. Additionally, we’ll investigate the different performance characteristics of each of these. The primary focus will be AMD ISA but I can also include snippets from Nvidia (SASS). Experience with shader ISA is not necessarily required as I’ll try to explain each relevant instruction as we go.

Variable-Rate Compute Shaders in DOOM: The Dark Ages

In this talk, we’ll present the use of Variable-Rate Compute Shaders (VRCS) to improve GPU performance in DOOM: The Dark Ages (DtDA). DtDA was developed by id Software and released in May 2025 on Xbox Series X|S, PlayStation 5 and PC to critical acclaim.

Visibility Buffer and Deferred Rendering in DOOM: The Dark Ages

In this talk, we’ll present the new geometry rendering pipeline developed for idTech 8. Instead of rendering geometry in multiple passes and relying on a standard Forward+ opaque lighting evaluation using pixel shader we’ll show our journey towards using a triangle visibility buffer and a fully compute-based rendering approach. We’ll detail and compare different shading-dispatch strategies and share important performance considerations and guidelines we’ve discovered. In addition, we show how we combined this approach with an optimized tiled deferred lighting algorithm that’s also capable of performing compute-based software VRS These rendering techniques were shipped in DOOM: The Dark Ages (DtDA), developed by id Software and released in May 2025 on Xbox Series X|S, PlayStation 5 and PC to critical acclaim.

Appearance Editor in Dragon Age

Appearance Editor tool was used for creating character appearances in Dragon Age: The Veilguard, which is the latest installment in the Dragon Age series. This presentation is divided into 2 parts: first part will go over the architecture of the tool itself and how characters were shaped using this tool. Second part will go over the character creator in game and technical decisions made to fulfill the game’s requirements. We showcase the variety of character customizations that were allowed and how the performance and memory budget were kept in check. Presentation also shows how the same appearance tool can be used to make characters of varying complexity and randomizing the appearances for crowds.

Raytracing Voxels in Teardown and Beyond

The dynamic world of Teardown poses a unique rendering problem. Voxel art style meets realistic lighting in a physically simulated and breakable world. The game relies on an unconventional raytracing technique that runs well on older GPUs without dedicated raytracing hardware. We take you through the decisions that led up to the original rendering method along with the limitations that come with it. Following this, we'll take a peek into the future and present how we're evolving this technique into our next-generation renderer for an upcoming game, to make efficient use of modern hardware.

Temporal AA/upscaling and frame generation in Warhammer 40,000: Space Marine 2 and RoadCraft

Modern real-time rendering relies heavily on temporal anti-aliasing, upscaling, and frame generation. This talk shares insights from our practical experience integrating FSR, DLSS, and XeSS in the current-gen iteration of our custom in-house engine used in Warhammer 40,000: Space Marine 2 and RoadCraft, and explores how we navigated common pitfalls such as ghosting, flickering, and aliasing artifacts.

DOOM: The Dark Ages uses a real-time path tracing to deliver high-fidelity lighting to the game’s already fast paced action. DLSS and NRD were both integrated into the engine to enable full path tracing across the range of desktop GPUs. The path tracing solution was designed to work alongside the available scaling technologies provided by desktop GPU vendors, ensuring broader platform compatibility. Path tracing enables consistent and realistic global illumination throughout the game's gothic environments, unifying lighting, shadows, reflections, and ambient response under a single model. Integrating the path tracer into a renderer that already supported ray-traced features introduced several challenges, as it had to work seamlessly with the game’s existing assets, material systems, and tooling without requiring a complete reauthoring of content. The path tracer leverages SHaRC (Spatially Hashed Radiance Cache) to reuse radiance across bounces and Opacity MicroMaps (OMMs) to accelerate intersections through alpha-tested geometry—both critical to achieving the target frame rate. We’ll cover how these systems interact, their impact on GPU performance and memory usage, and the trade-offs made during integration. We’ll also touch on challenges we encountered—such as denoiser instability, refraction handling, and VRAM pressure—and how we addressed them. Finally, we'll look at how these components come together to form a stable, scalable renderer that balances visual quality, latency, and resource constraints.

Profiling with PIX

In this session you will learn how to use PIX for Windows to optimize your DirectX 12 renderer. The session will focus on profiling methodology, GPU architecture, and how to interpret high frequency counters. Finally, we'll discover how to bring this knowledge to bear to make your renderer go faster.

Ray Tracing on Qualcomm® Adreno™ GPUs

This talk will explore the ray tracing architecture of Qualcomm Adreno GPUs, providing an in-depth look into our latest ray tracing capabilities and features. Attendees will gain valuable insights into best practices for developing ray tracing applications on our hardware. Finally, the session will cover Qualcomm-specific tools and resources available for developers, enabling them to maximize the potential of our technology.

After the Tutorial: Where to Continue your Graphics Programming Journey

There exist many great courses, tutorials, and books that describe the fundamentals of graphics programming with various graphics APIs like OpenGL, DirectX, Vulkan, etc. However, the next chapter often missing from tutorials, is how to start building a rendering pipeline that puts these features into a unified framework. In this talk, I will discuss 'the next chapter' of the graphics programming tutorial that describes how to build a rendering framework: automatically parsing uniforms, handling materials, uniting the compute and graphics shaders, navigating the screen tree, and bringing order to a graphics pipeline that has multiple passes over a series of frames. This talk is targeted towards folks who are newer to graphics programming with an API, but who otherwise have dabbled enough to have implemented the phong illumination model. After leaving this talk, audience members will have a path forward toward implementing a graphics framework, and otherwise understanding graphics architecture talks with big pipelines.

Seed-Based Character Generation in Unreal Engine 5

At GOALS, we're building a new free-to-play, esports-ready football game in Unreal Engine 5, where every player character is visually unique - generated on the client at runtime using seed data provided by the server. But unlike traditional randomization, our characters are statistically grounded: visual features such as skin tone, facial structure, and hair type are influenced by real-world demographic distributions tied to character nationality. In this talk, we'll share how we built a scalable, deterministic character generation system that balances artistic control, statistical authenticity, and runtime performance.

A Methodical Approach to Profiling & Optimizing Graphics

Profiling is a technological challenge that benefits from a careful scientific approach. Optimization workload is rarely known ahead of time, so new bottlenecks must be detected iteratively using a wide suite of profiling tools. This talk will take a dive into the profiling & optimization pipeline used during the development & porting of King of Meat for low power platforms.

Bridging Pixels and Code: Teaching Computer Graphics to Technical Artists

This talk offers a retrospective on how we teach computer graphics in a bachelor’s program that prepares students for roles as technical artists and game programmers in the video game and movie industry. With diverse skill sets and perspectives, these students work at the intersection of creative expression and real-time technology, where a solid grasp of rendering fundamentals is essential. From the structure of our curriculum to the integration of modern graphics APIs, we will share how we build a common foundation that supports both artistic and technical growth. The talk will highlight common hurdles students face, reveal concepts that are often overlooked, and offer practical strategies we have developed to make complex ideas more accessible and relevant for production-ready

Sending More Dudes - A Helldivers 2 Xbox postmortem

For once, the main challenge wasn't the port itself. What were the difficulties of bringing a constantly evolving game to a new platform? How did we optimize the Xbox Series S to run Helldivers 2's chaotic, explosive end-game missions as smoothly as possible? In this talk, we'll explore the technical challenges and design decisions behind these questions, and share what worked, what did not, and what lessons we learned along the way.

Battlefield 6: Pushing visual fidelity while optimizing for all hardware

This presentation covers how we pushed visual fidelity in Battlefield 6 while meeting performance targets across a wide range of hardware, including Intel integrated GPUs. We'll discuss our approach to optimizing for PC, the development and deployment of a GPU-driven geometry pipeline, parallelization with the CPU to allow for better throughput, and our migration to an entirely new shader graph-based material authoring system and renderer. Additionally, we'll cover the implementation of XeSS Super Resolution and Frame Generation, which deliver an exceptional performance uplift and improved power consumption to provide an enhanced experience for Intel mobile and handheld gaming platforms.

How to Decimate your textures – BCn compression tricks in Horizon Forbidden West

In this talk we present how we used DXT1/BC1 to encode high-precision scalar values for the clouds and heightfield shadows in Horizon Forbidden West. This format has some historical quirks which make it difficult to accurately predict the sampled values. This talk will cover our experiences, explain the limits of the approach, map out the pitfalls, and includes all the details needed to easily replicate it in your codebase.