cuda-api-wrappers VS wxWidgets

1. This implements the clunky C-ish API; there's also the Modern-C++ API wrappers, with automatic error checking, RAII resource control etc.; see: https://github.com/eyalroz/cuda-api-wrappers (due disclosure: I'm the author)

2. Implementing the _runtime_ API is not the right choice; it's important to implement the _driver_ API, otherwise you can't isolate contexts, dynamically add newly-compiled JIT kernels via modules etc.

3. This is less than 3000 lines of code. Wrapping all of the core CUDA APIs (driver, runtime, NVTX, JIT compilation of CUDA-C++ and of PTX) took me > 14,000 LoC.

> since the underlying API's are still C/C++,

If the use of GPUs is via CUDA, there are my https://github.com/eyalroz/cuda-api-wrappers/ which are RAII/CADRe, and therefore less unsafe. And on the Rust side - don't you need a bunch of unsafe code in the library enabling GPU support?

Given your criteria, you might want to consider (modern) C++.

* Fast - in many cases faster than Rust, although the difference is inconsequential relative to Python-to-Rust improvement I guess.

* _Really_ utilize CUDA, OpenCL, Vulcan etc. Specifically, Rust GPU is limited in its supported features, see: https://github.com/Rust-GPU/Rust-CUDA/blob/master/guide/src/... ...

* Host-side use of CUDA is at least as nice, and probably nicer, than what you'll get with Rust. That is, provided you use my own Modern C++ wrappers for the CUDA APIs: https://github.com/eyalroz/cuda-api-wrappers/ :-) ... sorry for the shameless self-plug.

* ... which brings me to another point: Richer offering of libraries for various needs than Rust, for you to possibly utilize.

* Easier to share than Rust. A target system is less likely to have an appropriate version of Rust and the surrounding ecosystem.

There are downsides, of course, but I was just applying your criteria.

https://github.com/eyalroz/cuda-api-wrappers

I try to address these and some other issues.

We should also remember that NVIDIA artificially prevents its profiling tools from supporting OpenCL kernels - with no good reason.

On the host side however - the API you use to orchestrate execution of kernels on GPUs, data transfers etc. - the official API is very C'ish, annoying and confusing. I have written C++'ish wrappers for it which many enjoy but are of course not officially supported or endorsed: https://github.com/eyalroz/cuda-api-wrappers

Oh, I really wish those hackers would release the sources rather than pursue their dumbass crypto-mining demands... "We decided to help mining and gaming community" - hurting the gaming community, helping the get-rich-quick "community".

My own C++ wrappers for the CUDA APIs (shameless self-plug: https://github.com/eyalroz/cuda-api-wrappers/) would really benefit a lot from behind-the-curtains access to the driver; and even if I just know how the internal logic of the driver and the runtime works, without actually being able to hook into that logic - I would already be able to leverage this somewhat in my design considerations.

As a person making a living from being the "GPU guy" - I definitely agree.

The ecosystem around AMD GPUs is quite small - and now that they seem to have abandoned OpenCL (possibly not their own fault though) - even that is put into question.

But things are bad even on the NVIDIA side. Example of how bad: I had to write my own C++ bindings for the CUDA runtime API (https://github.com/eyalroz/cuda-api-wrappers/). You'd think they would have that after 13 years of CUDA being available, right? Wrong. I repeatedly tried to pitch this to them, but they seem to suffer from the "Not Invented Here" syndrome (https://learnosity.com/not-invented-here-syndrome-explained/). This despite me having a lot of respect for people like Mark Harris, Bryce Lelbach, Duane Merrill et alia, and their work.

You're also rights about the "two kinds of brains" - or rather, it's not clear to me that the brains creating the silicon and the brains creating the software are in close enough cooperation.

By the way - it is possible to extract a pretty distribution of CUDA to justify run 20 lines of GPGPU code, from their installer. But they won't be bothered to package this nicely for you.

Try Vulcan, or OpenCL. There are tons of wrappers for CUDA to make coding simpler ie https://github.com/eyalroz/cuda-api-wrappers

The Elixir programming language is no stranger to desktop applications as the language actually supports building them out of the box. It uses wxWidgets: a C++ library that lets developers create applications for Windows, macOS, Linux and other platforms with a single code base. But wxWidgets has a very complex API, and doesn’t solve issues that usually come with desktop applications around packaging.

Qt is also 100% open/free. In fact, both are available under the LGPL, just that wxWidgets also grants an exception to not have to distribute application sources even when statically linked:

https://github.com/wxWidgets/wxWidgets#licence

But for big programs, ones written in C++? Good luck it won’t be easy at all. You might try wxwidgets or qt. I do not predict trying to click box-ify complex cli tools yielding much success.

In theory, you should be able to use FFI to interface with something like wxWindows, but you might again have problems on macOS, I don't know. And to me eyes, Wx looks a bit outdated.

This seems to be like the classic wxWidgets [1], i.e. it's an API that wraps the underlying platform's default toolkit. So on Windows it uses Windows' native controls, in Linux it seems to use GTK, and so on.

That means that the advantage is being able to write against one API, and get cross-platform compatibility, which can be nice. It also means (typically) being limited in what you can do to the least common denominator, or you (=the toolkit author) end up having to re-implement features from one platform that you want to expose but that are missing on some supported target(s). Or, of course, have an API with non-portable parts in it.

In any case, it means the "look and feel" is not the core feature of the API since that is going to be "like the target platform" and that is the point.

Given the origin, I guess Lua support is important too, here.

[1]: https://www.wxwidgets.org/

- So, I found wxWidgets. Which looked good. However, when I followed some tutorials I was getting errors. Even when I copied and pasted the tutorial code. Furthermore, the library still doesn't seem to simplify the process much.

It is the icon for WXWidgets, a programming toolkit for making user interfaces that work on Windows, Mac OS and Linux.

In general, people will use a cross-platform library to port such applications. While QT will likely never really stabilize (I'd flag it unsustainable), the https://www.wxwidgets.org/ is able to be statically linked into commercial and opensource projects at no cost without tripping GPL.

"Hiring a senior C++ developer with GTK experience is costlier"

I think you are confusing skill valuation, and operational productivity. Some have an erroneous notion talent is interchangeable. Likewise, applicants with identical base skill-sets on their CV often mistakenly believe they even have long-term employment options (outsourced, youth tax credit churn, and or senior wage suppression).

Most FOSS people are easier to train, as most already can mitigate utter chaos already. =)

There are a few like that in the C++ community. WxWidgets is the most famous/popular with this approach. But it is a library almost impossible to use in other languages because their api is heavily templated.