Low-Level Game Technology

Dive into the heart of game technology with this capstone project, where teams of computer science students will design and implement a low-level, gaming-oriented system to push the boundaries of their technical expertise. Each team will choose one of four exciting options: 

  1. Custom 2D/3D Game Engine with OpenGL: Build a lightweight engine for rendering, physics, and input, with a demo game (e.g., 2D platformer, 3D maze). Use OpenGL (C++) for desktop or WebGL (JavaScript) for web.
  2. WebGL-Based Procedural Content Generation Framework: Create a framework for generating game content (e.g., terrain, levels) using WebGL, with a demo application (e.g., dungeon crawler).
  3. Contributing to an Open-Source Game Engine: Add a feature (e.g., new shader system, networking) to Godot or Bevy, with a demo showcasing the contribution.
  4. Real-Time Networking Library for Multiplayer Games: Develop a library for multiplayer synchronization (e.g., UDP-based), with a demo game (e.g., arena shooter).

Teams will propose their specific implementation, tailoring their project to a small demo (e.g., a simple game or interactive application) to showcase their system’s capabilities. The project culminates in a published artifact (e.g., source code on GitHub, demo on itch.io) that attracts users and feedback, with teams competing on technical innovation, performance, and user engagement. This is your chance to master low-level programming, collaborate like industry professionals, and create a portfolio piece that stands out in the tech world!

Note: Students working on these projects will meet as one, in-person, every two weeks with the instructor. The goal of these meetups is to demo progress and encourage feedback accross teams. 

Objectives

Objectives

  • Design and implement a low-level, gaming-oriented system (chosen from the four options) that demonstrates technical proficiency in systems programming, graphics, or networking.
  • Develop a small demo (e.g., a simple game or interactive application) to showcase the system’s functionality.
  • Publish the system and demo on platforms like GitHub and itch.io, attracting users and feedback to refine the project.
  • Compete with other teams to create the most innovative, performant, and user-engaging project, evaluated by faculty, industry experts, or community feedback.

Deliverables

  • Project Proposal: A document detailing the chosen option, specific implementation (e.g., engine features, generation algorithms), demo concept, target platform (desktop/web), and technical plan, submitted for instructor approval within the first 3 weeks.
  • Published System and Demo: The completed system (e.g., engine, framework, library) with source code on GitHub and a playable demo on itch.io or a web server (for WebGL-based projects), accessible to users with no major bugs.
  • Documentation: Technical specifications, API guide (for developers to use the system), and a basic user guide for the demo.

Motivations

Game development is a dynamic field that demands expertise in low-level systems like graphics, networking, and engine architecture. While high-level game engines like Unity simplify development, understanding and building the underlying technologies (such as rendering pipelines or multiplayer systems) equips students with skills that are highly valued in the 2025 job market. The problem is that many CS students lack hands-on experience with these low-level systems, limiting their ability to compete for specialized roles like graphics engineer, engine programmer, or network developer. This project addresses this gap by offering four challenging options that let students:

  • Master cutting-edge skills: Learn graphics programming, procedural algorithms, or networking, directly applicable to gaming and real-time applications.
  • Build impactful tools: Create reusable systems (e.g., engines, libraries) that benefit developers or the open-source community.
  • Stand out to employers: A published low-level project demonstrates technical depth, problem-solving, and initiative, giving students a competitive edge in roles at companies like Epic Games, NVIDIA, or Riot Games.
  • Contribute to innovation: By competing with peers, teams push the boundaries of creativity and performance, mirroring the collaborative and competitive nature of the tech industry.

This project not only hones your technical abilities but also prepares you for the demands of modern software engineering, where low-level expertise is a differentiator.

Qualifications

Minimum Qualifications:
  • Programming Skills: Proficiency in C++ or JavaScript, with understanding of object-oriented programming and data structures (e.g., arrays, graphs).
  • Computer Science Fundamentals: Knowledge of algorithms (e.g., pathfinding, sorting), linear algebra (e.g., vectors, matrices for graphics), and basic software engineering practices (e.g., version control with Git).
  • Teamwork: Willingness to collaborate in a team of 3-4, with clear communication and task division.
  • Interest: Enthusiasm for low-level programming and gaming technology, even without prior graphics or networking experience.

Preferred Qualifications:
  • Graphics Programming: Familiarity with OpenGL, WebGL, or GLSL (for engine or procedural generation projects).
  • Systems Programming: Experience with C++ (for engine contributions, networking) or Rust (for Bevy contributions).
  • Networking: Basic understanding of networking concepts (e.g., TCP/UDP, client-server models) for multiplayer projects.
  • Open-Source Experience: Prior contributions to GitHub projects or familiarity with pull request workflows (for open-source contributions).
  • Debugging and Optimization: Experience with profiling tools (e.g., RenderDoc, Wireshark) or optimizing code for performance.


Details

Project Partner:

Alexander Ulbrich

NDA/IPA:

No Agreement Required

Number Groups:

4

Project Status:

Accepting Applicants

Card Image Capstone