DEV Community: Hasan Yousef

Cross compiling Rust for Raspberry Pi

Hasan Yousef — Wed, 11 Sep 2019 22:05:32 +0000

In a previous post, I mentioned how to install Rust at RPi, this may not be accepted in order to save space in RPi and to get things done faster, the solution is to do cross compiler, that is compile in a given OS, and run in different OS, which is supported smoothly by Rust, what you need is a linker.

For compiling to RPi the linker required is arm-linux-gnueabihf-gcc which can be installed easily in Linux sudo apt-get install gcc-arm-linux-gnueabi make git-core ncurses-dev you can check this but it took half day from me to find how to do it in MacOS and Win 10, and here I'm sharing the final steps with you:

For MacOS better use: musleabihf as target, and for Windows you can use gnueabihf as bellow:

Mac

$ brew install arm-linux-gnueabihf-binutils
$ rustup target add armv7-unknown-linux-musleabihf

In .cargo/config

[build]
target = "armv7-unknown-linux-musleabihf"
[target.armv7-unknown-linux-c]
linker = "arm-linux-gnueabihf-ld"

With simple src/main.rs

fn main() {
    println!("Hello, Raspberry!");
}

Then things are fine:

Hasans-Air:rpi hasan$ cargo build
   Compiling rpi v0.1.0 (/Users/hasan/PycharmProjects/rpi)
    Finished dev [unoptimized + debuginfo] target(s) in 0.41s
Hasans-Air:rpi hasan$ scp target/armv7-unknown-linux-musleabihf/debug/rpi pi@192.168.1.43:
pi@192.168.1.43's password: 
rpi                                                                                         100% 2702KB   2.6MB/s   00:01    
Hasans-Air:rpi hasan$ ssh pi@192.168.1.43 'chmod +x ~/rpi && ~/rpi'
pi@192.168.1.43's password: 
Hello, Raspberry!

Win 10
Get the linker from here, and run:

rustup target add armv7-unknown-linux-gnueabihf

Creating file .cargo/config with content:

[build]
target = "armv7-unknown-linux-gnueabihf"

[target.armv7-unknown-linux-gnueabihf]
linker = "arm-linux-gnueabihf-gcc"

And with simple src/main.rs:

fn main() {
    println!("Hello, Raspberry! from Win 10");
}

I was able to get things done

Prepare Raspberry Pi and starting with Rust Embeded

Hasan Yousef — Wed, 19 Dec 2018 20:16:04 +0000

I just got my Raspberry Pi 3 (along with sensors kit), and below how I did the setup and got it run:

Download Etcher for copying the iso.
Download Raspbian Stretch Lite (Minimal image based on Debian Stretch), the November 2018 version is only 351MB (the Raspbian Stretch with desktop is 1GB, while the Raspbian Stretch with desktop and recommended software is 1.8GB)
Flash the SD card with Etcher
Connect the Raspberry Pi 3 to:
- HDMI cable connected toscreen
- Keyboard
- Mouse
- USB cable connected to power source (or computer)
- Ethernet cable (if you or your device do not have WiFi network)
Insert the flashed SD card into the Raspberry slot.
Power on the device (by connecting the other edge of the USB cable to computer or power source)
Once the device boot up (may take 2 minutes depending on your SD card speed), you'll be prompted to enter your login, default user is: pi, default pswd is rasbperry:

Raspbian GNU/Linux 9 raspberrypi tty1
rasbperrypi login: pi 
Password: raspberry

Then you'll get the device ready to use showing a:

pi@raspberrypi:~$

Do the require changes in the configuration, like user password, WiFi and ssh connection as below:

pi@raspberrypi:~$ sudo raspi-config

- For `changing password` select `1 Change Password`
- For `wifi` select `2 Network Options`, you'll be asked to select country of the WiFi, then entering the SSID (i.e. the wifi name) and the wifi passphrase, BE CAREFULL both network name and password are case-sensetive.
- For `ssh` select `5 Interfacing Options`, scroll down to `P2 SSH`, and confirm `Yes` as an answer to `Would you like the SSH server to be enabled`
- For `Updating the OS` select `8 Update`
- for `Auto login`, i.e avoid being asked everytime for username and password, select `3 Boot Options` then `B1 Desktop / Cli` then `B2 Console Autologin`
- Change the `keyboard layout if required` you can check if the correct one selected or no, by trying printing `#` and `|`

