How do I set up Sulong to run my C code in GraalVM?

Compile your C code to LLVM bitcode using Clang with the -emit-llvm flag, then use GraalVM's polyglot API to execute it. Detailed instructions are in the Graal repository's documentation.

Sulong or traditional FFI: which is better for C/Java integration?

Sulong offers more seamless integration within a single VM, allowing direct calls and shared memory. Traditional FFI like JNI requires more boilerplate and has higher marshalling costs, but might be more stable for pure Java environments.

Can Sulong run Rust programs on GraalVM?

Yes, if Rust code is compiled to LLVM bitcode, Sulong can execute it, enabling Rust to interoperate with other GraalVM languages. However, this requires specific compiler settings and might not support all Rust features.

What are the performance implications of using Sulong vs native C?

Sulong adds VM interpretation overhead, so native C is faster for raw computation. However, for polyglot applications, the interoperability benefits may outweigh the performance cost, and GraalVM's optimizations help mitigate it.

How does Sulong handle C pointers and memory management?

Sulong simulates C's memory model within GraalVM's managed environment, which can involve garbage collection interactions and potential performance hits for pointer-intensive code.

Is Sulong suitable for embedding C libraries in Node.js applications on GraalVM?

Absolutely, Sulong allows C libraries to be called directly from JavaScript code running on GraalVM, making it easier to integrate performance-critical C code into Node.js apps without separate processes.

Open-Awesome

Sulong

NOASSERTIONJava

Sulong is an LLVM bitcode interpreter for the GraalVM polyglot runtime, enabling execution of C/C++ and other LLVM-based languages.

GitHub

626 stars63 forks0 contributors

What is Sulong?

Sulong is an LLVM bitcode interpreter for GraalVM that enables execution of C, C++, and other LLVM-based languages within GraalVM's polyglot runtime. It allows these traditionally native languages to run on the GraalVM platform and interoperate with other supported languages like JavaScript, Python, and Ruby. The project solves the problem of language isolation by bringing C/C++ into a managed, multi-language execution environment.

Target Audience

Developers working with polyglot applications who need to integrate C/C++ code with other languages, and researchers exploring language interoperability and virtual machine design. Particularly useful for teams building applications that combine performance-critical C/C++ components with higher-level scripting languages.

Value Proposition

Sulong provides unique value by enabling C/C++ code to participate in GraalVM's polyglot ecosystem with full interoperability capabilities. Unlike traditional approaches that require foreign function interfaces or separate processes, Sulong allows direct, high-performance interaction between C/C++ and other languages within the same runtime environment.

Overview

Obsolete repository. Moved to oracle/graal.

Use Cases

Best For

Running C/C++ libraries within a polyglot JVM application
Integrating performance-critical C code with higher-level scripting languages
Researching language interoperability and virtual machine design
Building applications that combine multiple programming languages with C/C++ components
Executing LLVM bitcode from various language compilers on GraalVM
Creating polyglot microservices with C/C++ performance kernels

Not Ideal For

Projects that exclusively use C/C++ without any polyglot requirements
Applications demanding the highest possible performance that only native compilation can achieve
Environments where GraalVM is not an option due to licensing, support, or technical constraints

Pros & Cons

Pros

Polyglot Interoperability

Enables direct interaction between C/C++ and other languages like JavaScript and Python within GraalVM, reducing the need for complex bridging code.

High-Performance LLVM Execution

Utilizes GraalVM's advanced compiler optimizations to execute LLVM bitcode efficiently, offering better performance than standard interpreters.

Broad Language Support

Compatible with any language that targets LLVM bitcode, extending beyond C/C++ to include Rust, Swift, and more.

Integrated Development

Now part of the main Graal repository, ensuring tight integration with GraalVM's ecosystem and continuous updates.

Cons

Standalone Obsolete

The original repository is deprecated, forcing users to work with the larger, more complex Graal repository for current versions and support.

VM Overhead

Introduces the overhead of running on GraalVM, which may not be ideal for latency-sensitive or resource-constrained applications compared to native execution.

Ecosystem Dependency

Heavily reliant on GraalVM, limiting adoption in environments that prefer other runtimes or have restrictions on JVM-based solutions.

Frequently Asked Questions

Related Projects

Truffle

GraalVM compiles applications into native executables that start instantly, scale fast, and use fewer compute resources 🚀

Stars21,648

Forks1,802

Last commit7 hours ago

JavaPoet

A Java API for generating .java source files.

Stars10,854

Forks1,394

Last commit1 year ago

auto

A collection of source code generators for Java.

Stars10,561

Forks1,221

Last commit6 hours ago

error-prone

Catch common Java mistakes as compile-time errors

Stars7,212

Forks806

Last commit10 hours ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub