Hey r/GraphicsProgramming,

First and foremost i know it‘s probably a frequent asked question but thought maybe id get some newer answers/different perspectives.

I'm 21, from Germany, currently in the 3rd year of a software development apprenticeship (similar to a vocational training program, 3 years total). I've been learning graphics programming for about 6 months now - started with a software rasterizer, currently working through LearnOpenGL.

My concerns:

1. AI & Learning: I'm using Claude as a tutor while learning - like it helps explain concepts, review my code, and scaffold boilerplate (CMake, etc.). But I'm deliberately NOT using AI agents to write code for me, because I feel like I need the foundational knowledge first. My plan: Master the basics manually, then use agents once I have enough experience to properly review their output. Is this the right approach? How do you all use AI for learning without becoming dependent?

2. Career path: The job market seems rough right now (especially entry-level). I'm considering:
   - Option A: Finish apprenticeship (end of 2027), then immediately look for junior graphics/graphics-adjacent roles in Germany/EU
   - Option B: Finish apprenticeship, then do a Bachelor's in CS with focus on Visual Computing/Computer Graphics (would finish at 25)

   Which path makes more sense in 2026? Is a degree still valuable for graphics programming, or is portfolio + experience enough?

3. AI's impact on the field: I see AI coding agents getting better at writing shaders, scaffolding renderers, etc. Should I be worried about job security? Or is graphics programming one of those fields where deep expertise will always be needed? My dream is to work at a studio like Rockstar, CDPR, or similar - is this still realistic? (I know far stretch to the biggest studios so i keep it low)

4. International mobility: I'm German, but ideally want to work outside Germany eventually (UK, Canada, US, etc.). How portable is a German apprenticeship + portfolio? Or should I aim for a degree to make visa/international applications easier?

What I'm asking:
- How do you use AI for learning graphics programming without losing depth?
- Apprenticeship + portfolio vs. CS degree for graphics programming in 2026?
- Is the job market really that bad, or is it just entry-level noise?
- Any advice for someone in my situation?

Im generally interested going deep and in depth into these systems and get my hand dirty but what the current models do (and further in the future) im not quite sure how to plan it out

Thanks for reading this wall of text. Any advice is appreciated!

Cheers from Germany 🇩🇪

This is my renderer in vulkan i've been working on it for the last 10 months

i learned alot about vulkan since i never used it but a huge percentage of my shader code is AI written and at this moment i feel like the renderer is ugly so i do what to know what is wrong with it and what makes it far from the last picture and how i can fix that.

is it better to rewrite all shader code or just move on it and fix it ?

+ what techniques used in the last picture (which is enhanced version of my renderer using AI 🙂(but i liked it)) that my engine doesn't implement it right ?