Click finish once done to go back to the command prompt:

pi@raspberrypi:~$

Setup static ip

// check your current ip
pi@raspberrypi:~$ sudo ifconfig
// update your ip in the DHCPCD configeration file as static ip
pi@raspberrypi:~$ sudo nano /etc/dhcpcd.conf

- Scroll down to `define static profile`, and uncommit (i.e. remove the `#`)notice the ip is appearing as `static ip_address=192.168.x.xx`
- Press `Ctrl+X` to exit, confirm `Yes` that you want to save, then press `Enter` to save with the same name

Reboot your device:

pi@raspberrypi:~$ sudo reboot

To check if your device is connected to internet, run the below:

$ sudo ping -c 5 www.google.com

Now you can disconnect the monitor, keyboard and mouse.
In your other device, ssh login to your raspberry pi as:

ssh pi@192.168.x.xx

If you want to map the raspberry files with your system, so you can open the files saved in the raspberry with the apps in your PC, you need to have Fuse and SSHFS from here
- Create mapped folder in your pc, let's say ssh_pi

$ mkdir ~/ssh_pi
//Map the raspberry pi `home` folder
$ sshfs pi@192.168.x.xx:/home/pi ~/ssh_pi
pi@192.168.1.43's password:

Install your apps, and work the way you like, from keyboard / ssh / FUSE_SSHFS, I was able to install rust

$ curl https://sh.rustup.rs -sSf | sh

Make my first app

$ cargo new my_rust

And open the files at Intellij at my mac.
Now will start playing with Rust Embeded and physical-computing-with-rust-on-raspberry-pi and physical-computing-rust

Note: Compiling at Raspberry itself is slow, so better to compile for raspberry platform in your PC, work at your ssh_pi folder, then it will sync smoothly with the Pi.

In your PC, open the ssh_pi folder at the terminal, and write:

// get the raspberry pi platform target
$ rustup target add armv7-unknown-linux-gnueabihf
// set the raspberry pi platform as default target for this folder (ssh_pi if covring all the folders in the raspberry pi)
$ rustup override set stable-armv7-unknown-linux-gnueabihf
// To confirm you set the atrget correctly
$ rustup show
// To compile for rasberry pi in your pc
$cargo build --target=armv7-unknown-linux-gnueabihf

To shutdown your Pi

$ sudo shutdown

Build Android app with rust

Hasan Yousef — Sat, 15 Dec 2018 18:25:50 +0000

Install rust
Add $ANDROID_HOME, $NDK_HOME and $JAVA_HOME

Hasans-Air:~ h_ajsf$ sudo code $HOME/.bash_profile
// Write below 
PATH=$PATH:/usr/local/Cellar/flutter/bin
PATH=$PATH:/Users/$USER/.cargo/bin
PATH=$PATH:${ANDROID_HOME}/tools/

export JAVA_HOME=$(/usr/libexec/java_home)
export ANDROID_HOME=/usr/local/share/android-sdk
export NDK_HOME=$ANDROID_HOME/ndk-bundle
// save and Exit
// Confirm changes
Hasans-Air:~ h_ajsf$ source $HOME/.bash_profile

Add Android targets:

Hasans-Air:ndk h_ajsf$ rustup target add x86_64-linux-android aarch64-linux-android armv7-linux-androideabi i686-linux-android arm-linux-androideabi

For iOS, below targets are require:

Hasans-MacBook-Air:rust_lib_for_android h_ajsf$ rustup target add aarch64-apple-ios armv7-apple-ios armv7s-apple-ios x86_64-apple-ios i386-apple-ios

Create rust lib

Hasans-Air:greetings h_ajsf$ cargo new rust_lib_for_android --lib
     Created binary (application) `cargo` project
Hasans-Air:greetings h_ajsf$ cd rust_lib_for_android

