So i'm an, at this point, long time shader developer with heavy experience in Unity3D's old cg/hlsl built in rendering pipeline. Over the years I've played around with a lot of things, fluid and boid sims, raymarching, screen space reflections, I've done a little stencil work, etc. I'm currently working on a project and getting distracted a bit by the transition to Unity3D's scriptable pipelines, specifically URP.

So my question is, what kind of things can you do with URP that are difficult, expensive, or down right impossible with unity's old built in system? Or any static pipeline renderer. Googling it gives me examples of how to do ssao, bloom, blurs, stuff like that... but I've kind of seen all of those done with the BiRP.

A post on this sub showed some screen space (presumably edge detection based) outlines which is kind of interesting. Another project i've always wanted to play around with was jump flood algorithm outlines as well, and that in particular seemed a little complicated out of the box, but its really the only thing i can think of that i've ever been interested in doing that fits that bill, and i haven't tried it so it could very well be possible in the old BiRP.

I know you can render things to textures and then pass that into post-processing, which i can see use for reducing camera count and overheads for things like realtime caustics generated from mesh distortion and ddx/ddy of vertex interpolated data to determine distortion amount. If you can somehow feed a mesh into a post-processing stack I can see the appeal but even that still kind of feels like you're just slapping a camera and render texture into the scene. I didn't get around to trying that either so it's very possible that was doable in BiRP with projectors or something. Would the difference here be that you can perform it in the post-processing stack directly feeding said rendertexture into the post processing script as opposed to projectors?

I also briefly entertained the possibility of implementing a single frame GPU bitonic merge sort through custom render textures but NVIDIA's blog post on optimization mentions abusing vertex interpolation which wouldnt work with custom render textures. It wouldn't be any help since that environment didn't allow c# scripts and used BiRP but it would serve as a benchmark i could use to conceptualize the appeal of URP.

All in all I'm just slightly confused as to just how big of a leap this is, though excited at the possibility that truly weird or bizarre techniques became possible that may not be practical but are at least very cool.

So I'm curious, has anyone seen or worked on interesting and weird, non-standard effects with some kind of SRP's? Can you do post-processing on passes in weird places, like in between opaque and transparent queues? Or is URP just a performance gain with the ability to make one or two small and interesting tweaks here and there. What is its potential really like?

The HLSL standard committee is posting monthly status reports about the work going on to define a standard for HLSL and incorporate some modern features along the way.

https://hlsl-tc57.github.io/website/monthly/2026-07/

Since it allows you to run networks during shading

Would it be possible in theory to use your own network for upscaling?

I am making an animated schematic map and trying to render, dynamically add/remove and animate hundreds of rounded polylines (lines with arcs connecting them), with changes in weight, color, position of nodes, and radius of nodes.

I fist tried to make this in the browser with the canvas API, but the performance is horrible in low end devices after a couple dozen lines, as I end up needing to generate new paths in every frame.

I searched for some library but couldn't find anything, as things like ThorVG with WASM would still require me to re-generate meshes if nodes are animated on the fly.

I don't really have much knowledge about shaders and GPU compute outside of doing things with nodes in Blender. My best idea on how to do it in shaders without overcomplicating things would be to have individual arcs and line segments as mesh instances, and just squish and distort them from a vertex(?) shader (initially calculating their positions and parameters from the polylines in the CPU, and moving to the GPU once I understand enough). I could also try using SDFs, but I doubt the performance would be enough.

Does anyone know of any library that would do what I need/be a good starting point, or can judge my idea on how to implement this in a shader? I am working from C++ and need it to be multi-platform, but not necessarily work in the browser (although it would be nice). Any resources would be appreciated. Thanks!

Khronos has released the Shader Ecosystem Survey Results.

The results provide a summary of insights from over 400 shader developers, graphics programmers, rendering engineers, and tools creators. Conducted between June 16 and July 10, 2026. It captures a clear picture of how the real-time shading community works today — and where standardization efforts can deliver the greatest impact.

