Leitwolf11 · Oct 17, 2026 · Oct 16, 2026 · Oct 16, 2026 · Oct 17, 2026 · Oct 17, 2026
diff --git a/Documents/ARCHITECTURE.md b/Documents/ARCHITECTURE.md
@@ -168,7 +168,7 @@ temporary object. Bounded Xpp/Xmm v7 readers and writers support verified forwar
 
 ## Process and temporary-file model
 
-The private frontend library is located relative to `talac` in the build or installed layout. The current working directory
+The private frontend library is located relative to Talac in the build or installed layout. The current working directory
 is project input, not an executable search mechanism. The driver owns in-memory Core buffers plus temporary link artifacts through scoped
 cleanup objects so partial runs do not leak files or accidentally reuse an older artifact.
 
@@ -187,8 +187,8 @@ not become compiler passes merely because `tazel fmt` and `tazel lint` dispatch
 
 ## Architecture constraints
 
-- One shipped `talac` command coordinates frontend and backend; frontend/backend are not separate user binaries.
-- `tazel` starts `talac`, `talafmt` and `talalint` as programs; it is never linked into them and they never read a
+- One shipped Talac command coordinates frontend and backend; frontend/backend are not separate user binaries.
+- `tazel` starts Talac, `talafmt` and `talalint` as programs; it is never linked into them and they never read a
   project file.
 - CorePrep remains internal and cannot appear in `--emit` or `--build`.
 - Public artifacts require an explicit, versioned reader/writer contract.

diff --git a/Documents/BUILDING.md b/Documents/BUILDING.md
@@ -122,7 +122,7 @@ go run ./helpers/cmd/develop build
 go run ./helpers/cmd/develop test
 ```
 
-`build` compiles `talac`, `tali`, and 16 component-owned test targets (15 Catch3 suites plus the C11 AARC ABI contract).
+`build` compiles Talac, `tali`, and 16 component-owned test targets (15 Catch3 suites plus the C11 AARC ABI contract).
 `test` performs the same build and then executes each native program directly. This
 avoids introducing Git Bash/MSYS solely for Bazel's POSIX-oriented `cc_test` launcher on Windows while retaining the same
 suite set on macOS.
@@ -134,7 +134,7 @@ go run ./helpers/cmd/develop version 0.6.0
 ```
 
 The check compares `MODULE.bazel`, the changelog heading, the Haskell package, and the Kotlin project runtime using exact
-release lines. If a Bazel-built `talac` is available, its `version` output must agree as well. This Go command replaces the
+release lines. If a Bazel-built Talac is available, its `version` output must agree as well. This Go command replaces the
 retired root `release.java`; repository automation does not require a Java script runtime.
 
 Useful component targets for incremental work are:
@@ -173,11 +173,11 @@ Kotlin:
 
 The repository wrapper pins the Gradle distribution used by the project. Use it instead of a machine-global Gradle command.
 JDK 25 must be visible to the wrapper process. Kotlin Script Runner remains an external runtime requirement; it is not
-embedded into `talac`.
+embedded into Talac.
 
 ## Building the private frontend
 
-The Haskell driver package produces the private frontend consumed by `talac`. Build all compiler packages together so Cabal
+The Haskell driver package produces the private frontend consumed by Talac. Build all compiler packages together so Cabal
 selects one coherent local package set:
 
 ```powershell
@@ -202,7 +202,7 @@ Build and validate an install-shaped compiler directory with one command:
 go run ./helpers/cmd/develop bundle
 ```
 
