Extension compilers and retained builds
Use System → Compilers to install an extension toolchain on this computer. Use Code → Projects → Build extension to compile saved project source, keep the result in the owning gridoc, and…
Extension compilers and retained builds
Use System → Compilers to install an extension toolchain on this computer. Use Code → Projects → Build extension to compile saved project source, keep the result in the owning gridoc, and prepare that exact package for model admission. Compiler installation and compilation are explicit desktop operations. Opening a document does not download tools or execute a build recipe.
Install a compiler
Choose a language, review its exact version and installer source, and select Download & install. Grid verifies the pinned installer size and SHA-256, resolves a platform download lock, installs with that lock enforced, and records the compiler executable's identity and version. Files and caches stay in Grid's private tool directory; the operation does not alter shell profiles or global PATH. Installation output and cancellation use the existing desktop job owner. A failed installation is not presented as ready. Retrying can reuse verified provider and tool downloads.
Use an existing installation checks an absolute executable against the same pinned version, records its executable digest, and links it for this machine. Linked installations remain under their existing owner's control. Compiler version and executable changes are refused at the next build.
The catalog projects the supported profiles from Core, including their profile versions. Pilot profiles are not promoted by appearing in earlier design reviews.
| Existing supported profiles | Selected tool |
|---|---|
| Luau script V1/V2 | Included; no download |
| C Wasm core V1/V2 | Zig 0.15.2 C compiler |
| Rust Wasm core V1/V2 and native V1 | Rust 1.98.0, including the Wasm target |
| AssemblyScript Wasm core V2 | AssemblyScript 0.28.19 and Node 24.11.0 |
| JavaScript/TypeScript component V1 | Node 24.11.0; project-locked component tools |
| Python native V1 | Python 3.12.14 |
| Go native V1 | Go 1.25.0 and Zig 0.15.2 for cgo |
| Ruby native V1 | Ruby 3.4.10 |
Download availability and native prerequisites remain platform-specific. A failed vendor lookup, checksum, locked installation or compiler probe stops the operation; Grid does not silently use another installed version. Native Python runtime selection remains a separate Runtime Links setting. Installing a compiler does not grant a package runtime capabilities or trust.
Compile saved source
Open an extension source project with grid-extension.json and
grid-extension.dev.json. Select one of the supported profiles actually declared
by that project's artifacts. Save all editor drafts, then select Compile.
The project still defines its build arguments, bindings and optional native
capsule assembly. This surface does not invent a language profile or change a
package's ABI. Python and Ruby native projects need their own declared build
recipe; this is not a new Python/Ruby scaffolder.
Grid captures bounded project source and dependency locks into private staging, selects the verified compiler, and invokes:
gridctl --json extension build ./extension-project
The independent CLI owns compilation, native capsule assembly, digest
synchronization and binding generation. This command does not execute declared
behavioral fixtures. Development → Build & test remains the existing explicit
Testing operation. JavaScript component builds acquire exactly the dependencies
in package-lock.json, enforce their Node engine requirements, and disable npm
lifecycle scripts. Projects requiring
additional acquisition steps must declare and prepare them explicitly.
Native capsule recipes preserve the runtime contract declared by the selected profile:
| Native runtime | Capsule recipe fields |
|---|---|
| C ABI, including Go c-shared output | runtime: "cabi", library |
| Rust or Ruby | runtime: "rust" or "ruby", runner |
| Python | runtime: "python", pythonAbi, platform |
Library and runner paths must be relative to the capsule root and must exist after compilation. A recipe that disagrees with the selected profile is refused. Python's ABI and platform must match the receiving runtime.
A successful build produces a content-addressed descriptor binding source, profile, target, compiler identity, effective recipe, manifest and output bytes. The original project and its development configuration are not rewritten. Compiler binaries, machine environment variables and credentials are not included in the portable receipt. Source snapshots use Code's bounded source inventory; hidden files, dependency trees and compiler output directories are excluded. Manifest-declared outputs are captured separately.
Keep, reopen and use
Keep in gridoc transfers verified chunks through the exact native document owner. The document artifact store retains source, settings, dependency locks, receipt, manifest and outputs. The project head advances only after all file hashes, sizes and manifest-bound outputs verify. A conflicting head requires a refresh; failed or incomplete uploads leave the previous retained build intact. Repeating an interrupted transfer reuses matching chunks. Builds with identical files retain separate ownership records while sharing stored content. Save the document to preserve the updated archive. Saving keeps the current model live, including its input values and retained-project connection; you can continue editing without reopening the window. File Save updates the saved label when the current draft is archived; newer edits remain unsaved.
Retained content uses the document's codec. Portable export decodes extension payloads within the existing private export staging, and import re-encodes them under the receiving document's key while translating artifact references. Prior retained revisions remain reachable through artifact history. Ordinary artifact retention and garbage collection own their lifetime.
Opening Code Projects for a native gridoc with no local projects restores its retained project sources into private working copies, using the existing project tabs. Existing restored working copies keep saved edits. Restoration preserves the selected tab and resumes when native model admission changes during opening. Restoration does not run compilers or install dependencies. Code retains its existing twelve-tab limit.
Use in model reads the exact retained head, restores its verified package bytes, and prepares an immutable package workspace. It then opens the existing workspace activation review and adds the package import when needed. Runtime admission still checks the receiving platform, ABI, capabilities and trust. Retaining or restoring bytes does not activate them. A document switch during transfer or preparation refuses a handoff to the replacement model.
You can switch or deactivate a workspace without removing imports for builds retained in the gridoc. The native compiler reads their verified retained package definitions independently of the active execution workspace, preserving source and model state. Calls still require the matching active package; retention does not authorize execution. If the model calls an inactive package, calculation and archive Save wait for activation or a formula using the active package. Imports can remain unchanged. Activating another verified workspace replaces the current workspace through the existing activation transaction. Reactivating a workspace retries the unchanged source, including a draft that could not execute while its package was unavailable. Packages not retained in the gridoc still require their definitions to be available through the active workspace.
Bounds and operation isolation
A descriptor is limited to 1 MiB, with at most 4,096 files and 2 GiB of declared content. Transfers use 1 MiB chunks. Archive formats and the artifact store may impose additional aggregate limits. Compiler caches are machine-local and are not part of those document limits.
Installation, source hashing, subprocess execution and retained-content checks run only at their selected authoring or storage boundary. No compiler service, worker, timer or tool scan is added to formula evaluation or formula evaluation. Native outputs keep their existing platform contract; cross-compilation is not inferred from a language label.