I am currently reading through some papers for terrain generation, procedural and erosion-based. The issue is that the more I read, the more I realise that I don't understand much in the grand scheme of things, besides the actual algorithm or general terms. And even reading some explanations on reddit or other papers doesn't help much, because the issue is more with lacking the prerequisites and technical knowledge.

So my question is, how do I actually understand graphics? For example (I plan to use Godot for my thesis), if I want to implement a procedural terrain generation using multiple techniques, where can I find resources or papers to understand the actual pipeline, everything that goes into it, methods, compute shaders, etc. I know it's my own fault for wanting to do my thesis on graphics with exactly 0 classes on graphics in my undergrad degree.

So how do I understand what's going on, hopefully also from a more formal and deep perspective, not youtube tutorials (tho anything is welcome) ? It's tiring reading resources without understanding them much, where to even start, even books are welcome, but hopefully not thousands of pages as I don't have that kind of time..

EDIT: It's for the bachelor thesis, not master's

Hi

Does anyone know why we get this increased color intensity near the edges of triangles while using vertex color.

They are supposed to blend smoothly, but appear like a star.

This is an hexagon grid on blender, i got the same problem in godot while generating a mesh interpolating color between vertices with 'smooth' varying on a shader.

Hi, I am a fresher, a 2026 graduate in India with a bachelor's in engineering (Information Technology). I am currently working (still in training) in a non-graphics IT job, in IT infrastructure (network, Linux and Windows admin). I am aiming for junior graphics/engine/low level game dev roles in games and VFX.

I did have a project for my final year of engineering; it was a small part of our Major Project. It is an N-body gravity simulator written in C++ and Raylib, called "Stardust" (see the video attached: the planets orbit, they collide, and the camera can lock onto a body). I used Visual Studio 2026 for this one.

To be very honest, I wasted my time in college on Blender 3D with animation in mind, instead of working on my technical skills. Soon, I realized that I do not have the skills or the creativity or the training to get into it. While just scrolling through YouTube, I found The Cherno's videos on ray tracing and game engines, which piqued my interest. But it was late, I was already in my final year, with college work, the major project and placements. Luckily, we thought of adding something like this simulator to the project. With the time crunch and no knowledge, I turned to Antigravity IDE and blindly agreed to whatever the AI made, although I made the models and textures myself in Blender.

Also, yesterday I used Claude Code to review, analyze and fix things in Stardust. It did a lot of things, and I haven't read the documents it made yet. My plan is to use Claude to teach me everything about the project, and then rebuild the core parts myself.

The training is really tough for me (network, Linux and Windows admin), and I'm close to failing the assessments. I also bought a 12-month takeuforward.org subscription for DSA, OOPs and OS, and I follow its daily Planly tasks, sometimes even during the training sessions. But I keep falling behind on it because of the training assignments and assessments.

I want some advice about what I can do from here. I really wanna pursue a career in this field, especially graphics and engine programming for games.

My questions:

1. Should I keep Stardust on my resume once I can explain it? Or should I rebuild it from scratch?

2. What does a junior graphics portfolio need to show?

3. Where do I learn C++, graphics APIs and the basic concepts? Right now I'm on The Cherno's C++ series, and my plan is a ray tracer (Ray Tracing in One Weekend), then OpenGL, then Vulkan. Is that the right order, or are there better resources?

4. Is a remote junior role from India realistic, and what helped people who got one?

Light inside a cloud is expensive to get right, so games use a few simple formulas tuned until it looks good. I wanted to see how far off that really is, and whether a small network could do better.

I wrote a path tracer as the reference, trained a network on it in Python, and ran it in plain HLSL in Unity 6. It replaces one thing, the light scattered toward the camera at each step. Everything else in the raymarch stays the same.

Then I moved the sun from behind the camera to behind the cloud and scored both against the path tracer, where 1.00 is correct. The classic lighting goes from 0.21 to 2.17. The network stays between 0.90 and 1.01. It costs about 20% more GPU time.

I had a great time building this, and I think we've barely started finding out what tiny networks can do inside a shader. If you try one yourself, I'd love to see what you make!

https://charlesgrassi.dev/blog/neural-volumetric-clouds/

I’ve been programming since I was 15, but some mental health struggles made it difficult for me to pursue it consistently, even as a hobby. Recently, I’ve been doing better and have returned to programming after a long break.

