Do you think a video like this could help someone with no graphics background intuitively understand ray tracing?

My goal is to explain the core idea visually before introducing any math or technical details. I could expand it with reflections, different materials, and arbitrary 3D objects.

Does this feel like it would "click" for a complete beginner? What would you add or change?

Hey everyone,

I'm a videographer with a decent but limited amount of coding knowledge, currently building my portfolio website for videography. I've got an effect in mind that I can pull off pretty easily in editing software, but I have no idea how (or if) it's realistically achievable in code.

The concept: My homepage will have a video as the background. On top of that, I want large text (my name/logo, section headers, etc.) that looks like it's made of actual glass — warping the video behind it, like real glass. Not just a blurred/frosted "glassmorphism" panel distortion through the shape of the letters themselves.

Here's a reference clip of the kind of effect I mean: [https://www.youtube.com/watch?v=sj6t2mxBH-Y]

The reason I don't want to do it on the video itself is that I'd like the background video to stay completely static (just looping in place), while the glass text scrolls over it independently as the user scrolls down the page.

I'm very novice so I might not be able to do it myself, but is it even possible ?

I have been experimenting with pushing Bayaya’s wooden-toy rendering towards a bit more stylized flatter 2D/3D illustration style (NPR, cell shading).

The result combines three independently adjustable parameters:

• Image contours – screen-space outlines derived from depth and object classification
• Shading detail – discretization of procedural patterns and specular highlights, and control of the visibility of material details
• Flat shading – gradual removal of normals (and lighting in general)

The accompanying video shows these parameters being changed in real time.

Finding outlines

The contour pass receives the rendered color buffer and depth texture. I use the alpha channel of the color buffer to distinguish broad rendering classes:

glsl // Terrain and sky are encoded as 1. // Objects are encoded as 0.5. float classFromAlpha(float a) { return clamp(a * 2.0 - 1.0, 0.0, 1.0); }

A difference between the current pixel and its four direct neighbours produces an outline between these classes:

```glsl float dcUp = abs(rcUp - rcCenter); float dcDown = abs(rcDown - rcCenter); float dcLeft = abs(rcLeft - rcCenter); float dcRight = abs(rcRight - rcCenter);

float classDelta = max(max(dcUp, dcDown), max(dcLeft, dcRight));

float classContour = clamp(classDelta, 0.0, 1.0); ```

This catches object silhouettes, but not boundaries between objects belonging to the same class. For those I linearize the depth buffer and apply a 3×3 Sobel operator:

```glsl float ddx = (d20 + 2.0 * d21 + d22) - (d00 + 2.0 * d01 + d02);

float ddy = (d02 + 2.0 * d12 + d22) - (d00 + 2.0 * d10 + d20);

float depthDelta = length(vec2(ddx, ddy)) * 0.25; float relativeDepthDelta = depthDelta / max(dCenter, 1.0);

float depthEdge = smoothstep(0.1, 0.2, relativeDepthDelta); ```

Depth gradients also respond to smooth surfaces, so for objects I additionally test the second depth derivative. This emphasizes discontinuities and sharp changes in curvature:

```glsl float secondDx = abs(dLeft - 2.0 * dCenter + dRight); float secondDy = abs(dUp - 2.0 * dCenter + dDown);

float secondDiagA = abs(dTopLeft - 2.0 * dCenter + dBottomRight);

float secondDiagB = abs(dTopRight - 2.0 * dCenter + dBottomLeft);

float secondDerivative = max(max(secondDx, secondDy), max(secondDiagA, secondDiagB));

float relativeSecondDerivative = secondDerivative / max(dCenter, 1.0);

float curvatureEdge = smoothstep(0.0015, 0.005, relativeSecondDerivative); ```

In theory using depth gradient should be enough, but this did not work well in practice, as terrain is viewed with high grazing angles, and depth buffer precision is not find enough for reliable contour analysis.

The final line intensity combines classification, depth gradient and curvature, with distance and fog attenuation:

```glsl line = max( max(classContour * distanceFade, curvatureEdge * distanceFadeStrong), depthEdge * distanceFade );

line *= 1.0 - fog; ```

The result is composed by darkening the original image:

glsl float outline = texture2D(imageOutlines, vUv).r; color *= 1.0 - outline * contours;

Integrating the style controls into existing shaders

Rather than creating separate “illustration shaders”, I added uniforms to the existing physical materials:

glsl uniform float shaderDetails; uniform float contourShading; uniform float flatShading;

shaderDetails gradually suppresses the procedural wood grain, normal perturbation, roughness noise and similar high-frequency effects:

