I’ve been working on a proof-of-concept in #Rust to check if my dream #GameEngine is feasible for me to put together. You know, the one that’s supposed to support multiplayer runtime modding of the game you’re playing?
I mean, ideally, I’d get some help and input, because I’m really not that experienced in the end.
Putting together a document of “here’s what I want to achieve and what I feel like are open questions” to get people interested is really not my strong part, so the PoC is currently my way of pushing my ideas forward.
- There’s a good chance the compiler itself will be able to run in the #WASM sandbox itself in the future. Which I feel like will be important.
- Its meta-programming really helps with writing a clean API where some heavy-lifting is done by the compiler. Such as analyzing the script file and deciding whether to register a component and/or system for a particular script entity.
I feel like it would be nice to compile this for the web too. #WebGPU sounds interesting, gotta look into it more. Imagine inviting friends to games by just linking them to a web page?
I’m not sure if there’s a lot to share yet, but you could go over to @copygirl to check screenshots. (Or heck, even catch one of my streams.)
2000 non instanced #webgpu meshes. Not too bad for my poor mid-tier 2018 laptop.
Since I think I reached the point where I can no longer manually calculate my struct/uniforms, I decided to try incorporate
@greggman's webgpu-utils into my code because why not but after checking out his code and other dependencies (WgslReflect) the code is 3560 of extra lines, while my library is around 1682.
I honestly thought this would just be like a couple of functions and not a behemoth 😂
I've already made a change that as always, it means it breaks every example and I have to fix them all. This after I decided to not use a branch that had a lot of changes related to uniforms that I made months ago. My uniforms are f32 only and I want to make them work with more data types, but I can't recall anything, so I have to review the storage creation process to understand what's going on.
Happy (US) Thanksgiving, y'all! I prepared a tasty article all about using #WebGPU Render Bundles, just for you! https://toji.dev/webgpu-best-practices/render-bundles
Heyo, Unity has added early access to a WebGPU backend.
Mandelbrot in #WebGPU
from an old demo made in the previous version of my library, I just ported it to WebGPU. Actually a very easy port.
#generativeart #creativecoding #genart #webgl
#abstract #abstractart #digitalart #vaporwave #vaporwaveart
#shader #glsl #p5js #processing
#wgsl #computeshader #cgi #mandelbrot #fractal
I think for next year I want to try setting up a realtime render version of the same effect (#WebGPU, naturally!) So that I can puppeteer them. I saw several little kids trying to talk to the pumpkins this year, and it would be a lot of fun if they could talk back!
Here are the release notes for #WebGPU in Chromium 119: https://developer.chrome.com/blog/new-in-webgpu-119/
Filterable 32-bit float textures, unorm10-10-10-2 vertex format, and rgb10a2uint texture format and more! We have a much awaited extension that starts with an f and ends with a 16 in the next release :)
New version of **rio terminal** supports Alacritty's Vi mode! 🚀
🦀 A hardware-accelerated GPU terminal emulator powered by WebGPU. (written in Rust)
⭐ GitHub: https://github.com/raphamorim/rio
Chrome M120 (stable in late November) will turn on 'shader-f16' by default in #WebGPU, for hardware that supports it.
This includes all macOS and many Windows devices.
This was a great collaboration with the rest our WebGPU partners at W3C and particularly Intel, who championed its standardization, implementation, and conformance-test-writing.
Working on adding all kind of examples to my incoming wip gpu-curtains lib.
This one is demonstrating the use of custom instanced geometries & attributes.
Having a benchmark sure seems key for #WebGPU work.
I was surprised when seemingly trivial wgsl changes caused things to slow down by 15%.. not sure why. But at least the benchmark caught it.
Tweaked the #WebGPU reduceTexture shader a bit.
It takes less than 1ms to find the maximum value for an 8K/8K image. So, fast enough that you can feel free to use min/max color as part of your video processing algorithm.
This doesn't look like much, but it took me quite some time to achieve. #webgpu compute pass + mesh instancing.
All done with my work in progress gpu-curtains lib.
François Beaufort discusses the transition from WebGL to WebGPU, highlighting key differences between the two technologies, including state management, asynchronous operations, the introduction of compute shaders, video frame processing capabilities, and more
Here are the release notes for #WebGPU in Chromium 118: https://developer.chrome.com/blog/new-in-webgpu-118/
We have easier uploads of ImageData and HTMLImageElement to textures, experimental support for the long awaited read-write storage textures, a DawnInfo program, and the usual slew of improvements and bugfixes!
I built a demo in #bevyengine . With all features enabled (the default) it came out to 30mb.With some light work it came down to 7mb. (wasm-bindgen, wasm-opt, some flags, only 2d-related features).
I'm looking to build some demos for blog posts, and its looking like webgpu-only wgpu is the best size-route forward.
Heyo, new blog post "From WebGL to WebGPU".
It highlights key differences between the to web graphics APIs. It's meant to give a flavour. I found it interesting. Take a look.
Hey folks! we’re hiring!
We’re an early stage startup working to build the #spatailweb
We understand that this is a new space, so we encourage everyone to apply regardless of #xr experience. We want a strong engineer first, XR experience is just a plus.
Kind of perplexing how Apple has treated #WebGPU. To have it in Safari Technology Preview and then pull it without replacement for quite some time now both makes forward looking development harder, and sends a pretty negative signal regarding future availability.
Servo’s got #WebGPU working and some demos running now.
FYI. The #WebGPU samples have been growing.
Yesterday a camera-control sample was added https://webgpu.github.io/webgpu-samples/samples/cameras
And before that an example showing how to use a web worker to render but then display the canvas on the main thread.
All three were running full-screen and configured to use the same font and approximately the same point size (11.0).
Wezterm was built from sources using "cargo build --release". The other two are distro binaries from #Fedora Rawhide.
Note that Wezterm (the slowest of the three) has a gradient background). It's also a git snapshot that recently switched its default rendering backend to #WebGPU.
Sadly, and frustratingly, implementations don't do what programmers think should happen. We are seeing very very nonportable behavior.
Still collecting data across devices and platforms that we will share soon enough.
Here are the release notes for #WebGPU in Chromium 117: https://developer.chrome.com/en/blog/new-in-webgpu-117/
Standing out among the small features and fixes are a fix for the caching of pipeline with implicit layouts so that pages using them should now start much quicker! (after the first load)
Thnking about the list of things needed to get my game running on linux, it's a very short list and would probably just about work out of the box.
This got me thinking about WASM though... I think SDL2 can be compiled with Emscripten and ImGui has an experimental WebGPU backend already working. Might just work??
Anyone had any experience getting an OpenGL/SDL2 C++ app running in a browser?
Not sure if I'm going to take it any further, but I find it's therapeutic to take some small chunk of older code and redo it with all the accumulated tooling and experience you've gained since.
Added a page to the #WebGPU samples demonstrating use in a web worker. (Spoiler alert: It's basically the same as WebGPU on the main thread, with a couple of extra postMessage() calls) https://webgpu.github.io/webgpu-samples/samples/worker
My colleague François Beaufort just published a good article about building #WebGPU apps targeting native C++ and the web with a single codebase.
maplibre-rs is a portable and performant vector maps renderer, which aims to support Web, mobile and desktop applications. It is written in Rust, and uses WebGPU.
An academic paper has been published, https://isprs-archives.copernicus.org/articles/XLVIII-4-W1-2022/35/2022/ _maplibre-rs: toward portable map renderers_.
It targets the Web via WebAssembly, and other platforms via FFI. Rust is used as a Lingua-franka on all platforms.