The expanded syllabus below is suitable for the national authority page. On the website, present it as an accessible accordion while keeping all module text available in the rendered HTML. The active batch may adjust project depth, but the page must not advertise modules that will not be delivered.
Module 1: Game Development, Industry Roles and the Unity Ecosystem
The course begins with a clear view of how modern games are planned, produced, tested and released. Learners distinguish game design, game art, game programming, level design, technical art, quality assurance and production. They explore the Unity Editor, Unity Hub, packages, templates, scenes, GameObjects, components, prefabs and the relationship between assets and code. The module also explains 2D, 3D, mobile, desktop, web and XR project types so students can connect course topics to realistic portfolio goals. Rather than presenting Unity as a collection of buttons, the training introduces it as a complete real-time development environment in which design decisions, code, assets, testing and platform constraints work together.
Module 2: Unity Installation, Project Setup and Editor Workflow
Learners install an approved supported Unity release, add the required build modules and configure a compatible C# editor. They become comfortable with the Scene, Game, Hierarchy, Inspector, Project and Console windows; transform tools; layouts; play mode; project settings; package management; importing assets; and safe folder organisation. Students learn how to avoid common project problems such as missing packages, incorrect build modules, broken references, duplicated assets and unmanaged Library folders. The module also introduces backup practice, project naming, version compatibility, source-control readiness and the importance of testing on the intended target device rather than assuming that Editor performance matches a production build.
Module 3: C# Programming Fundamentals for Unity
This module teaches the C# foundations required to create gameplay instead of relying only on drag-and-drop components. Topics include variables, data types, operators, conditions, loops, methods, arrays, lists, dictionaries, classes, objects, access modifiers, properties, enums, interfaces, inheritance, composition, events, exceptions and debugging. Learners connect language concepts to Unity scripts, MonoBehaviour lifecycle methods, serialized fields and component references. They practice writing readable, testable code and learn why object-oriented design, clear naming and small focused methods improve larger projects. The aim is practical game programming fluency: students should be able to read error messages, trace program flow and modify mechanics confidently.
Module 4: GameObjects, Components, Prefabs and Scene Architecture
Students learn Unity's component-based model in depth. They create reusable prefabs, prefab variants and nested structures, understand local and world coordinates, use parent-child hierarchies responsibly and organise scenes for maintainability. The module covers instantiation, destruction, object activation, tags, layers, scene loading, persistent managers and references between systems. Learners compare tightly coupled scripts with cleaner communication patterns and begin using ScriptableObjects for configurable game data where appropriate. By the end, they can structure a small project so that player, environment, UI and management systems remain understandable as features are added.
Module 5: Input, Player Control and Camera Foundations
Interactive experiences depend on reliable input and readable camera behaviour. Learners create keyboard, mouse, touch and controller actions using the approved Unity input workflow. They build character movement, jumping, aiming, interactions and context-sensitive actions while considering update loops, fixed-step physics and frame independence. Camera topics include follow cameras, target framing, damping, look controls, camera boundaries, screen shake and Cinemachine awareness. The module emphasises input abstraction so controls can evolve without rewriting every gameplay script. Students also consider remapping, sensitivity, mobile controls and accessibility-friendly alternatives as part of a professional player-control system.
Module 6: 2D Game Development with Sprites, Tilemaps and 2D Physics
Learners build a complete 2D workflow using sprites, sprite sheets, sorting layers, tile palettes, Tilemaps, colliders, Rigidbody2D, triggers, joints and 2D lighting where appropriate. They create movement, collectibles, hazards, checkpoints, enemies and level progression. The module covers pixel-per-unit decisions, sprite import settings, animation clips, sprite atlases and common performance considerations. Students learn when to use physics and when to use custom movement logic, how to avoid tunnelling or unstable collisions and how to design levels that communicate goals visually. A guided 2D project turns these skills into a playable portfolio outcome.
Module 7: 3D Worlds, Materials, Lighting and the Universal Render Pipeline
This module introduces meshes, transforms, materials, textures, physically based rendering concepts, lighting, shadows, skyboxes, reflection probes, post-processing awareness and the Universal Render Pipeline. Learners import and organise 3D assets, create coherent scenes and understand how art quality must be balanced with target-platform performance. They use ProBuilder or comparable blockout methods to prototype spaces before polishing them. The course explains draw calls, batching awareness, texture sizes, light modes and why mobile, XR and high-end desktop projects need different budgets. Students develop an environment that supports gameplay rather than treating visual decoration as a separate task.
Module 8: Physics, Collisions, Raycasts and Interactive Objects
Learners use Rigidbody, Collider, Character Controller, joints, forces, triggers, raycasts and layer masks to create believable interactions. They build doors, pickups, moving platforms, projectiles, destructible-style props, pushable objects and sensor systems. The module explains collision matrices, continuous collision options, physics materials, FixedUpdate, interpolation and common causes of jitter or unexpected movement. Students also learn to design interaction code that separates detection from game rules, making systems easier to debug and reuse. Exercises compare physics-driven mechanics with scripted alternatives so learners can select an approach based on control, performance and gameplay needs.
Module 9: Animation, Animator Controllers and Character Systems
Students create animation clips, Animator Controllers, parameters, transitions, blend trees, layers, masks and animation events. They work with imported character rigs, humanoid animation retargeting awareness and root-motion decisions. The module connects animation states to gameplay states such as idle, locomotion, attack, hit reaction and death. Learners also create simple procedural or timeline-based motion for environmental objects. The focus is not only playing animations but building reliable state logic that prevents stuck transitions, conflicting actions and visual mismatch between code and character movement.
Module 10: Game UI, Menus, HUDs and Player Feedback
Learners design title screens, pause menus, settings, HUDs, health bars, score displays, inventory panels, mission prompts, dialogue boxes and end-state screens. They use Unity's supported UI systems according to project needs and learn anchors, layout groups, scaling, navigation and event handling. The module covers responsive interfaces for different aspect ratios, readable typography, colour contrast, controller navigation and localisation awareness. Students connect UI to game state without creating fragile scene references. Feedback systems such as damage indicators, interaction prompts, progress bars and animation are used to make mechanics understandable to players.
Module 11: Game Audio and Immersive Sound Design
This module covers AudioSource, AudioListener, AudioClip, mixers, groups, snapshots, 2D and 3D spatial sound, looping, randomisation, volume control and sound-trigger design. Learners add music, ambience, UI feedback, footsteps, impacts and event-based effects while avoiding clipping and uncontrolled overlap. They understand basic audio compression, platform considerations and why sound should reinforce gameplay information rather than simply fill silence. Students build an audio manager or equivalent reusable system and include settings that respect player control over music and effects.
Module 12: Particles, Visual Effects, Shader Graph and Game Feel
Learners create particle effects for impacts, pickups, fire, smoke, weather, magic and feedback. They are introduced to Shader Graph and Visual Effect Graph awareness where suitable for the target project and hardware. The module combines particles, animation, camera response, sound and timing to improve game feel. Students learn that visual polish should remain readable, consistent with the art direction and measurable against performance budgets. They practise pooling frequently spawned effects, selecting appropriate transparency and limiting expensive effects on mobile or XR targets.
Module 13: Level Design, Prototyping and Player Guidance
Students turn game ideas into playable spaces using blockouts, metrics, pacing, landmarks, challenge curves, checkpoints, rewards and risk. They learn how level design differs from environment art and why testing grey-box levels before final art saves time. The module covers tutorialisation, affordances, navigation cues, encounter design, difficulty progression and replayability. Learners create a level brief, sketch a flow, prototype the space, run playtests and revise based on observed player behaviour instead of relying only on personal preference.
Module 14: Gameplay Architecture, ScriptableObjects and Design Patterns
As projects grow, learners need systems that can change without breaking unrelated features. This module introduces events, interfaces, state machines, command-style input, object pooling, factories, data-driven configuration, ScriptableObjects and separation of responsibilities. Students apply patterns only where they solve a real problem, avoiding unnecessary complexity. They organise game states, settings, item data, enemy data, progression and reusable services. The outcome is cleaner code that can be explained during interviews, extended during capstone work and reviewed by a team.
Module 15: Artificial Intelligence for Games and Navigation
Learners create non-player character behaviour using finite state machines, perception checks, patrol and chase logic, attack ranges, cooldowns and navigation meshes. They explore pathfinding, obstacles, target selection and behaviour debugging. The module explains the difference between game AI and machine-learning AI: most useful game behaviour is designed for predictable player experience, not maximum computational intelligence. Students build enemies or agents that are readable, balanced and performant, then tune behaviour using data rather than scattering constants across scripts.
Module 16: Inventory, Save Systems, Progression and Data Persistence
This module covers inventories, items, equipment, score, checkpoints, settings, player progress and save data. Learners compare PlayerPrefs-style settings, JSON or file-based data, ScriptableObject configuration and backend-connected persistence awareness. They handle data validation, versioning, reset flows and safe separation between static game data and player-specific state. Students understand that local saves can be modified and should not be treated as secure authority for competitive or valuable data. A practical exercise adds saving and loading to an existing project.
Module 17: Mobile Game Development, Touch Controls and Device Features
Learners adapt projects for Android and iOS targets with touch input, screen orientation, safe areas, performance budgets, asset compression, mobile UI and device testing. They consider battery use, thermal limits, memory, app size and diverse hardware. The module introduces permissions, vibration, notifications and in-app service awareness without promising every external service in every batch. Students create release builds for an approved mobile target and learn why store submission requires current account, privacy, content-rating and platform-policy compliance.
Module 18: Multiplayer and Networking Foundations
This module introduces local and networked multiplayer concepts, authority, clients, servers, latency, state synchronisation, spawning, ownership, lobbies and relay-style connectivity. Learners use the current approved Unity multiplayer packages or services for a guided prototype rather than obsolete networking workflows. They discuss cheating risks, server validation, connection failure and the additional testing burden of multiplayer projects. Depending on batch scope, students build a simple lobby, networked movement or cooperative interaction demo and document the limitations of the prototype honestly.
Module 19: AR, VR and Spatial Interaction Foundations
Learners receive an introduction to augmented, virtual and mixed reality development using current Unity XR workflows. Topics can include XR project setup, OpenXR awareness, XR Interaction Toolkit concepts, locomotion, grabbing, ray interaction, spatial UI, comfort, performance and device testing. AR topics can include plane detection, anchors, object placement and AR Foundation awareness. Because hardware access varies, the live page and admissions team must state which devices and practical exercises are available for a specific batch. The goal is a defensible foundation, not an unsupported claim of advanced XR mastery.
Module 20: Testing, Debugging and Quality Assurance for Games
Students develop a repeatable bug-fixing workflow using the Console, breakpoints, logs, in-game debug displays, test cases and selected automated-test concepts. They learn to reproduce problems, record steps, isolate systems, verify fixes and test again on target hardware. The module includes gameplay testing, usability checks, boundary cases, save-data checks, input-device tests and build validation. Learners also create a small issue list or test report, showing employers that they understand quality as a development responsibility rather than a final afterthought.
Module 21: Performance Profiling, Memory and Optimization
Learners use Unity profiling and analysis tools to measure CPU, GPU, rendering, memory, scripts and frame behaviour. They practise identifying bottlenecks before optimizing, compare Editor and device performance and understand common causes such as excessive allocations, unbounded instantiation, expensive physics, high overdraw, oversized textures, too many real-time lights or inefficient update loops. Techniques include object pooling, level-of-detail awareness, occlusion, batching, asset compression and reducing unnecessary work. Every optimization decision is tied to a target platform and measured result rather than vague claims that a project is “optimized.”
Module 22: Version Control, Git, GitHub and Team Collaboration
Game projects combine code, scenes, prefabs, settings and large assets, so disciplined collaboration is essential. Learners create repositories, configure appropriate ignore rules, make meaningful commits, use branches, resolve simple conflicts and write README files. They understand why binary assets and scene conflicts need planning, why credentials or store keys must never be committed and when large-file solutions may be required. Students document their own contribution in group projects and build repositories that recruiters or clients can understand.
Module 23: Building and Publishing for Desktop, Mobile and Web
Students prepare builds for supported target platforms such as Windows, Android or Web according to current batch resources. They configure player settings, icons, splash screens, scenes, input, quality levels, architectures, signing awareness and development versus release builds. The module explains that console deployment normally requires platform-holder approval and cannot be promised as ordinary open-platform publishing. Learners also review store listing assets, privacy disclosures, content ratings, testing tracks and post-release maintenance. Publishing is taught as a controlled workflow, not a single Export button.
Module 24: Portfolio, Capstone and Game Production Workflow
The capstone brings together design, C# programming, art integration, UI, audio, testing, profiling and release preparation. Learners write a concise game concept, define a minimum viable scope, create a task board, build a vertical slice, playtest, revise and prepare a release candidate. Each portfolio submission includes a playable build where practical, source repository, README, screenshots or trailer, controls, known limitations and an explanation of individual contribution. The project should be small enough to finish well, because a polished focused game demonstrates more professional judgment than an unfinished oversized idea.
Module 25: Career Readiness, Freelancing and Indie Game Planning
The final module connects skills to practical next steps. Learners prepare a role-focused resume, GitHub profile, portfolio page, short project walkthrough and interview explanations for gameplay code, architecture, debugging and performance decisions. They practise coding and Unity questions, discuss game jams, internships, junior roles, freelance prototypes and responsible indie publishing. The course does not promise a job, income, studio partnership or commercial success. Instead, it helps learners present evidence of skill, continue deliberate practice and understand the production, marketing, support and legal work that exists beyond development.
