Performance Engineer

This is a fully remote position, open to applicants in Canada.

📋 Description

• Lead the development of essential systems and performance initiatives from the planning and design stages through to implementation and optimization.

• Collaborate closely with engineers and cross-functional teams, providing technical leadership and ownership of features.

• CPU & Game Thread Optimization (~25%): Analyze and enhance the game thread, render thread, and RHI thread in Unreal Engine — identify cross-thread bottlenecks, tick overhead, and inefficiencies in the task graph.

• Troubleshoot and resolve hitching issues: address garbage collection pauses, streaming stalls, async loading conflicts, and spikes in physics simulation.

• Minimize tick overhead: identify UObjects and ActorComponents with unnecessary tick enabled, excessive work in critical paths, and incorrect tick group assignments.

• Optimize gameplay and engine code at the C++ level — not only profiling but also implementing and deploying the fixes.

• Implement custom profiling markers (SCOPE_CYCLE_COUNTER, CSV_SCOPED_TIMING_STAT, custom Unreal Insights channels) for ongoing regression detection.

• GPU & Rendering Pipeline Optimization (~25%): Analyze rendering performance using RenderDoc, PIX, NSight, Xcode GPU Frame Capture, and Unreal's GPU Visualiser — isolate draw call overhead, overdraw, shader complexity, and GPU memory bandwidth.

• Collaborate with the rendering team to improve material pipelines: reduce shader permutations, tune LOD, optimize occlusion culling, and enhance distance field shadows.

• Identify and alleviate GPU memory pressure: manage texture streaming configurations, render target pooling, and VRAM budget per platform.

• Possess a deep understanding of rendering architecture to distinguish between CPU-bound, GPU-bound, and bandwidth-bound frames and implement the correct fixes.

• Address platform-specific GPU constraints: recognize the significant differences in GPU architecture between PS5/Xbox Series and PC; be aware of the unique thermal and bandwidth profiles of mobile (Adreno, Mali, Apple GPU).

• Memory Profiling & Leak Detection (~20%): Ensure memory budget compliance on client projects: monitor resident set size, texture memory, audio memory, and engine overhead against platform limits.

• Detect and eliminate memory leaks in C++ using automated tools (ASan, Valgrind on non-console platforms, custom allocator hooks) and Unreal's LLM (Low-Level Memory tracker).

• Manage memory fragmentation: comprehend pooled allocators, custom memory arenas, and when Unreal's default allocation strategy leads to fragmentation during prolonged sessions.

• Console memory challenges are particularly demanding: operate within fixed RAM ceilings without swap capabilities. Experience in shipping under these constraints is essential.

• Develop memory regression tests that run in CI — ensuring ongoing compliance, not just one-time snapshots.

• Networking / Latency Diagnostics (~10%): Analyze and optimize Unreal's replication system: identify bandwidth-heavy actors and components, adjust replication frequency, and prioritize replication effectively under load.

• Assess client-server latency: differentiate network latency from server frame time and client simulation costs — do not conflate the two.

• Familiarity with NetStat, Unreal's network profiler, and packet-level capture when necessary.

• Scope: support multiplayer engagements where networking poses a performance challenge — not the primary focus on pure networking architecture.

• Profiling Tool Development & Automation (~20%): Create internal profiling tools in C++ (UE plugins) and Python — automate performance validation scripts, integrate regression detection with CI, and establish custom Unreal Insights data channels.

• Write automated performance regression tests: capture baselines, set threshold alerts, and visualize trends — ensuring regressions are detected during the build process, not during client reviews.

• Enhance developer-facing profiling UX: simplify the process for other engineers to identify their own bottlenecks without requiring specialist support.

• Document profiling methodologies and tool usage: enable other engineers to replicate analyses without the need for knowledge transfer sessions.

⛳️ Requirements

• A minimum of 5 years of professional game engineering experience, with at least 3 years in a dedicated performance, engine, or low-level systems role.

• At least 2 commercially released titles where performance was a clearly defined area of ownership — not a general engineering role with some profiling involvement.

• Proficiency in C++ at a deep level: understand memory layout, cache efficiency, branch prediction, SIMD, and the impact of compiler optimization decisions on runtime behavior.

• Expertise in Unreal Engine 5 profiling: fluent in Unreal Insights, Stat commands, LLM, and GPU Visualiser — not just familiar but experienced in using them to identify real problems in actual projects.

• Cross-platform experience: have shipped on at least two types of platforms (PC + console, or console + mobile) and comprehend the distinct constraint profiles.

• Proficient in Python: able to write automation scripts, integrate with CI, and process data for performance telemetry — not a Python developer but capable of handling Python-related tasks.

• Structural fix mindset: capable of profiling, identifying root causes, and implementing C++ fixes. Does not stop at merely providing recommendations.

• Able to articulate a performance issue to a gameplay engineer or producer without requiring them to understand the intricacies of the GPU pipeline.

• **Preferred**

• Experience with console certification performance submissions: has prepared and successfully passed performance gates for Sony/Microsoft.

• Mobile performance experience on Android (Adreno/Mali/Dimensity) and/or iOS (Apple Silicon GPU) — knowledgeable about thermal throttling, tiling architecture, and bandwidth constraints.

• Experience with custom allocator or memory pool implementations in C++.

• Knowledge of shader authoring: HLSL/GLSL fluency sufficient to read shaders and identify unnecessary ALU or texture sampling costs.

• Familiarity with Tracy, Optick, or custom in-house profiling frameworks beyond Unreal's built-in tools.

• Experience optimizing Nanite, Lumen, or other UE5-specific rendering features at an engine-level depth.

🏝️ Benefits

• This is a full-time employment position offering standard benefits in the province of Quebec.