Create chain tools Using rustup, like:

Hasans-MacBook-Air:~ h_ajsf$ rustup target add x86_64-linux-android
Hasans-MacBook-Air:~ h_ajsf$ rustup toolchain install stable-x86_64-linux-android
Hasans-MacBook-Air:rust_lib_for_android h_ajsf$ rustup override set stable-x86_64-linux-android

see (here)[https://forge.rust-lang.org/platform-support.html] for supported platforms.
Or, using Android NDK, as not all Tier 2 platforms are working fine with rustup tolchain, NDK can be used as:

usage: make_standalone_toolchain.py [-h] --arch {arm,arm64,x86,x86_64}
                                    [--api API] [--stl STL] [--force] [-v]
                                    [--package-dir PACKAGE_DIR | --install-dir INSTALL_DIR]

Details commands are below:

Hasans-MacBook-Air:rust_lib_for_android h_ajsf$ ${NDK_HOME}/build/tools/make_standalone_toolchain.py --api 28 --arch x86_64 --install-dir NDK/x86_64
Hasans-Air:rust_lib_for_android h_ajsf$ ${NDK_HOME}/build/tools/make_standalone_toolchain.py --api 28 --arch arm64 --install-dir NDK/arm64
Hasans-Air:rust_lib_for_android h_ajsf$ ${NDK_HOME}/build/tools/make_standalone_toolchain.py --api 28 --arch arm --install-dir NDK/arm
Hasans-Air:rust_lib_for_android h_ajsf$ ${NDK_HOME}/build/tools/make_standalone_toolchain.py --api 28 --arch x86 --install-dir NDK/x86

For iOS,cargo-lipo creates a universal library, and can be installed as below:

Hasans-MacBook-Air:rust_lib_for_android h_ajsf$ cargo install cargo-lipo

Create /.cargo/config file

Hasans-Air:rust_lib_for_android h_ajsf$ mkdir .cargo
Hasans-Air:rust_lib_for_android h_ajsf$ cd .cargo
Hasans-Air:.cargo h_ajsf$ touch config

Open the greetings folder in your favorite IFE, I'm using VS Code

Hasans-Air:.cargo h_ajsf$ cd ..
Hasans-Air:rust_lib_for_android h_ajsf$ cd ..
Hasans-Air:documents h_ajsf$ ls
rust_lib_for_android
Hasans-Air:documents h_ajsf$ code rust_app

Add the below to the /.cargo/config file

[target.x86_64-linux-android]
ar = "NDK/x86/bin/x86_64-linux-android-ar"
linker = "NDK/x86_64/bin/x86_64-linux-android-clang"

[target.aarch64-linux-android]
ar = "NDK/arm64/bin/aarch64-linux-android-ar"
linker = "NDK/arm64/bin/aarch64-linux-android-clang"

[target.armv7-linux-androideabi]
ar = "NDK/arm/bin/arm-linux-androideabi-ar"
linker = "NDK/arm/bin/arm-linux-androideabi-clang"

[target.i686-linux-android]
ar = "NDK/x86/bin/i686-linux-android-ar"
linker = "NDK/x86/bin/i686-linux-android-clang"

Replace the content of the src/lib.rs by the below:

use std::os::raw::{c_char};
use std::ffi::{CString, CStr};

#[no_mangle]
pub extern fn rust_greeting(to: *const c_char) -> *mut c_char {
    let c_str = unsafe { CStr::from_ptr(to) };
    let recipient = match c_str.to_str() {
        Err(_) => "there",
        Ok(string) => string,
    };

    CString::new("Hello ".to_owned() + recipient).unwrap().into_raw()
}

/// Expose the JNI interface for android below
#[cfg(target_os="android")]
#[allow(non_snake_case)]
pub mod android {
    extern crate jni;

    use super::*;
    use self::jni::JNIEnv;
    use self::jni::objects::{JClass, JString};
    use self::jni::sys::{jstring};

    #[no_mangle]
    pub unsafe extern fn Java_com_mozilla_greetings_RustGreetings_greeting(env: JNIEnv, _: JClass, java_pattern: JString) -> jstring {
        // Our Java companion code might pass-in "world" as a string, hence the name.
        let world = rust_greeting(env.get_string(java_pattern).expect("invalid pattern string").as_ptr());
        // Retake pointer so that we can use it below and allow memory to be freed when it goes out of scope.
        let world_ptr = CString::from_raw(world);
        let output = env.new_string(world_ptr.to_str().unwrap()).expect("Couldn't create java string!");

        output.into_inner()
    }
}

Add the below to the Cargo.toml

[target.'cfg(target_os="android")'.dependencies]
jni = { version = "0.5", default-features = false }

[lib]
name = "greetings"
crate-type = ["dylib"]

Build the static library for each target

Hasans-MacBook-Air:rust_lib_for_android h_ajsf$ cargo build --target x86_64-linux-android --release
Hasans-MacBook-Air:rust_lib_for_android h_ajsf$ cargo build --target aarch64-linux-android --release
Hasans-MacBook-Air:rust_lib_for_android h_ajsf$ cargo build --target armv7-linux-androideabi --release
Hasans-MacBook-Air:rust_lib_for_android h_ajsf$ cargo build --target i686-linux-android --release

Note aarch64 can be used for both arm64 and arm64-v8a

For iOS, run cargo lipo --release

Hasans-MacBook-Air:rust_lib_for_android h_ajsf$ cargo lipo --release
Due to a known rustc issue, cargo-lipo can only be run on macOS. See https://github.com/rust-lang/rust/issues/36156#issuecomment-373201676 for more info.
   Compiling cargo v0.1.0 (/Users/h_ajsf/Documents/greetings/rust_lib_for_android)
warning: dropping unsupported crate type `dylib` for target `aarch64-apple-ios`                                                                                    

warning: dropping unsupported crate type `cdylib` for target `aarch64-apple-ios`                                                                                   

    Finished release [optimized] target(s) in 5.90s                                                                                                                
   Compiling cargo v0.1.0 (/Users/h_ajsf/Documents/greetings/rust_lib_for_android)
warning: dropping unsupported crate type `dylib` for target `armv7-apple-ios`                                                                                      

warning: dropping unsupported crate type `cdylib` for target `armv7-apple-ios`                                                                                     

    Finished release [optimized] target(s) in 0.98s                                                                                                                
   Compiling cargo v0.1.0 (/Users/h_ajsf/Documents/greetings/rust_lib_for_android)
warning: dropping unsupported crate type `dylib` for target `i386-apple-ios`                                                                                       

warning: dropping unsupported crate type `cdylib` for target `i386-apple-ios`                                                                                      

    Finished release [optimized] target(s) in 1.56s                                                                                                                
   Compiling cargo v0.1.0 (/Users/h_ajsf/Documents/greetings/rust_lib_for_android)
warning: dropping unsupported crate type `dylib` for target `x86_64-apple-ios`                                                                                     

warning: dropping unsupported crate type `cdylib` for target `x86_64-apple-ios`                                                                                    

    Finished release [optimized] target(s) in 0.88s

And the universal iOS library can be found in cargo/target/universal/release/libgreetings.a

For iOS:
Add the greetings.h file, by: File\Add files to "Greetings"...
Add native file libgreetings.a and the native interactive framework libresolv.tbd by General -> Linked Frameworks and Libraries
Create bridging header Greetings-Bridging-Header.h by File\New\File.... Header File and import the greetings.h file into it so the file became as below:

#ifndef Greetings_Bridging_Header_h
#define Greetings_Bridging_Header_h

#import "greetings.h"

#endif

Update the Build Settings -> Objective-C Bridging Header by adding the path of Greetings-Bridging-Header.h file
Update the Build Settings -> Library Search Paths by adding the path of imported libgreetings.a file
Create RustGreetings swift file by File\New\File... and iOS\Source\Swift File, and add to it the:

class RustGreetings {
    func sayHello(to: String) -> String {
        let result = rust_greeting(to)
        let swift_result = String(cString: result!)
        rust_greeting_free(UnsafeMutablePointer(mutating: result))
        return swift_result
    }
}

Update the viewDidLoad in the ViewController.swift file, by adding:

let rustGreetings = RustGreetings()
print("\(rustGreetings.sayHello(to: "world"))")

Building WASM, Android and iOS app with single/common RUST core code

Hasan Yousef — Wed, 12 Dec 2018 19:46:22 +0000

I'll write below, the file required to write simple hello world code using RUST, that can be called by WASM/Android/iOS app, compiling and calling will follow in later article.. follow me to be notified..

I tested both WASMand Android and they are fine.

src folder tree:

Hasans-Air:src h_ajsf$ tree .
.
├── lib.rs
├── android
│   └── mod.rs
├── ios
│   └── mod.rs
└── wasm
    └── mod.rs

3 directories, 4 files

And the files now are:

Main:

// lib.rs
pub mod wasm;
pub mod ios;
pub mod android;

#[cfg(not(target_arch = "wasm32"))]
use std::os::raw::{c_char};

#[cfg(not(target_arch = "wasm32"))]
use std::ffi::{CStr};

pub fn rust_greetings(to: &str) -> String {
    format!("Hello {}", to)
}

#[cfg(not(target_arch = "wasm32"))]
fn char_str(pattern: *const c_char) -> &'static str {

    let c_str = unsafe { CStr::from_ptr(pattern) };
    let string_ptr = match c_str.to_str() {
        Err(_) => "there",
        Ok(string) => string,
    };
    string_ptr
}

