kite

Imported from channyeintun/kite-lang (skills/kite/SKILL.md). Install upstream with npx skills add channyeintun/kite-lang --skill kite. Copyright stays with the author.

Kite

Garbage-collected, WasmGC-first. Go's (T, error) made enforceable, Rust's traits without lifetimes, newline-terminated statements, no truthiness, no implicit conversion. You have not seen this language before. Anything carried over from Rust, Go or TypeScript is a guess, and most of the guesses below are wrong.

1. Compile it. Do not guess.

The compiler is one command away. Being wrong first time is fine; handing over unchecked Kite is not.

# in this repo
./target/release/kitec check file.kite

# anywhere, nothing installed
npx --yes --package=@kite-lang/compiler-wasm kitec check file.kite

--package= is load-bearing: npx @kite-lang/compiler-wasm kitec check f.kite passes kitec as the subcommand and fails.

Every diagnostic carries a code, and the code explains itself. Run kitec --explain E0302 for any code you see — it prints the rule and its rationale, not a restatement of the message. Also kitec run, kitec test (fn test_* and every doc-comment example, in the entry file only — a used module's tests are invisible to it), kitec fmt, kitec fix, kitec build --emit wasm --out dist. Write, check, fix, check again.

--explain, test and fix belong to the native kitec — this repo's build, or npm install --save-dev @kite-lang/cli. The WebAssembly kitec that npx fetches has run, check, build, fmt and doc only.

For a web page a project reaches for vite-plugin-kite rather than kitec: <script type="module" src="/src/main.kite"> in the project's own index.html is the entire wiring. It hands the compiler the .kite files beside the entry keyed by basename, so keep such a project's modules one file each.

2. Hello, world

fn main() {
    io.print("hello, world")
}

io is a compiler builtin reached by dotted path, not a module: use std/io is E0400, and io.println does not exist.

3. The shape of a real program

use std/errors

struct Item {
    name: str
    pence: int
}

impl Display for Item {
    fn show(self) -> str {
        return "\(self.name) at \(self.pence)p"
    }
}

enum Payment {
    Cash
    Card(last4: str)
}

fn describe(p: Payment) -> str {
    return match p {
        Cash => "cash",
        Card(last4) => "card ending \(last4)",
    }
}

fn lookup(stock: [Item], name: str) -> (Item, error) {
    let hit = find(stock, |it| it.name == name)
    if hit == nil {
        return _, errors.new("no item called \(name)")
    }
    return hit, nil
}

fn total(stock: [Item], wanted: [str]) -> (int, error) {
    var sum = 0
    for name in wanted {
        let (item, err) = lookup(stock, name)
        check errors.wrap(err, "totalling \(name)")
        sum = sum + item.pence
    }
    return sum, nil
}

fn main() {
    let stock = [
        Item{ name: "bolt", pence: 30 },
        Item{ name: "nut", pence: 12 },
    ]
    for it in stock {
        io.print(it)
    }
    io.print(describe(Card(last4: "4242")))

    let (sum, err) = total(stock, ["bolt", "nut", "washer"])
    if err != nil {
        io.error(err.message())
        return
    }
    io.print("total \(sum)p")
}

4. What you will get wrong

A page of your own has to start the program

--out leaves your index.html alone, but nothing in it runs Kite until you say so. Without these four lines the page is blank and the console is empty — the same silent failure as a missing mount point, one step later.

<ul id="list"></ul>
<script type="module">
  import { instantiate, resident } from "./app.js";
  const exports = await instantiate("./app.wasm");
  resident(exports);      // keeps listeners and tasks alive after main returns
  exports.main();
</script>

resident is not optional for a program that listens: without it, everything main attached is collected the moment main returns.

5. The reference pages

Read the page before writing much of the thing it covers; they are checked against the compiler and they say where SPECIFICATION.md is wrong.

Three worked projects sit in the repository's examples/, and they are the three shapes usually asked for: page/ — hand-written index.html with --emit wasm built into that same directory; vite-starter/ — vite-plugin-kite, one file per module; inventory/ — a module directory whose two files share a namespace. The rest of that directory is single-file demos of one feature each.

When a page does not answer it, kitec check a five-line file. That is faster than reading, and it is the authority — the compiler wins over every document here.