AILANG look for Claude Code: the AILANG version beside the prompt hint, compiler-flavoured spinner words (Unifying…, Inferring effects…), and /ailang for a…

Quick start package for using AILANG with Claude Code and OpenAI Codex.
AILANG is a deterministic programming language designed for AI code synthesis and reasoning.
Install the AILANG CLI before installing either agent integration:
curl -fsSL https://ailang.sunholo.com/install.sh | bash
ailang --version
The plugins invoke the local ailang executable, so it must be available on PATH.
# Step 1: Add the marketplace
/plugin marketplace add sunholo-data/ailang_bootstrap
# Step 2: Install the plugin
/plugin install ailang@sunholo-data/ailang_bootstrap
Or clone and add locally:
git clone https://github.com/sunholo-data/ailang_bootstrap
/plugin marketplace add ./ailang_bootstrap
/plugin install ailang@ailang_bootstrap
Codex requires Node.js 18 or newer for the local MCP server:
node --version
codex plugin marketplace add sunholo-data/ailang_bootstrap --ref stable
codex plugin add ailang@ailang-marketplace
codex plugin list
Start a new Codex session after installation. Alternatively, add the marketplace with the CLI, then install AILANG through /plugins or the Codex desktop Plugins directory.
Codex loads the shared skills and five local MCP tools: ailang_prompt, ailang_check, ailang_run, ailang_builtins, and ailang_eval.
Download a platform-specific release from GitHub Releases:
| Platform | Architecture | Asset |
|---|---|---|
| macOS | Apple Silicon | darwin.arm64.ailang-bootstrap.tar.gz |
| macOS | Intel | darwin.x64.ailang-bootstrap.tar.gz |
| Linux | x64 | linux.x64.ailang-bootstrap.tar.gz |
| Windows | x64 | win32.x64.ailang-bootstrap.zip |
Each release includes the AILANG binary pre-bundled.
| Skill | Purpose |
|---|---|
| ailang | Write, run, and develop with AILANG |
| ailang-inbox | Cross-agent messaging with semantic search, deduplication, and GitHub sync |
| Command | Purpose |
|---|---|
/ailang-prompt | Load syntax teaching prompt (do this first!) |
/ailang-run <file> | Run an AILANG program |
/ailang-check <file> | Type-check without running |
/ailang-new <name> [template] | Create new program from template |
/ailang-repl | Start interactive REPL |
/ailang-builtins [search] | List builtin functions |
/ailang-editor <editor> | Install syntax highlighting |
| Hook | Event | Purpose | |||
|---|---|---|---|---|---|
session_start.sh | SessionStart | Inbox check + brain context | |||
brain_session.sh | SessionStart | Inject relevant brain knowledge | |||
git_guard.sh | PreToolUse(Bash) | Block destructive git ops | |||
microrag_context.sh | PreToolUse(Edit\ | Write\ | Read\ | MultiEdit) | JIT μRAG knowledge injection — surfaces AILANG syntax/builtin docs at tool-call time |
microrag_lint.sh | PostToolUse(Edit\ | Write\ | MultiEdit) | First-use builtin nudge for *.ail edits | |
brain_resolution.sh | PostToolUse(Bash) | Capture command resolutions | |||
observatory_hook.sh | All events | OTEL telemetry for AILANG Observatory |
Disable μRAG: export AILANG_MICRORAG_ENABLED=0. Requires ailang and jq on PATH; degrades silently if either is missing.
μRAG brain corpus auto-bootstrap: install.sh runs ailang micro-rag init && ailang micro-rag bootstrap --scope user --no-embed after the binary lands. This populates the brain DB at ~/.ailang/state/brain.db with the ailang-syntax (~50 frames) and ailang-builtins (~280 frames) namespaces using only resources embedded in the binary — no source repo required. Works on Windows / minimal Docker images / anywhere awk and python3 are absent.
Re-run manually after install.sh to upgrade the corpus to embedding-backed retrieval (requires Ollama):
ailang micro-rag bootstrap --scope user # add embeddings on top of SimHash/FTS
ailang micro-rag bootstrap --scope user --reset # full rebuild (use after AILANG version bump)
A live pane that shows what you're writing as AILANG sees it. After every Edit/Write of a .ail file it runs ailang iface and ailang check and draws the module's functions, their types and effect rows (pure or !{IO,FS}), plus any type errors — keeping the last good signatures on screen beside a broken edit. The status line carries a one-line summary.
/plugin install ailang-lens@ailang-marketplace
/reload-plugins
/ail-lens [file.ail] # open the pane, or analyse any file into it
Mods are an early-access Claude Code feature; where they are not enabled the plugin installs but does nothing. Requires ailang on PATH.
1. Local stdio MCP (auto-installed by this plugin) — wraps the local AILANG CLI for actually running/checking code:
ailang_check - Type-check filesailang_run - Run programsailang_prompt - Get teaching prompt (embedded copy)ailang_builtins - List builtinsailang_eval - Evaluate an expression in the non-interactive REPL2. Remote HTTP MCP at mcp.ailang.sunholo.com — version-locked live docs, stdlib, examples, design docs, benchmarks. Available to any agent harness that supports remote MCP (Claude Desktop, Cursor, Cline, Continue, Claude Code).
{
"mcpServers": {
"ailang-docs": {
"url": "https://mcp.ailang.sunholo.com/mcp/",
"transport": "streamable-http"
}
}
}
Tools include prompt_get, stdlib_modules, stdlib_search, examples_for_concept, limitations_list, effects_catalog, and submit_feedback (for filing AILANG bugs from inside an agent session). Use these to avoid stale embedded knowledge — the snapshot is rebuilt and redeployed on every AILANG release.
See docs/guides/agent-mcp for the full tool catalog.
Once installed, you can:
# CRITICAL: Load syntax before writing code
ailang prompt
# Run AILANG code
ailang run --caps IO --entry main program.ail
# Start interactive REPL
ailang repl
# Type-check without running
ailang check program.ail
module myproject/hello
export func main() -> () ! {IO} {
print("Hello, AILANG!")
}
Run with:
ailang run --caps IO --entry main hello.ail
func - NOT fn, function, or deflet x = 1; let y = 2; x + y=> - NOT : or ->print expects string - Use print(show(42)) for numbersailang_bootstrap/
├── .claude-plugin/
│ ├── plugin.json # Claude Code plugin manifest
│ └── marketplace.json # Skills marketplace
├── .codex-plugin/
│ └── plugin.json # Codex plugin manifest
├── .mcp.json # Codex MCP configuration
├── .claude/commands/ # Slash commands
│ ├── ailang-run.md
│ ├── ailang-check.md
│ ├── ailang-new.md
│ └── ...
├── mcp-server/ # MCP server for AILANG tools
│ ├── server.js
│ └── package.json
├── skills/
│ ├── ailang/ # Main AILANG skill
│ │ ├── SKILL.md
│ │ └── resources/
│ └── ailang-inbox/ # Agent messaging skill
│ └── SKILL.md
├── bin/ # AILANG binary (in releases)
└── .github/workflows/
└── release.yml # Platform-specific release builds
MIT License - see LICENSE
hooks/register.tsx 82 lines1import type { EngineInterface, Register } from 'claude-code'
2
3const PANE = 'ailang-brand'
4
5// Present / past pairs; the engine samples its own word per turn, and we map
6// it onto this list by hash so one turn keeps one word.
7const WORDS: readonly (readonly [string, string])[] = [
8 ['Unifying', 'Unified'],
9 ['Inferring effects', 'Inferred effects'],
10 ['Elaborating', 'Elaborated'],
11 ['Monomorphizing', 'Monomorphized'],
12 ['Pattern-matching', 'Pattern-matched'],
13 ['Checking contracts', 'Checked contracts'],
14 ['Lowering to bytecode', 'Lowered to bytecode'],
15 ['Folding', 'Folded'],
16 ['Normalizing', 'Normalized'],
17 ['Resolving modules', 'Resolved modules'],
18]
19
20/** Pure: a stable index for a word. */
21export function pick(word: string): readonly [string, string] {
22 let h = 0
23 for (const c of word) h = (h * 31 + c.charCodeAt(0)) >>> 0
24 return WORDS[h % WORDS.length]!
25}
26
27let version = ''
28
29async function readVersion($: EngineInterface): Promise<void> {
30 try {
31 const run = await $.process.run(['ailang', '--version'], { timeoutMs: 5_000 })
32 version = run.stdout.match(/AILANG (v[0-9][^\s-]*)/)?.[1] ?? ''
33 } catch {
34 version = ''
35 }
36}
37
38export const register: Register = on => {
39 version = ''
40
41 on('session.start', async ($, e, next) => {
42 await $.command.register({ name: 'ailang', description: 'AILANG: logo, version and the mods you have' })
43 await readVersion($)
44 return next(e)
45 })
46
47 on('command.run', { command: 'ailang' }, async $ => {
48 await $.ui.open({ id: PANE, title: 'AILANG' })
49 return { text: `AILANG ${version || '(ailang not on PATH)'}` }
50 })
51
52 // Beside "? for shortcuts" under the prompt.
53 on('ui.render', { component: 'PromptHint' }, ($, e, next) =>
54 next({ ...e, props: { ...e.props, tail: `${e.props.tail ?? ''} λ AILANG${version ? ` ${version}` : ''}` } }))
55
56 on('ui.render', { component: 'Spinner' }, ($, e, next) =>
57 e.props.message ? next(e) : next({ ...e, props: { ...e.props, word: pick(e.props.word)[0] } }))
58
59 on('ui.render', { component: 'TurnDuration' }, ($, e, next) =>
60 next({ ...e, props: { ...e.props, word: pick(e.props.word)[1] } }))
61
62 on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
63 const elements = $.ui.resolve(e)
64 const { Box, Text } = elements
65 // Image is on the terminal and desktop tables; the terminal shows the
66 // picture where it speaks the kitty graphics protocol, the alt text elsewhere.
67 const logo = 'Image' in elements
68 ? <elements.Image
69 source={{ png: (await $.fs.read(`${$.plugin.root}/assets/ailang-logo.png`, { as: 'bytes' })).base64 }}
70 columns={24} rows={11} alt="λ AILANG" />
71 : <Text bold color="cyan">λ</Text>
72 return (
73 <Box flexDirection="column" alignItems="center">
74 {logo}
75 <Text bold>{`AILANG ${version}`}</Text>
76 <Text dimColor>The AI-first programming language</Text>
77 <Text dimColor>/ail-lens · /ail-inbox · ailang prompt</Text>
78 </Box>
79 )
80 })
81}
82