Explicit on demand, implicit by default.

Crisp (.crp) is a systems language that transpiles to Rust. You write compact source; crisp infers types, ownership, and error propagation, emits Rust, and rustc is the soundness boundary.

This is a Rust-hosted bootstrap compiler (v1.9.0) — public release track. It is not self-hosted yet (ROADMAP Phase 2 / milestone v2.0.0). The language document remains spec v0.2.0-draft — treat “spec-complete” claims cautiously; see known limitations and spec ↔ impl deltas.

Known Rust Result APIs from rust = true deps lower to Crisp ambient errors (CrispError::Thrown + ?) — see examples/rust_import, examples/net_http (#55).

Spec: docs/spec/CrispLang-SPECS-0.2.0.md
Quickstart: QUICKSTART.md
Web docs: crisp-lang.org · branch docs
Roadmap: ROADMAP.md
Changelog: CHANGELOG.md
Contributing: CONTRIBUTING.md
Security: SECURITY.md
Milestone: v1.9.0

License: MIT OR Apache-2.0 (LICENSE, LICENSE-MIT, LICENSE-APACHE).

Crisp is optimized for writing and local reading. Semantics are defined by lowering to Rust, not by a separate runtime or VM.

In practice that means:

• Types, borrows, lifetimes, and error sets are inferred globally when the source stays silent.
• When you need precision — public APIs, performance-sensitive paths, or ambiguous usage — you annotate, and the compiler treats those annotations as hard constraints.
• reveal is the “show your work” companion to crisp: it prints inferred types, ownership (& / &mut), lifetimes, error sets, traits, and the emitted Rust that compact .crp source leaves implicit. See QUICKSTART §10.

Crisp is a front end that produces Rust. Rust remains the authority on memory safety and data races. Crisp’s own borrow/region passes exist to drive good diagnostics and to decide what to emit (&, &mut, owned, .clone() fallbacks); they are not claimed as an independent soundness boundary. If generated Rust fails to compile, that is a crisp bug, not a user error.

Design goals: native code via rustc; HM-style type inference; deterministic global ownership dataflow; ambient fallible functions lowered to a uniform Result<T, CrispError>; compact syntax; tooling-first ergonomics.

Non-goals: scripting semantics; a GC; a stable library ABI across separately compiled units; pretending Crisp’s checker replaces rustc; claiming full enum/trait/shape coverage while those remain incomplete.

Crisp v0.2.0 (spec) retargets from “direct-to-LLVM language” to source → CIR → Rust → native. The unit of compilation is the whole program or a sealed crate — inferred signatures depend on call sites, so ad-hoc separate compilation without a lockfile is not supported.

.crp sources
    │
    ▼
Lexer → Parser → Resolve → Type inference → Ownership → Regions → Errors
    │
    ▼
CIR (typed, ownership-resolved IR)
    │
    ▼
Rust emission  ──►  rustc  ──►  native binary
    │
    └── probe emit + rustc (§7.6 fallbacks when ownership disagrees)

Sealed crates (crisp.lock): a crate’s pub API has fully resolved signatures frozen at publish time. Downstream code analyzes against the lockfile, not re-inferred internals — the explicit tradeoff for whole-program inference inside a boundary.

Type vs ownership inference: HM-style unification handles types; ownership is a separate deterministic dataflow pass over the typed program. They are not unified — affine ownership does not compose with HM unification.

Comments: -- and nested {- -}. String interpolation: "hello {name}". Exponentiation: ** → .powf().

v1.9.0 — extern rust vec<float> / vec<int> (#153); OS prelude env_* / path_* / fs_write (#151); src/lib.crp emits Cargo [lib] (#152). v1.8.x language features remain.

Still open: crates.io republish (#66), repo visibility (#58); trait bounds / dyn Trait remain partial (#59). See ROADMAP.md.

MSRV: Rust 1.85 (rust-version in root Cargo.toml). CI runs Ubuntu + macOS on stable, plus an MSRV job.

Install the compiler from crates.io (puts crisp and reveal on your PATH via ~/.cargo/bin):

cargo install crisp-lang --locked
crisp --version

You still need a Rust toolchain (1.85+) with cargo / rustc — Crisp lowers to a Cargo project and builds with rustc.

mkdir -p hello/src && cd hello

cat > crisp.toml <<'EOF'
[package]
name = "hello"
version = "0.1.0"
edition = "2026"

[build]
target = "rust"
runtime = "tokio"
error_model = "enum"
EOF

cat > src/main.crp <<'EOF'
shape Named = {
    name: str
}

type Guest = {
    name: str = "world"
}

id(x: T) = x

greet(who: Named) = "hello {who.name}"

pub main() = {
    world := Guest {}
    print(id(greet(world)))
}
EOF

crisp run .

Expected output:

"hello world"

git clone https://github.com/jose-compu/crisp.git
cd crisp
# already installed via cargo install crisp-lang, or:
# cargo install --path crates/crpc --locked
crisp run examples/hello

Other commands on a project:

crisp check .                 # resolve + typecheck
crisp emit .                  # write Rust under target/rust/
crisp build .                 # emit + cargo build

Optional LSP:

cargo install crisp-lsp --locked

See QUICKSTART.md for project layout, modules, tests, and fallible functions. crates.io notes: docs/CRATES_IO.md (#66).

crates/          Rust compiler workspace (lexer → emit, crisp, lsp, reveal)
docs/            Spec, limitations, error catalog, web site scaffold
examples/        Sample .crp projects
std/             Standard library (Crisp prelude and modules)
tests/           Integration placeholders (fixtures live under crates/)

cargo build --release -p crisp-lang
cargo test --workspace --verbose
cargo fmt --all --check
cargo clippy --workspace -- -D warnings

See CONTRIBUTING.md. Spec conformance and e2e coverage live under crates/crisp-rust-emit/tests/ and crates/crpc/tests/.