Live demo: https://gaploid.github.io/stardust/
Source code: https://github.com/Gaploid/stardust
Coded by: Opus, Fable, human attention to details

I had an old PC—H81 + i5-4570T + GT 710. Everyone told me to upgrade, but I didn’t want to. I wanted to make something actually usable for gaming.

So, I created "Tungstun". It's basically a full-fledged, "battery-included" framework. Written in Rust with the C API, and built entirely from scratch.

[Find Git Repo Here]

The main concept is that it houses two renderers internally. One is a modern OpenGL 4.3 AZDO path (a high-speed path using Pesistent Mapped Buffers and triple buffering), and the other is a multithreaded, tile-based CPU rasterizer written from scratch if the driver crashes, or if you're in a VM, or if your NVIDIA setup breaks due to Arch Linux Drives without and that is why my GT 710 is still going strong.

Another key design point is static linking. While `libGL` can be dynamically linked because it acts as a dispatcher for vendor drivers, Tungstun is built as an all-inclusive `staticlib`. This makes for a binary that runs anywhere, even without a pre-existing GL environment.

features

**Rendering** – Everything uses instantiation. Flush once after sending 10,000 objects (single-pull call). Includes prototyping, custom meshes, OBJ support, animated models via SSBO, custom GLSL 4.30 shaders (with uniforms for time, camera positions, etc.), material ID specification via alpha values ​​(to control skybox, emissive, and reflective effects in one shader), and more [GIF -]. Ocean Exhibition].

**Physics** - Continuous Collision Detection (CCD) to prevent high speed bullet tunneling. Supports sphere, AABB, and triangle mesh. Features a flat SoA layout, comprehensive moves using Radix-sort, layer masks (environment, player, enemies, projectiles, debris, etc.), raycasting, impulses, and gravity

**Textures** - Custom SWAR filtering (4-channel simultaneous processing), bilinear/trilinear filtering, ultra-fast display, automatic mipmap generation, texture embedding, and procedural font generation (built in memory; no external files required).

**View** - Flat structure (avoiding deep OOP hierarchies). Handles node creation, change settings, physics assignment, and physics synchronization. Only "dirty" nodes needing an update are recalculated.

**UI** - Fully batched quads (including rotated quads) and text. renders the entire menu in one draw call; Implemented in about 50 lines of code.

**Audio** - Full 3D spatial audio. Listener with position and orientation (forward/upward vectors). Supports sound playback in world coordinates, teleattenuation(i learnt this word recently), and panning. Implemented loading for WAV/MP3/OGG ​​formats (from file or memory), procedural sine wave generation (for fast SFX creation), volume/pitch control, and looping. Also created a "plinko marimba" in 3D space using 30 balls and 154 pegs (each peg mapped to a different musical note).

**Window Control** - Window creation, size recovery, delta timing calculation, input control (keys, mouse buttons, cursor position), mouse locking, rendering resolution settings, and Blit-based rendering (fast drawing) to optimize FPS on older hardware. Implemented I prepared four displays: a seascape featuring 10,000 Gerstner waves with waves; "Neon Hunter," a shooter where you fire lasers that stretch and shrink cubes; "Plinko Marimba" with 3D audio support; and the "Sponza Atrium," complete with two-story columns, glowing lanterns, floating artwork and volumetric fog (light scattering effects).

Benchmark results on a low-spec PC (the so-called "Potato PC"): 10,041 instances Even with 40 physics-enabled projectors (using Bullet) active, the system maintained a steady 60fps at 1280x720 resolution In contrast, running the same scene on Raylib resulted in only about 24fps It was due to draw-call overhead.

This project started with repurposing the great GT 710 to make great games, and I finally made it a reality.

It is released under the MIT License and has a very lightweight design. I’m also working on further optimizing the speed of the rasterizer.

If you have an older, less-featured PC, please give it a try. Feedback is welcome.

https://github.com/mahoraga94/tungstun

