r/GraphicsProgramming • • Oct 04 '26

The Beast Engine - face video texture (webGPU)

0 Upvotes

In matrix-engine-wgpu "Effects" are subRender standalone system. I mean it own shaders own pipelines. In that way The Beats can eat every interesting demo from internet.
Because engine objective is "Mobile browsers support" optimisation done "cached pipeline per effect type". I dont have passing scene lighting intro effect but it is posible but not possible to put all intro single pipeline!

Source:
https://github.com/zlatnaspirala/matrix-engine-wgpu


r/GraphicsProgramming • • Aug 28 '20

What are some cloud-based solutions for path-tracing/volumetric path tracing?

0 Upvotes

There's already long since been general cloud-based ray-tracing solutions...

https://software.intel.com/content/www/us/en/develop/articles/tracing-rays-through-the-cloud.html

https://www.gamasutra.com/view/feature/6322/sponsored_feature_changing_the_.php?print=1

But are there any solutions for path-tracing or volumetric path tracing?


r/GraphicsProgramming • • Aug 10 '26

Article Benchmarking 2,307 glTF assets for topological health: technical breakdowns, engine impacts, and repair strategies

0 Upvotes

I engineered a headless mesh QA pipeline to evaluate 2,307 generated assets across 23 tools from the MIT-licensed 3D Arena dataset. Following reviewer feedback, this post details the topological metrics, their implications across graphics pipelines, when non-watertight geometry remains acceptable, and how automated repairs handle topological defects.

Benchmark dataset results

  • 40.1% non-watertight geometry

  • 39.7% missing UV channels

  • 79.8% exceed 30k triangle threshold (Unity mobile baseline)

  • 14.9% vertex-color only (zero texture bindings)

  • 9.7% non-manifold edge topology

  • Median face count: 77,402 triangles

Pipeline implications across developer workflows

Open boundaries (Non-watertight geometry)

  • Low-level impact: Breaks volumetric rendering, Constructive Solid Geometry (CSG) operations, 3D printing slicers, and signed distance field (SDF) generation.

  • When it skirts by: Standard single-sided rasterization of opaque background props. If the backfaces are culled and the interior space is unexposed, non-watertight meshes render without visual artifacts. I haven't measured what share of the corpus falls into that "technically broken, practically usable" bucket, and I don't think I can, it depends on how the asset gets used, which isn't a property of the mesh.

Missing UV coordinate channels

  • Low-level impact: Prevents texture coordinate sampling in fragment shaders, lightmap baking, and standard PBR material binding.

  • When it skirts by: Pipelines using procedural noise, triplanar world-space projection, or pure vertex-color attribute buffers.

High triangle density

  • Low-level impact: Increases vertex shader load, degrades rasterizer quad-occupancy efficiency, and bloats VRAM usage.

  • When it skirts by: High-end desktop pipelines, cinematic rendering, or virtualized geometry systems like Unreal Engine 5 Nanite.

Non-manifold edge topology

  • Low-level impact: Defined as three or more faces sharing an edge. Invalidates mesh decimation, subdivision algorithms, auto-LOD pipelines, and surface normal calculations.

  • When it skirts by: Rarely acceptable, but non-simulated static geometry with internal non-manifold edges will still draw on standard GPUs.

Disconnected geometry shards (Floating debris)

  • Low-level impact: Expands world-space axis-aligned bounding boxes (AABB), causing early culling failures and inefficient shadow map rendering.

  • When it skirts by: Internal floating faces that do not extend past the outer AABB boundary.

Remediation and mesh optimization methods

  • Retopology: Voxel remeshing followed by quad retopology (e.g., Instant Meshes or Quad Remesher) reconstructs clean manifold shells.

  • UV Generation: Automated seam generation and packing using tools like xatlas or native engine auto-UV unwrappers.

  • Decimation: Quadric Error Metric (QEM) reduction to scale polygon density down while preserving geometric features.

  • Topology Cleanup: Spatial vertex welding, deletion of degenerate faces (zero-area triangles), and normal recalculation.

Code updates and tool improvements

Testing 2,300+ models uncovered three major issues within the QA software itself:

  • Repair pipeline bug fixes: The repair path initially caused regressions on 616 assets. Adding manifold safety checks to the hole-filler and resolving normal inversions dropped failures to 454, with 237 remaining cases linked to decimation edge cases.

  • Storage vs. geometric topology handling: glTF splits vertices along UV seams and hard normals. Naive index buffer checks flag these as open boundary edges. The tool now welds coincident positions before topological evaluation.

  • Batch state preservation: Fixed a state file corruption bug during crash recovery that previously caused silent data loss.

