C++ & OpenGL · Try a full lesson without signing up

Learn graphics programming inside the IDE, not inside a video.

Abedaca replays a real engine codebase scene by scene in a fully navigable lesson player. Pause anywhere. Open any file. Jump to the moment a line was written, and read the explanation beside it.

Try a lesson Start the free course

Built by Alex Kulbitsky — 10+ years shipping AAA engines and rendering (Hogwarts Legacy, Gotham Knights, Age of Empires II). 1,251 students took the original version of this course.

1.6 — Vertex attribute pointers scene 12 / 18

source

main.cpp

shader.cpp

shader.h

assets

basic.vert

basic.frag

151// --- Create VAO: how vertex attributes are laid out ---
152GLuint vao;
153glGenVertexArrays(1, &vao);
154glBindVertexArray(vao);
155
156glBindBuffer(GL_ARRAY_BUFFER, vbo);
157
158// Position attribute (location = 0)
159glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,
                      3 * sizeof(float), (void*)0);
160glEnableVertexAttribArray(0);
161
162glBindBuffer(GL_ARRAY_BUFFER, 0);
163glBindVertexArray(0);

Interleaved buffer, stride 3 floats

xyz xyz xyz

offset 0 · stride 12 bytes

Narration

The VAO is bound, but it is still empty.

This call is the one that tells OpenGL how to walk the buffer: attribute zero, three floats, tightly packed.

The stride is what most people get wrong the first time.

◀ ▶ Read

Try the actual lesson player

Draw your first triangle in Lesson 1.6. Follow code as it appears, explore diagrams, and move through the explanations at your own pace. The complete lesson is open without an account; no installation is needed to watch.

Try a lesson

View the course outline

Video tutorials are broken for code

Not because the teaching is bad. Because the medium throws away everything that makes code readable: structure, navigation, and the ability to stop and look.

Pause and look around

What you see isn't a picture of an editor — it's editor state. Stop mid-sentence, open another file, scroll back twenty lines, select something. The lesson waits for you.

A codebase, not a snippet

Multi-file project state, replayed deterministically scene by scene. Built for the lessons where the architecture across files is the actual subject — not a single editable box.

Diagrams on the line they explain

Vertex layouts, buffer bindings, matrix order — drawn as overlays anchored to the exact line being discussed, not on a slide you saw two minutes ago.

Read at your own pace

Step through each explanation when you are ready. The code and diagrams respond to the sentence you select, so you can pause and inspect the project.

One commit, one lesson

The course isn't a tutorial project rebuilt for the camera. It's the real git history of a real engine. Each lesson is a single commit that carries both the prose and the code it teaches — so what you read and what you run can't drift apart.

01
Start from the last commit

Every lesson opens on the exact state the previous one left behind. No skipped files, no "as you can see, I've already added…".
02
Watch the diff happen

Lines arrive where they belong, in the order a person would actually write them, explained as they land.
03
End on a commit you can build

Every lesson finishes at a state that compiles and runs. Byte for byte the same code the author committed.

First on Abedaca: a graphics engine, from an empty file to a playable game

C++ and OpenGL, no framework doing the interesting parts for you. From opening a window and getting the first triangle on screen, through buffers, shaders, textures and lighting, to models, animation blending, and a game loop you can actually play.

It's a reworked and considerably deepened version of the course 1,251 people have already taken on Udemy — rebuilt for a medium that can show what a screen recording can't.

Chapter 1 is free now: 10 lessons. The first 15 lessons are planned to be free as the next chapter is published.

81lessons
6chapters
10free now
C++& OpenGL

Who's building this

I'm Alex Kulbitsky. I've spent 10+ years in AAA engine and graphics teams — on Hogwarts Legacy, Gotham Knights, and Age of Empires II — and a few of those years teaching this material to 1,251 students who mostly told me the same thing: the explanation was fine, the format got in the way.

Abedaca is my attempt to fix the format. The first chapter is available to try, and the email list gets updates as the course grows.

alexkulbitsky.com LinkedIn The original course

Questions you're about to ask

Is this just a video course with extra steps?

No. There's no video of a screen. The player holds real project state — a file tree, tabs, an editor — and the lesson drives it. That's why you can stop, open a file the lesson isn't looking at, and come back without losing your place.

When can I actually use it?

Try Lesson 1.6 right now, without signing up. A free account opens the first 15 lessons, starting with project setup.

How much C++ do I need?

Enough to be comfortable with classes, pointers, and building a project. No graphics background is assumed — buffers, shaders, and the pipeline are built up from nothing.

Get updates as new lessons arrive

Chapter 1 is already free to explore. Join the email list for occasional updates on new lessons and the course launch. This list is separate from your player account.