{"id":35133037,"url":"https://github.com/murphsicles/zeta","last_synced_at":"2026-05-10T06:04:36.393Z","repository":{"id":324084915,"uuid":"1095884973","full_name":"murphsicles/zeta","owner":"murphsicles","description":"The final systems language","archived":false,"fork":false,"pushed_at":"2026-04-23T22:27:32.000Z","size":80280,"stargazers_count":50,"open_issues_count":1,"forks_count":4,"subscribers_count":5,"default_branch":"main","last_synced_at":"2026-04-24T00:24:13.825Z","etag":null,"topics":["code","compiler","programming"],"latest_commit_sha":null,"homepage":"https://z-lang.org","language":"PowerShell","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/murphsicles.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-11-13T16:39:09.000Z","updated_at":"2026-04-17T05:50:09.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/murphsicles/zeta","commit_stats":null,"previous_names":["murphsicles/zeta"],"tags_count":92,"template":false,"template_full_name":null,"purl":"pkg:github/murphsicles/zeta","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/murphsicles%2Fzeta","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/murphsicles%2Fzeta/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/murphsicles%2Fzeta/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/murphsicles%2Fzeta/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/murphsicles","download_url":"https://codeload.github.com/murphsicles/zeta/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/murphsicles%2Fzeta/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":32458237,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-29T22:27:22.272Z","status":"online","status_checked_at":"2026-04-30T02:00:05.929Z","response_time":57,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["code","compiler","programming"],"created_at":"2025-12-28T07:06:53.631Z","updated_at":"2026-05-08T05:56:31.395Z","avatar_url":"https://github.com/murphsicles.png","language":"PowerShell","funding_links":[],"categories":[],"sub_categories":[],"readme":"# [\u003cimg alt=\"Zeta Logo\" width=\"24px\" src=\"https://z-lang.org/assets/images/z72.png\" /\u003e](https://z-lang.org) Zeta v1.0.2 — CI hardened, cross-platform pipeline\n\n[\u003cimg alt=\"Zeta Logo\" width=\"128px\" src=\"https://z-lang.org/assets/images/z128.png\" /\u003e](https://z-lang.org) [![Latest Release](https://img.shields.io/github/v/release/murphsicles/zeta)](https://github.com/murphsicles/zeta/releases) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)\n\n**Zeta is a systems programming language bootstrapped in Rust, targeting LLVM.** v1.0.2 ships 35 commits since v1.0.1: Windows LLVM support, macOS ARM64 CI, Node 24 action upgrades, and updated pre-built binaries.\n\nBuilt from the algebraic foundations of Stepanov's *Elements of Programming* — first principles, zero bloat, maximum efficiency.\n\n\u003e \"Weaponized minimalism. Surgical violence against complexity.\" — Roy Murphy\n\n## 🚀 v1.0.2 — CI Infrastructure\n\nCross-platform CI: Windows LLVM via choco, macOS ARM64 + x86-64, self-hosted Galaxy runner. Pre-built binaries updated for all platforms.\n\n## ✨ Features\n\n### Core Language\n\n**Strong static typing** with type inference:\n```zeta\nfn add(x: i64, y: i64) -\u003e i64 {\n    return x + y;\n}\n\nfn infer() {\n    let x = 42;       // inferred i64\n    let y = 3.14;     // inferred f64\n    let b = true;     // inferred bool\n}\n```\n\n**First-class functions and closures:**\n```zeta\nfn apply(f: (i64) -\u003e i64, x: i64) -\u003e i64 {\n    return f(x);\n}\n\nfn make_adder(n: i64) -\u003e (i64) -\u003e i64 {\n    return fn(x: i64) -\u003e i64 { x + n };\n}\n```\n\n**Algebraic data types** (structs, enums, tuples):\n```zeta\nstruct Point {\n    x: i64,\n    y: i64,\n}\n\nenum Option\u003cT\u003e {\n    Some(T),\n    None,\n}\n\nfn origin() -\u003e Point {\n    return Point { x: 0, y: 0 };\n}\n```\n\n**Generics and specialization:**\n```zeta\nfn identity\u003cT\u003e(x: T) -\u003e T {\n    return x;\n}\n\nfn max\u003cT: Ord\u003e(a: T, b: T) -\u003e T {\n    if a \u003e= b { return a; }\n    return b;\n}\n```\n\n### Memory Model\n\n**Stack-priority allocation** with optional heap:\n```zeta\nfn stack_example() {\n    let arr: [i64; 5] = [1, 2, 3, 4, 5];  // stack allocated\n    let sum = arr[0] + arr[1];\n}\n\nfn heap_example() {\n    let vec = Vec::new();                    // heap allocated\n    vec.push(42);\n    vec.push(100);\n}\n```\n\n**Ownership and borrowing:**\n```zeta\nfn borrow_example() {\n    let data = Vec::new();\n    data.push(1);\n    \n    let len = data.len();      // immutable borrow\n    let first = data[0];       // immutable borrow\n    \n    data.push(2);              // mutable borrow (unique)\n}\n```\n\n### Standard Library (Tier 1)\n\n| Module | Description | Status |\n|--------|-------------|--------|\n| `std::mem` | Memory operations, size_of, align_of | ✅ |\n| `std::ptr` | Raw pointer operations | ✅ |\n| `std::cmp` | Ordering, comparison traits | ✅ |\n| `std::hash` | Hashing infrastructure | ✅ |\n| `std::iter` | Iterator traits and adapters | ✅ |\n| `std::vec` | Vector type with dynamic sizing | ✅ |\n| `std::string` | UTF-8 string type | ✅ |\n| `std::option` | Option enum | ✅ |\n| `std::result` | Result enum | ✅ |\n| `std::collections` | Collection types | ✅ |\n| `std::simd` | SIMD vector operations | ✅ |\n| `std::thread` | Threading primitives | ✅ |\n| `std::sync` | Synchronization primitives | ✅ |\n| `std::io` | Input/Output | ✅ |\n| `std::fs` | Filesystem operations | ✅ |\n| `std::net` | Networking | ✅ |\n| `std::time` | Time and duration | ✅ |\n| `std::path` | Path manipulation | ✅ |\n| `std::process` | Process management | ✅ |\n| `std::char` | Character operations | ✅ |\n| `std::marker` | Marker types | ✅ |\n| `std::ffi` | Foreign function interface | ✅ |\n\n### Compiler Pipeline\n\n```\nZeta Source (.z)\n    │\n    ▼ Lexer → Parser\n    │\n    ▼ AST → HIR (High-level IR)\n    │\n    ▼ Resolver (imports, generics, specialization)\n    │\n    ▼ THIR (Typed HIR)\n    │\n    ▼ MIR (Mid-level IR — CFG with basic blocks)\n    │\n    ▼ LLVM IR → Machine Code\n```\n\n### Compile-Time Evaluation (CTFE)\n\nExecute Zeta code at compile time:\n```zeta\nconst FACTORIAL_10: i64 = comptime {\n    fn fact(n: i64) -\u003e i64 {\n        if n \u003c= 1 { return 1; }\n        return n * fact(n - 1);\n    }\n    fact(10)\n};\n// FACTORIAL_10 = 3628800 at runtime\n```\n\n### SIMD Vector Types\n\n```zeta\nfn simd_add(a: [i64; 4], b: [i64; 4]) -\u003e [i64; 4] {\n    return a + b;  // auto-vectorized where possible\n}\n```\n\n### Murphy's Sieve — Prime Sieving\n\nCompetition-ready wheel-optimized prime counting:\n```zeta\nfn murphy_sieve(limit: i64) -\u003e i64 {\n    if limit \u003c 2 { return 0; }\n    \n    // 30030-wheel: 80.8% reduction in checks\n    const WHEEL: i64 = 30030;  // 2×3×5×7×11×13\n    \n    let mut count: i64 = 1;  // 2 is prime\n    let mut i: i64 = 3;\n    \n    while i \u003c= limit {\n        if is_coprime_to_wheel(i) {\n            if is_prime(i) { count += 1; }\n        }\n        i += 2;\n    }\n    return count;\n}\n```\n\n## 📁 Project Layout\n\n```\nzeta/\n├── bin/              # Pre-built compiler binary\n│   └── zetac         # v1.0.1 Linux x86-64\n├── src/              # Self-hosted Zeta sources (51+ files)\n│   ├── main.z        # Entry point\n│   ├── frontend/     # Lexer, parser, AST\n│   ├── middle/       # Resolver, MIR, type system\n│   ├── backend/      # Code generation\n│   └── runtime/      # Runtime library\n├── build/stubs/      # Generated stdlib stubs (bootstrap)\n├── tests/            # Zeta test suite (44+ categories)\n├── examples/         # Example programs\n├── docs/             # Documentation\n└── README.md         # This file\n```\n\n## 🔧 Getting Started\n\n```bash\n# Clone the repository\ngit clone https://github.com/murphsicles/zeta.git\ncd zeta\n\n# Compile a Zeta source file (Linux)\n./bin/zetac src/main.z -o output\n\n# Or compile an example\n./bin/zetac examples/hello.z -o hello\n./hello\n\n# Run tests\n./bin/zetac tests/language/basic_tests.z\n```\n\n\n\n## 📝 Examples\n\n### Hello, Zeta\n```zeta\nfn main() -\u003e i64 {\n    println_str(\"Hello, Zeta!\");\n    return 0;\n}\n```\n\n### Fibonacci\n```zeta\nfn fib(n: i64) -\u003e i64 {\n    if n \u003c= 1 { return n; }\n    return fib(n - 1) + fib(n - 2);\n}\n\nfn main() -\u003e i64 {\n    let result = fib(20);\n    println_i64(result);  // Output: 6765\n    return 0;\n}\n```\n\n### Working with Vectors\n```zeta\nfn main() -\u003e i64 {\n    let v = Vec::new();\n    v.push(10);\n    v.push(20);\n    v.push(30);\n    \n    let sum: i64 = v[0] + v[1] + v[2];\n    println_i64(sum);  // Output: 60\n    return 0;\n}\n```\n\n## 🏗️ Architecture\n\nThe compiler pipeline processes Zeta source through multiple IR tiers:\n\n1. **Lexing \u0026 Parsing** — Tokenizes and builds AST from `.z` files\n2. **HIR** — High-level IR: resolves imports, identities, and macros\n3. **Resolver** — Type resolution, generics, specialization, concept checking\n4. **THIR** — Typed HIR: fully resolved types and identities\n5. **MIR** — Mid-level IR: control flow graph with basic blocks\n6. **LLVM Codegen** — Lowers MIR to LLVM IR, runs optimization passes\n7. **Machine Code** — LLVM produces native executable\n\n## 🔗 Links\n\n- **GitHub**: https://github.com/murphsicles/zeta\n- **Website**: https://z-lang.org\n- **License**: MIT\n\n---\n\n*Zeta v1.0.1 — The language that will outlive its bootstrap.*\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmurphsicles%2Fzeta","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fmurphsicles%2Fzeta","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmurphsicles%2Fzeta/lists"}