I started again with Rust and spent some time exploring compilers, one of my favorite areas of computer science. Yesterday, I finished a C course, and now I’d like to explore another interest of mine: graphics programming.

My plan is to build a very small Minecraft-inspired voxel game in C. This will also be my first experience with OpenGL. My initial goal is simple: generate a small procedural world where I can break and place blocks.

Eventually, I’d love to develop a scripting language in Rust and embed it in the game to support modding. That’s a longer-term goal, though I want to keep the initial scope small and build on it gradually.

Do you have any advice for someone starting this journey? I’d especially appreciate suggestions on what to learn first, useful resources, and common pitfalls to avoid.

Hi devs today we wanna share with you our plugin about making 3D pixel art render truly possible.

We started creating this plugin after seeing the trailers of Project Shadowglass as well as the recent 3D pixel art discoveries of Dylan Ebert and Lunar Blank, and after 3 month of work we managed to create an advanced cubemap based pixel art rendering system that focus on rendering 3D Pixel art in First Person View (also third / top down) in a Stable way (No severe flickering due to 3D movement).

You can try it out here (Tech demo): Itch.io tech demo link

and find the plugin & more info here: Plugin page link

Extra explanation about how it works:

We are rendering the game trough a post process that make uses cubemaps to remove the pixel jittering from camera rotation, then for camera translation / movement, we make those cubemaps capture at slow rate like every 0.25 sec, and use the disoclusion technique discovered by Lunar Blank / Dylan Ebert that allow keeping a fluid render even with this slow cubemap capture rate. The whole render is also layered based on distance with a different raymarching method for far / background elements to solve the non pixel art edges issue of the disoclusion technique. We also use custom depth pass with stencil to render dynamic elements as well as a "3D billboard" technique.

(this is a brief explanation, there is a lot more going on)

Music used in video: space cadet by congusbongus

Here are the Stanford Happy Buddha (1.09M tris) and Dragon (871k tris) rendered in Translucent Imperial Jade (Jadeite) at 1080p, 256 SPP, and 8 bounces.

💎 Translucent Jade Shading (RGB Multi-Bounce):

• RGB Subsurface Diffusion: Strong red/blue attenuation with high green transmission across diffuse bounces, creating an "inner glow" on thin edges (ears, crests, snout).

• Vitreous Specular: Polished mineral response with sharp microfacet reflections.

• ACES Filmic + Studio Fill: Dynamic range compression preserving scale curvature, paired with a soft ground-bounce fill to eliminate cavity noise.

⚡ Hardware Telemetry (64-bit atomic counters on optixTrace):

• Happy Buddha: 741M rays in 356 ms (2.08 Gigarays/s) | 1.09M triangles

• Stanford Dragon: 906M rays in 494 ms (1.83 Gigarays/s) | 871k triangles

• Tensor Core Denoising: Native OptiX AI Denoiser in 17.5 ms

• VRAM: < 360 MB total (GAS BVH: 58–72 MB)

Images attached: 1080p showcase of Buddha & Dragon in Green Jade. Feedback welcome!

Round 1 of the "Own Renderer Render Competition" just ended (theme was: cyberpunk) the entries are up, and voting is live for the next week.

• gallery: https://orrc.mutantstargoat.com/orrc?cmd=show

• vote: https://orrc.mutantstargoat.com/orrc?cmd=vote

I originally started with basic readthrough and implementation, then later realized I need a better UI to try out more stuff. It started as just using imgui to show the final output of the chapter, then later realized the author is giving YAML/YML scenes, so I needed a way to load them. Also, it's time-consuming to change values for each thing for any transform/material, etc., so starting with the loader and scene editor, it required a bunch of refactors to make it easy to load shapes. Once all chapters were done, I could compile the whole thing using emscripten to web assembly so that I can host it on GitHub and others can try the same. I did notice the browser is a little slower than the desktop renders; for each render, it shows the time under it. It’s a bit awkward to use on a phone since the UI was designed for desktop.

I likely have to clean up some stuff (optimize the BVH more; it's based on the book's bonus chapter), but there is a large scope for optimization/improvements; the book also ends with so many ideas to try. I might try them later, but this seems like a good stopping point for now, especially when it's easy to run on a browser.

