graal

This is one of the most promising aspects of GraalVM and Sulong[1]. [1]: https://github.com/oracle/graal/tree/master/sulong

Java can run C/C++: https://github.com/oracle/graal/tree/master/sulong What's your point?

I think there is sulong for that (https://github.com/oracle/graal/tree/master/sulong)

Of course you could run Rust on the JVM (more precisely on GraalVM)! Have a look at Project Sulong. https://github.com/oracle/graal/tree/master/sulong

Yes, and it's available on GitHub now! Here's the heap implementation, for example: https://github.com/openjdk/jdk/blob/master/src/hotspot/share... The GraalVM is a Java implementation of the Java compiler and VM and it's also on GitHub: https://github.com/oracle/graal

There'd have to be a new implementation rewritten from scratch for native-image (the native-image GC is actually written in Java itself, while ZGC is written in C++), but I don't see any reason why it would be impossible. Note that Oracle does have intentions to commercialize similar features; there's already a low latency GC for native-image apps, but it's inspired by G1, not ZGC, I believe, and only available in Graal Enterprise Edition. So any such ultra-low-latency GC might be in a similar basket, unless it was implemented by an outside party or something. Or Oracle changes course on this. If you don't use native-image and can use a normal JDK to host your Graal app (by using Graal as the JVMCI compiler), then you might be able to use ZGC today with that setup, assuming support for ZGC read barriers has been implemented in Graal. EDIT

Doesn't stop there. There's also project sulong that tries to bring LLVM IR into the graal ecosystem. Giving you the ability to integrate C/C++/Rust/Fortran/etc. Whatever has an LLVM backend could possibly run side by side with Java/javascript/python all without major FFI penalties and possible cross language optimizations. https://github.com/oracle/graal/tree/master/sulong

Good question: GraalVM support taking LLVM IR as an input https://github.com/oracle/graal/tree/master/sulong Which means that graalVM can support any llvm language almost out of the box (in theory) Llvm IR however has not been designed with inter language interoperability in mind or at least not enough. E.g rust has no transparant, complete, seamless and efficient interop with swift, go, c++, etc But in theory llvm is just an AOT and both AOT and JIT can enable true interoperability which is why graalvm support both a jit mode and an AOT mode. However JITs enable better performance at least for any high level, GCed language than would an AOT. Moreover, GraalVM through the truffle framework enable unprecedented language designer productivity. Through high level constructs the designers can be much more productive than in standard VM/AOT, w

If people want a concrete example, here's a 6 GB repo that's 90% Java, 5% C, then some other languages. https://github.com/oracle/graal It's not even a mono-repo - this is just part of the project. Maybe someone's got some tools that let them dig around in the history and find large things or explain why it's so large? I don't think they've been checking ISOs in.

> do you think that memory allocation is always bumping a pointer a uniform amount with no memory being freed, no variance in allocation size and no interlaced lifetimes? In modern language implementations with moving collectors allocation is literally what I've described in the fast path. Not theoretical. That's literally the instructions used. > You originally said that memory allocation was 'just a few instructions' Here it is in a real industrial compiler and garbage collector, for example. https://github.com/oracle/graal/blob/f9530b0948c58a66845e84f... It's precisely as I've described.

Check https://github.com/oracle/graal. From readme: > GraalVM is a universal virtual machine for running applications written in JavaScript, Python, Ruby, R, JVM-based languages like Java, Scala, Clojure, Kotlin, and LLVM-based languages such as C and C++. and yes, it can do interop between those languages

GraalVM dev here. Note that Java on Truffle is fully Open Source and available on Github. If you can read Java code and you are interested in how it is implemented start reading here: https://github.com/oracle/graal/blob/espresso/espresso/src/c... If you are interested in a deep dive into the Truffle technology and are interested in why it makes sense to implement a language on top ofTruffle checkout my recent Rebase talk for a really long answer: https://youtu.be/O4icaN9khp4 If you don't have enough time for an 1h talk checkout my summary tweet: https://twitter.com/grashalm_/status/1212763944043139072

This seems like FUD. Truffle is licensed under the permissive UPL[0]. Even if they decided to make newer versions of it closed-source the opensource versions would still be available, and their licenses would continue to hold. This happened with solaris: oracle decided to make new ‘official’ development closed, but the last opensource version continued to be used and developed by the community. 0. https://github.com/oracle/graal/blob/master/truffle/LICENSE....

Espresso's README.md contains some interesting details, for example: > ... it already passes >99.99% of the Java Compatibility Kit ... > Running HelloWorld on three nested layers of Espresso takes ~15 minutes. Link: https://github.com/oracle/graal/tree/6dd83cd94763b8736b42063...