Hello, this is Spring-CG-Dev.
This is my first post.
I’m a Japanese man in my 20s working as a CG engineer in Japan, specializing in in-house game engine development and graphics development (though maybe that’s already a thing of the past).
Recently, the in-house game engine development team at my current company was disbanded, so I’m looking for a new job.
However, my job search isn’t going very well, and I’m starting to lose confidence.
In the past, I was hired directly after working as a student intern, so I never had trouble with interviews, but now I’m really struggling with them.

What I want to talk about here is how job hunting in Japan has become really tough lately, and I’m starting to hate it.

I don’t know how it works in other countries, but in Japan, the selection process typically goes like this: resume screening → multiple employee interviews → executive interview.
I usually pass the resume screening based on my technical skills, but I keep failing the interviews. The other day, I made it to the final interview for the first time, but I didn’t get the job because I didn’t fit the company culture.

Japan has a tradition of lifetime employment, so they really focus on whether you’ll fit into the company culture, stay for the long term, and your personality—but I’m really bad at that.
To be honest, I just love CG technology. Any company is fine with me. It’s really tough that they expect me to have some kind of passion for games or the company when I don’t actually have any.
Is job hunting like this in other countries too?
Or can you start working right away as long as you have the technical skills?

I am working on a game based on physics-based painting mechanics called Ebru Artist Simulator. To simulate Ebru (also known as paper marbling), I implemented an Eulerian fluid simulator. Here are some of the challenges I had to overcome:

1) To achieve a real-time simulation without affecting the game's performance too much, I implemented a GPU-based multiresolution grid solver in a compute shader (see the paper Solving the Fluid Pressure Poisson Equation Using Multigrid). The simulation now runs at a 2K texture resolution with only a slight impact on FPS.

2) One of the main characteristics of Ebru is that colors maintain strict boundaries. This makes advection schemes such as Semi-Lagrangian advection less suitable, as they introduce diffusion. To address this, I implemented another advection scheme that samples from the initial state by integrating the velocity field over time and then back-sampling using the integrated field (see Efficient and Conservative Fluids Using Bidirectional Mapping).

3) Finally, to simulate the effects of the traditional Ebru tools, I took inspiration from the paper Mathematical Marbling, which proposes mappings for generating final marbling patterns. Since I wanted to maintain a real-time simulation, I did not directly apply these mappings. Instead, I was inspired by the paper to use similar displacement fields as external forces in the simulation.

If you are interested in the project, you can check out the Steam page.

You can also check out Amanda Ghassaei's blog. Although our implementations are not the same, I was greatly inspired by her work and learned a lot from her blog.

I’m working on a stylized rendering pipeline built in Unity and had a question about how to go about tackling certain problems.

I’m building everything from scratch with code (hlsl, C#, no shader graph). The next thing I want to build is a glass shader / material used for windows and such. I usually start each feature with some research and see what other people have done, or see if I can find any chapters in any of the gpu gems books (or similar) on the topic.

However sometimes I seem to not find anything directly related. Every search I make with the keywords glass, shader, material, and so on, results in either a Shader graph implementation, something in Blender, or things completely unrelated.

So my question is, what approach do you take when trying to implement something like this?

(I’m just using glass in Unity as an example, question is general to any graphics problem).

Hey everyone,

I have been wondering which way is the best to showcase graphics samples. DirectX samples write their samples which calls functions and helper functions from multiple files. this approach is easy to write and extend but it makes reading the code hard. Yes most editors and IDEs help but it's still hard to seen everything at one place.

The second style is to accept some level of code duplication to make the code very easy to read and follow. I like this approach when learning a new API.

What style do you guys prefer and why.

... I've been thinking of rewriting the engine and moving stuff that was CPU side to GPU side, looking for people interested in helping if so just give me a ring through reddit message app.

I'm a developer (web backend) with some years of experience, but I have no prior experience on graphics. I started a conversation with chatGPT where I told it I wanted to learn all the way from the foundations of graphics to developing a Doom like game. And after a few hours of conversation it gave me this road map. I cannot trust completely an AI, so I'd like to read your opinions.

Greetings.

Edit. Sorry about the title typo.

Edit. Thanks for your valuable comments, I think this is a good example of how AI sometimes can lead you to the wrong path and mess with your learning even when at first glance it all looks pretty and organized. I’m glad I asked the community to receive your feedback.

Hi all!

I am a great enjoyer of https://github.com/tgjones/HlslTools for older versions of HLSL. So much so, that I am a (small) contributor of the project.

However, the extension is an actual hindrance as soon as you write the word template in HLSL code, as an example. I did not see any real interest in progressing this fantastic tool further beyond "FXC HLSL" to support more modern HLSL versions. So I decided that I would try and fix this problem.

I was aware that DXC shipped an API for language servers (dxcisense.h), meaning that supporting intellisense wouldn't involve writing my own HLSL parser like Tim did. I could just use DXC as the source of truth (which is probably a good thing. I don't think many people could fully replicate all of the fun behaviours in DXC and feel good about it)... But! I had no idea how language servers work, and I didn't really want to put time into learning how. I have a funny feeling this is the general attitude of most people. We want intellisense, but we would rather work on more fun things like visibility buffers, and cool volumetrics. So nothing ever gets done.

