Packaging questions and review request

Ah sure,

I've written C (max-api) externals years ago but more to explore the SDK not complex stuff.
I've never used C++ (min-api) since it was not made at that time.

I'm kind of familiar with C (max-api) headers, probably not all but I check them out when I need to.
I find the source code of the headers more easier to read than the doxygen generated doc.

Rust bindings are usually done with bindgen. They're auto generated from the C headers.
In the Rust ecosystem we usually separate the binding packages (crates) and suffix them as -sys.

The max-sys crate mirrors all the C headers which you can find in the SDK so you can call those functions but they're considered "unsafe" since the Rust compiler (borrow checker) can not track the lifetimes of allocations through the FFI boundary (Foreign Function Interface) so you need to manage the memory manually like C.

People usually wrap the memory management logic and expose APIs to the users which adheres to Rust standards so at least people can think about the memory management in a Rust way or think about the memory management a bit less.

Median also does this (a little bit).

It also experiments with proc marcos (compiler plugins for Rust) where it generates code in compile time to make things easier for the user even closer to JS apis. On the other hand there are heavy trade offs with this approach and it is hard to get right. In median's case I'd consider it more like an experiment compared to a feature. I'd say if you'd like to do something serious you should avoid using those macros at the time of writing this.

Here is my opinion on that
https://github.com/Cycling74/median/issues/17

My approach is to use a hybrid of median safe wrappers with raw max-sys bindings since median safe wrappers are not complete and do not expose the complete features of the C SDK.

On the other hand it is a good starting point and for me writing in Rust is much much more ergonomic compared to C and on top of that you get all the goodies of crates.io, borrow checker, easy concurrency, testing suite, tracing and all the other very nice features which comes with Rust.

Error handling (if you know how to do it) is very powerful in Rust so combined with tracing you can really go a long way there and development experience is much easier. Also if you don't use raw max-sys apis due to Rust guarantees there will be no segfaults and raw pointer management. If you're are careful with max-sys you can also wrap the apis you need in a safe way.

In short words, if you're an experienced Rust programmer median wins in every way but the project (in my opinion) is in an experimental state.

The downside is the beginner or early intermediate Rust programmer can not use it easily if they want to do something relatively complex. In other words the entry barrier is high.

If one develops median more this entry barrier may get lower but this requires a lot of careful design work and somebody needs to devote time into it :)