WASM

// src/wasm/mod.rs
#[cfg(target_arch = "wasm32")]
pub mod wasm {
    use crate::rust_greetings;
    use wasm_bindgen::prelude::*;

    #[wasm_bindgen]
    pub fn wasm_greetings(to: &str) -> String {
        rust_greetings(to)
    }
}

Android

// src/android/mod.rs
#[cfg(target_os="android")]
#[allow(non_snake_case)]
pub mod android {
    use crate::rust_greetings;
    use crate::char_str;
    extern crate jni;

    use self::jni::JNIEnv;
    use self::jni::objects::{JClass, JString};
    use self::jni::sys::{jstring};

    #[no_mangle]
    pub unsafe extern fn Java_com_hasan_RustGreetings_greetings(env: JNIEnv, _: JClass, java_pattern: JString) -> jstring {

        let jvm_input = env.get_string(java_pattern)
                                        .expect("invalid pattern string").as_ptr();

        let input = rust_greetings(char_str(jvm_input));

        let output = env.new_string(input)
                                        .expect("Couldn't create java string!");
        output.into_inner()
    }
}

iOS

// src/ios/mod.rs
#[cfg(target_os="ios")]
#[no_mangle]
pub mod ios {
    use crate::char_str;

    use std::ffi::{CString, CStr};
    use std::os::raw::{c_char};
    use crate::rust_greetings;

