3D Graphics & Computing 3
▼
Knows major 3D formats (glTF, FBX, OBJ, USDZ) and their applicability. Imports 3D models into Unity/Unreal and configures materials. Understands basic concepts: mesh, UV-mapping, normal maps.
Builds the 3D asset import pipeline for the project. Optimizes models: polygon reduction, LOD, atlas textures. Works with PBR materials and shaders. Configures lightmapping and baking for AR/VR.
Architects the asset pipeline for the XR project. Automates 3D asset optimization (batch processing, scripted import). Works with procedural generation for AR/VR content. Implements a USD pipeline for collaborative 3D workflows.
Defines 3D pipeline standards for the team. Coordinates work between 3D artists and programmers. Establishes asset budget guidelines. Implements automated asset quality checks.
Understands basic 3D math concepts: coordinate systems, vectors, transformation matrices. Uses quaternions for rotation representation in Unity/Unreal. Works with the Transform API for object positioning.
Fluently applies linear algebra in AR/VR development: dot/cross product, projection matrices, rotation interpolation (slerp). Solves spatial geometry problems: ray-casting, intersection tests. Understands the difference between Euler angles and quaternions.
Defines mathematical approaches for XR products. Mentors the team on 3D math. Conducts reviews of mathematical algorithms. Builds a library of reusable math utilities.
Understands spatial computing concepts: 3D interaction design, hand tracking, and spatial anchors. Builds basic AR/VR scenes with spatial awareness using ARKit/ARCore or OpenXR frameworks.
Implements spatial computing for AR/VR: mesh reconstruction, spatial mapping, occlusion. Works with persistent spatial anchors and cloud anchors. Uses scene understanding for integrating virtual content with the real world.
Defines the spatial computing strategy for products. Coordinates development of spatial features. Establishes spatial mapping quality metrics. Plans the architecture for multi-user spatial experiences.
Algorithms & Data Structures 2
▼
Knows fundamental data structures (arrays, hash tables, trees) and their applicability in XR. Understands Big-O notation. Implements simple search and sorting algorithms for AR/VR data.
Applies optimal algorithms for XR tasks: spatial hashing, octree for collision detection. Optimizes algorithms for time and memory in real-time XR. Uses graph algorithms for navigation.
Develops high-performance algorithms for XR: BVH traversal, frustum culling, spatial indexing. Optimizes for CPU cache lines. Architects data-oriented systems for XR.
Reviews team's algorithmic solutions. Defines efficiency standards for XR systems. Mentors on algorithmic thinking.
Uses fundamental data structures for AR/VR development: List, Dictionary, Queue. Understands when to use arrays vs linked lists. Works with Transform hierarchies.
Applies specialized data structures for XR: spatial hash maps, priority queues for event systems. Selects optimal data structures for specific XR tasks.
Designs custom data structures for XR optimization: NativeArray, NativeHashMap for DOTS. Implements lock-free structures for multithreaded XR. Optimizes memory layout.
Defines data structure usage standards for the XR project. Reviews architectural decisions on data structures.
AR Development 3
▼
Creates basic AR content using ready-made 3D models and animations. Works with Reality Composer / Spark AR for simple AR effects. Understands 3D asset formats (glTF, USDZ) and their limitations for AR.
Develops interactive AR content with animations and interactions. Optimizes 3D models for AR (polycount, textures, LOD). Uses Reality Composer Pro and Scene Understanding. Creates AR filters and effects for social platforms.
Builds an AR content production pipeline for the team. Coordinates work between 3D artists and developers. Defines AR asset quality standards. Creates a library of reusable AR components.
Getting started with ARKit (iOS) and ARCore (Android), performs basic AR session setup. Uses ARFoundation in Unity for plane detection and object placement. Understands the difference between world and face tracking.
Confidently works with ARKit and ARCore for creating AR applications. Uses image/object tracking, plane detection, and light estimation. Implements persisted anchors and AR collaboration sessions. Configures ARFoundation for cross-platform AR development.
Defines the AR platform strategy for the product. Architects the AR system for multi-device support. Coordinates AR feature development between iOS and Android teams. Establishes best practices for AR tracking and anchors.
Understands markerless AR tracking principles (SLAM, visual-inertial odometry). Uses plane detection for placing objects on surfaces. Works with face tracking for basic AR filters.
Implements world tracking with persistent anchors for stable AR positioning. Works with body tracking and hand tracking via ARKit/ARCore. Configures SLAM parameters for optimal tracking under various lighting conditions.
Designs the tracking strategy for AR products. Coordinates development of custom tracking solutions. Defines tracking requirements for various use cases. Establishes AR tracking quality metrics.
Clean Code & Refactoring 1
▼
Follows the code style guide for the XR project. Writes clear and documented code. Uses linters and auto-formatting. Follows Unity/Unreal naming conventions.
Conducts code reviews for XR code. Configures static analysis for C#/C++. Writes self-documenting code with clear naming. Refactors legacy XR code.
Establishes code quality standards for the XR project. Configures automated quality checks in CI. Architects for maintainability.
Defines the code quality strategy for the XR team. Conducts architectural code reviews. Establishes coding guidelines.
Code Review 1
▼
Participates in code review as a reviewee. Responds to comments and fixes code. Learns colleagues' approaches to XR development.
Conducts code reviews of XR code: architecture, performance, best practices. Leaves constructive comments explaining XR-specific decisions.
Conducts deep code reviews focusing on XR performance, memory, and architecture. Develops a review checklist for XR. Mentors through code review.
Defines the code review process for the XR team. Conducts architectural reviews. Establishes review guidelines.
Concurrency & Parallelism 2
▼
Uses coroutines (Unity) / async-await (C#) for asynchronous operations in XR. Loads assets asynchronously to prevent freezes. Understands the event-driven model.
Architects asynchronous XR systems: scene loading, asset streaming, networking. Uses UniTask for performant asynchrony in Unity. Manages cancellation for VR transitions.
Architects asynchronous XR systems. Optimizes the async pipeline to minimize GC allocations. Implements streaming loading without freezes for VR.
Defines asynchronous code standards for the XR project. Establishes approaches to streaming and dynamic loading.
Understands the need for multithreading in VR (90+ FPS). Knows that render and main threads are separate. Uses async/await for non-blocking operations in Unity/Unreal.
Works with multithreading for XR: Job System (Unity), TaskGraph (Unreal). Implements offloading heavy computations to worker threads. Understands thread safety and race conditions in the XR context.
Architects multithreaded XR systems. Uses Unity DOTS Job System for parallel computations. Optimizes the threading model to minimize frame spikes. Implements lock-free algorithms.
Defines the threading strategy for the XR project. Establishes multithreaded code standards. Reviews threading solutions.
Game Design 1
▼
Understands VR/AR UX principles: comfort, ergonomics, spatial UI. Implements basic UI elements in VR (world-space canvas, buttons, sliders). Follows platform guidelines (Meta, Apple).
Designs VR/AR interfaces considering ergonomics and comfort. Implements diegetic UI, head-locked and body-relative elements. Conducts usability testing of VR interfaces. Considers accessibility.
Develops a UX framework for XR applications. Designs adaptive UI that accommodates different XR devices. Creates a design system for spatial interfaces. Explores new XR UX paradigms.
Defines the UX strategy for the XR product. Coordinates UX research and design. Builds an XR design system for the team. Conducts UX reviews of XR features.
Game Engines 2
▼
Works with Unity Editor: creates scenes, configures GameObjects and components. Writes C# scripts (MonoBehaviour lifecycle). Uses Prefabs, ScriptableObjects. Configures input via Input System.
Architects Unity project structure (MVC/ECS approaches). Works with Addressables for asset management. Configures URP/HDRP for rendering. Uses Unity Profiler for optimization. Develops Editor tools.
Defines Unity project architecture and standards. Establishes CI/CD processes for Unity builds. Coordinates work with 3D artists and designers. Plans Unity version migrations.
Getting started with Unreal Engine 5: Editor, Blueprints, C++ basics. Creates simple scenes and levels. Works with basic BP scripting for prototypes. Understands the Actor/Component model.
Develops on Unreal Engine using C++ and Blueprints. Works with Nanite and Lumen for visual quality. Configures VR rendering in UE5. Uses the Enhanced Input System.
Architects UE5 project structure for VR/AR. Optimizes rendering for VR (instanced stereo, forward shading). Develops custom plugins and modules. Works with Unreal Insights for profiling.
Defines the technical strategy for using UE5 in VR/AR projects. Establishes coding and architecture standards. Coordinates with Epic Games when necessary.
Game Programming 4
▼
Works with Animator Controller / Animation Blueprint for XR characters. Sets up basic animations: idle, walk, grab. Uses Animation Clips and Blend Trees.
Implements IK systems for VR avatars (hand IK, body IK). Configures procedural animation for VR. Works with Animator Override Controllers for variety. Optimizes animations within the VR frame budget.
Develops custom animation systems for XR: full-body tracking, facial animation. Implements physics-based animation. Optimizes skeletal animation for mobile VR (bone reduction, animation compression).
Defines the animation strategy for the XR product. Coordinates work between animators and programmers. Establishes the animation pipeline for VR avatars.
Sets up basic audio in Unity/Unreal: AudioSource, sound effects. Understands 3D sound and its parameters (rolloff, spatial blend). Uses Audio Mixer for sound management.
Implements spatial audio for VR/AR using FMOD / Wwise. Configures HRTF for realistic 3D sound. Works with ambisonics format. Optimizes audio consumption for mobile VR.
Architects audio systems for XR projects. Develops dynamic audio systems based on spatial context. Optimizes spatial audio for various XR devices. Integrates audio occlusion and reverb zones.
Defines the audio strategy for the VR/AR product. Coordinates work between sound designers and programmers. Establishes audio quality standards for XR.
Uses built-in physics in Unity (Rigidbody, Collider) / Unreal (Physics). Configures physical materials and collision layers. Understands the difference between dynamic and kinematic bodies.
Configures physics for VR/AR: precise collisions, Physics.OverlapSphere, raycasting. Optimizes physics computations (broad/narrow phase). Uses joints and constraints for VR interactions.
Develops custom physics solutions for XR. Implements deterministic physics for multiplayer VR. Optimizes physics timestep for the VR frame budget. Works with soft body and cloth physics.
Defines the physics engine strategy for the XR project. Establishes performance budgets for physics computations. Coordinates development of physical interactions.
Understands rendering fundamentals for AR/VR: stereoscopic rendering, shader basics, and frame timing constraints for head-mounted displays. Uses engine profiling tools to identify GPU-bound issues. Follows team guidelines for draw call reduction and texture optimization in XR projects.
Optimizes rendering for VR: single-pass instanced, foveated rendering, fixed foveated. Works with URP/HDRP for VR. Develops shaders for AR (occlusion, shadow receiver). Optimizes draw calls and overdraw.
Defines the rendering strategy for the XR product. Establishes the rendering budget (GPU time, draw calls, textures). Coordinates work between graphics programmers and artists.
Game QA 1
▼
Understands the performance budget for VR (90 FPS, 11ms per frame). Uses Unity Profiler / Unreal Insights for basic profiling. Knows the main causes of FPS drops (draw calls, overdraw).
Profiles and optimizes VR/AR applications: CPU/GPU bottlenecks, memory. Uses RenderDoc for GPU analysis. Optimizes for mobile VR (Quest): LOD, occlusion culling, baked lighting. Monitors thermal throttling.
Builds a performance culture within the team. Defines performance budgets for all platforms. Implements a CI pipeline for performance regression testing. Coordinates optimization with 3D artists.
Git & Workflows 1
▼
Works with Git: commit, push, pull, branch, merge. Understands Git LFS for working with large XR assets. Resolves simple merge conflicts.
Uses Git strategies for XR projects: feature branches, rebasing, cherry-pick. Configures Git LFS for binary XR assets. Optimizes .gitignore for Unity/Unreal.
Configures Git workflows for the XR team. Optimizes working with large repositories (partial clone, sparse checkout). Designs branching strategy for multi-platform XR.
Defines the Git strategy for the XR project. Configures Git hooks and CI integration. Establishes branching and merging policies.
Memory Management 1
▼
Understands memory management in the VR/AR context (GC in Unity, reference counting). Avoids frequent allocations in Update/FixedUpdate. Knows about GC spikes and their impact on VR framerate.
Minimizes GC pressure in VR: object pooling, struct vs class, NativeArray. Profiles memory via Unity Memory Profiler. Manages AR/VR object lifecycle to prevent leaks.
Defines the memory budget for the XR project. Establishes memory management standards. Implements automated memory profiling in CI.
OOP & Design Patterns 2
▼
Knows basic patterns (Singleton, Observer, Factory) and applies them in XR development. Uses Observer for event-driven VR interactions. Understands the Component pattern in Unity.
Applies design patterns for XR: State Machine for VR states, Command for undo/redo, Object Pool for VR objects. Selects appropriate patterns for specific XR tasks.
Designs custom architectural patterns for XR. Combines patterns for complex XR systems. Adapts patterns to real-time XR constraints.
Builds a pattern catalog for XR development within the team. Reviews pattern application. Trains the team on architectural approaches.
Applies OOP principles (encapsulation, inheritance, polymorphism) in C# for Unity. Creates component-based architecture for AR/VR objects. Understands SOLID principles.
Architects OOP systems for XR. Uses interface-based design for cross-platform compatibility. Applies composition over inheritance for XR components.
Architects large-scale OOP systems for XR. Balances OOP and data-oriented approaches for optimal performance. Develops APIs for XR libraries.
Defines architectural approaches for XR projects. Conducts architecture reviews for SOLID compliance. Mentors on design.
Optimization 1
▼
Understands the criticality of latency for VR/AR (motion-to-photon < 20ms). Knows the main sources of latency: rendering, tracking, display. Measures frame time.
Optimizes end-to-end latency of VR/AR applications. Uses async time warp / reprojection. Minimizes input-to-render latency. Configures predictive tracking.
Defines the latency SLA for the XR product. Establishes the latency optimization strategy. Implements latency monitoring.
Profiling 2
▼
Uses Unity Profiler / Unreal Insights for basic CPU profiling. Identifies hotspots in VR applications. Understands the frame budget for VR (11ms).
Profiles CPU for VR/AR applications: deep profiling, marker-based profiling. Analyzes call stacks to find bottlenecks. Optimizes Update/FixedUpdate loops.
Performs deep CPU profiling of XR applications: cache misses, branch prediction, SIMD. Uses platform-specific profilers (Snapdragon Profiler for Quest). Optimizes at the instruction level.
Develops CPU performance strategy for the XR project. Implements automated CPU profiling. Defines CPU budgets for various systems.
Uses Memory Profiler in Unity / Unreal to track memory usage. Identifies obvious memory leaks. Understands the difference between heap and stack memory.
Performs detailed memory profiling of XR applications. Analyzes memory snapshots to find leaks. Optimizes texture and mesh memory for mobile VR.
Performs deep memory analysis of XR systems: fragmentation, allocation patterns. Optimizes managed/unmanaged memory balance. Implements custom memory tracking.
Develops a memory profiling strategy for the XR project. Implements automated memory regression testing. Defines memory budgets.
Unit Testing 1
▼
Writes basic unit tests for XR logic using NUnit / Unity Test Framework. Tests helper functions and utilities. Understands the AAA principle (Arrange-Act-Assert).
Writes tests for XR systems: interaction logic, state machines, event handlers. Uses mocking to isolate VR dependencies. Configures test coverage for the XR project.
Architects the testing strategy for the XR project. Creates test frameworks for VR/AR-specific scenarios. Automates regression testing. Implements playmode tests.
Builds a testing culture within the XR team. Defines coverage targets. Implements automated testing in CI for XR projects.
VR Development 3
▼
Works with VR controllers via XR Interaction Toolkit / OpenXR Input. Configures button mapping for Meta Quest / PCVR controllers. Implements basic hand tracking for standalone VR.
Develops custom controller mappings for various VR devices. Implements advanced hand tracking with gesture recognition. Configures haptic feedback for controllers and hand tracking. Integrates Ultraleap for high-precision hand tracking.
Defines the strategy for supporting various VR controllers and input devices. Establishes controller mapping standards for the team. Coordinates input system development. Evaluates new input devices.
Implements basic VR interactions: grab, point, click using XR Interaction Toolkit. Configures UI elements in 3D space (world-space canvas). Works with gaze-based interaction for standalone VR.
Designs complex VR interfaces with haptic feedback. Implements physics-based interactions (kinematic and dynamic object manipulation). Creates custom interactors and interactables. Works with hand tracking for natural interaction.
Establishes VR interaction standards for the product. Coordinates VR UX design with development. Conducts usability testing of VR interfaces. Defines accessibility standards for VR.
Implements basic VR locomotion: teleportation and snap turn. Configures comfort settings to reduce motion sickness. Understands cybersickness issues and contributing factors.
Designs locomotion systems considering user comfort. Implements smooth locomotion with vignetting and other comfort mechanics. Configures roomscale tracking and guardian/boundary systems. Creates custom locomotion systems (climbing, swimming).
Defines locomotion standards for the VR product. Coordinates research on comfort settings. Establishes VR user comfort metrics. Conducts A/B testing of different locomotion approaches.
XR Platforms 3
▼
Getting started with Apple visionOS and RealityKit. Studies SwiftUI for spatial interfaces. Creates simple immersive experiences in Reality Composer Pro. Understands concepts of shared space and full immersion.
Develops visionOS applications using RealityKit and SwiftUI. Implements spatial windows and volumes. Uses ARKit on visionOS for hand/eye tracking. Works with PolySpatial for Unity projects on visionOS.
Architects visionOS applications with immersive spaces. Develops custom RealityKit components and systems. Optimizes rendering for visionOS (render-to-texture, shader optimization). Integrates SharePlay for collaborative XR.
Defines visionOS development strategy. Coordinates migration of XR applications to visionOS. Establishes development and testing processes for Apple Vision Pro. Engages with Apple Developer Relations.
Develops applications for Meta Quest using Oculus SDK / Meta XR SDK. Configures the project for Quest builds (Android manifest, graphics settings). Tests and debugs on Quest devices.
Optimizes applications for mobile VR Quest (draw calls, overdraw, shader complexity). Uses Meta Interaction SDK for advanced interactions. Implements the Passthrough API for mixed reality. Works with Meta App Lab for distribution.
Defines the Meta Quest platform development strategy. Coordinates application optimization and certification. Establishes the release process for Meta Quest Store. Engages with Meta Developer Relations.
Understands the OpenXR standard and its role in unifying XR development. Uses OpenXR via Unity XR Plugin / Unreal OpenXR plugin. Configures the OpenXR runtime for target devices.
Works with the OpenXR API directly for cross-platform XR development. Uses OpenXR extensions (hand tracking, eye tracking). Configures action-based input through the OpenXR Input System. Debugs OpenXR runtime issues.
Defines the OpenXR adoption strategy for products. Coordinates cross-platform XR development based on OpenXR. Establishes standards for using OpenXR extensions. Participates in OpenXR working groups.