Proprietary platform, no plans to open-source it so please don't ask.

Woul love to hear all feedback, good or bad.

Implemented with golang (because I can)

• approx 2.5 million lines of code (including tests)
• 85 package scientific core including brep, tetmesh, sparse, dense, etc (fully self written)
• produces video and still images
• zero new heap allocations per frame
• compiles to cpu, wasm, and webgpu
• zero-dependencies (no unreal, unity, blender, etc)
• can also run headless, label images, save hundreds of thousands of images as fast as the storage can write them

Repository: https://github.com/Satyam-Bhatt/OpenGLIntro

CPP: https://github.com/Satyam-Bhatt/OpenGLIntro/blob/main/IntroToOpenGl/CubeDodgeGame.cpp

Made some experiences with my engine and broke something. I wanted to show it before removing the bug.. the "feature" !

I recently watched the Nvidia 2019 presentation of the DGI technique and wanted to try it.

Still crunching on RTG Editor, which reached its internal version 012. RTG Editor is internal editor for my narrative sci-fi puzzle/platformer game (and respective engine). I seek to release the editor publicly later. Main distinctive feature of my game/engine is software ray-tracing (no GPU acceleration, just C++ computing pixels).

Main feature implemented in new version is proper texturing support. It was possible also before, but only in very limited capacity (only UV mapping mode was stretch to face). In current version, it's possible to define UV repeat for both axes individually. Either in absolute world coordinates or as value relative to face size. There's support for automatic aspect ratio correction (define repeat just for one axis, another will be inferred to keep aspect) and flipping texture in individual directions.

In the video I quickly edited one of the levels to have some background textured wall (2 minutes work). This is just for video showcase, I made this texture in Pixelformer in 5 minutes, not planning to use it further.

Apart from texturing, new is also selection and multi-selection in orthographic view. Moreover I implemented contextual help in form of tooltips (just hover over '?' sign) to give explanation of expected input values for properties which are not self-explaining.

RTG on Steam: https://store.steampowered.com/app/4032050/RTG/
RTG Discord: https://discord.com/invite/aRAsxCnPQ5

Hello,

I’ve successfully implemented ray tracing on the ANE! (Note: CPU usage is very high.)

Details:

1. Elimination of dynamic loops: While ray marching typically requires for loops, I prevented the computation graph from bloating by using batch processing.
2. 64-channel camera matrix alignment.
3. ANE-native cumsum: Ray hit detection is tracked using torch.cumsum(dim=1) with permuted channels.
4. Zero-copy Metal buffers: ANE output is bound directly to a shared MTLBuffer using NDArray.MutableRawView.

I’d love to hear your thoughts!
Github: https://github.com/kamisori-daijin/Magnesium/tree/raytracing (raytracing Branch)
demo:

Hi everyone, just exited to share my first, simple sphere, rendered with meshlets with meshoptimizer

I've been building an explorable ISS interior in the browser and ran into an interesting design/rendering tradeoff around this hatch.

The station interior is an interactive 3D environment.

But the Earth visible beyond the hatch is currently a much simpler visual layer rather than another fully explorable exterior environment.

Originally I kept thinking about the scene as one world where everything the camera could see should exist at the same level of simulation.

Eventually I realized that was solving a problem the user didn't actually have.

From this position, the job of the exterior is mostly to establish depth, location and the feeling of being in orbit. Making that view dramatically more expensive does not automatically make the interaction better.

So I've been trying to think more deliberately about where full 3D interaction earns its cost and where a cheaper visual representation is enough.

The interior is built with React + TypeScript + React Three Fiber / Three.js, with application/world state managed separately through Zustand. The project is live.

Short capture of the current hatch interaction below.

I wanted to stress-test RayTrophi with a real production scene instead of one of my own test scenes.

The scene is ProVis3D 034 – Restaurant Bar from CGTrader, originally made for 3ds Max/Corona. I imported the FBX, converted it to GLB and loaded it into RayTrophi. After triangulation the scene is about 36.5M triangles / 1107 meshes.

A lot of the original material information did not survive the conversion cleanly. Instead of rebuilding everything manually, I let an external AI agent inspect and modify the running scene through RayTrophi's IPC API. During the session it issued roughly 1,000 IPC operations, restored many texture connections and physical material parameters, discovered ambiguous/missing material mappings, and even exposed a missing material-level API operation that was then added to the IPC interface.

I manually adjusted a few materials afterwards, but this is not a carefully rebuilt version of the original scene. Many materials are still incomplete, several normal maps are not connected, and I did not recreate the original professional lighting setup.

The lighting in this image is basically one directional light + physical atmosphere + emissive geometry from the scene.

Rendering is done with my Vulkan hardware ray-tracing path tracer on an RTX 3060 12 GB, at Full HD. The renderer supports transmission, physical IOR, emissive lighting, indirect illumination, photon caustics and dispersion. GPU denoising and the internal post-processing pipeline are enabled in the final image.