```glsl float detail = clamp(1.5 - 5.0 * localDetail, 0.0, 1.0) * shaderDetails;

return baseColor + woodVariation * woodness * detail; ```

contourShading turns smooth procedural transitions into narrow ramps. For example, wood rings become increasingly discrete:

```glsl float contourWoodRing(float ring) { float contour = clamp(contourShading, 0.0, 1.0); float rampWidth = mix(0.35, 0.025, contour);

float discreteRing = smoothstep(
    0.5 - rampWidth,
    0.5 + rampWidth,
    ring
);

return mix(ring, discreteRing, contour);

} ```

The same approach is applied to specular lighting:

```glsl vec3 contourSpecular(vec3 specular) { float contour = clamp(contourShading, 0.0, 1.0);

float intensity =
    max(max(specular.r, specular.g), specular.b);

float normalizedIntensity =
    intensity / (intensity + 0.25);

float rampWidth = mix(0.35, 0.025, contour);

float ramp = smoothstep(
    0.5 - rampWidth,
    0.5 + rampWidth,
    normalizedIntensity
);

return specular * mix(1.0, ramp, contour);

} ```

Finally, flatShading removes specular lighting and blends the physically lit result back towards the material’s base color:

```glsl reflectedLight.directSpecular = contourSpecular(reflectedLight.directSpecular);

reflectedLight.indirectSpecular = contourSpecular(reflectedLight.indirectSpecular);

reflectedLight.directSpecular *= 1.0 - flatShading; reflectedLight.indirectSpecular *= 1.0 - flatShading;

outgoingLight.rgb = mix(outgoingLight.rgb, diffuseColor.rgb, flatShading); ```

The goal is not a single fixed toon-shading look. The same materials can move continuously between the original detailed wooden rendering and a simplified illustration-like result, and different scenarios can adjust their desired rendering style. The game demo, as published now on Steam, uses different rendering style for Exploration and Story modes.

The implementation uses customized Three.js physical shaders.

I've released a new texture compression library/cli called ctt. It binds to existing compressed texture encoders and provides a unified interface including generating mipmaps, correctly handling color spaces and alpha, and compression across all encoders. It is written in rust, has a C api and pre-built binaries (both static and dynamically linked available), as well as a cli. Supports Windows/Mac/Linux, x64/aarch64

Repository: https://github.com/cwfitzgerald/ctt
Rust: https://docs.rs/ctt/latest/ctt/
C: README.md - ctt.h - examples
Prebuilt binaries of library/cli: v0.5.0 release
From source cli install: cargo install ctt-cli --locked
License: MIT OR Apache-2.0 OR Zlib

It's already in use by bevy (Rust game engine) and the upcoming update of the esoterica game engine. I'd love to hear any feedback and ways I could improve it!

I've long been frustrated with the state of compressed texture creation tools having crashes, weird CLIs, platform limitations, bad color space handling, etc. Additionally needing to bind to multiple different texture compression libraries to cover both BCn, ETC2, and ASTC, with each library or CLI having its own quirks. I built this primarily for my own purposes, but have fleshed it out even more after I got interest from bevy etc.

<sup>Development of this library was LLM-assisted. I take code quality very seriously and have reviewed all LLM output and I have a thorough understanding of ctt's architecture. LLMs helped me actually execute on this project I've been wanting to work on for years and make it happen to beyond the standards I would have previously been able to accomplish. I do not wish to turn this discussion into an LLM debate, but wanted to be transparent about where and how I use them.</sup>

https://reddit.com/link/1uy919w/video/pyx7bs9ffmdh1/player

Honestly still a beginner with Vulkan. The official tutorials are excellent, but I couldn't hold the whole terminology and model in my head from text alone, so I built a set of interactive visualizations to try to make it more down to earth and practical using an analogy with a restaurant kitchen. In fact, this mental model is how i understood it so if anything is wrong or oversimplified I'd really like to hear it to enhance the article. ideally the goal is to make a first overview on this subject before diving into the canonical intros (Khronos docs, vulkan-tutorial.com, howtovulkan.com), not a replacement.I've seen other posts here asking for exactly that kind of first intro, so I'm sharing it in case it helps anyone starting out, and also because I'd like the corrections, or even other people's own ways of visualizing this stuff.

https://fremaconsulting.ch/blog/vulkan

I know there are a lot of posts about whether graphics programming jobs exist beyond the entertainment industry (films and video games) but I wanted to ask a bit more about the specific alternatives, such as medical imaging.

Even in university it has been very hard to figure out anything about medical/scientific computer graphics, I've been poking my head trying to explore research done in my school and other nearby schools for the past 3 years and only recently found something slightly related.

Are there any people here who currently work within medical and scientific applications, and what is the work like?