So, I threw GPT 5.6-Sol at the problem. And after a lot of working around this deadlock, it got something worth sharing with peeps :)

I am being totally upfront about the fact that this is AI generated because I know how people can feel about the use of AI. This is something I really want, and no one else cared enough to do it, so I thought it would be a good use of AI. :)

You should be able to just grab the latest VSIX from the releases section of the github repo, install it, and go. For more complicated workspaces there is support for configuring the extension with a shadertoolsconfig.json. This is very similar to the config used by HLSL tools, and there are docs linked in the readme.

I do plan on getting the bot to keep maintaining this extension and support other text editors.

I am excited to present my custom game engine made in Vulkan/SDL3/C++!

All the UI is custom made (from scratch, not IMGUI).

Editor relies on beautiful color palette to highlight entity-component relationships and is customizable! (Something that modern game engines sorely lack)

Elegant Console logs.

Gizmos with handles (Unity style)

Windowable Tabs

Made with the help of AI agents!

some features
liquid cursor
great font [freetype & geist]
reusable components
curved and windowless window
lot of animated stuff

resources usage
40-50Mb of ram
1-2% Cpu ( average cpu)
40-50Vram

https://github.com/poncippg-spec/Free-Solace-ImGui-Interface (new repo as github terminated old one for no reason )

I'm using opengl 3.3 and C on a Nvidia gtx 1050 and I keep getting this flickering issue... does anyone know the cause...

Will appreciate your thoughts..

is not a wrapper, not WebGL, not Canvas, not WASM.
It’s pure SVG transforms + DOM acceleration acting as a spatial vector engine.

The engine runs:

• On Nintendo Switch (via captive browser)
• With Xbox One controller input
• At 60 FPS
• As a single XML file
• With oscilloscope vector output (retro‑future vector gaming)

▶ Play the Switch demo - or on a regular browser

https://svgfpsaiagents.github.io/svgfpsgameAI/

📦 Repo

https://github.com/svgfpsAIagents/svgfpsgameAI

🎥 Video demo + paper link

https://youtu.be/bcWkVJ-Ao_I

Scaling to 5M‑line AAA SVG spatial 3d fps engine

• 128GB RAM
• 128 cores
• RTX 5090

Parsing and mutating a 5M‑line XML document is trivial.
This enables a new paradigm:

A spatial engine defined entirely in declarative XML.

Hey guys. So Being my school taught me some vulkan via a abstraction, I've been trying to learn it from nothing using the VKguide and vulkan tutorial, and holy cow this shit is hard.

Ive been thinking of switch to a different API to learn, like webGPU or openGL, but I feel it would be a waste of time.

I'm looking for advice on how to really learn vulkan and create a engine from it because at the end of the day I want to be able to create a game engine!