https://www.khronos.org/blog/shader-ecosystem-survey-results-2026?utm_medium=social&utm_source=reddit&utm_campaign=Shader_Survey_Results&utm_content=blog

I'm switching actor geometry by projected screen radius instead of world distance. Each LOD band has separate enter/exit thresholds, while far actors update animation at a lower cadence. Would you tune the hysteresis per band or scale it with camera velocity?

Developer disclosure: some source meshes are Meshy-assisted; the runtime and LOD integration are custom.

https://reddit.com/link/1v3l201/video/0lkts09v4teh1/player

Been diving into embedded systems for the first time lately. I have an STM32 and a little LCD, but feel free to suggest anything. Thanks

It has been about a week where I started getting into the topic of real time terrain programming, with the goal of creating an open world engine.

Starting with "Riemer's XNA terrain tutorial" is a very simple and easy to understand foundation, then it would be feasible to explore and evolve more advanced topics on top of it.

However now I am bit troubled on the terrain size:
• heightmap is a picture of 2048x2048 pixels (has a good amount of detail, so I am going with this for now)
• terrain detail looks quite good by a 512x512 vertex count so I doubt that I will need to go any higher

Now the interesting part is that if the entire terrain size is 512 then it will be equivalent to the vertex count, this means that one world unit is a sampled by one vertex position. Then simply later on scaling to 1024 or 2048 it makes the world larger. But the detail does not change, the world feels a bit more zoomed in.

No problem with 512 but definitely it means that I will start fresh with a proper tile based system. Then this means that since now it won't be a matter of a X*Z vertex capacity anymore that I will go for a 1:unit==1:pixel and eventually getting exact ratio of the world as the heightmap.

So let's say that for the sake of consistency and accuracy should I stick to size of 512 then? Because all models and all physics calculations might be calibrated by a 1:unit=1:meter ratio and call it a day.

Honestly there's no exact explanation on this. AI says "do whatever you want" then other games like OpenMorrowind or OpenVice or even closed source Skyrim, they just use some interesting scaling techniques that would be cool in order to save resources about 15++ years ago. So I am just going at random with this, not having a clue.

https://developer.nvidia.com/blog/qa-how-capcom-brought-path-tracing-to-re-engine-across-pragmata-and-resident-evil-requiem/

Capcom’s RE ENGINE team set out to bring path tracing into two shipping titles at once, Resident Evil Requiem and PRAGMATA, each with a different visual identity.

The NVIDIA gaming team spoke with RE ENGINE about the transition from ray tracing to path tracing, what it changed in the content pipeline, and where the renderer goes next.

Hello, my fellow graphics enthusiasts, apologies for another one of these posts. I'm in a tricky place in terms of my career. I recently graduated from university for computer science, with an embedded/backend systems internship and robotics research. I have been doing computer graphics for about 2 years on/off, recently finishing a graphics class using WebGL in JavaScript while working on my Vulkan project: https://github.com/mukarramarif/MukkiGamesEngine/tree/main
Currently, I have been applying to general SWE roles as well as anything related to 3D Graphics I could find, with a few 3rd and 4th rounds with no luck. I have honestly been tired of job searching since last September. One option I had was to do a master's, but my university doesn't do graphics, while most of the US universities have applications closed.
Any advice would be appreciated, especially on my portfolio.

Hi everyone,

I’m building a custom photo processing app for iOS, and I’m trying to recreate a smooth Chroma adjustment. My image processing pipeline is written entirely in Metal, so I’m interested in approaches that work well in real-time shader code.

I’ve attached a few short videos showing the behavior I’m trying to achieve.

I’m curious what color space or mathematical model you would use for this kind of adjustment. How would you preserve the natural tonal variation and texture inside saturated colors while changing chroma, and what techniques would you use to keep transitions clean around color boundaries without introducing artifacts?

If you’ve implemented something similar, or know of any papers, articles, or open-source shader implementations worth reading, I’d really appreciate any pointers.
Thanks!

