26 篇博文含有标签「MoonBit」

MoonBit Pilot：全球首个自底向上的代码智能体，全栈 AI 原生

2025年7月30日 · 阅读需 10 分钟

通过从语言到工具链的 AI 原生重构，IDEA 研究院基础软件中心 MoonBit 团队打造的 MoonBit Pilot 构建出与大模型深度协同的开发环境，在代码生成质量与大规模重构效率上均超越 Cursor 等现有智能编程工具，首次呈现无需人类接管的 L4 软件交付能力的工程闭环雏形。

MoonBit Pilot 优势一览

从代码生成到软件级合成

MoonBit Pilot 不仅能够辅助补全若干行代码，还通过 prompt 驱动、大模型推理与 MoonBit 语言工具链的高效联动，真正实现工业级软件的全自动化开发。
并行协作快速攻克复杂任务

依托 MoonBit 工具链与先进的 Segment 并发机制，MoonBit Pilot 已进化成为具备状态感知能力的流水线式 Agent 系统。它支持多任务并行处理，系统中的每个子 Agent 如同生产线的精密组件，围绕用户需求高效协同，从而快速攻克复杂任务。
开放API降低接入门槛且支持上云

MoonBit Pilot 进一步提供开放 API 接口，可轻松连接第三方系统（如CI/CD、IDE 插件、AutoCoder、代码审查系统等），极大降低系统接入门槛，使开发者和企业能以极低成本快速享受类 Devin 式的自动化开发体验。

MoonBit Pilot 可高效部署在云端，用户可彻底脱离本地编码过程，专注效果验收与代码审查，实现生产力跃升。

从底层语言适配AI,深度激发大模型潜能

大模型赋能下，软件工程领域正发生革命性的变化。代码智能体（Coding Agent）不再只是人类开发者的生产力工具，而是成为具有端到端交付能力的软件合成引擎，可覆盖软件开发全生命周期并深度渗透多行业，带来效率跃升与成本锐减，推动产业协作模式重构，这其中孕育着万亿美元的商业价值。

然而，当前市场上的代码智能体依托基于人与机器交互的旧式工具，未能打造 AI 直接与机器交互开发的友好环境，限制了 AI 开发的效率与潜力。

alt text

只有从底层开始就设计一整套原生的AI开发者工具 (Agent Devtools Interface)，与大模型垂直整合，才能更好地发挥大模型的潜能。

基于 AI 原生环境下的开发者工具，通过语言、工具、模型三个层面的深度联动，可实现更精准的需求转化、更低的错误率，显著提升代码生成的效率与可靠性，能够支持更复杂的端到端开发任务，如全流程软件合成、动态代码重构，突破传统 “辅助工具” 的边界。

在这一愿景下，MoonBit Pilot 诞生 —— 从最基础的编程语言到工具链（编译器/调试器/包管理），全栈基于 AI 原生设计重构，在各环节为大模型提供有效反馈。

MoonBit Pilot 不仅能自动高效地生成完整软件库，还附带结构化文档与高质量测试用例，这将帮助企业在保障质量的基础上降低开发成本、加速交付效率。

在软件工程中最关键环节之一的大规模代码重构中，MoonBit Pilot 也展现出领先优势，表现超过了“主流编程语言 + 最强大模型”的组合，在开发过程中高效解决此关键痛点，将助力企业快速应对技术迭代，提升竞争力。

MoonBit Pilot 能力展示

零干预合成高质量软件库

下面我们用 MoonBit Pilot 一键生成 TOML 语法解析器作为示例展示其软件合成能力：

TOML 是一种配置文件格式，设计初衷是简单易读、易写，并能清晰表达嵌套的数据结构。它常用于项目配置文件，特别是在 Rust 生态中被广泛使用。

我们打开 vscode 运行测试：

我们注意到，大模型在最初生成代码时由于缺乏 MoonBit 语料，并未直接输出正确结果。但在自动调用 MoonBit 自研工具链并获取精确反馈的过程中，模型无需人工干预便完成了修复与优化，最终成功输出正确代码，并自动添加了有效测试，整个过程耗时仅约 6 分钟。

不只是 TOML, MoonBit Pilot 在很短时间零人工干预合成了 ini-parser, lisp 解释器等更多示例，这些合成的软件库也将被用于下一代基模的训练中，更好地提升 MoonBit Pilot 的软件合成能力。

ini-parser >> https://github.com/bobzhang/ini-parser

lisp >> https://github.com/bobzhang/lisp-machine-MoonPilot

支持超大规模代码重构，提升代码质量

原生语义查找，降低推理成本

AI 生成的代码一个普遍痛点是缺乏可维护性，提升代码可维护性的最重要方法之一就是安全重构。不同于传统智能体依赖 grep 等基于正则的代码查找方式（既低效又不准确，还大量消耗上下文窗口），MoonBit Pilot 提供了原生的语义查找工具，能够一键精确定位代码定义。这不仅提升了交互体验，更重要的是显著减少了 token 浪费，从本质上降低了推理成本，是 Coding Agent 系统中少有的“具备实际节省支出的能力模块”。

这里以一个简单的函数重命名作为示例：

假设我们需要将标准库 Core 中的 Array::length() 改名为 Array::len()，我们先发出 prompt 指令：can you add 'Array: :len' which is the duplicate of 'Array:: length' and deprecate the latter

alt text

可以看到，MoonBit Pilot 短时间内即可正确地完成任务。

alt text

分段编码，快速的高并发重构

传统 Agent 在执行此类修复任务时效率极低，往往需要反复调用构建系统获取警告信息，并以串行方式逐一调用大模型进行修复，每次调用可能耗时十几到几十秒，完整修复过程可能持续数十分钟。

同时，这类 Agent 缺乏对警告的结构化处理，导致上下文信息冗杂、重复，进一步干扰大模型的判断与执行效率。

MoonBit Pilot 充分利用底层的 Subagent 机制以及 MoonBit 语言自身提供的分段机制避免并发提交和验证中的竞争与隔离问题，确保并发后的结果能有效合入，实现了真正意义上的多 Agent 并行修复能力，在类似任务场景下，相比传统 Agent 工作流可以实现 5 至 10 倍的效率提升。

速度远高于 Cursor, Codex

在修复一个由 MoonBit 编程语言构建的包含 126 条警告的大型项目实际场景中，与市面上主流的编程代码助手 Codex（由 OpenAI 研发）和 Cursor（行业领先）对比，MoonBit Pilot 仅用1/5的时间、零人工干预完成了任务。

Codex CLI ：35 分钟之后仍然没有完成所有警告的修复工作，且需要中途加入额外的对话内容才能继续任务。

Cursor ：16 分钟后因为触发最大工具调用次数而中止，此时剩余警告数并不为 0，在相同提示词的情况下同样会触发串行的警告修复任务。

相比之下，MoonBit Pilot 在约 7 分钟时间内完成了上述所有 126 条警告的修复任务。并且最终实现从代码到文档的全面修改替换：

值得注意的是，大部分 Agent 和语言工具链的组合往往只能完成代码的修正工作，但得益于 MoonBit 语言对 Markdown 格式的特殊支持，MoonBit Pilot 也能确保 .mbt.md 文档中代码的正确性。

另一种范式：云端异步编程，零人工干预

Cursor 和 Codex 需在用户本地电脑运行且依赖频繁交互，难以支持高并发运行（如同时启动十余个任务）。

MoonBit Pilot 不同于以往基于 VSCode 的 AI 智能体，它不再依赖传统的 LSP (Language Server Protocol) 获取反馈，而是采用一套内部高度定制的 ASP (Agent Server Protocol)，可以脱离 VSCode 等 GUI，高效部署在云端并取得同样效果。

迁移至云端后，用户可彻底脱离编码过程，专注效果验收与代码审查，实现生产力跃升。

以下是使用 Web 端版本的 MoonBit Pilot 在一个真实 MoonBit 项目 https://github.com/moonbit-community/cmark.mbt 中进行自动警告修复的例子。在进入任务总览视图后，可以点击“新建按钮”创建一个新任务。在新建任务页面，我们可以指定目标仓库，并在提示词中说明我们的意图，即修复项目中的所有警告：

alt text

稍等一段时间之后，我们便可以看到任务已经变为完成状态。

alt text

点击任务卡片可以查看本次任务的用时、对话历史、控制台输出等详情：

alt text

在对话历史的末尾，可以看到 MoonBit Pilot 已经成功创建了与修复内容相对应的 GitHub Pull Request：

alt text

此 Pull Request 描述和内容完整，CI 检查顺利通过，可以直接合并。 alt text

MoonBit 社区基于 MoonBit 的语义基础和 Agent 的智能协作机制，致力于从简单的“写代码”迈向高效的“构建软件”新范式。

团队预计将在接下来的半年时间中，通过 MoonBit Pilot 完成 MoonBit 语言生态的自举。此过程也将为 MoonBit Pilot 提供海量的训练语料和经验积累，使 MoonBit Pilot 最终达到L4级别的软件自动交付。

一键安装

MoonBit Pilot 面向所有用户支持桌面端一键安装体验：重新执行官网安装命令，即可通过 moon pilot 启动 MoonBit Pilot的命令行版本：

https://www.moonbitlang.com/download#moonbit-cli-tools

云端 Web 版本采用定向邀请制开放，MoonBit 正逐步邀请一批对智能体编程、语言工具链感兴趣的开发者参与体验。欢迎感兴趣的用户发送邮件至：jichuruanjian@idea.edu.cn，附加（Github ID），申请开通web 端权限

IDEA 编程语言 MoonBit 进入Beta版本，构建下一代基础软件系统入口

2025年6月18日 · 阅读需 15 分钟

cover

软件定义世界，语言定义软件。MoonBit 是AI时代的编程语言，也是下一代基础软件系统的新入口。

IDEA研究院编程语言 MoonBit 在架构稳定性和工程实用性上取得关键突破，发布 Beta 版本，正式迈入可落地应用的新阶段，并逐步演进为可被实际部署的基础设施技术。

进入 Beta 版本的 MoonBit，具备以下优势特性：

语言特性进入稳定期：目前 MoonBit 已覆盖工业级开发所需的语言特性与工具链支持。现有语法和语义将保持向后兼容，未来的更新将尽量避免破坏性修改。
改进流程更标准化：语言层面的进一步优化将通过公开、透明的 RFC 流程与社区共同讨论，确保演进方向清晰、稳定、可协作。
异步支持三大优势：MoonBit 在语言层面提供了错误处理与异步编程的支持。MoonBit 对错误处理和异步编程的支持有三大优势。
- 安全性
  
  大部分编程语言在静态分析中，彻底放弃错误处理的支持，这意味着任何函数都可以抛出异常，很难写出高可靠性的代码，MoonBit 通过准确的控制流分析，可以完全在编译时期跟踪函数的错误，用户只需要在顶层标记用作文档的签名。这一过程几乎完全由编译器自行推导，而又不像 Java checked exception 那样过于繁琐，对用户带来较高的心智负担；
- 编写便捷性
  
  在 MoonBit 中，带有错误和异步操作的函数使用起来就像普通函数一样便利，无需任何特殊标记，也无需修改程序结构；
- 可读性
  
  MoonBit IDE 会给带错误的函数标注「下划线」、并将异步函数标记为「斜体」。用户在编写代码时无需写任何特殊标注，但依然能在阅读代码时快速定位到带有错误/异步的关键操作。

构筑差异化技术壁垒，构建云原生系统与底层框架

MoonBit 在语言设计上已达到阶段性稳定，并逐步从实验性工具发展为可用于实际生产环境的基础技术，获得技术社区和产业界的关注。

过去几个月，MoonBit 已在多个真实项目中被用于构建云原生系统与底层框架，开始展现工程实用性与生态可塑性。

厂商视角：从关注到技术试点

海外云服务厂商GolemCloud 已通过构建完整的 MoonBit WebAssembly SDK 并投入实际运行；成功推动项目收录进入 Extism 官方插件库 。

其 CEO John A. De Goes 在今年与 MoonBit 团队负责人张宏波于 WASM I/O 会议线下交流后，公开表达了对 MoonBit 技术路线的关注。他在 X 平台表示：

“MoonBit 融合了 Rust 的语义特性，引入 GC，同时在工具链和性能方面有很多值得深入探索的亮点。”

随后他宣布，在 2025 年由 LambdaConf 组织的 GolemCloud Hackathon 活动中，将考虑正式采用 MoonBit 作为比赛语言之一。

MoonBit 的实际能力也逐渐引起技术型企业关注。国际知名 AI 工程平台的开发负责人在社区提出：

“我们团队正在评估将 MoonBit 用于某个关键系统组件的可行性，希望获得语言作者的付费咨询支持。MoonBit 的架构设计已经接近我们使用的门槛，如果能获得语言团队的技术协作，我们将更有信心在此基础上进行关键性技术投入。”

企业微信截图_1750219884397.png

各种信号表明， MoonBit 已不再仅被视为“关注中的技术”，而是开始进入企业的项目选择视野。

高校教育：纳入课程实践工具

因具备现代工具链和更贴近工业实践的语法设计，同时拥有强类型、模式匹配、函数式编程等教学所需的关键语言特性，MoonBit正逐渐得到高校教学的青睐；

今年3月，北京大学研究生院《编程语言的设计原理》课程大纲正式发布，创新性的将MoonBit纳入课程，取代OCaml成为课程推荐的实践工具，早前在清华大学暑期实践课程，2024 亚洲和太平洋地区信息学奥林匹克以及中国科学院软件研究院PLCT实验室联合发起的甲辰计划中，MoonBit也已深度参与进入校园。

AI 协同开发与国产芯片适配双轨演进

MoonBit 的技术路线自立项以来始终聚焦两大方向：AI 协同开发与软硬件融合能力。在 Beta 阶段发布的同时，MoonBit 已逐步建立起一套难以被复制的语言能力边界，这些能力不仅支撑其在研发一线的广泛适配，也为未来生态拓展提供长期技术护城河。

面向 AI 协同的开发语言：构建双向智能通道

随着大模型驱动开发模式的逐步成型，编程语言如何与 AI 高效协作成为关键问题。MoonBit 在语言设计上原生考虑了 AI 编程需求，强调双向可读性与结构性可操作性：

双向可读性 AI 生成的代码保持高度可读性，结构清晰、风格一致，便于人类理解与接续开发；反向也成立，MoonBit 的语法具备良好的上下文表达力，AI 更容易理解变量作用域、函数调用链、控制结构等核心语义，从而提升补全与重构质量，减少传统编码助手的「断片化建议」。
重构安全机制 借助静态类型系统与编译器推导能力，MoonBit 能对 AI 生成的代码变更进行自动语义校验，确保不会破坏原有逻辑，避免因重构带来的回归错误。这一机制被视为“为 AI 编程加装安全缓冲”，使人机协同在效率与稳定性间取得更好平衡。
可感知的调试体验 传统调试过程往往依赖断点设置和逐步排查，效率受限。MoonBit 引入了 IDE 级别的 value tracing 机制，使 AI 能在运行时动态捕捉变量变化轨迹，辅助开发者在无需中断程序的情况下，快速识别异常路径与关键数据状态。
模块化构造与多任务 AI 赋能 MoonBit 的模块化设计使得每个函数、类等语言单元具备高度自治性，AI 可并行处理文档生成、测试覆盖、接口校验等任务，开发者可专注于核心逻辑，从而形成类似“多线程编程”的高效协同开发流程。

从目前已公开的对比数据看，MoonBit 内置的 AI agent moonagent相比 Codex-cli（OpenAI）可实现近 2 倍提效，支持多段并发处理与智能修改推理，展现出更强的 AI 编程协同能力。

MoonBit 内置 AI agent（moonagent）与 OpenAI 出品的 codex-cli 工具在处理同一编程任务时的性能差异

向下延伸至国产芯片支持：从工具语言迈向系统构建引擎

在另一关键维度上，MoonBit 也在积极探索软硬件融合的语言支持能力，特别是在国产芯片架构上的适配上取得突破。

面向 RISC-V 与国产嵌入式平台构建 MoonBit 支持原生后端代码生成，可编译为静态链接、零依赖的本地可执行文件。2024 年已完成对 RISC-V 指令集的适配，在无需依赖传统 VM（虚拟机）或运行时环境的前提下，即可部署于多种边缘计算与 IoT 设备中。
ESP32-C3 是国产主控芯片中使用较广泛的 RISC-V 架构代表。MoonBit 已在该平台上完成编译器适配，并在 QEMU 模拟器 + ST7789 显示器环境中实测，运行效率与 C 语言实现基本相当，延迟控制在 0.5ms 内。

生名游戏2.png

Beta 版：工具链打磨与语言层面深度融合

作为最早支持 WebAssembly 的编程语言之一，MoonBit 天然契合高性能、低延迟、跨平台的分布式系统开发需求。在浏览器、边缘节点和轻量微服务等场景中，MoonBit 可通过 Wasm 实现快速部署与高度可移植性，同时保持极低运行时开销，为“一次编写，任意运行”的开发模式提供了切实可行的路径。

更重要的是，MoonBit 还带来了具备“修改即响应”特性的即时反馈开发体验。开发者可直接在 Web 环境中编写、运行与调试代码，极大提升开发效率。这种体验目前在主流语言体系中仍属稀缺，也正是 MoonBit 在工具链打磨与语言层面深度融合下取得的重要成果。

下面是一个著名命令行程序 cat 的简单版的 MoonBit 实现。这段程序包含了对多个不同来源操作的错误处理、异步操作等，实际控制流非常复杂。但在 MoonBit 中，这段程序编写起来非常自然简洁，没有任何语法噪音。同时，得益于语法着色，阅读代码时很容易捕捉到几处异步/带错误的关键操作。

async fn cat(files : ArrayView[String]) -> Unit raise {
  if files is [] {
    @async.stdin.read_streaming() // read from stdin only once
  } else {
    for file in files {
      if file is "-" {
        @async.stdin.read_streaming() // read from stdin
        continue
      } else {
        @async.path(file).read_all()
      }
    }
  }
}

【READ MORE】MoonBit 的三年探索历程

近年来，中国在芯片、操作系统、数据库等关键技术领域不断攻坚，已逐步建立起自主生态。然而，国内主流语言的设计、工具链与标准，仍高度依赖于国外技术力量。

在 AI 驱动的软件变革中，如何构建具备本土主导性、面向未来算力架构和智能协同模式的编程语言体系，是我国基础软件领域形成技术护城河的重要课题亟需正视的重要课题。

作为一门具备自主设计、原生 AI 支持、高性能执行能力的静态类型语言，MoonBit 自 2023 首次公开以来，在编译器架构、运行性能、多后端适配和 IDE 工具链等多个维度实现关键突破，并在国际技术社区获得广泛关注。

2023：核心技术突破与首次公开

发布 WebAssembly 后端：在体积控制和运行效率方面优于 Rust、Go 等主流语言，尤其适用于边缘计算与资源受限场景。
推出工业级在线 IDE：支持离线运行，首次实现“开箱即用”的云 IDE 原型。

2024：生态扩张与后端布局

发布 JavaScript 后端：MoonBit 编译生成的 JS 在实际项目中展现出显著性能优势，引发日本 Zenn.dev 和美国 InfoWorld、《The New Stack》等技术媒体报道。
完成三大后端技术布局：WASM、JavaScript、Native 后端同时落地，覆盖从浏览器到硬件、从前端到系统层的全栈开发场景。
原生后端支持 RISC-V：MoonBit 可生成静态链接、零依赖的可执行文件，在嵌入式、IoT 等领域实现部署落地。
获得首批商业用户：数据库公司燕几图基于 MoonBit 构建相关平台。
举办全球创新编程挑战赛：吸引上千支队伍参与，推动语言在真实项目场景中的应用验证。

2025：学术融合与国际亮相

纳入北大研究生课程体系，作为现代语言设计与系统编程的综合教学平台。
获得 OS2ATC 年度硬科技创新奖
受邀参加国际学术会议 WASM I/O 和 LambdaConf 发表主旨演讲，进一步扩大国际影响力。

IDEA研究院基础软件中心首席科学家张宏波在编程语言与开发工具领域已有近二十年的持续探索。他曾深度参与 OCaml 核心开发、主导创建 ReScript 编程语言，相关成果已被 Meta（Facebook）在 Messenger、Chats 等项目中采用，并参与 Flow 静态类型工具的开发。

面向文档(Markdown)编程：MoonBit 的创新开发体验

2025年6月4日 · 阅读需 7 分钟

cover MoonBit 自诞生以来，始终致力于为开发者提供极致的开发体验。通过整合编译器、构建系统和 IDE 等核心组件，MoonBit 正式推出“面向文档编程”（Document-Oriented Programming）的创新概念。这一功能在 Markdown 文档中无缝集成了代码静态分析、IDE 原生支持、自动化格式化、测试运行和调试等功能，为开发者带来前所未有的文档与代码协同体验。与传统的编程模式相比，MoonBit 的面向文档编程突破了将文档嵌入源代码注释的局限。传统方式（如通过注释记录 API 文档）适合简短说明，但难以承载详细的文档内容或可运行的代码示例。

虽然一些编程语言（如 Rust）支持文档中的代码高亮和测试，MoonBit 在此基础上进一步扩展，提供了更强大、更自然的文档编程体验：在 Markdown 文档（.mbt.md 文件）中的 MoonBit 代码块与常规 .mbt 源文件享有相同的工具链支持，真正实现 “文档即代码，代码即文档”。借助 MoonBit 工具链，在 Markdown 文档中进行编程的过程如下：在某个包中新建 Markdown 文档，注意该文档需以 .mbt.md 结尾，这是 MoonBit 工具链识别文档的标志。

使用方式

在 MoonBit 项目中，只需在某个包中创建一个以 .mbt.md 结尾的 Markdown 文档，即可启用面向文档编程功能。.mbt.md 是 MoonBit 工具链识别文档的标志，文件中的 MoonBit 代码块将获得与源代码一致的开发支持，享受与 .mbt 文件相同的功能支持，包括但不限于：

代码高亮：语法高亮，增强文档可读性。
跳转到定义：点击符号跳转到其定义位置。
代码补全：提供类型引导的智能补全建议。
实时诊断：检测代码中的警告和错误，实时渲染在 IDE 中。
自动化格式化：一键格式化代码块，保持风格一致。
测试运行：支持文档中的测试代码运行。
调试支持：在文档中直接调试代码。在该文档中通过 ```mbt 或者 ```moonbit 声明代码块，写在这些块中的代码便能享受到原生的 IDE 功能支持：

IDE 支持

MoonBit 的 IDE（基于 VS Code 插件）为 .mbt.md 文件提供了原生支持，极大提升了文档编程的效率。以下是一些实用的功能：

便捷的代码块插入：

