Lume:一门内置 HTTP、数值算法与原生 Agent 的静态类型 DSL

作者:

在

🇬🇧 English

这篇看什么

关于 Lume 是什么、bridge.c 怎么桥接、VM 与 GC 怎么在请求间复用,已经有一篇专文做过源码级解剖(https://erishen.cn/lume/),这里不重复。这篇只回答另一个问题:把实现掀开之后,这门语言到底递到开发者手里哪些能力,又怎么当场验证它们是真的。

答案不在宣传语里,在一个公开实例上。它把 Lume 的语言内核、三条执行路径、内建 HTTP、算法库与确定性 Agent Demo 暴露成 /api/* 端点——公开的那部分能对着源码读、当场 curl 出来;宿主侧的 LLM 接入与原生工具执行没有公开端点,只能读源码和运行时测试。下面沿这条线索走一遍。

先看它真实的样子。这是 showcase 里 server.lume 的两个路由,不是伪代码:

get "/api/health", (req) => {
  return json_resp(stringify({ ok: true, service: "lume-showcase", cores: 1 }));
};

get "/api/features", (req) => {
  return json_resp(stringify(feats.feature_list()));
};

一条 get 语句注册一个路由,handler 返回 map,由框架按 JSON 序列化。没有 stringify 之外的手工拼装,没有手写 status/type。文件末尾再把服务器能力声明出来:

server {
  host = bind_host;
  port = 18793;
  docroot = "web/dist";
}
run();

server{} 是语言内置的能力,不是引入的框架;run() 把这一切变成一个正在监听的进程。静态站点(docroot)和 JSON API 由同一个进程服务——这就是 Lume 想消掉的那层部署胶水。

速览(TL;DR)

  • 静态类型与代数数据类型:枚举 + 穷尽 match、高阶函数、Result + ? 错误传播、模块导入,都写进语言而非库。
  • 一个前端、三条执行路径:解析器产出带类型 AST 后分叉为树遍历解释器、手写 LLVM IR 文本后端、libLLVM C API 后端,三者对同一份源码逐字节给出一致结果。
  • HTTP 是语言能力:server{} + run() 直接起静态站点与 API,get/write 语句注册路由;生产运行时不需要 Node.js,也不需要独立应用服务器。React 前端经构建后由 Lume 内置 HTTP Server 与 API 同进程服务。
  • 数值与 ML 是语言自带版图:矩阵、线性代数、积分、优化、MLP、PINN、PDE 等 12 类算法有专用标准库;三组加速比来自真实测量。
  • Agent 表面是语言自带的:catalog()/tools()/mcps()/skills() 内省内建、经环境变量接入的外部 LLM 钩子、宿主侧原生 ReAct 循环(模型写 SQL、sql_query 只读执行、拿真实结果作答)——不靠 Python、MCP stdio 或 Node sidecar 拼装。showcase 里的纯 lume 循环只是可定制的一例。
  • 公开能力当场可验:公开实例把语言内核、执行后端、HTTP、算法库与确定性 Agent Demo 暴露成 /api/* 端点,页面数字直接来自解释器返回值;宿主侧 LLM 与原生工具执行由源码和运行时测试验证,不在公开端点里。
  • 部署轻到可以铺开:生产运行时不带 Node,镜像压到约 12MB(scratch 基底,纯静态二进制还能更小),一台极简 ECS 上可以按端口配多个实例。

四层全景:从应用到原生运行时

上面七条分散在各层,先看它们的位置关系:

         Applications
    Web / CLI / Agent / MCP
                |
          Lume Server
       HTTP / SQL / Tools
                |
           Lume Core
     Parser / Type Checker
       Interpreter / LLVM
                |
         Native Runtime
       C11 / SQLite / C Kernels

从下往上读:最底层是 C11 与 SQLite、数值 C 内核撑起的原生运行时;Lume Core 在其上提供解析、类型检查与三条执行路径;Lume Server 把 HTTP、SQL 与工具注册做成语言能力;最上层才是 Web、CLI、Agent、MCP 这些应用形态。这篇文章的每一节都能在这张图里找到位置,showcase 只是最上层的一个公开验证窗口。

语言内核:类型、枚举与 Result

Lume 的类型不是贴在变量上的注释,而是编译期就参与决策的约束。src/features.lume 里的这段自检展示了类型标注、推断和 int→float 加宽:

func demo_types(): string {
  let a: FPoint = { x: 3, y: 4 };
  let dx = a.x;               // inferred int
  let w: float = 7;           // int literal widens to float
  return "p=" + str(a) + " dx=" + str(dx) + " widened=" + str(w);
}

FPoint 是文件顶层声明的类型别名,let dx = a.x 推断为 int,let w: float = 7 让整数字面量加宽为浮点。再看枚举与模式匹配——这是 Lume 处理代数数据类型的核心:

enum FShape { Cir(r: float) | Rect(w: float, h: float) }
enum FColor { Red | Green | Blue }

func demo_enum(): string {
  let s = Cir(2.0);
  let area = match (s) { Cir(r) => 3.14 * r * r, Rect(w, h) => w * h };
  let name = match (s) { Cir(r) => "circle", Rect(w, h) => "rect" };
  let c: FColor = Green;
  let word = match (c) { Red => "stop", Green => "go", Blue => "cool" };
  return "area=" + str(area) + " " + name + " " + word;
}

match 是穷尽的(FShape 两个分支、FColor 三个分支都被覆盖),模式里的 r、w、h 直接绑定枚举载荷。错误传播则用 Result 加 ? 运算符,省掉一层层 if err:

func demo_result(): string {
  let ok_part: Result = _report_ok();
  let e: Result = _divide(1, 0);
  return get(ok_part, "ok", "?") + " err=" + str(get(e, "err", ""));
}

func _report_ok(): Result {
  let q: float = _divide(21, 7)?;
  return { ok: "q=" + str(q) };
}

func _divide(a: int, b: int): Result {
  if (b == 0) { return { err: "div by zero" }; }
  return { ok: a / b };
}

_divide(21, 7)? 在成功时取出 ok 值、失败时把 err 直接向上传播。这三段不是幻灯片上的示意——它们是 feature_list() 收集、由 /api/features 返回、在解释器上真实执行过的结果。还有两条刻意设计的语言纪律值得记住:/ 运算恒为浮点(7 / 2 得到 3.5 而不是截断的 3),list 是引用语义(push 原地修改)。前者避免整数除法的静默截断,后者关系到算法代码里容器怎么传递。

一个前端,三条执行路径

Lume 的执行模型是分叉而非串行:共享前端(词法 / 解析 / 类型检查)产出带类型 AST,然后分成三条互不串行的路径——树遍历解释器、手写 LLVM IR 文本后端、libLLVM C API 后端。三条路径消费同一份 AST,而不是「前端 → 解释器 → 后端」的流水线。

为什么保留三条?因为一致性本身就是能力:tests/smoke.sh 会起解释器、文本后端与 libLLVM 后端三个服务器,对每个 /api/* 端点比对 JSON 是否逐字节一致。这意味着同一段 .lume 代码无论解释运行还是编译成原生代码,语义都不会漂移——对 AI 生成的代码来说,这是把它「跑对」的面积压小的关键。

代价是边界要写清楚:一些解释器侧的 builtin(如带 SSRF 闸门的内建 HTTP 客户端 http_get、agent 内省用的 catalog/tools/mcps/skills)并不存在于编译后端。showcase 的 agent demo 因此刻意只用纯 lume 实现——宁可少用内建,也要保住三后端逐字节一致。这条纪律贯穿整个项目。

内建 HTTP:server{} 不是框架

前面已经看到 server{} 和 get 路由的样子。值得强调的是这件事的性质:HTTP 是语言内置能力,不需要引入 Web 框架,也不需要在进程外挂 nginx 做应用服务器。要说清楚边界:React 前端仍由 Vite 构建,开发与构建阶段离不开 Node 工具链;但构建产物静态资源一旦产出,生产运行时不需要 Node.js,也不需要独立的应用服务器——Lume 的内置 HTTP Server 与 API 在同一进程里把 web/dist 吐出去。外部 HTTPS 仍由反向代理终结 TLS,这一层 Lume 不做。server.lume 把 12 个应用目录里的一类直接写成「同进程静态站 + API」:

out = push(out, { name: "static site + API in one process",
                  desc: "docroot static + route API · single binary process",
                  libs: "server{}", status: "ok" });

docroot 指向前端构建产物 web/dist,生产构建完成后同一个进程既吐 API 也吐静态资源。这让部署形态塌缩成一个二进制加一个端口:本地默认绑定 127.0.0.1(安全优先),容器里通过环境变量改成 0.0.0.0;外部要上 HTTPS 仍需反向代理做 TLS 终结——这一层 Lume 明确不做,文档里也写在前头,不假装覆盖。

数值与 ML:语言自带的算法版图

一门面向 Agent 的语言,如果每次算矩阵、解微分方程都要从零写循环,那胶水只是从 Web 层挪到了算法层。Lume 的回答是给常用数值与 ML 配专用标准库,src/algorithms.lume 把现状摆成 12 类:稠密矩阵乘(blas)、PINN、MLP 反向传播、线性代数(LU/QR/特征/SVD)、数值积分、梯度下降、k-means、一维热方程(PDE)、KL 散度、复数、信号平滑、图 BFS。每一条都带一个真实跑过的 mini demo,例如梯度下降收敛到最小值:

func demo_gd(): string {
  let x = 0.0;
  let lr = 0.1;
  for (let i = 0; i < 50; i = i + 1) {
    let grad = 2.0 * (x - 3.0);
    x = x - lr * grad;
  }
  return "gd_min=(x-3)^2 -> x=" + str(x);
}

更硬的是性能。server.lume 里的 bench() 收了三组实测加速比:

out = push(out, { name: "wall 1 · PINN analytic gradient",
                  from: "4.5 min (numeric)", to: "1.3 s (analytic)", speedup: 207, ... });
out = push(out, { name: "wall 2 · codegen vs C",
                  from: "1.00x (C)", to: "1.02x (lume)", speedup: 1.02, ... });
out = push(out, { name: "wall 3 · blas C kernel",
                  from: "0.60 s (pure lume)", to: "0.05 s (C kernel)", speedup: 12, ... });

207× 来自把 PINN 训练的数值梯度换成解析梯度,1.02× 是编译后端在标量循环上追平 C,12× 是 C 内核矩阵乘相对纯 lume 循环的加速。三组数字的测试条件也写在 bench() 的 note 字段里,可通过 /api/bench 原样取到:

数据 测试条件(源码 note)
207× 训练场景、编译后端;loss 0.573 → 0.00224,相对 L2 误差 1.43%
1.02× 标量循环,codegen 达到 C 的速度
12× 128×128 矩阵,30 次运行,结果逐位一致

这三条都是特定条件下的对比,不是「Lume 比某语言快 N 倍」的普适结论——207× 比的是解析梯度与数值梯度两种算法,12× 比的是 C 内核与纯 lume 循环两种实现。原文没有记录测试硬件型号,所以这里不补无法核实的环境参数;要横比请按同一条件重测。数字的合法性不取决于写在哪里,而取决于它们只从 bench() 经 /api/bench 流向前端图表——前端不能为了图形好看做任何数值加工。

Benchmark Methodology(已知边界):上面三行条件全部来自 server.lume 里 bench() 的 note 字段,/api/bench 原样返回,可自行核对。源码未记录 CPU 型号、编译参数、完整迭代配置与测量工具,因此这里不臆造实验环境——要横比请按同一条件自测。三组数据的意义是说明「哪种优化带来多大变化」,不是跨语言性能排名。

Agent 表面:内省内建、LLM 钩子与原生 ReAct

Lume 的定位是「面向 Agent 应用的 DSL」。它给开发者的不是一段参考循环,而是三层现成的表面:

先说清楚别误会:本页 showcase 的 Agent 演示用的是确定性策略,没有调用外部 LLM。上面说的原生 LLM 接入与 ReAct 执行由宿主运行时提供,公开演示刻意不碰它们,以保证三后端逐字节一致。

内省内建,定义在 lume-core 的 builtins_catalog.c:catalog() 一次给出 { skills, tools, mcps } 注册表快照,tools() 返回工具名、描述与 OpenAI 风格参数 schema,mcps() 返回网关与本地 MCP 服务器(带来源标记),skills() 列出具名技能。脚本里直接调用,不用自己解析配置文件。要注意这些是解释器侧能力:语言树自带的注册表是空的(签名与语义都在,只是没东西可枚举),宿主树从 agent-httpd 的注册表读表——同一段脚本跑在哪一层,决定它枚举出什么。

LLM 钩子:LLM_API_URL / LLM_MODEL(配合 LLM_API_KEY)经环境变量接入外部模型,后端外部、可选,语言不绑定某家厂商。数据发往哪个端点由你配置决定,涉及第三方时对出境内容要自行评估。

原生 ReAct agent,在宿主 agent-httpd 层:这是真正的多轮循环——agent.c 按 AGENT_MAX_ROUNDS(默认 8)逐轮调用模型,每轮把上一轮的工具执行结果作为 observation 回灌进 messages,模型据此继续决策,直到不再请求工具、由模型在末轮流出最终答案。工具结果连同错误信息(SQLite 的 errmsg 也写进结果文本)作为 observation 回灌,所以模型能据此再决策、重试 SQL;最终回答是模型生成的,不是宿主模板拼的。落到 SQL 场景:模型写 SQL,sql_query 在进程内只读执行(只有显式白名单才放开 sql_write),中间没有 Python、MCP stdio 进程或 Node sidecar。配上 SQLITE_DB 时,服务端把实时 schema、行数、样例值与外键提示注入 system prompt,模型按真名写只读 SQL 而不是靠猜;回答规则强制只引用返回行里的数字。

那 showcase 里的 src/agent.lume 是什么?它是这三层之上可定制的一例:刻意不碰任何解释器侧内建,用纯 lume 写了个确定性的 plan → act → observe → refine 循环(先平方再累加),为的是让三个后端对同一段代码逐字节一致——/api/agent 端点展示的就是它。换句话说,上面三层才是 Lume 自带的 agent 能力,这段循环只是「你也可以自己写一个」的示范,不是能力上限。

串起来:从自然语言任务到可执行的数值计算

把前面的层连起来,才能回答「为什么是 Lume 而不是 Go/Python/TypeScript」。看一条中性的任务链——用户给一句口语请求,系统要给出可信的数值结果:

用户:"对这组观测值做平滑,并估计最小二乘拟合的参数"
   |
   v
任务识别(宿主 ReAct agent,LLM 解析意图)
   |
   v
工具选择(catalog()/tools() 看到当前可用能力)
   |
   v
调用数值库(signal smoothing / linear algebra / gradient descent)
   |
   v
进程内执行(sql_query 取数 · lume 算法库算值 · 三后端可选)
   |
   v
真实结果回填(不是模型编出来的数字)
   |
   v
生成报告(结构化输出,可再落到静态站或 API)

这条链上每一环都是 Lume 已经内置的:内省让 agent 知道有什么工具,数值库让它有东西可调,原生 ReAct 让循环在宿主运行时里跑,内置 HTTP 让结果直接变成可访问的端点。单一语言覆盖「意图 → 工具 → 计算 → 输出」,省掉的是 Python 脚本 + Node 中间层 + 独立 API 服务这三段胶水——这才是它区别于通用 Web DSL 的地方。注意这里的能力是语言与运行时自带的,具体业务语义由你写的 .lume 脚本和接的模型决定。

应用全景:这门语言已经跑在哪

语言能力最终要看它能承载什么。server.lume 里的 apps() 列了 12 类形态,覆盖 HTTP API/Web 服务、科学计算 CLI、ML 训练与推理、PINN 求解、PDE 数值、数据管道、同进程静态站 + API、MCP 服务器、图/信号/统计工具、SQLite 存储、crypto/hash、最优化。每一行都标了 status: "ok",含义是功能已实现、有可运行代码——mini demo、CLI 工具、可部署服务都算,ok 不代表这一类里的每种应用都经过生产级验证(错误处理、监控、容量保障是另一回事)。这张清单不是 roadmap,它说明 Lume 已经从「一个能跑的编译器」走到了「围绕一门语言的应用版图」——其中哪些真跑成了系统,下一节看一个具体案例。

垂直应用:lume-scanner 把三层能力跑成一个系统

前面几节是能力盘点,这一节看它们怎么在一个真实业务里闭环。lume-scanner 是一个 A 股全市场技术信号扫描仪表盘:上游 stock-analyzer 的 Python ETL 每天算出信号与指标、落两张 SQLite 库;lume-scanner 用一个 Lume C11 二进制把这两张库只读服务成 HTTP API,前端是 React SPA,跑起来是一个进程、一个静态二进制。它是「Lume 能承载什么」的具体回答,不是又一个能力 demo。

它用到的正是前面三层:

能力层 在 lume-scanner 里的落点
内建 HTTP 单个 scanner.lume 用 server{} 声明 11 个 /api/* 路由加 /discovery,静态 SPA 与 API 同进程
数值与 ML 内建 /api/indicators/:code 用 Lume 内建实时重算 KDJ / Williams / ATR / OBV / MACD / RSI(Wilder + Cutler 两口径)/ 布林,外加夏普 / Sortino / CVaR / VaR 绩效面板——读原始 K 线,不读 ETL 指标列
Agent 表面 AI 聊天接白名单只读工具(scan_signals / stock_kline / sql_query 等),配了 LLM_API_KEY 才走模型驱动的多轮工具调用
原生 C11 / SQLite 单一静态二进制只读打开两张库,带用户输入的筛选走 ? 占位绑定,sql_query 物理 SELECT-only

最能说明「语义一致性」价值的是一处交叉验证:上游 Python ETL 用 pandas 算的 Cutler RSI,与 Lume 内建 rsi_cutler 现算的结果对得上。这里把统计口径说准:80 是 /api/signals 的默认 limit,即最新交易日按共振度降序返回的前 80 条信号,每条对应一只股票的 RSI 对照(不是 80 个指标或 80 组参数);对每条按 |Δ| < 0.05 记一次 match,实测 80/80 全部 match,观测差值为 0。判定阈值是 0.05 而非逐位相等,实测差值恰为 0 是结果、不是判据——这两层要分开看。core 侧量化内建另有跨三后端的一致性测试,并钉死到 Python 参照值。这不是巧合——两边被独立钉住,「Lume 算的 RSI」和「pandas 算的 RSI」才能写成等式断言。前面「一个前端,三条执行路径」讲的三后端逐字节一致,在这里落成了「和一套成熟 ETL 的计算结果对得上」。

聊天这里有两种模式,边界要讲清:配了 LLM_API_KEY 走模型驱动的多轮工具调用——模型理解问题、选白名单只读工具、拿真实返回作答;没配 key 走的是宿主 C 内置 demo 引擎,它逐字流式吐一段 canned reply,只认「问候 / agent-httpd / streaming / SSE」这类内置话题,不查库、不回答股票问题——存在意义只是让 SSE 流式链路在没有密钥时也能演示。它是降级兜底,不是一个能离线查询的备用 Agent。

只读不等于无脑读。180 天战绩的窗口函数扫一遍约 8.5M 行、耗时近 8 秒,所以数据按更新频率走分层 TTL 缓存(meta 5 分钟、signal-stats 30 分钟、daily-picks 10 分钟、实时行情 15–30 秒),并通过 /api/freshness 暴露库最后更新时间让下游判断新鲜度。安全边界同样写进架构:默认绑 127.0.0.1、对外要显式开 Basic Auth,read_file 锁在 web root 防目录穿越,数据库在容器里以 :ro 挂载。

边界要说清楚:lume-scanner 不生产信号——信号生成与回测留在 Python ETL 一侧,它只读消费并验证一致性;Lume 承担的是读侧的服务化、实时指标重算与可信呈现。数据来自公开行情源,项目是本地研究工具,不收集个人数据,所有结果不构成投资建议。11 个路由的设计、缓存分层与逐位对账的具体做法写在专文里;这里只关心它证明了什么——一门语言加一个静态二进制,能把「取数 → 计算 → 验证 → 呈现」这条链跑成一个可部署的系统。

部署成本:没有 Node,镜像约 12MB

一门语言能跑出应用还不够,得能便宜地铺开。Lume 在这件事上有个结构性优势:运行时是一个静态链接的 C11 单二进制,不带 Node、不带 Python、不带 JVM。少一个运行时,镜像里就少一整棵依赖树。

主镜像用 Docker 的 scratch 空镜像作基底——不含操作系统、编译链和包管理器,只装配静态二进制、busybox、CA 证书和静态资源。结果是一个约 12MB 的镜像(如果只要最裸的静态二进制,实测还能压到 5MB 以内)。作为对照,一个带 Node 运行时的同类服务镜像通常在百 MB 量级。镜像里没有 shell、包管理器和编译器,凭据只通过环境变量注入,攻击面也跟着缩小。

小镜像真正值钱的地方在云端:一台最低配的极简 ECS 就能按端口配多个 Lume 实例,每个实例换一份 .lume 脚本、一个端口和一份白名单环境变量,静态资源目录共用。这不是假设——Lume 主仓的 compose 文件(docker/docker-compose.yml)就是这样跑的:invest、hub 等多个 service 通过共用锚点共享同一个镜像与同一棵 docroot,各自只换一份 .lume 脚本、宿主端口和技能/工具白名单。

这里只讲能量化的收益:镜像约 12MB、单一静态运行时、没有 Node/Python/JVM 运行时依赖、多实例共享镜像与静态资源、容器部署与升级更简单。镜像小不等于单机能塞的实例数必然多一个量级——运行时内存和 CPU 占用还看具体负载,本文没有同硬件同负载的对照实测,所以不给这类结论。

对部署形态的意义是:把一个「跑一门语言的服务器」压成了「丢一个十几 MB 的镜像、开一个端口」。边缘节点、低成本云主机、一次性任务容器——这些过去要权衡要不要上完整运行时的场景,现在可以直接用一个 .lume 文件加一个小镜像填满。

当场验证:showcase 是窗口,不是主角

公开实例上的那部分能力,不需要读我这篇文章就能当场验证。这是 showcase 存在的理由——它是 Lume 能力的验证窗口,而不是被展示的项目本身。但要划清边界:宿主侧的 LLM 接入、内省内建与原生工具执行没有公开端点,它们由源码和运行时测试验证;showcase 的 /api/agent 只是确定性的纯 lume demo,不是宿主原生 agent 的在线演示。

先给出每一项能力对应的实现位置与验证方式:

能力 实现位置 验证方式
类型系统 lume-core /api/features
三执行后端 lume-core tests/smoke.sh
HTTP Server lume(agent-httpd) /api/health
数值算法 src/algorithms.lume /api/algorithms
Benchmark server.lume /api/bench
确定性 Agent src/agent.lume /api/agent
Agent 内省 builtins_catalog.c 宿主运行时测试(无公开端点)
LLM 工具执行 agent-httpd 集成测试(无公开端点)

前六项都能在公开实例上 curl 出来;后两项属于宿主侧,只能读源码或自己起宿主运行时验证——这张表就是为了避免把它们混为一谈。

六个数据端点由 server.lume 暴露、由解释器执行后返回:

/api/overview   /api/features   /api/algorithms
/api/apps       /api/agent      /api/bench

前端 web/src/api.ts 只解析 lume-core 返回的 { status, type, body } 信封,失败即抛错,没有本地常量可兜底:

async function getJson<T>(path: string): Promise<T> {
  const res = await fetch(path);
  if (!res.ok) throw new Error(`${path} -> ${res.status}`);
  const env = await res.json();
  return JSON.parse(env.body) as T;
}

于是页面上的每个数字都只能来自真实运行。条目、词条、详情之间的一致性由 tests/check_coverage.py 压成一个退出码:它从运行中的服务拉六类列表,逐条检查英文 name 是否同时命中 zhDict 与 content.ts 的详情表,缺失就退出码 1 并打印缺项。运行约束则收进镜像——Dockerfile 的健康检查判据不是「进程还在」,而是响应体里出现 "status":200:

EXPOSE 18793
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD wget -q -O - http://127.0.0.1:18793/api/health | grep -q '"status":200' || exit 1

镜像最终阶段不装 node、以非 root 用户运行,SQLite 需要的可写目录 /app/data 预先建好交给该用户,因此只读根文件系统下也能起服务。这些约束的目的只有一个:让「你可以这样重测」替代「我们测过」。

复现:三条命令

curl http://127.0.0.1:18793/api/health        # 期望 "status":200
curl http://127.0.0.1:18793/api/features      # 看 12 条语言特性由解释器真实返回
curl https://lume.erishen.cn/api/bench        # 公开实例上的三组加速比

前两条针对本地进程(按 README 起服务后),第三条针对公开实例——两者返回同一形状的 { status, type, body } 信封。想连容器一起验,就按 README 的 docker build + docker run --read-only 序列起镜像,健康检查与手工 curl 用的是同一条判据。

源码导航

三个仓库各管一层,按需取用:

线上:https://lume.erishen.cn

正文只写文件与符号,不列行号——行号随提交漂移,按符号名或关键句检索即可。

  • server.lume — 路由注册、apps()、bench()、server{} 与 run()
  • src/overview.lume — 「Lume 是什么」导览与 overview_sections()
  • src/features.lume — 语言特性自检与 feature_list()
  • src/algorithms.lume — 12 类算法 demo 与 algorithm_list()
  • src/agent.lume — 可定制的纯 lume agent 循环示例与 agent_list()
  • tests/check_coverage.py — 条目/词条/详情漂移检测
  • tests/smoke.sh — 三后端逐字节一致性
  • Dockerfile — 只读容器与健康检查
  • web/src/api.ts — 信封解析与六个数据入口

这篇和《Lume:C11 单二进制的 Agent DSL 服务器》那篇有什么不同?

分工不同。那篇往里看:bridge.c 的桥接契约、fork 后的 VM 复用、值栈即 GC 根的内存模型,逐行对源码解剖。这篇往外看:语言交到你手上有哪些能力(类型内核、三后端、内建 HTTP、算法库、agent 表面),以及怎么在一个公开实例上把每条当场验一遍。想审实现读那篇,想知道能用它做什么、以及是不是真的,读这篇。两篇合起来是 Lume 的全貌。

三后端逐字节一致到底在验什么?

tests/smoke.sh 分别用解释器、手写 IR 文本后端与 libLLVM 后端起服务器,对每个 /api/* 端点比对 JSON 是否逐字节一致。代价是解释器侧的一些内建(如带 SSRF 闸门的 http_get、agent 内省接口)不进编译后端,showcase 的 agent demo 因此只用纯 lume 实现,以保住这份一致性。

Lume 的 agent 能力是自带的,还是要自己写?

自带的是三层——catalog()/tools()/mcps()/skills() 内省内建、LLM_API_URL/LLM_MODEL 外部模型钩子、宿主侧原生 ReAct。showcase 里那段纯 lume 的 plan → act → observe → refine 循环只是可定制的一例:它刻意不调外部 LLM,好让三后端逐字节一致;不代表 Lume 只能这样跑 agent。两类能力在文档里分得很清楚,前者才是语言递到你手里的东西。

文章里的性能数字可信吗,怎么自己复核?

三组加速比来自 bench() 的真实测量,只经 /api/bench 流向前端。curl https://lume.erishen.cn/api/bench 就能拿到原始数值;页面图表不加工数据,tests/check_coverage.py 保证条目和详情不漂移。数字本身是历史测量值,反映的是当时那组 benchmark 条件。

评论

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

商店 Web Chat Nsbp 关于 隐私政策

@ 2026 ESN
沪ICP备2024079226号-1   沪公网安备31010502007082号