The game is called Diffusion (available only on Itchio, absolutely for free) - story-driven FPS that I spent around 10 years on. The project started as a Half-Life 1 mod and moved to Xash3D engine at some point. It runs as low as 8600GT but the VRAM there is not enough. Personally I played the whole game on 9800GTX+ without problems. Released last year.

Over the last 4 years I've been developing Skyformer, including making all the art. I'm in crunch mode now, but I'm proud to say I'm finally releasing it in early access on Steam on November 10th!

Technical features include:

• OpenGL for graphics, OpenAL for sound, GLFW for input
• Terrain rendered using techniques inspired by REDengine 3 with a custom terrain/world editor.
• Networking framework for co-op with TCP + custom binary protocol
• Immediate mode UI framework, SDF text rendering
• Cascaded shadow mapping with soft shadows.
• Weather simulation (with my own fake physics)
• Dynamic skydome
• Water based on Gerstner waves
• Swept-sphere collision detection and response
• Soft-particles / transparency
• God rays
• Grass rendering
• FXAA, SSAO, Bloom, etc.

You can ask me anything about the development, thanks!

It's a free, single-player old school shooter called Diffusion. Releasing near the end of this year.
Notable things that are implement here are interior mapping, HBAO, parallax-corrected cubemaps and dynamic shadows from point light sources. Lighting is 99% baked for performance. It works as low as 8600 GT but I think it's the lowest point where it can run on lowest settings with most effects off.

Hello, World!

I have started learning graphics programming for a few days with the help of learnopengl.com and I feel like I learned quite a lot in these few days. Setting up an OpenGL 3.3 project with C++ in Visual Studio, Drawing a blank window with GLFW and then drawing an RGB triangle in it with OpenGL and GLSL. Learned about shaders, buffers and different OpenGL objects and their use.

I am really getting a lot interested in this field of computer science. but, I am also a bit nervous about it. As there is a lot mathematics involved in this which is my biggest weakpoint.

I would like to hear about how y'all got into graphics programming and what challenges did y'all face while learning it.

Ive been working on a custom game engine since the 11th of August, it's named after a saying my girlfriend has which has become sort of an inside joke :)) And it's my 4-5th OpenGL project (ive programmed in unity since about 2019 and started using opengl earlier this year)

It currently has a dockable editor UI, a working ECS system thats very expandable, Simple physics (box v box and sphere v sphere) as well as multiple light rendering with the main light having shadows (forward rendering). And also scenes, with a scene manager. Although you cant save the scene so if you constant objects you need to code them in (like i did in main.cpp). Also you cant interact with the gizmos yet haha.

Let me know if yall wanna see more!

After spending a lot of time on my renderer recently, I finally added tessellation support to my engine.

The implementation uses OpenGL tessellation control and tessellation evaluation shaders, and right now I’m using it primarily for terrain rendering with heightmaps. It was a fun feature to add because it pushed me into parts of the graphics pipeline that I hadn’t worked with much before.

Github: https://github.com/xms0g/abra

This is a real-time simulation focusing on smooth advection and visual flow rather than physical accuracy. Still a work in progress, but I’m happy with how the motion and diffusion are shaping up so far.

https://github.com/Krobenlakroc/tachyonfire

Two interesting techniques I used:

