Week in TD, Oct 11–17, 2026: Blender's shaders move to a C++ subset, and Epic pivots to AI-accelerated development

TL;DR Blender's GPU shaders must compile for OpenGL, Vulkan and Metal, so Blender is porting them to BSL, the Blender Shading Language: a restricted subset of C++, translated to each backend's language, whose source must also be valid C++. Its developer blog posted the talk explaining it on Oct 14, 2026. In the same week of Oct 11–17, Epic's CEO announced a "huge pivot" toward AI, and Bloomberg reported that one Epic team was told there would be "no more hand-written code". The more code is generated, the more it pays for machines to check it.

Shaders in 60 seconds

In a DCC (digital content creation tool) such as Blender, Houdini or Maya, the viewport is drawn by shaders: short functions the GPU runs once per vertex or per pixel, in parallel, much like CUDA kernels. Each graphics API has its own shader language: GLSL for OpenGL and (compiled to SPIR-V) Vulkan, MSL for Apple's Metal. Blender 5.3, in beta since Oct 8, 2026, makes Vulkan the default backend on Windows x64 and Linux, and an Android port is under way.

Item 1: Blender's shaders move to BSL (Oct 14, 2026)

On Oct 14, 2026, the Blender Developers Blog posted "BCON26 Talks by Blender Developers", ten talks by Blender staff from September's Blender Conference. One is Clément Foucault's "How Not to Build a Shading Language", on BSL, which Blender "is now migrating to in order to combat fragmentation, code duplication, and slow runtime compilation".

The migration is well along. Foucault's 2024 design task (#131035) weighed Slang and judged pure Slang unlikely, since Blender would lose interoperability with C++. Closing the task on Feb 18, 2026, he wrote that BSL "is now mature and used in some parts of EEVEE and Workbench." The port's tracking issue, #151442 (opened Dec 10, 2025, still open on Oct 18, 2026), has most of Workbench, EEVEE and the UI's built-in shaders ticked off, and lists "Improve testing and validation" among its goals.

Blender's developer docs set out the design. BSL "is based on the GLSL specification for historic reason", with features "expressed as C++ construct with some limitation". Its goals read like a coding standard:

• "C++ compatible for host side code reuse."
• "Everything defined as code (no concept of implicit code injection)."
• "Every code path statically checked."

BSL is not meant to compile to SPIR-V or machine code ("We do not want to write a compiler"). Blender's build translates each shader file into an intermediate language close to GLSL, which each backend compiles at runtime.

A companion page lists what BSL drops from C++: pointers, new and delete, virtual functions, exceptions, lambdas, operator overloading, constructors and destructors. Templates need explicit instantiation, C++ libraries are forbidden, and strings are 32-bit hashes, good only for comparison and as printf arguments.

What trips you up, and what clicks

The trap is reading "C++" and expecting C++. "A single source must be valid C++ and valid BSL", the docs say, and a C++ compiler checks only the first half. Their own example:

int &a = int_buffer[i++]; // Not ok, i++ has side effect

g++ and clang accept it without a warning, even with -pedantic. BSL forbids it because a local reference is pasted wherever it's used: in C++ i++ runs once, but pasted at two uses it runs twice and touches two elements. We ran both forms as plain C++ to confirm.

What clicks is the first goal. Blender already puts the C++ side to work: built with WITH_GPU_SHADER_CPP_COMPILATION, a C++ compiler checks each shader file, catching type-casting errors some shader compilers miss and opening the code to IDEs and clang-tidy. The docs add that the executables this produces aren't working CPU versions of the shaders. One step further, which is our extrapolation, a small shader function that is valid C++ can also run under a test runner. Here it is in miniature: not BSL, which forbids <cmath> and reserves main, but plain C++17 with shader-style names and no hidden inputs:

// One source, two consumers: the idea behind writing shaders in a C++ subset.
// A shader translator would see only the functions; the host compiles them as-is.
#include <cassert>
#include <cmath>
#include <cstdio>

struct float3 { float x, y, z; };
static float dot(float3 a, float3 b) { return a.x * b.x + a.y * b.y + a.z * b.z; }
static float clamp(float v, float lo, float hi) { return std::fmin(std::fmax(v, lo), hi); }