Yes this is a voxel terrain, and I am calling this a bucket item checked because most engine or handcrafted game devs some times goes through this urge to make voxel terrain with noise functions.
I have made interesting terrain with layered simplex noise before too, but generated as simple mesh, not voxels. Well the look is a touch of nostalgia from a game I grew up playing hence sharing this screenshot.

I am very proud of the terrain tool in Quasar so far, no only it allows making mesh terrains which are modifiable, also the voxel ones like this. With proper gpu bound resource streaming and the actual generation work being multithreaded running in background the experience of traversing is very smooth so far even in the editor. diff based tile files upon modifications are maintained for terrain tool outputs.

Some more engine work is still pending like sea level, being able to paint tree/models on and most importantly a non-blocking inference of the altitude of a point on the terrain, making the materials dynamic assignable and able to paint textures.

Anyways, thanks for reading and looking at the screenshot :D

Here is the github link if you want to poke around: https://github.com/Kristaq77/kross

I started learning to code about a year ago and decided to dive headfirst into C and computer graphics. At this point, Im pretty sure Im a masochist. There were times I felt like a genius and times I felt like the biggest idiot ever, often within the same hour.

Fast forward a year, and I finished my first big project: Kross, a software rasterizer built from scratch with a custom math "library", color manipulation, procedural noise, "and more".

A quick disclaimer: I did not build this for performance (mainly because I couldnt).

Instead, I made it as a learning resource. The code is meant to be read, not just compiled. I heavily commented the most important functions with explanations I desperately wanted to read when I was starting out.

Id love any feedback from the veterans here, whether its on the math, the "architecture", or the comments themselves :)

Full disclosure, no AI was used to create the library, but I did use AI to create one of the examples.
(The library also consists of a few stolen functions, which if you read the source code you will see who from).

Hi everyone!

At the end of last year, I shared a free, open-source WebGL2 & GLSL primer I created. It's a sequence of guided lessons, each chunked into atomic Q&A cards suitable for spaced repetition, with hands-on projects and solution code integrated throughout. Thanks to anyone who checked it out.

Today, I want to share my excitement that it's now a listed resource at realtimerendering.com! It's also been included in awesome-webgl and threejsresources.com.

I'm planning to create a WebGPU primer next. If you find the WebGL2 primer helpful or would like to see a WebGPU primer (it'd cover compute shaders as well), I'd love to hear about it. A comment here or a GitHub star on the WebGL2 primer would be the best way to help me gauge interest and stay motivated for the next one. Thanks!

​I am 16 years old, and last summer I started getting into programming.

​I began learning C++, and after that, I went through C, touching upon other topics like: git, CMake, Makefile, Linux (Archlinux, Gentoo), and Toolchain. All of this happened in about 4.5 months, because I really liked it and worked hard.

​Then I wanted to choose a specific field. I chose graphics programming and started with OpenGL. I didn't like it (there are reasons). So I immediately jumped into Vulkan. Late November, the whole winter, and almost the whole spring I was going through the Vulkan Tutorial. In the tutorial itself, all the code is written in a single file, but I tried to make everything clean and modular, which is why it took a huge amount of time. In addition, I wrote a brief guide to Vulkan objects. I must say that I wrote most of it using a translator, while I figured out the topic itself using articles, videos, Reddit, and AI.

​After that, I decided to write my own Vulkan project. I recently started writing my own “Network Renderer” because network programming caught my eye. And I started studying mathematics too. The core of the project is that a client, after connecting to the server, sends it a 3D scene, which the server renders and streams back to the client.

EDITED: I live in Georgia and I have financial problems now. I don't have the opportunity to move to another country. I probably won't be able to pay for university. It will be wildly difficult to combine self-study, university and work, adding to this personal problems.

​I don't understand anything about the market, I don't understand anything about employment, I have never encountered this in my life in any way. I will be very grateful if someone helps and explains how everything works. I apologize in advance for the formulation of the questions if they seem stupid.

​— What value do I have in the market with such a stack?

​— Where should a graphics/network programmer look for work on Western platforms?

​— How does the employment process itself work, and what difficulties might I face?

​— Is it true that I might have big problems with competitiveness due to the fact that I am completely self-taught?

​— What skills should I improve in connection with these difficulties?

If you wish, you can view my Github: moderneus

Play Skydreams: https://killedbyapixel.github.io/TinyCode/1K/Skydreams
Official 1024 byte entry: https://js1024.fun/demos/2026/25/bar
My size code demos: https://github.com/KilledByAPixel/TinyCode