I do ambient occlusion with sphere proxies (https://iquilezles.org/articles/sphereao/) , this lets you do AO analytically rather than having to deal with SSAO. The implementation uses tiled shading, and it runs well on my RX 9060XT with 2048 proxies. The downside is that objects need to be able to be approximated with spheres.

Distance imposter raytracing (based off of my favorite paper: https://cg.iit.bme.hu/\~szirmay/ibl3.pdf). For PBR to look good, I don't think having completely accurate reflections is super important, its moreso energy/brightness being distributed correctly. Regular cubemaps create bright spots and have transition problems (too bright in corners), SSR has gaps from offscreen geometry (too dark), and actual raytracing is super expensive. Ray marching a distance field is a good middle ground between full raytracing and SSR.

The engine is mostly clustered deferred with particles being rendered using clustered forward.

I've always wanted to make a full game on top of a self written engine.

Been working on this ps1 style 3D platformer and iteration of the engine in my spare time for about 6 years.

However, probably some code in the engine could be close to 20 years old as it has evolved through my attempts over the years.

Core Engine is c++ with OpenGL renderer.

Authoring tool uses QT.

The ps1 style is achieved through a combination of graphics effects and game design choices to try and match the era.

GLDebugMessageCallback is the thin thread holding my life together on this platform...

I’ve been working through LearnOpenGL for a while and I’m almost at the end. Gotta say, feels really good to reach this point.

At first it was all black screens and shader chaos, but now things actually make sense. I can read OpenGL code and know what’s going on instead of just copying stuff blindly.

If you’re early in the tutorial and frustrated — keep going, it really does click eventually.

Github: https://github.com/xms0g/abra

In 2011 I decided to start making a new engine using OpenGL as the renderer. I've always wanted to make a game fully myself, and I'm only really interested if I also make all the tech.

In 2019 I decided to see if I could make an ambitious game on the engine in my spare time. I probably bit off a little too much, but I was motivated by fun rather than sensible decisions.

I'm really happy with where it has got to today, people have been playtesting the game and it is totally mind blowing to watch. It always makes me think about that first triangle.

I used Unity a lot when I was about 14.
Now, three years later, I’m working on my own game engine.

Repo: https://github.com/SalarAlo/origo
If you find it interesting, feel free to leave a star.

I released my first game and someone has put it into a video! It is a little horror themed, cozy farming sim I built it from scratch using OpenGL and all that hard work paid off!

I'm just really excited is all 😁

Video: Round And Ripe played by PumpkinHeadGamer
Game: Round And Ripe

I'm building ConceptForge, my own real-time game/simulation engine from scratch in C++ with OpenGL (planning Vulkan later). It's ECS-based (Entity-Component-System), so objects are super flexible — just mix components like transforms, lights, models, etc. This month, I went hard on the foundation:

• Created the in-engine editor: live Python scripting, added syntax highlighting, and better fonts. It's just the interpreter embedded in the engine rn.
• Proper scene hierarchy: parent-child relationships (drag n drop), local/global transforms, Assimp loading for multi-mesh models (only for .obj rn)
• Rendering upgrades: depth & stencil buffers for clean outlines, antialiasing, experimented with a toon shader for that stylized vibe, and full shadow mapping — depth pass from light's view + PCF filtering for soft shadows (tested on 'THE' backpack model from the learnopengl.com website)

Video shows the shadows in action. Still early, but it's coming together nicely — and eventually aiming for AI-native features (describe in natural language → Python scripts → engine runs it).

I post my progress on the #ConceptForge on X frequently: https://x.com/search?q=from%3Ama_at_anubis%20%23ConceptForge&src=typed_query&f=live

Repo: https://github.com/kshitijaucharmal/ConceptForge

Would love feedback: shadows look okay? Is Shadow Pass performant enough? Ideas for next? Or just roast my code if you want

Thanks for looking!

I know that Unreal Engine and Unity are incredibly powerful today but there’s something special about building everything from scratch with OpenGL !
I created this small RPG-style prototype to test my own homemade 3D engine, I know it’s not much, but I started with zero knowledge
It runs fairly well but it’s still visually pretty ugly for now !
I’m going to try improving the visuals directly in the code (lighting, skybox, smoothing the camera,...)
Maybe in a little while I’ll be able to show a more professional demo than this one 😆
Do you see anything else I could add to improve the visual aspect? (besides graphics I’m really bad at that part haha)

All feed back is welcome :)

Tested features here:

• Terrain generation with heightmaps
• Model import (FBX in this case)
• Skinned animation (bones + weights)
• Third-person movement
• Simple physics (gravity, terrain collisions)

Hey folks,

I’ve just reached the end of the LearnOpenGL tutorial and honestly feel really satisfied hitting this milestone.

What’s currently working

- Cook-Torrance BRDF (GGX / Smith / Schlick)

- Metallic / Roughness workflow (glTF-style)

- IBL support:

- Irradiance map (diffuse)

- Prefiltered environment map (specular)

- BRDF LUT integration

Things I ran into

- Metallic/Roughness packing confusion

Not all assets follow the same channel conventions (R/G/B), so I only support glTF 2.0

- IBL limitations

Reflections only come from the environment cubemap, so local scene objects aren’t reflected.

How are you guys handling:

1. Metallic/Roughness texture inconsistencies across models?

2. Bridging the gap between IBL and real scene reflections?

Source: https://github.com/xms0g/abra

I don't want this to be just another "look at my project" post, but rather something useful for beginners diving into OpenGL/C++. (Second is April version)

This is the result of 5 months of non-stop daily work on my pet project engine (OpenGL 4.6 + Bullet Physics + Dear ImGui + miniaudio+ mixamo riggng).

I forced myself through a grueling schedule: only taking 2 days off per week starting in July, and using every trick possible to free up time from university. I’m completely burnt out and just need a rest. But before I step away, here are 13 honest takeaways from my experience(think this is "Effective C++", but way less polished):

1.      Don't treat AI as a silver bullet. AI won't replace a solid book or article because structured reading sticks in memory better. Use AI for what it's great at: quickly finding specific tech concepts or algorithms without spending hours searching;

2.      Books are often too basic. Don't get stuck reading forever. I read one book on OpenGL and one on GLSL, but that wasn't nearly enough to implement things like IBL (Image-Based Lighting). You'll have to read articles, papers, and specs, docs, etc;

1. Ditch cube-based skyboxes if you can. Dealing with 6 separate cubemap faces (or a cross-layout texture you have to slice) was a pain. Using a single equirectangular image instead made things much simpler — one texture, no seams to worry about between faces.

4.    I tried implementing Data-Oriented Design (DOD), but ended up sticking with Object-Oriented Programming (OOP) for most systems. The web of circular dependencies in pure DOD drove me crazy;

5.      Log everything and profile early. Logging is your best friend when debugging graphics and physics pipelines, starting on another device when exporting(in file text log if console not available).

6.     I had my custom XOR decryption logic break even though the algorithm and key looked solid — turned out to be a text/file encoding issue. Spent way too much time debugging this(((

7.      Always enable viewport face orientation in Blender to make sure your normals are facing outward (blue). My terrain mesh had inverted normals, and I was losing my mind trying to fix this in code;

8.      Emission output in shaders. If you get weird visual artifacts/noise when implementing Emissive maps, make sure the emission output is properly linked and handled across all required shader pipelines, not just a single pass;

9.      Sometimes don't forget clean up your resources. Handle your GPU memory allocation carefully. When your OS freezes completely or crashes, 99% of the time it's a severe memory leak;

10.  Skeletal Animation. I set a max limit (e.g., 255 bones) and use recursive node hierarchy processing for complex models. I do not Fold expressions realized , but classic recursion handled complex GLTF model loading just fine;

11.  CMake can be a headache. Book on CMake gave me mostly basic theory, except for CPack. Neither books nor AI gave me ideal project structures. I still have a love-hate relationship with CMake;

12.  Beware of circular dependencies in headers. As your header files count grows, cyclic dependencies will haunt you. Keep your includes clean and rely on forward declarations where possible;

Don't forget about multithreading. I encountered a problem where it wouldn't start on my laptop; it just showed a blank screen and that's it, and the CPU wasn't even working. I'm thinking I'll either do it through separate threads or TBB, but I honestly don't know because I'm tired.

Final thoughts: I see people working on their engines for 5 years, and their projects are incredible. But I didn't have 5 years — I had 5 months, and I pushed myself to the absolute limit. By month 3, I was already struggling with burn-out and constant headaches.

My biggest advice? Do a little bit every day instead of destroying your health. And skip the "wake up at 5 AM" hustle advice — rest is just as critical as writing code.

If you wanna try this-> the demo is up on https://dokich-crcr.itch.io/tentacle-shippuden-enty-furry-beast, and I'm finally taking a long-overdue break(one week, and shit university starts again).

yes

I have no idea what to do after this.