winsafe-examples VS winlamb

You might be interested in winsafe. There are a few examples how it can be used without unsafe code.

If you think this is nuts, just wait until you find out that people are writing high level, native desktop applications in pure Rust!

The easy path is just to build your structs normally, letting the burden of Rc/Arcing everything to the user. My first design was like this. Once I decided to bury this stuff inside the library, then my headaches began. But the API ends up being very ergonomic.

For example, a button click, where self.wnd is the parent window, looks like this:

Well, I can't really say it's new, but I'm working on a safe GUI API for native Win32 applications, where you can draw the windows using a WYSIWYG resource editor, like this example. And I'm having a lot of fun with it.

The first thing that came into my mind was: why not simply go fully native, with the aid of something like WinLamb? Often you can roll your own custom controls quicker than a cross-platform library.

I write C++ and raw Win32 for more than 20 years. I'm the author of this, and I'm rewriting my personal stuff in Rust just for fun.

I wrote a very thin C++11 wrapper for Win32 a few years ago, in case you're interested: WinLamb. It won't do everything, it just covers window creation and messaging, and leaves room to plug any other Win32 stuff on top of it.

Given my C++ Win32 background, the very first thing I tried was to write a native Win32 GUI app in Rust. It later became the WinSafe crate, which is strikingly similar to WinLamb C++ lib. The Rust experience was awesome. The correctness of the type system was something I really appreciated, things C++ cannot give you.

I write native Windows stuff sometimes, and I use Windigo, which I wrote based on my WinLamb C++ lib. It's a GUI system over raw Win32, so this has the disadvantage that you'll have to learn some Win32... but it has the advantage that you have the unleashed power of Win32 at your fingertips.

I used this pattern in my C++ lib, and I just translated it to Rust idioms. The trickiest part is working under Rust's ownership system – the borrow checker is really unforgiving.

There's a low level wrapper, and on top of the wrapper there's a new API to use native controls and create custom windows (the gui module). It was based on WinLamb, which is a C++ lib.

Today I have a bunch of native Win32 applications, all C++, most of them slowly incorporating C++17 features. Some of them are built upon WinLamb library. Some of them are 20 years old, packed with all sorts of tricks. (I think I can be considered one of those "old Win32 dinosaurs".)