winsafe VS winlamb

Externally, you can write a lot of native Windows stuff in Rust already. Personally, I'm having a lot of fun with WinSafe.

If you had such problems (which I also had in the past), I'm really interested in you opinion about WinSafe, and if it could help you solving them.

If you're after a native Windows application, WinSafe may suit your needs.

As the author of WinSafe, I can say it's tedious sometimes, but it's often very challenging, because you have to translate crazy unsafe behaviors into Rust's ownership model. It's surely hard, but also very rewarding at the end.

As the author of the WinSafe lib, I wholeheartedly agree.

WinSafe says hello.

Currently I have a bunch of those Win32 iterators in WinSafe crate, and the stabilization of GATs will clean up a lot of the internal code. So this is really, really good news.

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

WinSafe implements the event methods in traits, and most of them are generated by macros due to similarity. The autocomplete is now working for them, so thank you very much.

You're lucky, I also wrote one.

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