Hey everyone,

I'm a beginner in OpenGL development. I've used OpenGL before, but mostly to create simple demos by following the OpenGL Programming Guide (the Red Book).

I'm looking for a project that's beginner-friendly but still challenging enough to help me understand OpenGL at a deeper level. I'd love something that goes beyond basic tutorials and teaches me more about graphics programming, rendering, shaders, and how everything fits together.

What projects would you recommend?(I did use AI,english isn't my native language)

Hi there. I've started getting this OpenGL error. I've tried various things to fix it—such as changing video driver or Windows versions, reinstalling OpenGL, etc.—but nothing stops the error.

I don't think it's a problem with my PC itself, but rather an internal error, since everything was working fine about a month ago. I’d appreciate any help you can offer. (This error only happens with OpenGL applications; I tested DirectX games and didn't encounter any issues.)

Some weeks ago , the tech market saw some major Apple related news , Rosetta 2 would be completely deprecated and slowly removed from macOS 28.0 update that is about to come

This news startled me , as a systems designers and tinkerer , especially on Unix based OSes like Linux and macOS , as it would bring a threat to a lot of x86_64 apps on macOS

Remember how Apple deprecated OpenGL 4.1 Core Profile in macOS Mojave 10.14 in 2018 , it struck me an uncanny feeling that at this current pace , Apple may make Metal 4 the monolithic owner of the entire graphics stack slowly and remove the remaining 1% ownership left to OpenGL , and now that Mojang dropped the Vibrant Visual Update for Minecraft Java Edition ver 26.2 , where the Blaze3d would transition to Vulkan , Apple may feel it more to have a reason to completely remove OpenGL's frozen driver , leaving macOS with dynamic library based graphics backends/translators like MoltenVK and MGL, which are kinda sus than a native driver .

Thus, I started researching Mesa’s OpenGL stack, its state tracker, driver architecture, shader infrastructure and the way applications communicate with userspace graphics libraries before commands eventually reach the GPU backend.

That research led to Khronos_AppleICDs, an experimental attempt to build a system-facing OpenGL 4.6 Core Profile implementation for macOS.

This is not intended to be another application-specific wrapper, injected translation library or patched game renderer. The project is designed more like a native graphics-driver stack:

OpenGL application
        ↓
libGL / CGL / NSOpenGL userspace interfaces
        ↓
ICD dispatch layer
        ↓
OpenGL_4.6.framework runtime
        ↓
libgl2mtl backend
        ↓
Metal
        ↓
Apple GPU

Applications communicate through the normal OpenGL-facing libraries and APIs, while the framework runtime manages contexts, share groups, drawables, object state and command dispatch. The backend then validates and lowers those OpenGL operations toward Metal execution.

The project currently includes generated Khronos-style GL entry points, CGL and NSOpenGL compatibility paths, context management, pbuffers, offscreen rendering, texture objects, mipmap generation, buffer objects, immutable buffer storage, indexed buffer bindings, mapping, sub-data updates and buffer-to-buffer copies.

The buffer subsystem now includes functions such as:

• glGenBuffers
• glCreateBuffers
• glBindBuffer
• glBindBufferBase
• glBindBufferRange
• glBufferData
• glBufferSubData
• glBufferStorage
• glMapBuffer
• glMapBufferRange
• glUnmapBuffer
• glCopyBufferSubData

GL_COPY_READ_BUFFER and GL_COPY_WRITE_BUFFER have real binding state, and the copy path performs bounds, mapping and overlapping-range validation rather than simply forwarding everything to a hopeful memcpy.

Texture support currently includes object creation and binding, parameter state, storage allocation, sub-image updates, mipmap generation, pixel-store handling and readback. The runtime also has smoke tests covering contexts, state queries, clears, drawing, textures, buffers, pbuffers and shared-object behavior.

After completing an initial implementation threshold manually, we started using Mesa’s source as a reference for implementation ideas, especially for validation rules, object semantics, state tracking and the separation between frontend OpenGL behavior and backend execution.

I am currently handling the architectural checklist, studying Mesa and Khronos specifications, planning feature order and documenting the semantic requirements for each API block. A developer friend is handling the next major implementation phase and working through the OpenGL 4.6 feature-completion stack.

The intention is not to blindly transplant Mesa into macOS. The Apple-facing framework architecture, CGL compatibility, NSOpenGL integration, ICD communication model and Metal backend remain specific to this project. Mesa is being used to avoid rediscovering decades of solved OpenGL behavior through unnecessary pain, an activity graphics developers have historically performed with disturbing enthusiasm.

The project is still experimental. It is not yet a complete or Khronos-conformant OpenGL 4.6 implementation. Major remaining areas include:

• GLSL 4.60 compilation
• shader linking and reflection
• Metal render and compute pipeline generation
• complete framebuffer support
• synchronization and memory barriers
• UBOs, SSBOs and image load/store
• compute shaders
• transform feedback
• geometry shader emulation
• tessellation
• SPIR-V ingestion
• queries and robustness
• performance optimisation
• conformance testing

Even if Apple does not immediately remove its existing OpenGL framework, the larger issue remains: macOS currently depends on a frozen OpenGL 4.1 implementation for legacy and cross-platform software.

The goal of Khronos_AppleICDs is to investigate whether modern OpenGL can exist again on macOS as a proper system-facing implementation, with Metal acting as the native GPU execution layer underneath rather than forcing every application to carry its own translation backend.

Repository:

https://github.com/Anonymous137-sudo/Khronos_AppleICDs

Does anyone know why my skybox stretches like this when moving the camera in my 3D scene?

This is my first time attempting to draw a skybox in an OpenGL project, any help or guidance is greatly appreciated!

How should i draw on 3d objects?

Im a moronic newbie to OGL and i am quite perplexed on how to make a renderer api following azdo principles, should i use multiple opengl objects (like for example; vaos, vbos) or group it all into one. Share wisdom of your methods perhaps?: thanks!

Edit: [fixxed grammatical errors]

After months of hesitation I finally begun writing up a project in OpenGL 1.1/FreeGLUT. Drawing shapes like triangles, rectangles, circles, etc, was easy. Then came the textures and everything went off the rail.

I've been sitting on this for two days straight, trying out various solutions found on decades-old StackOverflow pages, digging into the source code of old games and graphics libraries, but nothing works.

Either nothing renders, or the texture renders in the wrong position (I have a macro to translate window coordinates to OpenGL ones), or it is weirdly rotated, or it is larger than glVertex2f's specify, or it has mirrored copies around it, or all of the above.

For context, I'm using stb_image to load the texture files.

Can anyone tell me how to actually draw a 2d texture in OpenGL 1.1 in a way that actually, for real, works, the way it is meant to work?

Thanks.

glutInit(&argc,argv) works but if i don't want command line arguments in my program how do i make these empty?

i tried glutInit(NULL,NULL) but that doesn't work

solved

Hey, I cooked up this cool newtonian gravity simulation in c++ and through to share it here. I also made a devlog about the development process: https://www.youtube.com/watch?v=qYqOz-Fhbbs

i want to make a 3d game engine, and i have to start somewhere

Hi! I'm in a point where i can draw textures, have lights, have animations. But I cannot implement materials while keeping the whole thing batched. I thought that if I added to the vertex buffer everything in order( first everything with a material, then something with another material ) I could still keep the batching. But that seems kinda raw. Do you guys do it like this or in another way?

edit: thanks a lot guys, I decided to use the solution of Still_Explorer because I found it simple but effective

I just added Non-Euclidian Portals to my game engine!

https://github.com/ViciousSquid/Fio

Fun stuff learning OpenGL ES 3.2 in C using EGL, quite hard at first to implement, but finally I get my first triangle!

Java 7 && OpenGL ES 2.0

Just a janky movement👍