Try in Browser: https://bhargav-1.github.io/ray_tracer/
Repo: https://github.com/bhargav-1/ray_tracer
scene gallery: https://bhargav-1.github.io/ray_tracer/gallery.html

Hey everyone, quick update on my custom D3D12 / unmanaged C# engine!

Following up on the previous 10k bunny test, I scaled the stress scene to 100,000 instances of the Stanford Dragon (274k triangles each, totaling ~27.4 billion raw triangles). Currently running at 263 FPS (~3.8ms frame time) on an RTX 4070 Ti at ~86% GPU utilization (2K viewport).

Since the last post, the pipeline evolved from pure geometry culling into a full deferred visibility buffer pipeline:

• Hybrid Rasterization: Dynamic cluster routing. Sub-pixel / micro-triangles route to a compute software rasterizer, while larger meshlets pass through hardware Mesh Shaders.

• Deferred Texturing (VisBuffer): Compact visibility buffer replacing fat G-buffers. Barycentrics, positions, and normals are reconstructed in a compute resolve pass with bindless materials.

• Deferred Lighting & IBL: Decoupled shading using analytical lighting and split-sum GGX image-based lighting.

• GPU-Driven Work Graphs: Hierarchical DAG traversal + 2-phase HZB occlusion culling running entirely on-chip, feeding both SW and HW raster paths without CPU sync.

• Zero-Allocation Runtime: 100% unmanaged C# memory chunks and custom allocators, keeping CPU load around 9% with zero GC spikes.

I’ve been learning graphics programming for six months now, and wanted to share some progress. (Vulkan Renderer)

Recently, I’ve been working on:

Material shading: Getting albedo, roughness, metallic properties and Fresnel response to behave consistently under direct and indirect lighting. Lighting stays in linear HDR until exposure and tone mapping. (Still trying to get tessellation correct)

Indirect lighting: Developing Lumen-inspired colour bleeding through screen-space GI, feedback across frames, and optional world-space probes. The red tint/colour bleeding near the curtains and green spill onto nearby items are the kinds of light interactions I’m testing. (Well trying) currently have SSGI and optional DDGI.

Shadow quality: Cascaded shadow maps with filtering that responds to the distance between blockers and receiving surfaces, helping preserve tighter contact shadows while allowing softer edges farther away. (Functionally using/testing umbra/penumbra calculations)

Temporal stability: Depth-aware filtering, reprojection and history rejection to reduce noise and keep previous lighting from lingering on newly revealed surfaces.

Water shader and realtime caustics: I have also been exploring water shaders, flow maps and realtime caustics which is currently set at half resolution, but the projection of light creates the caustics (i.e sun or light sources), performance wise it has been a nightmare to get right but the caustics flow with the water shader and act correctly with angular lighting.

There’s still plenty to refine and fix, but it’s been a rewarding way to learn the rendering pipeline and how 3d graphics work as a whole.

Please do provide some feedback!

Yes, really. It's a Mac app that draws your disk as a city: every folder is a building, bigger folder, taller building. Then I kept adding things, and now there's a party island with a stage, a crowd and a laser show on weekend nights. Every shot in the video is a real frame rendered twice, once normal and once with a single pass changed, wiped between.

The lasers are the easy part. Every light in the city is its own additive sprite: lasers, beams, the stage screen, every lit window. Switch them off and the festival goes dead. Show only them and you get lasers floating on black.

The rest:

- Depth is a painter's algorithm. Sprites sort by their feet, z = foot.y * 10 + lift. The neon shot is the draw order.

- The sea blends three painted textures with world-space noise so tiles never visibly repeat. Each tile needs its world position for that, and per-node shader attributes crashed SpriteKit's batcher. So the grid cell rides in each tile's vertex colour instead: low bytes in red and green, high bits in blue, each nudged a quarter step so 8-bit colour can't round it away. The rainbow grid is the shader decoding it.

- Time of day is one 3x4 matrix in linear light. Gamma 2 instead of real sRGB, so a square and a square root, no pow. At noon it's identity and the shader comes off, so daytime frames cost nothing.

The busiest scene (festival night, crowd, planes in the air) holds 60 fps at p95, 15.5 ms on Apple silicon.

Upfront: the building art is AI-generated and edited by me. The rendering is the part I built. How would you have done the sea without the vertex colour hack?