Toolchain: installation, channels, and versioning

How Argon is installed, versioned, and switched. oxup is the toolchain manager (rustup-style); ox/oxc/ox-lsp/oxfmt are the tools it dispatches.

Install

curl -fsSL https://argon.sharpe-dev.com/install.sh | sh

Installs oxup into ~/.argon/bin, links the tool shims, and installs the stable toolchain. Ensure ~/.argon/bin is on PATH.

Platforms: macos-arm64, linux-x86_64, linux-aarch64.

Channels

Version strings

X.Y.Z is the in-development line; dev/nightly are prereleases of it (they sort ahead of the last stable). oxup and the toolchain share one version.

Distribution layout

Served from https://argon.sharpe-dev.com (S3 origin behind CloudFront):

/install.sh                                                          installer
/toolchains/<version>/<platform>/argon-<version>-<platform>.tar.gz(.sha256)
/dist/channel-<channel>.toml                                         current version per channel
/dist/index-<channel>.json                                           all published versions
/oxup/latest/<platform>/oxup(.sha256)                                oxup self-update (stable)
/oxup/<channel>/latest/<platform>/oxup(.sha256)                      oxup self-update <channel>
/editors/vscode/<version>/argon-<version>.vsix(.sha256)              editor extension

• /toolchains/<version>/ is immutable. dev/nightly tarballs are pruned 30 days after publish; stable is kept indefinitely.
• index-<channel>.json is newest-first: an array of { version, released, platforms[], sha256, available }. A pruned build stays listed with "available": false.

Toolchain spec

A spec identifies a toolchain to install/use/+<spec>:

oxup commands

oxup use <spec>                            install if needed, then set as default
oxup default <spec>                        alias for `use`
oxup install <spec>                        install without changing the default
oxup uninstall <spec>                      remove an installed toolchain
oxup update [channel]                      re-fetch a channel's latest
oxup list                                  installed toolchains (default marked)
oxup list --available [--channel C] [--limit N]   published versions
oxup search <pattern>                      search published versions across channels
oxup show                                  active toolchain, default, installed
oxup which <tool> [--toolchain <spec>]     resolved binary path
oxup self-update [channel]                 update oxup itself (stable; or dev/nightly)
oxup extension install|uninstall|list      editor extension (matches the active toolchain)

--json is available on list, search, and show (for tooling).

Selecting a toolchain (per invocation)

First match wins:

1. OXUP_TOOLCHAIN=<spec>
2. +<spec> as the first argument — e.g. oxc +nightly build
3. ox-toolchain.toml in the working directory or a parent — [toolchain] channel = "<spec>"
4. ~/.argon/settings.toml — [default] channel
5. the built-in stable

A missing toolchain is fetched automatically on first use.

~/.argon/

~/.argon/
  bin/
    oxup                     the manager
    ox oxc ox-lsp oxfmt      symlinks → oxup
  toolchains/<spec>/
    bin/                     ox oxc ox-lsp oxfmt
    share/std/               bundled stdlib packages
    manifest.toml            version, platform, components
    provenance.toml          source (cdn|local), origin, sha256, install time
  settings.toml              [default] channel, [extension] state

ox/oxc/ox-lsp/oxfmt on PATH are symlinks to oxup; oxup reads argv[0], resolves the active toolchain, and execs ~/.argon/toolchains/<spec>/bin/<tool>.

Tools

Formatter notation policy

Argon’s dual notation (Unicode notation) lets source mix Unicode glyphs (∀ ⊑ → ⊞) with their ASCII spellings (forall <: -> box_plus); both lex to the same token. The formatter can normalize a file to one form, governed by [fmt] notation in ox.toml:

[fmt]
notation = "preserve"  # | "unicode" | "ascii"

• preserve (the default) never rewrites between the two forms — a file is formatted as typed, so mixed notation is left untouched.
• unicode rewrites every ASCII spelling to its glyph (forall → ∀); ascii does the reverse. The rewrite is lossless and round-trips, because both forms produce the identical token.

The policy resolves through a nearest-wins cascade (rustfmt/prettier-style): a package’s own [fmt] overrides a [workspace.fmt] at the workspace root, which overrides the global user config. The notation table itself is the single [[notation]] source shared with the lexer aliases and editor input methods. Notation is policy (a per-project taste call); spacing and layout are the Argon convention and are not configurable.

Editor support

Everything an editor knows about an Argon program comes from one place: the language server, ox lsp. The reason is the meta-calculus. Argon’s surface vocabulary is user-extensible — a package declares its own metatypes, concepts, relations, and constructs, so the set of meaningful words in a file is not fixed by the language. A static grammar can color and brace-match the punctuation, but it cannot know that Obligation is a concept or that owes is a relation; only the resolver that elaborated the package knows that. So all the language-aware behavior — diagnostics, hover, jump-to-definition, the right token colors — lives in the server, and editors are thin clients of it. One server, written once, drives every editor; an editor plugin is just an LSP client plus a syntax floor.

What ox lsp provides

ox lsp speaks LSP over stdio and advertises:

Inlay hints and code lenses are not built yet. Because the diagnostics are the server’s, they always match the toolchain that produced them — there is no second, drifting implementation of the checks.

Installing it

oxup installs and version-locks the editor integration, so the editor support matches the active toolchain:

oxup extension install                         # auto-detect every installed VS Code-family editor
oxup extension install --editor neovim         # or name one explicitly
oxup extension uninstall --editor emacs
oxup extension list                            # detected editors + the installed version

The two editor families install differently because they expose different contracts:

• VS Code family (VS Code, Cursor, VSCodium, VS Code Insiders, and the browser-hosted code-server) have an --install-extension CLI. oxup fetches the .vsix stamped with the active toolchain version from an immutable CDN path, sha256-verifies it (the same fail-closed discipline as the toolchain fetch), and installs it. A user on stable 0.2.2 gets the 0.2.2 extension, not “latest”.
• Neovim, Vim, and Emacs have no extension-CLI contract, so oxup installs them by file placement: it writes the embedded plugin files into the editor’s package directory and adds an idempotent, oxup-managed block to the init file (between >>> argon (oxup-managed) >>> sentinels) that points the client at the active toolchain’s ox lsp. Re-running updates the block in place and leaves everything outside the sentinels untouched; uninstall removes both.

oxup init and oxup update auto-install and refresh the integration after the toolchain is placed (oxup init --no-extension opts out). A failed editor install is a soft, one-line warning — the toolchain is what matters — never a hard error.

The VS Code extension ships the Argon “A” glyph as the .ar file icon. The Neovim and Emacs plugins cannot reuse that SVG (their file explorers draw a Nerd Font glyph, not an image); their READMEs give a suggested glyph-and-color registration keyed on the .ar extension.

Environment