-The command performs both build-system steps deliberately: Bazel produces the C++20 `talac` driver and Cabal produces the
+The command performs both build-system steps deliberately: Bazel produces the C++20 Talac driver and Cabal produces the
 Haskell frontend shared library. It then stages a fresh directory with this shape:
 
 ```text
@@ -223,9 +223,9 @@ The brackets above describe the host suffix; they are not literal filename chara
 compiler version, host platform, and architecture so separately built bundles do not silently overwrite one another.
 `dist/` is ignored generated output and is not committed.
 
-The bundle contains two executables and one shared library. Users invoke `talac`; the driver calls the adjacent
+The bundle contains two executables and one shared library. Users invoke Talac; the driver calls the adjacent
 `tala-frontend` library in-process through the versioned C ABI, and `tali` is the REPL executable.
-Do not move `talac` without its matching library or place an unrelated library beside it.
+Do not move Talac without its matching library or place an unrelated library beside it.
 
 Staging is not considered successful merely because both build systems returned zero. The bundle command invokes the
 staged tools, checks the compiler version, compiles a real `.tala` fixture to an executable, and executes that native program.
@@ -383,7 +383,7 @@ depend on a temporary directory.
 
 ### Private frontend is missing
 
-Build the Haskell workspace and confirm the frontend is placed in the layout expected by `talac`. Installing a same-named
+Build the Haskell workspace and confirm the frontend is placed in the layout expected by Talac. Installing a same-named
 command globally is not a supported fix because it could mismatch the Core wire contract.
 
 For an install-shaped local layout, prefer `go run ./helpers/cmd/develop bundle`; it stages the matching Bazel and Cabal

diff --git a/Documents/CLI.md b/Documents/CLI.md
@@ -13,8 +13,8 @@ Tala ships several programs, and each does one job:
 | `talafmt` | the formatter | Haskell |
 | `talalint` | the linter | Haskell |
 
-`talac` knows nothing about projects, dependencies, packages, formatting or linting. `tazel` compiles nothing: it starts
-`talac`, `talafmt` and `talalint` as separate programs and passes them arguments.
+Talac knows nothing about projects, dependencies, packages, formatting or linting. `tazel` compiles nothing: it starts
+Talac, `talafmt` and `talalint` as separate programs and passes them arguments.
 
 Every command line is read by a parser written by hand for that program. A line that is accepted becomes a typed value,
 and no later stage looks at the argument text again. No program uses a command-line library.
@@ -135,7 +135,7 @@ An option the compiler reads but cannot carry out is refused by name with exit c
 
 ### The frontend library
 
-`talac` loads the Haskell frontend from a shared library beside the executable: `tala-frontend.dll`,
+Talac loads the Haskell frontend from a shared library beside the executable: `tala-frontend.dll`,
 `libtala-frontend.dylib` or `libtala-frontend.so`. It is an implementation library, not a second command.
 
 ## `tazel`
@@ -165,7 +165,7 @@ tazel <command> [arguments]
 | `tazel version` | prints the version of Tazel |
 | `tazel help [command]` | prints the help, or the help of one command |
 
-`tazel check` starts `talac` with `--emit=metadata` and the compiler options of the project file. `tazel build` starts it
+`tazel check` starts Talac with `--emit=metadata` and the compiler options of the project file. `tazel build` starts it
 with `--emit=executable` and moves the result into the output directory of the build mode, under the name of the target.
 
 ### Selecting targets

diff --git a/Documents/COMPILER-PIPELINE.md b/Documents/COMPILER-PIPELINE.md
@@ -47,9 +47,9 @@ LLVM IR -> LLVM verifier -> optimization -> target machine
         `--> LLD -> executable
 ```
 
-The user-facing compiler command remains `talac`. The native driver calls the adjacent Haskell `tala-frontend` shared library
+The user-facing compiler command remains Talac. The native driver calls the adjacent Haskell `tala-frontend` shared library
 through a versioned C11 ABI; the library is not a second process or public compiler command. Native middle-end and backend
-libraries are linked into `talac`; CorePrep is never exposed as a command or file type.
+libraries are linked into Talac; CorePrep is never exposed as a command or file type.
 
 ## 1. Input selection
 

diff --git a/Documents/CORE-IR.md b/Documents/CORE-IR.md
@@ -425,7 +425,7 @@ Two bounds keep the recursion within the stack. The frontend rejects a
 function body that nests statements more than 256 levels or expressions more
 than 1024 levels deep, with a source position, before Core exists. The
 native wire reader and writer bound statement bodies and expressions at 4096
-levels each, so Core from a file is bounded as well. `talac`, `tali` and the
+levels each, so Core from a file is bounded as well. Talac, `tali` and the
 fuzz programs run the pipeline on a thread with 256 MiB of reserved stack,
 `Tala/Support/CompilerStack.hpp`, instead of the stack the
 operating system gives the process, which is one megabyte on Windows. A

diff --git a/Documents/Contributing/COMPONENTS.md b/Documents/Contributing/COMPONENTS.md
@@ -3,7 +3,7 @@
 
 # Find the owning component
 
-The public `talac` command is one compiler, but implementation ownership is split deliberately. Put a rule where it first
+The public Talac command is one compiler, but implementation ownership is split deliberately. Put a rule where it first
 becomes meaningful, then test the next boundary that consumes it. Do not add a second parser, semantic model, or option
 validator in a convenient downstream component merely because that is where a symptom appears.
 
@@ -30,7 +30,7 @@ explain the contracts and implementation limits.
 | Xpp/Xmm operation or ownership check | `Talac/Codegen/Xpp`, `Talac/Codegen/Xmm`, or `Talac/Analysis` | Component tests plus connected `Talac/Driver/Tests` |
 | LLVM lowering or object emission | `Talac/Backend/LLVM` | Backend tests and native artifact smoke checks |
 | AARC runtime/ABI | `Talac/Runtime/AARC` and owned public headers | C++ runtime tests and C11 caller ABI test |
-| Native CLI spelling, precedence, help, dispatch | `Talac/Cli` | CLI tests and a `talac` process test |
+| Native CLI spelling, precedence, help, dispatch | `Talac/Cli` | CLI tests and a Talac process test |
 | Project file evaluation, plugins, lockfile, project commands | `Tazel/` | Kotlin tests, which run whole commands against stand-in tools |
 | REPL cell/session behavior | `Interactive` | `Interactive/Tests` and a `tali` smoke check |
 

diff --git a/Documents/DIAGNOSTIC-PROTOCOL.md b/Documents/DIAGNOSTIC-PROTOCOL.md
@@ -10,7 +10,7 @@ boundary between the compiler and trusted local tools such as Xide. It is not a
 format, or a replacement for readable terminal diagnostics.
 
 TADG version 1 carries enough structure for an editor to present an error list, navigate to related declarations, and
-offer explicitly described edits without parsing English text. The public `talac` command remains the only compiler
+offer explicitly described edits without parsing English text. The public Talac command remains the only compiler
 executable users invoke. The native driver starts the Haskell frontend and passes the side-channel path privately.
 
 ## Design rules
@@ -32,7 +32,7 @@ diagnostics produced there use the ordinary `CorePrep` stage tag.
 
 ## Transport
 
-A trusted local consumer sets `TALA_DIAGNOSTICS_FILE` on the native `talac` process when it requests structured diagnostics.
+A trusted local consumer sets `TALA_DIAGNOSTICS_FILE` on the native Talac process when it requests structured diagnostics.
 The native driver preserves that private variable for its child frontend, which writes one complete document before it
 exits. In the absence of the environment variable, the frontend performs no extra I/O and preserves existing CLI behavior.
 

diff --git a/Documents/DIAGNOSTICS.md b/Documents/DIAGNOSTICS.md
@@ -51,7 +51,7 @@ Human stderr may be displayed as supplemental detail, but it must never be repar
 
 ### Document-version ownership
 
-TADG version 1 describes the disk snapshot compiled by `talac`; it does not carry an editor document version. Xide records
+TADG version 1 describes the disk snapshot compiled by Talac; it does not carry an editor document version. Xide records
 the active version when it starts a check and publishes the resulting diagnostics only if that version remains current.
 Edits made while the compiler runs therefore invalidate the result. Fixes require the same version guard before their
 text edits can be applied.
@@ -62,7 +62,7 @@ highlighting after supplementary characters.
 
 ## Output channels
 
-`talac` writes ordinary requested output to standard output and diagnostics to standard error. Help and version are parser
+Talac writes ordinary requested output to standard output and diagnostics to standard error. Help and version are parser
 outcomes rendered by the driver; parsing itself does not print. This separation lets tests and embedding clients inspect a
 typed parse result without redirecting global streams.
 
@@ -612,7 +612,7 @@ A stable machine-facing diagnostic needs:
 - optional related locations and safe fixes.
 
 The current CLI is text-oriented. A future structured protocol must be versioned rather than inferred from terminal output.
-Until then, external tools should use the compiler libraries/frontends they own instead of scraping `talac` wording.
+Until then, external tools should use the compiler libraries/frontends they own instead of scraping Talac wording.
 
 ## Security and privacy
 

diff --git a/Documents/ECOSYSTEM.md b/Documents/ECOSYSTEM.md
@@ -235,7 +235,7 @@ without coupling all releases to the compiler workflow.
 ## Boundary rules
 
 - Do not move language parsing or type checking into editor code.
-- Do not make `talac` silently format or lint during ordinary compilation.
+- Do not make Talac silently format or lint during ordinary compilation.
 - Do not make Ecosystem/talafmt/Linter installation a compiler build dependency.
 - Do not use filesystem layout as namespace identity.
 - Do not call an unevaluated Kotlin model an active configuration evaluator.

diff --git a/Documents/FUZZING.md b/Documents/FUZZING.md
@@ -361,7 +361,7 @@ removed. What an argument by need costs in generated code is a cost of the
 current lowering, listed in `EVALUATION.md`.
 
 The source fuzz targets and the source smoke programs run the compiler on the
-compiler stack, as `talac` does, because an input nested up to the frontend's
+compiler stack, as Talac does, because an input nested up to the frontend's
 limits does not fit on the default stack of a process. `Corpus/source` has
 permanent seeds for deep nesting, for nesting at and one level beyond each
 limit, for long `else if` and operator chains, which are not nesting, for

diff --git a/Documents/IMPLEMENTATION.md b/Documents/IMPLEMENTATION.md
@@ -5,7 +5,7 @@
 
 ## Summary
 
-Tala now has one production source route for the implemented language subset. The C++20 `talac` driver starts the private
+Tala now has one production source route for the implemented language subset. The C++20 Talac driver starts the private
 Haskell frontend, receives bounded verified Core, and continues through CorePrep, Xpp, Xmm, and LLVM. The old C lexer/parser,
 macro, HIR/MIR, and C-to-Rust syntax-packet route has been removed rather than retained as a fallback.
 
@@ -191,8 +191,8 @@ The compiler reads its command line with a typed schema written by hand: option
 value conversion. It has no command-line library and knows nothing about projects.
 
 Tazel is a separate Kotlin program. It owns project discovery, the project DSL, source discovery, the SQLite lock file and
-its text dump, and it starts `talac`, `talafmt` and `talalint` as programs. `tazel check` evaluates the project, collects
-the sources of each executable and starts `talac` with `--emit=metadata` and the compiler options of the project;
+its text dump, and it starts Talac, `talafmt` and `talalint` as programs. `tazel check` evaluates the project, collects
+the sources of each executable and starts Talac with `--emit=metadata` and the compiler options of the project;
 `tazel build` does the same with `--emit=executable` and moves the result into the output directory. The entry is
 resolved by the frontend from namespace and class identity; no source file is guessed from the entry spelling.
 

diff --git a/Documents/INTERACTIVE.md b/Documents/INTERACTIVE.md
@@ -5,7 +5,7 @@
 
 Tala Interactive is the expression-oriented REPL distributed as `tali`. It is a user of the compiler, not a second
 language implementation: source cells enter the maintained Haskell frontend and then follow the production native
-pipeline. The public compiler remains the `talac` command.
+pipeline. The public compiler remains the Talac command.
 
 ## Invocation
 
@@ -17,7 +17,7 @@ tali --help
 
 `tali` is a program of its own; the compiler has no command that starts it.
 
-The repository's native bundle stages `talac`, `tali`, and the private `tala-frontend` shared library together. `tali`
+The repository's native bundle stages Talac, `tali`, and the private `tala-frontend` shared library together. `tali`
 loads the shared library beside its own executable. The library is not a user-facing compiler, and an unrelated copy on
 `PATH` cannot override it.
 

diff --git a/Documents/LLVM-BACKEND.md b/Documents/LLVM-BACKEND.md
@@ -141,7 +141,7 @@ compiler or IDE part of the build architecture. ClangCL/LLD remain the native to
 
 ## Linking an executable
 
-`talac` links a native executable on every host. The entry of a program is a bridge the backend
+Talac links a native executable on every host. The entry of a program is a bridge the backend
 adds for an executable and for nothing else: it calls the program's `Main` and returns zero.
 
 | Host | Entry symbol | Linked by | Runtime library | Takes from the system |

diff --git a/Documents/MONOREPO.md b/Documents/MONOREPO.md
@@ -44,7 +44,7 @@ Talac/
 └── Linker/                typed LLD execution
 ```
 