(Full methodology, runner code, and benchmark dataset linked in the comments below.)


r/GraphicsProgramming • • Jun 09 '26

Salary at Pixar makes me think web developers are more well off

Post image
0 Upvotes

After checking the qualifications and pay for graphics programming roles at top companies like Pixar, I can say CRUD developers are better off.


r/GraphicsProgramming • • Sep 12 '26

Source Code Real-Time Raymarching on a Fixed-Function NPU. No dynamic loops. Just a 1,115-Ops ANE graph and a 1x1 Conv2d cumsum hack.

1 Upvotes

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:


r/GraphicsProgramming • • Sep 30 '24

Is it really surprising PS5 games look like PS4?

0 Upvotes

Looking at the specs, both PS5's CPU and GPU are approximately 2.5x faster than PS4 Pro, plus a few more capabilities (e.g. Ray Tracing). Given that we moved from a 30fps target on the PS4 era to a 60fps target on this generation, won't we spend most of the extra horse power on computing each frame twice as fast at roughly the same quality? Of course the quality modes represent a step up over last gen (FFXVI, Spidey 2, Alan Wake 2), but even then, Ray Tracing and increase in resolution are an OK jump in quality but at a huge computational expense. Is there really an optimization problem in the industry? Or are we just bound by the jump in hardware and fps target? Are we reaching diminishing returns for graphical quality?


r/GraphicsProgramming • • Jan 14 '25

Question Will traditional computing continue to advance?

3 Upvotes

Since the reveal of the 5090RTX I’ve been wondering whether the manufacturer push towards ai features rather than traditional generational improvements will affect the way that graphics computing will continue to improve. Eventually, will we work on traditional computing parallel to AI or will traditional be phased out in a decade or two.


r/GraphicsProgramming • • Oct 14 '25

Question I want to move to Linux. Can I use DX12 over there?

0 Upvotes

I want to move to Linux. Can I use DX12 over there?


r/GraphicsProgramming • • Aug 23 '26

Question Toughts on this road map

Post image
0 Upvotes

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.


r/GraphicsProgramming • • Sep 12 '25

Source Code I made MoVer, a tool that helps you create motion graphics animations by making an LLM iteratively improve what it generates

0 Upvotes

Check out more examples, install the tool, and learn how it works here: https://mover-dsl.github.io/

The overall idea is that I can convert your descriptions of animations in English to a formal verification program written in a DSL I developed called MoVer, which is then used to check if an animation generated by an LLM fully follows your description. If not, I iteratively ask the LLM to improve the animation until everything looks correct.


r/GraphicsProgramming • • Feb 07 '20

Hello guys, can you please take my survey regarding the use of quaternions and matrices in 3D graphics? It is for a research paper I am doing for a class.

2 Upvotes

Hello guys, I am a college student and decided to learn 3D graphics in my free time. I didn't want to use an external graphics library since I wanted to learn the behind-the-scenes math and so eventually I came across quaternions and matrices.

I know that matrices are more widely used but I was wondering about the performance impact of using quaternions in certain parts of the rendering pipeline. I decided to make this the research question for my English class and as part of that, I have to take a survey and here I am.

Link to survey: https://forms.gle/wb6eEEViUiWWmvTe7

Thank you!


r/GraphicsProgramming • • Dec 14 '25

Playing around with foliage creation in my custom OpenGL Engine

Post image
0 Upvotes

I just had to do it.


r/GraphicsProgramming • • Feb 19 '23

Source Code A simple graphing calculator I wrote in Java with AWT

0 Upvotes
import java.awt.*;
import java.awt.event.*;

/**@author Kaspar Winston
 */
class GraphingCalculator extends Frame
{
	public static void main(String[] args)
	{
		new GraphingCalculator();
	}

	GraphingCalculator()
	{
		super("Graphing Calculator");

		// Terminate when window is closed
		addWindowListener
		(
			new WindowAdapter()
			{
				public void windowClosing(WindowEvent e)
				{
					System.exit(0);
				}
			}
		);
		setSize(1000, 1000);
		add("Center", new CvGraphingCalculator());
		setVisible(true);
	}

