learn-wgpu VS winit

> 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.

> Is this something Flutter doesn't do?

Flutter does do this (at least to some extent) on Desktop/Mobile. It attempts to create a hidden DOM tree for accessibility on web. Which generally doesn't seem to be thought to work very well.

> One of the most jarring experiences I have with Flutter Desktop was it lacked MacOS Emacs-style key bindings for text editing (ctrl-a, ctrl-e, etc.). Not sure if Dioxus solved this?

Ah, we're nearly there on that one. We have a PR [0] accepted into Winit (the underlying windowing library we use) which will allow us to access those events. We're just waiting on Winit to do a new release and then we can integrate it into Dioxus.

[0]: https://github.com/rust-windowing/winit/pull/3824)

Hi! I’m Aloke, an engineer at Warp.

I’m really excited to share that Warp is now available on Linux! If you’re interested in trying it out, you can download Warp: https://warp.dev/

Building Warp on Linux was quite an undertaking. Warp uses a custom Rust-based UI framework that we built in house and renders natively on the GPU. To get Warp running on Linux, we built a version of our UI framework that supports winit [1] as a windowing backend. We also built a version of our renderer that uses wgpu [2]. Reducing complexity by using these well-supported, cross platform, frameworks let us bootstrap a version of Linux quicker than expected and should make it easier to build Warp for other platforms (like Windows).

Please let me know what you think! Happy to answer any questions, either about the product or about technical challenges.

[1] https://github.com/rust-windowing/winit

This link: https://github.com/rust-windowing/winit has this code:

Have you seen the official example?

That's a bit shortsighted given that there is an active discussion about reducing the interior mutability.

I really need a file dialog for my ImGui-based project in Rust. I tried using this crate but it's wayyyyyyy too old. I also saw this but considering the date it was last updated and the look of the repo, it's not gonna work either. Also I maintain my own library for such things, but it's currently blocked by this issue. What options do I have?

In this case, I used the "A"GPL because this crate could feasibly run on the web. winit has a web backend. At the moment I don't support it (there's a PR that needs to land first), but in the near future it's not implausible that this crate could be used in a web environment.