FluidX3D running AMD + Nvidia + Intel GPUs in "SLI" to pool together 132GB VRAM @ProjectPhysX

Uploaded March 2025 | Updated September 2026, 2 weeks ago

I made this #FluidX3D #CFD simulation run on a frankenstein zoo of 🟥AMD + 🟩Nvidia + 🟦Intel #GPUs! 🖖🤪

This RGB SLI abomination setup consists of 8 GPUs from 3 vendors in one server:
- 1x Nvidia A100 40GB (2 domains)
- 1x Nvidia Tesla P100 16GB (1 domain)
- 2x Nvidia A2 15GB (1 domain each)
- 3x AMD Instinct MI50 (1 domain each)
- 1x Intel Arc A770 16GB (1 domain)

I split the simulation box with 2322×1857×581 = 2.5 Billion grid cells (132GB VRAM requirement) up into 9 equal domains of ~15GB each, which run on 8 GPUs. The A100 is fast enough to take 2 domains while the other GPUs each get 1 domain. This is 5 completely different GPU microarchitectures seamlessly communicating over PCIe 4.0 x128. Under #OpenCL they are all created equal and don't care what vendor the GPU is which computes the neighbor domain.

This demonstrates that heterogenious #GPGPU compute is actually very practical. FluidX3D users can run the hardware they already have, and freely expand with any other hardware that is best value at the time, rather than being vendor-locked and having to buy more expensive GPUs that bring less value.

The demo setup itself is the Cessna-172 in flight fir 1 second real time, at 226 km/h airspeed. 159022 time steps, 11h27min runtime consisting of 9h16min (compute) + 2h11min (rendering).
Setup: github.com/ProjectPhysX/FluidX3D/blob/master/src/setup.cpp#L771
Cessna-172 3D model: thingiverse.com/thing:814319/files

I created the FluidX3D CFD software from scratch and put the entire source code on #GitHub, for anyone to use for free. Have fun!
github.com/ProjectPhysX/FluidX3D

Huge thanks to Tobias Ribizel from TUM Campus Heilbronn for providing the hardware for this test!

FluidX3D running AMD + Nvidia + Intel GPUs in SLI to pool together 132GB VRAM

Line3D [GRAPHICS ENGINE] Dynamische Beleuchtung

Commercial CFD would take months for this | its just minutes with FluidX3D

Real time raytracing without RTX? No problem! Raytraced isosurface demo running on GTX 960M

FluidX3D [FLUID SIMULATION] - Real Time Free Surface LBM with Volume-of-Fluid

FluidX3D [FLUID SIMULATION] - Smashing the Memory Wall with FP16 | 100 Subscriber Special

Radial Fan simulated in FluidX3D CFD (this was 45min on a gaming PC)

$FluidX3D Rendering Comparison (Raindrop Impact) How do visual quality and combined compute+render time compare for different variants of raytracing? Compute time alone of this simulation is 16 minutes. Rasterization adds another 5 minutes, flat triangle raytracing 8 minutes. With normal vector interpolation its 10 minutes. A second raytracing pass vastly elongates render time to 31 minutes. Resolution is 1080p, and 599 frames are rendered. 1 raytracing pass means the camera ray enters the fluid and gets split in reflection and internal ray; the internal ray exits the fluid again and becomes the refraction ray. Per pixel, a total of 4 rays are computed (camera ray, reflection ray, internal ray, refraction ray). The 2nd pass means that both reflection and refraction ray again can intersect fluid and become reflected and refracted. With 2 raytracing passes, the entire simulation box is reflected on / refracted through every single dropelt. Per pixel, a total of 10 rays are computed (camera ray, 3x reflection ray, 3x internal ray, 3x refraction ray). Entire simulation in 4K: https://youtu.be/UUYrWUpPQwY From Boxes to photorealistic Fluid: https://youtu.be/u83qaxuT6eA See my published research paper in Microplastics and Nanoplastics: https://microplastics.springeropen.com/articles/10.1186/s43591-021-00018-8 The large simulation domain is made possible by FP32/FP16 mixed precision with novel 16-bit number formats: https://arxiv.org/pdf/2112.08926.pdf This is a Volume-of-Fluid lattice Boltzmann method (LBM) simulation of a 7 mm diameter terminal velocity (9.55 m/s) raindrop impact (D3Q19 SRT) at 20° inclination. Velocity, density and fluid mass are solved at 108 Million lattice points (504x504x428) for 13752 time steps, equivalent to 10 milliseconds in real time. The simulation required 12 GB video memory. For reproducibility: The dimensionless numbers for this setup are Re = 63618, We = 8864, Fr = 36.44, Ca = 0.1393, Bo = 6.674. The simulation software used is FluidX3D, an OpenCL implementation of the lattice Boltzmann method. FluidX3D runs at peak hardware efficiency on the worlds fastest data-center GPUs (8799/5232 MLUPs/s on the Nvidia A100/V100 @ D3Q19 SRT FP32), on gaming GPUs and CPUs and it even runs my smartphone. The rendering is done by FluidX3D as well. Simulated light rays from the camera traverse the LBM lattice and check for intersections with the triangles that marching-cubes generates on-the-fly from the isovalues. Triangles never leave registers. The 3D lattice that the LBM provides already is one of the ideal acceleration structures for raytracing. Any ray only has to check for possible intersections with iso-surface triangles contained within the traversed grid cells. This makes it - when the lattice is not too large - even run in real time on non-RTX GPUs. I am the lead developer of FluidX3D. The implementation is detailed in my Masters thesis, which is freely available on ResearchGate: https://www.researchgate.net/publication/349552856_High_Performance_Free_Surface_LBM_on_GPUs The Volume-of-Fluid extension is detailed in this research paper: https://www.mdpi.com/2079-3197/10/2/21 Timestamps: 00:00 Intro 00:02 Video Comparison 00:12 Freeze Frame 00:17 Outro #FluidX3D #OpenCL #Raytracing #GPU #LBM Music: admo - On The Nightway$

Simulating an oblique drop impact on a shallow liquid pool with FluidX3D

$I wrote this Real Time RayTracer from Scratch in 1 Week. Hybrid Rasterization + Raytracing Demo I wrote this real time OpenCL raytracer in one week from scratch and without any external libraries. Timestamps 0:00 Intro 0:02 1 Sphere 0:29 64 Spheres 1:34 Triangles - reflection 2:23 Triangles - reflection+refraction 4:10 How it works 4:39 Outro This project was first inspired by this awesome video from the YouTuber NamePointer: https://youtu.be/lKIytgt3KXM It is surprisingly easy: From the camera, shoot a ray through every pixel. Reflect the ray off the first surfaces in its way, reflect the reflection 2 more times. Finaly when the reflected ray hits the skybox, mix all the colors to paint the original pixel with. The GPU does this for all 2 Million pixels on the screen in parallel. I implemented: - ray-sphere intersection - ray-triangle intersection (Möller-Trumbore algorithm) - reflection as well as refraction with Snells law - hybrid rasterize-raytrace approach: First rasterize triangles and instead of the pixel color save their IDs in the bitmap. Then the raytrace kernel looks up the ID to immediately get the first intersecting triangle. This way the first intersection and reflection are basically free, so the shiny Stanford bunny with 70k triangles runs at 200+fps. Because I wrote the raytracer in OpenCL, it runs on any OpenCL capable device (GPUs, CPUs, even my Samsung phone). No proprietary RTX hardware required. Music: Unfound - Promenade$