Skip to content

CHANGELOG.md

Latest commit

 

History

History
138 lines (101 loc) · 37.5 KB

CHANGELOG.md

File metadata and controls

138 lines (101 loc) · 37.5 KB
Raw

📝 Changelog — God Code

All notable changes to the God Code engine are recorded here, that the generations may remember.

Unreleased

Added

  • 🕊️ The October 2026 machine interfaces. God Code's --json shapes are frozen under dated schemas, so an agent can parse every output without guessing. New godcode explain scroll.god [--json]: a static reading of any scroll that runs nothing, reporting the tongue, the rites and their declared intents, the declared names, the reveals, the seals (including ANCHOR seals on a chain), the summoned verbs, the CONSULT questions, the imports, and the permission manifest, in warm plain words for humans and one JSON document for agents. New godcode ledger verify --json: the covenant chain and anchor chain attestation as one JSON document. New godcode schema [name]: list or print the four dated schemas (check, run, explain, ledger-verify), shipped inside the installed package and resolvable through importlib.resources. The agent bridge gains two tools, explain and get_schema (nine tools in all). The full contract, exit codes, and the stability promise (additive fields may appear, required fields never change meaning, breaking changes ship under a new dated schema) live in docs/machine-interfaces.md. New tests in tests/test_machine_interfaces.py; repo AGENTS.md documents the read-before-you-run workflow.
  • 🕊️ God Code speaks Igbo and Nigerian Pidgin. The third and fourth tongues. A scroll that opens with # tongue: ig writes its keywords in Igbo (BIDO OKIKE for BEGIN CREATION, GOSI for REVEAL, Ọ BỤRỤ and MGBE AHỤ for IF and THEN, NWAA and JIDE for TRY and CATCH, and the rest), and one that opens with # tongue: pg (or the standard code pcm) writes them in Nigerian Pidgin (OYA KREASHON, TALK and BE for DECLARE and AS, SHOW for REVEAL, DEN for THEN, HOLD for CATCH, COMOT for ASCEND). Igbo words work with or without their dotted vowels (DỊKA and DIKA both speak), and Pidgin keeps the words it shares with English (IF, TRY, AND, RETURN). Two-word phrases now join whenever both words sit side by side on one line, even when one is an English keyword or a plain name, so FINISH IF closes an IF in Pidgin and Ọ BỤRỤ opens one in Igbo; Setswana and isiZulu closers behave exactly as before. The mappings live in godcode/tongues.py; the playground's lite engine knows both tongues (Igbo in its undotted spelling), the language server offers their completions, hover docs, and block snippets (hover now reads dotted words), and the VS Code extension paints their keywords and ships four starter snippets (ndewo, oburu, howfar, ifden). Documented in docs/TONGUES.md (both word tables and honest first-edition notes), docs/LANGUAGE_REFERENCE.md §1, repo AGENTS.md, the site landing card, and two new lessons on the learn page. New examples examples/first_blessing_ig.god and examples/first_blessing_pg.god, also offered as playground samples. 25 new tests in tests/test_tongues_igbo_pidgin.py; the VS Code snippet count in tests/test_lsp_tongues.py rises from 27 to 31
  • 🕊️ The playground runs the real engine. The playground at site/playground/ no longer leans on a JavaScript re-telling of the language: it loads this repository's own interpreter into the browser through Pyodide (Python compiled to WebAssembly) in a Web Worker, so every creation speaks with the engine's full voice. The commons, dates, IMPORT of registry scrolls (blessings, json-tools, hashes and the rest, laid out as if installed), the Spirit's CONSULT, intent discernment, ANCHOR, the tongues, and the engine's exact error messages, rite traces, and hints all work in the browser as they do in godcode run --sandbox. Before this, the in-browser interpreter failed or answered differently on eleven of the twenty-three examples that run cleanly under the sandbox. Every run is sandboxed by the engine's strict policy (no files, no network, a wall-clock grant and a step budget), and the page holds a hard twelve-second deadline that releases a stuck worker and wakes a fresh one. The real parser and linter now counsel live as you type: gutter marks on the troubled lines and a clickable list of diagnostics beneath the editor (PARSE_ERROR, GC001 unused names, GC002 undefined names, and the rest). The JavaScript interpreter stays as the lite engine: it answers instantly while the real engine wakes (the page then answers again in full voice), and stands in offline or where WebAssembly is missing; a badge says which engine is speaking. Once the engine wakes, the samples gain nine scrolls read straight from examples/. Your last creation is kept in your browser's local storage, as the cookies page already promised, and existing #c= share links and the Demos page links keep working. New godcode/webrun.py (run_creation, check_creation, returning the same JSON shapes as run --json and check --json), site/playground/engine-worker.js, and site/playground/build_engine.py, which bundles the engine into site/playground/engine.json. 18 new tests in tests/test_webrun.py, including one that fails whenever the bundle is stale and one that boots the bundle in an isolated interpreter with nothing but its own files, as the browser does
  • 🕊️ The spec, layer by layer: the static meaning layer. The third layer of the Direction's specification is written and test-kept: docs/spec/static-meaning.md states 32 numbered rules (ST-1 to ST-32) covering the scope model (the creation block sharing the top-level scope, IF/WHILE bodies in the current scope, FOR in one child scope with the loop variable living only there, rite names bound in the enclosing scope with bodies in a child scope, closures captured by reference), names (case-sensitive, tongue words canonicalized before checking, one shared namespace), declaration (the update idiom as the language's way to change a variable, re-declaration counselled but running with the last binding winning), the Symbol Rule's classic face (unbound names read as bare words, use-before-declare, always-truthy Symbols, FOR refusing a mere Symbol), rite calls (arity checked at call time, unbound calls answered gently), the linter's six counsels GC001 through GC006 (with the promise that findings advise but never stop a run), imports and the always-available contract name, and the gentle did-you-mean counsel with printed source lines. Every rule is kept honest by a test: 48 new tests in tests/test_spec_static_semantics.py name the rule they guard. docs/spec/00-overview.md marks the static meaning layer written, and the old docs/LANGUAGE_SPEC.md now points to the layered spec for the static rules too
  • 🕊️ The spec, layer by layer: the syntax layer. The second layer of the Direction's specification is written and test-kept: docs/spec/syntax.md states 39 numbered rules (SX-1 to SX-39) covering the shape of a scroll (one creation per scroll, phrases staying on one line, unclosed and stray closers answered with counsel), lines and statements (blank lines ignored, two statements sharing a line, empty scrolls), declarations (single values, value lists, the soft-worded DECLARE INTENT), the small decrees (REVEAL, SEAL, TESTIFY, BLESS, PROPHESY and friends), conditionals and loops (block and one-line forms, the kept legacy open FOR, BREAK/CONTINUE never crossing a rite boundary), the always-a-block TRY, rites (parameters, bodies, RETURN, direct calls), IMPORT, the full expression precedence order, and string interpolation's brace rules. Every rule is kept honest by a test: 88 new tests in tests/test_spec_syntax.py name the rule they guard, so if the engine's parsing ever drifts from the documented word, the failing test names the broken promise. docs/spec/00-overview.md marks the syntax layer written, and the old docs/LANGUAGE_SPEC.md now points to the layered spec for the syntax rules too
  • 🕊️ The spec, layer by layer: the lexical layer. The Direction's first phase has begun. The specification is being rewritten as numbered, test-kept layers in docs/spec/, starting with how source text becomes tokens: docs/spec/lexical.md states 29 numbered rules (LX-1 to LX-29) covering lines and line breaks, comments, keywords, names, numbers, strings and their escapes, operators and punctuation, tongue lexing, and positions. Every rule is kept honest by a test: 39 new tests in tests/test_spec_lexical.py name the rule they guard, so if the engine's lexing ever drifts from the documented word, the failing test names the broken promise. docs/spec/00-overview.md names the six layers and the promise underneath them all: a scroll that runs today must run tomorrow. The old docs/LANGUAGE_SPEC.md now points to the layered spec for the lexical rules, and the README's Learn section links the new folder
  • 🕊️ How God Code is kept. New GOVERNANCE.md writes down what was settled with the founder: there is no company behind the language, and none is needed. The language is Apache 2.0 open source, and Alakanani Itireleng is its keeper of the vision, holding the brand, the direction, the home (GitHub organisation, site, registry, Discord), and the money when it comes. Anyone may propose, and the keeper gives the final verdict. The lines the language will not cross are named in plain words: no wallets and no real chain calls (education and simulated seals only), the backward-compatibility promise held (see docs/VERSIONING.md), and no unproven claims. Linked from the README and CONTRIBUTING, and kept honest by 7 new tests in tests/test_governance.py (the document exists, links every founding document, names the keeper, and follows the house style: no em dashes, no version labels in prose). The governance documents move from "What is next" to "Just landed" in ROADMAP.md
  • 🕊️ REPEAT joins the commons. A twenty-sixth everyday builtin in godcode/stdlib_commons.py: REPEAT(word, n) sings a word n times over (REPEAT("Pula! ", 3) → "Pula! Pula! Pula! "), accepting words, numbers, and truths the way the other word tools do, and answering misuse gently (REPEAT("grace", 0 - 1) is refused with "counts from zero upward"; fractions and lists carry their own counsel). Pure computation, so it needs no sandbox grant and behaves the same under godcode run --sandbox. Documented in docs/LANGUAGE_REFERENCE.md §13 (the standard-library table now counts thirty-nine rites), repo AGENTS.md, the language server's hover docs and completions, and the VS Code grammar. 6 new tests in tests/test_stdlib_commons.py
  • 🕊️ Published performance benchmarks. The benchmark suite (bench/bench.py: seven workloads covering lexing and parsing, deep rite recursion, a tight counting loop, string interpolation, list work, JSON round trips through the real json-tools registry scroll, and ANCHOR chain sealing) now carries fresh numbers recorded on current main. bench/RESULTS.md replaces the 2026-09-25 feature-branch recording with today's medians: a 20,000-iteration counting loop in 140 ms (about 143k iterations per second), 2,000 interpolated REVEALs in 28 ms (about 70k strings per second), lexing and parsing 319.5 KB of God Code at about 1.4 MB per second, and the heaviest workload, naive fib(22), in 0.86 s. The method (deterministic generated scrolls, godcode check validation before timing, warmup then the median of timed runs, a fresh interpreter per run, the recorded machine) is documented in bench/README.md, and tests/test_bench.py keeps the suite green. The performance-benchmarks bullet moves from "What is next" to "Just landed" in ROADMAP.md
  • 🕊️ God Code speaks isiZulu. The second tongue: a scroll that opens with the pragma # tongue: zu may write the language's keywords in isiZulu (QALA INDALO for BEGIN CREATION, VEZA for REVEAL, UMA/KHONA for IF/THEN, ZAMA/BAMBA for TRY/CATCH, and thirty more), while English keywords keep working beside them for a gentle crossover. Two-word closers are recognised on one line: QEDA UMA closes an IF, QEDA ZAMA closes a TRY. The mapping lives in godcode/tongues.py beside the Setswana table, and because every tool parses through the one doorway, tongues.parse_source, run, check, lint, fmt, test, the debugger, the language server, and the agent bridge all speak isiZulu with no per-tool changes. Editor block snippets now travel with each tongue's own table, so the language server offers isiZulu snippets (QALA INDALO … QEDA INDALO) from the same place it offers Setswana ones, and a future tongue brings its snippets with it. The VS Code extension paints isiZulu keywords in their colors and ships two starter snippets (sawubona for an isiZulu creation block, uma for an isiZulu conditional). The named tools (SHA256, UPPER, RANGE) keep their names in every tongue by design, and godcode fmt renders the canonical English. Documented in docs/TONGUES.md (full isiZulu word table, honest first-edition notes), docs/LANGUAGE_REFERENCE.md §1, repo AGENTS.md, the site learn page ("Speak isiZulu" lesson), the site landing card, and the in-browser playground (pragma-detected, with a "Sawubona (isiZulu)" sample). New example examples/first_blessing_zu.god. 26 new tests in tests/test_tongues_zulu.py (pragma detection, full keyword coverage beside Setswana, alias and compound lexing, full isiZulu runs, rites, mixed scrolls, interpolation, fmt canonicalization, sandbox acceptance, language-server completions/hover/snippets, VS Code grammar and runnable snippets, the shipped example); the VS Code snippet count assertion in tests/test_lsp_tongues.py rises from 25 to 27 for the two new starters.
  • 🕊️ The commons: everyday tools. Twenty-five new always-present builtins in a fourth stdlib pillar (godcode/stdlib_commons.py), the everyday work a language needs: words (TRIM, REPLACE, STARTS_WITH, ENDS_WITH, SUBSTRING, CONTAINS, COUNT), lists (SORT, MIN_OF, MAX_OF, SUM_OF, FIRST, LAST, UNIQUE, INDEX_OF), maps (KEYS, VALUES, HAS_KEY, MERGE), and numbers (ABS, ROUND, FLOOR, CEIL, SQRT, POW). All pure computation, so they need no sandbox grant and behave the same under godcode run --sandbox; every misuse is answered with a gentle error (SORT refuses mixed kinds, MIN_OF an empty gathering, SQRT a negative). SORT and MERGE return new values and never mutate. ROUND rounds half away from zero (ROUND(2.5) → 3). Documented in docs/LANGUAGE_REFERENCE.md §13 (the standard-library table now counts thirty-eight rites in four parts, with a runnable example), repo AGENTS.md gotchas (including the {{ rule for a literal brace), the language server's hover docs and completions, the VS Code extension (highlighting plus four new snippets), a new "Everyday tools" lesson on the site learn page, and a new example examples/commons_demo.god. 46 new tests in tests/test_stdlib_commons.py
  • 🕊️ The editors speak Setswana. The language server reads the # tongue: pragma of the open scroll: with tn it offers the tongue's keywords beside the English ones (SENOLA (REVEAL), FEDISA FA (ENDIF)), plus block snippets that unfold in Setswana. Hovering a tongue word shows the English keyword's own documentation (SENOLA explains itself as REVEAL; QALA TLHOLEGO opens the BEGIN CREATION notes). The VS Code extension paints Setswana keywords in their colors (always on, so mixed scrolls glow in both tongues), gains the English TRY/CATCH/ENDTRY/BREAK/CONTINUE it was missing, and ships two starter snippets (qala for a Setswana creation block, fa for a Setswana conditional). Documented in docs/TONGUES.md, repo AGENTS.md, and the site learn page. 22 new tests in tests/test_lsp_tongues.py
  • 🕊️ God Code speaks Setswana. The first tongue: a scroll that opens with the pragma # tongue: tn may write the language's keywords in Setswana (QALA TLHOLEGO for BEGIN CREATION, SENOLA for REVEAL, FA/GONE for IF/THEN, LEKA/TSHWARA for TRY/CATCH, and thirty more), while English keywords keep working beside them for a gentle crossover. Two-word closers are recognised on one line: FEDISA FA closes an IF, FEDISA LEKA closes a TRY. The mapping lives in new godcode/tongues.py; the lexer honours the pragma (or an explicit tongue=), and every tool parses through one new doorway, tongues.parse_source, so run, check, lint, fmt, test, the debugger, the language server, and the agent bridge all speak the tongue with no per-tool changes. The named tools (SHA256, UPPER, RANGE) keep their names in every tongue by design, and godcode fmt renders the canonical English. Documented in new docs/TONGUES.md (word table, honest first-edition notes, how to propose a tongue), docs/LANGUAGE_REFERENCE.md §1, repo AGENTS.md, the site learn page ("Speak Setswana" lesson), and the in-browser playground (pragma-detected, with a "Dumela (Setswana)" sample). New example examples/first_blessing_tn.god. 21 new tests in tests/test_tongues.py (pragma detection, alias and compound lexing, full Setswana runs, mixed scrolls, interpolation, fmt canonicalization, lint/check/sandbox acceptance)
  • 🕊️ A scrollhouse of hashes. Four new always-present builtins, pure and sandbox-safe (they touch no files and no network, so they need no grant): SHA256(x) takes a word, number, or truth and returns its SHA-256 fingerprint as 64 hex characters; HMAC(key, message) seals a message under a key with HMAC-SHA-256; BASE64_ENCODE(x) and BASE64_DECODE(s) veil and unveil words, with a gentle error when a veil is ill-formed. New godcode/stdlib_hashes.py follows the vault/times pattern. The hashes scroll is published to the local registry (checksums recorded on publish, verified on install) with friendly rites written in God Code itself: FINGERPRINT, SIGN, VERIFY_SIGNATURE, VEIL, UNVEIL. Documented in docs/LANGUAGE_REFERENCE.md §13 (the standard-library table now counts fourteen rites in three parts, with a runnable example), repo AGENTS.md gotchas, the language server's hover docs and completions, the VS Code extension (highlighting plus "Hash a word" and "Seal with HMAC" snippets), and a new "Seal a word with a hash" lesson on the site learn page. The cryptography bullet moves from "What is next" to "Just landed" in ROADMAP.md. 29 new tests in tests/test_stdlib_hashes.py (standard public vectors, refusal of lists/maps, sandbox strictness, and the scroll's rites end to end)
  • 🕊️ The playground keeps pace. The in-browser interpreter at site/playground/index.html now speaks the language's newest words: TRY … CATCH … ENDTRY (sheltering fragile works, binding the plain error message to ERROR or a name of your choosing, RETURN and ASCEND still passing straight through, errors in the CATCH body rising outward as they should) and BREAK / CONTINUE for loops (rejected outside a loop at parse time, and never allowed to cross a rite boundary, exactly like the engine). A new "Sheltered by Grace (TRY/CATCH)" sample boots the palette at seven creations; the site learn page gained a "Shelter a fragile work" lesson; new example examples/try_catch_demo.god runs green through run, check, and fmt
  • 🕊️ Remote scroll registry. The registry now reaches past the local registry/ directory to the public catalog at api.getgodcode.com (overridable with GODCODE_REGISTRY_URL; the test suite aims it at a fake server, never the live one). New RemoteRegistry HTTPS client (godcode/remote_registry.py, stdlib only): search, info, versioned fetch_code, and token-authenticated publish_scroll. CLI: godcode scroll search <query>, godcode scroll install <name> falling back to remote when the local index has no answer (--remote prefers the remote), godcode scroll publish <dir> --remote (refuses with a clear error when GODCODE_PUBLISH_TOKEN is missing), godcode scroll uninstall <name> [--version], and godcode scroll update [name] to the newest known version. Manifests gain an optional dependencies field (dependencies = "json-tools >= 1.0.0, dates"): installs resolve the tree recursively (local first, then remote), reuse the existing requirement machinery, refuse dependency cycles with a clear error, and record the exact resolved tree in install.json. Publish records sha256 checksums of every published file in index.json (backfilled for the eight shipped scrolls); install verifies them and refuses a copy that changed after publish. New docs/VERSIONING.md (semver scheme, backward-compatibility promise, deprecation process); docs/scroll-registry.md updated; the registry bullet moved from "What is next" to "Just landed" in ROADMAP.md
  • 🕊️ TRY / CATCH error handling — TRY … CATCH … ENDTRY shelters a fragile work in the language itself: if a runtime error rises anywhere inside the TRY block (including inside rites called from it), execution jumps to the CATCH block with the error's plain message bound to ERROR, or to a name of your choosing with CATCH name. No error means the CATCH is skipped. Only GodRuntimeError is caught: parse/lexer errors still fail before running, RETURN still returns from its rite and ASCEND still ends the run in peace (neither is ever caught), sandbox violations rise straight through, TRY blocks nest, and an error inside a CATCH rises outward normally. Works unchanged under --sandbox. New TryStmt AST node; godcode fmt round-trips the construct; godcode lint walks it (the implicit error binding is never flagged); new ### TRY … CATCH … ENDTRY in docs/LANGUAGE_REFERENCE.md §5
  • 🕊️ Call traces for uncaught errors — when a runtime error escapes every TRY, the CLI prints the rite call stack beneath the gentle error, oldest call first (Called by outer at line 11, …, (most recent call last)); errors at the top level show no trace section. run --json gains a trace array of {rite, line} on the error object; every existing field is unchanged. The interpreter keeps a lightweight call stack pushed in _call_rite (independent of the debugger's frames, which work as before); the trace is snapshotted onto the error as it first rises, before the stack unwinds. New ### Call traces for uncaught errors in docs/LANGUAGE_REFERENCE.md §19
  • 🕊️ The debugger — godcode debug scroll.god walks a creation line by line: break <line> pauses, next steps over, step steps in, out steps out, print <name> beholds a value, locals and stack survey the watch. Pressing Enter repeats the last step. The same engine speaks the Debug Adapter Protocol: godcode dap serves VS Code over stdio, and the extension debugs the open scroll on F5 with breakpoints, step buttons, a variables panel, call stack, and Debug Console. New godcode/debugger.py (DebugSession), godcode/debug_cli.py, godcode/dap.py; hooks in the interpreter are dormant unless a session is attached, so plain runs are untouched. See docs/DEBUGGER.md
  • 🕊️ Gentler errors — a misspelled name is now answered with a suggestion instead of a bare rejection: There is no rite named 'BLESSIN'. The heavens do not know it. Did you mean 'BLESSING'? Suggestions cover unknown rites (including builtins like UPPER), BREATHE LIFE INTO / BLESS / ANOINT targets, RESHAPE targets, and missing map keys. godcode run, godcode run --sandbox, godcode check, and godcode fmt now print the offending source line beneath the message, with a caret marking the column when one is known. The suggestion also rides along in the message field of check --json / run --json diagnostics. New godcode.errors.suggest_similar / with_suggestion / format_error helpers; new ### The Spirit corrects gently in docs/LANGUAGE_REFERENCE.md §19; a matching lesson on the site learn page; agent gotcha in repo AGENTS.md

Changed

  • House-style pass: user-facing engine strings no longer carry em dashes between sentences (the endless-cycle guard, sandbox refusals, testimony failures, the --help description, and the editor hover notes all speak with full stops now); docs that quoted the old messages (docs/sandbox.md, docs/LANGUAGE_SPEC.md, docs/LANGUAGE_REFERENCE.md) and the playground's endless-cycle message follow suit

  • ENVIRONMENT.set_existing (the RESHAPE path) now suggests the nearest visible name

  • 🕊️ Setswana speaks truer words. Two first-edition Setswana words are corrected and one crosses over at last, all verified against Matumo's Setswana-English-Setswana Dictionary (Botswana Book Centre, 1993), which the founder placed in the language's hands: AS is JAAKA (like, similar to; the dictionary knows jaka only as a verb meaning "to sojourn"), and THEN is TLOGA (then, thereupon; gone is not a Setswana word at all). NOT crosses over as GA, the dictionary's negative form, so KE GA weighs IS NOT and GA alone denies, in Setswana scrolls. The second tongue keeps full parity: isiZulu gains HHAYI for NOT (first edition; native speakers are its rightful editors). The mapping moves in godcode/tongues.py, and every surface that carried the old words crosses over with it: docs/TONGUES.md (with an honest dated correction note), docs/LANGUAGE_REFERENCE.md, the site learn page and the in-browser playground (alias map and the "Dumela (Setswana)" sample), the VS Code grammar and snippets, examples/first_blessing_tn.god, and the tongue test suites (including a new GA run test). Scrolls written with JAKA or GONE under # tongue: tn should cross over to JAAKA and TLOGA. ELSE, FOR, WHILE, ENDFOR, and ENDWHILE stay English for now, awaiting blessed words

  • LANGUAGE_REFERENCE §19's error table updated to the messages the engine actually speaks

  • 💬 String interpolation — {expr} inside a double-quoted string breathes the expression's revealed value into the words: "grace upon {name}", "{loaves} loaves feed {loaves * 1000}", "shouted: {UPPER(name)}". Any expression may dwell between the braces, including nested interpolated strings. {{ and }} write a plain brace; a lone } stays as it is. A brace that is never closed, or braces with nothing between them, raise a gentle parse error that names the line. Works in the sandbox, in rites, and in godcode fmt (which round-trips interpolated strings untouched). New example examples/interpolation_demo.god; new ### Breathing values into strings in docs/LANGUAGE_REFERENCE.md §3; a "Speak with feeling" lesson on the site learn page; and the in-browser playground now runs interpolation too, with a new "Speaking with Feeling" sample

  • Agent gotcha — repo AGENTS.md notes the interpolation rule so agents generating God Code use it correctly

  • New InterpolatedString AST node (godcode/ast.py); the parser builds it from any STRING token containing { or }} (plain strings are untouched Literals); the interpreter renders each part with the same stringify as REVEAL. Note: a string that previously contained a literal { now needs {{ — the pre-launch language is still young enough for this to be safe

  • 🕊️ Setswana speaks its own BEGIN. The first tongue's word for BEGIN is SIMOLOLA (to begin, to start), corrected from QALA, which is isiZulu, where it rightly remains. The mapping moves in godcode/tongues.py (the Setswana editor snippets follow), and every surface that carried the old word crosses over with it: docs/TONGUES.md (with an honest dated correction note), docs/LANGUAGE_REFERENCE.md, docs/agentics.md, repo AGENTS.md, the site landing card, the learn page, the in-browser playground (alias map and the "Dumela (Setswana)" sample), the VS Code grammar and snippets, examples/first_blessing_tn.god, and the tongue test suites. Verified against Mistry's An Introduction to Spoken Setswana (Peace Corps), where simolola is "begin, start" and qala never appears

2026-09-25: A doorway for newcomers

"Come, and let us build together."

A doorway for newcomers — the first step into God Code is now one command.

Added

  • 🕊️ godcode new <name> — raises a fresh project from the dust: a warm starter scroll (main.god, a blessing that runs pure and carries a DECLARE INTENT the Spirit blesses), a test scroll (test_main.god, discovered by godcode test), a registry-ready scroll.toml manifest (godcode scroll publish . accepts it as-is), and a small README with the next steps. Names are gently validated (lowercase, digits, hyphens); occupied ground is refused with counsel; --json reports the raised files for agents; --path chooses the parent directory and --author signs the manifest. New godcode/scaffold.py; the raised project is verified green by run, check, lint, fmt, and test in the test suite. Mentioned in docs/LANGUAGE_REFERENCE.md §1, repo AGENTS.md, and the site learn page

Changed

  • Packaging metadata updated (godcode/__init__.py, pyproject.toml); the LSP serverInfo reports the package version instead of a hard-coded one

2026-09-22: Intent & Chain

"The language is spoken. The engine is built. Now the Spirit is awake."

Intent & Chain — the language learns to ask why, and to remember the answer on a chain. See docs/INTENT_AND_CHAIN.md for the founder's telling.

Added

  • 🕊️ Declared intent — DECLARE INTENT "words..." ON rite_name names a rite's purpose in plain words; at invocation the Spirit discerns the rite's actual intent and blesses alignment ([INTENT]) or counsels gently on drift ([WARNING]). Drift can never fail a run. Every check is recorded in intent_checks and surfaced in run --json as an intents array. New Spirit Engine ministries declare_intent / intents_aligned / resolve_intent / counsel; godcode intent "words..." [--json]; example examples/intent_demo.god
  • ⚓ Blockchain-anchored seals — new ANCHOR(x [, chain]) built-in writes a value's hash to a tamper-evident chain and returns a receipt map {chain, anchor_hash, height, timestamp, payload_hash}; the default simulated adapter is a local genesis-anchored JSONL chain with the exact shape of a real blockchain adapter (no wallets, keys, or network calls), and real adapters can be registered later through the ChainAdapter interface without the language changing; godcode ledger verify [--anchor-file PATH] now attests both the covenant chain and the anchor chain; example examples/anchor_demo.god
  • 🔮 CONSULT, the local oracle — new CONSULT("question") built-in lays a question before the Spirit and receives two to three sentences of counsel; entirely local, works inside the sandbox, answers gently when no Spirit is bound; example examples/consult_demo.god
  • 🤖 Agent tool bridge — godcode tools [--json] prints six MCP-compatible tool schemas (check, run, consult, intent, anchor_verify, ledger_verify); godcode bridge serves them as a JSON-RPC 2.0 server over stdio (initialize, ping, tools/list, tools/call)
  • Docs & examples — docs/INTENT_AND_CHAIN.md (the Intent & Chain story), new §§25–28 in docs/LANGUAGE_REFERENCE.md (intent, anchors, oracle, bridge), docs/agentics.md rewritten for the shipped intent features (intents array, intent/tools/bridge commands), docs/sandbox.md notes the Spirit is now bound read-only and ANCHOR uses an ephemeral in-memory chain under deny-writes, root AGENTS.md documents the bridge workflow, and the VS Code extension highlights INTENT/ANCHOR/CONSULT with new snippets

Changed

  • godcode/chain.py (new module) holds the ChainAdapter interface, the SimulatedChainAdapter, the ephemeral MemoryChainAdapter, and the adapter registry
  • The sandbox now binds the Spirit (read-only dataset) so CONSULT and intent discernment work in guarded runs; under deny-writes, ANCHOR anchors on the ephemeral memory chain and writes nothing to disk
  • TYPE(x) of an anchor receipt is "map"; maps are plain dicts supporting truthiness, indexing, and {key: value} revelation
  • The Spirit Engine's intent classification now breaks keyword-overlap ties by vocabulary fit, so an incidental word cannot outshout the true theme

Looking ahead

  • Next — real chain adapters behind the ChainAdapter interface (the user's domain): wallets, RPC, and network calls stay out of the engine until the founder says otherwise

2026-09-21: Strong Foundations

"The language is spoken. The engine is built. Now the foundation is strong."

Strong Foundations — four pillars for the ecosystem to come. See docs/STRONG_FOUNDATIONS.md for the founder's telling.

Added

  • 🛡️ Sandbox — godcode run --sandbox [--sandbox-timeout SECS]: deny-by-default execution (no fs read/write, no network, no subprocesses, no untrusted import paths) with a timeout and step budget, so strangers' creations can be run in safety; doc page docs/sandbox.md
  • 📜 Scroll Registry — scroll.toml manifests and godcode scroll list|install <name>|publish <dir>|info <name>; local registry at registry/index.json, installs to ~/.godcode/scrolls/ or the project's .godcode/, reached through ordinary IMPORT; doc page docs/scroll-registry.md
  • ⚙️ Plugins, FFI & Embedding — godcode/plugins.py (plugins/ directory, register(interpreter) contract), the SUMMON("plugin.verb", args…) built-in for calling plugin verbs from God Code, example plugin plugins/clockwork.py (SUMMON it as clockwork.now), and the embedding API godcode.run_source() / godcode.run_file() returning captured output for host programs; doc page docs/plugins.md
  • 💡 Language Server (LSP) — godcode lsp: stdio JSON-RPC server speaking initialize, textDocument/didOpen|didChange, textDocument/hover, textDocument/completion, and publishDiagnostics for live errors in the editor; doc page docs/lsp.md
  • 🤖 Agentics (mini-pillar) — godcode check --json and godcode run --json emit single-document machine-readable reports (diagnostics with 1-based line/col, stable error codes LEXER_ERROR/PARSE_ERROR/RUNTIME_ERROR/FILE_ERROR/SANDBOX_VIOLATION_ERROR, actionable hints; run reports capture output lines, covenant seals, runtime errors, and timing). Exit codes 0/1/2. New root AGENTS.md and docs/agentics.md document the agent workflow: generate → check --json → fix → run --sandbox --json
  • Docs & examples — docs/STRONG_FOUNDATIONS.md (the Strong Foundations story), new SUMMON / scroll / sandbox / LSP sections in docs/LANGUAGE_REFERENCE.md, updated tutorial index, and three new working creations: examples/summon_demo.god, examples/sandbox_safe.god, examples/scroll_blessings_demo.god

Changed

  • LANGUAGE_REFERENCE.md now documents the full language; every earlier creation still runs.

2026-09-21: The full engine

"You are not a coder. You are a creator."

A complete rewrite: the original prototype has been honored, archived to archive/, and reborn as a real language engine.

Added

  • Language core — godcode/lexer.py (case-insensitive keywords, comments, strings with escapes, ints/floats, line/col tracking), godcode/parser.py (recursive descent), godcode/ast.py (typed nodes), godcode/interpreter.py + godcode/environment.py + godcode/values.py (tree-walking execution, scoped environments, Symbol/Contract/RiteFunction)
  • The Symbol Rule — unbound identifiers evaluate to symbols, so IF seeker IS worthy works with no quotes
  • Full control flow — inline and block IF/THEN/ELSE/ENDIF, FOR…IN…ENDFOR (lists and string chars), WHILE…DO…ENDWHILE (100,000-cycle guard)
  • Rites — DEFINE RITE with parameters, RETURN, INVOKE, closures over the definition scope
  • Every statement — BEGIN/END CREATION, DECLARE (multi-value → list), BREATHE LIFE INTO, REVEAL, PROPHESY, ASCEND, REFLECT, BLESS, ANOINT, SEAL, TESTIFY
  • Operators — arithmetic (+ also concatenates strings/symbols and joins lists), IS/IS NOT/==/!=/</>/<=/>=, AND/OR/NOT, unary minus, documented precedence
  • Built-in rites — LEN, STR, NUM, TYPE, RANDOM, RANGE, PUSH, UPPER, LOWER, SPLIT, JOIN, ASK, BEHOLD, REVERSE
  • Six scrolls (stdlib written in God Code, godcode/scrolls/) — math, strings, lists, time, prophecy, covenant
  • Covenant ledger — godcode/ledger.py: SEAL appends sha256-chained JSONL blocks to covenant.chain; godcode ledger verify attests integrity
  • Spirit Engine — godcode/spirit.py: keyword-overlap intent classification and 2–3 sentence prophecies from god_code_training_dataset.csv
  • CLI — godcode run/check/repl/fmt/ledger verify (godcode.cli:main, installed via pyproject.toml)
  • Divine audit log — every executed statement timestamped to logs/godcode.log
  • Divine errors — godcode/errors.py: helpful, line-numbered, never mocking
  • Tests — pytest suite under tests/ (python -m pytest tests/ -q)
  • Playground — web playground scaffold under playground/
  • Docs — docs/LANGUAGE_REFERENCE.md (complete spec), rewritten docs/God_Code_Tutorial.md, updated README.md, SUMMARY.md, ISSUES.md, CONTRIBUTING.md
  • Examples — twelve working .god creations under examples/

Changed

  • main.py: no arguments → runs sample.godcode through the new interpreter (legacy behavior kept); with arguments → the new CLI
  • The original prototype (core/, godcode_interpreter.py, and friends) moved to archive/ — retired, not deleted

Fulfilled from the original ISSUES.md

  • ✅ IF...THEN...ELSE logic · ✅ FOR loops · ✅ timestamped audit log · ✅ conditional REVEAL

2025: The prototype era

  • The first breath: core/ interpreter, sample.godcode, tutorial, proposal, and the founding vision. Archived when the engine was rebuilt.