第五十七篇讲的是"自举闭环"------一件非常硬核、非常值得骄傲的事。但那一篇写完之后,我意识到一个问题:
如果你是第一次听说 Kylix,你点开这一系列,会一脸懵。
因为第五十七篇的前提是"你已经知道 Kylix 是一门什么语言、它能写什么、它怎么跑起来"。但如果这三个前提都没有,第五十七篇就只是技术宅的自嗨。
所以第五十八篇,我把整件事翻个面:
忘掉前面五十七篇的所有前提假设------我们从零开始。
这一篇的对象是:完全不懂 Pascal、完全不懂编译器、可能只用过 Python 或 JavaScript 的人。你要做的只是"打开终端,跟着敲"。如果你照着敲完能跑出 Hello World,就算过关;如果你照着敲完能写出一个能登录的 Web 服务,就算精通。
读完之后,你至少要能讲清楚三件事:
-
- Kylix 是一门什么样的语言?
-
- 它能做什么?
-
- 怎么从零开始动手?
至于"它内部是怎么实现的"、"它怎么编译自己"这些细节,我会点到为止;真正想深挖的人,看完这一篇再去翻第五十七篇、或者直接去 GitHub 看源码。
按惯例,一句话记住第五十八篇:
Kylix 是一门给"想认真写程序"的人准备的现代 Pascal------简单、快、可以编译自己,而且写 Web 服务和写命令行工具一样自然。
接下来我们一步步走。
§ 1 三句话讲清楚 Kylix 是什么
第一句话:Kylix 是一门语言 。它有自己的文件后缀 .klx(Kylix Language 的缩写),有自己的语法,有自己的编译器。你写 .klx 文件,编译器帮你产出可执行程序。
第二句话:Kylix 是一门现代 Pascal。它保留 Pascal 的优雅骨架(清晰、可读、类型安全),但加上了现代语言里几乎所有你想要的能力------类型推导、泛型、Lambda、async/await、模式匹配、字符串插值、异常处理。读起来像 Python / Swift 的亲戚,语法骨架是经典 Pascal。
第三句话:Kylix 能编译出真正的原生二进制------不依赖虚拟机,不依赖解释器,运行速度就是机器码的速度。它有两条后端:
你写的 hello.klx
│
▼
┌──────────────┐
│ kylix 编译器 │
└──────┬───────┘
│
┌─────┴─────┐
▼ ▼
走 Go 后端 走 LLVM 后端
生成 Go 代码 生成 LLVM IR
→ go build → llc → clang
→ 原生二进制 → 原生二进制
(需要 Go) (需要 LLVM,不要 Go)走 Go 后端 好处是生态丰富(能借力 Go 的库);走 LLVM 后端好处是不依赖 Go,产物体积更小、启动更快,适合做 KylixRT(让 Kylix 程序在自己产出的二进制里运行,不依赖宿主环境)。
一句话:写起来像 Python,跑起来像 C,后台挂着 Pascal 的优雅。
最打动人的三个特点:
┌──────────────────────────────────────────────────┐
│ │
│ 简单 ──► Pascal 语系,begin...end 清晰, │
│ 初学者一晚上能读懂基本语法 │
│ │
│ 快 ──► 编译毫秒级,运行原生机器码 │
│ (LLVM -O2 编译速度 575ms,运行更快) │
│ │
│ 自举 ──► 编译器能编译自己(v0.6.9 达成) │
│ 用 Kylix 写 Kylix 编译器, │
│ 而且输出逐字节一致(数学不动点) │
│ │
└──────────────────────────────────────────────────┘如果你只想记住一句话------
Kylix 是一门"让认真写代码这件事回归简单"的现代语言。
§ 2 第一个程序:十分钟,从安装到 Hello World
不废话,直接动手。
§ 2.1 安装
Kylix 编译器本体用 Go 写,需要在 macOS / Linux 上先装两个东西:Go 和 LLVM。
# macOS
brew install go llvm
# Ubuntu / Debian
sudo apt install -y golang-go llvm clang libsqlite3-dev libcurl4-openssl-dev libssl-dev装好之后,把 Kylix 编译器装到本机:
git clone https://github.com/astra-zhao/kylix.git
cd kylix
go build -o /usr/local/bin/kylix ./cmd/kylix/
kylix --version期望输出:Kylix 0.6.9。
如果哪一步卡了,跑一下体检:
kylix doctorkylix doctor 会一项一项检查 Go、LLVM、链接库、版本兼容性,然后告诉你哪缺什么、怎么装。这是 Kylix 最贴心的命令,没有之一。
§ 2.2 Hello, World!
建一个文件 hello.klx:
program Hello;
begin
WriteLn('Hello, World!');
end.注意三个老派但有讲究的写法:
| 写法 | 含义 |
|---|---|
program Hello; |
声明程序名(分号结尾) |
begin ... end. |
代码体,end 后面是句号(表示程序结束,不是分号) |
每条语句以 ; 结尾 |
Pascal 传统 |
然后一条命令搞定------编译 + 运行:
kylix run hello.klx输出:
Hello, World!kylix run 是 Kylix 最聪明的命令,它叫 auto 后端:
-
• 本机装了 Go → 走 Go 后端(编译最快,毫秒级)
-
• 本机没装 Go → 自动切 LLVM 后端(需要 LLVM,产物体积更小)
两种情况你都不用操心------一条命令自动选最快的路径。
§ 2.3 如果你想分步
kylix build hello.klx # 编译 → 产出 hello 二进制
./hello # 自己运行kylix build 支持各种参数:
kylix build hello.klx --backend=llvm # 强制走 LLVM 后端
kylix build hello.klx --target=linux-arm64 # 交叉编译到 Linux ARM64
kylix build hello.klx --llvm-opt=2 # LLVM -O2 优化
kylix build hello.klx -g # 带 DWARF 调试符号(lldb 可逐行调试)到这里你已经会写第一个程序了。接下来我们扫一下语言特性。
§ 3 语法速览:核心特性五分钟扫描
如果你会 Python、JavaScript、Java、Go 里任何一个,下面这些代码你应该都能一眼看懂。
§ 3.1 变量与类型------编译器帮你算
program Variables;
const
MAX = 100; // 常量,编译期定死
begin
var age: Integer; // 显式类型
age := 25;
var name := 'Astra'; // 推断类型(String)
var pi := 3.14; // 推断类型(Float)
var ok := true; // 推断类型(Boolean)
WriteLn(name + ' is ' + IntToStr(age) + ' years old');
WriteLn('age = ${age}'); // 字符串插值
end.两种声明方式 ------显式(var age: Integer)和推断(var name := 'Astra')。编译器永远帮你,不会让你搞混。
常用类型速览:
| 类型 | 装什么 | 例子 |
|---|---|---|
Integer |
整数 | 42 |
Float |
小数 | 3.14 |
String |
文本 | 'hello' |
Boolean |
真/假 | true |
Variant |
动态类型(啥都能装) | var v := 1; v := 'one'; |
§ 3.2 条件与循环------程序会做决定了
program ControlFlow;
begin
var score := 87;
// if-else if-else
if score >= 90 then
WriteLn('优秀')
else if score >= 60 then
WriteLn('及格')
else
WriteLn('不及格');
// while:先判断再跑,可能一次都不跑
var i := 0;
while i < 3 do
begin
WriteLn('while: ' + IntToStr(i));
i := i + 1;
end;
// for:正着数、倒着数
for j := 1 to 5 do
WriteLn('for: ' + IntToStr(j));
for k := 5 downto 1 do
WriteLn('倒数: ' + IntToStr(k));
// repeat:先跑再判断,至少跑一次
var n := 0;
repeat
n := n + 1;
until n >= 3;
// case:多路分支
var day := 6;
case day of
1, 2, 3, 4, 5: WriteLn('工作日');
6, 7: WriteLn('周末');
end;
end.四种循环怎么选:
知道次数吗? ── yes ──► for ... to / downto
│
no
│
先判断还是先跑? ── 先判断 ──► while ... do
│
先跑
│
repeat ... until(至少跑一次)§ 3.3 函数------把活儿打包
program Functions;
// 函数:有返回值
function Add(a: Integer; b: Integer): Integer;
begin
result := a + b; // result 是内置的返回值变量
end;
// 多返回值(同时算商和余数!)
function DivMod(a: Integer; b: Integer): (Integer, Integer);
begin
result := (a div b, a mod b);
end;
// 过程:没有返回值
procedure Greet(name: String);
begin
WriteLn('Hi, ' + name + '!');
end;
var
q, r: Integer;
begin
Greet('Kylix');
WriteLn(Add(1, 2)); // 3
(q, r) := DivMod(17, 5); // 解构接收:q=3, r=2
WriteLn(IntToStr(q) + ' 余 ' + IntToStr(r));
end.多返回值 是 Kylix 相对传统 Pascal 的重要增强------不用再为"返回两个值"专门定义一个 Record 或者用 var 参数了。一行 (q, r) := DivMod(17, 5) 全部搞定。
匿名函数(lambda):
program LambdaDemo;
begin
var dbl := procedure(x: Integer)
begin
WriteLn(x * 2);
end;
dbl(21); // 42
end.§ 3.4 集合类型------数组、Map、Record、枚举
program Collections;
type
TPoint = record
X: Integer;
Y: Integer;
end;
TColor = (Red, Green, Blue);
var
fixed: array[0..4] of Integer; // 静态数组:定长
p: TPoint;
c: TColor;
begin
// 动态数组:自动扩容
var nums := [1, 2, 3];
WriteLn(Length(nums)); // 3
// 遍历数组
for n in nums do
WriteLn('n = ', n);
// Map:键值对
var m: map[String]Integer;
m['apple'] := 5;
m['pear'] := 3;
WriteLn(m['apple']); // 5
// Record:按字段访问
p.X := 3;
p.Y := 4;
WriteLn(p.X + p.Y); // 7
// 枚举
c := Green;
if c = Green then WriteLn('是绿色');
end.它们的关系一张图:
一个变量装一个值 一个变量装一堆值
┌──────────────┐ ┌────────────────────────────┐
│ Integer │ │ 数组:一排同类型(按下标取) │
│ Float │ │ Map:键值对(按名字取) │
│ String │ │ Record:不同类型打包(按字段取)│
│ Boolean │ │ 枚举:有限个命名常量 │
│ 枚举 / Record│ │ Variant:动态装箱(啥都行) │
└──────────────┘ └────────────────────────────┘§ 3.5 面向对象------类与继承
program OOP;
type
TAnimal = class
public
Name: String;
constructor Create(n: String);
procedure Speak; virtual;
end;
TDog = class(TAnimal)
public
procedure Speak; override;
end;
constructor TAnimal.Create(n: String);
begin
self.Name := n;
end;
procedure TAnimal.Speak;
begin
WriteLn(self.Name + ' makes a sound');
end;
procedure TDog.Speak;
begin
WriteLn(self.Name + ' says: Woof!');
end;
begin
var a := TAnimal.Create('Generic');
var d := TDog.Create('Rex');
a.Speak; // Generic makes a sound
d.Speak; // Rex says: Woof!
if a is TAnimal then WriteLn('a 是 TAnimal');
end.virtual / override 的玩法跟 C++ / C# / Java 几乎一样。is / as 类型判断和转换也都有。
Kylix 还有更多 OOP 能力:接口(interface)、泛型类 TStack<Integer>、属性(property)、inherited 调父类 ------完整教程见 examples/complete-tutorial/04_oop/(后面 § 9 会详细说)。
§ 3.6 异常处理------出错了别崩
program Exceptions;
begin
try
var x := 10 div 0; // 会抛异常
WriteLn(IntToStr(x));
except
on E: Exception do
WriteLn('捕获异常: ' + E.Message);
end;
end.try / except / finally 三件套与主流语言语义一致:except 接住错误,finally 无论成败都执行(善后清理)。
到这里,Kylix 的核心语法你已经掌握了------是不是比你想象的简单?
§ 4 标准库------站在巨人的肩膀上
Kylix 自带一套覆盖常见场景的标准库(uses 引入即用):
┌─────────────────────────── Kylix stdlib ───────────────────────────┐
│ sysutil 文件/目录:ReadFile, WriteFile, DirExists, CopyFile... │
│ jsonutil JSON 编解码:JsonEncode/Decode, JsonGetString... │
│ datetime 时间:Now, Today, FormatDate, AddDays, Year/Month/Day │
│ encoding 编码:Base64/Base64URL, Hex, CSV │
│ crypto 安全:SHA256, AES-256-CBC, HMAC, BCrypt │
│ jwt 令牌:JwtSign / JwtVerify(HS256,双端实现) │
│ cache 缓存:NewCache, Put/Get(带 TTL 过期) │
│ db 数据库:DbOpen, DbExec, DbQueryRows(SQLite) │
│ httpclient HTTP 客户端:HttpGet/Post/HttpPut + JSON 直解 │
│ net 网络:TCP/UDP/DNS + WebSocket(RFC 6455) │
│ regex 正则:RegexMatch / RegexReplace │
└────────────────────────────────────────────────────────────────────┘举个例子------读配置文件 + 解析 JSON:
program StdlibDemo;
uses sysutil, jsonutil;
begin
var content := sysutil.ReadFile('config.json');
var cfg := JsonDecodeMap(content);
WriteLn('name = ' + JsonGetString(cfg, 'name'));
end.全部 stdlib 函数清单 在 stdlib/klx/ 目录里------那是给 LSP 补全用的声明文件,也是最好的 API 速查表。在 IDE 里你只要打 Json 再按 Tab,补全菜单就把所有 jsonutil 函数列出来。
§ 5 写一个 Web 服务------KylixBoot
Kylix 内置一套注解驱动的 Web 框架 KylixBoot------风格类似 Spring Boot / FastAPI:写好类和方法,打上注解,路由/校验/文档全自动。
一个能登录的完整 Web 服务:
program MyApp;
uses boot, jwt;
[Entity('users')]
type
TCreateUser = class
[Required]
[Email]
Email: String;
[Required]
[MinLen(8)]
Password: String;
end;
[Controller('/api')]
type
TAuthController = class
[Post('/login')]
function Login(req: TRequest): TResponse;
begin
var token := JwtSign('my-secret', 'user42', 3600, nil);
result := BootText(200, token);
end;
[Get('/me')]
[Authenticated]
function Me(req: TRequest): TResponse;
begin
result := BootText(200, 'hello, kylix');
end;
[Post('/users')]
[Body(TCreateUser)]
function CreateUser(req: TRequest): TResponse;
begin
result := BootText(201, 'user created');
end;
end;
begin
BootRegisterJwtAuth('my-secret');
BootRun(8080);
end.编译运行:
kylix run myapp.klx立刻可以 HTTP 访问:
curl http://localhost:8080/api/me # 401 未登录
curl -X POST http://localhost:8080/api/login # 拿 token
curl -H 'Authorization: Bearer ' http://localhost:8080/api/me # 200 OK
curl -X POST http://localhost:8080/api/users \
-H 'Content-Type: application/json' \
-d '{"Email":"a@b.com","Password":"hunter22"}' # 201 创建注意,上面那个例子没有任何反射、没有任何运行时解析 ------所有路由、DI、Body 绑定、JWT 校验,都是编译器在编译时生成的。所以运行时极快,而且可以编译到 LLVM 后端跑在 KylixRT 里。
KylixBoot 注解全家福:
路由与文档 数据校验 依赖与安全
┌─────────────────┐ ┌──────────────────┐ ┌──────────────────┐
│ [Controller] │ │ [Required] │ │ [Service] │
│ [Get] [Post] │ │ [Email] │ │ [Component] │
│ [Put] [Delete] │ │ [Min] [Max] │ │ [Inject] │
│ [Body(TEntity)] │ │ [MinLen][MaxLen] │ │ [Authenticated] │
│ │ │ │ │ [Role('admin')] │
│ 自动生成 OpenAPI │ │ 自动 400 拦截 │ │ 自动 JWT 校验 │
└─────────────────┘ └──────────────────┘ └──────────────────┘
[Entity]/[Repository] 注解还能自动生成数据库 CRUD(ORM)自动文档------一条命令从注解生成 OpenAPI 3.1 文档:
kylix doc --openapi --title "My API" --api-version 0.1.0 myapp.klx > openapi.yaml下次写新接口不用手写文档,跑一遍 kylix doc 就出来了。
到这里,你已经会写一个能登录的 Web 服务了。整个过程不到 20 行代码------这是 KylixBoot 的核心承诺:用最少的代码,做正确的事。
§ 6 双后端------两条腿走路
前面 § 1 已经剧透过------Kylix 有两条后端,任你挑。这里多说两句为什么"双后端"重要:
┌────────────────────────────────────┐
│ kylix 编译器 │
│ (词法 → 语法 → AST → 代码生成) │
└──────────────┬─────────────────────┘
Go 后端 │ │ LLVM 后端
▼ ▼
┌────────────────────┐ ┌────────────────────┐
│ 生成 Go 源码 .go │ │ 生成 LLVM IR .ll │
│ → go build │ │ → llc → clang │
│ → 原生二进制 │ │ → 原生二进制 │
└────────────────────┘ └────────────────────┘
依赖:Go 工具链 依赖:LLVM 工具链
优势:编译极快(毫秒级) 优势:无 Go 也能跑
(KylixRT / 交叉编译)Go 后端 的优势是快------毫秒级编译,适合开发时反复改反复跑。LLVM 后端的优势是无 Go 依赖------你编译出来的二进制,不需要宿主机装 Go 就能跑,而且产物体积更小、启动更快。
kylix run --backend=auto 的探测逻辑:
kylix run hello.klx
│
▼
本机有 Go 吗?
│ │
有│ │没有
▼ ▼
Go 后端 LLVM 后端
(最快) 找到 llvm/ 工具链 → IR → llc → clang → 二进制 → 运行
甚至自带 `kylix test / kylix bench --backend=llvm`
(没有 Go 也能跑测试和基准)51 个官方教程 全部通过两种后端编译运行且输出一致------这是 Kylix 每次发版的回归基线。换句话说,你不用担心"走 Go 后端的程序能跑、走 LLVM 后端的程序不能跑"------两套都是生产可用的。
§ 7 自举------它能编译自己
第五十七篇把这件事讲得很透,这一节只点一下结论,不展开过程。
v0.6.9 起,Kylix 编译器本体是用 Kylix 自己写的。
具体来说:
第 1 代 (gen1) 第 2 代 (gen2) 第 3 代 (gen3)
host 编译器(Go) gen1 编译 src/*.klx gen2 编译 src/*.klx
编译 src/*.klx 产出 LLVM IR → llc → 二进制 同样流程
│ │ │
▼ ▼ ▼
产出 LLVM IR ──逐字节对比──► 产出 LLVM IR ──逐字节对比──► 产出 LLVM IR
└───── 三代输出完全一致 = 数学上的"不动点" ─────┘
关键:gen2 是纯原生二进制,构建它不需要 Go!这件事的意义不是"很酷",而是"Kylix 从此可以脱离 Go 工具链自我繁殖"------意味着:
-
• 未来 Kylix 可以运行在任何装好 LLVM 的机器上,包括嵌入式和裸机;
-
• 编译器的更新不再依赖 Go 生态,迭代速度完全由 Kylix 团队掌控;
-
• 极端情况下,你可以拿 Kylix 编译 Kylix 编译器,然后用这个 Kylix 编译器去编译别的程序,链条可以无限长。
调试这个故事花了几十轮,最有意思的两个 bug:
-
• for 循环计数器被误绑到全局变量槽(污染后死循环);
-
•
array of Boolean写入按 1 字节、读取按 8 字节算偏移(数据错乱)。
细节见 CHANGELOG 的 P4.10/P4.11。这些坑踩过之后,Kylix 的"自举"才真正立得住。
如果这件事让你兴奋(或者让你好奇),去看第五十七篇------那篇把每一轮修复都讲了。
§ 8 工具链全家福
Kylix 不止一个编译器,它是一个完整的开发生态:
┌─────────────┬──────────────────────────────────────────┐
│ 编译器 │ kylix(Go 编写,支持自举) │
│ 双后端 │ Go(默认)/ LLVM(--backend=llvm) │
│ 运行时 │ KylixRT(无 Go 环境一键编译运行) │
│ Web 框架 │ KylixBoot(注解驱动 + OpenAPI) │
│ IDE │ VS Code 插件 / JetBrains 插件(LSP4IJ) │
│ LSP │ 补全/跳转/重命名/格式化/悬停文档 │
│ 调试 │ DWARF + LLDB/GDB 逐行调试 │
│ 测试/基准 │ kylix test / kylix bench │
│ 文档生成 │ kylix doc --openapi(OpenAPI 3.1) │
│ 包管理 │ kylix pkg add (类似 Go modules) │
│ 交互式 │ kylix repl │
└─────────────┴──────────────────────────────────────────┘命令速查表:
kylix run # 编译并运行(auto 后端)
kylix build # 仅编译
kylix build --backend=llvm # 走 LLVM 后端
kylix build --target=linux-arm64 # 交叉编译
kylix build -g # 带 DWARF 调试符号
kylix test # 跑测试
kylix bench # 跑基准
kylix doc --openapi # 生成 OpenAPI 文档
kylix doctor # 环境体检
kylix lsp # 启 LSP(供 IDE)
kylix debug # 启 Delve 调试器
kylix pkg add # 加包
kylix repl # 交互式 REPL两个 IDE 插件都已经可用:
-
• VS Code :
vscode-ext/目录,语法高亮 + LSP 集成 + 25 个 Live Templates + 编译/运行命令; -
• JetBrains(IntelliJ IDEA / GoLand) :
jetbrains-plugin/目录,v0.6.7 起发布,TextMate 语法高亮 + LSP4IJ 桥 +.klx文件图标 + Kylix Run 配置。
两个插件都用同一套 LSP 后端 (kylix lsp),所以补全、跳转、定义、重命名、诊断的体验是一致的------你在 VS Code 写的代码,切换到 GoLand 不会有任何不一致。
§ 9 怎么开始------三步上手
如果你读到这里,心里在想"那我试试"------以下是三步路线图。
[1] 先跑起来
git clone https://github.com/astra-zhao/kylix.git
cd kylix
go build -o /usr/local/bin/kylix ./cmd/kylix/
kylix doctor # 体检
mkdir myapp && cd myapp
kylix new . # 创建项目脚手架(v0.3.0+)
kylix run # 跑 Hello, World!
[2] 系统学语法(1-2 周)
把 examples/complete-tutorial/ 下面 51 个教程按目录顺序刷
01_basics → 02_control_flow → 03_functions → 04_oop →
05_generics → ... → 21_variant
每个教程都可独立编译运行,跑不通先 kylix doctor
[3] 做点真东西(2-4 周)
文档路线:
├─ docs/GETTING_STARTED_CN.md (环境与工具链)
├─ docs/WEB_FRAMEWORK.md (KylixBoot 详解)
├─ docs/ORM_GUIDE.md (ORM 注解)
├─ docs/TEMPLATE_GUIDE.md (模板引擎)
├─ docs/llvm-backend.md (LLVM 后端内幕)
└─ docs/SELFHOSTING_DEV_GUIDE.md (自举开发指南)如果你想看 51 个完整教程 ,它们都在仓库的 examples/complete-tutorial/ 目录下,每个都是独立可编译运行的 .klx 文件------你可以挑感兴趣的看,不必从头刷到尾。
官网 :kylix.top------有交互式文档、实时可运行示例和完整功能展示。
§ 10 承上启下------Kylix 接下来要往哪里去
前面五十七篇把"v0.6.9 之前的 Kylix"讲得很透。这一篇我们换个角度,看看"v0.6.9 之后的 Kylix":
v0.6.x 段 ──► v0.7.0 ──► v0.8.0 ──► v0.9.0 ──► v1.0.0
自举闭环 Web 页面 跨平台 生态 生产级
(已达成) + 模板 Linux/ Marketplace KylixBoot+
+ 表单 Windows + 完整示例 Web 框架+
+ Cookie ARM64 + KylixBoot 生态
+ 文件上传 端到端示例按 ROADMAP,接下来四个版本要做的事是:
| 版本 | 主线 | 给你带来的体验 |
|---|---|---|
| v0.7.0 | Web 页面开发 | 模板引擎 + 表单 + Cookie + 文件上传;能写完整 Web 应用(页面 + API) |
| v0.8.0 | 跨平台分发 | Linux/Windows/ARM64 原生二进制,KylixRT 真正落地 |
| v0.9.0 | 生态建设 | 包注册中心 Marketplace 上线、官方 KylixBoot 端到端示例、文档站完善 |
| v1.0.0 | 生产级承诺 | KylixBoot + Web + 生态全部到位;1.0.0 命名空间已经从 v0.6.9 段让出 |
如果你今天开始学,到 v1.0.0 发布时,你可能已经能跟着版本更新写一两个真实的 Web 应用------这是 Kylix 最想看到的事。
§ 11 收尾:第五十八篇,留给小白的一句话
第五十八篇讲到这里,我们做到了三件事:
-
- 讲清楚了 Kylix 是什么------一门现代 Pascal,可以编译到原生二进制,有 Go 和 LLVM 两条后端。
-
- 展示了它能做什么------从 Hello World 到完整 Web 服务,从文件 IO 到 JWT 认证,从 ORM 到 OpenAPI 文档。
-
- 给了三步上手路线------跑起来 / 系统学语法 / 做真东西。
如果你读完之后想动手,记住这一句话:
打开终端,跑
git clone https://github.com/astra-zhao/kylix.git,然后kylix doctor。
kylix doctor 会告诉你环境是不是 OK,哪里要补------这是最稳妥的"第一步"。
至于后面的事(更深的功能、更多的语法、更复杂的 Web 应用),下一篇文章再说------或者你自己去 examples/complete-tutorial/ 翻,或者翻第五十六篇 / 第五十七篇看前面的硬核拆解。
第五十八篇,先写到这里。
参考链接与审阅依据:
-
• GitHub 主仓库:https://github.com/astra-zhao/kylix
-
• 官方小白教程:
docs/TUTORIAL_FOR_BEGINNERS_CN.md(本文与该文档同步,但更偏"故事化") -
• Web 框架详解:
docs/WEB_FRAMEWORK.md -
• KylixBoot 注解体系:
docs/WEB_FRAMEWORK.md末尾的"支持的注解一览" -
• 完整教程:
examples/complete-tutorial/(51 个.klx文件) -
• 自举开发指南:
docs/SELFHOSTING_DEV_GUIDE.md -
• LLVM 后端内幕:
docs/llvm-backend.md -
• 路线图:
ROADMAP.md -
• CHANGELOG(版本演进):
CHANGELOG.md -
• 官网(交互式文档 + 实时示例):https://kylix.top
-
• 本文写作时间:2026-09-05
-
• 对应 v0.6.9(已发布,tag
v0.6.9指向ca66821a20a08c516d553466aec80f9bb77ec047) -
• 本文前置阅读:无(小白从这一篇开始)
-
• 本文后续文章:第五十九篇以后,继续讲 Web 框架 / KylixRT / Marketplace / v1.0.0