-The directory names are architectural seams even though `talac` is the only public compiler command. The current distribution
+The directory names are architectural seams even though Talac is the only public compiler command. The current distribution
 also stages the private Haskell `tala-frontend` shared library beside it; splitting native components does not create additional
 publicly installed frontend/backend tools.
 

diff --git a/Documents/PROJECT-ARTIFACTS.md b/Documents/PROJECT-ARTIFACTS.md
@@ -12,7 +12,7 @@ CLI option.
 
 The compiler selects an output kind with `--emit` when several sources are
 compiled as one program. Tazel itself asks only for an executable or for a
-check; the other kinds are reached by starting `talac` directly. An
+check; the other kinds are reached by starting Talac directly. An
 executable build still produces exactly one native executable. A project `object`
 or `assembly` build instead produces one native artifact for every physical
 source unit in the selected entry namespace's Core catalog:

diff --git a/Documents/README.md b/Documents/README.md
@@ -36,7 +36,7 @@ following vocabulary:
 | Exercise malformed compiler inputs | [Fuzzing](FUZZING.md) |
 | Place tests and fixtures | [Test ownership](TEST-OWNERSHIP.md) |
 | Measure compiler throughput | [Benchmarking](BENCHMARKING.md) and [recorded baselines](../Benchmarks/README.md) |
