Skip to content

Install and run Incan

The current release line is Incan 0.5. The supported install channels deliver the compiler, language server, and release Loaf envelope used by the 0.5 tutorials.

Supported hosts

The stable binary installer ships archives for macOS arm64, macOS x86_64, and Linux x86_64. Native Windows and Linux arm64 are not supported by the current binary installer; use WSL2 or a source build on those hosts.

The release manifest records the compiler archive, checksum, Rust backend policy, and extra targets needed by the toolchain. The direct installer and package-manager adapters consume the same release payload rather than publishing separate compiler builds.

Install the 0.5 toolchain

The supported release channels install the same Incan toolchain payload. Choose the command manager that already fits your environment:

curl -fsSL https://github.com/encero-systems/incan/releases/latest/download/install.sh | bash

export PATH="$HOME/.local/bin:$PATH"
incan --version
incan-lsp --version

This path verifies the release manifest and checksum and can provision the stable Rust backend through rustup.

brew tap encero-systems/tap
brew install incan
incan --version

Homebrew installs the prebuilt command binaries. Manage Rust separately.

npm install -g @incan/toolchain
incan --version

npm installs command shims without a lifecycle script; the first incan run provisions the checksum-verified toolchain for your host. Manage Rust and the wasm32-wasip1 target separately.

pipx install incan
incan --version

pipx keeps the command package isolated and routes installation through the shared release installer.

Native Windows and Linux arm64 are not supported by the current binary installer. Use WSL2 or a source build on those hosts.

Create and exercise a project

incan new hello --yes
cd hello
incan oven bake --project .
incan run
incan test
incan build --release

This is the canonical first-contact loop: scaffold one project, prepare its receipt-bound debug and release plans once, run its entry point, execute its tests, and produce a native release build. Normal run, test, and build commands then reuse the sealed plans without invoking Cargo.

incan new creates incan.toml, src/main.incn, tests/test_main.incn, README.md, and .gitignore. The starter is deliberately small so the first run proves the complete project loop without hiding the generated files.

Build the 0.5 toolchain from source

To build the 0.5 toolchain from source, use the matching release checkout and prepare its bounded release Loaf envelope:

git clone https://github.com/encero-systems/incan.git
cd incan
git switch --detach v0.5.0
export INCAN_CHECKOUT="$PWD"
make build
make test-prewarm-oven-release-loafs \
  INCAN_TEST_COMPILER_ALREADY_BUILT=1 \
  INCAN_TEST_OVEN_RELEASE_COMPILER_BIN="$PWD/target/debug/incan"
export INCAN_SOURCE_ROOT="$INCAN_CHECKOUT"
export INCAN_STDLIB="$INCAN_CHECKOUT/crates/incan_stdlib/stdlib"
export INCAN_STDLIB_DIR="$INCAN_STDLIB"
export INCAN_TOOLCHAIN_CRATES_DIR="$INCAN_CHECKOUT/crates"
export PATH="$INCAN_CHECKOUT/target/oven-alpha-release-toolchain/bin:$PATH"
incan --version

make build compiles the compiler and language server. The explicit prewarm target then assembles the complete 0.5 release envelope used by repository smoke tests—including the debug and release full-standard-library Loaf families—and puts its compiler under target/oven-alpha-release-toolchain/bin. The checkout variables keep examples tied to the same compiler and standard library after you change directories. This is a source-checkout preparation step, not a normal project build command. Keep that prepared binary first on PATH while using the source-built toolchain, and repeat both commands after updating the checkout.

Use this route when contributing to Incan or when a supported prebuilt archive is unavailable. It prepares the same bounded release envelope expected by the tutorials; cargo install alone does not.

The 0.5 compiler uses the Oven-managed build path: project dependencies resolve into receipt-compatible Loaf state, generated Rust stays inspectable, and ordinary incan build, run, and test invoke rustc without a Cargo fallback. Cargo remains an internal publishing and compatibility boundary rather than the authority for normal project builds.

Continue