The Best of WebGPU in May 2025

May kicked off with a fluid simulation demo by Renaud Rohlinger, CTO at Utsubo, presented live for Expo 2025 in Osaka.

Unlike typical WebGPU water demos using SPH (Smoothed Particle Hydrodynamics, a common fluid simulation technique using particles), this version leverages the Material Point Method (MPM—a technique combining particles and grids for more realistic soft-body and fluid behavior) for improved particle handling, smoother motion, and realistic pressure-based reactions.

Renaud Rohlinger’s tweet highlights the use of the Three.js WebGPU renderer, which enables more lifelike rendering and interactive responsiveness, critical for high-footfall installations.

In a follow-up demo, you can see the system being stress-tested with high-density particle flows, achieving consistent frame rates directly in the browser.

This is one of the cleanest, most production-ready WebGPU physics simulations we’ve seen so far, and a strong candidate for WebGPU’s breakout moment in front of a mainstream audience.

You can check it out here: MPM Fluid Tweet

Later in the month, Renaud Rohlinger also teased a node-based authoring environment (a visual programming style where effects are built by connecting functional blocks) for live media processing, built entirely with WebGPU. While at first glance it looks like another visual patching tool, what sets it apart is its role as a bridge between creative platforms, not limited to just an isolated toy.

The tool can export or stream GPU-processed outputs to external apps like TouchDesigner, Notch, and Unreal (professional tools for creating visuals, performances, and games). This makes it act as a sort of connective tissue across the creative installation ecosystem.

Imagine prototyping your video effects in-browser, then immediately sending them to a Notch-based media server or TouchDesigner-led show-control system without needing redundant pipelines or native builds.

This kind of cross-app GPU interoperability—the ability to share GPU outputs across software tools—is rarely seen in browser-based tools and hints at a future where the web plays an active role in real-time performance setups, not just as a display layer but as a modular GPU node within larger, more complex systems.

Watch the preview: Node Editor Preview

Lisyarus returned this month with a new Life Particle Simulation running fully on WebGPU. While simple on the surface, the simulation showcases a major strength of the API: managing hundreds of thousands of particles in real time without compromising frame rate.

In this demo, each particle behaves autonomously using attraction and repulsion rules (inspired by emergent behavior systems like flocking, swarming, or reaction-diffusion models). Thanks to WebGPU’s parallel compute capabilities, the number of agents is vastly higher than what you’d achieve in WebGL or Canvas.

This simulation isn’t just about pretty visuals; it’s a performance statement. Browser-based GPU compute has reached the level where these emergent systems can be rendered and simulated interactively—and even be ported to game tools, scientific modeling, or live art setups.

View the demo: Shallow Water Demo

In parallel, Mustafa Ali posted a hands-on preview of a graph editor (a visual tool that lets you build and edit systems using nodes and connections, like a flowchart) built on top of Three.js’s WebGPU path. It lets users design shader logic (small GPU programs that control how visuals look or behave) visually, using a patch-based interface that compiles directly into GPU-executable code.

The example showcases dynamic animations and lighting changes that respond to user-modified graph structures, demonstrating not just node-based logic but real-time feedback that’s critical for modern creative workflows.

This work follows the trend of visual programming in creative coding and could evolve into a modular editor for motion design, VFX prototyping, or shader education. Since Three.js already supports a growing ecosystem of WebGPU-powered features, this kind of tool might one day be bundled with the framework itself, or serve as a standalone playground for shader logic testing.

It’s also noteworthy that the design mirrors other tools popping up across the WebGPU space, suggesting a design language for GPU graph editors may be slowly crystallizing.

Watch the preview: Node Editor Preview

Holtsetio shared a visually striking WebGPU demo featuring procedural motion and compute-driven effects in the browser. The simulation showcases smooth real-time particle dynamics rendered with a minimal, elegant UI overlay.

While there isn’t a direct technical breakdown yet, the video highlights a polished UI and smooth simulation response. The graph resembles those seen in game engines or shader editors, suggesting a future WebGPU-based authoring app for procedural motion, fluid-like behavior, or custom visual logics.

The project is still in early stages, but the interface and real-time visuals already make it one of the most promising entries in the growing wave of node-first GPU playgrounds.

Check it out: Demo Tweet

Xenova continues their mission to bring AI model inference (when an AI model makes predictions from data) to the browser, and their latest update shows real promise.

Their new transformer engine (a powerful type of AI model for understanding language and images) runs inference directly with WebGPU, handling vision-language tasks on-device. In their latest benchmark, inference speed reached over 60 tokens/sec in-browser without cloud dependencies.

With efforts like Janus Pro and SmolVLM in past months, this builds on a broader trend: local-first AI made possible by WebGPU’s compute shaders and efficient memory usage.

Try it in your browser

Pablo Stanley introduced a browser-based playground that applies old-school visual effects—like halftone patterns, noise, and other non-AI filters—to images using WebGPU. This project highlights how WebGPU can be utilized for creative, real-time image processing directly in the browser.

While the demo doesn't delve into complex simulations or 3D animations, it effectively demonstrates WebGPU's capability to handle intricate visual transformations efficiently. This tool serves as a testament to the potential of WebGPU in enhancing web-based creative applications.

Check out the video here: Demo Video

May has given us a glimpse of what WebGPU can deliver not just for coders, but for performers, artists, and installation designers. From MPM-based water simulations to modular media tools and node-first shader workflows, the platform is expanding beyond performance into expressiveness.

The tools highlighted this month suggest that WebGPU is no longer a niche developer feature; it’s fast becoming a canvas for creativity. If you’re building something with WebGPU, drop us a message—we’re always on the lookout for next month’s highlights.