LIlincpa·Jan 7, 2019
Clojure can also do it.
Java Abstracted Foreign Function Layer
https://github.com/jnr/jnr-ffi
In How innovative is Clojure as a Lisp dialect from Lisp expert's perspective?jnr
jnr-ffi
Java2015–2019
jnr / jnr-ffi
jnr-ffi
Java Abstracted Foreign Function Layer
5Distinct people
7Mentions
0Explicit recommenders
1.3KGitHub stars
What to know before exploring
What it is
Java Abstracted Foreign Function Layer
GitHub
Where it is used
No documented product use has been verified yet.
What people are saying
No recommendation phrase was found in the indexed comments.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
- java-native-access/jna · linked in 2 of the same discussions
Mentioned in the same Hacker News threads. That is not proof they are substitutes.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 5:04:57 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year7 dated mentions
Observed mentions: 2015-01-10 13:14:37 UTC to 2019-01-07 10:53:38 UTC.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 3 | 0 | 3 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 1 | 0 | 1 |
What Hacker News says
7 sourcesI suspect the built-in Java Native Interface (JNI) won't work when compiling bytecode to native code, since the JNI methods require a pointer to the JVM (passing a pointer to the JVM to C functions or calling methods on the JVM class in C++). Perhaps an FFI library like this could work, though: https://github.com/jnr/jnr-ffi .
In Scala Native with Denys Shabalin – Software Engineering Daily PodcastThere already are alternatives for JNI. You can use JNR[0] and JNA[1] which allow you to access native libraries by writing java.
In some future version panama[2] will offer similar functionality to JNR.
[0] https://github.com/jnr/jnr-ffi
[1] https://github.com/java-native-access/jna
[2]http://openjdk.java.net/projects/panama/
In JEP 295: Ahead-of-Time Compilation> Go has far better C linkage
This is changing. There already are 3rd-party FFI libraries for java[0][1] which are far less cumbersome to use than JNI and in the future there will be Project Panama[2] which will provide that out of the box.
[0] https://github.com/jnr/jnr-ffi
[1] https://github.com/java-native-access/jna/blob/master/www/Ge...
[1] http://openjdk.java.net/projects/panama/
In Proposed New Go GC: Transaction-Oriented CollectorOf course you can implement any shared/consistent memory transaction on top of shards -- after all, the CPU implements shared memory on top of message-passing in a shared-nothing architecture, too. It's just that then you end up implementing that abstraction yourself. If you need it, someone has to implement it, and if you need it at the machine level, it's better to rely on its hardware implementation than re-implement the same thing in software. Naive implementations end up creating much more contention (i.e. slow communications) than a sophisticated use of hardware concurrency (i.e. communication) instructions.
My point is that if you're providing a shared-memory abstraction to your user (like arbitrary transactions) -- even at a very high level -- then your architecture isn't "shared-nothing", period. Somewhere in your stack there's a
Read the rest
n implementation of a shared-memory abstraction. And if you decide to call anything that doesn't use shared memory at CPU/OS level "shared nothing", then that's an arbitrary and rather senseless distinction, because even at the CPU/OS level, shared memory is implemented on top of message-passing. So the cost of a shared abstraction is incurred when it's provided to the user, and is completely independent of how it's implemented. The only way to avoid it is to restrict the programming model and not provide the abstraction. If doing that is fine for the user -- great, but there's no way to have this abstraction without paying for it.
And JNI is better now[1] (I've used JNR to implement FUSE filesystems in pure Java). JNR will serve as the basis for "JNI 2.0" -- Project Panama[2]. And thanks!
[1]: https://github.com/jnr/jnr-ffi
[2]: http://openjdk.java.net/projects/panama/
Which of the JNR projects is the one you used? There are three that sound like they would do the exact same thing:
https://github.com/jnr/jnr-invoke
https://github.com/jnr/jnr-ffi
https://github.com/jnr/jffi
In Go GC: Prioritizing low latency and simplicityYes, and this was not something that demanded attention because Java originally wanted to discourage the use of native -- and platform specific -- code. So JNI was originally thought of as a bridge you build once to your legacy C code, and then move on. Recently, people have been wanting a more liberal use of native 3rd party libraries, so this issue is getting fixed with JNR[1], which will serve as the basis of Java's new FFI being developed under Project Panama[2].
[1]: https://github.com/jnr/jnr-ffi
[2]: http://openjdk.java.net/projects/panama/
In Native calls to Rust code from Java code