1st Year: Foundations, Core Concepts & Basic Algorithms

• Core Math & Programming: Fundamental Mathematics and procedural programming using C.
• Computer Science Fundamentals: Introduction to basic algorithms (sorting, searching), Big O notation, and fundamental data structures (arrays, linked lists, stacks, queues).
• Graphics & Production: Working with 2D graphic libraries and learning the basics of game production methods.
• Collaboration & Professional Growth: Participating in workshops, masterclasses, and an English-language curriculum, alongside a joint project with 1st-year graphic design students.

2nd Year: Advanced Programming, Vector Math & AI/Patterns

• Math & Coding Evolution: Transitioning to vector analysis mathematics and procedural programming in C++.
• Advanced Computer Science & AI: Graph algorithms (A* pathfinding, BFS/DFS), memory management (pointers, dynamic allocation), and complex data structures (binary search trees, hash tables).
• Software Design: Core design patterns frequently used in game development (Singleton, Factory, State Machine).
• Graphics & Production: Continued work with 2D graphic libraries and game production methodologies.
• Collaboration & Communication: Advanced workshops, masterclasses, English and communication skills, and a joint project with 2nd-year graphic design students.

3rd Year: Object-Oriented Programming, Advanced 3D Math, Shaders & Unity

• Advanced 3D Mathematics: Matrix numerical analysis, linear algebra, 3D transformations, and quaternions (for smooth 3D rotations, avoiding gimbal lock).
• Shaders & Graphics Pipelines: Introduction to programmable graphics pipelines, writing vertex and fragment/pixel shaders, manipulating buffers, lighting models, and visual effect creation.
• Object-Oriented Programming: Mastering OOP paradigms natively in C++ and C#.
• Engine Integration (Unity): Working extensively with Unity for 3D game development, mapping C# scripting to game objects, physics engines, and components.
• Engine-Level Computer Science: Advanced spatial data structures (graphs, trees) and architectural design patterns (Observer, Command, Component pattern) applied to game engines.
• Game Development Core: Deep dive into Gameplay, Game Engine, and Tools programming.
• Collaboration & Soft Skills: Workshops, masterclasses, English and communication development, and a joint project with 3rd-year graphic design students.

4th Year: Unreal Engine, AAA Optimization & Network Engineering

• Unreal Engine Systems & Production Core:
  • Advanced Engine Architecture: Deep interface with engine reflection systems for metadata management, automated garbage collection cycles, and memory safety abstractions. Mastering the core gameplay framework hierarchy to manage state, player input, and world actors.
  • Blueprint Integration Architecture: Designing modular boundary layers between code and visual scripting, exposing data securely, implementing polymorphic function overrides, and managing complex event execution flows via dynamic dispatch systems.
  • Advanced Materials & Custom Shaders: Constructing optimized node-based systems within the engine material editor; integrating custom HLSL blocks for specialized math; developing master materials, parameter-driven instances, vertex displacement physics, and post-process effects.
  • Animation Engineering Pipelines: Implementing runtime state machines, blend spaces, procedural inverse kinematics, and raw bone transformation modifications within the engine's animation evaluation loops.
• High-Level Systems Programming & Architecture: Advanced programming utilizing entity-component-system patterns to enforce strict data locality and maximize performance throughput, alongside offloading logic to background threads using engine-native task scheduling, managing synchronization through atomic operations, and handling complex dependency graphs.
• Low-Level Code & Hardware Optimization:
  • Code Profiling: Identifying performance bottlenecks, stalls, and critical path computations across isolated engine threads using industry-standard telemetry, hardware-sampling, and statistical analysis tools.
  • Data Locality & CPU Cache: Designing hardware-aware, cache-friendly systems to minimize L1/L2/L3 cache misses. Shifting from pointer-heavy object architectures to contiguous, array-based memory layouts.
  • Micro-optimizations: Maximizing instruction pipelining, optimizing branch prediction, minimizing context switching, and implementing branchless programming techniques to achieve peak frame-time consistency.
• Video Game Network Engineering (Low-Level to Cloud):
  • Socket Layer & Binary Serialization: Master low-level socket abstractions. Building custom binary stream packing to bypass text-based overhead, implementing manual endianness translation, data quantization, and delta compression.
  • Reliable Transport Layers: Engineering bespoke reliable transport protocols over raw datagram sockets to avoid head-of-line blocking; implementing sequence verification, rolling acknowledgments, and manual packet fragmentation management.
  • Synchronization Topologies: Coding robust replication architectures, including deterministic lockstep models, predictive input rollback systems for latency compensation, and authoritative client-server models with historical interpolation.
  • Cloud Infrastructure & Microservices: Architecting decoupled online services (Matchmaking, Inventory, Auth) using microservice patterns; routing transactions via API gateways and containerizing server instances for scalable cloud deployment.
• Advanced CS, Math & Production:
  • Applied Engineering Math: Multivariable differential calculus and numerical approximation methods for curve fitting, animation interpolation, and physics trajectory estimation.
  • Spatial Partitioning: Developing advanced tree-based structures (2D/3D partitioning) to reduce query complexity for collision and visibility detection.
  • Capstone Production: Masterclasses and a final-year team-based capstone project.