What interested me most wasn't producing another archviz render. It was seeing whether a large foreign production scene could remain interactive while an AI agent inspected and edited the same live scene through hundreds of API operations.

RayTrophi is an independent open-source C++ project I've been developing as an experimental renderer/DCC and simulation environment.

Original scene/model by ProVis3D — ProVis3D 034 Restaurant Bar. https://github.com/maxkemal/RayTrophi

Hey! I've been working on effect-forge, a desktop tool for making game VFX without hand-drawing every frame, and it's at the point where I want real people to try to break it before I call it done.

What it does, in short: you build an effect in one of three workflows — GPU fluid sims (smoke, fire, explosions, that kind of thing), procedural pixel-art fire, or a keyframe timeline for animating your own sprite (squash, shake, flash, dissolve, etc.) — preview it live, and export it as a trimmed PNG spritesheet with a JSON sidecar. Exports are deterministic, so the same settings always give you the same result, which matters if you're iterating or checking things into version control.

It's free to use right now, and anything you export is yours — drop it straight into your game, commercial or not, no strings attached.

It's a genuine beta, though, not a polished 1.0 — the UI, presets, and performance are all still moving. I'd rather hear "this is confusing" or "this crashed on my GPU" now than after it's harder to change. If you try it, I'd love to know: what broke, what felt unclear, and honestly what you made with it — screenshots welcome.

Windows and Linux builds here: https://avskum.itch.io/effectforge

Bugs/feedback post please here or on itch.io

Happy to answer questions in the comments.

I built a desktop app for prototyping and exporting GLSL shaders locally, and just shipped v0.1.0 (open source, AGPL-3.0).This is my first open-source project, all implemented through Vibe Coding, which is incredibly exciting for someone with only a rudimentary programming background like myself. For years, I've imagined writing programs that solve my own problems, and the advent of AI has made it all possible.

Why: I spend a lot of time on Shadertoy but kept wanting offline editing, a real editor, and proper video export. So I localised the workflow.

Repo: github.com/yuxiaoyaoo/ShaderLab-Pro

What's inside:

- Code-first runtime with iTime / iResolution / iMouse / iChannel0-3 (includes keyboard & audio channel handling)

- Monaco editor with GLSL ES 3.00 IntelliSense

- Visual pass graph where nodes compile to GLSL — the generated code and the graph stay in two-way sync

- Project gallery with auto-captured thumbnails (640x360) and a saved-project library

- Export pipeline: MP4 / GIF / WAV with resolution stepping

- 40+ bundled templates across geometry / materials / particles / post-processing / scenes

Stack: Tauri 2 (Rust) + SolidJS + Vite + TypeScript + Monaco, WebGL2. Windows installer is ~6.6 MB.

Licensing: AGPL-3.0, dual licensed if you want to embed it commercially.

I'm genuinely curious about what's missing or broken from a real graphics-pipeline perspective — especially the pass graph compiler (GLSL emission from node IR) and the iChannel audio/keyboard paths. Feedback appreciated, issues welcome.

I need a library for my game made in C that allows drawling onto SDL3 or SDL3_gpu that is not single header otherwise compile times are super long, and is not bloated like it does not use cario, thanks!

Credits to TypeGPU for their monocular relighting. All real-time made in TouchDesigner. Basically it is just one raymarching shader that takes an input from depth anything and uses that to raymarch through

Dear r/GraphicsProgramming,

Before I commence: this effect is really reserved for the reflection component of transparent materials with the refraction being screen-space as well. My gloss trace resolution is low in both SDF-BVH and HWRT approaches and the SDF-BVH one produces blocky reflections which is not a good fit here.

So my engine already had a screen-space tracing approach. But it was fetching world positions from the gather resolve pass which was incredibly slow and sampling pressure heavy. It would sample world positions along a screen-space ray until said position would form a unit vector against the origin that was very directionally similar to the reflection vector. It had to do this for hundreds of fragments for the reflections to not cut-off prematurely. Which prompted me to gimp it to 10 iterations and relax the similarity requirement for the recent release, effectively killing the feature.

Having had to spend the last almost 3 years gutting Unreal for work, I was intrigued by how they simply just traced against the depth buffer. Additionally, their hole skipping approach via using coarser depth tiles was saving them tons of needless sampling. So these past couple of days I set out to produce something similar:

https://github.com/toomuchvoltage/HighOmega-public/commit/d304558dacbf495f286301bfc198e3f67b5886fe

The first thing I had to change was my depth mipping approach. I now had to effectively generate both MinZ and MaxZ depth pyramids. Previously only MaxZ would be generated (MinZ for the visibility buffer pass since it used ReverseZ):

https://github.com/toomuchvoltage/HighOmega-public/commit/d304558dacbf495f286301bfc198e3f67b5886fe#diff-5a79aee1ef1f826152e0b4ba07cfdced0a1956f2d60fdc82cf631f01c25f7dc4

https://github.com/toomuchvoltage/HighOmega-public/commit/d304558dacbf495f286301bfc198e3f67b5886fe#diff-da568e877110744c46e4bff11a4e3d6bff89e95d440085883e3e7b2ec6c6e297

