ui-mock VS arewegameyet

It's quite possible to develop Rust for Windows without using Windows.

Try my open source "ui-mock".[1] This is a test of the cross-platform stack. Just get the repository with "git clone", and make sure you have Rust installed for target "x86_64-pc-windows-gnu". See the Cargo.toml file for build instructions.

This is a game-type user interface. It's just some menus and a 3D cube. It doesn't do much, but it exercises all the lower levels. This allows debugging cross-platform problems in a simple environment. The main crates used are winit (cross-plaform window event handling), wgpu (cross-plaform GPU handling), rfd (cross-platform file dialogs), keychain (cross-platform password storage), egui (Rust-native menus and dialogs), and rend3 (safe interface to wgpu). For graphics, it uses Vulkan, so it will run on Windows back to the last release of Windows 7. Not Windows 95, though; it's 64-bit. It will also run under Wine, so you don't even need a Windows system to test.

My metaverse client uses the same stack. It's compiled on Linux, and runs on both Linux and Windows. So I'm building a high-performance 3D graphics program for Windows without even owning a Windows system or using any Microsoft software.

[1] https://github.com/John-Nagle/ui-mock

Profiling on the CPU side is well handled by tracy, which is a game-oriented profiler. My programs render-bench and ui-mock are prepped for Tracy, as is Rend3, so you can try it out on them.

ui-mock -- game GUI test fixture This exercises rfd->egui->rend3->wgpu. It's a game GUI with menus and dialogs, but no game behind it, just a 3D drawing of a cube. It's useful for making bugs in that stack repeatable. That's been helpful in wringing out obscure bugs in egui.

Egui works well with Rend3. Here's my example and library for that. It's a dummy game UI; no game, but brings up menus atop Rend3 3D. Egui is very low level. Each dialog takes a lot of code. Something to generate dialogs from some kind of template would be useful. I have many of those to do. Incidentally, does anyone have examples of good color themes for egui? The default is shades of black on black, which is a bit harsh. I'd like to see some examples where the aesthetics are better.

There's an attempt to make this work for Rust desktop applications. There's the winit crate, which does cross-platform windowing and event loops. There's egui, for menus and subwindows. There's rfd, for file dialogs, which are special for security reasons. And there's wgpu, for cross-platform 3D.

I'm using all of these in my ui-mock,[1] which is a GUI for a game without the game. It has 3D graphics with 2D GUI elements on top. I'm using this to shake down all the cross-platform problems for my metaverse client. My own code, which is 100% safe Rust, has no platform dependent code.

Results are pretty good. There's minor dirty laundry in those libraries, which has been reported to the various maintainers. Stuff like this:

- You can get a file dialog hidden behind the main window, which, in a full screen program, is a real problem. Mostly a Linux problem; works fine on Windows.

- Full screen on Windows mode under Wine 7 crashes Wine. Known Wine bug.

- Warnings from WGPU, but it works around all of them with some minor performance loss.

- Cross-platform packaging, to make a Windows installer without Windows, isn't implemented yet.

So, not big stuff. A lot of stuff works that you might not expect to work, such as profiling with tracy. Wgpu is taking care of Vulkan vs Apple's Metal. (Apple just had to Think Different, to the annoyance of everybody doing 3D.) Opening a web page in the default browser is cross-platform. You can cross-compile - I build the Windows version on Linux, without using any Microsoft tools.

With some more work, I could make this work on WASM and Android as well, but that requires some special casing, mostly because WASM doesn't have proper threads.

So cross-platform desktop development is working pretty well. Most of the problems I'm running into would not appear in a more typical application.

[1] https://github.com/John-Nagle/ui-mock

I have a Rend3/Egui/WGPU program, https://github.com/John-Nagle/ui-mock

arewegameyet

"While the ecosystem is still very young, you can find enough libraries and game engines to sink your teeth into doing some slightly experimental gamedev."

I think Rust for games has come really far. I will cite https://arewegameyet.rs/ "Almost. We have the blocks, bring your own glue.".

All the blocks are there and the language is really well suited to games.

On top of my head:

The pros:

- The crate ecosystem and the package manager makes it really easy to integrate any useful component such as pathfinding, spatial partitioning, graphics backend, audio system.. Most crates take a lot of effort to be cross-platform so I can develop on linux and not spend too much time debugging windows releases.

- The strong typing and algebraic data types makes expressing the game state very pleasant. I also found I was able to develop a very big game without too many bugs even though I don't write many tests.

- Ahead of time compilation + LLVM guarantees you won't have to optimise for weird things around a virtual machine. Rust gives you more control to optimise hot loops as you can go low-level.

- I find wgpu to be the perfect balance between ergonomics and power compared to Vulkan. OpenGL support through wgpu is also a nice addition for lower end devices.

- The Rust community is very helpful, you can often talk directly to crate maintainers

The cons:

- Compilation times, when compared to JITed languages such as C# can be very painful. It can be alleviated by buying a 3950X but I still often get 10-30s iteration times.

- The static nature of Rust means you often need a dynamism layer above to tweak stuff that can be awkward to manage. I made inline_tweak for this purpose but it's really far from how easy Unity makes it. https://github.com/Uriopass/inline_tweak

- Since Rust feels very ergonomic, you are tempted to write almost all game logic within it, so mod support feels very backwards to implement as you cannot really tweak "everything" like in Unity games. Thankfully "Systems" game like Factorio or Egregoria can be theoretically split into the "simulation" and the "entities" so mod can still have a great impact. Factorio is built in C++ so has the same problematic. Their Lua API surface is quite insane to be able to hook into everything. https://lua-api.factorio.com/latest/

Now, I have to talk about Bevy: https://bevyengine.org/. It did not exist when I started but it is a revolution in the Rust gamedev space. It is a very powerful 100% Rust game engine that makes you write game code in Rust too. It has incredible energy behind it and I feel like if I'd used Bevy from the start I wouldn't have had to develop many core engine systems. Its modular design is also incredibly pleasant as you can just replace any part you don't like with your own.

For practical uses of Rust? Whatever you want to program. People use Rust for game development, GUIs, web dev, and more. Anything where abstraction, speed, concurrency, memory safety, etc. are important, Rust will probably be a good fit.

Are we game yet? "Almost. We have the blocks, bring your own glue"

Not seeing anything else that's close to photo realistic. I'm hitting the tough bugs first all too often. More than half my time has been spent on ecosystem problems.

I also know of https://arewegameyet.rs/

Yes — and in fact, Firefox's implementation has been the go-to graphics API for folks trying to make Rust gamedev happen for a long time now. Bevy Engine's renderer is built on it, for example.

They're all/mostly websites about the state of the Rust language ecosystem. For example, can you write games in Rust (https://arewegameyet.rs/) or what's the state of the async (https://areweasyncyet.rs/)