One JavaScript API.
Every engine, in Rust.

use rong::{Rong, RongJS, Source};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // shared() for stateless work on any available worker;
    // pinned::<K, S>() keeps keyed work on the same runtime.
    let rong = Rong::<RongJS>::builder().shared().workers(2).build()?;

    let value: i32 = rong.call(|runtime, _receiver| async move {
        let ctx = runtime.context();
        ctx.eval(Source::from_bytes(b"21 * 2"))
    }).await?;

    println!("JS result: {value}"); // JS result: 42
    Ok(())
}

use rong::*;
use rong::{js_class, js_export, js_method};

#[js_export]
struct Point { x: i32, y: i32 }

#[js_class(rename = "Point2D")]
impl Point {
    #[js_method(constructor)]
    fn new(x: i32, y: i32) -> Self { Self { x, y } }

    #[js_method(getter, enumerable)]
    fn x(&self) -> i32 { self.x }

    #[js_method(rename = "moveBy")]
    fn move_by(&mut self, dx: i32, dy: i32) {
        self.x += dx;
        self.y += dy;
    }

    // Static method: Point2D.origin()
    #[js_method]
    fn origin() -> Self { Self { x: 0, y: 0 } }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let rt = RongJS::runtime();
    let ctx = rt.context();

    // Register once, then use from JavaScript:
    //   const p = new Point2D(1, 2); p.moveBy(3, 4);
    ctx.register_class::<Point>()?;
    Ok(())
}

[dependencies]
# Engines are mutually exclusive — pick one, plus a TLS backend.
# Desktop: tls-aws-lc · HarmonyOS/OpenHarmony: tls-ring
rong = { version = "0.4", features = ["quickjs", "tls-aws-lc"] }

# Run the Rong CLI / REPL — QuickJS + aws-lc by default on desktop
cargo run -p rong_cli

# Switch to JavaScriptCore explicitly
cargo run -p rong_cli --no-default-features --features jscore,tls-aws-lc

# Build for ArkJS on OpenHarmony targets
cargo build --no-default-features --features arkjs,tls-ring \
  --target aarch64-unknown-linux-ohos