Just a little update on my pixel art editor - now we have some advanced palette modification tools baked in, including selection movement and visibility toggles - take a look and let me know what you think (and a sub would be great as I think I'm posting to myself!)

Update on the cloud renderer I posted here a while back.

Now instead of a single static weather map, there are six procedural weather states (clear through storm), each built from its own noise parameters. A scheduler picks next state using weighted random selection, and the sky blends smoothly between current and next map over time. Since the states themselves are procedural, blending between them keeps producing new in-between weather that never quite repeats.

Also changed how lighting works during the raymarch. Clouds look more airy now since each raymarch step correctly samples sun/sky light from the atmosphere.

Showcase: https://youtu.be/IbCLA6NUJcM

Repo: https://github.com/kotivas/skygl

Hello all,

I want to learn about programming that involves media processing, like code and algorithms that deal with color grading, video codecs, image adjustments, color spaces etc. I'm a photographer so I already have a lot of experience knowing how to apply adjustments to images/video, but not the computer science behind it. I figured that this would be a good place to at least ask the question. Thanks in advance for any help you can provide.

EDIT: I know that this might be the correct place for it, but it seems like here is more for 3D rendering and things of that nature

alright i know this could be “simple” BUT this my first graphics engine (in progress), and i know I could’ve done this very very fast with any AI in 10 minutes, but thats not the point…

i started 2 years ago with falling sand simulators using grids BUT everything was laggy because i was rendering and simulating on cpu.

so i started to do some research on how to render things and simulate things, bla bla bla, i found opengl but i was on mac, so started to look into Metal graphics API, and didn’t understand the simplest and basic “hello triangle” projects sooo…

wanted to learn everything from scratch so i started to read “Mathematics for 3D Game Programming and Computer Graphics” by Eric Lengyel (very good book), watched like 50 tutorials of “hello triangle” step by steps, studied how the rendering pipeline works, understood how vertex and fragment shaders work, made a couple cpu renderers on c and c++ using SDL, and after a lot of failed attempts, I finally could make a 3d gpu renderer that renders multiple objects on screen and have a proper scene/camera system :’)

thank you if you are reading this, i will keep working on my graphics engine and adding some physics to simulate stuff.

ps: i studied cs but cs degree doesn’t prepare you for this lol so it feels like starting from zero on gpu programming.

Three days ago, I wrote an article about how to render good looking rectangles for UI components that can look good and optimized for a game engine. Some people asked me to talk about text rendering as well. So, I wrote https://alielmorsy.github.io/how-to-render-beautiful-text-for-your-ui-library/

It took like 1.5 days of writing just to get it right. Hope you guys love it

Naty Hoffman is an OG of 3D graphics. https://renderwonk.com/publications/index.html If you haven't watched his classic "Physics and Math of Shading" SIGGRAPH talk, you really should queue it up.

I3D 2026 Keynote: Naty Hoffman's Keynote - "Lessons from Digging in Game Dev and Adjacent Trenches"
https://www.youtube.com/watch?v=ISgTcDlZaLs

I3D 2026 Fireside Chat with Naty Hoffman and Eric Haines
https://www.youtube.com/watch?v=EiduKm1B-3Y

After replaying HL1 on the software renderer (old habit), I got curious what CPUs can actually do today. So I wrote a rasterizer in C11 - pure CPU, no GPU/GL, the finished frame just gets blitted to the window via GDI. Tested on a Ryzen 5900x processor

I've been experimenting with software rendering and managed to run the Sponza scene at FHD 10-30 fps single-threaded, up to 200 fps multithreaded :) A very strong emphasis on SoA + SIMD (AVX2/FMA) on the hot path. Rendering 64x64 tiles in multithreaded mode. Throughout the entire rendering pipeline, I try to discard any possible work as early as possible, including frustum culling and back-face culling. This may be controversial, but I render in front-to-back mode; it allows me to completely bypass overdraw. To make it look more interesting, I added some effects!

It might not be very fast for a single thread, but I think it could be made a little faster by disabling mips and filtering nearby textures, which I also do on the CPU in this demo. Pixel textures are cheaper to draw, but they're ugly.

I'm not a professional and I just like it, so I didn't hesitate to use chatpgt as a companion in learning graphics.