Game Technology Syllabus

The following syllabus map represents common subject families. Universities arrange subjects differently and may use different names.

Game mathematics and linear algebra

Students study calculus, differential equations, matrices, probability, statistics, numerical methods and discrete Mathematics. These topics support algorithms, machine learning, graphics, networks and system modelling.

Discrete Mathematics is especially relevant because computing uses logic, sets, relations, graphs, combinatorics and proof. It strengthens rigorous reasoning beyond numerical calculation.

Programming fundamentals

Introductory programming teaches variables, control structures, functions, arrays, pointers or references, input-output and debugging. C is common because it reveals memory and system behaviour, while Python may be used for accessible problem-solving.

The objective is not to memorise syntax. Students should learn to break a problem into steps, select data representations, test edge cases and explain the result.

Object-oriented programming

Object-oriented programming introduces classes, objects, encapsulation, inheritance, polymorphism, exceptions and reusable design. Java, C++ or another language may be used. Laboratory projects often include small desktop, web or console applications.

Data structures

Data Structures covers arrays, linked lists, stacks, queues, trees, graphs, hashing and heaps. Students analyse how organisation affects search, insertion, deletion and memory use.

This is a core placement subject. Strong learning requires implementing structures and solving problems rather than reading finished code.

Design and analysis of algorithms

Algorithms examines complexity, recursion, sorting, searching, divide-and-conquer, greedy methods, dynamic programming, graph algorithms and computational limits. Students learn to evaluate solutions using time and space complexity.

Real-time computer graphics

Students learn pixels, colour, vectors, matrices, transformations, projections, cameras, meshes, lighting, materials, texture mapping and the real-time rendering pipeline. Practical work should connect the mathematics to scenes that can be inspected and profiled.

Frame rate is a design constraint as well as a technical measure. Students learn to reduce draw calls, control asset complexity and select effects that suit the target device.

Computer architecture and performance

Computer Architecture studies instruction sets, processor design, datapaths, control, memory hierarchy, cache, input-output, pipelining and parallelism. Students learn why hardware decisions affect program performance.

Advanced courses may introduce multicore processors, graphics processors, accelerators and performance evaluation. This knowledge is useful for embedded systems, compilers, operating systems and high-performance computing.

Rendering and shaders

Rendering courses introduce vertex and fragment shaders, programmable graphics pipelines, shadows, post-processing, particle effects and physically based material ideas. Advanced work may cover global illumination, compute shaders or ray-tracing concepts, depending on laboratory capability.

Game physics and simulation

Game physics covers velocity, acceleration, forces, collision detection, rigid bodies, constraints and numerical integration. Students balance physical accuracy with stable and enjoyable behaviour. They may use an engine physics system and implement smaller simulations to understand what the engine is doing.

Game engines and scripting

Engine study includes scenes, entities or actors, components, prefabs, input, cameras, animation, physics, audio, user interfaces, asset import and builds. Students may use a major commercial or open-source engine, but assignments should test transferable concepts.

Scripting enables rapid gameplay iteration, while lower-level programming supports engine modules and performance-critical systems. Students should understand the boundary between editor configuration, scripts, plugins and source code.

Operating systems and memory

Operating Systems covers processes, threads, scheduling, synchronisation, deadlocks, memory management, file systems, protection and input-output. Laboratory work may use Linux commands, system calls, shell scripting or small kernel-related exercises.

This subject explains how software shares processor time, memory and devices. It is valuable for development, cybersecurity, cloud and embedded work.

Game data and persistence

DBMS teaches data modelling, relational design, SQL, normalisation, transactions, concurrency, indexing and recovery. Students should learn both query writing and why a database preserves consistency.

Projects may include a web or mobile application backed by a relational database. Advanced electives may introduce distributed, NoSQL or data-warehouse systems.

Multiplayer networking

Computer Networks covers layered models, physical media, framing, addressing, routing, transport protocols, congestion, application protocols and wireless networks. Practical exercises may include packet analysis, socket programming and network simulation.