	class CvGraphingCalculator extends Canvas
	{
		public void paint(Graphics g)
		{
			Dimension d;
			int maxX, maxY;

			// get the size of the canvas
			d = getSize();

			maxX = d.width - 1;
			maxY = d.height - 1;

			drawGraph(g, maxX, maxY);
			equation(g, maxX, maxY, 50, 25);
		}

		/** @param g awt graphics
		 * @param maxX max y coordinate (top and bottom edges of the graph)
		 * @param maxY max y coordinate (right and left edges of the graph)
		 * @param scale scale of the graph (how "zoomed in" it is)
		 * @param resolution resolution of the graph (space between each point drawn; higher resolution = closer together)
		 */
		void equation(Graphics g, int maxX, int maxY, int scale, int resolution)
		{
			float x, y;

			// set the origin at the center of the canvas
			g.translate(maxX / 2, maxY / 2);

			g.setColor(Color.black);

			for (x = -(maxX / 2); x < maxX / 2; x += (float) .01 / resolution)
			{
				y = (float)
				-(
			   		// equation goes here
					Math.sin(100 * x) + Math.sin(x)
				);

				g.drawLine(Math.round(x * scale), Math.round(y * scale), Math.round(x * scale), Math.round(y * scale));
			}
		}

		/** @param g awt graphics
		 * @param maxX max y coordinate (top and bottom edges of the graph)
		 * @param maxY max y coordinate (right and left edges of the graph)
		 */
		void drawGraph(Graphics g, int maxX, int maxY)
		{
			int midX = maxX / 2;
			int midY = maxY / 2;

			// draw x and y axis
			g.setColor(Color.lightGray);
			g.drawLine(0, midY, maxX, midY);
			g.drawLine(midX, 0, midX, maxY);
		}
	}
}

r/GraphicsProgramming • • 4d ago

Question Could two GPUs render separate halves of a game using a PBP monitor?

1 Upvotes

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 • • Aug 21 '25

Question I know how to make a raytracer, but haven’t learned much C++ yet. Do I try anyways?

0 Upvotes

Do I? I barely know any C++, but can I make it run at more than 3fps without using any advanced features?


r/GraphicsProgramming • • Jul 20 '21

Video I made another Vulkan short, this time its a little different in nature. Please lmk what you guys think of this one! (also the stance is completely subjective - the video is my opinion and is meant in a comedic way)

Thumbnail
youtu.be
0 Upvotes

r/GraphicsProgramming • • Oct 20 '26

Question What do you reckon is the best 2D Graphics API(C++)

0 Upvotes

As someone who is quite new to graphics programming I am having a bit of trouble deciding on what 2D api I should learn and use as a main. What do you suggest for both general stuff and games?


r/GraphicsProgramming • • May 14 '26

I built a tool that lets AI agents automatically analyze game GPU performance with Nsight Graphics

0 Upvotes

Hey everyone,

I’ve been working on a small open-source tool / agent skill for analyzing NVIDIA Nsight Graphics GPU Trace captures:

https://github.com/FrostyLeaves/nsight-graphics-analyzer

The main idea is to make Nsight Graphics GPU Trace data easier to use inside AI coding agents like Claude Code, Codex, or similar tools.

Right now, Nsight GPU Trace exports can be huge and hard to reason about manually, especially when you are trying to compare passes, find bottlenecks, or ask an agent to help explain performance issues. This project tries to convert the relevant data into a more compact and AI-friendly format, so the agent can reason about things like:

  • SM / L2 / VRAM / PCIe throughput

  • GPU pass cost

  • occupancy-related issues

  • frame bottlenecks

  • suspicious expensive draw / dispatch regions

It is mainly built for Windows workflows around NVIDIA Nsight Graphics and .ngfx-gputrace captures.

I’d really appreciate feedback from developers who regularly use Nsight tools for performance optimization, especially on whether this skill is actually useful, what problems you see with it, and any suggestions for improvement.


r/GraphicsProgramming • • Feb 27 '25

#python

0 Upvotes

r/GraphicsProgramming • • Jul 04 '20

Hello guys :) I am new to this group. I would love to participate in discussions

0 Upvotes

I am a student at the code camp.

Love my experience, have a lot of questions for tasks usually :)


r/GraphicsProgramming • • Jun 14 '21

Why do modern games look so bad

0 Upvotes

