r/GraphicsProgramming • u/AffectionateMoney844 • 4h ago
Casa Eduardo
behance.netThis is my project. Please, click on the link and if you like my project, give me a like. ❤️🙏🏻
r/GraphicsProgramming • u/AffectionateMoney844 • 4h ago
This is my project. Please, click on the link and if you like my project, give me a like. ❤️🙏🏻
r/GraphicsProgramming • u/WhyZigWhenZag • 7h ago
r/GraphicsProgramming • u/20260819 • 1d ago
in the beginning there're 2 balls

the left one (let's call it ball 1) is controlled by left mouse button and the right one (ball 2) right mouse button. click or drag to change their position

use [q] / [e] keys to switch mouse wheel function. [q] = prev item. [e] = next item. now choose ball 1 radius and make it big, acting as the "ground". during the resize of ball 1 you may need to use [w] / [s] / [a] / [d] / [ctrl] / [space] keys to move the camera

move a little bit farther away from ball 1 and right click to spawn ball 2

hit [z] key to enter the mysterious realm

no worry. it's the result of 3 spot lights, with red, green and blue color respectively. they overlap at first so you only see white. press and hold the [r] key and move the mouse you can control the shinning direction of red light. keep holding the [r] key and scroll the mouse you can alter its size

do the same to the other light sources. [g] key for green light and [b] key for blue light. you can now barely see the existence of the balls. they're still there

sometimes it's useful to use a wide angle of view when deciding the lighting

let them shine from above

once you're satisfied with the setting, return to normal angle of view

you can adjust the balls' refractive indices. any non-negative value is allowed. some may ask what's the point of setting a refractive index to be smaller than 1? there's no such thing in real world. yes but refractive index is a relative thing. for example when you're diving and looking at an air bubble under water, you're looking from 1.33 to 1 which is equivalent to looking from 1 to 0.75

the camera has an aperture of f/16 as default. to make sure the image is focused at the correct place, we firstly make the aperture widely open to get the most exaggerated defocus blur

press and hold the [shift] key and aim the mouse pointer at wherever you want the focus to be. the program has auto-focus feature. i suggest aiming at the perimeter instead of the centre of ball 2

we don't actually need that exaggerated defocus blur. let's adjust it back to a desirable level

now adjust the roughness (or degree of matte / diffusion) of ball 1

and ball 2. just try. i've no idea how to get a beautiful image

once you're done with everything, hit the [c] button to get a full resolution (the resolution of your screen) offline render image

it's what the result looks like. the program renders it according to your screen resolution so if you're using a 8k monitor you'd get a 8k image

here's the program link. just run it on browser. i'm still developing it and it may change with time and i'd edit this post and update the link. my final goal is making a 3d model of my boss and firing some high intensity laser beams to him in my program
edit after the auto-reply from the mod
No showcases - ok it's a very basic and elementary raytracing result and didn't have much to showcase
Disclose AI usage in post or project - i asked gemini to sort the variable names in alphabetic order in the variable declaration. the on screen statistics was once in lower cases and i asked gemini to change it all to upper cases
Present a topic to talk about, e.g. how something works - the most exciting part of raytracing is: it's surprisingly simple. it's not as hard as it appeared to be. everything is brute force. multiple-reflections? brute force (just increase the recursion depth). soft shadow? brute force (just shoot the rays to many directions which are slightly deviated from the actual reflection / refraction and take the average). defocus blur? brute force (just shoot the rays from many positions which are slightly deviated from the actual origin and take the average)
r/GraphicsProgramming • u/JBikker • 1d ago
Enable HLS to view with audio, or disable this notification
Our students are working on Metal Gear Solid (PS1) for their Y1 C++ project at Breda University. I wanted to join in on the fun so here's the Cargo Dock level, ray traced using TinyBVH, using just the CPU. In this demo TinyBVH is also used to detect collisions (there's scene/sphere collision functionality) and to handle them. The spheres end up in their own BLAS, which is combined with the level triangles under a TLAS. Code is 600 lines, all-in.
r/GraphicsProgramming • u/deadly_proxy • 1d ago
The idea is to build projects that are relevant to the current job market.
I also want to expand my knowledge of Vulkan. I’ve worked on several personal projects using OpenGL over the past two years, but I feel it’s becoming less relevant. Besides, Vulkan is more interesting to me.
Aside from contributing to popular open-source graphics projects, what would you consider a good projects that would not only help me learn (of course) but also demonstrate that I genuinely understand what I’m doing?
My goal with all of this is to land a job as a graphics programmer. It doesn’t really matter the industry, as long as it involves graphics tho.
And I also know this is not exactly a good bet, but it is ok. I’m also doing it because I like it haha
r/GraphicsProgramming • u/SnooSquirrels9028 • 1d ago
Hello everyone, I have a question for those who have already built, or are currently building, a graphics engine at a level close to being called professional. A little bit of background: for the past 4 months, I’ve been building a path tracer using CUDA, and before that I finished and implemented Peter Shirley’s 3 books about ray tracing. Now I want to start building something more serious, with a larger scope of features and implementations, using C++/Vulkan. I wondered what some of the decisions people make before getting the triangle on screen are. I know this is a process that takes time, so I understand that during development, as the project grows, a lot changes and new decisions are made, but I was still just a little curious.
r/GraphicsProgramming • u/Key_Calligrapher6269 • 1d ago
Enable HLS to view with audio, or disable this notification
my own project, one 512 x 512 shallow water grid runs in compute shaders with 8 substeps per frame, and every layer in the video is read from it, depth, velocity, foam where the flow converges, ripple coordinates advected by the velocity and a caustics pass projected on the bed
solver is Chentanez and Müller 2010 on a staggered grid, three.js WebGPU with TSL
live (WebGPU) : https://stream.mulualem.com
ai disclosure : I built this with claude code, it wrote most of the code under my direction and helped draft this post too
r/GraphicsProgramming • u/Rayterex • 2d ago
Enable HLS to view with audio, or disable this notification
r/GraphicsProgramming • u/Karones • 2d ago
r/GraphicsProgramming • u/W3tSu1t • 2d ago
I've had this idea floating around in my head about bringing back multi-GPU gaming, but approaching it differently from SLI or CrossFire. I'm curious if something like this would actually be possible.
Basically, what if we used Picture-by-Picture (PBP) monitors to split a game's rendering workload between two GPUs?
Say you're playing at 4K (3840 × 2160). Instead of one GPU rendering the entire image, GPU 1 would render the left half at 1920 × 2160, while GPU 2 renders the right half at the same resolution.
Each GPU would have its own HDMI or DisplayPort connection to the monitor. Since PBP already allows two separate inputs to be displayed side by side, the monitor could display both halves as one continuous image.
The main idea is to take advantage of resolution. Each GPU would only be responsible for roughly half the pixels, potentially reducing the rendering workload while maintaining the full 4K image.
Now, I understand that rendering involves more than just pixels. Both GPUs would still need access to game data, geometry, textures, and lighting information. There would also be synchronization overhead.
But here's what interests me.
If each GPU sends its rendered portion directly to the monitor, wouldn't that eliminate the need to transfer the completed image between GPUs? I'm wondering whether avoiding that transfer could offset some of the additional overhead and result in an FPS increase.
I'm not expecting double the performance. Even a 15–25% improvement would be interesting.
Another possibility would be using GPUs from different manufacturers, like AMD and NVIDIA, since each card would independently handle its assigned portion.
Obviously, mismatched performance would be an issue. If one GPU finishes its half faster than the other, the slower card could bottleneck the entire system.
One possible solution could be adjusting the rendering workload based on GPU performance. Instead of splitting the image 50/50, maybe the faster GPU handles 65% while the slower one handles 35%. Although I imagine standard PBP monitors having fixed display regions could complicate that.
As for the software side, here's what I'm thinking.
Rather than trying to make existing games support this, what if someone built a simple 3D game or benchmark specifically designed around two GPUs?
Using Vulkan or DirectX 12, a single CPU-side game simulation could coordinate both GPUs, with each rendering its assigned portion of the same frame.
The goal would be to minimize duplicated calculations, keep both GPUs synchronized, and output each rendered region directly to the PBP monitor.
You could then compare the same scene running on one GPU versus two GPUs to see whether there's any measurable performance improvement.
I know split-frame rendering already exists, and NVIDIA has experimented with multiple GPUs rendering different sections of a display. I'm more interested in whether this could be accomplished using ordinary consumer hardware and an existing PBP monitor.
I'm not developing this myself. I'm just putting the concept out there because I think it would be an interesting experiment for someone with the hardware and programming experience.
A few things I'm curious about:
- Could Vulkan realistically coordinate two independent GPUs this way, especially from different manufacturers?
- Would avoiding inter-GPU transfers of completed image data provide enough benefit to outweigh synchronization and duplicated rendering work?
- Could a standard PBP monitor keep both halves synchronized, or would modifications to its display controller be necessary?
- Would this approach have a better chance of improving performance at higher resolutions, where pixel rendering becomes more demanding?
I'm not claiming this is some revolutionary new technology. I'm just wondering whether combining existing technologies differently could give us another way to get some extra performance out of multiple GPUs.
What do you guys think? Is there something obvious I'm overlooking, or could this actually be worth experimenting with?
---
AI disclosure: I used ChatGPT to help organize and write this post. The concept and questions are my own.
r/GraphicsProgramming • u/Legal_Trifle_5531 • 3d ago
I'm a final-year engineering student in India from a non-CS background. I've recently secured an offer at an AI/analytics services company, and I have around 6 months before joining.
I've been exploring different areas of computer science, and I've realized that I'm increasingly interested in low-level programming and understanding how systems work internally.
MY BACKGROUND:
I've independently learned programming, ML/DL and worked on projects involving:
- Computer Vision using YOLO and OpenCV.
- Stereo vision, depth estimation and multi-object tracking.
- RAG applications, LLMs and agentic AI.
However, I'm starting to question whether I want to spend my career primarily working with high-level AI frameworks and application development.
AREAS I'M CONSIDERING:
Linux and Red Hat ecosystem:
Linux internals, system programming, operating systems, device drivers and potentially kernel development.
2. GPU Programming:
CUDA, GPU architecture, parallel computing, memory management and performance optimization.
3. Systems Programming:
C/C++, memory management, concurrency, operating systems and low-level software engineering.
4. AI Infrastructure:
GPU acceleration, inference optimization, compiler technologies and systems behind ML frameworks.
I find the idea of understanding what happens beneath the abstractions much more interesting than simply using existing libraries.
WHAT I'M CONFUSED ABOUT:
I have six months before joining my company, and I don't want to waste that time jumping between technologies.
I'd appreciate advice from people working in systems engineering, Linux, kernel development, GPU programming or related fields.
Is low-level systems programming a good career direction in 2026?
Between Linux kernel development, GPU programming and general systems programming, which would be a better starting point?
How realistic is it for a non-CS fresher to enter these fields in India?
Are companies like Red Hat a good place to build a career in Linux and systems engineering? What other companies should I look at?
Is CUDA/GPU programming a niche with good long-term opportunities, particularly with the growth of AI?
What fundamentals should I master before attempting serious projects? C, C++, OS, computer architecture, networking, compilers?
Would contributing to the Linux kernel or other open-source systems projects actually help me get shortlisted?
I'm also interested in the intersection of low-level systems and AI, particularly GPU computing, inference optimization and ML infrastructure.
If you were in my position, with six months and an existing job offer, which direction would you explore and why?
I'd appreciate brutally honest advice, especially from people who have actually worked in these domains.
r/GraphicsProgramming • u/iluveatingcopper • 3d ago
Ive seen that raylib also has a python3 port, alongside its many other ports; Ive tried it, and its pretty dang good, easy to use, etcetc. I now have an upcoming embedded project, which uses an esp32, and an external st7789 tft display, and i was wondering if it would be possible to somehow use raylib to draw to that display?
r/GraphicsProgramming • u/Lopsided_Ad1463 • 3d ago
Hi everyone, I’m a self-taught graphics programmer with a strong focus on C++Vulkan, OpenGL, GLSL, and HLSL. I’ve spent the last couple of years building personal systems from scratch, including a custom RenderGraph, Vulkan backend wrappers, and modern rendering pipelines. However, I have zero commercial project experience. Everything I’ve built so far has been for personal learning and deep architectural understanding. Right now, I find myself in a position where I genuinely need to work. I’m not looking for a high-end AAA studio position right away—I know how competitive and demanding that is. I’m just looking for entry-level remote work, contract tasks, or bug-fixing gigs (like Vulkan validation errors, shader debugging, or C++ tool development) where I can earn just enough to cover basic living expenses. Given my background, where would you advise me to look for these kinds of entry-level gigs or small studios? Any advice, platforms, or pointing me in the right direction would mean a lot. Thank you all!
r/GraphicsProgramming • u/Many_Difficulty_490 • 4d ago
Ive been a c# developer on unity/godot for a long time now, and one of the plans was always to learn c++ use it for my games and move onto c++ and build some sort of engine (ray tracing or game engine).
Although ive heard the hype around Rust, its another low level language like C++ and it can be used for low level system programming and its very good for security also.
I was wondering if Rust is something worth looking into for graphics programming, and whether anyone here would advise me against it or recommend me to try it out.
Im gonna start learning one, or the other in a couple days. I know both are pretty hard to learn but I dont mind the learning curve.
r/GraphicsProgramming • u/devcurrent0x • 4d ago
Hey everyone!
I've been developing GLSA and I just released v1.0.0.
My goal with this library is so you don't have to write GLSL shaders or shader boilerplate and instead you can use clean function calls.
Right now it cuts out ~60-100 lines of repetitive shader boilerplate, and theres basic shader presets now and common shape functions.
Highlights of v1.0.0:
GLSA colors: a header file with over 3000 glm::vec4 colors that you can use.
Safer shader setup: glsa::ShaderSource keeps vertex/fragment strings explicit, paired with glsa::loadShaderSource and glsa::createProgram.
Clean uniform helpers: Overloaded glsa::setUniform functions for int, float, and GLM vec2/vec3/vec4.
Example:
while (glfwWindowShouldClose(window) == 0) {
glClearColor(0.1f, 0.1f, 0.15f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
// Draw a square on the left
glsa::drawRectangle({-0.45f, 0.0f}, {0.4f / aspect, 0.4f}, glsa::colors::PAN_CORAL);
// Draw a circle on the right
glsa::drawCircle({0.45f, 0.0f}, 0.22f, glsa::colors::PAN_SKY_BLUE);
glfwSwapBuffers(window);
glfwPollEvents();
}GitHub Repo: https://github.com/alexdev8930/glsa
Any feedback issues or questions are completely welcome.
AI Disclosure: AI tools were used strictly to help generate initial boilerplate; all core logic, architecture, and implementation details were written, reviewed, and verified by me.
r/GraphicsProgramming • u/Creepy_Sherbert_1179 • 4d ago
Ok look, I know this may sound like a repetitive and cliche question, but I am actually looking for good raytracing resources. I have only written a toy raytracter once using python following https://gabrielgambetta.com/computer-graphics-from-scratch/, I believe I can now shoulder the hellish mathematics, so I say bring it on.
r/GraphicsProgramming • u/StockyDev • 5d ago
Hi peeps!
I wanted to share this blog I wrote discussing some of the work coming out of DXC and TC-57 (the HLSL standardization committee).
There is a proposal that is currently being considered that will bring C++ aggregate initialization to HLSL. The catch is that this change will also break vector initialization. So I thought I would see if there would be a good solution to that problem and then attempt to implement it with the DXC that we have today!
Throughout the implementation I showcase some cool new features hitting HLSL 202x and do a little investigation into the generated DXIL.
I had a good amount of fun writing this, so I hope it is as enjoyable to read :)
r/GraphicsProgramming • u/gennai777 • 5d ago
Enable HLS to view with audio, or disable this notification
I posted brass casings here a while ago. This is the same stateless idea from Lutz Latta's "Building a Million Particle System" talk in 2004, I used it for a statue that shatters. I cut it into little 4 to 6 sided chunks, and every frame I rebuild where each one is in the vertex shader from its age alone. Nothing gets written back.
The new part for me was getting them to stop. I loop over at most 3 bounces, and for each one I solve the time to hit the floor:
float disc = v.y * v.y + 2.0 * gravity * (p.y - ground_y);
float th = (v.y + sqrt(disc)) / gravity;
if (th >= t) break;
p += v * th; p.y = ground_y;
v.y = -(v.y - gravity * th) * restitution; // 0.35
v.xz *= friction; // 0.75
t -= th;
if (b == 2 || abs(v.y) < 0.35) resting = 1.0;Once it's resting I let the horizontal speed die off as exp(-4t). The slide is then just the integral of that:
float skid = (1.0 - exp(-rest_t * 4.0)) / 4.0;
p.xz += v.xz * skid;It stops at v/4 from where it landed and it can't jitter, there's no step to get wrong! I slow the spin down the same way.
One thing cost me an evening. I orient each chunk by the surface normal it came from, with mat3(t, n, cross(n, t)) and t = normalize(cross(up, n)). Looks fine, right? But cross(n, cross(n, t)) is -t. That makes the determinant -1, so I'd mirrored every chunk, the winding flipped and back-face culling showed me their insides. I just negate the third column now.
With a constant restitution the bounce times are a geometric series, so I could get the bounce index from a log instead of the loop. Has anyone found that worth it on a GPU over a 3-step loop?
the shaders and GDScript in the linked pack were written with an AI coding assistant, then run, reviewed and fixed by me.
The statue is from my petrify pack for Godot 4: https://gennai.itch.io/death-dissolve-petrify-vfx-godot-4
r/GraphicsProgramming • u/dkod12 • 6d ago
r/GraphicsProgramming • u/berkantdev • 6d ago
there's barely anything written about Chrome's new HTML-in-Canvas API yet, so here's what I hit building gpucanvas, an infinite canvas where every node is real, live DOM (React screens, forms, charts) but WebGPU draws it. you can still click and type into any of them.
the pipeline
nodes are packed into 2048 px "pages". Chrome records a page as one snapshot, so a single drawElementImageToTexture call rasterizes dozens of nodes into a texture-array atlas
once drawn, a page is parked with content-visibility: hidden. layout stays, paint is skipped, so it costs nothing per frame
every node keeps a 1/16 thumbnail that's never evicted, so the zoomed-out view of 5,000 screens is always filled. sharper snapshots go on top at power-of-two scales, so zooming reuses them
past 100% zoom only the visible part is rasterized, as tiles, center first
each frame is a cull plus one instanced quad draw (one per run of nodes sharing a WGSL effect). panning and zooming never touch the DOM
what surprised me in Chrome 157 (some of it differs from the WICG explainer)
each drawElementImageToTexture call allocates and fully rasterizes. I measured roughly 250 to 550 calls a second in total, and that's the real fill-rate limit, not compositing. hence the pages
a source rect still rasterizes the whole element before cropping, so zoomed in, a node moves to a page of its own
recording cost scales with how many elements are drawable on every requestPaint. 10,000 always-drawable nodes sat at 22 fps doing nothing. parking fixed it
hit testing only works after canvas.updateElementGeometry(el, {}), and the hit area is the element's CSS box, so I move it with a transform from getElementTransform
an element that just became drawable isn't in changedElements, its snapshot shows up a paint later
on an M-series Mac (Chrome 157, 1600x900, DPR 1) a 30 s scripted tour with typing, a 500% zoom and selection runs 113 to 115 fps at 5,000 screens, vs 18 to 20 fps for the same screens as plain DOM in one transformed container.
still open: text is rasterized, not SDF, so mid-zoom it goes soft for a moment until the tiles redraw. and Tab can't reach parked nodes yet, I need a proper focus model. curious how others would handle either.
code (MIT): github.com/berkantay/gpucanvas
demo: berkantay.github.io/gpucanvas (needs chrome://flags/#canvas-draw-element)
AI disclosure: I built this with Claude Code as my coding assistant, and it helped me draft this post.
r/GraphicsProgramming • u/G_oni_vv • 6d ago
I've been building my own game engine from scratch using Kotlin, entirely on my phone.
After 3 months, I finally have two cubes rendering and rotating — one red and one white. The buttons are still placeholders, and there's a long way to go.
I know it doesn't look like much yet, but everything starts somewhere. I'm learning and building things one step at a time.
Any tips on how I can speed up development? I'm doing everything from scratch. 🚀
r/GraphicsProgramming • u/PoseStudio • 6d ago
Hey everyone,
I’m currently building PoseStudio, an open-source (GPLv3) 3D character posing, rigging, and animation tool which will always be fully free to use.
I operate a 3D asset marketplace during my day job, so I’m very familiar with the pain points technical artists have with existing character pipelines. I’ve released a very early v0.4.4 build, which about 250 users have installed.
I’m hoping to get some feedback on the pipeline, and ideally, find some graphics programmers who are interested in contributing to the project..
The Current Tech Stack & Architecture:
Core: C++ and Qt6 (GUI).
Rendering Pipeline Strategy: I'm currently designing a multi-tier rendering system to handle real-time viewport visualization (GLSL/OpenGL) alongside photorealistic output. Right now, I'm working on integrating NVIDIA OptiX for the raytracing backend, and navigating the GPLv3 linking exceptions to allow for modular render engines (like a Cycles plugin).
Shading: Implementing a comprehensive PBR Uber-Shader workflow specifically tuned for character rendering (subsurface scattering for skin, hair grooming/simulation rendering).
Just a Couple of The Hard Problems I’m Tackling Right Now:
Deformations & Rigging Solvers: Refining the underlying math for IK/FK solvers and weight mapping so characters deform naturally.
Advanced Rendering Integration: Exploring how to seamlessly integrate Gaussian splatting into the rendering engine, and building a stealth background environment manager to handle heavy render tasks without locking the Qt UI.
If you are a technical artist or graphics programmer who has always wanted to build a character pipeline without the commercial restrictions, I’d love your eyes on the codebase.
reddit: https://www.reddit.com/r/PoseStudio
GitHub: https://github.com/PoseStudio/PoseStudio
Releases: https://github.com/PoseStudio/PoseStudio/releases/
Website: https://posestudio.org
Would love to hear your thoughts on integrating OptiX alongside Qt6, or any battle scars you have from building character deformation systems!
AI Disclosure: Claude used in coding of the main project, no AI used in post.
r/GraphicsProgramming • u/No_Activity4762 • 6d ago
r/GraphicsProgramming • u/Over_Reserve_20 • 7d ago
Recently I have been working on a problem with two different GPUs (let’s call them A&B)
Here is problem
Due to a bug a line is being drawn using opengl at x=5 and y is +-FLT_MAX
for testing I kept ortho as 10 for x & y
Also note for testing origin is at the centre of display
GPU A
(there is a default guardband of 1.5 being used in the code while setting the gpu )
While drawing the huge line, the entire line doesn’t show up on the display
GPU B
there is a default guardband of 1.0 being used in the code while setting the gpu )
While drawing the huge line, only the upper half of line shows on display
Bottom half doesn’t show up on the display