MoonBit IDE 提供专用的代码片段（code snippet）。在 .mbt.md 文件中输入 mbt 并触发补全，即可自动插入 ```mbt代码块，简化编写流程。

自动化格式化：

每个 MoonBit 代码块上方显示 CodeLens 按钮（如 Fmt），点击即可一键格式化代码块，保持规范一致的代码风格。

测试与调试：

支持在 .mbt.md 文件中编写测试代码块（test block），通过 moon test 或者代码块上方的 Test CodeLens 自动运行。
支持调试功能，开发者可以在文档中设置断点，直接调试代码逻辑。 MoonBit 对于 .mbt.md 提供的是开箱即用的原生支持，也就是说，.mbt.md 中的代码和常规的 MoonBit 代码是一样的（在实现上我们将其作为黑盒测试处理），用户可以像写黑盒测试一样通过 @pkg.xxx 使用本包中的 pub 定义。

工具链支持

MoonBit 的构建系统（moon）对 .mbt.md 文件提供全面支持，与常规 .mbt 文件无缝集成：

静态分析：
- 运行 moon check 时，工具链会自动检查 .mbt.md 文件中的 MoonBit 代码块，输出警告和错误到控制台。
- IDE 实时检测代码中的类型错误、未定义符号等问题，确保文档代码的正确性。
测试运行：
- 运行 moon test 时，工具链会自动执行 .mbt.md 文件中的测试代码块，与常规测试文件（如 _wbtest.mbt、_test.mbt）一起运行。
- 测试结果统一输出，方便开发者验证文档代码的正确性。
构建集成：
- .mbt.md 文件中的代码块被视为黑盒测试，参与构建流程，确保文档与源代码一致。
单文件支持：
- 可以通过 moon test /path/to/xxx.mbt.md运行不在某个包中的 .mbt.md 文档中的测试。若是该 .mbt.md 文档存在于某个包中，在包含该包的项目目录下直接运行 moon test 即可。另外，即使是单个 .mbt.md 文档（不在某个包中），也可以使用第三方依赖（通过文档首部的 header 声明，示例如下），赋予文档编写极大的灵活性。

---
moonbit:
  deps:
    moonbitlang/x: 0.4.23 // 第三方依赖
  backend:
    js                    // 指定运行后端
---

```moonbit
test {
    let single_mbt_md = 1
    let path = "1.txt"
    let content = "Hello, MoonBit"
    @fs.write_string_to_file!(path, content)  // 使用 moonbitlang/x 中的 fs 包
    let res = @fs.read_file_to_string!(path)
    inspect!(res, content=content)
    inspect!(234523)
    println("222")
}
```

用 `.mbt.md` 写技术博客

借助 .mbt.md 文件，开发者可以直接在 Markdown 格式的技术博客中嵌入可运行的 MoonBit 代码，享受 IDE 和工具链的全程支持，如：

实时验证：代码块中的拼写错误（typo）或逻辑错误会被 MoonBit 工具链实时检测，避免博客中出现无效代码。
一致体验：博客编写过程与编码一致，支持代码高亮、补全、跳转等 IDE 功能。
可运行示例：读者可以直接复制代码块运行，或通过 .mbt.md 文件复现示例。

这种方式特别适合撰写教程、API 文档或技术文章。现在有许多优秀的静态博客生成框架，支持将 Markdown 文件直接渲染为漂亮的网页。我们以 hexo 框架演示用 .mbt.md 写技术博客的过程：

用 CI 确保文档代码始终正确

MoonBit 的工具链为 .mbt.md 文件提供强大的静态分析支持，结合持续集成（CI）可以确保文档代码始终与源代码保持一致以及文档中的代码始终能够编译以及通过单元测试，一旦因为源代码改动导致文档代码发生 breaking change 也能第一时间发现并修改，避免了文档滞后于代码的常见问题，提升了文档的可信度。 moonbitlang/core 项目已经全面接入 .mbt.md 文档，其中每个 package 的 README 都以这种格式书写，以详细的文档配合代码示例说明该包的用法，一旦包中的某个 api 改动导致文档中的测试运行失败，moonbitlang/core 的 CI 会立刻报告错误，此时开发者便能及时修复源代码中的 bug 或者更新文档以适应新 api。

总结

MoonBit 的面向文档编程重新定义了文档与代码的协作方式，通过 .mbt.md 文件将 Markdown 文档提升为可执行、可验证的开发环境。借助 IDE 的原生支持、工具链的静态分析和 CI 的自动化验证，开发者可以在编写技术博客、API 文档或教程时享受与编码一致的体验，MoonBit 提供了其他语言难以企及的文档编程体验。欢迎尝试 .mbt.md 的 MoonBit 专属文档，体验代码与文档的完美融合！

MoonBit：为 AI 与大型系统而生，无缝调用 Python

2025年5月23日 · 阅读需 10 分钟

引言: MoonBit 正在为开发者提供一种全新的路径：不必舍弃 Python 的生态优势即能获得更严谨智能、适合大型系统与 AI 编程的开发体验。在近二十年的开发实践中，Python 为大量应用领域的开发者打开了技术民主化的大门。Python成功的背后，是一整套逾千万开发者共同维护的应用库和依赖组件经济。其丰富的应用库已全面覆盖各类开发场景和行业需求。

然而，进入人工智能时代，Python曾经的“易学易用”，在面对更大、更复杂的任务时，反而成了一把双刃剑：简洁带来了开发门槛的降低，也带来了在类型安全与系统扩展性上的结构性不足。工业界也因此对一种新型语言的需求日益迫切：它需要既能兼容 Python 已建立的庞大生态，又具备类型安全、静态分析与高可维护性的现代语言特性。

在 AI 工具链的加持下，MoonBit 的实践验证了实现上述需求的可能性，让编程语言可通过“生态继承”而非“生态重建”实现迭代。

MoonBit的技术路径为行业提供了启示：

生态复用模式：通过 AI 自动化封装，降低跨语言调用门槛，避免重复造轮子，加速技术栈升级。
静态类型普惠化：将严格类型系统与 AI 代码生成结合，既保留 Python 的灵活性，又弥补动态类型的系统性缺陷，推动开发者向更安全的编程范式过渡。

无缝融合Python 生态

Python简单易学、生态丰富，适合小项目开发，但难以胜任复杂大型系统的构建。在大模型面前，Python的短板逐渐明显：

动态类型 → 一旦规模复杂，运行时错误频发，缺乏编译期防护。
保守语法 → 缺乏现代语法导致难以清晰地表达复杂和高度抽象的逻辑。
对 AI 编程不友好 → AI 编程依赖静态类型系统、清晰可分析的错误信息，以支持高质量的代码生成与自动修复。然而，Python 在静态分析能力和错误提示方面存在明显不足。其错误信息往往零散、不具结构性，难以形成有效的上下文推理，既限制了 AI 在大型项目中的参与能力，也降低了自动化调试与修复的准确性。

Rust 、C++ 、Ocaml、Hashell 等编程语言都曾尝试吸取 Python 丰富生态的优势，去其糟粕。原理是首先通过CPython的API调用Python解释器获得Python对象，进而再使用语言本身的类型系统和语法进行管理。

但是在没有 AI 代码生成工具时代，后续的库的拓展开发所需要耗费的精力太大，所以至今难以全面完成。而且这几门编程语言学习曲线过于陡峭，对于 Python 用户来说缺乏动力去替换。

MoonBit 借鉴了 Rust、C++ 等语言对 CPython 的集成和类型管理经验，并在此基础上，进一步结合了自研的「moon-agent」智能体框架（即将公开上线）。

通过 AI 驱动的自动封装机制，MoonBit 可批量生成对主流 Python 库的高质量绑定。一旦封装完成，结合 MoonBit 的原生构建系统，用户可在不抛弃原有 Python 资产的前提下，获得更强的类型系统、更智能的 IDE 支持与更精确的 AI 代码生成能力。备注：「moon-agent」智能体框架即将公开上线

国际关注

自 2023 年底开源核心编译器并发布 WASM 后端后，MoonBit 受邀亮相WASM I/O 2025，成为首个登上该全球 WebAssembly 核心大会的中国开发者平台。 随后，MoonBit 也在刚刚结束的国际顶尖函数式编程会议 作为唯一受邀的国产语言项目，登上了编程语言与系统架构领域重量级会议 LambdaConf 2025，与 Jai 编程语言作者 Jonathon Blow、新加坡前总理李显龙之子、 Scala 社区核心贡献者李浩毅等开发者代表同台演讲。在这两场国际会议上，MoonBit 展示了其在语言设计、异步模型、工具链构建等方面的进展，代表了中国语言研发项目在全球开发语言演进中的全新探索。海外照片

MoonBit的优势

AI原生设计：MoonBit 在语言设计层面即高度适配 AI 编程需求，内部实际场景测试中已实现“千行级代码零改动一次跑通”的成果。
工具链先进、体验统一：从语言本身、到文档内联代码校验、再到 IDE 与构建系统，MoonBit 提供一体化的现代开发体验。
更低学习门槛，更快迁移路径：相较 Rust、C 等语言，MoonBit 学习曲线更平缓。

对不同层级用户的使用体验：

对初级用户而言：MoonBit 提供完善的类型系统、编译器静态分析、详细的错误提示，有助于一次性写出更健壮、稳定的代码。
对高级用户、企业级用户而言：MoonBit 让团队可以直接在 MoonBit 中使用现有的 Python 资产，无需重写或迁移，从而安全地构建大型系统。
对生态贡献者而言：绑定 Python 库比绑定 C 库要简单得多。只需要编写 MoonBit 代码和部分 Python 代码，而无需处理 C 库的链接器、头文件位置、C Wrapper 等底层细节。

以下两个案例可以直观的体验MoonBit无缝融合Python生态。

例-1 双摆，turtle 绘图工具，绘画双摆（封装好）

调用 Python turtle 库进行物理系统模拟，底层调用 Python turtle 这是一个通过封装 Python turtle 库实现的 MoonBit 示例。整段绘图逻辑完全使用 MoonBit 语法编写，用户无需接触任何 Python 代码，即可实现图形绘制。这种体验不仅继承了 Python 图形库的成熟能力，更充分发挥了 MoonBit 编译器的类型检查、自动补全和错误提示等工具链优势。从开发者视角来看，虽然底层依赖的是 Python 原生的 Turtle 实现，但封装后的接口在语义上已高度 MoonBit 化：调用方式更加简洁，参数具备明确的类型与可推导性，逻辑结构也更具可组合性与可维护性。这一案例充分体现了 MoonBit 在生态融合方面的设计思路——通过自研的封装与构建机制，MoonBit 可以以最小成本复用 Python 丰富的类库资源，避免了绑定 C 库时常见的链接器配置、头文件路径、内存模型差异等复杂操作，极大降低了跨语言调用的技术门槛。简而言之，MoonBit 以一种面向现代开发者的方式，实现了对 Python 生态的高层次封装，使“使用外部库”不再是一项复杂任务，而是变成了“编写 MoonBit 代码”的自然延伸。

例-2 外星人小游戏，直接调用 Python 生态（直接调用）

video2

与此形成鲜明对比的是传统 C 库的绑定方式：开发者常需面对冗长的头文件、复杂的函数签名、不一致的内存模型，以及 CMake、Makefile 等构建系统的繁琐配置。这不仅加重了使用门槛，也大幅拉高了调试与部署成本。而在 MoonBit 中，这一过程被大幅简化：

只需一行 pyimport，即可获取 Python 库模块引用；
开发者将无需再烦恼繁琐的C/C++头文件嵌套问题，不同平台链接的差异问题，不同项目构建系统的兼容问题等等。

以上，以两个实际案例展示了 MoonBit 对 Python 生态的无缝融合能力：

在封装类库方面，MoonBit 可将如 turtle 这类图形库高度 MoonBit 化，开发者几乎无需接触底层即可直接绘图；
在直接调用方面，MoonBit 也能加载完整的 Python 模块，如 pygame 外星人小游戏，支持复杂逻辑的原样运行。相较于传统 C 库绑定所需的大量工程配置与接口对接，MoonBit 调用 Python 模块无需引入 C 头文件、无需处理链接器与构建系统，开发体验更轻量、更稳定。那么，这种“无缝融合”是否只是技术细节上的简化？通过进一步对比一下 MoonBit 与 Python 在调用方式上的代码对比，MoonBit 不只是“能用”Python 库，而是用一种更现代的方式让代码更简洁、更易懂。

MoonBit 与 Python 对比

对比一：错误提示机制的友好性

左边: MoonBit, 右边: Python

在图中，MoonBit 和 Python 都因颜色参数写错而报错，但两者的提示体验截然不同： MoonBit 编译器在构建阶段即指出问题所在，直接定位到具体文件与行号，错误信息结构化、语义明确，例如：“Color 枚举中不存在 Greenyellw 构造器（正确的单词是Greenyellow）”。这类提示不仅方便开发者快速定位和修改，也便于 IDE 与 AI 工具理解上下文并生成修复建议。相比之下，Python 仅在运行时报错，输出大量调用堆栈，真正有用的信息被埋藏在底部 ValueError 中，缺乏清晰的上下文与可操作性，对初学者尤其不友好。从底层机制看，这是静态语言与动态语言在错误处理上的根本差异：MoonBit 在“运行前”就能发现问题，Python 通常只能在“运行后”才暴露错误。

对比二：类型系统驱动的 IDE 自动补全

在 Python 中，color='orange' 这样的参数是通过字符串传递的，完全缺乏类型约束。如果不小心写成 'oragne'，程序将直接在运行时报错或表现异常，而 IDE 无法在编辑阶段提供任何帮助——既没有补全，也无法进行静态检查。相反，MoonBit 对参数类型采用显式的枚举建模。例如颜色参数使用 @plt.Color 枚举类型（如 Orange、Darkblue 等），IDE 能根据类型信息实时提供候选选项，开发者不必记忆，也不必担心拼写错误。同时，编译器会在构建阶段对所有参数合法性进行验证，错误可在运行前即被发现。这一设计不仅提升了日常开发效率，更在构建复杂系统或 AI 自动代码生成场景中大幅降低了“微错误”的发生概率。类型驱动的补全与验证机制，是实现高可靠性与智能协同开发的基础

总结

MoonBit 的崛起，标志着国产编程语言从“技术追赶”转向“场景创新”的关键转折。它不仅是 Python 生态的挑战者，更是 AI 时代编程范式的探路者——若能在性能、生态与开发者体验间持续平衡，或将成为下一代云原生与边缘计算开发的核心基础设施。这场革新能否成功，取决于技术、社区与商业化的协同共振，而答案或许将在未来三年初见分晓。

项目链接

python.mbt：https://github.com/Kaida-Amethyst/python.mbt
matplotlib.mbt: https://github.com/moonbit-community/matplotlib.mbt

MoonBit 新特性：Virtual Package 虚拟包机制

2025年5月16日 · 阅读需 4 分钟

cover

Moonbit 最近新增了一项特性：virtual package。通过将一个 package 声明为虚拟包，定义好一套接口（通过 .mbti 文件声明），**用户可选择具体使用哪一份实现，如不指定则使用该虚拟包的默认实现。通过这项特性，给分离接口与实现带来较大灵活性。**注意：目前这项特性处于实验性状态。

使用方法

以: virtual_pkg_demo 这个项目为例，项目结构如下：

.
├── virtual // 声明为 virtual package，其中的 virtual.mbti 定义了一套接口
├── impl    // 为 virtual 包中的接口提供了一份自定义实现
├── lib     // 依赖了 virtual 包中的接口
└── main    // 依赖了 lib 包，声明了用 impl 包去 override 掉 virtual 包的默认实现

声明某个包为 virtual package：在 virtual 包的 moon.pkg.json 中用一下字段声明该包是一个 virtual 包。包中需有 .mbti 文件否则报错，若 "has-default" 为 true 则会构建默认实现的编译产物，在没有 override 该包的情况下一起被链接
```
"virtual": {
    "has-default": true
}
```
为某个 virtual package 提供自定义实现：在 impl 包中的 moon.pkg.json 设置 "implement" 字段为某个 virtual 包的完整包名。需要完整地实现 virtual package 中的 .mbti 文件中规定的接口
```
    "implement": "username/hello/virtual"
