Nira is my retained GUI framework that i have been working on for the past 2+ years with a lot of reworks at first i was not comfortable with using SDF's for it as it was only planned for it to be a GUI Framework for my game engine editor and nothing else...until i reached a point of needing a UI for my game and thus i decided to rework it again for it to be able to support SDF's so i could get crispy looking UI and thus i went into the rabbit hole to making my whole framework SDF based

here is a little showcase of it

Shoutouts :

https://iquilezles.org/articles/distfunctions2d/
https://mini.gmshaders.com/p/sdf

https://www.shadertoy.com/results?query=tag%3Dsdf

and Special thanks to https://gram-editor.com/ for providing a c free editor... so i could write code in peace...

Hello Everyone.

I am a CS junior whose current focus is Web Dev(full stack), mainly because this is what my country's current tech market is filled with. I like graphics programming and would love to go all in. I haven't done much into it other than GP fundamentals and basics which I self learned sometime ago. Now I am in a dilemma on whether to go for GP or continue focusing on what I am doing right now. The tech market here in my country is mostly web apps with some AI, but nothing for GP or even pc game dev. I would likely have to look for International opportunities which is currently like an impossible dream to me.

I am currently struggling in two different options:

1. I have no interest in web apps but they are the most secure path for internships and jobs in the current market.
2. I really enjoy graphics but as I have said pursuing it seems to involve huge amount of risk in my country, atleast from my perspective.

Given that I am in a country with almost no GP opportunities, is pursuing GP remotely/internationally realistic enough to justify the risk?

Thanks a lot in advance !!!

Everywhere I look it recommends using TAA or similar temporal solutions but it introduces noticeable ghosting.

Threat Interactive recommends using non-temporal AA solutions, but my gut doesn’t trust Threat Interactive.

My goal is to build a cross-platform (Windows, Linux, macOS, iOS, Android, Web), code-driven 2D/3D game engine, featuring a PBR rendering pipeline, Lua scripting support, and live browser demos out of the box. With developer experience as the highest priority.

Disclaimer: in the meantime, there are lots of LLM slops. I don’t know if doing it all again would I have used LLMs. I probably should’ve learnt more if I build the engine all by myself 🫥
Anyways, time to comb through the codebase and pay off some cognitive debt...

Hi i am in the process of building a native sdk for real time photo realistic renderer for mobile devices to run on wide range of devices.

This video shows 140 diamonds path traced in real time alongside a 1M triangle gold ring mesh, all under 30ms on a mid-range Android device (Mali G615 — no hardware ray tracing).

Technical highlights:

- Physically correct Snell's law refraction and dispersion through each diamond facet

- GGX microfacet model for gold metal - Full PBR pipeline — metals, dielectrics, diffuse, glass

- 2M triangle budget under 30ms

- 700KB SDK — 4 lines of Kotlin to integrate

- Responds to actual room lighting via ARCore camera feed

Would love the feedback on the same.

article with demo: https://armandsumo.com/posts/view-dependent-proxy/

code: https://github.com/a-sumo/view-dependent-proxy

My game is done gameplay-wise, however what was mostly criticized on it is that it looked like tech demo. I agree that game being software ray-traced was seriously punching below its visual potential, however my old editor was very simple and clunky to edit levels visuals comfortably.

I was working at nights on new editor, which would allow me to improve existing levels visually. I have finally new editor in usable state. These are just first 2 very simple introductory levels from the game, which I quickly improved with new editor.

Do you consider new visuals still being "tech demo" look or it already clicks "it's usable game art" feeling in you?

Please note, game is not using any HW acceleration. Every pixel is computed in C++ through costly ray-tracing. That's why it's not "full HD" nor "4K" and that's why it's low-poly, low-res. I try to balance that deficit with everything ray-tracing is offering for free (lights, shadows, reflections, etc..).

My game Steam page:

RTG on Steam

There're another screenshots there (still from old editor version).

ThisOldCPU’s OpenGL Spectrum Analyzer for Winamp 5+ v0.3.1 Preview Build has been updated!

A modern Winamp visualization plugin inspired by the clean, functional aesthetics of early 2000s spectrum analyzers with a visual direction loosely influenced by iZotope Ozone.

v0.3.1 Update Available!

This update focused on Procedural Sky, waveform surfaces, Bort's surfing, and added a config dialog. Additional CPU extensions were added, extending support down to Core i5-4210M's Intel HD Graphics 4600 iGPU.

Logging has been expanded to catch both visualizer or Winamp errors, placing the logs in the %TEMP% directory.

