Senior Graphics Programmer

Writing high-performance rendering code, engine modifications, custom tools, and implementing complex algorithms. You'll be living in C++.

Implementing low-level rendering features, debugging API validation errors, optimising command buffer submission, and managing GPU resources directly. You'll be working very close to the metal.

Authoring complex vertex, pixel, and compute shaders for various effects, lighting models, and post-processing. You'll be translating math into beautiful pixels.

Modifying or extending the core renderer of a commercial engine (e.g., implementing custom lighting models, optimising the base pass, integrating new rendering features). This isn't just using the editor; it's digging into the engine's guts.

Independently using these tools to diagnose complex GPU performance issues like cache misses, shader stalls, driver overhead, and memory usage. You'll also be writing custom profiling instrumentation.

Managing complex merges and resolving conflicts in large, shared codebases. You'll understand branching strategies for feature development and release stabilisation, keeping our code clean and coherent.

• Lead Graphics Programmer
• Art Director and Senior Artists
• Technical Artists
• Engine Programmers
• QA Team

• Hardware Vendors (NVIDIA, AMD, Sony, Microsoft)
• Engine Developers (Unreal, Unity, custom)
• Industry Conferences (SIGGRAPH, GDC)

As visual fidelity increases, shaders become more complex and performance-critical. Understanding the nuances of different GPU architectures (e.g., register pressure, instruction throughput, memory bandwidth on NVIDIA vs. AMD vs. Apple Silicon) will be key to squeezing out every last frame. Generic optimisations won't cut it anymore.

Shader Instruction Latency & Throughput · Register Pressure & Spill · Memory Access Patterns (texture caches, L1/L2) · SIMD/Wavefront Optimisation · Platform-specific Shader Intrinsic Functions

• This week: Dive into the documentation for a specific GPU architecture (e.g., NVIDIA Ampere or AMD RDNA 3).
• This month: Profile a complex shader using vendor-specific tools (Nsight Compute, RGP) and identify instruction-level bottlenecks.
• Month 2: Experiment with rewriting parts of a shader to reduce register pressure or improve memory access patterns.
• Month 3: Share your findings with the team, explaining how specific hardware features impact shader performance.

Quick win: Pick your most complex pixel shader, profile it with vendor tools, and try to reduce its instruction count by 10%. You'll learn a lot.

Creating massive, detailed worlds manually is becoming unsustainable. PCG, especially with AI assistance, will be crucial for generating environments, textures, and even entire assets. As a graphics programmer, you'll need to understand how to render and integrate this dynamically generated content efficiently.

Noise Functions (Perlin, Simplex) · L-Systems & Fractals · GPU-based Generation (Compute Shaders) · Data-Driven Asset Streaming · Integration with AI-generated assets

• This week: Research basic procedural generation techniques for textures or meshes.
• This month: Implement a simple procedural texture generator using a compute shader.
• Month 2: Experiment with generating simple geometry (e.g., terrain, foliage) on the GPU.
• Month 3: Look into how to integrate and stream large amounts of procedurally generated data efficiently into the rendering pipeline.

Quick win: Write a shader that generates a simple noise pattern and use it as a texture. Then try to animate it. It's a fun way to start.