```
使用 virtual package：在 lib 包的 moon.pkg.json 中的 "import" 字段中引入 virtual 包
覆盖 virtual package：在 main 包的 moon.pkg.json 中的 "overrides" 字段中设置实现包。如果没有设置实现包且 virtual 包有默认实现则使用默认实现，无默认实现则报错
```
{
  "is-main": true,
  "import": [
    "username/hello/lib"
  ],
  "overrides": [
    "username/hello/impl"
  ]
}
```

具体示例

下面通过一个小例子说明 virtual package 在 moonbitlang/core 中的使用。moonbitlang/core/abort 被定义为一个 virtual package。具体代码如下：

abort.mbti：声明了这个包中暴露出来的 api

package "moonbitlang/core/abort"

// Values
fn abort[T](String) -> T

// Types and methods

// Type aliases

// Traits

abort.mbt：提供了 fn abort[T](String) -> T 这个 api 的默认实现。

pub fn abort[T](msg : String) -> T {
  let _ = msg
  panic_impl()
}

///|
fn panic_impl[T]() -> T = "%panic"

在目前的默认实现中会故意忽略掉 msg 参数，这是因为如果使用 println(msg) 的话会导致生成的 .wasm 文件依赖 moonrun 运行时中定义的 spectest::print_char 函数，此时若是使用除了 moonrun 之外的 wasm 运行时（如 wasmtime、wasmer 等）则会导致报错：

error: Unable to instantiate the WebAssembly module
╰─▶ 1: Error while importing "spectest"."print_char": unknown import. Expected Function(FunctionType { params: [I32], results: [] })

自定义 `moonbitlang/core/abort` 的实现

abort(msg) 接口在许多 builtin 数据结构中都有用到，在不满足某些 invariant 的情况下会在运行时失败退出，而按照目前的默认实现，abort 中的 msg 不会输出，用户也较难发现出错的原因。为此，我们可以自定义 abort 的实现，让他打印出 msg（当然，如果你不用 moonrun 以外的运行时运行编译好的 .wasm 的话），做法如下：首先执行 moon add moonbitlang/dummy_abort，然后在 moon.pkg.json 中增加以下字段：

"overrides": [
    // 这个包给 moonbitlang/core/abort 这个 virtual package 提供了一份自定义实现
    "moonbitlang/dummy_abort/abort_show_msg"
]

测试此时 abort 的行为，可以发现传入的参数确实被打印出来了

故意在一个数组上错误地使用 swap，abort 报错信息如下

未来，moonbit 社区将会提供符合 wasi 标准的库去实现 println，届时编译出来的 .wasm 也可以在支持此标准的 wasm 运行时上运行，敬请期待

MoonBit支持国产芯片开发--性能媲美C

2025年4月30日 · 阅读需 11 分钟

cover

在 ESP32-C3 上实现生命游戏

过去，我们曾在文章《硬件实现：在ESP32-C6单片机上运行MoonBit WASM-4小游戏》中，展示了如何通过 WebAssembly (WASM) 将 MoonBit 程序移植到物理硬件，初步探索其在嵌入式领域的潜力。而如今，随着 MoonBit Native 后端的正式发布: MoonBit 支持 Native 后端，MoonBit 迈出了关键一步：无需再依赖 WebAssembly 作为中间层，代码可以直接以原生形式运行在嵌入式硬件之上。这项进步不仅显著提升了性能和资源利用效率，也为 MoonBit 深度整合进嵌入式与物联网生态、直接控制硬件设备，奠定了坚实基础。

为了具体展示 MoonBit Native 在嵌入式开发中的优势，本文将通过一个经典实例——在乐鑫 ESP32-C3 芯片（或其 QEMU 仿真环境）上实现“康威生命游戏”——来进行探讨。

生命游戏是一个非常经典的细胞自动机，在一个二维网格上模拟细胞的生死演化。每个细胞的状态（存活或死亡）根据其周围 8 个邻居的状态，在离散的时间步中同时更新。基本规则包括：存活细胞在邻居过少（< 2）或过多（> 3）时死亡，在邻居适中（2或3）时继续存活；死亡细胞在正好有 3 个存活邻居时“复活”。
ESP32-C3 是一款流行的低成本、低功耗 RISC-V 微控制器，资源相对有限。生命游戏对计算和内存访问有一定要求，使其成为检验嵌入式系统性能和编程语言效率的理想模型。我们的目标是利用 MoonBit 编写生命游戏的核心逻辑，并将其运行结果显示出来。不仅支持在连接了 ST7789 LCD 的真实 ESP32-C3 硬件上运行，也支持在开发机上通过 QEMU 仿真环境运行，以方便开发和验证。

准备工作

在开始之前，请确保你的系统中安装了乐鑫官方提供的链接: ESP IDF 开发框架。请参考链接: ESP官方文档，当前支持的ESP-IDF（乐鑫物联网开发框架）版本为 v5.4.1。若希望使用 QEMU 仿真，请参考乐鑫官方文档中的链接: QEMU模拟器章节安装相关工具链。

本文使用MoonBit native后端生成C代码，并且借助链接: moonbit-esp32 包将MoonBit项目打包为静态链接库，以嵌入到标准的ESP-IDF项目中。 moonbit-esp32 库的核心功能体现在其 components 包中。这个目录扮演着关键的桥梁角色，专门负责提供 MoonBit 语言到 ESP-IDF中各种核心组件功能的绑定。具体来说，该目录下包含了多个子模块，例如 gpio （通用输入输出）、 spi（串行外设接口）、 lcd（液晶显示屏控制，包含通用接口和特定驱动如 ST7789 的封装）、 task（封装 FreeRTOS 任务管理）以及 qemu_lcd（针对 QEMU 仿真环境的 LCD 接口）。每一个子模块都封装了对应的 ESP-IDF C API，允许开发者使用类型安全、更符合 MoonBit 语言习惯的方式来直接操作 ESP32 的硬件外设和系统服务，从而将 MoonBit 的现代语言特性带入底层嵌入式开发。

本文相关代码位于链接仓库中的 game-of-life 子目录中。

注意：本文所述的开发与测试流程仅在 macOS 系统上验证通过，其他操作系统用户可能需要根据平台差异自行进行调整。

生命游戏逻辑的实现

相关代码位于game.mbt 文件中。

首先我们定义DEAD 定义为 0，ALIVE 定义为 Int16 类型的-1 。这里定义ALIVE 为 -1 而不是1 是一个巧妙的优化：在 RGB565 颜色格式下，0 （0x0000）恰好代表黑色，而 -1（0xFFFF ）恰好代表白色。这样，在将游戏状态数据传输给 LCD 时，可以省去颜色转换的步骤。
网格大小由ROWS 和COLS (均为 240) 定义。cells 使用一个一维 FixedArray 全局变量来存储整个二维网格的当前状态。FixedArray 是固定大小的数组，大小为 112.5KB(240 * 240 * 2 / 1024)。因为ESP32-C3可用内存约有320KB，且并不是连续的，所以next数组没有定义成完整的下一个状态副本，而是定义为一个 3 行滚动缓冲区，大小约为1.4KB。我们通过模运算循环使用这三行空间来存储计算中的下一代状态，并采用延迟提交策略将计算完成的旧行写回cells ，以降低内存使用峰值。


const DEAD : Int16 = 0
const ALIVE : Int16 = -1

pub const ROWS : Int = 240
pub const COLS : Int = 240

let cells : FixedArray[Int16] = FixedArray::make(ROWS * COLS, 0)
let next : FixedArray[Int16] = FixedArray::make(3 * COLS, 0)

在计算下一个状态时，核心代码如下：

let live_neighbors = live_neighbor_count(row, col)
let next_cell = match (cell, live_neighbors) {
  (ALIVE, _..<2) => DEAD  // 优雅地用范围模式匹配邻居数小于2的情况
  (ALIVE, 2 | 3) => ALIVE // 使用或模式, 将邻居数为2或3的情况合并在一个分支
  (ALIVE, 3..<_) => DEAD  // 用范围模式匹配邻居数大于3的情况
  (DEAD, 3) => ALIVE
  (otherwise, _) => otherwise // 必须考虑所有情况, 编译器会进行穷尽性检查
}

这是实现生命游戏规则的核心，充分展现了 MoonBit 模式匹配的强大和优雅。生命游戏的规则被近乎直译地映射到 MoonBit 的 match 模式匹配语句中，代码清晰、直观且不易出错。

此外，在需要性能的场景，MoonBit提供了对数组的unsafe操作。这在性能关键路径上消除了数组边界检查的开销，是嵌入式开发中为了榨取极致性能的常用手段，但需要开发者确保逻辑的正确性。

最后，对比 QEMU（仿真）版本和 ST7789（硬件）版本的 main.mbt 文件。与 QEMU 虚拟 LCD 面板相关的逻辑位于 game-of-life/qemu/src/main/main.mbt，关键代码摘录如下：

let panel = @qemu_lcd.esp_lcd_new_rgb_qemu(@game.COLS, @game.ROWS, BPP_16)
  ..reset!()
  ..initialize!()
@game.init_universe()
for i = 0; ; i = i + 1 {
  let start = esp_timer_get_time()
  panel.draw_bitmap!(0, 0, @game.ROWS, @game.COLS, cast(@game.get_cells()))
  @game.tick()
  let end = esp_timer_get_time()
  println("tick \\\\{i} took \\\\{end - start} us")
}

这段代码借助MoonBit ESP32 binding，首先初始化一个用于 QEMU 仿真的虚拟 LCD 面板，并对其进行复位和初始化设置。这段 MoonBit 代码利用了级联运算符 (..) 和错误处理(!)。

首先创建 panel 对象。
接着，..reset!() 使用级联运算符，在 panel 上调用 reset 方法；由于 reset 函数的返回类型可能包含错误，末尾的 ! 表示：如果 reset 成功，则继续执行；如果 reset 引发了一个错误，! 会立即将该错误重新抛出，中断后续操作。
同理，..initialize!() 只有在 reset! 成功后才会执行，并且同样带有自动错误传播的 !。这种组合使得对同一对象执行一系列可能失败的操作时，代码既简洁（避免重复写 panel）又安全（错误自动向上传播）。
接着，它初始化生命游戏的世界状态。
最后，代码进入一个无限循环：在每次循环中，它将当前的游戏状态绘制到虚拟 LCD 上，然后计算并更新游戏到下一代状态，同时测量并打印出每次绘制和更新操作所花费的时间。

与 ST7789 LCD 相关的逻辑位于 game-of-life/st7789/src/main/main.mbt，关键代码摘录如下：

let spi_config : @spi.SPI_BUS_CONFIG = { ... }
@spi.spi_bus_initialize(@spi.SPI2_HOST, spi_config, SPI_DMA_CH_AUTO) |> ignore

...

let panel = @lcd.esp_lcd_new_panel_st7789(
    io_handle~,
    reset_gpio_num=PIN_RST,
    rgb_ele_order=@lcd.BGR,
    bits_per_pixel=16,
  )
  ..reset!()
  ..initialize!()
  ..config!(on_off=true, sleep=false, invert_color=true)
@game.init_universe()
for i = 0; ; i = i + 1 {
  let start = esp_timer_get_time()
  panel.draw_bitmap!(0, 0, @game.ROWS, @game.COLS, cast(@game.get_cells()))
  @game.tick()
  let end = esp_timer_get_time()
  println("tick \\\\{i} took \\\\{end - start} us")
}

这段代码首先定义了与物理 ST7789 LCD 连接所需的 GPIO 引脚和 SPI 时钟速度等常量。
接着，它执行了一系列硬件初始化步骤：配置并启动 SPI 总线，创建基于 SPI 的 LCD IO 句柄，然后使用特定驱动初始化 ST7789 面板并设置其显示状态（复位、初始化、开启显示、唤醒、颜色反转）。
完成硬件准备后，它初始化生命游戏的状态。
最后，程序进入一个无限循环，在循环中不断将当前游戏画面绘制到物理 LCD 屏幕上，计算游戏的下一代状态，并测量打印每次循环所需的时间。

此外，读者可以注意到，MoonBit支持标签参数。无论是在 esp_lcd_new_panel_st7789 的调用中（如reset_gpio_num=PIN_RST, rgb_ele_order=...），还是在后续链式调用的 ..config!(on_off=true, ...) 中，都明确地将值与其参数名称关联起来。这种方式极大地提高了代码的可读性和自文档性，使得参数的意图一目了然，并且也无需关心参数顺序。

我们可以发现：生命游戏的计算 (@game.tick()) 和主循环结构完全相同。主要的区别在于与显示设备的交互层。ST7789 版本需要进行详细的物理硬件配置（定义 GPIO 引脚、配置 SPI 总线、初始化特定 LCD 驱动）；而 QEMU 版本则直接与仿真环境提供的虚拟 LCD 接口交互，初始化过程相对简单。

运行实例代码

您可以通过克隆示例代码仓库来亲自体验：

git clone <https://github.com/moonbit-community/moonbit-esp32-example.git>

QEMU 版本 为了方便读者不借助硬件复现，我们提供了QEMU版本，代码位于 game-of-life/qemu 目录，在确保环境配置无误后，运行以下命令便可看到结果。33.1 FPS (每帧约 30.2 ms)

cd game-of-life/qemu
moon install
make set-target esp32c3
make update-deps
make build
make qemu

以下为运行效果

此外，我们还提供了一份使用C实现的代码，位于 game-of-life/qemu-c 目录，测试结果表明，使用C实现的生命游戏每帧的计算时间与MoonBit版本相同，均为30.1ms左右。

ST7789 版本

此版本在真实的 ESP32-C3 开发板和 ST7789 LCD 上运行。实测帧率约 27.1 FPS (每帧约 36.9ms)。

cd game-of-life/st7789
moon install
make set-target esp32c3
make build
make flash monitor

此外，我们还提供了一份使用C实现的代码，位于 game-of-life/st7789-c 目录，测试结果表明，使用C实现的生命游戏每帧的计算时间与 MoonBit 版本几乎相同，为36.4ms。

对于具体的测试方法，详见链接: 仓库

总结

通过在 ESP32-C3 上运行生命游戏的实例，我们展示了 MoonBit 的 Native 后端在嵌入式开发中的应用。MoonBit生命游戏代码经过优化，能到达与C几乎相同的速度。同时，MoonBit 的模式匹配等现代语言特性有助于提升代码的可读性和开发体验。结合其与 ESP-IDF 等生态系统的无缝集成能力，MoonBit 为ESP32嵌入式开发提供了一种将原生级执行效率与现代化开发体验相结合的高效解决方案。

下一步

在 MoonBit 中引入 Elm 架构：用简单原则打造健壮的 Web 应用

2025年4月16日 · 阅读需 9 分钟

Elm 是一种纯函数式编程语言，专为构建前端 Web 应用程序而设计。它编译为 JavaScript，强调简洁性、性能和健壮性。

纯函数式的含义是函数没有副作用，这使得代码更易于理解和调试。通过强大的静态类型检查，Elm 确保应用程序不会抛出运行时异常，从而提供更高的可靠性。Elm 架构强制执行单向数据流，使状态管理变得可预测且简单。

受 Elm 的启发，我们使用 MoonBit 开发了一个名为 Rabbit-TEA 的前端 Web 框架。

为什么选择 MoonBit？

函数式编程的兴起也推动了 React 从基于类的范式向 React Hooks 的演进。在 JavaScript 中已经有了一些函数式框架，那么为什么还需要 MoonBit？

尽管 JavaScript 生态中已经有一些支持函数式风格的框架和库，但 JavaScript 本身缺乏诸如模式匹配等特性，这使得编码体验不够理想。以下是 MoonBit 和 JavaScript 等效代码的对比：

let x = match y {
  a => value1
  b => value2
  c => value3
}
f(x)

var x = null;
if (y == a) { x = value1 }
else if (y == b) { x = value2 }
else { x = value3 }
// x 可能会在这里被意外修改！
return f(x);

// 或者
const x = y == a ? value1 : (y == b ? value2 : value3);
return f(x);

以下是另一个 MoonBit 例子。函数 validate_utf8 检查输入的 bytes 是否是有效的 UTF-8 序列：

fn validate_utf8(bytes : Bytes) -> Bool {
  loop bytes {
    [0x00..=0x7F, ..xs]
    | [0xC0..=0xDF, 0x80..=0xBF, ..xs]
    | [0xE0..=0xEF, 0x80..=0xBF, 0x80..=0xBF, ..xs]
    | [0xF0..=0xF7, 0x80..=0xBF, 0x80..=0xBF, 0x80..=0xBF, ..xs] => continue xs
    [_, ..] => false
    [] => true
  }
}

MoonBit 是一种面向表达式的语言，变量默认是不可变的。它完全支持模式匹配这一在函数式编程语言中流行已久的特性，确保生成高效的 JavaScript 代码。此外，MoonBit 编译器支持多种后端，包括 JavaScript、WebAssembly 和 native 后端。

Rabbit-TEA 如何工作

TEA 架构非常的简单，它由 Model、View、Update 组成：

Model：App 的状态，由不可变的数据结构组成。
View：App 的视图，声明了如何将 Model 显示为 HTML、用户的操作触发什么消息。
Update：App 的逻辑，处理用户触发的消息，将旧的 Model 转换为新的 Model。

下面是一个完整的计数器程序：

typealias Model = Int
let model = 0

enum Msg {
  Increment
  Decrement
}

fn update(msg : Msg, model : Model) -> (Command[Msg], Model) {
  match msg {
    Increment => (none(), model + 1)
    Decrement => (none(), model - 1)
  }
}

fn view(model : Model) -> Html[Msg] {
  div([
    h1([text(model.to_string())]),
    button(click=Msg::Increment, [text("+")]), // button1
    button(click=Msg::Decrement, [text("-")]), // button2
  ])
}

fn main {
  @tea.startup(model~, update~, view~)
}

这个程序除了定义 Model、Update 和 View，还定义了 Msg 类型。Msg 类型类似于事件。当用户点击增加按钮时，会触发运行时向 update 函数发送 Increment 消息以及当前的 model。在 update 函数中，并不会直接修改 model，而是基于旧值创建一个新的 model 并返回。整个函数是无副作用的。最后，新的 model 将通过 view 函数渲染为 HTML。

update 函数还返回一个 Cmd 类型，它表示一个未执行的操作。我们稍后会对此进行介绍。

声明式视图: HTML EDSL

EDSL 即内嵌领域特定语言，是通过利用编程语言已有的语法结构设计的 DSL，不需要额外的预处理和编译步骤。

Rabbit-TEA 使用 MoonBit 的 labeled argument 语法糖定义了一组辅助函数，这些 HTML 函数尽可能地通过类型来提示用户参数的作用, 避免滥用模糊和令人困惑的 String 类型。它们使用起来就像：

fn view() -> Html[Msg] {
  div([
    h1([text("hello MoonBit")]),
    p([text("build robust app")]),
    a(href="moonbitlang.com", target=Blank, [text("try it")]),
  ])
}

以标签 <a> 为例子，它的辅助函数的类型定义如下。除了唯一的 childrens 参数，其他所有参数都是 labeled argument，labeled argument 根据需要可以声明为可选的，或者设置缺省值。

pub(all) enum Target {
  Self
  Blank
}

pub fn a[M](
  style~ : Array[String] = [],
  id? : String,
  class? : String,
  href~ : String,
  target~ : Target = Self,
  childrens : Array[Html[M]]
) -> Html[M]

在未来，我们将考虑在 MoonBit 中引入类似 JSX 的拓展语法，使视图的代码拥有更好的可读性。

消息与模式匹配

TEA 架构充分利用了模式匹配和带标签联合类型，用户定义的 Msg 可以视情况带上额外的数据，这使得 update 处理消息时更加安全和灵活。

例如，对于一个 input 元素，假如希望在用户输入的同时，处理它的值并将结果显示在另一个元素 p 中。我们可以在 Msg 类型中增加一个带 String 数据的 enum constructor，GotInputChange。GotInputChange 的类型和 input 中 change 参数的类型都是 (String) -> Msg。用户在修改 input 的值时，input 的值会被打包进 GotInputChange 并发送给 update 函数处理。

enum Msg {
  GotInputChange(String)
}

fn update(msg : Msg, model : String) -> (Cmd[Msg], String) {
  match msg {
    GotInputChange(value) => {
      ...
      (none(), value)
    }
  }
}

fn view(model : String) -> Html[Msg] {
  div([
    p([text(model)])
    input(input_type=Text, value=model, change=Msg::GotInputChange),
  ])
}

依靠 MoonBit 的穷尽性检查，下次 Msg 增加新的 enum constructor 时，IDE 将会提示相关的 pattern matching 需要处理新的 case，减少运行时错误。

管理副作用

Rabbit-TEA 与 Elm 一样使用 Cmd 类型管理函数的副作用，也就是修改外部状态、与外部系统交互的操作。例如，请求浏览器记录 URL History、滚动浏览器视图、向服务器发送 JSON 请求并处理返回的数据。所有的这些操作被封装为 Cmd。Cmd 代表一个未执行的动作，只有当它被 Update 函数的返回时，才会被 Rabbit-TEA 的 runtime 触发执行。

下面的例子演示了在用户点击相关的卡片时，先将界面转换为加载状态，然后通过 http 请求加载卡片的内容。 @http.get 返回了一个 Cmd，而它的第一个参数是请求的 URL，第二个参数声明期望的数据格式和处理响应的方法。

enum Msg {
  GotCardText(Result[String, String])
  ClickCard(Int)
}

pub fn update(msg : Msg, model : Model) -> (Cmd[Msg], Model) {
  match msg {
    ClickCard(id) => (@http.get("/api/card/\{id}", expect=Text(GotCardText)), Loading)
    GotCardText(Ok(text)) => (none(), Editing(text))
    GotCardText(Err(_)) => (none(), NotFound)
  }
}

这样一来，服务器响应请求时将触发 GotCardText 这个消息。它带上了一个 Result[String,String] 类型，这提示我们对响应进行分类讨论：当成功返回 card text 时，我们更新 model 以便 view 向用户展示内容；当请求失败时，我们跳转到 NotFound 页面。

Cmd 模式鼓励用户避免在一个函数中交替地触发副作用和更新 Model，从而防止 update 和 view 同时存在两个 Model 的数据来源，保证程序状态的一致性。

与 JS 世界交互

上面提到的这些 Cmd 并非经过框架特殊处理，而是基于 Cmd 的接口实现的。你也可以定义自己的 Cmd 来让 Rabbit-TEA 和外部的 JS 世界交互。MoonBit 允许以内联的形式书写 JS 代码，并将它和函数定义绑定。这很简单：

extern "js" fn set_timeout(f : () -> Unit, ms : Int) = "(f,ms) => setTimeout(f, ms)"

set_timeout 绑定了 JS 的函数 setTimeout。参数 f 表示将要触发的动作，ms 表示触发前等待的时间。我们定义一个函数 delay。它接受的参数 msg 表示将要触发的消息，ms 作用同上，最终返回 Cmd。

fn delay[M](msg : M, ms : Int) -> Cmd[M] {
  Cmd(fn(events){
    set_timeout(fn(){ events.trigger_update(msg) }, ms)
  })
}

Cmd 类型的值可以通过同名的 Cmd 构造器创建，它是一个未执行的动作的包装。在这个包装中，我们让 set_timeout 在合适的时机调用 events.trigger_update(msg)，让运行时使用 msg 和当前的 model 调用 update 函数。

我们可以使用这个 delay 函数，在用户点击按钮的5秒后显示一段文本：

enum Msg {
  Timeout(String)
  SetTime
}

fn update(msg : Msg, model : String) -> (Cmd[Msg], String) {
  match msg {
    Timeout(tips) => (none(), tips)
    SetTime => (delay(Timeout("You clicked the button 5s ago."), 5000), "")
  }
}

fn view(model : String) -> Html[Msg] {
  div([
    text(model),
    button(click=Msg::SetTime, [text("show tips after 5s")]),
  ])
}

不过，在编写内联 JS 时需要小心运行时错误。我们计划在 Rabbit-TEA 中提供更丰富的 Cmd，用户一般不需要自己编写这些绑定。

轻量的运行时

我们开发 Rabbit-TEA 时并没有注意过编译生成的 js 文件的大小。得益于 MoonBit 的全局 DCE 优化，我们发现 Rabbit-TEA 在带上 virtual dom 和 MoonBit 的标准库的同时，一个计数器应用生成的代码仅 33KB（经过 minify，未 gzip），小于 vue 的 50～60kb。

结论

在实现 Rabbit-TEA 的同时，我们还用它重写 MoonBit 的包管理网站 mooncakes.io。目前 mooncakes.io 和 Rabbit-TEA 还不够完善。我们希望随着 mooncakes.io 的实际应用，Rabbit-TEA 也能够成为成熟可靠的 UI 框架。我们未来也计划探索 TEA 架构的更多可能性，例如 native 后端支持、服务端渲染、时间旅行调试等等令人兴奋的特性。

如果你对这个框架和 MoonBit 感兴趣，也欢迎参与到 MoonBit 的社区当中。

下一步

MoonBit成为北大编程课程语言；LLVM后端同步发布

2025年3月11日 · 阅读需 11 分钟

MoonBit 团队近期取得两项进展。

MoonBit 语言发布了 LLVM 后端编译器。通过LLVM，MoonBit 可以直接编译为原生二进制文件，不再依赖C编译器，避免了兼容性问题。团队可以将更多精力投入在在运行时系统的创新上。

几乎同一时间，MoonBit 被纳入北京大学的编程语言课程，成为教学实践中的重要工具。

相比于推动企业生态的转型，高校教育场景为新的编程语言提供了最肥沃的土壤，因为学生群体具备高度开放性与探索精神。通过与课程体系融合，新语言能以自然和高效的方式进入年轻开发者的视野，从而逐步塑造未来的技术生态。

MoonBit 成为了少数能在工业级性能与教学实践价值之间，取得平衡的编程语言及开发者工具链。

list

MoonBit 团队近期双线告捷：LLVM 后端编译器发布，初步测试显示其性能超过主流语言水平，实验性的支持原生后端调试功能。

当前，国产基础软件的自主化进程正迈向深水区。

作为这一进程中的代表性力量，MoonBit 以 “快速、简单、可拓展” 为核心特质，构建跨越学术与产业的技术生态。

自2022年诞生以来，MoonBit 通过多后端架构设计，在编译速度、运行效率和代码体积等关键指标上实现对传统编程语言的超越，覆盖从嵌入式设备到云端服务的全栈开发场景。

在此过程中，MoonBit 逐渐找到了自己的位置，即做引领者而非追随者，和全球开发者并肩，重新定义编程语言的未来规则。

LLVM后端发布

MoonBit 的核心目标是通过性能突破与开发者体验革新，解决现有编程语言在关键场景中的效率瓶颈，如高并发和资源受限环境。

MoonBit 同步完善 C 后端并推出 LLVM 后端，分别针对嵌入式设备优化与跨平台高性能场景，通过统一工具链，实现了从硬件层到服务端的全场景覆盖。

LLVM 的引入，让 MoonBit 语言自身编译到原生二进制文件的过程可以完全脱离 C 编译器进行，避免了 C 编译器带来的兼容性问题。

在支持直接分发预编译的运行时库后，MoonBit 程序将彻底脱离对 C 编译器的依赖，可以仅依赖链接器生成原生程序。

有了 LLVM 处理底层的编译工作，团队可以将更多精力投入在在运行时系统的创新上。比如利用LLVM 对异常处理的完整支持，将错误处理函数优化为性能更好的 try-catch 实现。

性能维度： LLVM 后端复用与 Rust/Swift 相同的工业级优化管线（如自动向量化、LTO），为 MoonBit 提供与现代语言同级的优化潜力。
体验维度：原生集成 DWARF 调试信息，支持 GDB/LLDB 源码级调试，并计划实现运行时数据结构可视化。
生态扩展：基于 LLVM 对 RISC-V 向量扩展等新硬件的原生支持，MoonBit 可快速适配前沿架构。

MoonBit 的编译流程采用 “两阶段分层优化” 架构，兼顾开发效率与运行时性能。其核心思想是：在包级别进行轻量级即时优化，在链接阶段实施全局深度优化，既满足增量编译的敏捷性，又保障最终产物的性能。

成为北京大学课程语言

北京大学计算机学院近日调整其研究生课程《编程语言的设计原理》。自2025年春季学期起，MoonBit 替代编程语言OCaml 成为该课程推荐的实践工具。

高校在选择教学工具时，通常对语言的成熟度和稳定性有着严格的要求。编程语言的发展通常较为漫长，像OCaml等经典语言经过30多年的学术验证，才逐步在教学中得到广泛应用。

在此背景下，北京大学计算机学院率先将诞生仅两年的 MoonBit 引入其编程语言理论课程，无疑是创新之举。

MoonBit在工具链和语言特性的支持上，相比传统编程语言具有更好的表达能力和开发体验。

不仅保留了函数式编程的核心范式，还通过现代化工具链、AI编程和内存安全机制的整合，为教学场景提供了从理论到实践的衔接。

MoonBit 发展历程

过去一年，MoonBit 的全球用户数实现了12倍的指数级增长，且在国内外知名高校、海外云服务提供商、国家信息学竞赛组织等多个应用场景中落地。

根据2024年度 MoonBit 社区调查反馈，59.14%的用户已使用MoonBit 超过3个月，并持续运用在日常开发工作中。

在稳定的用户基础上，80%的用户评价 MoonBit 的性能为“优秀”。用户普遍认可其语言特性和平台规模生态。平台已实现从开发到部署的全流程自动化，尤其在微服务架构和云原生应用领域具有独特优势。

roadmap

LLVM 编译流程

MoonBit 程序的编译流程可以分为两部分。

第一部分是按需和增量式的，通过命令 moonc build-package 将每个包从源代码编译，输出我们称为 Core IR 的中间表示。Core IR 是一个以 ANF（Administrative Normal Form）风格的中间表示，我们用它来进行编译器优化。在这一部分，我们对 IR 进行各种优化。

第二部分是通过命令 moonc link-core 将包链接成最终的二进制文件。在这里，来自不同包的 Core IR 被链接在一起并再次优化，使用死代码消除、内联等优化技术。后结果被传递到编译流程的下游，最终生成输出二进制文件。

包的编译

在每个包的编译过程中，编译从抽象语法树（AST）开始——这是原始代码在内存中的结构化表示。

然后，从代码结构和导入的库中推断每个表达式的类型。这给我们带来了带类型的 AST（TAST）——每个表达式都标注了类型的 AST。

从 TAST，我们将其降级为主要的中间表示 Core IR，并进行一些高层级的变换和优化。这些优化包括将异步函数转换为普通形式，对不会逃逸的数据结构进行拆箱，以及删除未被其他代码引用的死代码。经过这些优化的 Core IR 结果成为每个库的编译形式。

链接和代码生成

与许多在链接后不做太多处理的编译型编程语言不同，MoonBit 的编译流程中，在 Core IR 链接后还有一系列降级和优化过程，逐步将 IR 转换为目标代码。

在编译时，来自不同包的 Core IR 首先被链接在一起。然后，通过优化和单态化（也就是移除泛型函数）转换为 MCore IR，再通过另一个移除闭包和降级的过程转换为 CLambda IR。垃圾收集的调用也在这个阶段被添加。

CLambda IR 是生成不同后端代码之前的最后一步。对于 WASM、JS 和 C 后端，输出代码是自包含的，所以只需要一步就能生成输出代码，然后将其写入输出文件。

LLVM 后端做的事情比其他后端要稍微复杂一些：CLambda IR 被转换为 LLVM IR，并通过 LLVM 库中的更多优化过程。在所有 LLVM 优化之后，代码被生成为目标文件，最后与预构建的运行时链接成一个可执行文件。

性能实测：LLVM 后端的工业级表现

LLVM 后端的 MoonBit 在性能方面也有着不俗的成绩。比如使用经典的 FFT 算法 benchmark ，让 MoonBit 和 Java 运行同样的 Cooley-Tukey 算法。MoonBit 相比 Java 有8倍以上的性能提升，比将 Java 静态编译的编译器 GraalVM 也有3倍以上的性能提升。下面是 MoonBit 与 Java 实现的 FFT 算法的性能对比。FFT（快速傅里叶变换）是一个计算序列的离散傅里叶变换的高效算法，在信号处理、压缩等许多领域有重要应用。FFT 算法涉及大量数值运算和数组操作，可以很好地体现语言的基础性能：

benchmark

由于 LLVM 后端涉及到更多的底层调整和优化，工具链还尚未能完全发挥 LLVM 所带来的性能优势。团队将会在未来的更新中继续优化 LLVM 后端生成的代码质量，进一步提升它的性能。

原生后端调试支持

在面向虚拟机的 JS 后端，借助 Chrome Debugger，MoonBit真正实现了调试体验的"开箱即用"。然而，对于面向原生平台的 C 后端，调试体验却并不完全尽如人意。在 C 后端中，用户可以调试编译后生成的 C 文件，但是 C 文件与输出的原始文件的映射信息在这一过程中依然是缺少的。

在 LLVM 的帮助下，当前MoonBit编译器已具备向最终二进制文件注入DWARF格式符号表的能力。

MoonBit 现在可以向输出二进制文件中插入调试信息，将二进制文件中的指令直接对应到源文件和行号列号。这一功能将很大程度上改善输出的文件与源代码映射信息缺失的问题。

基于该调试信息生成机制，MoonBit工具链支持开发者使用标准调试工具（如LLDB）对编译产物进行源码级调试。

具体而言，调试器能够自动解析符号映射关系，当执行流到达预设的源码位置时准确触发断点中断。比如，可以在 lldb 调试器中插入断点，以将程序在指定的位置暂停。

debug

虽然目前 MoonBit LLVM 后端对调试信息支持仍处于初步阶段，但已经对开发调试有了一定的帮助。团队后续会加入对调试器更好的支持，比如在调试器中展示局部变量和数据结构当前的值，以及更好的 name mangling 等。

未来展望

LLVM 的引入带来的最显著的改进是，MoonBit 语言自身编译到原生二进制文件的过程可以完全脱离 C 编译器进行，避免了 C 编译器带来的各种兼容性问题。在支持直接分发预编译的运行时库后，MoonBit 程序将彻底脱离对 C 编译器的依赖，可以仅依赖链接器生成原生程序。

有了 LLVM 处理底层的编译工作，团队可以将更多精力投入在在运行时系统的创新上，比如利用LLVM 对异常处理的完整支持，将错误处理函数优化为性能更好的 try-catch 实现；LLVM 对追踪式垃圾收集的原生支持能够考虑用追踪式 GC 来替代现有的 Perceus 和引用计数方案。

下一步

如何在你的网站中使用 Moonpad

2025年2月27日 · 阅读需 12 分钟

在MoonBit官网和语言导览中都有一个组件可以在浏览器中直接编写 MoonBit 代码并实时编译运行。它就是我们开发的 Moonpad 组件，目前已经发布到 npm 上，这篇博客将介绍如何在你的网站中使用 Moonpad。

这篇博客中出现的所有代码已都上传到 github，你可以在 https://github.com/moonbit-community/moonpad-blog-examples 中看到。

什么是 Moonpad

MoonBit 插件目前已具备多种为开发者带来极大便利的功能。除了针对 MoonBit 语法的高亮显示、自动补全，以及错误提示等功能的支持外，还实现了开箱即用的调试器、实时值追踪、测试以及内置的MoonBit AI助手，能够非常有效地减少除核心开发以外的工作量，提供一个高效流畅的开发环境。

在本篇教程中介绍的 Moonpad 是一个基于 monaco editor 的在线 MoonBit 编辑器，支持 MoonBit 语法高亮、自动补全、错误提示等功能。除此之外还支持在浏览器中实时编译 MoonBit 代码，可以说是一个在浏览器上的简单版 MoonBit 插件。它在 MoonBit 的官网和语言导览已经有所使用。如果你想体验完整版的 MoonBit 开发功能可以安装我们的 VS Code 插件。

如何使用 Moonpad

准备

新建一个 JS 项目：

mkdir moonpad
cd moonpad
npm init -y

安装依赖：

npm i @moonbit/moonpad-monaco esbuild monaco-editor-core

每个依赖的作用如下：

@moonbit/moonpad-monaco 是一个 monaco editor 的插件，提供 MoonBit 语法高亮、自动补全、错误提示、编译源代码等功能。
esbuild 是一个快速的 JavaScript 打包工具，用于打包源码。
monaco-editor-core 是 monaco editor 的核心库。选择这个库而不是monaco-editor的原因是，这个库没有 monaco editor 自带的 MoonBit 用不上的各种其他语言的语法高亮和 html, css, js 等语言的语义支持，打包出来的体积更小。

编写代码

接下来我们需要编写使用 moomnpad 和 monaco editor 的代码以及构建脚本。

以下展示的代码都是在 moonpad 目录下编写的。并且带有大量注释，以便你更好的理解。

创建 index.js 文件并输入以下代码：

import * as moonbitMode from "@moonbit/moonpad-monaco";
import * as monaco from "monaco-editor-core";

// monaco editor 要求的全局变量，具体可以查看其文档：https://github.com/microsoft/monaco-editor
self.MonacoEnvironment = {
  getWorkerUrl: function () {
    return "/moonpad/editor.worker.js";
  },
};

// moonbitMode 是一个 monaco-editor 的扩展，也就是我们提到的 Moonpad。
// moonbitMode.init 会初始化 MoonBit 的各种功能，并且会返回一个简单的 MoonBit 构建系统，用于编译/运行 MoonBit 代码。
const moon = moonbitMode.init({
  // 一个可以请求到 onig.wasm 的 URL 字符串
  // onig.wasm 是 oniguruma 的 wasm 版本。oniguruma 是一个正则表达式引擎，在这里用于支持 MoonBit 的 textmate 语法高亮。
  onigWasmUrl: new URL("./onig.wasm", import.meta.url).toString(),
  // 一个运行 MoonBit LSP 服务器的 Worker，用于给 MoonBit 语言提供LSP服务。
  lspWorker: new Worker("/moonpad/lsp-server.js"),
  // 一个工厂函数，返回一个运行 MoonBit 编译器的 Worker，用于在浏览器中直接编译 MoonBit 代码。
  mooncWorkerFactory: () => new Worker("/moonpad/moonc-worker.js"),
  // 一个配置函数，用于配置哪些codeLens需要被显示。这里我们出于简单的考虑，直接返回false，不显示任何codeLens。
  codeLensFilter() {
    return false;
  },
});
// 值得一提的是，这里所有的路径都是硬编码的，这意味着后面在编写构建脚本时，我们需要确保这些路径都是正确的。

// 挂载 Moonpad

// 创建一个 editor model，并且指定其 languageId 为 "moonbit"，在这里我们可以初始化代码内容，
// moonpad 只对 languageId 为 "moonbit" 的 model 提供 LSP 服务。
const model = monaco.editor.createModel(
  `fn main {
  println("hello")
}
`,
  "moonbit",
);

// 创建一个 monaco editor，展示我们之前创建的 model，并将其挂载到 `app` div 元素上。
monaco.editor.create(document.getElementById("app"), {
  model,
  // 这个主题是 moonpad 提供的主题，相比于 monaco 自带的主题，语法高亮效果更好。
  // 此外 moonpad 还提供了一个暗色主题 "dark-plus"，你可以尝试将其替换为 "dark-plus"。
  theme: "light-plus",
});

创建 esbuild.js 并输入以下代码，这是我们的构建脚本，用于打包 index.js ：

const esbuild = require("esbuild");
const fs = require("fs");

// dist 是我们的输出目录，这里把它清空，确保 esbuild 总是从头开始构建
fs.rmSync("./dist", { recursive: true, force: true });

esbuild.buildSync({
  entryPoints: [
    "./index.js",
    // 打包 monaco editor 用于提供编辑服务的 worker，这也是 `index.js` 中 MonacoEnvironment.getWorkerUrl 的返回值。
    // 之前提到所有的路径都是硬编码的，所以下面会使用 `entryNames` 确保这个 worker 打包之后的名字是 `editor.worker.js`。
    "./node_modules/monaco-editor-core/esm/vs/editor/editor.worker.js",
  ],
  bundle: true,
  minify: true,
  format: "esm",
  // 输出目录对应我们在 `index.js` 中硬编码的路径。
  outdir: "./dist/moonpad",
  entryNames: "[name]",
  loader: {
    ".ttf": "file",
    ".woff2": "file",
  },
});

fs.copyFileSync("./index.html", "./dist/index.html");

// 复制 `index.js` 中初始化 moonpad 所需要的各种 worker 文件。
// 由于它们已经被打包过了，所以不需要用 esbuild 再次打包。
fs.copyFileSync(
  "./node_modules/@moonbit/moonpad-monaco/dist/lsp-server.js",
  "./dist/moonpad/lsp-server.js",
);
fs.copyFileSync(
  "./node_modules/@moonbit/moonpad-monaco/dist/moonc-worker.js",
  "./dist/moonpad/moonc-worker.js",
);
fs.copyFileSync(
  "./node_modules/@moonbit/moonpad-monaco/dist/onig.wasm",
  "./dist/moonpad/onig.wasm",
);

最后是 index.html 文件，非常简单，没什么值得注意的。

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
    <link rel="stylesheet" href="/moonpad/index.css" />
  </head>
  <body>
    <div id="app" style="height: 500px"></div>
    <script type="module" src="/moonpad/index.js"></script>
  </body>
</html>

构建并启动服务器

运行构建脚本

node esbuild.js

此时 dist 文件夹应包含以下文件：

dist
├── index.html
└── moonpad
    ├── codicon-37A3DWZT.ttf
    ├── editor.worker.js
    ├── index.css
    ├── index.js
    ├── lsp-server.js
    ├── moonc-worker.js
    └── onig.wasm

2 directories, 8 files

此处展示的 codicon-37A3DWZT.ttf 文件后面的哈希值不一定与你实际操作下来的相同，但是无伤大雅。

在 dist 文件夹下启动一个 http 服务器：

python3 -m http.server 8081 -d ./dist

打开 locahost:8081，可以看到 moonpad 已经成功渲染出来了。

moonpad

如何在你的网站中使用 Moonpad

接下来我们以 jekyll 和 marp 为例，展示如何在你的网站中使用 Moonpad。

原理

在上一节中我们最终得到了一个 moonpad 文件夹，其中包含使用 Moonpad 需要的所有文件。任何网页只要修改一下 index.js 最后硬编码的挂载逻辑然后导入 moonpad/index.js 和 moonpad/index.css，就可以直接使用 Moonpad。

所以，想要在网页中使用 Moonpad，我们需要做的是：

根据不同的网页框架修改 moonpad/index.js 中的挂载逻辑。
在需要使用 Moonpad 的页面中导入 moonpad/index.js 和 moonpad/index.css。
将 moonpad 文件夹放到网站的静态资源目录下。确保它的路径是 /moonpad

在 jekyll 中使用 Moonpad

Jekyll 是一个简单的、博客感知的静态网站生成器。它使用 Markdown 或 Textile 以及 Liquid 模板引擎来生成静态网页。Jekyll 通过将内容与模板结合，生成可以直接部署到任何 Web 服务器上的静态文件。它特别适合用于 GitHub Pages，允许用户轻松地创建和维护博客或网站。

观察 jekyll 渲染代码块的结构

在 jekyll 中对于这样的 markdown 代码块：

```moonbit
fn main {
  println("hello, moonbit")
}
```

会生成如下的 html 结构：

<pre><code class="language-moonbit">fn main {
  println("hello, moonbit")
}
</code></pre>

如果我们希望 jekyllrb 中所有的 moonbit 代码块都在 Moonpad 中渲染，那么我们需要将生成的 pre 元素替换为 div 并将 Moonpad 挂载在这个 div 上。

以下是这个逻辑的实现：

// 便利所有的 moonbit 代码块
for (const pre of document.querySelectorAll("pre:has(code.language-moonbit)")) {
  // 获得代码块的内容
  const code = pre.textContent;
  // 创建一个 div 元素，这将会是 monaco editor 的挂载点
  const div = document.createElement("div");
  // 根据代码内容设置 div 的高度
  const height = code.split("\n").length * 20;
  div.style.height = `${height}px`;
  // 将代码块替换为 div
  pre.replaceWith(div);
  // 使用获得的代码内容创建一个 monaco editor model
  const model = monaco.editor.createModel(code, "moonbit");
  // 创建 monaco editor 并挂载到 div 上，展示上一行创建的 model
  monaco.editor.create(div, {
    model,
    theme: "light-plus",
  });
}

只需将上面的代码替换掉 index.js 中的挂载逻辑即可。

导入 Moonpad

jekyll 支持在 markdown 中直接使用 html，所以我们可以在 markdown 中直接导入 Moonpad。在需要使用 Moonpad 的 markdown 文件中的最后加入以下代码即可。

<link rel="stylesheet" href="/moonpad/index.css" />
<script type="module" src="/moonpad/index.js"></script>

将 moonpad 文件夹放到 jekyll 的静态资源目录下

在执行 jekyll build 之后，jekyll 会将所有的静态资源放到 _site 目录下。我们只需要将 moonpad 文件夹复制到 _site 目录下即可。

复制后 _site 文件夹的目录结构应为

_site/
├── ... # 其他静态资源
└── moonpad
    ├── codicon-37A3DWZT.ttf
    ├── editor.worker.js
    ├── index.css
    ├── index.js
    ├── lsp-server.js
    ├── moonc-worker.js
    └── onig.wasm

结果

完成以上步骤后，即可在 jekyll 中使用 Moonpad。效果如下：

在 marp 中使用 Moonpad

Marp 是一个 Markdown 转换工具，可以将 Markdown 文件转换为幻灯片。它基于 Marpit 框架，支持自定义主题，并且可以通过简单的 Markdown 语法来创建和设计幻灯片，非常适合用于制作技术演示文稿。

观察 marp 渲染代码块的结构

对于和上一小节 jekyll 中相同的代码块，marp 渲染出来的 html 结构大致如下：

<marp-pre>
  ...
  <code class="language-moonbit">fn main { println("hello, moonbit") } </code>
</marp-pre>

显然，如果我们希望所有的 moonbit 代码块都使用 moonpad 渲染，我们需要将 marp-pre 替换为 div 并将 Moonpad 挂载在这个 div 上。

以下是这个逻辑的实现，和 jekyll 的例子大同小异：

for (const pre of document.querySelectorAll(
  "marp-pre:has(code.language-moonbit)",
)) {
  const code = pre.querySelector("code.language-moonbit").textContent;
  const div = document.createElement("div");
  const height = code.split("\n").length * 20;
  div.style.height = `${height}px`;
  pre.replaceWith(div);
  const model = monaco.editor.createModel(code, "moonbit");
  monaco.editor.create(div, {
    model,
    theme: "light-plus",
  });
}

只需将上面的代码替换掉 index.js 中的挂载逻辑即可。

导入 Moonpad

marp 同样支持在 markdown 中使用 html，但需要显示开启这个选项。在需要使用 Moonpad 的 markdown 文件中的最后面加入以下代码：

<link rel="stylesheet" href="/moonpad/index.css" />
<script type="module" src="/moonpad/index.js"></script>

并在构建时开启 html 选项：

marp --html

将 moonpad 文件夹放到 marp 的静态资源目录下

在 marp 中预览幻灯片一般有两种方式，一种是使用 marp 自带的 server 功能，另一种是将 markdown 文件导出为 html，自行配置服务器。

对于 marp 自带的 server 功能，我们需要将 moonpad 文件夹放到 marp --server 命令指定的文件夹内。

对于将 markdown 导出为 html 的情况，我们需要保证 moonpad 文件夹和导出的 html 文件在同一个目录下。

结果

完成以上步骤后，即可在 marp 中使用 Moonpad。效果如下：

可惜的是，在 marp 中 monaco editor 的 hover 提示位置不对，目前我们还不知道如何解决这一问题。

如何使用 Moonpad 编译 MoonBit 代码

上面提到 moonbitMode.init 会返回一个简单的构建系统，我们可以使用这个构建系统来编译并运行 MoonBit 代码。它暴露了两个方法: compile 和 run：分别用来编译和运行 MoonBit 代码。例如：

// compile 还可以通过参数进行更多的配置，例如编译带测试的文件等。这里我们只编译一个单文件
const result = await moon.compile({ libInputs: [["a.mbt", model.getValue()]] });
switch (result.kind) {
  case "success":
    // 如果编译成功，则会返回编译器 js 后端编译出来的 js 代码
    const js = result.js;
    // 可以使用 run 方法运行编译出来的 js，得到标准输出的流。
    // 值得注意的是，这里流的最小单位不是字符，而是标准输出每一行的字符串。
    const stream = moon.run(js);
    // 将流中的内容收集到 buffer 中，并在控制台输出。
    let buffer = "";
    await stream.pipeTo(
      new WritableStream({
        write(chunk) {
          buffer += `${chunk}\n`;
        },
      }),
    );
    console.log(buffer);
    break;
  case "error":
    break;
}

打开控制台，可以看到输出了 hello。

对于compile函数的更多用法以及把代码输出展示在页面上的方法，可以参考语言导览中的代码：moonbit-docs/moonbit-tour/src/editor.ts#L28-L61

下一步

使用 Chrome 对 MoonBit 生成的 Wasm 进行性能分析

2025年2月14日 · 阅读需 7 分钟

cover

在我们前一篇博客中，我们介绍了如何在前端 JavaScript 中使用 MoonBit 驱动的 Wasm 库 Cmark。在本文中，我们将探索如何直接从 Chrome 浏览器中对该库进行性能分析。希望这篇教程能对你在使用 MoonBit 在类似的场景中进行开发时提供一些洞察，从而实现更好的整体性能。

具体而言，在本文中，我们将重点介绍如何对我们之前在前端应用中使用 Cmark 的示例做最小程度的修改，以便将 Chrome 内置的 V8 性能分析器应用到 Cmark 的 Wasm 代码中。

对 Cmark 库进行性能分析

我们很容易可以重构原始的前端应用程序，并添加一个新的导航栏以包含 “Demo” 和 “Profiling” 两个链接。点击第一个链接将使浏览器渲染原本的 A Tour of MoonBit for Beginners 示例的 HTML，点击第二个链接将导航到我们的新文档进行性能分析。（如果你对实际实现感兴趣，你可以在本文的末尾找到最终代码的链接。）

现在，我们已经准备为实际实现 Wasm 性能分析着手编写一些代码了。那么，与 JavaScript 性能分析相比，进行 Wasm 性能分析是否有不同之处？

实际上，我们可以使用与 JavaScript 相同的 API 来进行 Wasm 性能分析。Chromium 文档中有一篇文章详细描述了这些 API，简而言之：

当我们调用 console.profile() 时，V8 性能分析器将开始记录 CPU 性能概况；
之后，我们可以调用我们希望分析的性能关键函数；
最后，当我们调用 console.profileEnd() 时，性能分析器将停止记录，并将结果数据可视化显示在 Chrome 的性能标签页中。

考虑到这一点，让我们来看一下实际的性能分析功能实现：

async function profileView() {
  const docText = await fetchDocText("../public/spec.md");
  console.profile();
  const res = cmarkWASM(docText);
  console.profileEnd();
  return (
    `<h2>Note</h2>
