What a Junior } should know

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.

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.

Uses coroutines (Unity) / async-await (C#) for asynchronous operations in XR. Loads assets asynchronously to prevent freezes. Understands the event-driven model.

Follows the code style guide for the XR project. Writes clear and documented code. Uses linters and auto-formatting. Follows Unity/Unreal naming conventions.

Uses fundamental data structures for AR/VR development: List, Dictionary, Queue. Understands when to use arrays vs linked lists. Works with Transform hierarchies.

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.

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.

Applies OOP principles (encapsulation, inheritance, polymorphism) in C# for Unity. Creates component-based architecture for AR/VR objects. Understands SOLID principles.

Writes basic unit tests for XR logic using NUnit / Unity Test Framework. Tests helper functions and utilities. Understands the AAA principle (Arrange-Act-Assert).

Participates in code review as a reviewee. Responds to comments and fixes code. Learns colleagues' approaches to XR development.

Works with Git: commit, push, pull, branch, merge. Understands Git LFS for working with large XR assets. Resolves simple merge conflicts.

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).

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.

Works with Unity Editor: creates scenes, configures GameObjects and components. Writes C# scripts (MonoBehaviour lifecycle). Uses Prefabs, ScriptableObjects. Configures input via Input System.

Works with Animator Controller / Animation Blueprint for XR characters. Sets up basic animations: idle, walk, grab. Uses Animation Clips and Blend Trees.

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.

Uses built-in physics in Unity (Rigidbody, Collider) / Unreal (Physics). Configures physical materials and collision layers. Understands the difference between dynamic and kinematic bodies.

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).

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Implements basic VR locomotion: teleportation and snap turn. Configures comfort settings to reduce motion sickness. Understands cybersickness issues and contributing factors.

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.

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.

Understands the criticality of latency for VR/AR (motion-to-photon < 20ms). Knows the main sources of latency: rendering, tracking, display. Measures frame time.

Uses Unity Profiler / Unreal Insights for basic CPU profiling. Identifies hotspots in VR applications. Understands the frame budget for VR (11ms).

Uses Memory Profiler in Unity / Unreal to track memory usage. Identifies obvious memory leaks. Understands the difference between heap and stack memory.