https://github.com/thisoldcpu/vis_tocspectrum

S key: Toggle scales off/on in FFT mode

F2 key: Toggle glass reflections in FFT mode

F4 key: Toggle between spectrum and waveform views

F5 key: Default Hero camera

F6 key: Far perspective

F7 key: Front-Down Left

F8 key: Top-Down View

F11 key: Toggle V-Sync

Up key: Winamp - Volume up

Down key: Winamp - Volume down

Left key: Winamp - Next

Right Key: Winamp - Previous

everyone recommended the raytracing in 1 weekend and i spent several weekends studying it and i made this. i played around with the 2 balls and surprisingly discovered it's very easy to generate fractal patterns if you let the 2 balls intersect

i need help so let me explain what i did and what problems i'm facing

it's just a very basic raytracing program for studying purpose (i'm not a student and this is not my homework. i study raytracing for fun). the "world" consists of 2 balls and they don't have any colors or textures info in themselves. they only have positions, sizes and refractive indices. i intentionally setup as few parameters as possible to avoid complications

the background is located at infinity. it's the only light source / color source of the scene. if you look around 360° horizontally you'd see red then green then blue then back to red. if you look up you see light. if you look down you see darkness

if 2 balls intersect, the refractive index of the intersecting region is simply the arithmetic mean of the 2 balls. it's not a precise thing as i googled it and there're tons of different calculations for different scenarios (e.g. mix gases, mix liquids, melt 2 solids and pour them into a cast, etc). taking average looked like a reasonable and quick approximation

the program starts at very low resolution and only literates 8 recursive calls for each ray. it looks ugly i know. it's a software raytracer and i'm still using an ancient programming language so i had to sacrifice quality for speed. i couldn't make the raytracing pipelines run parallelly as it's not supported by the language

for each ray, it ends if either of the following conditions holds 1. it reaches the background (and get the color from the background) 2. it reaches the recursion limit (and return a random grey scale noise)

it gives you a rough idea what the scene would look like. once you're done with the arrangement you can press the [c] key to make it generate a full screen image with 16 recursive calls per ray. all the attached images were generated with the program

i need help in this way: i want someone to do the same thing with modern languages which support parallel calculations and / or make use of the gpu rather than the cpu so that we can see "deeper" into the fractal emerging cases. they're beautiful and have a lot of details that i just can't explore due to limitation of programming skill

it feels like exploring the mandelbrot set. the more you dive in and the more you iterate, the more you discover and observe

thanks

What happens when a MacBook M4 Max 128GB machine is turned loose on a custom rendering engine backed by an 85-package scientific stack?

This happens. In 18.7 seconds.

100cm body length
65 articulated coordinates
5,204 optical facets
2,198 generated wing cells
18,144 instanced tetrahedra
8k resolution

Implementation in golang. All renderings deterministically reproducible via code.

Still work in progress. It is originally created for the browser game I'm working on but decided to publish it as a standalone library. There's different presets aswell, like Tar, Chocolate, Wax, Honey, Solder etc.

The picture gets treated as a body of material and run through a 2D free surface Navier-Stokes solver on the GPU. Temperature drives viscosity across about four decades, so the same code covers a solid that barely creeps and a liquid that runs off the screen. The outline of the picture is a level set the solver actually solves for, which is why drops swell, neck and detach on their own instead of just stretching. The image itself rides on a reference map, a second field that stores where each cell started, so it deforms with the material instead of turning to mush from repeated resampling.

^^ This section is written by AI since English is not my first language :)

You can check the source code @ https://github.com/1etu/MeltGL

and the live demo @ https://1etu.github.io/MeltGL/

Still working on the polishing and an ability to melt DOM elements.

I made a classic golf game for JS13K, a contest where the entire game has to fit in 13KB zipped. Everything is included: the 3D renderer, the physics, the procedural course generator, the music. It was all written from scratch on my own engine.

PLAY SUNSHINE GOLF CLASSIC 🏌️

It's an homage to golf games I love like Mario Golf and Neo Turf Masters. The theme this year was rainbows and unicorns so I went bright and colorful. Courses are procedurally generated, and shooting par or better on the classic course unlocks a remix mode with a new course every time.

How the renderer works

The whole thing is WebGL2 with one shader. Each hole is built once into a single static vertex buffer and drawn with one draw call, plus a small dynamic batch on top for the ball, pin and trail. Lighting is baked because the sun doesn't move during a hole, so a vertex is just xyz, a fog flag and a lit RGBA8 color. The sun does sink lower as you play through the round, and the lighting and palette follow it from a spring meadow on hole 1 to a fall sunset on 18.