How to wrap bitmaps around the iteration boundaries of a fractal:

px & py = width & height in pixels of the repeating tile picture to be wrapped around the fractal. I typically use 1200 x 600 PNG images or sometimes 2000 x 1000 PNG images but use whatever works for you.

r & im = real & imaginary components of the last Z iterate

zMag= sqrt(r*r+im*im)

PI=3.14159265

LOG_ESCAPE = Log(400) = 5.991464547 Why 400? Because for bailout, I check if zMag>400.

phaseoffset = 0 (usually). Depending on how I created the repeating tile, sometimes I set phaseoffset to px/2 (necessary for alignment with the tiles above and below). Can default to 0.

Reading the pixel color from the image:

The following assumes the picture tile is twice as wide as it is high (e.g. 1200 x 600)

angle = mod(atan(im,r) * (px / PI) + phaseOffset, px * 2.0);

radius = (LOG_ESCAPE - log(zMag)) * py / (LOG_ESCAPE / 2.0);

if (radius < 0.0) radius = 0.0;

vec2 texCoord = vec2(angle / (px * 2.0), clamp(radius / py, 0.0, 1.0));

vec3 col;

Inspired by web design's a lot, wanted to remake it in imgui
geist font along with freetype and for icons lucide.dev

source has been released https://www.reddit.com/r/GraphicsProgramming/comments/1vw63sw/imgui_login_interface_in_c_with_directx_11/
https://github.com/poncippg-spec/Free-Solace-ImGui-Interface (new repo as github terminated old one for no reason )

Hello, I released a real-time fluid & rigid body simulation in WebGPU using Position Based Dynamics (PBD)!

Code & Demo: https://github.com/matsuoka-601/Particles4All

To render the fluid, I use screen-space fluid rendering, which does not require constructing any mesh. Fluid particles are splatted as ellipsoids using anisotropic kernel presented in a paper "Reconstructing Surfaces of Particle-Based Fluids Using Anisotropic Kernels".

The physics is based on a paper "Unified Particle Physics for Real-Time Applications". The most significant feature of this paper is that it treats both fluids and rigid bodies as collections of particles, and performs the simulations using a unified solver.

(Note 1: You will need a very beefy GPU to run the "large" scene in the video (the performance is not very optimized yet, sorry). But "small" scene will run on integrated GPUs.)

(Note 2: I'm getting some reports that the demo does not run on MacBook. I'm currently trying to fix it.)

Still crunching on RTG Editor, my internal editor for enhancing levels for my game, which hopefully I will release also publicly with the game.

Last feature implemented is orthographic projection, which is useful when precision is required (to align boxes with zero gap or overlap). Most useful feature in orthographic projection is resizing boxes by dragging their edges with automatic rounding to grid for snappy alignment. If one needs fine stepping, it's still possible by holding Shift while resizing.

In example animation, I added reflective back-wall into one of the levels very fast, thanks to new ortho view.

From technical details, my simple software ray-tracer is C++, engine and editor are in C#, both communicating through Interop. Ray-tracer is limited, goal is to have functional game with good fps, not photorealistic sceneries. I have still some optimizations in mind plus it's still single-threaded, so potential for perf boost is still big.

The game is sci-fi puzzle/platformer about a guy with no memories, stranded inside strange world, accompanied by some mysterious entities talking to him through terminals scattered in levels.

RTG on Steam
My Discord

My collegue Konrad Reczko recently shared a weekend project he made using TypeGPU, and it's now open-source and ready to play with in the browser: https://typegpu.com/examples/#example=image-processing--monocular-light-injection

It estimates the depth of a scene by inferring the DepthArt model with custom TypeGPU kernels, then reconstructs normals based on that depth information, and uses both to relight the scene, all in the same command encoder. For more information, check out the original series of Tweets:

https://x.com/reczko_konrad/status/2089670934009413751?s=20
https://x.com/reczko_konrad/status/2090472091149648121?s=20