jextract VS panama-liburing

I don't think so, given that there are more popular Java libraries than popular libraries with a C ABI. There is a small number of very popular C libraries that result in the majority of native call uses. But in any event, calling native libraries in Java is now no longer a pain thanks to FFM (and jextract [1]) so we'll see.

Note that interaction with native libraries often requires more careful management of native memory that -- even though it's much easier now with FFM -- is still significantly trickier (and more dangerous in terms of introducing undefined behaviour) than interacting with Java code regardless of how that interaction is declared. In Java, as in Python, interaction with native code -- in the vast majority of cases -- is best encapsulated inside a Java library and not often directly exposed to application programmers.

[1]: https://github.com/openjdk/jextract

ok, maybe I mixed it up with jextract https://github.com/openjdk/jextract

This is one level below P/Invoke. It just offers a linking runtime API.

There's also has a tool that can generate all the bindings from a C header file automatically: https://github.com/openjdk/jextract

Then it doesn't really matter whether annotations are used or not, or some more low-level linker API (like FFM went with). As a user you just call into the generated bindings.

That's the philosophy: the JDK provides the low-level capabilities, and jextract provides the 'civilization', i.e. a usability focused layer on top. One of the advantages is that the JDK doesn't compete with other existing solutions, and those existing solution can benefit from the new linking runtime APIs as well.

Depending on how work-aroundy you're feeling, using Kotlin/JVM with Panama and jextract might be the way to go. The generated bindings are a bit ugly, you'd need to use the very latest JVM and enable the preview features, and it won't help if you need to target iOS. But the jextract tool can fully understand C headers including macros because it's using the LLVM clang API to do so.

You can use jextract and a JDK 19 pre-release build to generate bindings and then do a JMH benchmark.

None of that needs to be done in the JDK, though, and the "big" project that can make a big difference here is jextract. The rest can easily be done by libraries.

Panama incubator module is available on jdk 17 and you can also use jextract (https://github.com/openjdk/jextract) to generate all java code without writing any JNI glue code.

It does allow for unsafe pointer math, I have some examples here where I've ported io_uring to use native Java Foreign Memory API with no external headers/bindings:

https://github.com/GavinRay97/panama-liburing/blob/6a80673e7...