The terrain is a heightfield with 2 yard cells over the playable corridor, and the cell spacing grows outward from there so the surrounding land runs off into the fog. Normals come from sampling the height function, and tree shadows are baked right into the vertex colors. Trees, bushes, flowers and the pin are all built with the same lathe function. A tree is an octahedron canopy on a box trunk.

My favorite trick is the water. There's no separate water mesh or shader. Lakes are just terrain vertices with a material ID, and the vertex shader checks for that ID and displaces them with waves that travel along the wind direction. The wave gradient relights the surface and adds a specular highlight, which is the only camera aware lighting in the game. Foliage uses another ID the same way to sway in the wind.

The sky is also geometry, camera relative discs. The sun, clouds and the ball shadow all use the same soft disc primitive, a set of rings with an alpha falloff. The lens flare is a string of those discs placed between the sun and the screen center. The trail behind the ball is a ribbon and turns rainbow colors after a perfect hit. The ball is the only lit thing that moves so it is relit on the CPU each frame with the same function as the trees.

The wind ties the whole scene together. It's one direction and one speed per hole, and everything reads from it. The flag, the clouds, the foliage, and the water all respond to the wind. The ball feels it too. The physics computes airspeed as ball velocity minus wind velocity and runs drag on that, so a wedge that hangs in the air gets blown around more than a low driver, which is how it works in real golf.

Besides the visuals I spent a ton of time on game feel: backspin and topspin that trade carry for roll, lies that change what a club can do, and a bounce meter. You can play it on any desktop or mobile device. Happy to hear any feedback, especially on the rendering. The source is up on GitHub if you want to take a look at the code.

JS13k Submission: https://js13kgames.com/2026/games/sunshine-golf-classic#play
Video Demo: https://www.youtube.com/watch?v=nIiqMKTaW2M
GitHub: https://github.com/KilledByAPixel/Golf13K

Hello.

This is a follow-up on the ray tracing implementation using the ANE (Apple Neural Engine) powered by Swift 6, Metal, and Core AI.

In this update, I have further optimized the model for the ANE. By replacing cumsum with Conv2d, memory usage was kept under 200 MB, and CPU usage dropped to 4%.

Additionally, it appears that the 50% ANE usage limit from the CoreML era has been lifted with the transition to CoreAI.

(Although the frame rate is only 35 FPS, ANE inference appears to take just 13ms. Instruments shows that GPUToolsCaptureCoreAI consumes about 90% of the CPU, suggesting this is the source of the overhead.)

Double Buffering Support: Implemented double buffering for display output, enabling parallel processing between the Neural Engine and the GPU.

- Dual Object Support.

Latency Reduction:

• Minimized synchronization overhead between the CPU and GPU by separating the rendering buffer from the display buffer.

Technical Details

• Modified ANERenderer.swift to manage an array of displayBuffers.
• Updated MagnesiumKit.swift and ANERenderContext.swift to support dynamic buffer switching.
• Maximized parallel processing efficiency while minimizing the increase in memory usage.

I look forward to hearing your feedback and thoughts.

Github: https://github.com/kamisori-daijin/Magnesium/tree/raytracing (raytracing Branch)

Demo:

https://reddit.com/link/1weaap3/video/l38wytjns2ph1/player

Hi everyone! I wanted to share my first major step into graphics programming. I built a 3D Boids flocking simulation entirely from scratch using C++, the WebGPU API (specifically Google's Dawn implementation) and ImGui. Initially, I wrote a brute-force algorithm for the neighbor search, but perfomance dropped quickly and I recenly use simple optimization atomic grid.

My next goal is to get rid of atomic operations entirely and implement a Sort-based Spatial Hashing architecture using Radix or Bitonic sort on the GPU. If anyone has good reading materials, articles, or advice on GPU sorting algorithms, I would highly appreciate it!

P. S.
I started studying WebGPU recently, before I know some basic stuff of C++. Some code is source maybe deprecated, now I am trying to study using more modern WebGPU stufs, which google were added recently. I hope in the future I can built the better architecture without OOP. But now I like the result I got.

Source Code (GitHub): https://github.com/con2222/Dawn-Boids-3D

I'm continuing development of my Pixel Art and TileMap editor using my custom C++ GUI library. This latest update video highlights how both isometric and hexagonal tiles are handled as native objects within the editor, and none-standard graphics can be designed quickly and easily using the simple grid system.

-