I've been building reze-design, a web-native MMD scene composer. The part this sub might like: every material is a Blender-style node graph that's validated, compiled to WGSL, and hot-swapped onto the WebGPU render pipeline.

Editor is built on React Flow, the graph->WGSL compiler and the render engine is Reze Engine.

We're the team behind **ImmerShare**—**a tool built for 3D XR developers who need to share their work with clients or reviewers without the usual friction.**

**The problem we kept hearing:** 3D XR developers either send a huge zip file, pay for cloud GPU time, or ask clients to install something. None of these are great.

**What ImmerShare does:** you run your packaged build on your own PC, and it streams live to a browser link. The viewer just clicks — no install, no account needed on their end.

**Here's a video demo showing how Process Sharing works with a UE packaged build:** [**https://youtu.be/xg1EOxqO\\_Vo\*\*\](https://youtu.be/xg1EOxqO_Vo)

Free plan available. Happy to answer any questions about how it works technically.

(Disclosure: we're the ImmerShare team.)

Demo: https://stfurkan.github.io/bitgpu/examples/chat.html

Repo: https://github.com/stfurkan/bitgpu

bitgpu is a zero-dependency WebGPU runtime for 1-bit (binary-weight) LLMs. The models are PrismML's Bonsai family (1.7B/4B/8B, plus the 27B which is a Qwen3.5-style hybrid with linear attention), I built the runtime, not the models. Weights stream from Hugging Face once, then everything runs on your GPU. Nothing leaves the machine.

Happy to get your feedback. Also, if you can share your setup and tok/s for the model you selected, I appreciate. I am developing this on my machine but it'll be good to hear if it's working as expected on other systems.

I've been playing with spawning particles in Text or Image shape, which can yield some nice effects.

Link to DEMO

I have built what appears to be the first publicly documented, open-source AI-native game platform combining:

• A maintained Godot 4.7.1 WebGPU browser backend
• An authoritative Rust shared-world simulation with PostgreSQL persistence
• A real 3D mining, production, battle, and territory loop
• An agent-operable pipeline that can build, export, render, test, visually verify, package, and deploy the game to the web

The result is a browser-native, AAA-oriented game-platform foundation where AI agents are first-class developers, not merely assistants inside a human-operated editor.

Unity, Unreal, and stock Godot each provide pieces of this. I have not found another public platform that integrates the complete system: AI-native production, browser-native WebGPU rendering, and one authoritative persistent world.

Repo: https://github.com/lxsolutions/studio-foundation

https://goldenspiral.itch.io/forest-of-hollow-blood

MOBA template is opensource it is a part of matrix-engine-wgpu project.

Focus on mobile browsers/devices.

LIVE :
https://maximumroulette.com/apps/webgpu/examples.html?demo=31

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

NUI commander :
https://www.npmjs.com/package/nui-commander?activeTab=readme

Special thanks to

https://github.com/soundstep/magic-xylophone

It's an endless flying game

In my wgsl.run project, I've updated the playground to a studio. Now you can do the following:

• Compiler-backed Monaco editing with diagnostics, semantic tokens, hover, definitions, references, rename, completions, signature help, quick fixes, and formatting

• Reflection for entry points, resources, bind-group layouts, overrides, vertex attributes, color targets, and struct memory offsets/padding

• An invocation inspector powered by libwgsl’s N-lane CPU interpreter

• Data-race, divergence, NaN/Inf, buffer, and per-lane execution inspection

• Static roofline, memory-access, coalescing, bank-conflict, and occupancy analysis, plus WebGPU execution timing

• Optimizer findings for dead code, unused symbols, constant branches, loops, and repeated expressions, with a small set of safe automatic fixes

• WebGPU host-code generation for layouts, bind groups, buffers, struct packing, pipelines, and dispatch

• Direct render and compute execution through WebGPU, including storage-buffer readback and visualization

• Experimental WGSL-to-MSL output

• A kernel advisor that detects patterns such as matmul, attention, softmax, and layer normalization

• Multi-kernel pipeline visualization and local multi-file projects

Everything runs locally in the browser.

The Beast - New Example 31 (NUI controll scene)

Rehabilitated old nui-commander become new deps for matrix-engine-wgpu ref: https://www.npmjs.com/package/nui-commander?activeTab=readme

https://reddit.com/link/1uyuy9i/video/m8bgn9dwerdh1/player

Special thanks:

Romuald Quantin

https://github.com/soundstep/magic-xylophone

Live :

https://maximumroulette.com/apps/webgpu/examples.html?demo=31

Engine source:
https://github.com/zlatnaspirala/matrix-engine-wgpu

Found and root-caused a WebGPU compute correctness bug that had been corrupting Gemma inference on every NVIDIA Windows machine running Xenova's WebGPU kernels. Sharing here because the failure mode is relevant to anyone shipping subgroup code.

The shape that breaks: an unrolled tail that does a subgroup reduction, then a lane-divergent if (tid == 0u) { store }, then another reduction, with an earlier reduction result live across the store. On the Dawn D3D12 backend with NVIDIA (measured subgroup_size 32, workgroup 32, so not a wave-width issue), the bare subgroupAdd returns wrong sums. Same WGSL is correct on Metal. Spec-valid code, platform miscompile, somewhere in Tint -> HLSL 2021 -> DXC -> driver.

Narrowing that might interest this sub:

• An in-kernel probe exporting @builtin(subgroup_size) reads 32 inside the failing kernel, killing the ranged-adapter theory.
• Hoisting all reductions above the divergent stores fixes it with subgroupAdd untouched, so the trigger is the reduction sitting in the reconvergence region, not the instruction itself.
• The same ingredients inside a loop with uniform work between store and reduction do NOT reproduce. Only the unrolled, tightly interleaved tail fails. Loop back-edges seem to give the compiler the reconvergence points it needs.
• A 32-lane subgroupShuffleXor butterfly is immune and costs nothing measurable (213-223 tok/s coherent vs 218 corrupted stock).

Proof is a 60-line clean-room kernel, no model, that fails 20/20 trials on an RTX 5070 and passes with the butterfly. Runs in ~2 seconds in your browser if you want to add a data point (AMD/Intel on Windows and NVIDIA on Linux are untested):

Live reproducer: https://ar5en1c.github.io/gemma4-webgpu-nvidia-subgroup-fix/crbug-minimal-repro.html

Chromium bug (now with Chrome's GPU team): https://issues.chromium.org/issues/535116173

Repo with raw evidence, both reproducers, and a drop-in runtime guard that behavior-tests the machine at load: https://github.com/Ar5en1c/gemma4-webgpu-nvidia-subgroup-fix

Full write-up: https://ar5en1c.hashnode.dev/on-device-llm-nvidia-webgpu-subgroup-bug

Happy to go deeper on the A/B harness or the probe methodology.

[1.16.xx - 1.17.00]

https://youtu.be/I_CvN0mReFM?si=apgxfoW7Le1R4GcJ

https://youtu.be/a147GVe0Oe4?si=c9DDhvaILZ31ZtLf

- Added plugin 'player object' now only for FPShooter prototypes.

- Added zombie area (Hang3d series).

- removeKeyboard for FirstPerson Camera.

- Splat class + animator for colors also vertex positions.

- Visual scripting improvments in general + ai tool part.

- MediaPipe implemented (hand model) tested on android chrome.

- Test webRTC canvas capture to android TV main instance for recceiver android-tv-cast.js/html

- Added First person shooter example (hang3d series - the-beast-hang3d)

- Base Position class changes, added `translateByXYZ`

- Micro optimisation : define CulledRenderPass only if culling activated from begin.

- Adding MatrixTTS to export/import npm services

- Make npm services sync with 1.16.2

How to init networking for remote stream:

streamRender.net = new MatrixStream({

active: true,

domain: 'maximumroulette.com',

port: 2020,

sessionName: 'tv-beast',

resolution: '1920x1080',

isDataOnly: false,

streamRender: true // NEW FLAG

});

Main instance for zombie game :

let app = new MatrixEngineWGPU({

canvasSize: 'fullscreen',

fastRender: 0.95,

render: 'culling',

cullingRange: 1200,

dontUsePhysics: true,

MAX_SPOTLIGHTS: 1,

MAX_BONES: 0,

LOAD_AFTER_CLICK_MOBILE: true,

MOUSE_SENS: 0.005,

TOUCH_SENS: 0.01,

mainCameraParams: {

type: 'firstPersonCamera',

responseCoef: 1000

},

clearColor: {r: 0, b: 0, g: 0, a: 1}

}, () => {

...

})

New examples for mediapipe implementation

Mobile chrome passed. Nice work but still this feature is high CPU cost.

Unfinished job but posible : "Push math calc of mediapipe intro worker", "remove buildin webgl hand skeletal drawer and make own in domain of the beast engine".

New example for android tv cast (remote) render (same as cloud rendering):

Render source (Can be mobile but best way is desktop device run). I use standard engine networking (kurento/openvidu) for video streaming. In initial i replace webcam track with canvas capture stream, works perfect.

https://maximumroulette.com/apps/webgpu/examples.html?demo=29

AndroidTV browser link : https://maximumroulette.com/apps/webgpu/tv-10.html

Special attribute/credits for new parts:

- For Hang3d zombi template - objects are downloaded from:
  www.md2.sitters-electronics.nl
  Keep this "readme.md" file with files.

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

Live demo: https://maximumroulette.com/apps/webgpu/examples.html?demo=30

Sharing a project and the architecture behind it. The goal was to make a photoreal captured scene feel like opening a webpage rather than installing an app.

- Render: PlayCanvas 2.x on WebGPU.

- Delivery: scenes are far too large to hand the browser at once, so they stream in chunks across three module workers (fetch, decode, persist) with buffers transferred rather than copied.

- Warm cache: decoded chunks persist to OPFS via createSyncAccessHandle, keyed by content SHA-256, so repeat visits load from local disk.

- Physics: Rapier3D vehicle dynamics against the captured collision geometry.

- LOD and render-scale are gated on a device-tier check to keep weaker GPUs alive.

Happy to go deeper on any of it. It is a single-person proof of concept built over the last two or three months, and I am still fairly new to this, so critique is the point.

Live (WebGPU required): wascape.com

Having a conversation with AI about this .. i suspect it's hallucinating at me.

i've got chrome 1.49, wgpu ="*" in cargo .. i've tried all the permuations of setting the wgpu::Features::IMMEDIATES flag or not on device creation (AI tells me a story about chrome vs wgpu vs the underlying driver i'm to exhausted to recount... where if you do set the flag it confuses the driver which enables it by default or something along those lines .. some clash between what rust's wrapper expects or assumes and what the driver does or doesn't do) .. I can get it to compile a shader that uses var<immediates> but the calls to .set_immediates(..&[u8]) always return this error : ":9: IMMEDIATES feature must be enabled to call set_immediates"

Is anyone out there using immediates through wgpu in rust (or even in javascript) in the browser ? can you confirm or deny if it does or doesn't work? if it's some bleeding edge WIP that isn't quite enabled everywhere yet (again in the AI narative it's asked me to add a shader 'requires...' , then remove it again ..).

one suggestion AI had was to use the underlying javascript functoin to set immediates, bypassing the rust wrapper, but the fiddliness of that trips me over my patience threshold right this minute :/

Whats the story with these .. after doing a port from gl (it's a rust codebase) where I ended up with some hashing/caching system for buffers and groups for the last few stragglers of plain setuniforms.. I was enthusiastic to get these in to reduce the pressure on that system , but didn't have any luck getting it to actually run. is there an ETA on these being rolled out, am I just missing some settings or what ( I see that wgpu itself seems to have overlapping support for native the native vulkan concept and a lowest common denominator webgpu set with a rename happening along th way)

Over the past 18 months or so, I ported much of d3-geo to an end-to-end WebGPU compute shader pipeline. This includes:

• Arbitrary spherical rotation that works with any projection
• Greiner-Hormann-like spherical clipping
• Adaptive sampling of projection curvature

It directly ingests and manipulates a Vello scene encoding, with only a single data readback for robust buffer reallocation. Vello Classic then renders it completely in compute shaders as well.

Rough performance increase to d3-geo (Canvas) on the 1:10m, 1:50m, and 1:110m Natural Earth datasets rendered using an RTX 2070 Super + Ryzen 5 3600:

• 110m: ~3-4x
• 50m: ~8-9x
• 10m: ~13x (render output of d3-geo completely broken, Vello also chokes if not ~50% of the geometry is clipped)

As can be observed in the demo, there are still a lot of visual artifacts. These mostly come down to some fundamental limitations of WebGPU and/or the underlying GPU architectures, namely:

• No 64-bit support
• No dynamic memory allocation
• No support for recursion

I managed to work around some of these limitations, though it took far more time and effort than anticipated (Hofstadter’s Law holds true, after all).

In the future, I would like to try and move from geographic coordinates and spherical math to a 3D-Cartesian pipeline and use targeted f64 emulation via a float-float polyfill. Help with this would be greatly appreciated.

The overarching vision for this project is to bring the concept of Adaptive Composite Map Projections (https://berniejenny.info/demos/AdaptiveCompositeMapProjections/) by Bernhard Jenny to life in a vector renderer that can handle the level of detail people have come to expect of modern maps in real-time.

Note: Code will be published either once it is ready or if there seems to be enough interest and willingness to help 😊

i am trying to isolate a subject for a basic talking head clip but i don't have a green screen setup. i tried using capcut's auto cutout feature and it works okay for a few seconds, but the moment there is any fast hand movement or a shift in lighting the edges start tearing and looking super messy.

i just want a reliable mobile app or lightweight tool that actually handles edge detection decently without a massive learning curve or a giant watermark on the final export. i have heard mixed reviews about unscreen and videoleap but i don't want to waste time downloading a bunch of stuff if they all have the exact same issues.

edit: wanted to give a quick update because i ended up sticking with Capcut to remove the background from my videos and the edge detection is actually working great now.

first off, my bad for posting in the completely wrong sub since this is for a graphics api lol. but the comment about low light and motion blur making it impossible to key was totally right. once i fixed my desk setup and added better lighting, the hand movements stopped blurring and the auto cutout handled it perfectly without any jagged edges.