Graphical Playground (GP) is an open-source, cross-platform game engine and educational platform built in C++23. Born as an EPITECH Innovative Project (EIP) in Lyon, France, GP combines a high-performance native engine with a cloud-native e-learning platform, so you can learn modern game engine architecture while reading the actual source code that powers it.

Whether you are a student stepping into systems programming for the first time or an experienced engineer who wants to study real-world engine design, GP gives you both the tooling and the curriculum in one place.

The GP engine is designed from the ground up to be truly cross-platform. Current targets include:

• Desktop: Windows, Linux, macOS
• Mobile: iOS, Android

A single codebase compiles to all of these without platform-specific forks. The build system is driven by GPBT (Graphical Playground Build Tool), our CMake wrapper that manages compiler flags, configurations, and third-party dependencies consistently across every target.

Most game engines are black boxes, you use them, but you do not learn from them. GP is designed with full transparency as a first principle:

• No RTTI, no exceptions: The engine follows a strict low-level philosophy with custom allocators, typed error codes, and a rich error-reporting system, the same constraints you would find in AAA studios.
• Modern C++23 throughout: Every system, smart pointers, containers, hashing, memory management, is handcrafted in idiomatic C++23, serving as living reference implementations you can read, fork, and learn from.
• Education-first: Architecture decisions are documented in detail on the e-learning platform, so you understand not just what the code does, but why it was designed that way.

The GP learning platform covers game engine architecture from first principles to production-grade systems. Topics include:

• Memory management: aligned allocation, custom allocators, smart pointer internals
• Error handling systems: severity tiers, typed domains, RAII breadcrumb scopes, crash reporting
• Rendering pipelines: GPU-driven culling, virtualized geometry (Nanite-style meshlet DAGs), visibility buffers
• Build systems: CMake, cross-compilation, CI/CD for multi-platform C++ projects
• Data structures: SSO strings, vectors, hash maps, all implemented without the STL

Courses are tightly coupled to the engine's actual source code, so theory and practice always stay in sync as the engine evolves.

Yes. The engine and its associated tooling are fully open source. You can browse the source, file issues, submit pull requests, and fork the project freely. We believe that transparency is the only credible foundation for an educational platform, you cannot teach engine architecture from a closed codebase.

The project follows a contributor-friendly workflow with documented coding conventions, automated CI across all platforms, and thorough code-review guidelines so that first-time contributors can get up to speed quickly.

Comfort with at least one compiled language (C, C++, Rust, or similar) is recommended, as the curriculum dives into low-level systems topics early. That said, the platform is structured so that complete beginners in game engine programming can follow along, we start from memory layout and work our way up to rendering pipelines, with each concept building on the last. If you are brand-new to C++, we suggest completing a basic C++ course first, then returning to GP for the engine-specific material.

Graphical Playground is built on an open, sustainable model, most of what we offer is free by design, and we rely on the community to keep it that way.

• Engine: Free forever. The GP engine is open source under our license & EULA. Use it for personal projects, commercial games, research, no hidden fees.
• Curriculum: Free. Every learning module, course, and piece of documentation on the platform is openly accessible. Knowledge should not have a paywall.
• Cloud computing: Paid. Running workloads on GP's cloud infrastructure (builds, simulations, hosted projects) is billed based on usage. You only pay for what you consume.
• Certifications: Paid. If you want an official GP certification to validate your skills, for a portfolio, a job application, or a studio requirement, a one-time fee covers the examination and the credential.

We are an independent, community-driven project. If GP has helped you, consider making a donation , it directly funds development, infrastructure, and the people who keep the lights on. Every contribution, large or small, makes a real difference.

There are several ways to become part of the GP community:

• Code contributions: Check the open issues on GitHub and pick something that matches your skill level. All contributions go through code review and must meet the project's coding standards.
• Documentation & curriculum: Writing is engineering. If you have strong technical communication skills, help us expand the learning modules or improve the API docs.
• Community: Join our Discord server to ask questions, share projects built with GP, or discuss engine architecture with the core team.
• Bug reports & feedback: Even filing a well-described bug report is a meaningful contribution. Use the GitHub issue tracker and follow the template.