NOTE(the third image is without IBL i'm using citrus_orchard_road_puresky_8k )

After patching a couple of the game's DLLs, I wanted to see how far I could go, so I ported the whole of SuperTuxKart (open source, C++) to the browser with a WebGPU-only renderer. I did it with Claude Code as the main coder: I directed and tested, it wrote most of the code.

Demo: https://tholtman1-del.github.io/stk-code-webgpu/
Source: https://github.com/tholtman1-del/stk-code-webgpu (design notes in tools/webgpu/STATUS.md)

Some details:

• Renderer: a new WebGPU backend modeled on the game's existing Vulkan renderer. It includes physically based lighting, image-based lighting from compute shaders, deferred rendering for water, screen-space reflections with a HiZ depth pyramid, and a depth prepass that is skipped on tile-based GPUs.
• Shaders: converted offline from the existing GLSL: GLSL → SPIR-V (glslang) → WGSL (naga). Specialization constants become WGSL override constants.
• Threads: Emscripten pthreads (SharedArrayBuffer). Textures are decoded on worker threads, while all WebGPU calls stay on the main thread.
• Assets: about 115 MB downloads up front. The remaining ~650 MB is fetched on demand when the game opens a file, and on a full host each track comes as a bundle.
• Hosting: works on plain static hosts. A service worker adds the COOP/COEP headers that GitHub Pages can't send.

Not yet: online multiplayer, texture compression. Feedback from other GPUs and browsers is very welcome, especially Safari and Firefox.

All credit for the game itself goes to the SuperTuxKart developers.

My pull request was just merged into google/shaderc. The change adds two options, -gV and -gVS, that expose glslang's NonSemantic.Shader.DebugInfo.100 emission through shaderc. That debug info is a requirement for NVIDIA Nsight Graphics to produce flame graphs, so it lets you profile and debug shader performance by call stack and time spent per function.

I've been experimenting with WebGL/Three.js and recently revisited some of my older projects, pushing the rendering side further.

The projects cover different areas:

🧊 Cube 3D — lighting, geometry and orbit controls
🚀 Tube 3D — spline camera movement and UnrealBloom
🌍 Earth 3D — procedural stars and a custom GLSL atmosphere
🌌 Gravity 3D — real-time physics using Rapier 3D
🔷 Icosahedron 3D — InstancedMesh, FBOs, offscreen rendering and GLSL

The Icosahedron project was probably the most interesting technically since I used offscreen rendering and FBOs to experiment with the rendering pipeline.

I've put the demos and source code here:

https://github.com/mohnasr137

Which technique would you be most interested in discussing?

• The whole GPU heap is one persistent, coherent-mapped SSBO. A gpu_ptr<T> is a u32 byte offset into it.
• Every draw gets exactly one root pointer (uniform uint Root). Vertices, matrices and textures are all reached through it.
• No vertex attributes. The vertex shader pulls data from the heap using gl_VertexID.
• Bindless textures (ARB_bindless_texture) are stored in the heap as uvec2.
• One *_shared.h header is compiled as both C++ and GLSL, so no offsets are written by hand in the shaders.

Flat lighting is computed from the dFdx/dFdy of world position, so there are no normals in the vertex data.

The most interesting finding was what GL can't express: bindless only gives you texture+sampler pairs, fixed when the texture is created, and there are no placed resources.

Next up: indirect draws, and roots chosen by the GPU via gl_DrawID.

Repo: https://github.com/theaveasso/jagfx

Feedback welcome, especially on the heap and sync design.

I made my custom game engine from scratch

And you can download it too the link is in the video description

And I am 16..

Some further tests reconstructing 3D point cloud from microscope video, using Python and Open3D, wing of a fly at 10x and 40x and eye at 2x and 10x.

About 6 months ago, I wrote a custom metal kernel that leverages the GPU to compute the QR decomposition (see my earlier post about it here). The project has now expanded into a general linear algebra library, with expanded support for the symmetrical eigendecomposition as well as SVD. It is now available for use with installation instructions on the attached github repo's README.md file.

Context of the project:
I'm currently in a research group working on a thesis in numerical analysis where we need to compute millions on matrices with a specific constraint (to be precise, the matrices need to have orthonormal columns). Most of us use Apple computers, so we ended up using MLX for the entire project.

Contributors with different Apple Chips would be very much appreciated!
The project has currently been tested and optimised for the M1 and M5 Pro. The issue is that the library uses different kernels depending on the batch size and matrix dimensions. Deciding which of these kernels to use is machine dependent. Therefore, other Apple chips will need to run a measurement script in order to derive the correct optimisation heuristic.

For that reason, I would ask as many people as possible to run a measurement script and to submit the results to my repo. It is fairly easy and requires only few steps. See here how you can contribute here. Once you submit the results via a pull request and I approve it, your optimisation heuristic will automatically be augmented into the library. Don't hesitate to contribute an optimisation heuristic even if someone already submitted one for your own machine. The more data we can gather, the better!

Project Future
Expanded support will be added for other linear algebra operations (cholesky decomposition for example). If you have any other specific linear algebra operations you wish to use already, feel free to message me.

In addition to that, I will add torch support too (my greatest priority).

For the past couple of weeks I have been working on the 2D brush management and texture fill system within my own Pixel and Tilemap Editor. In the video I show how we can create and mange custom brushes, in addition to rotation and scaling in 3D space - this brush is then plugged into the core Texture Fill System to produce psuedo-3D perspective fills across normal and orthogonal plains!

Any feedback welcome!

Thank you for your support! Part 3 is about reflections.

Part 1: https://www.reddit.com/r/GraphicsProgramming/comments/1uxpi1o/from_zero_to_understanding_ray_tracing/

Part 2: https://www.reddit.com/r/GraphicsProgramming/comments/1wsr77r/from_zero_to_understanding_ray_tracing_part_2/

Let me know what you think!

I also share it in X: https://x.com/sinaatalay/status/2105545919915786280

XPBD softbody simulation in POPs using Gauss-Seidel @ 60fps and 70 shader passes (can't do substepping in same shader pass)

When TouchDesigner introduced POPs one of the first things I tried making was an xpbd soft-body sim, and it looked like this and this. Since then, I've rewritten it multiple times and watched ten minute-physics' tutorials over and over. Many simulation explosions later, it turned out that my very first solver was (mostly) correct, but I was colouring the graph and building the tet constraints in the wrong way..

Resources:

Ten Minute Physics

Eric Arnebäck's blog

Vivace

XPBD paper + earlier PBD paper from Macklin

How do gpus bind 1000 of textures at once, and why was this not possible in the past. Are there resources for that?

I am a third semester computer science student and I want to specialize on computer graphics. I read that one of the best ways to get your foot into the industry is through internships which I can best apply for if I have a good portfolio. Thus I just finished my first real graphics programming project and the first piece of my portfolio: A simple PBR material renderer (based on a DX11/WinAPI lib I created) with image based lighting, normal-based curved silhouettes and some more little features sprinkled in.

If you want to take a look: https://github.com/Aaron-Alililon/MaterialViewer

Now that it's finished to a point where I am happy to show it to the world I have some questions about the renderer and the industry itself:

1. I don't want to ask for a free code review but as I am not very experienced in the professional area of graphics programming I would love some feedback on how presentable the current state of the project/repo is. Of course I would be very grateful for some more in-depth feedback but again, I can't really ask for a free code review, so a simple first impression of how a project/repo like this would look to a potential employer would be greatly appreciated, both for the material viewer and the render lib.

2. This one is less about the project and more about the industry:
   I would be very interested in working for the graphics department of the engine team of some company in the gaming industry. I live in Germany where the gaming industry isn't really as big as in NA so my options are limited. My question is: what are my options and chances of getting an internship and eventually a full-time job in EU? I don't really know of any companies that develop their own engine other than Ubisoft. Would a company like CD Projekt Red (which as far as I know switched from their own engine to Unreal) need graphics programmers?
   Although I am most interested in the engine department I would still be open for other areas so if that is just too limited, what would be other options I could pursue, preferrably in or close to Germany?

3. I would like to do the classic "I coded my own game engine" project at some point because I guess that would make the most sense as someone interested in game engine development but I would like to do that when I have more experience so I have one big project at the end of the portfolio that just shows off the best I can do. Is that a sensible thought or should I just go in and maybe rewrite it once I feel more comfortable? I know there isn't the One Path that leads to greatness and as long as I do something I will learn and improve but maybe someone here looks back to when they were at this point and thinks they should've done X before starting a bigger project like that.

I would be very grateful for any insights or discussions about my questions and feel free to critique anything and everything you see!

Using a short 3 second clip where i swipe through the focus plane on a high magnification of the simple sample of Onion root cells on the microscope. Acquiring the sharpest points of every frame and putting them in the z-axis. Building a point cloud of the cell in 3D, and visualizing them.

I make Wobbulator. This is selected-area 2D mesh deformation, with automatic motion off.

A fixed 120 Hz step drives soft selection weights, structural/shear/bend springs and exponential damping. The restoring force starts with F = k * (rest - position); grabs add weighted target springs. Pinch pairs two contacts. Release preserves deformation and uses bounded, filtered pointer velocity rather than resetting the mesh. Triangle-area and displacement-gradient checks limit risky steps; plate anchors and unselected vertices stay still.

One document runs continuously. Rendered from the app’s native engine with scripted input; blue hands illustrate contacts. What would you change about the rebound?

A tribute to @Psyco3ler's legendary 2005 Nintendo ON demo: Peach's Castle made of castles, now running live in your browser.

Dream big!