Backend-Agnostic C++ Architecture
Engine Interface is a modern C++ software architecture that demonstrates interface-driven design, modular system composition and dependency inversion. The project separates engine systems from backend implementations through stable interface contracts, creating a reusable framework that remains independent of any specific graphics library or platform.
Rather than focusing on rendering features, the project explores how well-defined architectural boundaries improve maintainability, extensibility and long-term software evolution.
The Engineering Problem
Many graphics applications become tightly coupled to the frameworks they use. Rendering, input handling, resource management and window creation often depend directly on a single backend, making future changes increasingly difficult as projects grow.
Engine Interface addresses this problem by introducing an abstraction layer between framework systems and their implementations. High-level modules communicate through interfaces rather than concrete classes, allowing backend technologies to evolve independently while preserving a stable architecture.
My Role
I designed and implemented the complete architecture, defining the interface hierarchy, organising the framework into cohesive subsystems and establishing the contracts that govern communication throughout the engine.
The project demonstrates software architecture rather than gameplay development, with an emphasis on modular design, separation of concerns and reusable engineering practices.
Architecture Overview
The framework is organised into distinct architectural layers that separate responsibilities and minimise coupling between systems.
Each layer has a clearly defined responsibility. Framework systems depend only on abstract interfaces, while shared infrastructure provides reusable functionality without introducing backend dependencies. Dedicated testing projects allow individual components to be validated independently of production implementations.
Core Framework
Engine Interface provides the architectural foundation for a collection of reusable engine systems.
Engine Services
Defines the core service contracts that provide rendering, window management, input handling, audio, timing and resource management. These interfaces establish a consistent API that applications depend upon regardless of the underlying backend implementation.
Framework Systems
Provides reusable framework abstractions for scene management, game objects, collision detection, artificial intelligence and user interface components. These systems define the structure of higher-level application logic while remaining independent of any graphics library.
Shared Infrastructure
Contains the common types and utilities used throughout the engine, including mathematics, event handling, utility components and shared data structures. These foundational services support consistency across all engine modules and backend implementations.
Each subsystem has a clearly defined responsibility and communicates through abstract interfaces rather than concrete implementations.
Engineering Principles
| Principle | Implementation |
| Interface-Driven Design | Stable interfaces define communication between framework systems. |
| Dependency Inversion | High-level modules depend on abstractions instead of backend implementations. |
| Modular Architecture | Independent subsystems reduce coupling and simplify maintenance. |
| Backend Independence | Rendering and platform technologies can be replaced without affecting engine systems. |
| Extensibility | New features can be introduced without modifying existing architecture. |
| Testability | Native testing projects validate interface behaviour independently of production code. |
Key Design Decisions
Stable Interface Contracts
Clear interface boundaries define how framework systems communicate, allowing implementations to evolve without affecting dependent modules.
Separation of Responsibilities
Each subsystem performs a specific role within the architecture, reducing complexity and encouraging cohesive, maintainable code.
Backend Independence
Rendering, window management and platform services remain isolated behind interface contracts, allowing alternative implementations to be introduced with minimal architectural impact.
Testing Support
Dedicated native testing and test-support projects provide a foundation for validating engine behaviour while supporting future automated testing.
Technologies
Development
C++ 20
Visual Studio 2022
Git
Engineering Approach
Interface-Driven Architecture
RAII
Dependency Inversion
Backend Abstraction
Native Testing
Modular Architecture
Layered Architecture
Contract-Based Design
Engineering Outcome
Engine Interface demonstrates how interface-driven architecture and dependency inversion can be applied to build flexible, maintainable C++ software.
The framework establishes stable contracts across rendering, input, scenes, resources, user interface and collision systems while isolating backend implementations from higher-level engine behaviour. This separation allows individual components to evolve independently, improves testability and provides a reusable architectural foundation for future engine development.
Repository
Explore the source code to see how the architectural principles are implemented throughout the framework.
Engineering Review
Read the accompanying architecture review for a detailed discussion of the design decisions, implementation strategy and engineering trade-offs behind the project.