Can VAO 0 be used as the default vertex array object in OpenGL core profile?

Question

Goal: determine whether VAO 0 can be treated as a portable default vertex array object for vertex attribute and draw calls in OpenGL core profile contexts, compared with compatibility profile contexts.
OpenGL 3.1 and later core profiles require a non-zero VAO to be bound before glVertexAttribPointer or glDrawArrays; VAO 0 is not specified as a usable default object. Compatibility profiles retain VAO 0 as the default vertex array object. Driver behavior differs when VAO 0 is bound in a core profile: some implementations accept it silently, while others generate GL_INVALID_OPERATION. The specification leaves the outcome implementation-dependent, so results may vary by GPU vendor, driver version, and context creation flags.
Does binding VAO 0 in a core profile context satisfy the VAO binding requirement for glVertexAttribPointer and glDrawArrays? Is VAO 0 guaranteed to act as a valid default vertex array object across core-profile drivers? Can the same vertex-state code rely on VAO 0 when a windowing system exposes both core and compatibility contexts?

Tasadduq Burney · Answer

Answer to the question

In an OpenGL core‑profile context (≥ 3.1), binding vertex‑array object zero is not a valid default. The specification requires a non‑zero VAO to be bound before any glVertexAttribPointer or draw call. Using VAO 0 will generate GL_INVALID_OPERATION on compliant drivers.

Why VAO 0 is disallowed in core profile

The core spec reserves name zero for “no object”. Binding it unbinds any VAO.
Vertex attribute state, buffer bindings, and attribute enablement are stored in the currently bound VAO.
Without a bound VAO, the state has no container, so the spec treats the operation as an error (see OpenGL 4.6 §10.3.1).

What the spec says

“The name zero is reserved for the default vertex array object. Binding vertex array object zero effectively unbinds any vertex array object. It is an error to specify vertex array state when no vertex array object is bound.”

What happens in practice

Compatibility‑profile contexts still allow VAO 0 as the default, so legacy code that omits glGenVertexArrays continues to work.
Many core‑profile drivers (macOS, recent Mesa, newer NVIDIA/AMD on Windows) correctly reject the use of VAO 0 and emit GL_INVALID_OPERATION (often visible via a debug callback).
Some older drivers tolerated VAO 0 in core profile, but this is non‑conforming and can change with updates.

Recommended minimal code for a core profile

#include <GL/glew.h>
#include <GLFW/glfw3.h>

int main() {
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    GLFWwindow* win = glfwCreateWindow(800, 600, "core", NULL, NULL);
    glfwMakeContextCurrent(win);

    glewExperimental = GL_TRUE; // required for core profile
    glewInit();

    GLuint vao; glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);          // bind a real VAO

    GLuint vbo; glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    // upload vertex data …

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
    glEnableVertexAttribArray(0);

    // draw
    glBindVertexArray(vao);
    glDrawArrays(GL_TRIANGLES, 0, 3);

    // cleanup
    glDeleteBuffers(1, &vbo);
    glDeleteVertexArrays(1, &vao);
    glfwTerminate();
    return 0;
}

Verification steps

Create a core‑profile context as shown above.
Call glBindVertexArray(0); and then glVertexAttribPointer(...);.
Check glGetError() or a debug callback. It should report GL_INVALID_OPERATION.
Repeat the same sequence in a compatibility context; the call should succeed.

When you can still use VAO 0

Only in compatibility‑profile contexts or when you explicitly request a legacy profile.
If you need a single binary that runs on both profile types, you must create and bind a real VAO in the core‑profile path and keep the legacy path separate.

Conclusion

For portable, core‑profile‑only applications, always create and bind a non‑zero VAO. Relying on VAO 0 is not guaranteed and will break on compliant drivers.