Jac Lang与Nura编程语言的对比

2026-10-08 （分类：技术、开源）

前言

2026年，"AI原生编程语言"从一个概念变成了多条真实的代码线。在众多探索者中，Jac Lang 和 Nura 是两条风格迥异的路径：Jac 走的是"全栈一语言、编译器生成胶水"的宏大路线，Nura 走的是"零依赖嵌入式脚本、AI能力即语法"的轻量路线。

本文从设计哲学、语法、AI集成、并发模型、生态工具链等维度做一次客观对比，帮助读者理解两种语言各自的取舍。

一、定位与设计哲学

Jac 的核心主张是消除胶水代码：一个全栈应用的前端、后端、数据模型、API、部署配置，全由一个编译器生成，开发者只写业务逻辑。它的理论根基来自 Jason Mars 的论文，将编程重新定义为"连续的、拓扑运动的"计算模型。

Nura 的核心主张是AI原生即语法，特殊类即框架：agent、cell、workflow、distributed、dsl 五大特殊类是语言级一等公民，各自内建完整的生命周期和运行时。LLM 类直接调用 DeepSeek/OpenAI 真实 API，支持流式输出、工具调用、多轮对话。同时保持零依赖、可嵌入的脚本语言特性，追求最小侵入地嵌入宿主程序。

二、语法对比

2.1 变量与类型

Jac（静态类型，编译器推导）：

can add(a: int, b: int) -> int {
    return a + b;
}
name: str = "Jac";
items: list[int] = [1, 2, 3];

Nura（动态类型，可选标注）：

fun add(a, b) {
    return a + b
}
let name = "Nura"
let items = [1, 2, 3]

Jac 的类型系统是编译期强制的，类型错误在 jac check 时就会被捕获。Nura 的类型标注仅为提示性，运行时不做类型校验，更接近 Python/Ruby 的脚本风格。

2.2 面向对象

Jac 使用 node / edge / walker 构成 Object-Spatial Programming：

node Task {
    has title: str;
    has done: bool = False;
}

walker:pub add_task {
    has title: str;
    can create with Root entry {
        task = Task(title=self.title);
        root ++> task;
        report {"id": jid(task), "title": task.title};
    }
}

Nura 使用传统 class / extends + 五大特殊类（agent/cell/workflow/distributed/dsl）：

class Task {
    var title = ""
    var done = false
    fun constructor(t) { this.title = t }
}

agent Brain {
    mem memory
    model "deepseek-chat"
    persona "你是一个智能助手"
    node tool search
    fun think(query) { ... }
}

workflow DataPipeline {
    stage extract { ... }
    stage transform { ... }
    stage load { ... }
}

关键区别：Jac 的 node / walker 既是数据模型也是 API 端点（:pub 标记自动生成 REST），而 Nura 的 class 是纯数据结构，agent 是带 LLM 能力的智能体实体（内建 think/chat/remember/工具调用），workflow 是内建生命周期的工作流引擎（Pipeline/DagFlow/Swarm/Debate/Hierarchy 五种模式），distributed 是节点调度器，dsl 允许用户自定义领域特定语言——这些都不仅仅是语法糖，而是各自拥有完整运行时的语言级框架。

2.3 控制流

两者都有 if/else/for/while，但细节不同：

• Nura 有独特的 circle/when 重试循环（面向 AI 场景），for i=0 i<5 i++ C风格循环（空格分隔，非分号）
• Jac 更接近 Python 风格，with entry {} 是程序入口

// Nura circle/when 重试循环
mut retries = 0
circle {
    retries += 1
    let result = call_api()
    if result != null { break }
} when retries >= 3 break

// Jac walker 入口
walker check_tasks {
    can start with Root entry {
        for t in [-->][?:Task] {
            if not t.done {
                report t.title;
            }
        }
    }
}

三、AI 集成

这是两种语言最核心的共同点，也是最大的分歧点。

Jac：Meaning-Typed Programming

enum Priority { LOW, MEDIUM, HIGH, URGENT }

def assess(ticket: str) -> Priority by llm();

with entry {
    print(assess("Checkout is down!"));
    // Priority.URGENT
}

Jac 的 by llm() 是编译器级AI集成：编译器根据函数签名和 sem 注解自动构造 prompt，返回类型作为输出 schema 被强制执行。这是 Meaning-Typed Programming 的实现，AI调用是一个类型安全的函数调用。

Nura：AI能力即语法 + 真实LLM调用

agent Assistant {
    mem history = []
    model "deepseek-chat"
    persona "你是一个智能助手"
    node tool search
    node tool calculate
    fun ask(question) {
        let result = this.chat(question)
        return result
    }
}

