Chrono water dam-break
Run Project Chrono's original SPH kernels on 16,731 fluid particles. Inspect all 15 CUDA-to-WGSL passes, with neighbours rebuilt every step. Currently slower than real time.
Explore live GPU experiments, inspect the CUDA behind them, and compare the results with native execution on an RTX 5080.
Run Project Chrono's original SPH kernels on 16,731 fluid particles. Inspect all 15 CUDA-to-WGSL passes, with neighbours rebuilt every step. Currently slower than real time.
OFFICIAL NVIDIA KERNELThe original CUDA kernel splits points into quadrants and recursively launches its children. Explore the complete GPU-built tree, verified against native CUDA.
OFFICIAL NVIDIA KERNELSThe original CUDA parent chooses curve detail, allocates vertices and launches child kernels. GPU-generated queues drive the children; zoom into their output in the sandbox.
CUDA PATH TRACERRoger Allen’s final Ray Tracing in One Weekend scene. Original CUDA device functions compile into five WGSL passes, with persistent objects, material dispatch and seeded random rays.
Sample five full-resolution scalar texture layers with the original CUDA kernel. Compare every output with native CUDA and inspect the generated WGSL.
Sample all six faces through 3D directions with the original CUDA kernel. Inspect face orientation and native-verified edge filtering.
Transform 8.4 million values, modulate with the original convolution kernel, then transform back. Inspect the complete native-verified output.
Price 1,024 options through 2,048 time steps with the original kernel. Inspect each result in the heatmap and compare CUDA with its generated WGSL.
Sort a million key/value pairs using the original shared-memory stage and 155 in-place global merge passes. Compare the input and final ordering.
Sort a million key/value pairs through the original shared-memory and in-place global merge stages. Compare the original and sorted keys side by side.
Compute ten million values across 100 dimensions. Explore a 3D projection of 100,000 vectors and choose other coordinate planes in the launch settings.
Generate over a million three-dimensional points with NVIDIA’s Niederreiter sequence. Orbit the complete GPU-generated distribution and compare CUDA with WGSL.
Compress the original teapot image into DXT1 blocks, then decode the GPU result for display. Inspect the complete compressor beside its generated WGSL.
Original real/complex preprocessing and frequency multiplication, with four million input values and all GPU stages exposed.
Combines spectrum conversion, multiplication and inverse preparation in NVIDIA’s original fused processing kernel.
Filter four million input values through texture padding, real FFTs and frequency multiplication. Original CUDA kernels with native-verified output.
Reveal motion between two camera frames. Six original CUDA kernels build an image pyramid, warp the image and solve the displacement field.
Recover image shifts from a stereo camera pair. Original CUDA block matching uses packed colour textures, shared memory and SIMD byte differences.
Drag to stir 262,144 particles. Original CUDA advection, forces and diffusion run with GPU FFT projection in a 512 × 512 fluid field.
Orbit a cloud of 16,384 particles. Original CUDA integration and depth calculation feed GPU sorting and a 32-slice smoke renderer with volumetric shadows.
See two colour and opacity tables reveal the original Bucky volume. Integration, layered tables and ray marching run from unchanged CUDA functions.
Watch 1,024 spheres fall, collide and settle. The original integration and collision code runs with GPU sorting and shared render positions.
Watch a wind-driven wave spectrum become an animated 3D surface. Spectrum, inverse FFT, heights and slopes run on the GPU.
Run NVIDIA’s optimized floating-point transform. Threads share a 32 × 16 image tile and process rows and columns before reconstructing the teapot.
Transform the teapot into 8 × 8 frequency blocks, quantize the coefficients and reconstruct the image. Compare the original CUDA kernels with generated WGSL.
Smooth image noise using colour-distance weights in a local window. Run NVIDIA’s original noisy portrait and compare CUDA with WGSL.
Compare neighbourhood patches to preserve image detail while reducing noise. Run NVIDIA’s original noisy portrait and compare CUDA with WGSL.
Reuse patch weights across a shared-memory tile using the original optimized kernel. Run NVIDIA’s original noisy portrait and compare CUDA with WGSL.
Run the shared-memory version of Sobel edge detection. CUDA lanes load a pixel tile together and write four packed output pixels per record.
Find edges in the original teapot image. The unchanged CUDA kernel reads a 3 × 3 neighbourhood and writes each pixel’s edge intensity.
Blur the original teapot image with a sliding window. The CUDA row and column passes share the intermediate image on the GPU.
Extract a triangle surface from NVIDIA’s original Bucky volume. Shared vertex pointers and surface normals stay on the GPU.
Build a mesh from the original implicit field. Classification, scans, compaction and triangle generation run on the GPU.
Filter the original Bucky volume and explore its slices. Compare voxel and upstream texture coordinates using the unchanged CUDA kernel.
Render Mandelbrot and Julia sets with NVIDIA’s original float kernel. Edit the viewport and colours, accumulate frames and compare CUDA with generated WGSL.
Smooth the original photograph while preserving colour boundaries. Run NVIDIA’s filter, edit its colour-distance setting and compare CUDA with generated WGSL.
Blur the original teapot image and amplify its highlights with NVIDIA’s CUDA kernel. Inspect RGBA texture sampling, shared-memory tiles and the generated WGSL.
Compare nearest, bilinear, bicubic, fast bicubic and Catmull–Rom sampling on the teapot image. Original CUDA filters, editable zoom and pan, and packed colour output.
Filter a teapot image with the original row and column kernels. Edit the 17 coefficients and compare both generated shaders; the intermediate image stays on the GPU.
The original simpleGL vertex kernel, unchanged. Orbit a moving surface of GPU-generated points.
The original tiled gravitational force and integration kernels. Watch 512 bodies evolve in 3D with position feedback entirely on the GPU.
A tiled 3D finite-difference stencil with configurable coefficients. Explore 8,192 interior field samples, colored directly from the GPU output.
Write the teapot image into a GPU surface, then sample it with the original rotation kernel. Both passes share the image entirely on the GPU.
Rotate the original teapot image with NVIDIA’s unchanged texture kernel. Edit the angle and compare nearest or linear sampling in the sandbox.
Ray-march the original Bucky volume using NVIDIA’s unchanged device code. Edit the camera, density and colour transfer table, then compare CUDA with generated WGSL.
Sample the original Bucky volume with a real 3D GPU texture. Choose a depth and compare point or linear filtering with wrapped coordinates.
Filter a colour image with the original recursive kernel and tiled transpose. Four GPU passes produce an RGBA preview with editable coefficients.
Decompose 4,096 signal values into coarse and detailed coefficients. Two original-kernel launches exchange coefficients directly on the GPU.
The original row and column kernels run in sequence. Keep the intermediate image on the GPU and compare the generated shader for each pass.
A GPU-resident particle simulation and live kernel workbench. Edit CUDA, inspect generated WGSL, and test the actual GPU.
No showcases match. Try another search or category.
The browser translates a supported subset of CUDA C into WGSL. Native comparisons use NVCC on an NVIDIA GPU. Each showcase explains its source, validation, and any host-side adaptation.