-| Use `talac` | [CLI](CLI.md) |
+| Use Talac | [CLI](CLI.md) |
 | Use or implement the REPL | [Tala Interactive](INTERACTIVE.md) |
 | Write `BUILD.kts` | [Project files](PROJECT_FILES.md) |
 | Understand per-source object and assembly outputs | [Project native artifacts](PROJECT-ARTIFACTS.md) |

diff --git a/Documents/ROADMAP.md b/Documents/ROADMAP.md
@@ -60,7 +60,7 @@ runtime features must not displace completion of that pipeline.
 - define the AARC closure environment and indirect invocation ABI;
 - connect project-wide object/assembly output with unambiguous names;
 - validate target-specific calling conventions and link inputs; and
-- keep `talac` as the only public compiler command while the private Haskell frontend remains an adjacent companion process.
+- keep Talac as the only public compiler command while the private Haskell frontend remains an adjacent companion process.
 
 ### 5. Project and ecosystem integration
 

diff --git a/Documents/SPECIFICATION.md b/Documents/SPECIFICATION.md
@@ -74,7 +74,7 @@ Use these layers when comparing design and code:
 1. `Spec/` defines the intended public language/library behavior.
 2. Compiler models show which parts can currently be represented.
 3. Focused tests show which behavior is implemented at an owning stage.
-4. Connected CLI tests show which behavior is usable through `talac`.
+4. Connected CLI tests show which behavior is usable through Talac.
 5. Backend tests show which represented values can produce native artifacts.
 
 A parser test alone does not prove runtime behavior. An LLVM test alone does not authorize new source syntax. A registered

diff --git a/Documents/TESTING.md b/Documents/TESTING.md
@@ -484,7 +484,7 @@ that boundary with:
 go run ./helpers/cmd/develop bundle
 ```
 
-This is more than an archive or copy test. A passing run proves that the staged `talac` reports the checkout's compiler
+This is more than an archive or copy test. A passing run proves that the staged Talac reports the checkout's compiler
 version, loads the adjacent private `tala-frontend` shared library in-process, compiles `Examples/HelloWorld` into an executable, and runs it until it prints
 `Hello from Tala!`. The tier workflows run it on every official host after the native suites. It also proves that the bundle contains `LICENSE.txt`, `PATENTS`, the current `1.1` exception and patent-grant
 texts, and a `SHA256SUMS` manifest covering the other staged files.