<p>
  <strong
    >Open your browser's
    <a
      href="https://developer.chrome.com/docs/devtools/performance"
      rel="nofollow"
      >Performance Tab</a
    >
    and refresh this page to see the CPU profile.</strong
  >
</p>` + res
  );
}

如你所见，我们必须最小化性能分析器激活期间执行的代码范围。因此，我们在该范围内仅调用了 cmarkWASM() 函数。

另一方面，我们选择了《CommonMark 规范》的 0.31.2 版本（即前文中提到的 spec.md）作为性能分析模式的输入文档。我们选择这一文档的主要原因是该文档使用了许多不同的 Markdown 特性，同时它的长度也足以使许多 Markdown 解析器遇到问题：

> wc -l spec.md  # 行数
    9756 spec.md
> wc -w spec.md  # 词数
   25412 spec.md

我们重新组织了前端应用程序，使得点击导航栏中的 “Profiling” 链接将触发上面定义的 profileView() 函数，从而得到以下结果：

如果你曾深入研究过性能优化，那么你应该不会对这个火焰图应该感到陌生了...

等等，wasm-function[679]、wasm-function[367] 这些名字又是什么？我们该如何知道哪个函数对应哪个编号？

事实证明，我们需要在构建 Wasm 文件时保留一些调试信息。毕竟，我们一直使用以下命令构建我们的 MoonBit 项目：

> moon -C cmarkwrap build --release --target=wasm-gc

...而去除调试信息是 moon 在生成 release 版本时的标准行为。

幸运的是，我们可以使用一个额外的标志 --no-strip 来保留符号信息，而不必依赖于慢速的 debug 版本。让我们使用这个标志重新构建项目：

> moon -C cmarkwrap build --release --no-strip --target=wasm-gc

注意

类似地，如果我们想对生成的 Wasm 文件使用 wasm-opt，可以使用 wasm-opt 的 --debuginfo（或 -g）标志来保留优化后输出中的函数名。

保留函数名后，我们终于可以在性能标签页中看到实际情况了！

分析火焰图

如上图所示的火焰图可以很好地总结函数调用及其各自的执行时间。如果你不太熟悉它，火焰图的主要思路如下：

Y 轴 表示调用栈，最顶部的函数最先被调用；
X 轴 表示执行时间，每个矩形节点的宽度对应于某个函数及其子函数的调用所花费的总时间。

既然我们正在研究 Cmark 库的性能，我们应该向下检索，并特别注意那里的 @rami3l/cmark/cmark_html.render() 节点。例如，在该节点处，我们可以清楚地看到 render() 的执行被分成了两个主要部分，分别被图中的两个子节点代表：

@rami3l/cmark/cmark.Doc::from_string()，表示将输入的 Markdown 文档转换为语法树；
@rami3l/cmark/cmark_html.from_doc()，表示将语法树渲染为最终的 HTML 文档。

为了更好地查看性能情况，我们可以单击火焰图中的 render() 节点。这会让 Chrome 更新“自底向上”视图，并仅显示由 render() 递归调用的函数。这样，我们将会得到如下所示的结果：

在“自底向上”视图中按自时间（即排除子函数所用时间的总时间）对条目进行排序，我们可以轻松找出那些自己消耗最多时间的函数，进而对这些函数的实现进行进一步的细致检查。同时，我们还需要尽量消除深层次的调用栈，这可以通过查找火焰图中较长的垂直条形找到。

实现高性能

在开发过程中，Cmark 已经使用我们上面展示的性能分析方法进行了数百次性能分析，以追求令人满意的性能。那么，它在与流行的 JavaScript Markdown 库的比较中表现如何呢？

在这个测试中，我们选择了 Micromark 和 Remark——这两个在 JavaScript 生态系统中广泛使用的 Markdown 库——作为我们的参考。我们在这个测试中使用了最新版本的 Chrome 133 作为我们的 JS 和 Wasm 运行时，并使用 Tinybench 来测量每个库的平均吞吐量。

以下是这些库在 MacBook M1 Pro 上将《CommonMark 规范》转换为 HTML 的平均吞吐量：

测试（从最快到最慢）	样本数	平均值/Hz	±/%
cmark.mbt (WASM-GC + wasm-opt)	21	203.66	3.60
cmark.mbt (WASM-GC)	19	188.46	3.84
micromark	10	15.48	2.07
remark	10	14.28	3.16

结果非常明确：得益于持续的性能分析和优化过程，Cmark 现在比 JavaScript 基于的库快了大约 12 倍，相比于 Micromark 快了 13 倍。并且，wasm-opt 的额外优化步骤可以为 Cmark 提供额外的性能提升，将这些因子提高到大约 13 倍和 14 倍。

总之，Cmark 的性能证明了 MoonBit 在前端开发场景中提供可见效率提升的强大能力。

如果你对这个演示的细节感兴趣，可以在 GitHub 上查看最终代码。用于基准测试的代码也可以在这里获得。

New to MoonBit?

在 JavaScript 中使用 MoonBit 的高性能 Wasm 库

2025年1月22日 · 阅读需 5 分钟

在我们之前的一篇博客文章中，我们已经开始探索如何在 MoonBit 的 Wasm GC 后端中直接使用 JavaScript 字符串。正如我们所见，不仅可以用 MoonBit 编写一个兼容 JavaScript 的字符串操作 API，而且在编译为 Wasm 后，生成的产物体积非常小。

然而，您可能会好奇，在更现实的使用场景中，这将会是什么样子。因此，今天我们展示一个更贴近实际的场景：在一个由 JavaScript 驱动的 Web 应用程序中渲染 Markdown 文档，并借助 MoonBit 库 Cmark 和 Wasm 的 JS 字符串内置提案。

动机

Cmark 是一个新的 MoonBit 库，用于处理 Markdown 文档，可以解析纯 CommonMark 和各种常见的 Markdown 语法扩展（如任务列表、脚注、表格等）。此外，它从早期开始就支持外部渲染器，并附带了一个名为 cmark_html 的官方 HTML 渲染器实现。

鉴于 Markdown 在当今网络世界中的广泛存在，将 Markdown 转换为 HTML 的流程仍然是几乎每个 JavaScript 开发者工具箱中的重要工具。因此，这也成为展示 MoonBit Wasm GC API 在前端 JavaScript 中使用的理想场景。

封装 Cmark

为了进行这个演示，先创建一个新的项目目录：

> mkdir cmark-frontend-example

在该目录中，首先创建一个 MoonBit 库 cmarkwrap 来封装 Cmark：

> cd cmark-frontend-example && moon new cmarkwrap

这个额外的项目 cmarkwrap 的主要作用是：

Cmark 本身不通过 FFI 边界暴露任何 API，这对大多数 MoonBit 库来说是常见的情况；
我们需要从 mooncakes.io 仓库中获取 Cmark 项目，并将其本地编译为 Wasm GC。

cmarkwrap 的结构非常简单：

cmark-frontend-example/cmarkwrap/src/lib/moon.pkg.json:

{
  "import": ["rami3l/cmark/cmark_html"],
  "link": {
    "wasm-gc": {
      "exports": ["render", "result_unwrap", "result_is_ok"],
      "use-js-builtin-string": true
    }
  }
}

这个配置基本与之前的博客中介绍的设置相同，为 Wasm GC 目标启用了 use-js-builtin-string 标志，并导出了相关的封装函数。

cmark-frontend-example/cmarkwrap/src/lib/wrap.mbt:
```
///|
typealias RenderResult = Result[String, Error]