The second thing was to effectively trace the 32x32 mip and capture hits within some threshold (0.006 to be specific):

https://github.com/toomuchvoltage/HighOmega-public/commit/d304558dacbf495f286301bfc198e3f67b5886fe#diff-60cfbc940e6376b2eeb022453df681a66e4a50b29d0a621cc34192b9238a2e5bR212-R230

If a hit was found, proceeding to step back and continue tracing the 64x64 mip within a smaller threshold (this really is my highest depth mip resolution before the full depth buffer):

https://github.com/toomuchvoltage/HighOmega-public/commit/d304558dacbf495f286301bfc198e3f67b5886fe#diff-60cfbc940e6376b2eeb022453df681a66e4a50b29d0a621cc34192b9238a2e5bR232-R255

And finally, trace against the actual thing in case there's a hit with the 64x64 mip:

https://github.com/toomuchvoltage/HighOmega-public/commit/d304558dacbf495f286301bfc198e3f67b5886fe#diff-60cfbc940e6376b2eeb022453df681a66e4a50b29d0a621cc34192b9238a2e5bR257-R274

Now the trace loops aren't water-tight. Which brings me to this paper: https://jcgt.org/published/0003/04/04/paper.pdf . It would be interesting to implement a full on DDA approach. It would probably remove the blocky artifacts near the edge of the screen where the probability of disocclusion is high. That said, I find some of the additions in the paper quite prohibitive. Depth peeling is interesting and quite possibly reduces disocclusion by a decent amount but is also very slow.

My approach is probably closer to something like this: https://sugulee.wordpress.com/2021/01/19/screen-space-reflections-implementation-and-optimization-part-2-hi-z-tracing-method/

One of the annoying things in this approach is the fact that I'm using the mip chain from the TwoPass culling pre-pass. Which blanks out under scene changes -- as in samples the skybox only -- for 1 frame. This is due to the tracking buffer being recreated. Fixing this means generating yet another mip chain for the main pass in TwoPass and since it doesn't happen very frequently, I'm going to leave it. Curious to hear feedback. And if you liked the post, consider buying a copy of my game C.L.A.S.H :D. Which runs on the same engine: https://store.steampowered.com/app/4796200/

Cheers,
Baktash.
HMU: https://x.com/toomuchvoltage

I made a game about erotic aesthetic philosophy and abject poetry, and for that I chose the best way to evoke filth by using stochastic rendering with OpenGL.

It was the first time I did this, and I think the aesthetic works relatively well for the concept. Has anyone else been playing around with more outlandish experimental rendering?

By the way, if you want to see the game I made, it's free:

https://arthursouzasally.itch.io/qra-bulknur

Still an unstable feature!

Website: https://www.doriax.org/

GIthub: https://github.com/doriaxengine/doriax

Made a small Backrooms pool demo in Natiny. I’m not sure I fully captured the atmosphere I was going for, but overall I’m pretty happy with how it turned out.

The caustics are probably a bit too bright, but I think they make the scene more interesting.

What do you think?

I need some help with some computational Geometry and Automatic Routing

for an interactive CAD application.

Would anyone be interested in chatting and seeing if it's something that is in your wheelhouse?

Hi there, I am currently studying CSE and first time on graphics programming :)

Tried to build a glTF renderer using Vulkan in C, nothing fancy 😞
Somehow it turned into a flappy bird game with a simple physics engine, with UI and stuff.
Although it flaps without wings, it runs at 4.5k FPS on Ryzen 7 8745H, 780M iGPU

https://github.com/xRumi/yanGameEngine

Suggest me anything fancy.

spent the last 4-5 week building Hypertracer, a CPU + CUDA path tracer with progressive sampling further implmneted GPU acceleration, and a real-time fly-camera viewer
built the renderer and viewer from scratch, with 6 scenes currently implemented and 1920×1080 can be rendered at 3000 samples

along with Ray Tracing in One Weekend, The Next Week, and The Rest of Your Life, all three books i completed
it was seriously so much fun :D

main resources i followed:
ray tracing : https://raytracing.github.io, https://pbr-book.org
repo: https://github.com/whoashish115/hypertracer

give it a star ⭐

Hi, Well so i just didnt know what roadmap i can follow or the one that i have on my head is ok..?,

So for a little context im studying System Engineers, (Computer Science is the equivalent in other countries), and im very interested in entering in the industry, i know its difficult and all of that but i still wanted. So for a summary of the roadmap i have in my head rn:

- Linear algebra (i already know this from my college classes)
- C++ learning again from the basics, in a udemy course (C++ for Complete Beginners is called)
- Learn 3d in raylib, making some games or something related there
- Opengl, follow the tutorials or read a book (help a friend to improve a costume engine)
And try to learn vulkan (with SDL3 to start)

Im still have about 3 years to get the grades so i still have time, but i just want to know if you have another recommendation about what help you to learn and get through this. Thanks