kukicha

Kukicha

A readable language that ships as a single binary, brewed from what Go leaves on the table. Focused on DevOps type operations, without reverting to a DSL.

kukicha.org | Cookbook | Quick Reference | Tutorials | Stdlib Reference

Coming from Python or shell? Start with the Cookbook;task-indexed recipes ("how do I read JSON?", "how do I run a subprocess?") with Python and bash equivalents.

A taste of Kukicha

Triage open GitHub issues with an LLM. Fetch, classify in parallel, keep the urgent ones, sort, print.

# triage.kuki — classify open issues with Claude, flag the urgent ones
import "stdlib/color"
import "stdlib/concurrent"
import "stdlib/fetch"
import "stdlib/json" as jsonpkg
import "stdlib/llm/chat"
import "stdlib/llm/safe"
import "stdlib/log"
import "stdlib/slice"
import "stdlib/sort"
import "stdlib/table"

type Issue
    number int
    title string
    body string

enum Severity
    Unknown = 0
    Trivial = 1
    Minor = 2
    Normal = 3
    Urgent = 4
    OnFire = 5

type Verdict
    number int
    severity Severity
    kind string # bug | feature | docs | question
    summary string

function classify(issue: Issue) Verdict
    # title and body are attacker-controlled — wrap them so a crafted issue
    # can't override the system prompt
    title := safe.Wrap("title", safe.SanitizeLine(issue.title, 200))
    body := safe.Wrap("body", safe.Truncate(issue.body, 4000))

    reply := chat.New("anthropic:claude-sonnet-4-6")
        |> chat.JSONMode()
        |> chat.System(`{safe.UntrustedPreamble}
Classify GitHub issues. Reply JSON: {severity:1-5, kind, summary}`)
        |> chat.Ask("{title}\n\n{body}") onerr return {}

    verdict := jsonpkg.ParseString of Verdict from reply onerr return {}
    verdict.number = issue.number
    return verdict

function main()
    url := "https://api.github.com/repos/golang/go/issues?per_page=20"
    issues := fetch.GetJson of list of Issue from url onerr
        log.Error("github fetch failed", "url", url, "err", error)
        return

    triaged := issues
        |> concurrent.MapWithLimit(4, classify)
        |> slice.Reject(v => v.kind equals "question")

    urgent := triaged
        |> slice.Filter(v => v.severity >= Severity.Urgent)
        |> sort.By((a, b) => a.severity > b.severity)

    log.Info("triaged {len(triaged)}, urgent {len(urgent)}")

    if len(urgent) equals 0
        print(color.Dim("Nothing urgent — go enjoy your tea."))
        return

    print(color.Bold("Needs attention:"))
    t := table.New(list of string{"sev", "kind", "#", "summary"})
    for v in urgent
        label := if v.severity equals Severity.OnFire then color.BrightRed("P{v.severity}") else color.Yellow("P{v.severity}")
        t = t |> table.AddRow(list of string{label, color.Dim(v.kind), "#{v.number}", v.summary})
    t |> table.PrintWithStyle(table.Style.Box)

Read it top-to-bottom: wrap the untrusted issue text, classify four at a time, drop the questions, keep the urgent ones, sort, print a colored table. English operators (and, equals, isnt, if … then … else), pipes that flow left-to-right, named severities via enum, and a friendly stdlib (fetch.GetJson, concurrent.MapWithLimit, safe.Wrap, table.PrintWithStyle). onerr keeps error handling out of the flow.

Why Kukicha?

• Readable
• Ships as one file. kukicha build produces a static binary, copy it to a server and run.
• Batteries included. fetch, shell, files, db, llm, mcp, concurrent, crypto, html and 30+ more.
• Safe defaults. Compile-time checks for SQL injection, XSS, shell injection, path traversal, and SSRF. Errors are values handled with onerr.
• No lock-in. kukicha brew file.kuki converts any file back to standard Go.

Quickstart

Grab a pre-built binary from GitHub Releases (Linux, macOS, Windows). Or, if you already have Go 1.26+ installed:

go install github.com/kukichalang/kukicha/cmd/kukicha@v0.16.0
mkdir myapp && cd myapp
kukicha init

kukicha init initializes a Go module (if go.mod is absent), extracts the stdlib, downloads dependencies, and writes an AGENTS.md language reference. Add .kukicha/ to your .gitignore.

Create hello.kuki:

function main()
    name := "World"
    print("Hello, {name}!")

kukicha run hello.kuki

Commands

Already use Go?

Kukicha is a near-superset of Go. Most Go compiles as-is — operators, pointers, if err != nil, anonymous funcs, slices, generics, interfaces. A few Go constructs (range, case/default, struct {} type literals, chan T, goto, parenthesized const ( ... )) have Kukicha replacements and won't parse in their Go form; see docs/kukicha-quick-reference.md for the full list. Kukicha forms desugar to standard Go before compilation, so mix and match freely, drop them when they don't help, and run kukicha-blend on existing Go to see suggestions.

kukicha-blend main.go            # see what idioms apply
kukicha-blend --diff ./pkg/      # preview changes
kukicha-blend --apply main.go    # convert in place
kukicha brew main.kuki           # and anytime, back to Go

The translation table:

Editor support

• VS Code: https://github.com/kukichalang/vscode-kukicha
• Zed: https://github.com/kukichalang/zed-kukicha
• Other: make install-lsp and point your editor at kukicha-lsp

Documentation

• Quick Reference: Go-to-Kukicha translation table
• Agent Workflow Tutorial: prompt AI, review, ship
• Beginner Tutorial: first program, variables, functions
• AWS Deployment Starter: first deployment helper from AWS console concepts
• Production Patterns: databases, auth, retry
• FAQ | Contributing

Version: 0.16.0 | License: MIT

[!NOTE] Portions of this codebase were written with AI assistance. Commits are reviewed by human maintainers before merge.