Networks connect the hardware and software sides of Game Technology. Students learn how data travels from an application through an operating system, interface, network and remote service.

Game software architecture

Software Engineering introduces requirements, design, development methods, testing, configuration management, maintenance and project planning. It shows why building production software involves more than writing code.

Team projects should use version control, issue tracking, review and documentation. These practices closely resemble professional work.

Game design fundamentals

Game design covers goals, rules, mechanics, dynamics, feedback, challenge, balance, progression, economy, narrative and level structure. Students create paper and digital prototypes, observe players and revise decisions based on evidence rather than personal preference alone.

Tools and engine development

Tools programming covers editor extensions, importers, exporters, build automation, visual debugging and content-validation utilities. Advanced technical programmes may also examine engine loops, entity systems, resource management and domain-specific scripting.

Mobile and web game development

Students study touch input, device capabilities, browser constraints, responsive interfaces, packaging, platform services and store requirements. Mobile projects must be tested on representative low- and mid-range devices rather than only in an editor.

Game security and anti-cheat

Security topics include authentication, secure storage, server authority, abuse prevention, cheating risks, privacy and safe payment or account integration. Anti-cheat work must remain lawful and defensive. Students should never test intrusive techniques on systems they do not own or have permission to assess.

Gameplay artificial intelligence

Gameplay AI commonly includes finite-state machines, behaviour trees, utility systems, navigation meshes, pathfinding, steering and group behaviour. The aim is often readable, controllable and entertaining behaviour rather than the most complex possible model. Machine learning may appear as an advanced elective.

Online services and cloud backends

Online-service subjects cover accounts, matchmaking, leaderboards, inventories, telemetry, content delivery, databases, service failures and live updates. Students learn why authoritative servers, observability, scalability, security and operating cost affect design.

Cloud tools can simplify deployment, but they do not remove the need to understand networks, databases and distributed failure. Small projects should set usage limits so that experiments do not create uncontrolled charges.

AR, VR and interaction

AR and VR subjects cover tracking, spatial interaction, comfort, locomotion, stereoscopic rendering, controllers and performance. User testing is important because frame instability, unsuitable movement or poor interface placement can cause discomfort.

Animation and asset pipelines

Students learn how concept art, modelling, UV mapping, texturing, rigging, animation, effects and audio move into an engine. Technical students need asset-pipeline awareness to diagnose scale, format, material, rig and performance problems, even if they are not professional artists.

Typical semester pattern

Laboratories

Important laboratory areas include programming, engine development, graphics, animation, game design, user interface, multiplayer networking, testing, audio integration and team production.

A laboratory should require students to design, implement, test and explain work. Copying identical programs prevents skill development and creates difficulty during placements.

Electives

Common electives include advanced rendering, virtual reality, technical art, procedural content, serious games, game analytics, machine learning, cloud backends, esports production, interactive narrative and audio design.

Students should choose electives that form a coherent pathway. Selecting unrelated fashionable subjects without prerequisites can create shallow knowledge.

Project ideas

• two-dimensional puzzle game with a level editor;
• short three-dimensional exploration game;
• local cooperative game with accessible controls;
• networked prototype with a small authoritative server;
• pathfinding and behaviour-tree demonstration;
• mobile game profiled on different devices;
• virtual-reality training interaction;
• procedural level or environment generator;
• educational game with measurable learning goals;
• graphics or shader demonstration with performance results;
• reusable dialogue, inventory or quest tool;
• game accessibility and usability testing project.

Every project should state the problem, users, requirements, architecture, testing method, limitations and future improvement. Security and privacy should be designed from the beginning.

Students should also record frame-rate targets, supported devices, accessibility decisions, asset licences and user-testing observations. This evidence shows whether the project was engineered carefully and helps reviewers understand the student's personal contribution, debugging method and response to technical or creative constraints.

Version history and reproducible build instructions further strengthen the portfolio.