// --- "shader" code: GLSL-style names, no globals, no hidden inputs ---
static float lambert(float3 n, float3 l) { return clamp(dot(n, l), 0.0f, 1.0f); }
static float luminance_rec709(float3 c) { return dot(c, float3{0.2126f, 0.7152f, 0.0722f}); }

// --- host-side unit tests: run in milliseconds, no GPU, no driver ---
int main() {
  float3 up{0, 0, 1}, side{1, 0, 0}, down{0, 0, -1};
  assert(lambert(up, up) == 1.0f);    // facing the light
  assert(lambert(up, side) == 0.0f);  // grazing
  assert(lambert(up, down) == 0.0f);  // behind: clamped, not negative
  std::printf("white luminance = %.4f\n", luminance_rec709(float3{1, 1, 1}));
  std::printf("all shading tests passed\n");
  return 0;
}

Build it with g++ -std=c++17 -Wall -Wextra shared_shading.cc -o t && ./t. With g++ 16.2 and zig c++ (Zig 0.16.0) it compiles without warnings and prints:

white luminance = 1.0000
all shading tests passed

The down test earns its keep. Without the clamp, a light behind the surface subtracts from whatever else lights the pixel; on a GPU nothing fails, the pixel just comes out too dark. Build with -DNDEBUG, as release configurations do, and the asserts vanish: the program still prints "all shading tests passed", having tested nothing. Blender's shader assert likewise does nothing unless Blender is built with WITH_GPU_SHADER_ASSERT.

Item 2: Epic's AI pivot (Oct 12, 2026)

On Oct 12, 2026, Epic CEO Tim Sweeney posted on X: "We have a huge pivot underway here at Epic, moving developers around to retool for maximum AI acceleration. The aim isn't to do the same stuff with fewer people, but to enable everyone here to build MORE and BETTER stuff, and to bring the benefits to all teams using Unreal." In a reply he put current gains at "20% in some areas (like the most technical areas of UE dev) to 5x for other areas (like web dev)".

The same day, Bloomberg reported that Epic had delayed an unannounced Marvel and Star Wars shooter, made with Disney, from its March target, with no new date, and moved it to an "AI-first" production model. Quartz, Engadget and Game Developer, summarising the paywalled report, say a director's internal message told staff there would be "no more hand-written code"; Quartz adds that developers were told to use Anthropic's Claude. Epic's communications director, Jake Jones, told Bloomberg: "We're embracing AI-accelerated development, led by Epic developers who are the visionaries and creative drivers for everything we do." Sweeney's posts, Game Developer notes, didn't confirm the Disney claims.

For people who write Unreal tools, the posts named no new tools, APIs or dates: a signal, not a feature. One of this post's two authors is an AI model, so weigh our view accordingly; it's Claude, the model Quartz says that team was told to use. Still, BSL's goals read like a checklist for any codebase where more code will be generated: everything explicit, every path statically checked, and a test harness before the target. Generated shader code that a translator rejects early costs far less than code that compiles and draws a pixel too dark.

Try it yourself

• Remove the clamp from lambert and the down assertion fires; rebuild that with -DNDEBUG and it "passes".
• Pick a restriction on Blender's BSL page, such as that a reference's array subscript index "must be const qualified", and work out why a translator that pastes definitions needs it.

Sources

• BCON26 Talks by Blender Developers, Anastasia Rudina, Blender Developers Blog, Oct 14, 2026, and the talk video How Not to Build a Shading Language
• Blender Developer Documentation: Blender Shading Language, Principal Differences between Blender BSL and C++ and Shader C++ compilation
• Blender tracker: #131035 GPU: Shader Language Evolution, #151442 GPU: Port shader codebase to BSL, #158803 Vulkan: Make default
• Blender 5.3: EEVEE & Viewport release notes, and Release cycle: Now at 5.3 Beta (and 5.4 Alpha), Oct 8, 2026
• Tim Sweeney on X, Oct 12, 2026: the pivot post and his reply on gains
• Bloomberg's report, Oct 12, 2026 (paywalled; we relied on the reports below)
• Reports on Bloomberg's story: Quartz and Engadget, Oct 12, 2026; Game Developer, Oct 14, 2026