Skip to main content

Getting Started

Welcome to LearnVertexNova — a hands-on guide to building a modern, multi-backend renderer in C++.

Every chapter maps to working code, ends with something you can run, and steadily builds the engine foundations: frame loop → resources → shaders → passes → presentation.

By the end of this path, you'll not only run demos — you'll understand why they work and how to extend them.

What is VertexNova?​

VertexNova Engine is a modern, multi-platform rendering and visualization engine designed for learning, clarity, and long-term maintainability. Unlike commercial game engines or high-level graphics libraries, VertexNova provides:

  • Transparent architecture — See exactly how rendering works, from API calls to frame presentation
  • Multi-backend support — Learn how to abstract across Vulkan, Metal, OpenGL, and WebGL with a unified API
  • Clean C++ design — Modern C++17+ with strict ownership, predictable lifetimes, and clear abstractions
  • Educational focus — Built to teach, not just to ship products

Core features​

  • Multi-backend mindset — Vulkan, Metal, OpenGL (and Web later)
  • Learn by building — small demos that prove each concept
  • Engineer-friendly workflow — CMake, debugging, and clean structure

What you need to know​

Essential skills​

  • Modern C++ (C++17+) — We use contemporary C++ features, but we'll explain them as we go
  • CMake workflows — Understanding how to build C++ projects is essential
  • Basic graphics concepts — Familiarity with vertex buffers, shaders, and matrices helps, but we'll build the mental model together

Nice to have​

  • Experience with any graphics API (OpenGL, Vulkan, Metal, DirectX)
  • Understanding of computer graphics fundamentals
  • Previous engine or graphics programming experience

Don't worry if you're new to graphics programming — we'll explain concepts as we encounter them, and the codebase is designed to be readable and educational.

Development environment​

VertexNova is developed and battle-tested across multiple platforms:

  • Windows 11 / Windows 10 — Full support for Vulkan and OpenGL
  • Ubuntu 22.04 (Linux) — Vulkan and OpenGL with excellent tooling
  • macOS — Native Metal support plus OpenGL and Vulkan (via MoltenVK)
  • Qt Creator / VS Code — Excellent for everyday development with great CMake integration
  • Xcode — Essential for macOS debugging and GPU tools (Instruments, Metal debugger)
  • CMake 3.15+ — Our build system of choice

Your first milestone​

✅ Build the engine
✅ Run your first demo
✅ Confirm your toolchain
✅ Set up a repeatable workflow

This first milestone is crucial. Once you can build and run demos reliably, you have everything you need to start learning and experimenting.

Quick start​

# Clone the repository
git clone https://github.com/ajeetsinghyadav/vertexnova.git
cd vertexnova

# Initialize submodules (required dependencies)
git submodule update --init --recursive

# Configure and build
mkdir build && cd build
cmake ..
cmake --build .

Expected time: 5-15 minutes depending on your machine and internet connection.

Run your first demo​

# After building, navigate to build directory
cd build

# Run a sample (exact path depends on your build configuration)
./bin/sample_02_triangle
# or
./bin/sample_04_cube

What you should see: A window opens with a rendered triangle or cube. Congratulations — you just ran your first VertexNova demo!

See the Demos page for a complete list of available samples and what each demonstrates.

Architecture overview​

VertexNova architecture layers
VertexNova layers: platform (xwin) + unified graphics API (xgl) + backend implementations.

VertexNova is organized into clean, focused components:

  • xwin — Platform and window/input utilities abstracting OS-specific functionality
  • xgl — Multi-backend rendering layer providing a unified API across OpenGL, Metal, Vulkan, and WebGL
  • xviz — Visualization helpers and utilities for common graphics tasks

This architecture is intentionally simple. Each component has a clear responsibility, making the codebase easy to understand, modify, and extend.

What you'll build​

As you progress through LearnVertexNova, you'll build:

Triangle

Basic rendering pipeline

Textured Cube

Textures & materials

Render Targets

MSAA & offscreen rendering

What's next​

Now that you're set up, here's your learning path:

Immediate next steps​

👉 Development Environment Setup
Get detailed platform-specific setup instructions, install dependencies, and configure your development environment for maximum productivity.

Learning path​

👉 Learn VertexNova
Follow our structured learning path. Start with window creation, progress through rendering basics, and advance to complex topics like instancing and render targets. Each lesson builds on the previous one.

👉 View Demos
Explore our demo suite. Each demo is a working example that validates specific engine features. Study the code, run the demos, and understand how they work.

Deep dive​

👉 Project Overview
Understand the engineering decisions behind VertexNova. Learn about cross-backend challenges, debugging strategies, and performance considerations.

👉 Roadmap
See what's currently working, what's in progress, and what's planned. This honest status helps you understand the project's current state.

Resources​

Design philosophy​

VertexNova follows a clear set of principles that guide every design decision:

  • Modern C++ with clarity over cleverness — Readable code is more valuable than clever code
  • Thin abstractions and clear layering — Enough abstraction to be practical, not so much that it's magic
  • Multi-backend design via unified API — Learn once, run everywhere
  • Build to learn first; scale responsibly later — Education and understanding come before optimization

Ready to begin?​

You're about to embark on a journey that will transform how you think about graphics programming. Every line of code you write, every demo you run, and every concept you master brings you closer to understanding what makes great graphics engines tick.

Let's build something amazing together.

Start with the Development Environment Setup, then dive into the Learning Path. Welcome to LearnVertexNova.