    #[no_mangle]
    pub extern fn ios_greetings(to: *const c_char) -> *mut c_char {

        let input = rust_greetings(char_str(to));

        CString::new(input).unwrap().into_raw()
    }

    pub extern fn iso_greeting_free(s: *mut c_char) {
        unsafe {
            if s.is_null() { return }
            CString::from_raw(s)
        };
    }
}

TOML

# Cargo.toml
[package]
name = "greetings"
version = "0.1.0"
authors = ["Hasan Yousef"]
edition = "2018"

[dependencies]

[target.'cfg(target_arch="wasm32")'.dependencies]
wasm-bindgen = "0.2.29"

[target.'cfg(target_os="android")'.dependencies]
jni = { version = "0.5", default-features = false }

[lib]
name = "rust_greetings"
crate-type = ["cdylib", "dylib", "staticlib"] 
# Android: dylib
# iOS: cdylib [armv7s-apple-ios] and staticlib [Others]
# WASM: cdylib

Below is to manage the linker for compiling Android targets

Cargo config:

# .cargo/config
[target.aarch64-linux-android]
ar = "NDK/arm64/bin/aarch64-linux-android-ar"
linker = "NDK/arm64/bin/aarch64-linux-android-clang"

[target.armv7-linux-androideabi]
ar = "NDK/arm/bin/arm-linux-androideabi-ar"
linker = "NDK/arm/bin/arm-linux-androideabi-clang"