///|
pub fn render(md : String) -> RenderResult {
  @cmark_html.render?(md)
}

///|
pub fn result_unwrap(res : RenderResult) -> String {
  match res {
    Ok(s) => s
    Err(_) => ""
  }
}

///|
pub fn result_is_ok(res : RenderResult) -> Bool {
  res.is_ok()
}
```
这里是关键部分。render() 函数封装了底层的 @cmark_html.render() 函数，不再是一个抛出异常的函数，而是返回一个 RenderResult 类型。

然而，由于 RenderResult 是一个 Wasm 对象（而不是数字或字符串），对 JavaScript 来说是不透明的，因此无法直接被 JavaScript 调用者使用。因此，我们还需要在 MoonBit 中提供拆解该类型的方法：result_unwrap() 和 result_is_ok() 函数正是为此目的设计的，它们接受一个 RenderResult 输入。

与 JavaScript 集成

现在是编写项目 Web 部分的时候了。在此阶段，您可以自由选择任何框架或打包工具。本次演示选择在 cmark-frontend-example 目录下初始化一个最小的项目结构，无需额外的运行时依赖。以下是项目的 HTML 和 JS 部分：

cmark-frontend-example/index.html:

<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Cmark.mbt + JS</title>
  </head>
  <body>
    <div id="app"></div>
    <script type="module" src="/src/main.js"></script>
    <link rel="stylesheet" href="/src/style.css" />
  </body>
</html>

这个简单的 HTML 文件包含一个 id="app" 的 div，稍后会用作渲染 Markdown 文档的目标。

cmark-frontend-example/src/main.js:

const cmarkwrapWASM = await WebAssembly.instantiateStreaming(
  fetch("../cmarkwrap/target/wasm-gc/release/build/lib/lib.wasm"),
  {}，
  {
    builtins: ["js-string"],
    importedStringConstants: "_",
  },
);
const { render, result_is_ok, result_unwrap } =
  cmarkwrapWASM.instance.exports;

function cmarkWASM(md) {
  const res = render(md);
  if (!result_is_ok(res)) {
    throw new Error("cmarkWASM failed to render");
  }
  return result_unwrap(res);
}

async function docHTML() {
  const doc = await fetch("../public/tour.md");
  const docText = await doc.text();
  return cmarkWASM(docText);
}

document.getElementById("app").innerHTML = await docHTML();

将 cmarkwrap 集成到 JavaScript 中相对简单。在 fetch 并加载 Wasm 产物后，可以直接调用封装函数。result_is_ok() 帮助我们判断是否在正常路径上：如果是，我们可以通过 result_unwrap() 解包跨 FFI 边界的 HTML 结果；否则，可以抛出一个 JavaScript 错误。如果一切顺利，我们最终可以将渲染结果填充到 <div id="app"></div> 中。

现在我们可以编译 MoonBit 的 Wasm GC 产物并启动开发服务器：

> moon -C cmarkwrap build --release --target=wasm-gc
> python3 -m http.server

大功告成！您现在可以在浏览器中访问 http://localhost:8000，并查看由 Cmark MoonBit 库渲染的 A Tour of MoonBit for Beginners。

您可以在 GitHub 上找到该演示的代码。

了解更多

MoonBit 正式开源核心编译器

2024年12月18日 · 阅读需 4 分钟

cover

MoonBit（月兔）AI 原生开发平台今日宣布正式开源其核心编译器 ( WebAssembly 后端)，可在 GitHub 和 Gitee 平台查看源码。

作为开放开源的开发平台。MoonBit支持多后端（WebAssembly，JavaScript，Native），全场景开发。

开源 Wasm 后端是 MoonBit 在 2024 年开源计划中的重要里程碑。这一后端是 MoonBit 当前最为成熟的技术模块，运行性能和代码生成体积相比于 Rust 和 Go 均有明显优势。作为工具链中的核心板块，Wasm 编译器在连接语言特性与实际应用方面也发挥着至关重要的作用。

今年以来，MoonBit 已先后开源了核心标准库和构建系统，通过不断降低开发门槛和提升工具透明度，吸引了越来越多的开发者加入生态建设。

拥抱开源

WebAssembly（Wasm）作为一种高效、安全的跨平台技术，是 MoonBit 重点关注的领域之一。尽管 Wasm 的潜力巨大，但许多现有编程语言未能充分发挥其优势。为了弥补这一空白，MoonBit 创立之初就为 Wasm 做了大量的优化，力求在 Wasm 平台取得数量级的比较优势，并成功因此为吸引到了第一批来自包含欧美、日、韩等国的全球用户。

通过优化 Wasm 组件模型，MoonBit成功将一个简单的「http-hello-world 」示例的代码体积压缩至 27kB，显著小于许多其他语言，进一步验证了 MoonBit-Wasm 的生产环境应用能力。过去的一年，MoonBit 在此基础上，继续拓展其应用场景成功支持了 JavaScript 和原生后端，未来有望在更多领域发挥作用。

开源 WebAssembly 编译器这一核心技术，未来开发者将有机会亲身体验到 MoonBit 在性能优化方面的卓越成果，进一步巩固了 MoonBit 生态的技术核心同时，也为开发者提供了直接参与技术优化和生态创新的机会。

为什么采用宽松版的 SSPL

MoonBit 将始终坚持以开放，开源为核心策略，而且 MoonBit 团队坚信，开发者需要的是透明、可靠的工具，而不是功能受限的“开源核心”（Open-Core）模式。这传递了一个重要信号：MoonBit 对于用户始终保持免费开放，无论何时全球开发者都能享受到最优质稳定可信赖的开发体验。

MoonBit 在 SSPL 的基础上放宽了两条限制：

MoonBit 编译器生成的成果可以由用户自行选择许可协议，用户拥有为自己的 MoonBit 源代码和生成成果自由选择许可的权利。
编译器的修改在非商业用途下（比如：学术研究）是被允许的。

MoonBit 选择了宽松版的 SSPL 许可协议而不是 MIT 或者 BSD，主要基于以下两点原因：

项目稳定性：MoonBit 目前仍处于测试预览阶段，此时引入硬分叉可能会影响项目的稳定性。团队希望在项目达到更成熟和稳定的状态后，再欢迎社区的广泛贡献。
商业保护：避免大型云服务商利用团队的成果进行商业化，而这些行为可能会削弱团队的努力。

当前，MoonBit 的战略聚焦在用户增长与生态构建。通过培育繁荣的生态系统，团队希望为海量用户带来由 AI 驱动的端到端开发体验，并通过高附加值的云端托管服务释放更大的价值。未来，MoonBit 也将大胆探索软硬件一体化的可能性，以更深度的整合方式打造商业闭环，充分释放技术潜力。

了解更多

MoonBit 中使用 Js string builtin 提案的介绍

2024年11月8日 · 阅读需 11 分钟

长期以来，WASM 虽然以性能优越著称，但是由于它与JS 互操作成本较高，性能优势得不到充分体现。最新的 WASM 提案 Js builtin string 已经在 Chorme 默认实现， MoonBit 月兔团队的编译器已经完成对Js builtin string 提案的适配，最终评价结果显示新的后端输出体积远小于 Rust，而且性能会更好。

背景介绍

自从去年 Wasm GC 提案落地以来，已经有越来越多的编程语言支持编译到使用标准 GC 的 Wasm 代码，MoonBit 语言也在第一时间推出了 wasm-gc 后端，然而，标准 GC 中只提供了 struct, array 等比较基础的数据类型，对于字符串这种比较复杂的类型，目前还没有标准化的实现，考虑到字符串不同的编码形式以及不同的实现方式涉及到的不同的语义，标准化 Wasm 中字符串是一件极为复杂的事情。在这种情况下，对于字符串类型的处理方式就有以下两种主要的实现方式：

第一种方式是使用 GC 标准中提供的 struct, array 类型进行定制化的字符串类型实现，比如对于使用 UTF-16 编码的语言可以使用 (array 16) 作为字符串类型的实现，这种实现方式具有非常高的灵活度，可以通过复杂的优化提升字符串操作的性能，但是当涉及到使用 JavaScript 宿主环境中提供的 Web API （比如 fetch）或者 DOM API 的情况的时候，需要将语言中定制化的字符串类型转换为 JavaScript 中的字符串，这个转换往往不可避免地需要对字符串在内存中进行多次拷贝，这会对程序的运行时间带来不小的额外开销。
第二种方式则是通过外部引用 (externref) 的形式使用 JavaScript 中字符串作为实现，字符串相关的操作（比如字符串截断和拼接等）则是通过从宿主环境中导入 JavaScript 中的函数来进行实现，显然这种方式的好处在于使用 JavaScript 中的 Web API 的时候，不需要进行额外的转换，但是与此同时，因为字符串的操作都是导入的外部函数，所以每次函数调用都会发生一次间接调用，相比于直接函数调用，间接函数调用更加不利于 Wasm 引擎进行性能优化，并且有更高的性能开销

由此可见，以上两种方式都不能令人满意，在这种背景下，Js-string-builtins 提案被提出，并且已经在主流浏览器环境中得到了实现。该提案主要是解决了上述第二种字符串实现方式带来的性能问题，在这个提案中，编译 Wasm 模块的时候可以通过传递参数来允许其导入 “wasm:js-string” 这个预定义模块中的函数，这个模块中包括 “length”, “concat”, 和 “substring” 等常见字符串操作，与普通的函数不同的是，Wasm 引擎中内置了这些函数的相关信息，所以在编译这个 Wasm 的过程中不会再将这些操作当作间接调用进行处理，并且在一些情况下可以对这些操作进行内联以提升运行效率。

使用方式

目前 MoonBit 已经支持了 Js-string builtin 提案，这里我们使用两个简单的例子分别展示如何使用 deno 和浏览器环境中使用 Js-string builtin。这一小节中完整的代码示例可以在 https://github.com/moonbit-community/demo-js-builtin-string 仓库中找到。

使用 deno 环境

首先使用 moon new --lib demo-js-builtin-string 来创建一个新的项目，接下来我们在这个项目中新建一个叫做 palindrome 的包，并且用 MoonBit 写一个判断回文字符串的函数：

// demo-js-builtin-string/palindrome/palindrome.mbt
pub fn palindrome(s : String) -> String {
  let len = s.length()
  for i in 0..<(len / 2) {
    if s[i] != s[len - i - 1] {
      return "false"
    }
  }
  return "true"
}

这里函数的类型是 (String) -> String ，当我们将对这个函数编译到 wasm-gc 后端时， MoonBit String 类型会被编译到 wasm-gc 中的数组类型，这个数组类型和 JavaScript 中的 String object 并不兼容，所以这里的 palindrome 函数被导出之后并不能直接在 JavaScript 环境中使用。在开启了 Js-string builtin 这一特性之后，MoonBit String 类型将被编译为 JavaScript 中的 String object，从而可以实现非常简洁的互操作。我们需要在 moon.pkg.json 配置文件中开启这一特性：

// demo-js-builtin-string/palindrome/moon.pkg.json
{
  "link": {
    "wasm-gc": {
      "exports": ["palindrome"],
      "use-js-builtin-string": true
    }
  },
}

这时我们可以执行 moon build 将这个包进行编译，接下来我们准备一个 JavaScript 环境来测试这个函数：

// demo-js-builtin-string/a.js
const { instance } = await WebAssembly.instantiateStreaming(
  fetch(
    new URL(
      "./target/wasm-gc/release/build/palindrome/palindrome.wasm",
      import.meta.url
    )
  ),
  {},
  {
    builtins: ["js-string"],
    importedStringConstants: "_",
  }
);
console.log(instance.exports.palindrome("hello"));
console.log(instance.exports.palindrome("ada"));

这里我们通过 builtins: ["js-string"] 这个选项来在 JavaScript 环境中开启 Js string builtin 的特性，importedStringConstants 这个字段用于支持字符串字面量，这里的 "_" 是 MoonBit 编译器在编译字符串字面量时使用的默认名称，这个字段可以进行定制化，具体方式将会在后文中提到，这时我们可以使用最新版本的 deno 运行这个 JavaScript 程序：

$ deno run -A --v8-flags=--experimental-wasm-imported-strings a.js
false
true

使用浏览器环境

现在我们使用浏览器环境展示一个使用 MoonBit 操作 DOM API 的示例。我们新建一个名为 dom 的包，将 DOM object 作为抽象类型，并通过 JavaScript 环境导入一个 set_css 函数来操作 DOM，比如这里我们可以使用它来实现一个 change_color 函数：

// demo-js-builtin-string/dom/dom.mbt
type DOM
fn set_css(dom : DOM, key : String, value : String) -> Unit = "dom" "set_css"
pub fn change_color(dom : DOM) -> Unit {
  set_css(dom, "color", "red")
}

同样地，我们需要在 moon.pkg.json 文件中开启 Js string builtin：

// demo-js-builtin-string/dom/moon.pkg.json
{
  "link": {
    "wasm-gc": {
      "exports": ["change_color"],
      "use-js-builtin-string": true
    }
  }
}

接下来我们通过下面的 JavaScript 程序提供需要被导入的 set_css 函数，并且调用 MoonBit 中的 change_color 函数来改变字体颜色。

// demo-js-builtin-string/b.mjs
const { instance } = await WebAssembly.instantiateStreaming(
  fetch(
    new URL("./target/wasm-gc/release/build/dom/dom.wasm", import.meta.url)
  ),
  {
    dom: {
      set_css: (dom, key, value) => {
        dom.style[key] = value;
      },
    },
  },
  {
    builtins: ["js-string"],
    importedStringConstants: "_",
  }
);
document.getElementById("hello").addEventListener("click", () => {
  instance.exports.change_color(document.getElementById("hello"));
});

同时我们使用下面的 HTML 文件来展示这个示例。在这个 HTML 文件中，我们创建了一个简单的 div 元素，并通过 script 标签引入了我们之前编写的 JavaScript 模块。这样，当用户点击 "hello" 文本时，就会触发我们在 MoonBit 中定义的 change_color 函数，将文本颜色改变为红色。

<!-- demo-js-builtin-string/index.html -->
<html>
  <body>
    <div id="hello">hello</div>
    <script src="b.mjs" type="module"></script>
  </body>
</html>

我们可以使用一个简单的 HTTP 服务器来托管我们的 HTML 和 JavaScript 文件。例如，我们可以使用 Python 的 http.server 模块来快速创建一个本地服务器。运行以下命令：

python -m http.server 8000

然后，在浏览器中访问 http://localhost:8000即可查看我们的示例。你会看到文字颜色变为红色，这证明我们成功地使用 MoonBit 和 Js-string builtin 实现了 DOM 操作。

体积比较

在使用了 Js builtin string 的提案之后，MoonBit 程序面向 wasm-gc 后端生成的 Wasm 二进制文件体积会进一步得到缩小，这里我们和 Rust 进行一个简单的对比，比如在 MoonBit 中我们可以实现下面这个 print_and_concat 函数：

// demo-js-builtin-string/print_and_concat/print_and_concat.mbt
pub fn print_and_concat(a : String, b : String) -> String {
  let c = a + b
  println(c)
  return c
}

这里使用的打印字符串和字符串拼接的功能都来自于 JavaScript 宿主环境，所以生成代码的体积非常小，在通过 MoonBit 编译后，得到的 Wasm 二进制文件体积仅为 182 字节，通过 wasm-opt 压缩后，其体积仅为 117 字节：

$ wc -c target/wasm-gc/release/build/print_and_concat/print_and_concat.wasm
182 target/wasm-gc/release/build/print_and_concat/print_and_concat.wasm
$ wasm-opt -Oz target/wasm-gc/release/build/print_and_concat/print_and_concat.wasm -o - -all | wc -c
117

我们在 Rust 中实现类似的功能：

// demo-js-builtin-string/rust-example/src/lib.rs
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn print_and_concat(a: &str, b: &str) -> String {
    let c = format!("{}{}", a, b);
    println!("{}", c);
    c
}

我们使用 wasm-pack 将这个 Rust 程序编译到 Wasm，并计算其体积大小：

$ wasm-pack build --target web
$ wc -c ./pkg/rust_example_bg.wasm
20727 ./pkg/rust_example_bg.wasm

这时得到的 Wasm 二进制文件体积有 20 kB 左右，为了减小这个体积，我们可以在 Cargo.toml 文件中加上一些编译优化的选项：

// demo-js-builtin-string/rust-example/Cargo.toml

[profile.release]
lto = true
opt-level = 'z'

并通过 nightly 的 Rust 编译器使用如下命令在编译过程中对一些不必要的模块进行裁剪，得到 Wasm 文件：

$ wasm-pack build --target web --release --manifest-path ./Cargo.toml -Z build-std=panic_abort,std -Z build-std-features=panic_immediate_abort
$ wc -c ./pkg/rust_example_bg.wasm                                                                                    ~/playground/moonbit-playground/js-builtin-string/demo-js-builtin-string/rust-example
12534 ./pkg/rust_example_bg.wasm
$ wasm-opt -Oz pkg/rust_example_bg.wasm -o - -all | wc -c                                                             ~/playground/moonbit-playground/js-builtin-string/demo-js-builtin-string/rust-example
12706

Rust 编译得到的 Wasm 文件体积有大概 12 kB，体积大小为 MoonBit 生成的 Wasm 文件 60 倍之多，虽然这其中很多是内存管理相关的代码，但是 Rust 并没有提供相关工具链适配 Wasm 标准原生的 GC，相比之下 MoonBit 编程语言在面向 Wasm 平台时，用户可以选择生成的 Wasm 代码是否使用 Wasm 标准原生的 GC，当使用 Wasm 标准原生的 GC 时，MoonBit 可以生成非常简洁高效的二进制代码。

MoonBit 支持 Native 后端

2024年10月17日 · 阅读需 9 分钟

MoonBit 诞生于2022年，作为一款专为云计算与边缘计算设计的 AI 云原生编程语言及其完整工具链，融合了 Rust 和 Go 等现代语言的优秀设计理念。在 2023 年 8 月 18 日的首次公开展示中，MoonBit 支持了 WebAssembly 这一跨平台标准指令集，并实现了优越的运行速度和紧凑的代码体积。在 2023 年 5 月，MoonBit 支持 JavaScript 后端，并在性能上实现突破，在 JSON5 库的测试中，MoonBit JS 性能表现比原生JavaScript提升了近8倍。在已有 WebAssembly 和 JavaScript 后端的基础上，MoonBit 平台新增原生后端支持。这一原生后端能够直接将 MoonBit 代码编译为机器码在硬件上运行，摆脱了虚拟机的限制，显著提升了性能。

为什么要支持 Native 原生后端？

编程语言的运行时实现方式主要分为两类：基于虚拟机的（如 Java、Kotlin 等）和直接在硬件上执行的（如C/C++、Rust等）。原生后端虽然具备更大的优化空间和更高的性能上限，但开发难度也相应增加。

目前，MoonBit 已支持 WebAssembly 和 JavaScript 后端，凭借虚拟机运行具备良好的生态支持。然而，在高性能要求的场景中，这些后端可能存在局限。MoonBit 的原生后端能够将代码编译为目标机器的可执行二进制文件，避免解释开销，充分利用硬件资源，如 CPU、内存和存储，从而显著提升性能。对于视频处理、机器学习和大规模数据分析等计算密集型应用，原生后端提供了必要的性能支持。

通过实际的性能数据对比，根据不同应用场景， MoonBit 原生后端在数值计算领域以及内容管理性能方面超速领先于传统编程语言 Java 以及 Swift。

数值计算领域：相比 Java 快一个数量级

原生语言相比于基于虚拟机的编程语言的性能优势在数值计算领域尤为明显，这得益于原生编程语言很大程度上能更好的优化内存布局和利用硬件加速指令。

在这个经典的FFT算法 benchmark 中，同样的 Cooley-Tukey 算法， MoonBit 相比 Java 有15倍以上的性能提升，比最先进的商业版本的 Java 编译器 GraalVM 也有4倍以上的性能提升。

下面是 MoonBit 与 Java 实现的 FFT 算法的性能对比。FFT（快速傅里叶变换）是一个计算序列的离散傅里叶变换的高效算法，在信号处理、压缩等许多领域有重要应用。FFT 算法涉及大量数值运算和数组操作，可以很好地体现语言的基础性能：

与传统的 C/C++ 等底层语言不同，MoonBit 在实现显著性能提升的同时，保留了极佳的开发体验。MoonBit 与 Java 一样，采用自动内存管理，避免了手动管理内存的复杂性。同时，MoonBit 通过更现代化的语言设计，提供了比 Java 更丰富的现代语言特性，进一步提升了开发者的使用体验。

在数值计算类程序中，性能主要由两方面决定：对计算的优化程度和语言本身的运行开销。C/C++ 在数值计算领域表现出色，不仅得益于编译器优化，还在于语言本身几乎没有额外开销。对于自动内存管理的高级语言来说，如何消除高级语言功能带来的额外开销，是提升性能的关键。加上现代 CPU 的缓存机制，数据布局对性能也有重要影响。

MoonBit 实现了性能与开发体验的双重优势，归功于其科学、现代的顶层设计：

MoonBit 语言设计简洁，额外开销极小，数据结构布局紧凑，能够更好地利用现代 CPU 的缓存架构。
MoonBit 采用多层中间表示（IR）和全局优化编译架构，能有效消除泛型等高级功能的开销，并对数据布局进行全局优化，以最大化性能。

内存管理：性能优于 Java & Swift

数值计算类任务能很好反映编程语言的基础性能。但在应用类程序中，更常见的是对内存中数据结构的各种操作。得益于定制的内存管理系统，MoonBit 的 native 后端在内存操作性能与内存占用上表现也非常优秀，优于拥有高性能 GC 的 Java，与同样编译到二进制、自动管理内存的语言 Swift：

上述 benchmark 来自论文：Perceus: Garbage Free Reference Counting with Reuse，通过对语言在大量动态内存分配操作时的运行时间和内存占用情况进行比较，从而很好反映语言的内存管理系统的性能差异。

在嵌入式与 IoT 设备上，计算资源与内存资源都非常紧张。因此编程语言的运行性能与内存占用表现都必须足够好，才能胜任嵌入式、IoT 开发的场景。

实践中，受制于硬件资源，嵌入式、IoT 开发者往往不得不使用 C/C++ 等底层语言来获得足够的性能。但这会极大增加开发者的心智负担、降低开发效率。而 MoonBit 原生提供了一种新的可能性：使用 MoonBit 原生开发程序，能兼顾开发体验、运行性能与内存占用。

深度硬件集成，接入嵌入式与 IoT 生态

原生后端的另一个优势就是深度硬件集成。原生应用能直接访问设备的硬件功能，如摄像头、GPS、传感器等，对后端服务至关重要。且深度硬件集成可以提供更快速的响应时间和更丰富的功能，增强用户体验。

除了生成开发机器的原生二进制，MoonBit 的原生后端还能交叉编译到所有 C 支持的平台，在第一时间实现了对 RISC-V 平台的原生支持，拥抱嵌入式与 IoT 生态。

MoonBit 的原生后端能生成只有少量 libc 依赖的可执行二进制。因此，MoonBit 的原生后端非常适合用于编写嵌入式、IoT 程序。此外，由于 MoonBit 原生生成的二进制高度self-contained，部署 MoonBit 原生程序到各类边缘设备上非常便捷。

下面是一个使用 MoonBit 交叉编译到 RISC-V 的例子。为了获得开箱即用的交叉编译体验，首先需要安装 Zig。接下来，我们创建一个新的项目：

moon new hello-riscv
cd hello-riscv

为了交叉编译到 RISC-V，我们需要修改 src/main/moon.pkg.json 文件，让 MoonBit 使用 zig cc 来进行原生后端的交叉编译。打开 src/main/moon.pkg.json，将其修改为：

{
  "is-main": true,
  "import": [
    "username/hello/lib"
  ],
  "link": {
    "native": {
      "flags": [ "-cc", "zig cc -target riscv64-linux-musl -O2 -static" ]
    }
  }
}

接下来，只需要执行：

moon build --target native

就能获得 target/native/release/build/main/main.exe，一个 RISC-V 二进制可执行文件。可以用 RISC-V 虚拟机或物理机直接运行这个可执行文件。这里以 Linux 下 libriscv 提供的虚拟机为例：

$ rvlinux ./target/native/debug/build/main/main.exe
Hello, World!

复用底层生态，同时提供安全可靠的系统编程体验

以C/C++语言为核心的原生生态在整个软件体系中占据着至关重要的地位。操作系统的底层 API、各类高性能计算库、以及 AI 张量库（如 llama.cpp、ggml 等），均通过 C ABI（应用二进制接口）提供服务。MoonBit的原生后端能够无缝与基于 C ABI 的第三方库进行交互，为MoonBit解锁更多开发场景，并带来卓越的用户体验。

MoonBit 原生后端采用多层 IR（中间表示）设计，其中最底层的 IR 是 C 语言的一个子集。这一设计确保了 MoonBit 与 C 语言之间的良好互操作性，避免了昂贵的 FFI（外部函数接口）开销，充分利用现有的各类高性能 C 语言库资源。未来，MoonBit 将提供规范化的 C 语言调用约定，进一步扩展其生态，便捷地集成现有的开源 AI 推理库，广泛应用于高性能计算和 AI 边缘推理领域，或用于开发直接调用操作系统 API 的高性能应用与服务。

相较于 C/C++ 等系统编程语言，MoonBit 在保持高性能的同时，尤为注重内存安全与可靠性。与 Rust 的内存安全机制不同，MoonBit 通过编译器自身的优化策略，在不影响开发者体验的前提下，在大多数开发场景中移除垃圾回收（GC）带来的开销。同时，针对部分核心场景，MoonBit 将逐步引入如“modality”等业界最新的研究成果，以提升程序的确定性。这一机制有效降低了学习曲线，使更多开发者能够轻松上手并从 MoonBit 生态中获益。

下一步

MoonBit 原生后端完成了 MoonBit 生态的最后一块拼图。通过原生后端，WebAssembly，JavaScript后端的支持可以满足绝大多数开发者的多场景需求。未来 MoonBit 团队将会聚焦于开发者的用户体验，提高软件的可靠性，以及培养开发者生态。在开发者体验方面值得注意的是，得益于 MoonBit 编程语言工具链的模块化设计，这三个后端共享了前面绝大部分基础框架，大部分前端的优化都会使三个后端的用户受益。

更多资源：

moonbitlang/x 现已支持文件 I/O

2024年10月10日 · 阅读需 4 分钟

cover

最近社区对于在 MoonBit 中进行文件 IO 的呼声很高，为此，我们在 moonbitlang/x 中提供了一个基础的 fs 包，moonbitlang/x/fs 包支持 wasm, wasm-gc, js 后端，包含以下常用 api：（注：此库目前是实验性的，其 api 可能会有进一步的更新和调整。）

write_string_to_file, write_bytes_to_file
read_file_to_string, read_file_to_bytes
path_exists
read_dir
create_dir
is_dir, is_file
remove_dir, remove_file

用法示例

声明依赖

在命令行中执行以下命令

moon update
moon add moonbitlang/x

或者手动在 moon.mod.json 中声明依赖

"deps": {
    "moonbitlang/x": "0.4.10"
}

在需要使用的包中的 moon.pkg.json 导入依赖

"import": [
    "moonbitlang/x/fs"
]

test "write_and_read" {
  let path = "1.txt"
  // write content to the file
  @fs.write_string_to_file(
    path="1.txt",
    content=
      #|target/
      #|.mooncakes/
      #|
    ,
  )
  // make sure the file has been create
  assert_true!(@fs.path_exists(~path))
  let byte = @fs.read_file_to_bytes!(~path)
  // verify file content
  inspect!(
    byte,
    content=
      #|b"\x74\x61\x72\x67\x65\x74\x2f\x0a\x2e\x6d\x6f\x6f\x6e\x63\x61\x6b\x65\x73\x2f\x0a"
    ,
  )
  @fs.remove_file!(~path)
  assert_false!(@fs.path_exists(~path))
  try {
    @fs.read_file_to_string!(~path) |> ignore
  } catch {
    @fs.IOError::NotFound(_) as e =>
      inspect!(e, content="`1.txt` does not exist")
    _ => return
  }
  let bytes = Bytes::from_array([65, 97].map(fn(x) { x.to_byte() }))
  @fs.write_bytes_to_file(~path, content=bytes)
  assert_true!(@fs.path_exists(~path))
  let content = @fs.read_file_to_string!(~path)
  inspect!(content, content="Aa")
  @fs.remove_file!(~path)
  assert_false!(@fs.path_exists(~path))
  try {
    @fs.remove_file!(~path) |> ignore
  } catch {
    @fs.IOError::NotFound(_) as e =>
      inspect!(e, content="`1.txt` does not exist")
    _ => return
  }
}

更多示例可参见 fs/fs_test.mbt，这个文件是对于 fs 库的黑盒测试，其中的 test case 直观地展示了外部用户应该如何该库。

Background：MoonBit 项目的测试机制

目前一个 MoonBit 项目中可以有三种类型的测试：白盒测试（white box test）、黑盒测试（black box test）、内部测试（inline test）。

白盒测试

写在 *_wbtest.mbt中，构建系统会把当前包中的 *.mbt 和 *_wbtest.mbt 一起打包编译，因此在 *_wbtest.mbt 中可以访问当前包的私有成员，这些测试可以使用 moon.pkg.json 中 import 和 wbtest-import 字段中的依赖。wbtest-import 只在白盒测试中用到，不会打包到最终的构建产物中。

黑盒测试

写在 *_test.mbt 中，构建系统会在编译 *_test.mbt 时会自动将其所在的包作为依赖， *_test.mbt 只能访问其所在包的公开成员（即模拟外部用户在使用这个包时的视角），这些测试可以使用 moon.pkg.json 中的 import 和 test-import 字段中的依赖（以及其所在包，不需要显式写在 test-import 字段中）。test-import 只在黑盒测试中用到，不会打包到最终的构建产物中。

内部测试

可以直接写在 *.mbt（注意这里的*.mbt 不包含上面提到的 *_wbtest.mbt与*_test.mbt）中，可以访问当前包的私有成员，这些测试只使用 moon.pkg.json 中 import 字段中的依赖。

测试类型	文件拓展名	访问权限	依赖来源	打包到最终产物
白盒测试	*_wbtest.mbt	当前包私有成员	moon.pkg.json import & wbtest-import	否
黑盒测试	*_test.mbt	公有成员	moon.pkg.json import & test-import	否
内部测试	*.mbt	当前包私有成员	moon.pkg.json import	是

更多资源

查看多人Wasm4游戏案例：双人乒乓
2024 MoonBit 编程创新挑战赛
开始使用MoonBit.
查看MoonBit文档.
学习基于MoonBit设计的课程《现代编程思想》
加入中文论坛

硬件实现：在ESP32-C6单片机上运行MoonBit WASM-4小游戏

2024年9月26日 · 阅读需 5 分钟

cover

本次2024 MoonBit全球编程创新挑战赛，我们开设了使用WASM-4开发的游戏赛道，在《基于 Wasm4 框架的 MoonBit 游戏开发指南》一文中，我们介绍了如何使用MoonBit在WASM-4框架中编写小游戏。

WASM-4模拟的硬件规格主要包括：160x160 像素的显示屏；64 KB 的线性内存；支持键盘、鼠标、触摸屏，以及最多 4 个游戏手柄作为输入设备；音频输出；1KB的存储空间。一个自然的想法便是将WASM-4移植到单片机上运行，将模拟的IO设备替换为真实的硬件。本文，我们将探索如何在真实的硬件中运行这些由MoonBit编写的小游戏。本文使用的芯片为 ESP32-C6，它搭载 RISC-V 32 位单核处理器，主频高达 160 MHz，内置 320 KB ROM，512 KB SRAM。

如下动图展示了在 ESP32-C6 开发板上运行使用MoonBit编写的贪吃蛇游戏。

移植过程

WASM-4 项目仓库中提供了两种运行时环境：一种是在Web环境中运行的，另一种是本地（native）运行时。所谓WASM-4运行时指的是一种能够运行符合WASM-4规范的游戏环境。其中，本地运行时则是使用C语言实现的，只需要对其稍加修改、删除不需要的组件，便能在单片机上运行。

LCD显示屏

WASM-4 的本地运行时自带图形用户界面 (GUI)，用于在屏幕上显示游戏图像。然而，当我们把它移植到硬件上时，就不再需要这个图形界面了，因为我们可以用真实的LCD屏幕来代替它。

因此，第一步是删除与 GUI 相关的组件。WASM-4 有一个内部的帧缓冲器，用于暂存显示数据，由 MiniFB 负责渲染每一帧。我们只需要保留这个缓冲区用于存储图像数据，同时移除 MiniFB 相关代码。在单片机上调试之前，我们可以将帧缓冲器中的数据输出为图片文件。一旦确认图像无误，我们的任务就变得非常简单了，只是将一个存有像素点数据的数组显示到显示屏上。本文所选用的显示设备为一块由ST7789驱动的1.54英寸LCD，其分辨率为240*240，如下图所示：

因此在居中显示WASM-4 160*160的图像时，四周会留有40像素的空间。此外还需注意，由于本文所选用的LCD显示屏只支持RGB565颜色格式，因此可能会出现颜色偏差。

游戏手柄

WASM-4支持键盘、鼠标、触摸屏，手柄等输入设备。本文使用硅胶按钮模拟手柄。

手柄有上下左右四个方向按键，以及X和Z两个动作按键。WASM-4使用其线性内存中的1个字节来表示一个手柄状态，其中的第 0 位和第 1 位分别对应 X 和 Z 按钮，第 4 到第 7 位对应方向键的左、右、上、下。每一位的值表示相应按钮是否被按下。因此只要为每个按钮的按下按键事件中设置对应的比特位即可。本文使用最简单的方式，每个按键占用一个GPIO接口。

使用 WAMR 替换 wasm3 解释器

由于 wasm3 项目不再活跃维护，缺失了一些需要的特性。因此，我们还需要将 WASM-4 本地运行时的 wasm 执行引擎为替换为 WAMR。与wasm3类似，我们只需要在WAMR的运行环境中提供相同的FFI即可。例如用于绘制线段的 line、hline、vline，用于绘制矩形的 rect，用于贴图的 blit、blitSub等。

总结

至此，本文已经完成了基本的游戏显示与控制功能，点击查看完整代码。当然，仍然有很多有趣的方向值得探索，例如本文并未充分利用ESP32芯片丰富的无线接口，我们可以利用WiFi实现WASM游戏模块的热加载。此外，本文未实现外接扬声器以支持音频输出。

更多资源

查看多人Wasm4游戏案例：双人乒乓
2024 MoonBit 编程创新挑战赛
开始使用MoonBit.
查看MoonBit文档.
学习基于MoonBit设计的课程《现代编程思想》
加入中文论坛

通过 Wasm 组件使用 MoonBit 编写 AI 代理

2024年9月5日 · 阅读需 4 分钟

cover

如果你有关注MoonBit的仓库，最近你可能发现了一个叫做 "peter-jerry-ye-code-review" 的机器人对每个新增的 PR 发表评论。如果有新的提交，它还会自动对评论进行更新。没错，这个实验性代码审查机器人就是我们用 MoonBit 编写的AI代理。在这篇文章中，我们将解释它的工作原理。

你可以在这个仓库，中找到完整代码的快照，README 文件里有技术细节的详细说明。

使用场景

当有 Pull Request 提交时，我们都希望能够得到及时的审查。这时，如果可以实时提供一些初步检查反馈，便可以提高审查效率，以便开发者及时更新内容。

一个自动审查 PR 的机器人可以轻松地帮助我们实现这一目标。通过使用场景分析我们可以推断出这是一个无服务器任务：服务器接收到 Pull Request 的通知，获取必要的信息，然后发布评论。过程中无需存储任何数据。出于 WebAssembly 对无服务器任务场景的优势，尤其在冷启动中极快的速度，在本次任务中我们将选择使用 MoonBit 和 Wasm 组件模型（component model）实现项目。

工作原理

架构

本示例将基于开源运行时 Spin 开发。Spin 建立在 wasi-http 标准上，并提供了连接 Redis 或关系型数据库的接口。本次示例将部署在 Fermyon Cloud，该平台为初学者提供免费计划。你也可以选择开源的 Spin Kube，并在 Kubernetes 集群上自托管。

通过 wit-bindgen 对 MoonBit 的支持，我们可以通过获取 WIT 文件并生成绑定代码，轻松集成 Spin 的功能。

工作流程

下图展示了工作流程：

在创建 GitHub App 并由用户安装后，我们可以接收 Webhook 事件。GitHub 会根据配置发送 Webhook 事件。接收到负载后，我们可以验证并收集必要信息：仓库名称、安装 ID、Pull Request 编号以及事件类型。

通过安装 ID，我们可以为 App 获取访问令牌，使其能够访问用户授权的权限，如读取/写入 Pull Request 权限，特别是如果应用安装在私有仓库中。

我们可以根据事件类型决定采取的行动。例如，"opened" 表示新 PR，"synchronize" 表示现有 PR 的更新。对于前者，我们可以创建新的评论，而对于后者，我们更新现有评论。相关事件类型和负载在 Webhook 文档中有详细描述。

通过负载中的信息，我们可以从 GitHub 获取 Pull Request 的变动情况，例如以 diff 或 patch 格式获取更改。我们还可以列出提交并获取相应的更改和消息等。

最后，我们将收集的信息通过 HTTP 请求发送到我们选择的 LLM 提供商，使用其响应内容在 Pull Request 上创建或更新评论。

结论

MoonBit 在支持组件模型后，可以适用于多种应用开发场景。随着越来越多的运行时对该标准的支持，MoonBit 将广泛应用于开发无服务器应用或边缘计算应用。本文介绍的 AI 代理只是其中一个示例，未来会有更多应用场景出现。

Additional resources:

开始使用MoonBit.
查看MoonBit文档.
学习基于MoonBit设计的课程《现代编程思想》
加入中文论坛

MoonBit 发布 beta 预览版，快速实现多领域落地应用

2024年8月18日 · 阅读需 12 分钟

cover

AI时代下编程语言的战略机遇

这个世界是否还需要一门新的编程语言？毫无疑问每一门新编程语言诞生时都被这样质问过，我们相信 MoonBit 可以通过技术实力给你肯定明确的答案。

编程语言的发展经历了60年代：结构化编程的兴起，到70年代：面向对象编程与C语言，再到90年代：脚本语言与互联网，又转变为00年代：语言的统一与多样性，最终来到了10年代：现代语言与大数据；编程语言在不断进步，同时也有大量的编程语言慢慢销声匿迹。

大模型时代的横空出世，把万事万物席卷进这股浪潮，编程语言作为计算机核心组件与软件开发者创造技术世界最重要的工具，自然被顶上风口浪尖，整个技术行业都对编程语言提出了更高的要求。

在大模型时代，工具重新塑造了开发者的工作方式，同时也降低了学习新语言的门槛，开发者将更专注于创意和设计，代码的实现和优化将由编程工具完成。这一转变推动编程工具从简单的代码生成器进化为复杂问题解决平台。

MoonBit AI 云原生开发者平台（MoonBit 编程语言及工具链）就在这个机遇与挑战并存时代应运而生，整个开发者工具链于 AI高度垂直整合，应用场景聚焦于云计算和边缘计算，MoonBit 目标是重塑软件开发生态。

MoonBit 于 2022 年启动开发计划，凭借团队在 ReScript、OCaml、Flow等工业编程语言研发中的十多年经验，迅速在两年内完成了整套工具链的开发，致力于成为第一个走向国际的中国编程语言。

Beta预览版的标志性意义

自从去年8月18日 alpha 版的宣布带来了热烈的反响，经过整整一年的高速迭代，MoonBit 迎来了 beta 预览版这样一个重要的里程碑: 我们在核心语言特性上媲美甚至超越了大部分主流语言 1.0，整个语言特性的开发趋于稳定，可以吸引开发者更广泛的参与到生态建设中来。这里列举几个 MoonBit 核心且有挑战性的特性：

现代化的泛型系统

现代语言复杂性的很大一部分在于类型系统的设计，很多主流工业语言，比如 Java ，Go 在 1.0 版本推出很多年以后才会渐渐完善泛型的支持，但是这会对生态造成撕裂。MoonBit 在 beta 版本已经完成了泛型和 ad-hoc polymoprhism，而且 MoonBit 在保持极快的编译速度的同时，提供了零开销的泛型支持。

准确的错误处理

错误处理是现代语言设计中的重要组成部分，大部分编程语言在静态分析中，彻底放弃错误处理的支持，这意味着任何函数都可以抛出异常，很难写出高可靠性的代码，MoonBit 通过准确的控制流分析，可以完全在编译时期跟踪函数的错误。这一过程几乎完全由编译器自行推导，而又不像 Java checked exception 那样过于繁琐，对用户带来较高的心智负担。

高效的迭代器

传统的编程语言的迭代器会产生频繁的装箱操作，导致其性能比普通的循环要糟糕很多，MoonBit 创新性的使用了零开销的迭代器设计，可以让用户既能写出优雅的代码，也能保持程序的性能。

四大优势

2023 年 8 月 18 日，MoonBit首次在海外发布后，迅速登上了 HackerNews 的头条。此外，MoonBit 还在全球 DevOps 领域权威媒体平台 The News Stack、日本顶尖科技社区 Zenn 等知科技媒体上频频出现，进一步巩固了其全球影响力。

在这一过程中，MoonBit 一直致力于发挥其在语言速度、代码精简、安全保障和数据处理等方面的卓越优势。

快

MoonBit 旨在实现全栈的高效，包括编译性能和运行时性能。MoonBit 为多级中间表示（IR）上的全局优化而设计，这种方法改善了内存布局，最小化缓存未命中率，并提供了优越的数据和控制流分析环境。从编译速度来看，MoonBit 编译 626 个包（package）只需 1.06 秒，比 Rust 快了近 9 倍，运行时间仅为Go的1/6。

小

MoonBit在输出Wasm代码体积上相较于传统语言显著优势，MoonBit 通过 WebAssembly（Wasm）组件模型，在生成代码时实现了显著的体积优化。相比其他编程语言，MoonBit 编写的 Wasm 组件代码体积大幅减少。例如，在编译一个简单的“Hello World” HTTP 服务器时，MoonBit 的输出文件大小仅为 27KB，而 WasmCloud 提供的http-hello-world模板中 Rust 的输出为 100KB，TypeScript 为 8.7MB，Python 更是高达 17MB。

安全

借助前文提到的创新错误处理机制，MoonBit 有效解决了传统编译技术在错误处理机制转换中遇到的适用范围有限和内存开销大的问题。通过静态分析源程序中的错误处理代码并根据目标编程语言的特性进行转换，MoonBit 扩大了适用语言范围，减少了内存开销，同时提升了代码的安全性和稳定性。

健壮的类型系统是 MoonBit 对安全保障的重要设计之一。MoonBit 采用了强大的类型系统，并内置静态检测工具，在编译期检查类型错误，从而提高代码的正确性和可靠性。

MoonBit 对安全的保障也来源于对 WebAssembly 的原生支持。MoonBit 充分利用 Wasm 对沙箱环境，内存隔离、默认的无权限机制（deny-by-default）等安全架构的设计，释放其在云计算和边缘计算安全问题上的潜力；同时结合语言自身类型系统安全，删减无用代码（DCE）、编译为经过验证的 Wasm 指令等三层保障，确保代码可信与数据隐私安全。

专注于数据处理

MoonBit 作为一门多范式编程语言，在保持语言简单性的同时，也侧重于提供数据处理的最佳体验。MoonBit 通过原生支持 Json 处理、Iter 类型和模式匹配实现高效数据处理，在语法设计上兼具动态语言的灵活性和静态语言的安全高效，直观而简洁地进行对数据的解析和转换。

json

MoonBit 在数据处理上的语法设计旨在优化常见的数据处理场景，解决传统方法中由于生成多个中间数组而导致的性能问题，在 Iter 性能对比中，MoonBit 的数据处理速度达到了 JavaScript 的 25 倍之多。

AI 原生 IDE

相较于传统的编程语言设计路线，MoonBit 在战略上从一开始就提供全套开发、调试、部署一站式解决方案。MoonBit 不仅提供了多后端支持、通用程序语言设计，还涵盖了编译器、构建系统、包管理、集成开发环境（IDE）、调试器，部署工具等。这个全面的设计使得 MoonBit 能够实现高度垂直整合，而且可以同时在云端和边缘端执行，更好地与各种资源进行交互，从而为用户提供极致的开发体验和性能。

MoonBit 提供对 IDE 的支持不仅包含了现代 IDE 的所有功能，与其他 Cloud IDE 不同，MoonBit 无需依赖容器,快速语义分析技术可处理大量的代码库，并且在更大规模的代码库中也能在百毫秒级别完成 IDE 响应。

现今大多数编程语言的 IDE 是为桌面操作系统设计的，未能很好地适应云原生环境和边缘端的需求。MoonBit 则通过采用高度并行化的架构和对分离编译的原生支持，突破这一限制，使得 Cloud IDE 可以直接在边缘端运行。这在现今大多数语言的 Cloud IDE 中是首次。

除传统 IDE 的功能以外，MoonBit AI 助手现已内置于 MoonBit IDE，并实现了自动化测试生成、文档生成，以及代码解释功能，为应用的开发、测试和文档编写提供了全方位的支持，使得开发者能够更加专注于业务逻辑的实现，而不必担心底层的复杂性和维护工作。

MoonBit在初始阶段已经提供相对于其他语言通常在成熟阶段才拥有的调试工具。并在JavaScript后端实现开箱即用的调试功能，用户仅需在 JavaScript Debug Terminal 上执行 moon run --target js --debug 即可立刻进入调试。

应用场景

MoonBit 是一个全场景覆盖的开发者平台，紧跟科技前沿和行业趋势，侧重于云计算、边缘计算、AI 以及教学领域的发展，并在每个领域做到极致，确保在性能上领先其他语言至少一个数量级。多应用场景：

云计算

在云计算领域，MoonBit 近期已支持 Wasm 组件模型（component model），并有海外用户实现了与 Spin 框架集成的 MoonBit SDK。通过将应用程序拆分成独立的、可重用的组件，MoonBit 可以在云计算开发中更好地利用模块化开发、灵活的部署和更新、资源优化、防止单点故障提高安全性、易于扩展和集成等特性，实现云计算应用场景中的突出优势，提高系统的灵活性和安全性，简化扩展和集成过程，从而显著提高云计算开发效率并降低运营成本。

边缘计算

在边缘计算领域，目前已有 MoonBit PDK 插件，并被 Extism 收入官方 PDK 库。通过 PDK 的支持，MoonBit 能够在边缘计算应用中更高效地利用硬件资源，实现分布式计算和本地处理，提升性能和响应速度，同时确保设备兼容性和数据安全性，从而大大提升开发和部署效率，满足低延迟和高效能的需求。

教育(wasm4, mario, minimoonbit)

在 MoonBit 的应用生态发展中，我们同样注重为学生群体以及编程语言初学者提供简单易学的入门环境，并以游戏的形式打造轻松愉悦的学习体验。

MoonBit 现已支持使用 WebAssembly 开发小型复古游戏的 WASM-4 框架。凭借 MoonBit 的高效工具链和简洁设计，入门级开发者可以在官方教程的指导下轻松创作属于自己的第一款游戏。同时，框架内置的多玩家支持功能能够让至多四名玩家共同体验游戏的乐趣。无论是创作过程还是开发体验，MoonBit 都能让初学者体验前所未有的简单与高效。

不仅如此，由于 MoonBit 支持实时可视化开发，同时编译速度极快，开发者还能够实时更改代码来灵活调整游戏参数。

MoonBit 团队正在开发 MiniMoonBit 这一编译器教学项目。学生通过这个项目可以用 MoonBit 实现 MoonBit 语言的一个子集。它去除了多态等复杂的功能，同时学生也可以在简单的语言设计下深入了解类型推导、高阶函数等现代语言特性。由于 MoonBit 强大的表达力，相较传统的用 C/C++ 实现的编译器项目，学生可以更轻松地上手实现。同时，MiniMoonBit 项目采用了模块化的设计，多层 IR 都有对应的 Json 文本表示，学生不再需要从头实现编译器的每个环节，而是可以选择感兴趣的模块来学习。

未来计划与支持

MoonBit AI云原生开发者平台是一个“道阻且长，行则将至”的系统工程，开发编程语言工具链以及培养生态系统是一个漫长且耗费各项资源的过程，但值得骄傲的是 MoonBit 汇聚了一批非常年轻的技术精英。当然，仅靠自身的力量是很难走向巅峰，我们正在马不停蹄的扩大 MoonBit 社区力量，培养社区人才，2 年的时间里 MoonBit 工具链已有几百名社区贡献者，近万人的全球的用户，我们相信未来 MoonBit的一定会成为百万级用户的现象级编程语言。

目前，MoonBit 已支持 Wasm 与 JS 后端，未来，MoonBit 计划支持 native 后端。这意味着无论是 UI、客户端、边缘计算还是系统编程，用户都能在 MoonBit 平台上找到适合自己的使用场景，从而使生态能够覆盖所有可能的应用场景。

路线图

使用 MoonBit 开发 Wasm 组件模型

2024年8月7日 · 阅读需 7 分钟

cover

Wasm组件

WebAssembly（Wasm）是一种新的低级虚拟指令集标准（low-level virtual instruction set standard），用于沙箱模型。低级的，意味着它接近原生速度。虚拟的，意味着它可以在包括浏览器和操作系统在内的多个运行时（runtime）上运行，例如wasmtime或wamr。它是沙箱模型，这意味着它不能与外界交互，除非使用FFI。不过FFI只能返回数字，因此通过线性内存进行数据传输是更有效的方法。许多编程语言都可以编译成Wasm，包括Java、JavaScript/TypeScript、Python、Rust以及当然还有MoonBit。

那么如何结合用不同编程语言实现的Wasm组件呢？我们便需要引入组件模型（component model），一个统一接口的提案。通过组件模型，我们可以定义一个高级抽象的API。只要接口匹配，组件就可以与不同组件结合。

本文将介绍如何使用MoonBit编写一个输出“Hello World”的小型HTTP服务器。通过本教程我们可以看出，MoonBit在开发Wasm组件模型时实现了高兼容性和互操作性，同时能够显著减少输出大小。

操作步骤

我们将编写一个小型HTTP服务器，它将使用MoonBit打印“Hello World”。先决条件如下：

wit-deps
wit-bindgen with MoonBit（目前需要从源代码构建，因此还需要Rust工具链）
wasm-tools
wasmtime
当然还有MoonBit工具链。

定义WIT（Wasm Interface Type）

首先，你需要使用WIT定义接口（如何使用详见官方手册）。

在wit/deps.toml中指定依赖项。本教程中仅使用wasi-http版本0.2.0。

http = "https://github.com/WebAssembly/wasi-http/archive/v0.2.0.tar.gz"

使用wit-deps更新依赖项，在wit/deps文件夹中可以看到所有依赖项。

然后我们在wit/world.wit中指定“世界”对应于生成的Wasm：

package moonbit:example;

world server {
  export wasi:http/incoming-handler@0.2.0;
}

一个“世界”可以包含其他“世界”，或导入/导出接口。这里我们导出wasi:http版本0.2.0的incoming-handler接口，因为HTTP服务器需要导出一个传入处理程序接口，以便运行时可以使用它来处理传入请求并生成响应。

生成代码

在这一步骤，我们会使用wit-bindgen生成代码。你可以利用这个命令安装：

cargo install wit-bindgen-cli --git https://github.com/peter-jerry-ye/wit-bindgen/ --branch moonbit

获得wit-bindgen命令后，只需使用适当的子命令(moonbit)和WIT文件的位置(wit)执行它。还有参数用于指定类型是否应派生Showtrait 或Eqtrait。

wit-bindgen moonbit wit --derive-show --derive-eq --out-dir .

你将获得以下内容：

.
├── ffi
│  ├── moon.pkg.json
│  └── top.mbt
├── gen
│  ├── ffi.mbt
│  ├── interface_exports_wasi_http_incoming_handler_export.mbt
│  ├── moon.pkg.json
│  └── worlds_server_export.mbt
├── interface
│  ├── exports
│  │  └── wasi
│  │     └── http
│  │        └── incomingHandler
│  │           ├── moon.pkg.json
│  │           ├── README.md
│  │           └── top.mbt
│  └── imports
│     └── wasi
│        ├── clocks
│        │  └── monotonicClock
│        │     ├── moon.pkg.json
│        │     ├── README.md
│        │     └── top.mbt
│        ├── http
│        │  └── types
│        │     ├── moon.pkg.json
│        │     ├── README.md
│        │     └── top.mbt
│        └── io
│           ├── error
│           │  ├── moon.pkg.json
│           │  └── top.mbt
│           ├── poll
│           │  ├── moon.pkg.json
│           │  ├── README.md
│           │  └── top.mbt
│           └── streams
│              ├── moon.pkg.json
│              ├── README.md
│              └── top.mbt
├── moon.mod.json
├── wit // contents ignored here
└── worlds
   └── server
      ├── import.mbt
      ├── moon.pkg.json
      └── top.mbt

生成的项目有四个文件夹：

ffi和gen是生成的帮助Wasm绑定的文件，可以忽略。gen目录包含项目入口。
interface包含所有导入到所选“世界”的接口。分为imports和exports，imports提供所有导入的函数和类型，而exports包含你所要导出的函数以及一个空实现（panic()）。
worlds包含"世界"。与interface类似，它包含一个import.mbt，提供“世界”级别的导入函数和类型，以及一个top.mbt，包含导出函数的模板。

然后你可以像开发一般MoonBit应用一样继续开发。此时moon check --target wasm应该能够成功通过。你可以通过运行moon doc --serve查看API以及类型或函数的注释文档。别忘了执行moon fmt来格式化程序。

开发

以下是我们用于演示的实现最小输出的“Hello-World”服务器代码：

pub fn handle(
  request : @types.IncomingRequest,
  response_out : @types.ResponseOutparam
) -> Unit {
  let response = match request.path_with_query() {
      None | Some("/") => make_response(b"Hello, World")
      _ => make_response(b"Not Found", status_code=404)
    }
    |> Ok
  response_out.set(response)
}

fn make_response(
  body : Bytes,
  ~status_code : UInt = 200
) -> @types.OutgoingResponse {
  ...
}

完整示例见moonbit-docs/examples/wasi-http。

组件化

我们已经实现了一个核心Wasm，即一个遵循WebAssembly标准的Wasm。然而，我们需要将其转变为一个组件，以便可以将必要的信息——接口——一并分发。

你需要使用wasm-tools将核心Wasm嵌入到组件中。首先将WIT信息嵌入到核心Wasm的自定义部分中，此步骤需要指定编码为UTF-16。然后我们将核心Wasm转换为组件Wasm。

moon build --target wasm
wasm-tools component embed wit target/wasm/release/build/gen/gen.wasm -o target/wasm/release/build/gen/gen.wasm --encoding utf16
wasm-tools component new target/wasm/release/build/gen/gen.wasm -o target/wasm/release/build/gen/gen.wasm

如果你更喜欢使用npm或pnpm，也可以使用JCO来完成此步骤。

使用

利用我们创建的Wasm，可以使用Wasmtime进行托管：

wasmtime serve target/wasm/release/build/gen/gen.wasm

你也可以使用JCO在Node.js或Deno上进行服务，或者使用WasmCloud或Spin进行托管。

比较

compare

至此，我们已经实现了一个简单的仅输出 “Hello World” 的 HTTP 服务器。下表为 MoonBit 与主流编程语言生成的http-hello-world大小对比（基于WasmCloud的模板）

语言	输出尺寸
Python	17M
TypeScript	8.7M
Rust	100K
MoonBit	27K

结论

我们展示了如何使用MoonBit创建一个遵循组件模型标准的Wasm。组件模型为创建可互操作的Wasm提供了新标准。比如我们能够通过从Spin中提取WIT文件，在5分钟内轻松构建一个无服务器AI应用。

通过支持WebAssembly组件模型，MoonBit增强了其在微服务架构和云原生应用中的应用场景，具有高编译性能和紧凑代码尺寸，允许在各种环境中快速部署和执行。

在8月18日，MoonBit将达到beta预览版本，表明着我们在语言方面已达到一定的稳定性，适合投入更加广泛的测试与实际应用环境。未来，我们将继续拓展MoonBit生态系统，优化文档和工具链，以提供更好的用户体验。敬请期待！

你还能做什么

开始使用 MoonBit
查看MoonBit 文档
学习基于MoonBit设计的课程《现代编程思想》
试用库中在MoonBit IDE上运行的项目
加入官方 Discord 中文论坛

基于 Wasm4 框架的 MoonBit 游戏开发指南

2024年7月31日 · 阅读需 8 分钟

MoonBit 即将面向全国举办“编程创新挑战赛”，并包含游戏赛道。本教程将介绍本次比赛中使用的框架 Wasm4，以及如何使用 MoonBit 在 Wasm4 框架中编写游戏。相关赛事详情见文末。

cover

如果你曾访问过 mooncakes 或我们官网的库，你可能已经注意到我们发布了一个名为 wasm4的包以及一个新的演示项目 Wasm4 Snake。今天我们将向大家介绍这个出色的游戏开发框架，并演示如何使用 MoonBit 开发。

什么是 Wasm4

WASM-4 是一个使用 WebAssembly 构建复古风格游戏的框架。它提供了一个 160 x 160 像素的游戏主机，内存少于 64K。通过使用 WebAssembly 这一指令集的新标准，这些游戏能够在所有网页浏览器上运行，甚至可以在一些低端设备上运行。任何能够编译为 WebAssembly 的编程语言都可以用于开发游戏。随着 MoonBit Wasm4 SDK 的发布，现在开发者也能使用 MoonBit 轻松开发 Wasm4 游戏。

本教程将详细介绍如何使用 MoonBit 制作你的第一款 Wasm4 小游戏。

开发教程

MoonBit 库支持实时重载，你可以在我们的云 IDE 中试玩官方提供的 Wasm4 贪吃蛇游戏。

通过 MoonBit 提供的云 IDE，你可以直接在 gallery 上体验和开发游戏，无需任何安装步骤

gallery: https://www.moonbitlang.cn/gallery/wasm4-snake/

在您在本地端开发，你需要安装：

Node.js
MoonBit工具链

创建项目

在当前目录下使用 MoonBit 创建一个新项目，并使用 npm 安装 wasm4。

moon new --user moonbit --name demo --lib --path .
npm install -D wasm4

完成后，你将看到如下的目录结构（node_modules 目录未列在内）：

.
├── .gitignore
├── lib
│  ├── hello.mbt
│  ├── hello_test.mbt
│  └── moon.pkg.json
├── moon.mod.json
├── moon.pkg.json
├── package-lock.json
├── package.json
├── README.md
└── top.mbt

其中 moon.mod.json 定义了整个项目的配置，moon.pkg.json 则定义了每个包的配置。top.mbt 将作为游戏的主要入口文件，我们可以在 lib 目录中编写辅助函数，而 hello_test.mbt 提供了一个黑箱测试的示例。在这个示例中，我们将不使用 lib 目录。

添加 Wasm4 依赖

在创建项目后，我们需要添加 moonbitlang/wasm4依赖：

moon update && moon add moonbitlang/wasm4

这将导致 moon.mod.json 变更为如下内容（以当前版本为例）：

{
  "name": "moonbit/demo",
  "version": "0.1.0",
  "deps": {
    "moonbitlang/wasm4": "0.2.0"
  },
  "readme": "README.md",
  "repository": "",
  "license": "Apache-2.0",
  "keywords": [],
  "description": ""
}

同时，还需要将 moon.pkg.json 修改如下，以满足要求：

{
  "import": [
    "moonbitlang/wasm4"
  ],
  "link": {
    "wasm": {
      "exports": [
        "start",
        "update"
      ],
      "import-memory": {
        "module": "env",
        "name": "memory"
      },
      "heap-start-address": 6560
    }
  }
}

在这一步有几点需要注意：

我们将 moonbitlang/wasm4/lib 包导入为 wasm4，所以需要使用 @wasm4 修饰符来调用函数和类型。
我们将此包配置为 Wasm 后端的链接目标，并进行了以下设置：
- 按照 Wasm4 的要求，导出 start 和 update 函数。
- 导入名为 env 模块中的 memory 内存，以符合 Wasm4 的 ABI 规范。
- 为了与 Wasm4 的 ABI 兼容，将 MoonBit 的堆内存起始地址设为 6560。低于 6560（0x19a0）的内存空间将保留给 Wasm4 使用。

相应地，我们将修改 top.mbt ：

pub fn start() -> Unit {

}

pub fn update() -> Unit {

}

现在，可以通过以下命令执行：

moon build --target wasm
npx wasm4 run target/wasm/release/build/demo.wasm

如有需要调试并查看带有函数名的堆栈跟踪信息，也可以使用调试模式：

moon build --target wasm -g
npx wasm4 run target/wasm/debug/build/demo.wasm

a blank canvas

在这一步，浏览器会自动打开并显示游戏画面。接下来，让我们开始添加游戏内容吧！

示例：移动方块

首先，在屏幕上绘制一个方块：

pub fn start() -> Unit {

}

pub fn update() -> Unit {
  @wasm4.set_draw_colors(index=1, 2)
  @wasm4.rect(0, 0, 80, 80)
}

a green box appear on the top left corner of the canvas

现在，你应该看到这样的画面。Wasm4 提供了四个调色板和四种绘图颜色。根据具体的 API，将使用相应的绘图颜色。这里的操作是我们将绘图颜色 1 设置为第二个调色板的颜色，然后从位置 (0, 0)开始绘制一个 80 x 80 的矩形。请记住，在编程世界中，显示坐标的原点位于左上角，y 轴方向朝下。

moonbitlang/wasm4 提供了一个高级抽象，使你可以轻松编写代码。为了避免混淆，绘图颜色和调色板的索引从 1 开始。你还可以设置 160 x 160 像素中的每一个像素。有关这一步的设置请参阅官方 Wasm4 document 和 MoonBit 的 SDK API。

现在屏幕上显示了一个静止的方块，但毕竟我们是在开发游戏，所以它最好是能动起来。start 函数将在初始化期间调用一次，而 update 函数将以 60Hz 的频率被调用。因此要让方块移动起来，我们可以这样编写代码：

struct Position {
  mut x : Int
  mut y : Int
}

let pos : Position = { x: 0, y: 0 }

pub fn update() -> Unit {
  if pos.x + 80 <= 160 {
    pos.x += 1
  }
  @wasm4.set_draw_colors(index=1, 2)
  @wasm4.rect(pos.x, pos.y, 80, 80)
}

然后它将变成这样（实际的移动速度会比图上显示的速度更快）：

a green box moving right

操纵方块

Wasm4 提供了两个按钮（X 和 Z）以及四个方向按钮。让我们尝试让方块根据用户的输入移动吧！

pub fn update() -> Unit {
  if @wasm4.get_gamepad(index=1).button_right && pos.x + 80 < 160 {
    pos.x += 1
  } else if @wasm4.get_gamepad(index=1).button_down && pos.y + 80 < 160 {
    pos.y += 1
  } else if @wasm4.get_gamepad(index=1).button_left && pos.x >= 0 {
    pos.x -= 1
  } else if @wasm4.get_gamepad(index=1).button_up && pos.y >= 0 {
    pos.y -= 1
  }
  @wasm4.set_draw_colors(index=1, 2)
  @wasm4.rect(pos.x, pos.y, 80, 80)
}

a green box moving under control

总结

还等什么？使用支持实时重载的 MoonBit 库开始你的第一个 Wasm4 游戏吧，玩得开心！

如果对 Wasm4 框架下的游戏风格还不熟悉，访问 Wasm4 官方页面查看更多案例。

MoonBit 全球编程挑战赛

由深圳市河套深港科技创新合作发展署指导，IDEA-MoonBit 联合名企一线互联网大厂、全国知名高校举办的 MoonBit 全球编程创新挑战赛，即将拉开帷幕！

在游戏赛道中，参赛者将通过使用 MoonBit 编程语言和 Wasm4 框架，开发出具有创新性和趣味性的游戏作品，展示他们的创造力和编程技巧。

在 MoonBit 全球编程挑战赛中，每位参赛者都有机会让自己的作品得到广泛的推广，创作优秀作品的参赛者将得到丰厚奖金与奖品，表现突出的参赛者更有机会获得知名企业提供的工作或实习机会，为你的职业发展添砖加瓦！

大赛的更多信息和报名细节，后续将通过 MoonBit 的官方平台发布，敬请期待～

更多资源

开始使用MoonBit.
查看MoonBit文档.
学习基于MoonBit设计的课程《现代编程思想》
加入中文论坛
查看多人Wasm4游戏案例：双人乒乓

MoonBit 构建系统正式开源

2024年7月23日 · 阅读需 8 分钟

cover

作为由 AI 驱动的云服务和边缘计算开发者平台，MoonBit 自设计之初便注重工具链与语言的协同效果。MoonBit 为开发者提供了一套开箱即用的工具链，包括集成开发环境（IDE）、编译器、构建系统和包管理器，使开发者在使用 MoonBit 时能够轻松入门，极大提高开发效率、代码质量和项目的可维护性，减少繁琐的手动操作和配置管理，从而更加专注于开发的核心逻辑与创新，以提升整体开发体验和生产力。 MoonBit 的构建系统 moon 启动于 2023 年 5 月，今天已通过 GitHub moonbitlang/moon 公开，以 AGPL 协议开源。

moon：MoonBit构建系统

moon 是 MoonBit 的构建系统，为 MoonBit 项目提供编译构建，自动化测试工具（集成 expect test），覆盖率测试、包管理器等功能，此外，moon 作为 MoonBit 语言编译工具链的重要组件，与 IDE 紧密结合，为 IDE 分析代码提供了详尽的项目结构和依赖等信息。

moon 用 Rust 开发，得益于 Rust 语言的内存安全、高性能和并发处理能力、跨平台等特性，确保构建过程的稳定性和速度。

moon 的并行与增量构建功能得益于 n2 项目（n2 与 ninja 都是由 Evan Martin 创建，n2 相比 ninja 更加轻量，并且在增量构建方面更出色），对其修改部分将保持原项目的开源协议 moonbitlang/n2。

为什么选择 moon

moon

速度
- MoonBit 的编译器速度极快，这得益于其精心设计的编译流程和优化策略。作为用户与编译器之间的桥梁，moon 在底层设计上力求精简，最小化自身的封装开销，从而最大化编译速度。
- 此外，moon 还为集成开发环境（IDE）提供了详尽的项目结构和依赖等信息，这对于对延迟极为敏感的 IDE 场景至关重要。moon 通过优化核心构建步骤的性能，确保了即使在高度交互的开发环境中也能提供流畅的用户体验。
并行增量构建
- moon 得益于 n2 项目的并行增量构建功能是其高效性的关键所在。通过自动分析和理解各个构建任务之间的依赖关系，moon 能够智能地将独立的任务并行化处理，充分利用现代多核处理器的强大性能，从而显著加快构建速度。更为重要的是，moon 仅对自上次构建以来发生更改或其依赖项有所更新的文件进行构建，这种增量构建策略极大地提高了构建效率，使得 moon 能处理需要频繁构建的大型项目。
集成和测试支持
- 与自动化测试工具紧密结合，能够在代码提交和构建过程中自动执行单元测试、集成测试和端到端测试，确保每一行代码都经过严格的检验。
- 在代码质量保障方面，MoonBit 提供了代码格式化和静态分析工具，这些工具能够自动检查代码风格的一致性，并识别潜在的逻辑错误和安全漏洞。在持续集成/持续部署（CI/CD）的流水线中，这些功能尤为重要，它们能够在代码合并到主分支之前，及时发现并报告代码质量问题，从而确保团队能够协同开发出高质量的代码。

Benchmark

构建矩阵性能测试

我们测试了 moon 在编译构建具有复杂依赖关系的项目时与 Rust cargo、Go 的性能差异。测试包括生成 DR _ DC 目录，即目录矩阵，每个目录包含 MR _ MC 模块，即模块矩阵。模块矩阵 r 行 c 列中的模块依赖于同一目录前一行中的所有模块。一个目录中的第一行模块依赖于前一行目录中的所有模块。这种依赖关系便于测试并行性，同一行中的模块可以并行编译，同一行中的目录也可以并行编译。如想进一步了解测试准则请参见 omake1，项目生成器代码见 moonbit-community/build-matrix。

在我们的测试中，取 DR、DC、MR、MC 均为 6，加上 main 模块后，每个项目都包含 1297（6^4 + 1）个包。测试环境为 MacBook Pro Apple M3 Max 128G RAM，操作系统为 macOS 14.4.1，测试结果如下：

debug

调试构建： 在调试构建（debug build）任务中，moon 依旧表现优异，用时 2.3 秒，go 次之，为 2.9 秒，而 cargo 最慢，耗时 20.0 秒。

check

类型检查： 在类型检查（check）任务中，moon 的性能最佳，耗时仅为 1.4 秒，而 cargo 则需要 16.2 秒，go 在此项任务中无数据。go 没有类似于 moon check 与 cargo check 仅执行类型检查的命令，因此结果为 -。

release

发布构建： 在发布构建（release build）任务中，moon 的表现依然出色，仅耗时 1.6 秒，go 为 3.1 秒，而 cargo 则未能完成任务。cargo build --release在该项目中耗尽内存后崩溃，因此结果为 ∞。

值得注意的是，moon 的发布构建要比调试构建的速度更快。

而当 DR、DC、MR、MC 均为 8 时，共 4097 个模块，moon build 用时为 5.7 秒，go build 用时 11.2 秒，而 cargo build 用时 1043 秒。在此项测试中，moon 与 go 均在数秒内完成，而 cargo 已经无法在合理的时间完成此项目的构建。

标准库上的性能测试

目前 moonbitlang/core 为最大的 MoonBit 项目，截止到 2024/07/03，它共有 38177 行代码，46 个包，195 个.mbt文件，2576 个测试。对项目进行类型检查仅需 0.28 秒，执行全部测试仅需 1.27 秒。

马上使用 moon

访问下载页安装脚本下载 MoonBit 工具链，或者在 VS Code 中安装 MoonBit 插件后根据提示一键安装
用法：moon help

The build system and package manager for MoonBit.

Usage: moon [OPTIONS] <COMMAND>

Commands:
  new       Create a new moonbit package
  build     Build the current package
  check     Check the current package, but don't build object files
  run       Run WebAssembly module
  test      Test the current package
  clean     Clean the target directory
  fmt       Format moonbit source code
  doc       Generate documentation
  info      Generate public interface (`.mbti`) files for all packages in the module
  add       Add a dependency
  remove    Remove a dependency
  install   Install dependencies
  tree      Display the dependency tree
  login     Log in to your account
  register  Register an account at mooncakes.io
  publish   Publish the current package
  update    Update the package registry index
  coverage  Code coverage utilities
  bench     Generate build matrix for benchmarking (legacy feature)
  upgrade   Upgrade toolchains
  version   Print version info and exit
  help      Print this message or the help of the given subcommand(s)

Options:
      --source-dir <SOURCE_DIR>  The source code directory. Defaults to the current directory
      --target-dir <TARGET_DIR>  The target directory. Defaults to `source_dir/target`
  -q, --quiet                    Suppress output
  -v, --verbose                  Increase verbosity
      --trace                    Trace the execution of the program
      --dry-run                  Do not actually run the command
  -h, --help                     Print help

如何贡献

我们欢迎来自社区各种形式的贡献，如文档、测试以及 issue 等，详细内容请参考贡献指南。

MoonBit 开源计划

自去年正式发布以来，MoonBit 已于今年 3 月 8 日对外开放标准库，在社区的热情贡献下，已经成功实现完备的数据结构库，进一步丰富了 MoonBit 语言的应用场景，使语言生态系统走向成熟。在本次构建系统开源后，我们将于下个月 8 月 18 日发布 MoonBit Beta 预览版本，标志着 MoonBit 语言达到一个相对成熟的阶段，可以供早期用户和开发者进行实际项目的开发和测试。在今年年底 11 月 22 日，MoonBit 编译器核心部分将正式开源。

roadmap

你还能做什么

开始使用 MoonBit
查看 MoonBit 文档
学习基于MoonBit设计的课程《现代编程思想》
试用库中在MoonBit IDE上运行的项目
加入官方 Discord 中文论坛

IDEA研究院编程语言MoonBit发布JavaScript后端，速度提升25倍

2024年4月29日 · 阅读需 11 分钟

从登顶HackerNews到走红日本社区，IDEA研究院MoonBit编程语言宣布重要更新：在率先通过支持WASM并显现显著优势后，将推出支持JavaScript后端的版本。

MoonBit诞生于2022年，是专为云计算及边缘计算设计的AI云原生编程语言及开发者平台。 作为一门诞生于AI与云原生的浪潮之中的编程语言，MoonBit汲取了多种语言的精华，特别是融合了Rust和Go的设计理念，使其不仅简洁易用，还具备强大的类型系统来增强容错性。同时MoonBit融合传统IDE智能与大模型智能，实现了智能代码生成的调整和修正。

MoonBit平台为WebAssembly提供了原生支持，在运行速度和代码体积方面领先于传统编程语言。随着团队能力的发展，MoonBit也扩展其支持到更多的后端，目前已新增对JavaScript的支持并带来前所未有的性能提升，在JS后端实现了超出Json5近8倍性能的优势。

为什么要支持JS：全球最大的开发者社区

根据GitHub发布的“编程语言”流行度排行榜【1】，JavaScript占据榜首位置，它是目前就业市场和应用开发领域中最受欢迎和流行的编程语言之一。JavaScript拥有全球最大的开发生态，因此，大多数编程语言都支持 JavaScript后端。MoonBit支持JavaScript，也意味着MoonBit进入了更加大众化开发者的生态，是在软件开发领域和应用场景全覆盖的一次重要演进。

Untitled

JavaScript常年高居编程语言流行度排行榜第一名。（数据来源：https://octoverse.github.com/2022/top-programming-languages）

但在当前编程环境中，市面上的大部分alt-js language都不如原生性能。根据以往的基准测试，一些编译后的代码比原生JavaScript的体积大几乎350倍。尽管ReScript/ReasonML在编译到JavaScript上显示出一定优势（其开发者也是MoonBit平台的负责人），但其性能与原生JavaScript仍存在一定差距。因此，对于开发者而言，如果转译后的语言仅仅在可维护性上有少许提高，却以牺牲大量的体积和性能为代价，那么大多数情况下，原生JavaScript仍然是用户首选。

Untitled 1

数据来源：https://unsafeperform.io/blog/2022-07-02-a_small_benchmark_for_functional_languages_targeting_web_browsers/

为此，基于当前已有的alt-js language性能问题，MoonBit支持将代码编译到JavaScript后端，并在性能上显著超越原生JavaScript。

基准结果：生成代码执行速度超出 JS 近 25 倍

根据最新的JavaScript提案【2】— Iterator Helpers（迭代器助手），JavaScript能够原生支持无需中间数组的迭代操作。MoonBit也同步引入了相同的功能，进一步强化了在现代JavaScript开发环境中的适用性和效率。

我们先来看一个常见的例子：在处理大量学生成绩数据时，传统JavaScript代码通常需通过多个步骤处理数据，例如首先遍历1000个学生的成绩，将成绩转换为等级，然后按A、B、C、D、E排序，并筛选出A等级的学生，最后计算A等级学生的数量。这种方法虽直观，但由于需要生成多个中间数组，会导致性能问题。MoonBit在与原生支持迭代器助手的JavaScript进行比较后，编写出来的JavaScript代码显示，MoonBit的执行速度比使用原生迭代器助手快了25倍。

JS Iterator Helpers代码：

export function run(data) {
  return data
    .values()
    .flatMap((c) => c.members)
    .filter((it) => it.gender)
    .map((it) => Math.min(100, it.score + 5))
    .map((it) => grade(it))
    .filter((it) => it === 'A')
    .reduce((acc, _) => acc + 1, 0)
}

MoonBit代码

pub fn task(data: Array[ClassRecord]) -> Int {
  data.as_iter()
    .flat_map(fn { it => it.members.as_iter() })
    .filter(fn { it => it.gender })
    .map(fn { it => @math.minimum(100, it.score + 5) })
    .map(fn { it => grade(it) })
    .filter(fn { it => it == "A" })
    .fold(fn { acc, _ => acc + 1 }, 0)
}

MoonBit引入了类似于Rust中的零成本抽象 —— Iter类型，这是一个针对常见数据处理场景进行特殊优化的库。此类型的设计利用了MoonBit的高级抽象能力，同时确保不引入任何额外的运行时开销。通过使用Iter，可以将多个处理步骤合并为一个连贯的流程，显著减少中间数组的生成，从而提高性能。MoonBit的实现使得开发者能够编写逻辑清晰且高效的代码，无需担心性能损耗。

这种实现方式优化了数据处理过程，尤其适合于需要处理大量数据或执行复杂数据转换的应用程序。使用Iter类型，开发者可以更方便地构建高效且易于维护的系统，充分发挥MoonBit的性能优势。

Untitled 2

Benchmark来源：https://github.com/moonbit-community/benchmark-202404.git

►**生成代码执行速度：**我们将MoonBit生成的代码的执行速度与JS进行对比，快了超过25倍。这种方法不仅简化了代码，还提升了处理效率，允许开发者专注于业务逻辑而非性能优化，减少开发者的心智负担。

►**一秒内执行测试任务的次数：**MoonBit的性能是原生JavaScript的25倍，这意味着MoonBit在每秒内能执行的操作（Ops/Sec）远超原生JavaScript。

Untitled 3

以下是使用MoonBit进行优化后的代码示例及其编译结果：

Iter代码MoonBit生成的JS

MoonBit JS vs. JSON5：性能快近8倍

最新的性能测试结果显示，MoonBit Core标准库移植了npm上top 0.1%的Json5库，经过MoonBit编译之后的JS，比Json5库快接近8倍。**计算任务执行效率的性能提升意味着 MoonBit能够在相同的时间内执行更多的解析任务，**极大地提高了数据处理效率。

Untitled 4

Benchmark 来源：https://github.com/moonbit-community/benchmark-202404.git

为什么MoonBit比Json5的运行速度快？

之所以能取得这样的性能优势，关键在于MoonBit在处理数据时做了优化：将字符串直接转换为整数进行处理。 由于JavaScript本身没有字符类型，字符在JS中也是以字符串形式存在的，这意味着任何字符操作，实际上都是在字符串层面上进行，自然比直接操作整数要慢。

此外，MoonBit利用编译技术优化了代码处理过程。 例如，在编译过程中，字符常量会被转换为它们的Unicode codepoint值。这样在执行时就可以直接利用这些预编译的整数值，而不是在运行时动态处理字符。同样，对于switch语句，整数的switch操作可以编译成更快的指令，而字符串的switch操作效率就相当于一连串的if判断，速度会慢很多。MoonBit还引入了多项与JS无关的通用优化技术，如常量折叠、尾递归转换为循环、可选字符（Option[Char]）的解包优化以及迭代器融合（Iter fusion），从而提高了整体编译和运行效率。

除了这些已经实现的优化，MoonBit团队仍在不断探索新的改进方式。例如，未来的优化计划包括将整型数组（Array[Int]）编译到Int32Array，等等。为了确保性能的持续提升并防止性能回退，MoonBit已建立了一套监测机制，对新的更改进行严格的性能评估。

除了运行性能，MoonBit在编译性能上也表现出色，能够无需等待响应，即时编译至JS。MoonBit JS复用MoonBit的IDE以及整套工具，借鉴以往IDE的架构经验。MoonBit在语言设计之初充分考虑了IDE、构建系统、语言设计的协同，实现类型检查和推断的高度并行化和增量化。

开箱即用的工具链支持

此前有很多语言长时间内都未能支持sourcemap调试功能。MoonBit不仅支持JavaScript代码，且目前所有的工具链都支持开箱即用。

►完善的sourcemap支持，友好的调试支持

去年，MoonBit推出了调试器（Debugger）功能，这是相对于其他语言通常在成熟阶段才拥有的。即便跟编译性能与运行性能相近的ReScript相比，MoonBit已提供sourcemap支持，而ReScript在这方面迟迟没有提供支持。目前，该功能已支持源码映射、基于源码设置断点、输出sourcemap等，在浏览器中进行源码调试。这项功能的推出不仅减轻了开发者在代码调试方面的负担，还显著提升了开发和调试的流畅性。

MoonBit的sourcemap和调试支持优化开发者的调试体验，确保JavaScript代码的生成尽可能贴近源码，变量名和字段名保持一致，便于使用浏览器的DevTools进行源码检查和调试。

Repo地址：https://github.com/moonbit-community/moonbit-js-debug-demo.git

►本地 test codelens 的全新支持

此外，MoonBit IDE支持本地环境的test codelens，且本地环境已支持expect test的自动更新。相较于此前用户需要手动编写命令行的版本，现在只需要点击「Run Test | Update Test」即可完成毫秒级的编译，几乎无需等待响应，大幅提升了测试的效率。

功能的具体效果展示

如果你想自己尝试一下，可以复制点击： https://github.com/moonbit-community/benchmark-202404/tree/master/bench_json5

MoonBit 初获国际认可

MoonBit在2023年8月18日首发后，在国内外社区引发了热烈的讨论，并在发布不到一天的时间内登顶硅谷知名科技社区HackerNews头版头条。

Untitled 5

MoonBit登顶HackerNews头版头条

随着开源计划的逐步推进，MoonBit在今年3月首次开放标准库后，迅速获得了社区的广泛认可和积极响应。标准库开源至今，MoonBit收到了超过501次添加新功能的记录，并且收到261次请求将改动合并到主代码库中。其中80%的提交已被成功合并，这些贡献来自于40多位代码提交者，不仅包括具有丰富开发经验的专业人士，也有国内外的高中在读学生。值得一提的是，这些学生提交的代码质量堪比资深开发者。

Untitled 6

MoonBit标准库代码贡献

此外，今年4月，技术爱好者开发者@mizchi在日本著名的开发者社区zenn.dev上发表了一篇关于MoonBit的详细介绍文章，**该文章引发热议并迅速攀升至热门榜首。**文章通过MoonBit与其他编程语言的对比和实际体验，进一步加深社区对MoonBit优势的认识，使得该平台获得了新一轮的正面评价和关注。

Untitled 7

日本开发者社区对MoonBit的评价（点击大图）

未来展望

截至今日，MoonBit已经通过支持WebAssembly和JavaScript来完善其生态系统，并在行业内达到领先水平。在未来，MoonBit计划扩展到更多后端平台，如Native和JVM，并开发自有的运行时及云端部署环境，进一步强化其工具链支持。MoonBit平台不仅仅是一种编程语言，它还提供了一个全面的开发工具链，包括集成开发环境（IDE）、编译器、构建系统和包管理器等，为开发者提供了一站式的软件开发解决方案。

Untitled 8

MoonBit本年计划“剧透”

附录：

【1】：https://octoverse.github.com/2022/top-programming-languages

【2】：https://github.com/tc39/proposal-iterator-helpers

01 基本用法

首先，让我们使用 moon new hello 创建一个新项目

此时项目的目录结构如下：

.
├── README.md
├── lib
│   ├── hello.mbt
│   ├── hello_test.mbt
│   └── moon.pkg.json
├── main
│   ├── main.mbt
│   └── moon.pkg.json
├── moon.mod.json

打开 lib/hello_test.mbt，将内容替换为：

fn matrix(c: Char, n: Int) -> String {
  let mut m = ""
  for i = 0; i < n; i = i + 1 {
    for j = 0; j < n; j = j + 1 {
      m = m + c.to_string()
    }
    m += "\n"
  }
  m
}

这里，matrix 函数接受一个字符 c 和整数 n 作为参数，生成一个 n * n 大小的字符矩阵。

接下来，添加如下内容：

test {
  inspect(matrix('🤣', 3))?
}

打开终端，执行 moon test 命令可以观察到类似如下输出：

Diff:
----
🤣🤣🤣
🤣🤣🤣
🤣🤣🤣

----

这里的输出展示了 matrix 函数的实际输出和 ~content 参数的差异，执行 moon test -u 或者 moon test --update 可以观察到 lib/hello_test.mbt文件中的测试块被自动更新成：

test {
  inspect(matrix('🤣', 3), ~content=
    #|🤣🤣🤣
    #|🤣🤣🤣
    #|🤣🤣🤣
    #|
  )?
}

让我们再把 n 改成 4，然后执行 moon test -u 可以观察到测试块被自动更新成：

test {
  inspect(matrix('🤣', 4), ~content=
    #|🤣🤣🤣🤣
    #|🤣🤣🤣🤣
    #|🤣🤣🤣🤣
    #|🤣🤣🤣🤣
    #|
  )?
}

02 稍微复杂的例子

一般来说，写完一个函数后，我们需要为其编写一些单元测试。最简单的是断言测试，MoonBit 标准库中提供了 @assertion.assert_eq 函数，用于判断两个值是否相等。对于上述例子来说测试编写相对容易，因为我们可以轻易预测输出结果是什么。

接下来让我们看一个稍微复杂一点的例子：如何测试计算斐波那契数列第 n 项的函数。

首先在 lib 目录下新建一个 fib.mbt 的文件，然后粘贴如下内容：

fn fib(n : Int) -> Int {
  match n {
    0 => 0
    1 => 1
    _ => fib(n - 1) + fib(n - 2)
  }
}

我们需要一些测试来验证我们的实现是否正确。如果用断言测试，那么编写测试的流程是什么呢？假设我们想测试输入为 10 时 fib的结果，我们会写下类似如下的代码：

test {
  @assertion.assert_eq(fib(10), ???)?
}

当我们写下这个测试的时候，会立即遇到一个问题，我们并不知道 assert_eq 中右侧的期望值应该是什么。我们可以自己在纸上计算，或者找一份斐波那契数列参考列表、或者执行我们自己实现的 fib 函数。总之，不论用什么方法，我们需要得到 fib(10) 的期望值是 55，才能完成一个测试用例的编写。

此时 lib/fib.mbt 文件内容应为：

fn fib(n : Int) -> Int {
  match n {
    0 => 0
    1 => 1
    _ => fib(n - 1) + fib(n - 2)
  }
}

test {
  @assertion.assert_eq(fib(10), 55)?
}

然后执行 moon test 可以观察到如下输出：

Total tests: 2, passed: 2, failed: 0.

大家可以感受到，这里的反馈周期是很长的。通常来说，用这种方法编写测试并不是很愉悦。

对于 fib 这个例子我们可以相对容易找到一个正确的值作为参考。然而，大多数情况下，我们想测试的函数并没有其他“真值表”作为参考。我们需要做的是给这个函数提供输入，然后观察其输出是否符合我们的期望。这种模式比较常见，但其他工具链很少提供支持。因此，我们的 MoonBit 工具链提供了对这一测试模式的一等支持。通过使用 inspect 函数，我们只需要提供输入，而不需要提供期望值。

接下来，让我们用 inspect 函数编写输入分别为 8，9，10 时的测试用例，此时 lib/fib.mbt 文件的内容如下：

fn fib(n : Int) -> Int {
  match n {
    0 => 0
    1 => 1
    _ => fib(n - 1) + fib(n - 2)
  }
}

test {
  @assertion.assert_eq(fib(10), 55)?
}

test {
  inspect(fib(8))?
}

test {
  inspect(fib(9))?
}

test {
  inspect(fib(10))?
}

通过执行：

moon test

可以观察到实际输出与 inspect 函数中 ~content的差异：

$ moon test
test username/hello/lib/fib.mbt::0 failed
expect test failed at path/to/lib/fib.mbt:10:3-10:18
Diff:
----
21
----

test username/hello/lib/fib.mbt::1 failed
expect test failed at path/to/lib/fib.mbt:14:3-14:18
Diff:
----
34
----

test username/hello/lib/fib.mbt::2 failed
expect test failed at path/to/lib/fib.mbt:18:3-18:19
Diff:
----
55
----

接下来，我们的工作变成了检查这个输出是否正确，如果确信这些输出是正确的，通过执行 moon test -u，在 lib/fib.mbt 文件中对应的测试块会被自动更新成：

test {
  inspect(fib(8), ~content="21")?
}

test {
  inspect(fib(9), ~content="34")?
}

test {
  inspect(fib(10), ~content="55")?
}

通过这种编写测试然后立即获取反馈的模式，能够极大提升编写测试的愉悦感。

接下来，让我们来看一个修改函数行为导致输出变化的例子。

例如，我们现在想让 fib 的第一项从 1 而不是从 0 开始，首先我们将 fib 函数中的 0 => 0 修改为 0 => 1：

fn fib(n : Int) -> Int {
  match n {

然后执行 moon test 可以看到 expect test 自动为我们展示了前后差异：

$ moon test
test username/hello/lib/fib.mbt::0 failed: FAILED:path/to/lib/fib.mbt:10:3-10:36 `89 == 55`
test username/hello/lib/fib.mbt::1 failed
expect test failed at path/to/lib/fib.mbt:14:3-14:33
Diff:
----
2134
----

test username/hello/lib/fib.mbt::2 failed
expect test failed at path/to/lib/fib.mbt:18:3-18:33
Diff:
----
3455
----

test username/hello/lib/fib.mbt::3 failed
expect test failed at path/to/lib/fib.mbt:22:3-22:34
Diff:
----
5589
----

Total tests: 5, passed: 1, failed: 4.

这里的输出结果发生了位移，符合期望，我们大概率可以确定输出是对的。于是通过执行 moon test -u 自动更新测试结果。

等等！为什么自动更新后，还有一个测试用例失败了呢？

Total tests: 5, passed: 4, failed: 1.

这是因为我们忘记了修改断言测试，与 expect 测试不同，断言测试并不会自动更新。我们需要手动将断言测试对应的测试块修改为：

test {
  @assertion.assert_eq(fib(10), 89)?
}

从这个例子也能看出来，expect 测试是可以与断言测试协同工作的。

重新执行 moon test，可以看到全部测试都通过了。

Total tests: 5, passed: 5, failed: 0.

想象一下，如果我们之前有数百个断言测试，修改起来将会非常麻烦。通过使用 expect 测试，可以让我们从枯燥的更新工作中解脱出来。

以上，我们通过两个例子展示了它们如何通过编写测试并获得即时反馈，显著提升测试效率的能力。

我们鼓励你尝试使用 MoonBit 的 expect 测试，体验其在实际应用中的便利和高效。

你还可以了解更多内容：

如何开始使用 MoonBit
详细的 MoonBit 文档
添加微信小助手moonbit_helper，加入 MoonBit 用户群。
MoonBit 标准库现已开源，查看指南了解如何进行贡献。

国人自主研发的编程语言 MoonBit Core 开源啦！

2024年3月6日 · 阅读需 3 分钟

cover

【新功能上线】mooncakes.io：新一代的MoonBit包管理平台来啦！！

2024年2月22日 · 阅读需 5 分钟

Cover

今天，我们很高兴地宣布：mooncakes.io (MoonBit的包管理和共享平台)正式上线！与此同时，我们还推出了Moondoc，它用于记录mooncakes.io内各种包和库，确保开发者可以轻松使用各种资源。

MoonBit最大的价值在于生态，更多的人更早的参与进来可以帮助我们一起完善MoonBit平台，一起分享它的成长。虽然还处于非常早期的阶段，还有很多地方需要完善，但是我们想第一时间分享给大家！

接下来，让我们一起深入了解 mooncakes.io 的独特之处。

MoonBit: 面向 WebAssembly 的快速、简洁、用户友好的语言

2023年8月18日 · 阅读需 9 分钟

blog-title

MoonBit Pilot 优势一览​

从底层语言适配AI,深度激发大模型潜能​

MoonBit Pilot 能力展示​

支持超大规模代码重构，提升代码质量​

分段编码，快速的高并发重构​

速度远高于 Cursor, Codex​

另一种范式：云端异步编程，零人工干预​

一键安装​

构筑差异化技术壁垒，构建云原生系统与底层框架​

厂商视角：从关注到技术试点​

高校教育：纳入课程实践工具​

AI 协同开发与国产芯片适配双轨演进​

面向 AI 协同的开发语言：构建双向智能通道​

向下延伸至国产芯片支持：从工具语言迈向系统构建引擎​

Beta 版：工具链打磨与语言层面深度融合​

【READ MORE】MoonBit 的三年探索历程​

推荐阅读​

使用方式​

IDE 支持​

工具链支持​

用 .mbt.md 写技术博客​

用 CI 确保文档代码始终正确​

总结​

无缝融合Python 生态​

国际关注​

MoonBit的优势​

MoonBit 与 Python 对比​

总结​

项目链接​

使用方法​

具体示例​

自定义 moonbitlang/core/abort 的实现​

在 ESP32-C3 上实现生命游戏​

准备工作​

生命游戏逻辑的实现​

运行实例代码​

总结​

为什么选择 MoonBit？​

Rabbit-TEA 如何工作​

声明式视图: HTML EDSL​

消息与模式匹配​

管理副作用​

与 JS 世界交互​

轻量的运行时​

结论​

LLVM后端发布​

成为北京大学课程语言​

MoonBit 发展历程​

LLVM 编译流程​

包的编译​

链接和代码生成​

性能实测：LLVM 后端的工业级表现​

原生后端调试支持​

未来展望​

什么是 Moonpad​

如何使用 Moonpad​

准备​

编写代码​

构建并启动服务器​

如何在你的网站中使用 Moonpad​

原理​

在 jekyll 中使用 Moonpad​

观察 jekyll 渲染代码块的结构​

导入 Moonpad​

将 moonpad 文件夹放到 jekyll 的静态资源目录下​

结果​

在 marp 中使用 Moonpad​

观察 marp 渲染代码块的结构​

导入 Moonpad​

将 moonpad 文件夹放到 marp 的静态资源目录下​

结果​

如何使用 Moonpad 编译 MoonBit 代码​

对 Cmark 库进行性能分析​

分析火焰图​

实现高性能​

动机​

封装 Cmark​

与 JavaScript 集成​

拥抱开源​

为什么采用宽松版的 SSPL​

MoonBit Pilot 优势一览

从底层语言适配AI,深度激发大模型潜能

MoonBit Pilot 能力展示

支持超大规模代码重构，提升代码质量

分段编码，快速的高并发重构

速度远高于 Cursor, Codex

另一种范式：云端异步编程，零人工干预

一键安装

构筑差异化技术壁垒，构建云原生系统与底层框架

厂商视角：从关注到技术试点

高校教育：纳入课程实践工具

AI 协同开发与国产芯片适配双轨演进

面向 AI 协同的开发语言：构建双向智能通道

向下延伸至国产芯片支持：从工具语言迈向系统构建引擎

Beta 版：工具链打磨与语言层面深度融合

【READ MORE】MoonBit 的三年探索历程

推荐阅读

使用方式

IDE 支持

工具链支持

用 `.mbt.md` 写技术博客

用 CI 确保文档代码始终正确

总结

无缝融合Python 生态

国际关注

MoonBit的优势

MoonBit 与 Python 对比

总结

项目链接

使用方法

具体示例

自定义 `moonbitlang/core/abort` 的实现

在 ESP32-C3 上实现生命游戏

准备工作

生命游戏逻辑的实现

运行实例代码

总结

为什么选择 MoonBit？

Rabbit-TEA 如何工作

声明式视图: HTML EDSL

消息与模式匹配

管理副作用

与 JS 世界交互

轻量的运行时

结论

LLVM后端发布

成为北京大学课程语言

MoonBit 发展历程

LLVM 编译流程

包的编译

链接和代码生成

性能实测：LLVM 后端的工业级表现

原生后端调试支持

未来展望

什么是 Moonpad

如何使用 Moonpad

准备

编写代码

构建并启动服务器

如何在你的网站中使用 Moonpad

原理

在 jekyll 中使用 Moonpad

观察 jekyll 渲染代码块的结构

导入 Moonpad

将 moonpad 文件夹放到 jekyll 的静态资源目录下

结果

在 marp 中使用 Moonpad

观察 marp 渲染代码块的结构

导入 Moonpad

将 moonpad 文件夹放到 marp 的静态资源目录下

结果

如何使用 Moonpad 编译 MoonBit 代码

对 Cmark 库进行性能分析

分析火焰图

实现高性能

动机

封装 Cmark

与 JavaScript 集成

拥抱开源

为什么采用宽松版的 SSPL