avendish

not op, but i've done this a couple times both through the python API: https://github.com/jcelerier/dynalizer to automatically generate safe dlopen stubs for runtime dynamic library loading from header files and through the C++ one (this one is an extremely quick and dirty prototype): https://github.com/ossia/score/blob/master/src/plugins/score-plugin-avnd/SourcePar… to pre-instantiate get<N>(aggregate), for_each(aggregate, f) and other similar functions in https://github.com/celtera/avendish because of how slow it is when done through TMP (doing it that way removed literally dozens of megabytes from my .o and had a positive performance impact even with -O3) ; so I weep a lot when I read that people in the committee object to pack...[indexing]

I absolutely disagree. I use Qt for most of my GUI C++ apps, it is very framework-y and a joy to get things done with. Since last year I've been working on a framework for making media processors (audio, etc): https://github.com/celtera/avendish Every year I have 2/3 internship students. This year I put them on this framework as a baseline, compared to the previous years where the students would have to do things more manually through libraries. They all got at least 5 times as much done as the students of the previous years in the same 3-4 months span of time.

I really don't know about this, I'm writing audio & media effects in a fairly declarative style with https://github.com/celtera/avendish and I'm so much more productive that it's not even funny - I can rewrite entire effects from scratch in the time that it used to take me to find a bug somewhere

99% of my new projects are in C++20, with Qt if they need a GUI. Here's a couple recent ones: - https://github.com/celtera/avendish - https://www.youtube.com/watch?v=fMQvsqTDm3k - most of the stuff in https://github.com/ossia and https://github.com/jcelerier/

plugging in my library for audio (and media) plug-ins: https://github.com/celtera/avendish ; here are the docs: https://celtera.github.io/avendish/ I think that in C++ it's the simplest possible way to write them :)

For anyone using c++, my declarative system has some amount of support for clap: https://github.com/celtera/avendish / https://celtera.github.io/avendish/ But unlike clap, targetting this also gives direct access to a few other environments, namely Max, Pd, ossia score, with the list hopefully growing. Here is an example minimal plugin : https://github.com/celtera/avendish/blob/main/examples/Raw/M... Note that unlike pretty much every other c/c++ plugin API, the plugin code does not need to include any header, everything is done through reflection of struct members at compile-time. This means that it's dead easy to port plugins to e.g. microcontrollers. Here's a per-sample noise generator which uses a small library of pre-made ports: https://github.com/celtera/avendish/blob/main/examples/Helpe... And a very naive buffer-based audio filter

Working on a subset of this with https://github.com/celtera/avendish - C++ reflection makes some aspects of this problem very easy to solve ; while my lib focusses on media objects (audio / video / GPU processors with a control UI), the same concepts could likely be extended to a more general shared object ontology..

so interesting, as a mostly C++ dev, UE's C++ style feels absolutely awful aha. Of course it mostly has to be like this because c++ used to not have reflection at all but I think that nowadays one could use similar principles as the ones I've tried to develop for audio / media objects in https://github.com/celtera/avendish to implement game objects / UObject in a much cleaner way and with better compile times. Add a couple custom attributes implemented as a clang plug-in like e.g. [[ue::name("Player HP")]] int hp{}; which can be done in a couple afternoons by an intern and things would look sooo muuuch better.

Slowly getting there with https://github.com/celtera/avendish :)

if the object you wanna bind fits into the mold of "an algorithm with inputs and outputs, and some helper methods" I've got automatic binding of a limited set of C++ features working in https://github.com/celtera/avendish ; for now I've been using pybind11 but I guess everything I need is supported by nanobind so maybe i'll do the port...

Heh, I've been working on something not that dissimilar from the C++ side in https://github.com/celtera/avendish (at compile time though, but I plan to target WASM so maybe some collaboration's possible) - https://vimeo.com/manage/videos/694659185 ; the definition of the UI widgets don't need to include any library and will be able to compile against Qt and others :)

oh, but I'd definitely use lisp ! If it had static types, easy simd support, complete Qt integration, value types and mandatory unboxed primitives, if it was possible to define non-trivial compile-time assertions and type checks (though maybe some LISP dialects can ? are there statically-typed lisps with the ability for arbitrary type computations ?), if normal programs with normal libraries in the LISP ecosystems could be entirely written without a GC, etc etc... and I'm sure I'm forgetting the other half of the absolute bare minimum of my requirements for the programming languages I use for my day-to-day tasks. Saying that parsing an AST is on its own a justification for using LISP, is very much like saying that one should use smalltalk or erlang instead of $LANGUAGE every time they implement a message-passing system: at best worth of a

hmm, I thought that my sentence in the introduction would have made the expectations as clear as possible, how would you improve it ? > By user code, I mean that all the “nice” UI work can be done in, say, foo.hpp: <...> without requiring any custom header. Some yet-unknown .cpp file will include foo.hpp, and, no matter what the content of my_ui is, will execute a nice user interface from it. Anyone will be able to create independent libraries which will render UIs according to whatever platform-specific intricacies there are, but the actual UI code will be entirely independent from anything: peak separation of concerns is achieved. Regarding: > the reader learns this can be tested with the avendish library... a bit after the sentence stating, "Glory to the post-library era." I say that because the UI code itself does not depend on any li

GCC on GH actions takes 2/3 minutes to build a couple hundred targets with this system (~30 test file times 6-8 backends) to give a reference. I think that's sufficiently short to make compile-times a non-issue when iterating ( https://github.com/celtera/avendish/runs/5652207236?check_su... )

Aw, C++20 only[1] :( [1]: https://github.com/celtera/avendish#dependencies