Interaction Rust with Julia

Rust and Julia are two promising languages focusing on speed, integrating them will help achieving great results.

Let's say we have the below Julia code, and we want to cal it from Rust code:

# __precompile__()   # If required to be kept precompiled for faster execution
# name = isempty(ARGS) ? "name" : ARGS[1] # To check input arguments
println("hello from Julia function")

Then we can call it using the below:

use std::process::Command;

fn main() {
    println!("Hello from Rust");
    let mut cmd = Command::new("Julia");
    // cmd.args(&["main.jl", "arg1", "arg2"]);
    match cmd.output() {
        Ok(o) => unsafe {
            println!("Output: {}", String::from_utf8_unchecked(o.stdout));
        Err(e) => {
            println!("There was an error {}", e);

Then, the rust file can be executed by running cargo run:

From the other other hand, let's say we have the below rust file:

pub extern fn double_input(input: i32) -> i32 {
    println!("Hello from Rust");
    input * 2

First we need to define proper cargo file to create the library, and calling cargo build:

name = "julia_call_rust"
version = "1.0.0"
authors = ["hasan yousef]

name = "my_rust_lib"
crate-type = ["dylib"]

Then the the functions in this lib can be called from Julia code as:

println("Hello from Julia")
input = 10 #Int32(10)
output =  ccall(   #(:function or "function", "library"), Return type, (Input types,), arguments if any)
                Int32,          # Return type
                (Int32,),       # (Input types,)
                input)          # Arguments if any
println("As result of $input * 2 is: $output")

Then, by running cargo build to get the rust library built, and by running julia main.jl you'll get the required output.

Learn Something New Everyday,
Connect With The Best Developers!

Sign Up Now!

& 500k+ others use Hashnode actively.

Comments (1)

Mark's photo

Cool, that's pretty easy!

But I wonder:

  • Isn't there some way to create Julia wrapper functions automatically? It's pretty unreadable.
  • Does it work with Rust Vec or &[f64] <-> Julia AbstractArray? I guess that's the main use case (heavy numerical computation).