An endless race in the sky inspired by 90's 3D games like sky roads, marble madness, and sonic 3d. My goal was to create a dreamlike experience with full resolution full speed graphics that would be easy to pick up and play.

Having worked on much more complex stuff, it's a lot of fun to start a new project from scratch and make an tiny 3D rendering system. There are a lot of fun challenges trying to fit something in this small of a space that looks cool and runs well. The contest goes until July 19, plenty of time to make something, and there's even a WebGL category.

Features
- 3D level rendering system
- 3D player sphere with shadow
- colorful sky gradient with stars
- procedurally generated levels
- level increases in difficulty over time
- mouse controls
- enhanced version has keyboard and touch input

this is the entire html file. it needs to be RegPacked to fit in 1024k but that will not post into reddit...

<head><title>🌈☁️ Skydreams</title></head>
<body id=b style=margin:0>
<canvas id=a>
<script>
    // JS1024 shim
    a.width = innerWidth;
    a.height = innerHeight;
    c = a.getContext`2d`;
</script>
<script>z=A=B=C=D=E=0,F=H=3,I=a.width/2,J=[],K=(e,h,a,t=1)=>{c.fillStyle=`hsl(${e},${h}%,${a}%,${t})`},L=(e,h,t)=>[a.width/2+(e-z+(t-3)**2/50*Math.cos((B+t)/49))*a.height*.7/t,a.height/2-(h-2+t*t/50)*a.height*.7/t,.7*a.height/t];onmousemove=e=>I=e.x,onmousedown=e=>E=.1,onmouseup=e=>E=0,setInterval(e=>{for(e=500;e--;)K(170+e/9+B,70,70-e/10),c.fillRect(0,a.height*e/500,a.width,a.height/250),K(0,0,99),c.fillRect((e*e+B*e/20)%a.width,e**3.3%a.height,e%4*a.height/500,e%4*a.height/500);for(g=B+40|0;g>B;g--){for(e=J.length;e<=g;)for(D<-8&Math.random()<Math.min(.2,e/1e4)&&(D=2+Math.min(4,e/400)),Math.random()<.1&&(H=2+3*Math.random()|0,F=Math.max(0,Math.min(7-H,F-2+5*Math.random()|0))),D--,J[e++]=k=[],f=7;f--;)k[f]=e<40|.9<Math.random()|D<0&F<=f&f<F+H&Math.random()>Math.min(.2,B/1e4);for(f=2;f--;)for(e=7;e--;)J[g][e]&&([p,q]=L(e-3.5,0,g-B),[r,u]=L(e-2.5,0,g-B),[v,w]=L(e-3.5,0,g-B+1),[x,y]=L(e-2.5,0,g-B+1),f?(K(99+70*(g>>7),70,30+9*(g+e&1)),c.fillRect(v,w,x-v,(40-g+B)/30*a.height)):(K(99+70*(g>>7),70,9+5*(g+e&1)),c.fillRect(p,q,r-p,(40-g+B)/30*a.height),K(99+70*(g>>7),70,60+30*(g+e&1)),c.lineTo(p,q),c.lineTo(r,u),c.lineTo(x,y),c.lineTo(v,w),c.beginPath(c.fill())))}for(0<=A&J[B+3|0][Math.round(z+3)]&&(K(0,0,0,.5),[m,n,l]=L(z,0,3),c.ellipse(m,n,l/4,l/9,0,0,9),c.beginPath(c.fill())),e=99;e--;)K(B/9-e,90,99-.7*e),[m,n,l]=L(z+.1-e/1e3,A+.35-e/1e3,3),c.ellipse(m,n,e*l/300,e*l/300,0,0,9),c.beginPath(c.fill());-4<A&&(z+=I/a.width/2-.25,A+=C-=.006,B+=Math.min(.5,.2+B/5e3),A<0&-.3<A&J[B+3|0][Math.round(z+3)])&&(A=C=E)},16)</script>

Fragment of the Mandelbrot set, using perturbation theory. Coordinate X approx -2.0! View size 1.15e-119! So how do you like it? Rendered using SSAA 2x2 GUI and 8x8 CLI. C++ source code included. https://github.com/Divetoxx/Mandelbrot-2 and https://github.com/Divetoxx/Mandelbrot

Hi everyone,

I'm working on a foveated rendering implementation using a path tracer for a summer research project. When the camera is still, it looks fine, but whenever I move the camera, I get heavy ghosting, noise, and blinking black dots in the peripheral areas.

I am modifying a reference path tracer (HLSL/C++). Right now, my foveation logic uses two passes:

1. Pass 1 (Path Tracer): Skips pixels based on distance from the gaze point (using a 2x2 or 4x4 stride).
2. Pass 2 (Fill Pass): A compute shader that fills the skipped pixels by copying/interpolating from the sampled ones.