I am sorry, but I have no idea what am I actually looking at, but I've noticed that some modern games have ridiculously bad shading, that makes my eyes hurt. Instead of solid or soft shadows, all I can see are tiny dots that are jumping all over the place making the entire picture noisy and ridiculously hard to watch. These dots are visible on both minimum and maximum details. It's truly infuriating to hear my graphics card rev up this hard, and still see flat lighting in combination of microdots all over the screen.

This screenshot is from Mech warrior, and the patterns are obvious even when the immage is scaled down to 1/2 of it's size (yes, the game realy looks like this). I've encountered the same problem in for instance FF 15, where not even combination of full anti-aliasing and 200 percent render resolution helped this problem.

What is this called, does it have a solution and why does it even exist in new games, when old games never had it?


r/GraphicsProgramming • • Apr 03 '26

Real-time Navier-Stokes fire and smoke for games — Arakawa Jacobian + DST-I spectral Poisson solve, open source C# DLL

0 Upvotes

Most real-time "fluid" effects in games are not fluid simulations. They are particle systems with a noise texture. I wanted to see how close to real CFD you could get while staying at interactive frame rates on a CPU.

The result is Loucetius GCE — a 2D incompressible Navier-Stokes solver in vorticity-stream function form:

Numerical approach:

- Arakawa Jacobian for the nonlinear advection term (conserves both energy and enstrophy — this is why the simulation stays physically correct at long run times instead of accumulating numerical garbage)

- DST-I (Discrete Sine Transform type I) spectral Poisson solve to recover stream function from vorticity — exact machine precision solution every frame, not an iterative approximation

- Thom boundary conditions on solid walls

- Baroclinic torque source term driving thermally-generated vortices

- CFL-adaptive vorticity clipping for stability at high Reynolds numbers

What this gets you visually:

- Kelvin-Helmholtz roll-up instabilities appear naturally, no noise textures needed

- Correct vortex ring structure at the base of a flame

- Two flames merging into one plume with the right geometry

- Plume deflection and reattachment around obstacles

- Realistic pressure-driven expansion in explosions

The temperature, density, soot, and stream function fields are exposed as flat float arrays each frame — bind them directly to compute shaders or render textures.

Performance: Game preset (65x65) runs real-time, single core. Quality (129x129) around 100ms/step.

GitHub: https://github.com/ceh303-tech/loucetius-GCE


r/GraphicsProgramming • • Jul 20 '26

Question Im 17 and i wanna know if graphics programming is viable?

8 Upvotes

Hello, ive always been interested in graphics in games and ive wondered if the career option is viable.

I know that its VERY math heavy, hard to start and very few jobs are taking in junior graphic programmers.

But honestly making shaders is fun and making custom engines sounds super fun (for me at least)

I have some expiriance with the godot engine and writing some shaders in it for my passion project (idk if that counts tho) and im very interested in this career path.

And how do i get started (and if its not viable, what other path can i take that involves graphics or maybe animation)


r/GraphicsProgramming • • Aug 16 '25

Better vegetation rendering than Unreal, the Witcher 4 demo proves why w...

Thumbnail
youtube.com
36 Upvotes

In my next video I take a look at the Witcher 4 demo, and Nanite vegetation, and compare it to my own vegetation system.

We frequently forget how fast GPU's have become and what is possible with a well crafted setup that respects the exact way that stages amplify on a GPU. Since the video is short and simply highlights my case, here are my points for crafting a well optimized renderer.

  1. Use bindless, or at the very least arrays of textures. By sizing and compressing (choice of format) each texture perfectly you can keep the memory footprint as low as possible. Also see point 2.

  2. Use a single draw call, with culling, lodding, and building the draw commands in compute shaders. Bindless allows an uber shader with thousands of materials and textures to render in one pass. Whatever you loose inside the pixel shader is gained multiple times in the single draw call.

  3. Do as much work in the vertex shader as possible. Since my own engine is forward+, and I have 4 million tiny triangles on screen, I process all lights, other than the sun inside the vertex shader and pass this in. The same is true for fog and small plants, just calculate a single value, don't do this per pixel.

  4. Memory access is your biggest enemy

  5. Memory - Compress all of you vertex data as far as humanly possible. But pack and write extraction routines. Only need 3 bits, don't waste an int on it. By far the biggest gains will come from here.

  6. Memory - Use some form of triangle expansion. Here I use a geometry shader, but mesh shaders can work as well. My code averages 1 vertex per 2 triangles using this approach.

  7. Test and test. I prefer real-time feedback. With hot reloading you can alter a shader and immediately see the rendering time change. It is sometimes interesting to see that changes that