[target.i686-linux-android]
ar = "NDK/x86/bin/i686-linux-android-ar"
linker = "NDK/x86/bin/i686-linux-android-clang"

[target.x86_64-linux-android]
ar = "NDK/x86/bin/x86_64-linux-android-ar"
linker = "NDK/x86_64/bin/x86_64-linux-android-clang"

Below are for running the WASM, which is already explained (here) [https://dev.to/h_ajsf/rust--wasm-using-bindgen-49b4]

webpack.config.js

// webpack.config.js
const path = require("path");

module.exports = {
  entry: "./index.js",
  output: {
    path: path.resolve(__dirname, "dist"),
    filename: "index.js",
  },
  mode: "development"
};

package.json

// package.json
{
  "name": "utils2",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "webpack": "^4.27.1",
    "webpack-cli": "^3.1.2",
    "webpack-dev-server": "^3.1.10"
  }
}

index.js

import("./pkg/greetings").then(wasmModule => {
  let gr = wasmModule.wasm_greetings("Karam sweet")
  console.log(gr);
});

index.html

<!DOCTYPE html>
<html>
<head>
    <script src="./index.js"></script>
    <head>
<body></body>
<html>

Simple Rust + WASM example

Hasan Yousef — Sat, 08 Dec 2018 13:57:18 +0000

Install rust

$ brew install rustup
$ rustup-init

Set default toolchain as nightly

$ rustup default nightly

Ass wasm target

$ rustup target add wasm32-unknown-unknown

Install wasm-gc tool to remove all unneeded exports, imports, functions, and so on from the generated WebAssembly module.

$ cargo instal wasm-gc

Instal https to runs a web server, serving static files from the current directory

$ cargo instal https

Create rust app, and open its files with your IDE (I'm using idea)

$ cargo new --lib utils
$ cd utils
$ idea .

7.Define the rust CDI lib type in the cargo.toml:

[package]
name = "utils"
version = "0.1.0"
authors = ["Hasan Yousef <hasan.ajsf@gmail.com>"]
edition = "2018"

[dependencies]

[lib]
crate-type =["cdylib"]

Define the extern function:

#[no_mangle]
pub extern fn add_one(x: u32) -> u32 {
    x + 1
}

The extern keyword is needed to create an interface, so that this function can be invoked from other languages.
The no-mangle annotation to tell the Rust compiler not to mangle the name of this function.

Build the wasm file:

$ cargo build --target wasm32-unknown-unknown --release

Run the wasm-gc to optimize the wasm file:

$ wasm-gc target/wasm32-unknown-unknown/release/utils.wasm -o utils.gc.wasm

Create the index.html file, and call the wasm module through javascript:

<!DOCTYPE html>
<html>
  <head>
    <script> 
      WebAssembly.instantiateStreaming(fetch("utils.gc.wasm"))
        .then(wasmModule => {
          const result = wasmModeult.instance.exports.add_one(3);
          const text = document.createTextNode(result);
          document.body.appendChild(text);
        });
    </script>
  <head>
  <body></body>
<html>

Using instantiateStreaming instead, we can stream, compile, and instantiate a WebAssembly module in one go.

Run the static file server:

$ http

Open your browser at: localhost:8000

ADVANCE

If you want to interact with JavaScript function, you need to:

Define these functions signature in the rust file
Define a bridge/wrapper in the javascript file between these functions

So, if want to call the javascript alert and another function, let's say, addOne, then the above main.rs and index.html files will be as below:

main.rs:

// To call a JavaScript function
// 1. Define the JS functions signatures
extern {
    fn addOne(x: u32);
    fn alert(x: u32);
}
// 2. Call the JS function using unsafe block
#[no_mangle]
pub extern fn add_one(x: u32) {
    unsafe {
        addOne(x);
        alert(x);
    }
}

index.html

<!DOCTYPE html>
<html>
  <head>
    <script> 
  const addOne = (number) => {
    const text = document.createTextNode(number + 1);
    document.body.appendChild(text);
  }

  const importObject = {
    env: {
        addOne: addOne,
        alert: alert,
    }
  };

  WebAssembly.instantiateStreaming(fetch("utils.gc.wasm"), importObject)
  .then(wasmModule => {
       const result = wasmModule.instance.exports.add_one(5);
   })
    </script>
  <head>
  <body></body>
<html>

For using bindgen, kindly see my other post

Rust + WASM using bindgen

Hasan Yousef — Sat, 08 Dec 2018 12:00:40 +0000

This is an advance topic using bindgen, as second step to my previouse post

Create project folder utils2
cd to this folder
from this folder create your lib:

// install rust if not yet done
// curl https://sh.rustup.rs -sSf | sh
mkdir utils2
cd utils 2
cargo init --lib

// Or it can be created in one line as:
cargo new utils2 --lib
cd utils2

make the default toolchain as nightly as wasm is only supported in nightly now:

rustup override set nightly
// Add was32 target if not yet installed
rustup target add wasm32-unknown-unknown --toolchain nightly

note:
Platforms are defined by their Target Triplet that is: machine-vendor-operatingsystem:

Machine / the name of the CPU family/model: wasm32,
The vendor: no specific, so it is unknown,
The operating system name: no specific, so it is unknown.
Create npm package file by running:

npm init

the above will create package.json.

Install webpack npm requirements, the node_modules folder will be created:

// brew install node
npm install -D webpack webpack-cli webpack-dev-server

the above will alter the package.json and make it loos something like::

{
  "name": "utils2",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "webpack": "^4.27.1",
    "webpack-cli": "^3.1.2",
    "webpack-dev-server": "^3.1.10"
  }
}

