MatrixAges/zxc

Última actividad de origen registrada: 13 de octubre de 2026 a las 12:36

Catálogo de SkillsMP actualizado: 5 de noviembre de 2026 a las 19:57

skills recopiladas: 2

Estrellas en GitHub: 0
Forks en GitHub: 0

Instalar con un asistente de IA

Copia este prompt en el asistente de IA que estés usando.

Follow https://skillsmp.com/skill-install/prompt.md to install Agent Skills from https://github.com/MatrixAges/zxc.

README del repositorio

Archivo de origen del README: README.md

Leer el README original

Mostrar README completo

# <img src="images/logo.svg" alt="" height="28" align="absmiddle" /> zxc **A programming language for AI-written business systems.** Write logic in **ZX** (TypeScript-like), wire it together in **RX** (XML), and compile to a native executable. [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE) ![Experimental](https://img.shields.io/badge/status-experimental-orange.svg) ![Zig 0.17.0](https://img.shields.io/badge/zig-0.17.0-f7a41d.svg) [CLI](packages/cli/README.md) · [RX Reference](packages/compiler/src/rx/README.md) · [Compiler](packages/compiler/README.md) · [Feature Reference](docs/2026-10-05/功能参考索引.md) · [Design](docs/zxc_deisgn_doc.md) ## Example A checkout flow. **RX** is the map — every step, and what flows between them, in one file: ```xml  <Module> <Call fn="subtotal" in={$in.items} /> <Call fn="discount" in={{subtotal: $ctx.subtotal, coupon: $in.coupon}} /> <Call fn="shipping" in={{amount: $ctx.discount, region: $in.region}} /> <Call fn="total" in={{amount: $ctx.discount, shipping: $ctx.shipping}} /> <Return value={$ctx.total} /> </Module> ``` **ZX** holds the logic — each step is one typed function in its own file: ```typescript // shipping.zx export type Input = { amount: u64 region: string } export type Output = u64 export default function (in: Input): Output { return match { in.amount >= 10000 => 0, in.region == "remote" => 1500, _ => 600 } } ``` `Call` no longer accepts `out`. Each non-void call automatically exposes its result as `$ctx.<filename>`: `discount.zx` becomes `$ctx.discount`. The name comes from the target filename without its suffix; `Call` has no `name` attribute. RX attributes assemble data and simple expressions; function calls and collection logic belong in ZX. The [complete checkout example](docs/2026-10-05/首页示例) includes every referenced function. From that directory, build and run: ```sh zxc build checkout.rx --out build/checkout ./build/checkout '{"items":[{"price":4500,"quantity":2},{"price":3000,"quantity":1}],"coupon":"SAVE10","region":"remote"}' # {"payable":10800,"shipping":0} ``` To change the shipping rule, an AI only needs `shipping.zx` — `checkout.rx` already tells it what goes in and what comes out. The compiler infers types across every `Call`, so a mismatched edit fails at build time, not in production. ## Why zxc - **Structure you can read** — RX files are the call graph and data flow. No digging through function bodies. - **Boundaries the compiler enforces** — typed `Input` / `Output` per unit, ownership checks, and a dependency graph that must be acyclic. - **Small, local changes** — change a rule in one `.zx` file; the RX wiring stays untouched. - **Native output** — ZX compiles to Zig; release packages embed the Zig toolchain, and `-no-zig` packages use the Zig named by `ZXC_ZIG`. ## How It Works ```mermaid flowchart LR RX[".rx modules"] --> Graph["Dependency graph<br/>acyclic check"] ZX[".zx functions"] --> Check["Type & ownership<br/>check"] Graph --> Infer["Type inference<br/>across Call"] Check --> Infer Infer --> IR["IR"] --> Zig["Zig"] --> Bin["Native executable"] ``` Every `.rx` and `.zx` file in the entry's closure is loaded, checked and type-inferred together, then lowered to Zig. `zxc` embeds the official Zig toolchain, so ordinary native builds need no separate Zig installation. Contract verification requires an external SMT solver. ## Compose Modules A module is just another unit. `Call.module` replaces the former `Call.service` attribute. Call it with `module` and branch on its result: ```xml  <Module> <Call module="checkout" in={$in} /> <Switch on={$ctx.checkout.shipping}> <Case value={0}> <Return value={{payable: $ctx.checkout.payable, free_shipping: true}} /> </Case> </Switch> <Return value={{payable: $ctx.checkout.payable, free_shipping: false}} /> </Module> ``` Functions form modules, modules form larger modules, and every level follows the same rules. Cycles are rejected anywhere in the graph. ## Contracts Add `requires` / `ensures` to a ZX function and prove it with an SMT solver: ```typescript // bounded_discount.zx export type Input = { price: u64 discount: u64 } export type Output = u64 export default function (in: Input): Output requires (in.discount <= in.price) ensures (out <= in.price) { return in.price - in.discount } ``` ```sh zxc verify bounded_discount.zx --solver z3 --out bounded_discount.smt2 # verified: entry paths satisfy supported safety obligations and reached contracts ``` The command assumes Z3 is on `PATH`; otherwise pass its executable path to `--solver`. Remove the `requires` and verification fails with a concrete counterexample: the subtraction can underflow. Verification covers fixed-width integers, booleans, static objects and branches. ## RX Tags | Tag | Purpose | | ------------ | ---------------------------------------------------------------- | | `<Module>` | Root of an `.rx` file; the module is identified by its file path | | `<Call>` | Call a ZX function (`fn`) or another RX module (`module`) | | `<Return>` | Return a value from the module | | `<Task>` | Group steps; optional `out={...}` exposes `$ctx.task.<name>` | | `<Switch>` | Branch on a value | | `<Case>` | A branch of `Switch` matching one value | | `<Default>` | The fallback branch of `Switch` | | `<Import>` | Declare a module dependency without calling it | | `<Parallel>` | Run supported pure Call/Task branches concurrently | | `<Emit>` | Reserved event syntax; execution is not implemented | | `<Store>` | Define application-lifetime shared memory in `*.store.rx` | | `<Object>` | A state object inside `Store` | | `<Field>` | A typed field with an initial value inside `Object` | | `<Gateway>` | Expose modules over HTTP in `*.gateway.rx` | | `<Group>` | A route prefix inside `Gateway` | | `<Route>` | Map a path and method to a module | See the [RX Reference](packages/compiler/src/rx/README.md) for attributes and nesting rules. ## ZX Language | Area | What ZX offers | | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------- | | Units | One default-exported function per file, with typed `Input` and `Output` | | Types | `u8`–`u64`, `i32`, `i64`, `f32`, `f64`, `bool`, `string`, objects, enums, `T?` optionals, `T[]` lists, `[A, B]` tuples | | Bindings | `const` only, destructuring and spread; no semicolons | | Control flow | `if`, `switch`, `match` and `loop` expressions | | Collections | `loop`, array [`map` / `filter` / `reduce` / `every` / `some`](packages/skills/rx/编码约定.md#集合工具); explicit immutable tuple results | | Errors | `const [err, res] = try expression`; finite error sets and checked success narrowing | | Concurrency | `async expression`, `await task`, `cancel task` and `parallel({name: () => expression})` | | Ownership | No pointers and no `clone`; the compiler decides how values move | | Imports | Relative paths, `@/` project paths and packages; imports must be acyclic | | Standard lib | Encoding, crypto, paths, URLs, compression, target info, files, processes and HTTP; see the [module index](docs/2026-10-05/功能参考索引.md) | | Native code | Explicitly declared `zig:` and `c:` interfaces | | Contracts | `requires` / `ensures`, proven with an SMT solver | See [typed errors](docs/2026-10-06/类型化错误参考.md) and [ZX async and parallel](docs/2026-10-06/ZX异步参考.md) for examples. A task handle can be consumed at most once by `await` or `cancel`. `cancel` requests cooperative cancellation and waits for the task to finish. Task execution requires an I/O-capable host. ## CLI | Command | Description | | ------------------------------------------ | ------------------------------------------------------ | | `zxc build <entry> --out <path>` | Build a native executable from an `.rx` or `.zx` entry | | `zxc build <entry> --watch` | Rebuild whenever sources or dependencies change | | `zxc build <entry> --watch --run` | Restart the native app after successful rebuilds | | `zxc build <entry> --mode lib --out <dir>` | Publish a library for zxc and Zig consumers | | `zxc build ... --target --cpu --optimize` | Cross-compile and tune the output | | `zxc build ... --asm <file>` | Also write the generated assembly | | `zxc <file.zx> --out <file.zig>` | Emit Zig source only | | `zxc fmt <source>` | Format ZX, RX or package configuration | | `zxc verify <file.zx> --solver <z3>` | Prove contracts and safety obligations | | `zxc fpga <file.zx> --out <file.sv>` | Generate a SystemVerilog kernel | | `zxc check-rx --entry <file.rx>` | Check RX structure and call targets | | `zxc pkg install` | Resolve and install dependencies from `pkg.yaml` | See the [CLI docs](packages/cli/README.md) for every option. ## License [MIT](LICENSE)

Cargando el README del repositorio…

Skills en este repositorio

clasificación pendiente

skill

ocupación

descripción

actualizado

compiler-performance

sin clasificar

诊断和优化编译器、代码生成器、自举与增量构建的耗时及内存成本。适用于编译慢、生成代码膨胀、复制或 arena 热点、缓存命中仍慢、并行化退化；提供可直接运行的测量、采样、产物对比和生成代码统计脚本。不用于仅修语法错误或普通应用性能调优。

Idioma del texto original: chino

2026-10-13

lib-conversion

sin clasificar

将其他语言的库迁移为 ZX 库，建立语义规则、依赖单元、独立审查、集中构建和新旧实现行为对照。用于实际跨语言库迁移，不用于仅封装原生库或普通 ZX 应用开发。

Idioma del texto original: chino

2026-10-03

Mostrando 2 de 2 skills recopiladas.