一套 JavaScript API。
贯通所有引擎，尽在 Rust。

Rong（融）是一个面向 Rust 的 JavaScript 运行时，以统一的 API 覆盖 QuickJS、JavaScriptCore 和 ArkJS —— 专为嵌入式场景、Rust 驱动的 JS API 以及长生命周期的 worker 运行时而设计。

快速开始在 GitHub 上查看

cargo add rong --features quickjs,tls-aws-lc

QuickJS
JavaScriptCore
ArkJS

3 种 JavaScript 引擎

20 个内置模块

1.95+ Rust 工具链（2024 edition）

MIT / Apache-2.0 双重许可

为什么选择 Rong

融合、和谐、流动 —— 源于设计。

「融」意为交融与和谐。Rong 将 JavaScript 引擎与 Rust 原生代码融为一体，以单一而优雅的 API 统一各式运行时。

统一 API

一次编写，到处运行。同一份 Rust 代码即可驱动 QuickJS、JavaScriptCore 和 ArkJS —— 引擎在构建时选定，代码中没有任何引擎相关的分支。

声明式类绑定

使用 #[js_class] 和 #[js_method] 将 Rust 结构体暴露给 JavaScript —— 构造函数、getter、setter 与静态方法，全部经过 Rust 类型检查。

Async / await

一流的 Promise 与异步迭代器集成，让 JavaScript 与 Rust 的 Future 跨越引擎边界自然交织。

Worker 池

显式选择执行模型：shared() worker 处理无状态任务，pinned() worker 让按键关联的状态始终驻留在同一个长生命周期运行时上。

有界执行

让任务截止时间覆盖排队与执行；在引擎支持时中断不让出执行权的 JavaScript，并在超时后安全复用 worker。

TypeScript 与工具链

类型定义以 @rongjs/rong 发布到 npm；@rongjs/rong-skill 则打包了带生成式 API 参考的可安装智能体技能。

多引擎支持

三个引擎，一套代码。

引擎彼此互斥，在构建时选定 —— 若同时启用多个引擎，构建会立即失败。库本身不预设默认引擎；由下游 crate 显式选择引擎与 TLS 后端。

默认 · 桌面端

QuickJS

轻量且快速。Rong CLI 在桌面主机上的默认引擎，搭配 aws-lc TLS 后端。

Apple 系统 + 源码构建

JavaScriptCore

在 macOS 和 iOS 上链接系统 JavaScriptCore.framework，或在受支持目标上使用固定版本、源码构建的 WebKit/JSCOnly 产物。Windows 源码产物目前不可用。

HarmonyOS / OpenHarmony

ArkJS

HarmonyOS 的 JavaScript 引擎，面向 aarch64 OpenHarmony 目标，搭配 ring TLS 后端。

架构

统一内核，引擎可换。

Rong 内核提供统一 API、类型系统、内存管理与异步层，引擎和内置模块在其下方接入。

Rong 内核

统一 API类型系统内存管理Async / Await

QuickJS JavaScriptCore ArkJS

内置模块与扩展

TimerHTTPFSConsoleS3SQLiteRedisWorker…

快速上手

从零到运行 JS，只需几秒。

添加依赖、选择引擎，即可在 Rust 中运行 JavaScript —— 或将 Rust 类暴露给 JavaScript。

use rong::*;

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

    // Execute JavaScript directly
    let result: i32 = ctx.eval(Source::from_bytes(b"2 + 3"))?;
    println!("Result: {}", result); // Result: 5

    Ok(())
}

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_method};

#[js_class]
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.6", 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