learn-wgpu VS glium

> Of course evidence continues to build that no tooling or coding practice eliminates the risk here

Concidering Rust is just tooling and coding practice in front of LLVM IR does this statement not also include Rust? There are in fact formally verified C and C++ programs, does that formal verification also count as tooling and coding practice and therefore not apply?

If either of the above is true why does it matter at all?

I am specifically calling out your blanket statement and want to open uo discussion about it because at present your implied point was it is impossible to write safe code in C/C++ and it is only possible in Rust, however the very point you made would also apply to Rust.

There are also non-safety issues that may affect the integrity of a program. I recently again looked into Rust, haven't given up just yet but to just instantiate a WGPU project the amount of incidental complexity is mind boggling. I haven't explored OpenGL but concidering that the unofficial webgpu guide for rust [1] recommends using an older version of winit because the current version would require significant rewrites due to API changes is not encouraging. Never mind the massive incidental complexity of needing an async runtime for webgpu itself, is this a pattern I am going to see in different parts of Rust. Rust already has enough complexity without injecting coroutines in places where blocking functions are reasonable.

1. https://sotrh.github.io/learn-wgpu/#what-is-wgpu

https://sotrh.github.io/learn-wgpu/

Wgpu is a Rust-based library that takes a similiar general API shape as Vulkan but is simplified. When I first tried to learn Vulkan I found the complication to be overwhelming (primarily because there are no defaults for ANYTHING) but once I learned wgpu it was substantially less so. It is still quite complicated though.

Wgpu is aiming to be almost as powerful as Vulkan, but it's not there yet because the features that are needed to do the modern techniques that make Vulkan really good (as compared to opengl) either aren't there yet or are so bug-ridden as to not be usable in practice yet.

It has some ability to run in a web browser, probably with JS, too, but I'm unfamiliar with the details there.

Nice.

Speaking of Snake game, if you want to go even deeper, you can try to use the wgpu crate to combine Rust and WebGPU to write everything from scratch. Here is the tutorial:

https://sotrh.github.io/learn-wgpu/#what-is-wgpu

I once wrote a code editor with wgpu, from font rendering to char/line state management (very rough) for music live coding:

https://github.com/glicol/glicol-wgpu

It runs in browsers, even including Safari!

https://sotrh.github.io/learn-wgpu/ This is probably the best resource out there for learning wgpu specifically. If you're unfamiliar with graphics, the learnopengl one is good. If you've got experience though, jumping right into that one is a shout or looking at some vulkan ones as they're pretty similar in terms of architecture.

- https://sotrh.github.io/learn-wgpu

Most of The WGPU I learnt is from https://sotrh.github.io/learn-wgpu/ but it doesn't really talk about designing n stuff, I thought of checking out the source code for Bevy or even games like veloren. But well, their codebases are pretty big to get started in the first place.

I am trying to follow to this tutorial on glium and I can't even get a window to show up because of what I assume to be a lack of comprehension on my end about how dependencies work.

Which is blocked, waiting for glium to update: https://github.com/glium/glium/pull/2036

https://crates.io/crates/glium (8 months ago - 925 kB)

The book is a great place to look at https://github.com/glium/glium/tree/master/book And glium itself is a bit outdated might be good to look at alternatives like glow

Hi rustaceans! I glued this prototype together with vtkio and glium. There are more features that are unsupported than supported at this point, but the code is here if you want to check it out: https://github.com/JeffIrwin/skillet

https://github.com/glium/glium/issues/941 is the relevant Glium bug/feature request. Long story short, structs as uniforms aren't supported by Glium's current design, it looks like.

Should i learn glium (https://crates.io/crates/glium)? i have some experience in opengl (C++) and i would like to use the opengl functionality in the Rust ecosystem.

I can recommend https://github.com/glium/glium as a good, safe abstraction. There was a time when I wanted to learn shaders and write complex pipelines with several stages, this library allowed me to learn about the important objects and their responsibilities without having to program the very verbose chunks of code to initialize. I learned the following:

Glium is a Rust-y OpenGL wrapper, and its repository contains a discussion that should give you an idea whether this is what you want to use, as well as some tutorial.

With a gluim window open, I want to count the number of user clicks and retain the number after the window is closed. In order to keep the program running after the window is closed, I had to change event_loop.run to event_loop.run_return and I think that means all variables will be moved into the closure and my counter goes out of scope.