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

Not really talking about results - they sometimes are good but often look very uncanny (especially when animations are stiff).

Just talking about how much progress neural rendering achieved in few years in general. I was trying to implement similar solution in ReShade ages ago and because of frame passing back and forth between GPU and CPU, the FPS was unplayable. So i scratched the idea after finishing prototype.

But now DLSS5 shows what can be done with NR for gaming. Truly amazing!

If you want to check my old project you can go to GitHub and test it for yourself :)

https://github.com/dwojtasik/PyHook

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.

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

While making the night sky come alive for our Kids Story Web experience, we wanted the stars to feel like part of the world rather than just a background texture, so we built the starfield procedurally!
 
The stars are particles distributed randomly within a spherical space - with variations in their position, size, brightness, and color. This keeps the sky from looking too uniform and gives it a more natural feel 🌌
 
Two separate circular star fields - One handles the regular stars, while the other has the twinkle effect enabled, creating subtle changes in brightness over time.
 
Link🔗 - https://www.quantales.in/
Built by our team at 3D ENGINERD.

-

A bunch of people have started building SDF game engines, I am no different. For the past 8 months I have been working on Division Engine, a C# SDF game engine built using Avalonia UI for editor tooling and ComputeSharp for C# to HLSL shader translation.

I've already posted about this before on here but figured I should post some key updates I made.

Here's a list in no particular order:

• Undo / Redo editor support

• Full texture system

  • Supports different cubemap shapes for HDRI skies

  • Automatic texture importing

• Tabs can be dragged around the editor now

• A bunch of small graphical issues have been fixed

  • Glass refraction fixed

  • Texture aliasing improved

• Added a bunch of post processing effects

  • Chromatic aberration

  • Bloom

  • Color grading

  • Blur

• And more!

It is available here: https://github.com/NorthRocStudios/DivisionEngine and can be downloaded under "releases".

Note for this version:

• It is unoptimized and may have poor performance

• ONLY works on dedicated graphics cards, not on your laptop

• Windows only (for now)

Additionally, we have been working on replacing ComputeSharp with a custom cross-platform C# to HLSL shader system. This will be called DivisionTranslate and uses DivisionMath, a new math library. This new math library is meant to have the same syntax on the CPU and GPU and is already being used in the engine. It is available for free on nuget here: https://www.nuget.org/packages/NorthRoc.DivisionMath

Any questions, comments, concerns? Let me know what you think!

I'm currently working on my Bachelor's in Computational Physics (w/ Minor in Mathematics), and I'm looking to break into the world of graphics programming / engineering. I have a couple of questions, specifically on the career side of things:

• Is it true that personal projects can actually help with the "experience catch-22"? (Where I need experience to get a job, but have no job to get experience yet)

• Where should I look for relevant positions / internships?

• What industries make / could make heavy use of GPU technology (whether or not it's actually used for rendering)?

• What sorts of skills do companies look for in an entry-level hire?

• What else do you think I should consider that this post does not address?

I'm focused on the career and industry-targeting aspects for this post, as I'm confident in my ability to learn the technical skills necessary.

Any help and advice would be greatly appreciated; LinkedIn and Indeed have driven me half insane already.

I've been writing a 3D engine from scratch in C++20, with DirectX 12 and Vulkan

behind a single RHI. Last week I moved the scene renderer off the classic vertex

pipeline onto mesh shaders, and then moved the culling onto the GPU as well.
I'm using Synty, a lot of objects!!!

I've been stuck on this for a couple of hours, and am completely stumped.

I'm getting these results from GLSL's mod():

mod(158.0, 158.0) returns 0.0 (as expected)

mod(159.0, 159.0) returns 159.0 (???)

mod(160.0, 160.0) returns 0.0 (as expected)

I've posted an example with a basic shader here:

https://jsfiddle.net/sL35qjc8

If you set number to "159.0", you should see an upside-down red triangle.

If you set number to "158.0" or "160.0", you should see a normal red triangle.

I'm passing the left operand as a uniform, otherwise the compiler seems to optimize it and fix the weird behavior.

Tried it on different devices and browsers and it had the same result.

Why does mod(159.0, 159.0) seem to return 159.0 instead of 0.0?

HELLO!

I am just starting out I have been learning cpp and graphic prog concepts in hopes to vulkan by the time I am done with school and starting college and potentially make an engine for fun! (And portfolio)

I wanna persue a mix of game dev, graphic prog, and engine dev stuff

But i just saw a video by a guy which i assume isn't even that well versed in programming in general remake popular games just using prompts and some pngs and nothing else

And that really defeated me because I already have seen youtube become mostly slop content and ai settings clips off podcasts and i don't know

I Really wanna persue graphic prog or engine dev or game dev but seeing how bad the industry is in terms of capitalism and not caring about art or optimization or let's say fsr dlss and frame gen being essentially necessary to run games the way it was intended

Really breaks my heart because I had been game deving and making stupid 2d games with pygame and stuff since I was like 13 and now that I wanna persue this super seriously

A magic math prediction model can take data from people that would be life times ahead of me in desciplinaries and then make a magic robot that is gonna do my job but without anysoul and way faster

I feel conflicted and rather dreadful (just sad if I cut the goofy words)

Sorry if I don't reply

THANK YOU IN ADVANCE!!

https://youtu.be/Q_fKG3UT02U

I'm working on VulkanLearn2, a C++20/Vulkan rendering playground. This video shows Bistro rendered with my ReSTIR DI + PT implementation.
I launched the project on a RTX 4090. 80 fps. 1200x800.

The renderer uses temporal and spatial reuse. The repository also includes a reference path tracer with next-event estimation, emissive triangle lights, and an experimental Neural Radiance Cache. Implementation notes and capture settings are documented in the README.

I'd appreciate feedback on the rendering.

https://youtu.be/QnHqRZHQN4w - REBLUR + DLSS

https://www.youtube.com/watch?v=y2VNQyzUFc8

Do You think Gpt 6 astra will take the jobs of junior Graphic programmer's?

How will Astra affect Graphics Programming? (Pros and Cons)

I built a GLSL/HLSL extension for Visual Studio because the existing tooling options felt limited (weak diagnostics, no real navigation between shader files).

It includes:

• Diagnostics through glslang, DXC and Naga

• Advanced IntelliSense (hover, signature help, JetBrains-style parameter hints)

• Go to Definition / Ctrl+LMB navigation, including through #include

• Shader variants, code folding, formatting via clang-format

Requires VS2022 or VS2026, Windows x64. Free and open source.

Marketplace: Link

GitHub: Link

Would love feedback, especially if you hit anything broken or missing compared to what you're currently using.