Luon 编程语言
一种面向安全的系统级 WASM 语言，具备数学身份——专为现代威胁环境而设计。
为什么选择 Luon？ •
安全 •
安装 •
语法 •
标准库 •
路线图 •
贡献
## 为什么选择 Luon？
大多数编程语言都在为**开发者人体工程学**进行优化——可读性、便利性以及低学习曲线。Luon 采取了一种根本不同的方法。
**Luon 为安全而优化。**
每一个设计决策——从数学语法到基于寄存器的执行模型——都是为了让 Luon 程序**能够抵抗逆向工程、自动化分析以及新兴的密码学威胁**。陡峭的学习曲线是一项深思熟虑的**安全设计选择**。
### 设计哲学
| 原则 | 描述 |
|---|---|
| **面向安全** | 每一项语言特性都会根据其安全影响进行评估。便利性永远不会凌驾于安全性之上。 |
| **抗逆向工程** | 源代码采用数学逻辑符号表示，旨在抵抗自动化分析、模式匹配和基于 AI 的代码理解。 |
| **量子感知设计** | 密码学基础在构建时充分考虑了新兴的量子计算威胁。采用 BLAKE2b、恒定时间操作和密封的可执行文件格式。 |
| **确定性执行** | 单线程，无 GC，无非确定性。每一条执行路径都是完全可预测的——这对于区块链共识和可审计计算至关重要。 |
| **WASM 沙箱** | 程序运行在 WebAssembly 的线性内存沙箱中，并进行严格隔离，显著减少了攻击面。 |
| **自举** | 编译器能够自行编译自身（已验证 `gen1 == gen2`）。编译过程完全零依赖外部工具链。 |
| **最小攻击面** | 小巧、可审计的 C 运行时（约 1000 行代码）。无外部依赖。没有臃肿的标准库。 |
### Luon 的独特之处
```
┌─────────────────────────────────────────────────────────────────┐
│ TYPICAL LANGUAGE │
│ if (x > 0) { print("positive"); } ← Readable by anyone │
│ AI can analyze, decompile, reverse ← Higher exposure risk │
├─────────────────────────────────────────────────────────────────┤
│ LUON │
│ (∂_Ω ≻_{ω₁} 0)^{well-order} ← Mathematical notation │
│ AI-resistant, RE-resistant syntax ← Security design choice │
└─────────────────────────────────────────────────────────────────┘
```
Luon 的语法派生自**范畴论**、**形式逻辑**、**代数几何**和**集合论**。这是一项刻意为之的安全设计选择——类似于数学论文的源代码，提高了随意阅读、未经授权复制和自动化逆向工程的门槛。
## 安全架构
Luon 在堆栈的**每一层**都实现了安全性：
### 第 1 层：语法级保护
源代码使用 Unicode 数学符号（∀, ∃, ⊢, ⊣, ∂, Ω, σ, η, μ, ⊥, ⊤）代替常规关键字，提高了未授权代码理解的门槛。
### 第 2 层：WASM 代码转换引擎（6 个阶段）
编译器包含一个可选的二进制保护管道，并支持多态输出：
| 阶段 | 技术 | 效果 |
|---|---|---|
| 1 | 指令替换 | 在算术操作周围填充 NOP |
| 2 | 死代码注入 | 随机生成 `i64.const; drop` 序列 |
| 3 | 不透明谓词 | 总是以相同方式求值的计算 |
| 4 | 控制流平坦化 | 将线性代码拆分为打乱的 `br_table` 状态机 |
| 5 | 寄存器洗牌 | 对局部索引 1-127 进行 Fisher-Yates 置换 |
| 6 | 多态输出 | 每次编译都会生成一个**唯一的**二进制文件（种子来源于 time + urandom） |
### 第 3 层：密封的可执行文件格式 (.lse)
Luon 定义了一种专有的加密容器格式：
```
┌─────────────────────────────────────┐
│ Magic: \x7fLSE │
│ Version + Seed │
│ Integrity Hash (BLAKE2b-256) │
├─────────────────────────────────────┤
│ Opcode Permutation Table │
│ (Fisher-Yates, 64-slot, per-seed) │
├─────────────────────────────────────┤
│ Encrypted Bytecode │
│ (BLAKE2b-CTR Stream Cipher) │
├─────────────────────────────────────┤
│ Integrity Verification Footer │
│ (BLAKE2b-256 over header+cipher) │
└─────────────────────────────────────┘
```
### 第 4 层：运行时沙箱
Luon VM 强制执行严格的执行限制：
| 守卫 | 限制 |
|---|---|
| 栈深度 | 65,536 个条目 |
| 函数数量 | 最大 256 |
| 调用深度 | 最大 1,024 |
| 局部变量 | 每个函数 256 个 |
| 内存 | 30 个 WASM 页（约 1.9 MiB） |
| 循环迭代 | 最大 50,000,000 |
### 第 5 层：WASM 内存隔离
每个 Luon 程序都运行在 WASM 的线性内存模型中——除了显式导入的 WASI 函数外，无法访问主机文件系统、网络或系统调用。
## 快速演示
```
∀ₛₚₑ𝒸 Ψ ∈ 𝔘[hello] ⊢_Γ {
∃!Φ ∈ Hom(𝒞,𝒟)[main] ⊣^{op} {
// Add 42 to the input parameter
(Ext⁰_𝔄(∂_Ω, 42))_{Spec ℤ}
⊥_{𝒯}→^{ex falso}⊤_{𝒯}
}
}
```
```
$ luon run hello.luon -a 10
52
```
发生了什么：
1. `∀ₛₚₑ𝒸 Ψ ∈ 𝔘[hello]` — 声明模块 `hello`
2. `∃!Φ ∈ Hom(𝒞,𝒟)[main]` — 声明函数 `main`
3. `(Ext⁰_𝔄(∂_Ω, 42))_{Spec ℤ}` — 将 42 加到累加器（输入为 10）
4. `⊥_{𝒯}→^{ex falso}⊤_{𝒯}` — 返回累加器的值 (52)
## 安装说明
### 前置条件
- **GCC** 或任何 C 编译器（用于构建本地运行时）
### 从源代码构建
```
git clone https://github.com/cagioo/LUON.git
cd LUON
gcc -O2 -o luon runtime/luon_vm.c
```
### 快速安装 (Linux/macOS)
```
bash install.sh
```
安装后，请重启你的 shell 或运行 `source ~/.bashrc`。
### 验证
```
./luon build examples/fibonacci.luon
./luon run examples/fibonacci.luon -a 10
```
## 架构
### 编译管道
```
┌─────────────┐ ┌──────────────┐ ┌────────────────┐
│ .luon │─────▶│ Parser + │─────▶│ .wasm │
│ (source) │ │ Emitter │ │ (binary) │
└─────────────┘ └──────────────┘ └───────┬────────┘
│
┌──────────────┐ │
│ Runtime │◀─────────────┘
│ (C / WASI) │
└──────────────┘
```
1. **解析器** — 读取数学语法，通过滚动哈希对操作符模式进行哈希处理，生成 IR
2. **发射器** — 将 IR 转换为有效的 WASM 二进制文件（i64 累加器模型）
3. **运行时** — 通过原生 C 运行时或任何兼容 WASI 的运行时（如 Wasmtime 等）执行
### 自举编译器
编译器（`bootstrap/compiler.luon`）可以自行编译自身，并在各代之间产生字节完全相同的输出：
```
compiler.luon ──[compiled by compiler.wasm]──▶ gen1.wasm
compiler.luon ──[compiled by gen1.wasm]──────▶ gen2.wasm
SHA-256(gen1.wasm) == SHA-256(gen2.wasm) ✅
```
### 执行模型
Luon 使用**基于累加器的模型**，包含 127 个通用寄存器：
| 概念 | 符号 | 用途 |
|---|---|---|
| 累加器 | `∂_Ω` | 主要工作值——大多数操作都对此进行读写 |
| 输入参数 | `σ₀` | 函数输入 |
| 寄存器 | `σ₁`–`σ₁₂₇` | 临时存储 |
| 函数调用 | `η_{Kan}N` | 通过索引 `N` 调用函数（多参数，多返回值） |
| 返回 | `⊥_{𝒯}→^{ex falso}⊤_{𝒯}` | 返回累加器（或通过 `→^{N}` 返回 N 个值） |
| 词法作用域 | `[σ₂, σ₃] ⊣_{scope}` | 块内的影子寄存器，退出时自动恢复 |
### 内存布局
Luon 程序使用 WASM 线性内存（30 页 ≈ 1.9 MiB）：
```
Address Range Purpose
───────────── ────────────────────────────────
0x00000–0x0FFFF Code/data area
0x10000–0x1FFFF Input buffer
0x20000–0x2FFFF Output buffer
0x30000–0x4FFFF Compiler metadata
0x50000–0x5FFFF Runtime state (heap ptr, test counters, PRNG, crypto)
0x60000+ Heap segment (bump allocator)
0xE000–0xEFFF WASI argument scratch
0xF000–0xFFFF General scratch space
```
## 语法参考
### 模块声明
```
∀ₛₚₑ𝒸 Ψ ∈ 𝔘[module_name] ⊢_Γ {
...
}
```
### 函数声明
```
// Single return value (default)
∃!Φ ∈ Hom(𝒞,𝒟)[function_name] ⊣^{op} {
...
⊥_{𝒯}→^{ex falso}⊤_{𝒯}
}
// Multiple return values (Tuple of 3)
∃!Φ ∈ Hom(𝒞,𝒟)[function_name] →^{3} ⊣^{op} {
...
⊥_{𝒯}→^{ex falso}⊤_{𝒯}
}
```
### 算术运算符
| 操作 | 语法 | 等效表示 |
|---|---|---|
| 加法 | `(Ext⁰_𝔄(∂_Ω, N))_{Spec ℤ}` | `acc += N` |
| 减法 | `(Tor₀^𝔄(∂_Ω, -N))_{Spec ℤ}` | `acc -= N` |
| 乘法 | `(∂_Ω ⊗_ℤ N)^{⊗L}_{D(𝔄)}` | `acc *= N` |
| 除法 | `(RHom_ℤ(N, ∂_Ω))_{D^b(𝔄)}` | `acc /= N` |
| 取模 | `(∂_Ω mod_{ℤ} N)^{Euclidean}` | `acc %= N` |
### 按位运算符
| 操作 | 语法 | 等效表示 |
|---|---|---|
| AND | `(∂_Ω ∧_{Bool} N)^{∧-intro}` | `acc &= N` |
| OR | `(∂_Ω ∨_{Bool} N)^{∨-intro}` | `acc \|= N` |
| XOR | `(∂_Ω ⊕_{Bool} N)^{⊕-intro}` | `acc ^= N` |
| 左移 | `(∂_Ω ≪_{Galois} N)^{adjunction}` | `acc <<= N` |
| 右移 | `(∂_Ω ≫_{Galois} N)^{adjunction}` | `acc >>= N` |
### 比较运算符
| 操作 | 语法 | 等效表示 |
|---|---|---|
| 等于零 | `(∂_Ω ≡_{E_∞} ⊥)^{acyclic}` | `acc == 0` |
| 等于 | `(∂_Ω ≡_{E_∞} N)^{acyclic}` | `acc == N` |
| 不等于 | `(∂_Ω ≠_{E_∞} N)^{acyclic}` | `acc != N` |
| 小于 | `(∂_Ω ≺_{ω₁} N)^{well-order}` | `acc < N` |
| 大于 | `(∂_Ω ≻_{ω₁} N)^{well-order}` | `acc > N` |
### 控制流
| 操作 | 语法 |
|---|---|
| 块开始 | `⊢_{Γ}^{⊃I}⟦` |
| 块结束 | `⟧^{⊃E}_{Δ}⊣` |
| 循环开始 | `μ_{ω₁}^{CK}⟦` |
| 循环结束 | `⟧_{ω₁}^{CK}μ` |
| 分支 (无条件) | `(⊬_{PA}^{Gödel} σ_N)^{ω-rule}` |
| 分支如果 (条件) | `(∂_Ω ⊬_{PA}^{Gödel} σ_N)^{ω-rule}` |
| 返回 | `⊥_{𝒯}→^{ex falso}⊤_{𝒯}` |
| 调用函数 | `(η_N ∘_{2-Cat} ∂_Ω)^{Kan}` |
### 内存操作
| 操作 | 语法 | 等效表示 |
|---|---|---|
| 存储 i64 | `(⊨_{𝕂,Γ}^{κ-forcing} ↦_𝒯 σ_N)` | `mem[acc] = σ_N` |
| 存储字节 | `(⊨_{𝕂,Γ}^{κ-forcing} ↦₈_𝒯 σ_N)` | `mem8[acc] = σ_N` |
| 加载 i64 | `(⊩_{𝕂,Σ}^{Γ-generic} ↤_𝒯 ∂_Ω)` | `acc = mem[acc]` |
| 加载字节 | `(⊩_{𝕂,Σ}^{Γ-generic} ↤₈_𝒯 ∂_Ω)` | `acc = mem8[acc]` |
### 浮点运算
| 操作 | 语法 | 等效表示 |
|---|---|---|
| FAdd | `(st(∂_{*ℝ}) ⊕_{*ℝ} st(σ_N))^{transfer}` | f64 加法 |
| FSub | `(st(∂_{*ℝ}) ⊖_{*ℝ} st(σ_N))^{transfer}` | f64 减法 |
| FMul | `(st(∂_{*ℝ}) ⊗_{*ℝ} st(σ_N))^{transfer}` | f64 乘法 |
| FDiv | `(st(∂_{*ℝ}) ⊘_{*ℝ} st(σ_N))^{transfer}` | f64 除法 |
| FSqrt | `(√_{*ℝ} st(∂_{*ℝ}))^{shadow}` | f64 平方根 |
### 寄存器操作
| 操作 | 语法 | 等效表示 |
|---|---|---|
| 存入寄存器 | `(∂_Ω ⊢_{Γ;Δ} σ₂)^{seq}` | `σ₂ = acc` |
| 从寄存器加载 | `(σ₂ ⊣_{Δ;Γ} ∂_Ω)^{co-seq}` | `acc = σ₂` |
| 加载常量 | `(42 ⊣_{Δ;Γ} ∂_Ω)^{axiom}` | `acc = 42` |
| 开始作用域 | `[σ₂, σ₃] ⊣_{scope} {` | 影子变量 |
| 结束作用域 | `} ⟧_{scope}` | 恢复变量 |
## 标准库
Luon 附带 **20标准库模块**：
### 核心
| 模块 | 描述 | 关键函数 |
|--------|-------------|---------------|
| `io` | WASI stdout/stderr | `write_stdout`, `print_str`, `print_int` |
| `memory` | Bump 堆内存分配器 | `heap_init`, `alloc` |
| `string` | 字符串操作 | `strlen`, `strcmp`, `memcpy`, `itoa`, `atoi` |
| `wasi` | WASI 系统接口 | `exit`, `get_args_count` |
### 数学与转换
| 模块 | 描述 | 关键函数 |
|--------|-------------|---------------|
| `math` | 整数/f64 数学运算 | `abs`, `min`, `max`, `pow`, `sqrt`, `gcd`, `lcm`, `factorial` |
| `convert` | 类型转换 | `clamp_u8/u16/u32`, `sign_extend`, `hex_digit`, `swap_bytes` |
| `fmt` | 格式化输出 | `print_char`, `print_bool`, `print_hex_byte` |
### 集合
| 模块 | 描述 | 关键函数 |
|--------|-------------|---------------|
| `array` | 动态数组 (vector) | `push`, `pop`, `get`, `set`, `reverse`, `contains` |
| `hashmap` | 哈希映射 (FNV-1a) | `set`, `get`, `has`, `delete`, `clear` |
| `sort` | 排序算法 | `insertion_sort`, `binary_search`, `is_sorted` |
| `buffer` | 字节缓冲区 I/O | `write_byte`, `write_i64`, `read_byte`, `seek` |
### 安全与错误处理
| 模块 | 描述 | 关键函数 |
|--------|-------------|---------------|
| `result` | Result\
/ Option\ | `ok`, `err`, `some`, `none`, `unwrap`, `is_ok` |
| `error` | 16 个标准错误码 | `is_error`, `is_success`, `error_or_default` |
| `testing` | 测试断言 | `assert_eq`, `assert_ne`, `assert_true`, `test_summary` |
### 系统与安全
| 模块 | 描述 | 关键函数 |
|--------|-------------|---------------|
| `fs` | WASI 文件系统 | `file_open`, `file_read`, `file_write`, `file_close` |
| `env` | WASI 环境 | `args_count`, `args_get`, `clock_time`, `exit` |
| `random` | xorshift64* PRNG | `seed`, `next_u64`, `range`, `bool` |
| `crypto` | 密码学原语 | `sha256_init`, `constant_time_eq`, `memzero` |
### 类型系统
| 模块 | 描述 | 关键函数 |
|--------|-------------|---------------|
| `struct` | 结构体/记录类型 | `struct_define`, `struct_new`, `get_field`, `set_field` |
| `enum` | 枚举/ADT 标签联合体 | `enum_define`, `enum_create`, `enum_tag`, `enum_match` |
## 工具链
| 工具 | 文件 | 描述 |
|------|------|-------------|
| **解析器** | `tools/parser.luon` | 基于哈希的操作码分派解析器（使用 Luon 编写） |
| **发射器** | `tools/emitter.luon` | 带有 ULEB128/SLEB128 编码的 WASM 二进制发射器 |
| **CLI** | `tools/cli.luon` | 命令行界面基础 |
| **类型检查器** | `tools/typechecker.luon` | 13 种类型 ID，赋值兼容性，错误报告 |
| **模块解析器** | `tools/module_resolver.luon` | 导入解析，循环检测，64 模块容量 |
### 类型系统（13 种基本类型）
| ID | 类型 | 大小 | 描述 |
|---:|---|---:|---|
| 0 | `void` | 0 | 无值 |
| 1 | `bool` | 1 | 布尔值 (0/1 整数) |
| 2 | `i32` | 4 | 32 位有符号整数 |
| 3 | `i64` | 8 | 64 位有符号整数 |
| 4 | `f32` | 4 | 32 位浮点数 |
| 5 | `f64` | 8 | 64 位浮点数 |
| 6 | `ptr` | 8 | 线性内存指针 |
| 7 | `str` | 16 | 字符串描述符 |
| 8 | `array` | 8 | 堆数组指针 |
| 9 | `struct` | 可变 | 用户自定义记录 |
| 10 | `fn` | 8 | 函数引用 |
| 11 | `result` | 16 | 标签结果对 |
| 12 | `option` | 16 | 标签可选对 |
| 13 | `never` | 0 | 非返回型 |
## 示例
`examples/` 目录包含 **34 个程序**：
| 示例 | 描述 | 概念 |
|---------|-------------|----------|
| `add42.luon` | 将输入加 42 | 基本算术 |
| `fibonacci.luon` | 迭代斐波那契 | 循环，寄存器 |
| `bubble_sort.luon` | 冒泡排序算法 | 内存，数组，循环 |
| `calculator.luon` | 多功能计算器 | 多函数，调用 |
| `linked_list.luon` | 单向链表 | 堆分配，指针 |
| `matrix_multiply.luon` | 3×3 矩阵乘法 | 嵌套循环，内存 |
| `testing_demo.luon` | 测试框架演示 | 断言，测试计数器 |
| `hello_wasi.luon` | 通过 WASI 输出 Hello World | WASI fd_write |
| `spectral.luon` | V-Dot 粒子过滤器 | 浮点运算 |
| `crypto_v2.luon` | 签名/验证加密 | Étale 上同调符号 |
| `comprehensive_v2.luon` | 完整 v2 语法展示 | 所有操作符域 |
| `codex.luon` | 复杂多模块演示 | 高级模式 |
| `tuple_test.luon` | 3 值元组返回 | 多返回值，`→^{N}` |
| `scope_test.luon` | 词法作用域演示 | `⊣_{scope}`，寄存器影子化 |
| `named_call_test.luon` | 按名称调用演示 | 链接器符号表，`η_{Kan}[name]` |
## 项目结构
```
LUON/
├── bootstrap/ # Self-hosting compiler
│ ├── compiler.luon # Compiler source (written in Luon)
│ └── compiler.wasm # Prebuilt bootstrap binary (27 KB)
│
├── runtime/ # Native C runtime
│ ├── luon_vm.c # WASM interpreter + CLI (single-file, ~1000 LOC)
│ └── luon_compile.h # Minimal v2→WASM compiler helper
│
├── stdlib/ # Standard library (20 modules)
│ ├── io.luon ├── math.luon
│ ├── memory.luon ├── array.luon
│ ├── string.luon ├── hashmap.luon
│ ├── wasi.luon ├── sort.luon
│ ├── result.luon ├── testing.luon
│ ├── random.luon ├── crypto.luon
│ ├── fs.luon ├── env.luon
│ ├── convert.luon ├── fmt.luon
│ ├── buffer.luon ├── error.luon
│ ├── struct.luon └── enum.luon
│
├── tools/ # Compiler toolchain (written in Luon)
│ ├── parser.luon # Hash-based opcode dispatch parser
│ ├── emitter.luon # WASM binary emitter
│ ├── cli.luon # CLI foundation
│ ├── typechecker.luon # 13-type static type system
│ └── module_resolver.luon # Import resolution + cycle detection
│
├── examples/ # 34 example programs
├── editor/luon-vscode/ # VS Code extension (v0.2.0)
├── docs/ # Additional documentation
├── .github/workflows/ # CI/CD pipelines
│
├── README.md # This file
├── ROADMAP.md # Detailed development roadmap
├── LICENSE # Apache 2.0
├── CHANGELOG.md # Version history
├── CONTRIBUTING.md # Contribution guidelines
├── CODE_OF_CONDUCT.md # Community standards
├── SECURITY.md # Security policy
├── LUON_DOCUMENTATION.md # Complete 1,200+ line technical reference
└── LUON_REFERENCE.md # Quick reference card
```
## 编辑器支持
### VS Code 扩展 (v0.2.0)
从 `editor/luon-vscode/` 安装：
```
cd editor/luon-vscode
code --install-extension .
```
功能：
- v2 数学符号的语法高亮
- 20 个代码片段（模块、函数、循环、块、操作符等）
- 括号匹配与自动闭合
- 12 个 TextMate 语法作用域类别
## 贡献
我们欢迎所有人的贡献。有关完整指南，请参阅 [CONTRIBUTING.md](CONTRIBUTING.md)。
### 贡献证明计划
Vesege 运营着一个**贡献证明** 激励系统。为生态系统提供价值的贡献者——包括错误报告、代码 PR、功能提案、文档——在主网 启动时，有资格获得 **VVF (Vesege Coin)** 分发。
### 如何贡献
1. Fork 该仓库
2. 创建一个特性分支 (`git checkout -b feature/amazing-feature`)
3. 提交你的更改 (`git commit -m 'Add amazing feature'`)
4. 推送到该分支 (`git push origin feature/amazing-feature`)
5. 发起一个 Pull Request
## 社区与支持
| 渠道 | 链接 |
|---|---|
| **Discord** | [discord.gg/47q8J5PgD](https://discord.gg/47q8J5PgD) |
| **X (Twitter)** | [@CagiR8649](https://x.com/CagiR8649) |
| **GitHub** | [github.com/cagioo](https://github.com/cagioo) |
| **Instagram** | [@cagi.r12](https://www.instagram.com/cagi.r12) |
| **Threads** | [@cagi.r12](https://www.threads.com/@cagi.r12) |
| **Facebook** | [Cagi R](https://www.facebook.com/share/1BMv3UaTMY/) |
| **赞助** | cagi@vesege.com |
## 许可证
本项目基于 **Apache License 2.0** 授权——有关详情，请参阅 [LICENSE](LICENSE) 文件。
Vesege — 信任源于透明