rust-zmq VS winapi-rs

It depends how useful you think the patch is, and maybe also how likely you think it will get merged.

In most cases I simply keep my fork as a PR and use the package either by vendoring or directly from the repo. If anyone else encounters the same bug, they will see my PR referencing the issue, they can do the same.

If many people are encountering the bug and using the package, and/or if the project seems dead, then it's a good idea to publish. You can do username prefix or you can just add "2" at the end. I've seen this for other repos, This is what https://crates.io/crates/zmq2 did while https://crates.io/crates/zmq was inactive, though it seems like the latter's maintainer became active and merged what the former's maintainer had done.

I have been using https://crates.io/crates/zmq since 2015 (shortly after rust 1.0 was announced) in production with pub-sub, request-reply and router without any issue. Processes about 5k msg/seconds (mid-freq market data).

I learned a lot about sockets with the library ZeroMQ, although at that time I was using the Python version. This library also has a Rust library, although it doesn't look like the amazing guide about sockets allows you to select Rust as of yet. Still I would recommend going through this guide, as it is not just teaching you how to use a library, but also teaches you about sockets at a theoretical level. It's entertaining to read as well.

I think maybe the ZeroMQ rust crate as a case study is something that is non-trivial: https://github.com/erickt/rust-zmq

Vtables are pretty solved as well. I do a lot of Windows COM interop. Using the `windows` crate, vtables for COM interfaces are relegated to an implementation detail - instead you simply implement a (typically safe!) trait:

https://microsoft.github.io/windows-docs-rs/doc/windows/Win3...

Which can then be converted to a refcounted smart pointer:

https://microsoft.github.io/windows-docs-rs/doc/windows/Win3...

All driven by win32 sdk parsing and metadata.

But suppose we want to roll our own, because we tend to prefer `winapi` but it lacks definition. That's not too terrible either:

• https://github.com/MaulingMonkey/thindx-xaudio2/blob/master/...

• https://github.com/MaulingMonkey/thindx-xaudio2/blob/master/...

• https://github.com/MaulingMonkey/thindx-xaudio2/blob/master/...

I could more heavily lean on my macros ala `windows`, but I went the route of manual control for better doc comments, more explicit control of thread safety traits to match the existing C++ codebase, etc.

Is there some pointer casting? Yes. Is it annoying or likely to be what breaks? No. What is annoying?

• Stacked borrows and narrowing spatial provenance ( https://github.com/retep998/winapi-rs/issues/1025 - this can be "solved" by sticking to pointers ala `windows`, or by choosing a different provenance model like rustc might be doing?)

• Guarding against panics unwinding over an FFI boundary. This is at least being worked on, but remains unfinished ( https://rust-lang.github.io/rfcs/2945-c-unwind-abi.html )

• Edge case ABI weirdness specific to C++ methods ( https://devblogs.microsoft.com/oldnewthing/20220113-00/?p=10... , https://github.com/retep998/winapi-rs/issues/523 )

Is winapi = { version = "0.3.9", features = ["winuser"] } in [target.'cfg(windows)'.dependencies]? All the missing symbols are functions in module winapi::um::wincrypt (see https://docs.rs/winapi/0.3.9/winapi/um/wincrypt/index.html#functions ) and the crate's Git repo at https://github.com/retep998/winapi-rs contains all the import libs and export defs for the corresponding DLLs in directory x86_64. As crypt32.dll ships with windows by default, I think this is all that would be needed for building on a windows PC.

The std library provides the type c_void for FFI, which is an enum with two variants. Some libraries have their own version, winapi for example defines c_void as an enum with no variants, making it identical to !. Finally, whenever the std needs a pointer with no particular type, they tend to reach for *const (), see ptr::to_raw_parts.

This would be a community driven project for now but I have high hopes considering we already had projects like winapi and Trantect/winapi-rs.

Can't you choose to control what OS APIs you use if you use crates such as libc and winapi, or just directly using extern "C" { ... }/extern "system" { ... }, or even inline assembly for syscalls with llvm_asm! or asm!?

Thank you! For SDL2 access, we're using custom bindings over the sdl2-sys crate, along with custom bindings for OpenGL and Vulkan access, and the winapi crate for Direct3D 11 access (as well as access to a few Windows APIs).

What is the difference between the winapi crate and the windows crate? Are they the same thing, and is one better than the other?

Turns out OpenGL and Vulkan sometimes behave weirdly on Windows machines (some OpenGL drivers use a huge amount of CPU power and create unexpected sync points; I also ran into this very weird driver crash while testing our Vulkan-powered version of Outer Wonders which is scary), so we implemented Direct3D 11 support using the winapi crate, which was much of a relief (D3D11 is an ideal rendering API when it comes to supporting Windows because it allows you target hardware with Windows versions going as far back as Vista, and from my experience, Direct3D drivers have a more consistent and reliable behavior). We didn't have to bring significant changes to our abstraction layer to add Direct3D 11 support.