winapi-rs VS Windows Terminal

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.

> convince management of the value

This presupposes that such convincing is even possible. Many, many companies have leadership that are simply terrible at identifying value. If you've never been part of a majority of developers advocating for, if not outright begging for, some huge ROI initiative to get the green light, you are very fortunate.

There are great counterexamples, like Valve, which is known for giving developers an extreme degree of autonomy, and they benefit greatly from that approach. For each Valve, though, there are dozens of companies that manage to succeed despite themselves.

Take Microsoft, for example. One tiny, yet representative, example: the way the Windows Terminal team handled a suggestion from Casey Muratori to take their software from abysmally slow to lightning fast:

https://github.com/microsoft/terminal/issues/10362

A quote from one of the Terminal developers, dismissing the suggestion:

> I believe what you’re doing is describing something that might be considered an entire doctoral research project in performant terminal emulation as “extremely simple” somewhat combatively…

Just how difficult was such an endeavor in actuality? Well, given that Casey implemented his own terminal emulator from scratch and incorporated the functionality he was proposing in a mere weekend... not a whole lot. Relatively minor effort for a huge return on investment. It took Casey explaining the concepts, then providing a working proof of concept, and finally a bunch of backlash online towards the Terminal team to get them to do the right thing for themselves and their users.

At this point ConHost.exe is open source [0] so it is maybe not a stretch to expect Microsoft to open source CMD.EXE at some point.

Though with PowerShell being cross-platform and already open source, I personally don't think there's enough to gain in some sort of better open source CMD.EXE fork. I'd be interested in being proved wrong on that, but I'm also happy enough with PowerShell these days I'm not in a hurry to return to CMD.EXE.

[0] https://github.com/microsoft/terminal/tree/main/src/host

"Users of Linux and macOS may well be familiar with the sudo command, used regularly in the terminal, and it looks like Windows may finally be getting its own version."

More Linux tools are coming to Windows, especially Windows Server because the tools are good and they make it easier to administer a Windows Server.

They are looking at adding a default TUI text editor (https://github.com/microsoft/terminal/discussions/16440) and now they are adding sudo.

I would not be surprised if systemd or something like it gets ported or reinvented for Windows simply because it makes managing services so nice.

GitHub

>We are allowed to view and consume it, to be influenced by it, and under many circumstances even outright copy it.

People keep saying this but it's actually much more complicated, and in many cases you can't view copyrighted content.

An example, MicroSoft employees are not permitted to view or learn from an open source (GPL-2) terminal emulator:

https://github.com/microsoft/terminal/issues/10462#issuecomm...

Another example is proprietary software that may have it's source available, either intentionally or not. If you view this and then work on something related to it, like WINE for example, you are definitely at risk of being successfully sued.

If you worked at MicroSoft and worked on Windows, you would not be able to participate in WINE development at all without violating copyright.

If you viewed leaked Windows source code you also would not be able to participate in WINE development.

An interesting question that I have, is whether training on proprietary, non-trade-secret sources would be allowed. Something like unreal engine, where you can view the source but it's still proprietary.

Windows Terminal is pretty good and a new terminal emulator written in the last few years. No smooth scrolling, here's the GitHub issue requesting it: https://github.com/microsoft/terminal/issues/1400

Assume its related to this:

https://github.com/microsoft/terminal/issues/10362

It's nothing serious just microsoft engineers writing slow as shit code and reacting poorly to someone trying to help.

"There are plenty of offline scenarios where this would be incredibly useful. For disconnected environments, etc. There are some environments that will never connect to winget."

Source: https://github.com/microsoft/terminal/discussions/16440#disc...