Create domUtils.js, index.html, index.js and webpack.config.js files, so that the structure be as below:

// if you need to install tree, it can be done by
// brew install tree
$ tree .
.
├── Cargo.lock
├── Cargo.toml
├── domUtils.js
├── index.html
├── index.js
├── package.json
├── src
│   └── lib.rs
└── webpack.config.js

Open the folder files in your idea, and update them, as shown in point #11

$ idea .

Build the rust wasm lib using wasm-pack as:

// cargo install wasm-pack
wasm-pack build
// this will create the standard target folder, and additional folder called pkg
// the pkg folder tree is:
├── pkg
│   ├── utils2.d.ts
│   ├── utils2.js
│   ├── utils2_bg.d.ts
│   └── utils2_bg.wasm

Run the server as:

npx webpack-dev-server

The files:

Cargo.toml

[package]
name = "utils2"
version = "0.1.0"
authors = ["Hasan Yousef"]
edition = "2018"

[dependencies]
wasm-bindgen = "0.2.29"

[lib]
crate-type = ["cdylib"]

domUtils.js

export const appendStringToBody = (value) => {
  const text = document.createTextNode(value);
  document.body.appendChild(text);
}

libs.rs:

use wasm_bindgen::prelude::*;

// Define the JS function signature
#[wasm_bindgen(module = "../domUtils")]
extern {
    fn appendStringToBody(s: &str);
}

#[wasm_bindgen]
pub fn run(my_text :&str) {
    // Call the JavaScript function
    #[allow(unused_unsafe)]
    unsafe {
        appendStringToBody(my_text);
    }
}

webpack.config.js

const path = require("path");

module.exports = {
  entry: "./index.js",
  output: {
    path: path.resolve(__dirname, "dist"),
    filename: "index.js",
  },
  mode: "development"
};

index.js

import("./pkg/my_app").then(wasmModule => {
  wasmModule.run("hi there");
});

index.html

<!DOCTYPE html>
<html>
<head>
    <script src="./index.js"></script>
    <head>
<body></body>
<html>

Interaction Rust with Julia

Hasan Yousef — Sat, 03 Nov 2018 07:34:10 +0000

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.arg("main.jl");
    // 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:

#[no_mangle]
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:

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

[lib]
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)
                (:double_input,
                "target/debug/libmy_rust_lib"),
                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.