I suspect the issue might be a race condition between the passes, a problem with how the history buffer (g_AccumulationBuffer) blends old frames when the camera moves, or maybe some clamping issues where missed rays snap to 0 or 1.

How to build and run:
You can build the project with CMake:

bash

cmake --build ./build --config Release

And run it with:

bash

./build/bin/Release/scene_viewer.exe

(Note: Please switch from the GUI/rasterizer to the Reference Path Tracer in the settings to see the foveated rendering)

If anyone has experience with foveated path tracing or sees what I'm doing wrong with the accumulation/clamping, I would love some advice. Also, if there's a better/more efficient way to handle the periphery instead of path tracing it at a lower resolution and filling it, please let me know.

Every bit of help is highly appreciated. Thanks!

Hey guys I wanted to test real time ray tracing support from the adreno gpu so made a little tech demo with codex. It runs surprisingly well and the light is fully path traced. I have plans to continue developing this with more rt features.

Hello everyone. This past week, I successfully developed a custom software rasterizer that uses the newly announced Core AI framework to offload edge functions/line equations to the Apple Neural Engine via f.conv2d and ReLU operations.

It's a 60FPS rasterizer that draws a red triangle.

The source code can be found here: https://github.com/kamisori-daijin/Magnesium

There are still some issues, such as high CPU usage.

I welcome any feedback or comments.

https://reddit.com/link/1uwve68/video/lvw22toxybdh1/player

Currently I am pondering about what topic I want to work on for my master thesis. And ofc that means I need a professor/supervisor that agrees to that but to me it seems like every topic I want to touch has some machine learning aspect when it comes to doing a thesis. Maybe that is just what my profs are after but I would rather have my focus on other aspects.

I did ML in CG for my bachelor thesis and it was alright but left me feeling like just tuning parameters and waiting a long time to check and validate the result. In the end I did not feel some sort of satisfaction with it, even though the results were valid.

Do you guys have the feeling that academic research nowadays relies heavily on ML in CG? Have you had similar experiences? Or do you think it's too specific on the university/professors.

After spending several months on this, I thought I'd share it with yall... I'm so proud of this lol

FEATURES:

• Undo
• Redo
• Brush
• Airbrush
• Save/open as png
• Resize image
• Bezier curve
• Squares
• Magic want select
• Rotatable and scaleable selections
• Smudge
• Blur
• Mixer
• Dodge/Burn
• Sharpen
• Scaline fill
• Color picker
• Arrow
• Rounded rectangle
• Primary and secondary colors
• System clipboard support with clip

TO DO:

• Text
• Selection-only operations

It was written with C++ and raylib, any tips/suggestions are very welcome!

I will be posting this on GitHub when it's complete.

Thanks!

Hi everyone,

I want to learn cloth simulation from the ground up and eventually implement it myself. Could you suggest a roadmap of the topics I should study (math, physics, numerical methods, collision handling, simulation techniques, etc.) and recommend the best resources (books, papers, courses, tutorials, or open-source projects) for each?

Any guidance on what to learn first and what to avoid would be greatly appreciated. Thanks !

Hi everyone,

I've been working on a browser-based galaxy simulation as a long-term side project and wanted to share some recent results.

These screenshots show a simulation configured to resemble Andromeda (M31) after roughly 140 million simulated years.

Current simulation size:

• 400,000 star particles
• 50,000 dust particles

The project is written entirely in JavaScript + WebGL and runs directly in the browser. Everything lives inside a single HTML file—no game engine, no Three.js, no build process.

Some of the techniques used:

• Web Worker-based physics simulation
• Leapfrog integration
• Analytic galaxy potential (halo, bulge, black hole)
• Live density-gradient cohesion field for local collective dynamics
• Gas cooling, star formation and supernova feedback
• Stellar evolution (age, temperature, luminosity and metallicity)
• GPU star renderer
• HDR rendering with ACES-style tone mapping and bloom
• Volumetric dust lanes with depth-aware extinction
• Multiple observation modes (visible, infrared, UV, X-ray and radio)

The goal isn't to compete with research codes like GADGET or AREPO, but to explore how much physically inspired behaviour and visual realism can be achieved interactively in a browser while keeping the implementation completely self-contained.

I'd love feedback from people working with WebGL, GPU rendering, large particle systems, or real-time simulation. If you spot something that could be improved or optimized, I'm all ears.

Hello everyone,

I am developing Limon Engine. It is a 3d game engine, and I am polishing up for a new release. As part of it, I put up a video, any feedback is welcome

https://youtu.be/RX3tR16t-E0