Low-Level Experimental In-House Game Engine for VantorStudios
Get Started · Report Bug · Request Feature · VantorStudios
Table of Contents
Vantor Engine is a low-level, experimental game engine developed in-house by VantorStudios for creating high-performance games. Designed from the ground up with a focus on minimal abstraction and maximum control, Vantor provides game developers with direct access to rendering pipelines, memory management, and system resources.
The engine prioritizes performance, modularity, and flexibility over ease of use, making it ideal for developers who need fine-grained control over every aspect of their game's execution. Built with modern C++20 and OpenGL, Vantor serves as the foundation for VantorStudios' game development projects.
- Low-Level Control: Direct manipulation of rendering, physics, and resource systems
- Performance First: Optimized for real-time applications and resource-constrained environments
- Modular Architecture: Use only what you need, extend what you want
- Experimental Nature: Cutting-edge features and techniques in active development
"A delayed game is eventually good, a rushed game is bad forever." – Shigeru Miyamoto
VantorStudios is an independent, hobby-driven game development studio focused on creating unqiue gaming experiences. The Vantor Engine serves as our proprietary technology stack, powering our internal game development projects and providing the technical foundation for our creative vision.
- Rapid Changes: APIs and architecture may change frequently
- Limited Documentation: Focus is on development rather than user documentation
- Internal Use Priority: Designed primarily for VantorStudios' development needs
- Community Contributions: Welcome but may be adapted to fit internal roadmap
- No Stability Guarantees: Breaking changes can occur between versions
The engine is made available for educational purposes and community collaboration, but production use is not recommended until a stable release is announced.
The Vantor Engine is built using modern technologies and industry-standard tools:
Core Technologies:
- C++20: Modern C++ with latest language features
- OpenGL 4.6: Primary rendering API with Vulkan support planned
- Custom GLSL Shaders: Hand-optimized graphics shaders
- Python: Development tools and build automation (VTRG)
- CMake: Cross-platform build system
Third-Party Libraries:
- Dear ImGui: Immediate mode GUI for debugging and tools
- GLFW: Window management and input handling
- STB Headers: image loading and writing
- tinygltf.h: glTF 2.0 object loading and animations
- tinyobjloader: .obj and mtl object loading
⚠️ Warning: This engine is experimental and intended primarily for VantorStudios development. APIs may change without notice.
To get started with Vantor Engine development, follow these steps. Note that the engine is designed for experienced C++ developers familiar with low-level graphics programming.
Before building Vantor, ensure you have the following installed:
Required:
- CMake (3.10 or higher)
- Make or Ninja build system
- C++20 capable compiler:
- MSVC 2019+ (Windows)
- GCC 10+ (Linux)
- Clang 12+ (Cross-platform)
- Git for version control
- Python 3.7+ for development tools (VTRG)
Optional but Recommended:
- clang-format for code formatting
- Visual Studio Code or similar IDE with C++ support
Step 0: Setup Environment
Install MSYS2 from their website and Python from python.org.
Step 1: Clone Repository
git clone https://github.com/LukasRennhofer/Vantor.git
cd VantorStep 2: Install Dependencies
pacman -S cmake mingw-w64-x86_64-toolchain mingw-w64-x86_64-freeglut mingw-w64-x86_64-assimp mingw-w64-x86_64-sdl2Step 3: Build Engine
# Using the new VTRG development tool
python vtrg.py build --platform Windows --debug
# Or using legacy DevConsole (deprecated)glTF 2.0 object loading and animations
python DevConsole.py --platform Windows --build-lib
⚠️ Status: Linux support is experimental and may have build issues. Tested on Ubuntu 24.10.
Step 0: Install Python
sudo apt-get install python3Step 1: Clone Repository
git clone https://github.com/LukasRennhofer/Vantor.git
cd VantorStep 2: Install Dependencies
sudo apt-get install build-essential libsdl2-dev libsdl2-2.0-0 libassimp-dev cmake libglm-dev libglew-devStep 3: Build Engine
# Using VTRG (recommended)
python3 vtrg.py build --platform Linux --debug
# Or using legacy DevConsole
python3 DevConsole.py --platform Linux --build-libVantor Engine is designed for experienced developers who need low-level control over game systems. Here are some ways to use the engine:
#include <Vantor/Vantor.hpp>
int main() {
// Initialize Vantor Engine
Vantor::Application app;
// Setup rendering context
app.Initialize();
// Main game loop
while (app.IsRunning()) {
app.Update();
app.Render();
}
return 0;
}The engine includes several sample projects in the Samples/ directory:
- Sandbox: Basic engine showcase and testing environment
- LightDemo: Demonstration of lighting systems
- Template: Starting point for new projects
# Build and run a sample using VTRG
python vtrg.py build --sample Sandbox --platform Windows --run
# Format code before contributing
python vtrg.py format
# Clean build artifacts
python vtrg.py clean --allFor more detailed examples and API documentation, please refer to the Documentation
VTRG is the enhanced command-line development tool for Vantor Engine:
# Build commands
python vtrg.py build --help
python vtrg.py build --sample MyProject --debug --run
# Code formatting
python vtrg.py format --check
python vtrg.py format --path ./Source
# Cleanup
python vtrg.py clean --build
python vtrg.py clean --all --dry-run
# Get help
python vtrg.py --help
python vtrg.py build --help- Multi-platform building with platform-specific optimizations
- Integrated code formatting with clang-format support
- Dependency checking and validation
- Build artifact management and cleanup
- Enhanced logging with colored output and progress indicators
- [🟩] Platform Abstraction Layer - Windows/Linux/Switch support
- [�] Core Rendering Pipeline - OpenGL 4.6 implementation
- [🟧] Memory Management - Custom allocators and resource pooling
- [🟩] Scene Graph - Efficient spatial organization
- [🟧] Multi-threaded Resource Management - Async loading and streaming
- [🟧] GPU-based Scene Graph - GPU-driven rendering pipeline
- [🟩] Editor Interface - Basic level editor and debugging tools
- [🟥] Audio System - 3D spatial audio implementation
- [🟥] Full Vulkan Support - Modern low-level graphics API
- [🟥] Advanced Physics - Custom physics simulation
- [🟥] Networking Layer - Multiplayer game support
- [🟩] Documentation Expansion - Comprehensive API documentation
Legend:
- 🟩 Complete
- 🟧 In Progress
- 🟥 Planned
Note: Roadmap priorities may change based on VantorStudios' internal development needs.
See the open issues for detailed feature requests and known issues.
We welcome contributions to the Vantor Engine! However, please note that this is primarily an in-house engine for VantorStudios, so contributions will be evaluated based on alignment with our internal development goals.
Before Contributing:
- Review our experimental status - APIs may change rapidly
- Check existing issues and pull requests
- Consider reaching out via issues to discuss major changes
Contribution Process:
- Fork the Project
- Create your Feature Branch (
git checkout -b feature/AmazingFeature) - Format your code (
python vtrg.py format) - Test your changes thoroughly
- Commit your Changes (
git commit -m 'Add some AmazingFeature') - Push to the Branch (
git push origin feature/AmazingFeature) - Open a Pull Request
- Contributions may be adapted or modified to fit Vantor's internal roadmap
- Breaking changes may be introduced that affect community contributions
- Focus is on engine functionality rather than external developer experience
Distributed under the GNU General Public License, v3. See LICENSE for more information.
VantorStudios Development Team
- Lukas Rennhofer
- Moritz Rottensteiner
Lead Developer: Lukas Rennhofer
📧 Email: lukas.renn@aon.at
Project Repository: https://github.com/LukasRennhofer/Vantor
For technical questions, bug reports, or feature requests, please use the GitHub Issues system.
VantorStudios would like to thank:
- Open Source Community - For the foundational libraries and tools that make Vantor possible
- Technical Inspirations:
- WickedEngine - Modern C++ game engine architecture
- Godot Engine - Open source game engine design patterns
- Unreal Engine - Industry-standard rendering techniques
- Library Contributors:
- Dear ImGui - Immediate mode GUI framework
- SDL2 - Cross-platform development library
- Assimp - 3D model loading library
- GLFW - Window and input management
- Development Tools:
- CMake - Cross-platform build system
- clang-format - Code formatting
- GitHub - Version control and collaboration
Special Recognition:
- All contributors who help improve the engine
- The game development community for sharing knowledge and best practices
- Beta testers and early adopters who provide valuable feedback
Vantor Engine - Experimental Low-Level Game Engine
Developed by VantorStudios (Lukas Rennhofer, Moritz Rottensteiner)