let answer = Assistant.ask("今天天气如何？")

// 也可以直接使用 LLM 类
let llm = new LLM().with_model("deepseek-chat").with_timeout(30000)
let response = llm.call_full("解释量子纠缠")
print(response.content)
print("消耗 " + str(response.prompt_tokens) + " + " + str(response.completion_tokens) + " tokens")

// 流式输出
http_stream("POST", "https://api.deepseek.com/chat/completions", headers, body, 60000, fun(chunk) {
    print(chunk)  // 逐 token 输出
})

Nura 的 AI 集成是双层架构：语法层有 agent/<<prompt>>/tensor/stream/task ~> node 等一等公民概念，运行时层有 LLM 类直接调用 DeepSeek/OpenAI 真实 API（通过 http_request_ex / http_stream 内建函数）。当未配置 API Key 时，Agent 自动降级为 echo 模式；配置后即为真实 LLM 调用，支持流式输出、多轮对话、工具调用、token 统计和成本估算。

AI 集成对比

四、并发与分布式

Jac：Walker 是天然的并发单元，jac scale deploy 自动将 walker 部署为微服务。并发是架构级的——编译器和运行时管理。

Nura：提供 chan()/mutex()/spawn() 等并发原语，distributed 特殊类提供节点调度（LEAST_LOADED/ROUND_ROBIN/RANDOM/RESOURCE_AWARE 四种策略），task ~> node 分布式语法。当前分布式为本地模拟（spawn + chan），已有完整 RPC 迁移路线图（5阶段，从本地到真实跨进程通信）。并发是语言级的——开发者手动管理，但特殊类封装了大部分复杂性。

// Nura 分布式节点调度
distributed InferenceCluster {
    node gpu_worker tags=["gpu","inference"] max_tasks=4 gpu_count=1
    node cpu_worker tags=["cpu","preprocess"] max_tasks=8
    schedule LEAST_LOADED
    fun infer(data) ~> gpu_worker {
        return llm.call(data)
    }
}

// Jac 分布式——代码不变，部署方式变
jac run api.jac           # 本地单进程
jac scale deploy api.jac  # Kubernetes 集群

五、生态与工具链

Jac 的工具链是一个完整开发环境：一个二进制文件替代了 Python解释器、JS运行时、C编译器、包管理器、部署工具。Nura 的工具链更轻量：eval/vm 两个可执行文件，标准库全覆盖但无 IDE 支持；但 Nura 的特殊类体系相当于语言级框架——agent 即 LangChain，workflow 即 Prefect/Airflow，distributed 即 Ray，dsl 即自定义 DSL 引擎，这些都内建于语言而非外部依赖。

六、代码量对比

Jac 的核心卖点是~5x less code，编译器生成胶水层。Nura 的代码量优势来自语法简洁——动态类型省去了大量声明代码。

一个 TODO 应用的对比：

• Jac：1个文件，~100行（前端+后端+持久化+API，编译器生成所有胶水）
• Nura：需要 nura-web 路由 + class 定义 + 手动 API 搭建，200行（但每行都很直白）；如果用 agent + workflow 特殊类，可以缩短到120行

七、适用场景

选 Jac 如果你需要：

• 全栈应用，前后端统一类型检查
• AI 集成作为核心业务逻辑，编译器保证类型安全
• 自动生成 REST API + Swagger + 持久化
• 从笔记本到 Kubernetes 的无缝部署
• 编译到原生可执行文件 / WebAssembly
• AI 编码助手（MCP 集成）

选 Nura 如果你需要：

• 嵌入宿主 C++ 程序的脚本语言
• 零依赖、最小侵入的运行时
• AI 智能体 + 工作流 + 分布式 + DSL 作为语言一等公民
• 真实 LLM 调用（DeepSeek/OpenAI），流式输出，工具调用
• 多智能体协作模式（Swarm/Debate/Hierarchy/DagFlow）
• 自定义 DSL 驱动 AI 推理
• 张量运算作为一等公民
• 学习编程语言实现（C++代码库清晰可读）

八、总结

Jac 和 Nura 都是"AI原生"的探索，但走了两条几乎相反的路：

一句话总结：Jac 是面向"AI时代的Java"——全栈、编译检查、生产就绪；Nura 是面向"AI时代的Lua+LangChain"——嵌入式、轻量、语言即框架。两者不是竞争关系，而是对"AI应该怎么融入编程语言"这一问题的两种回答：Jac 让编译器替你做，Nura 让特殊类替你做。

Nura 开源地址：https://gitee.com/somoe-net/nura

Jac 开源地址：https://github.com/Jaseci-Labs/jac