Rust builds that never do the same work twice.
A blazing-fast, Cargo-compatible build system and package manager for Rust.
Drop it into any existing Cargo workspace — zero migration, zero lock-in.
curl -fsSL https://runepm.com/install.sh | shIgel compiles your existing Rust projects directly with rustc while persisting every compiled crate into a shared, content-addressable store. Whether you switch branches, pull an older commit, spin up a secondary worktree, or spin up a fresh CI agent, artifacts built anywhere on your system are restored in milliseconds instead of compiled from scratch.
$ igl build
▸ resolved 249 packages (0.21s)
⠹ building ━━━━━━━━━━━━━━━╾───────── 147/197 regex-syntax, tokio, serde_derive +3
✓ dev · 12 compiled · 185 cached · 4.81s
| Benchmark on Igel Workspace (249 packages) | Igel | Cargo | Speedup |
|---|---|---|---|
No-op build (build) |
53 ms | 225 ms | 4.2× faster |
No-op check (check) |
64 ms | 234 ms | 3.6× faster |
No-op test prep (test --no-run) |
56 ms | 272 ms | 4.8× faster |
Dependency tree inspection (tree) |
9 ms | 184 ms | 20.4× faster |
| Full clean build from scratch | 112.5 s | 122.8 s | Faster |
| Fresh machine with shared cache | 0.65 s | Full rebuild (84s+) | 129× faster |
Across a generated 25-crate benchmark workspace, igel-bench clocks fresh checkouts at 108× Cargo's speed, branch switching at 34×, and test executions at 9×. Cold builds and single-file incremental edits remain on par because both run rustc — but everywhere else, Igel removes the waiting.
You can verify these figures on your own codebase anytime:
igel-bench run --project path/to/your/project- Compile once, share everywhere: Every compilation unit is keyed by its exact cryptographic inputs — compiler binary, flags, enabled features, target architecture, dependencies, and environment variables. Same inputs yield the exact same artifact across every workspace on your machine.
- Free
checkafterbuild: Type-checking seamlessly reuses the artifacts produced by full builds. - Whole-machine saturation: Compilation units schedule as soon as upstream metadata exists. Build scripts execute concurrently with independent dependency compilations, critical paths take priority, and dynamic memory tracking prevents system thrashing.
- Pipelined execution: Test binaries run the moment their code links — you don't wait for the entire workspace to finish building before your first test executes.
- Live progress: Real-time terminal dashboard tracking active binaries, completed suites, pass/fail counters, and run durations.
- Predictable concurrency: Test binaries run sequentially by default to protect shared resources like ports and test databases, while individual tests run in parallel. Parallel binary execution is easily enabled with
--test-jobs. - Laser-focused failure loops:
igl test --failedre-runs only the tests that failed previously until everything passes green. - Enterprise-ready features: Native test timeouts, automatic retries with flaky-test detection, JUnit XML generation, cached test outputs (
--cached: drops no-op runs from 8s to 0.26s), nextest-compatible test batching, and integrated code coverage viaigl coverage.
- Global cache sharing: Connect workstations and CI runners via shared network directories or dedicated Cairn cache servers. A developer checking out a fresh repo can restore an entire workspace in under a second.
- Hermetic cache bundles: Export and import self-contained, portable cache archives (
igl cas export/import) that stay lean instead of ballooning like persistenttarget/directories. - Intelligent change detection:
igl affected --since origin/maincalculates the exact set of affected packages across your workspace for efficient parallel CI matrix sharding.
- Sandboxed build execution: Constrain build scripts and procedural macros with strict filesystem and network isolation (
build.sandbox = true). - Continuous vulnerability auditing:
igl auditscans your locked dependency graph against the RustSec Advisory Database with clear remediation guidance. - Complete visibility: Generate standard CycloneDX and SPDX Software Bills of Materials (SBOMs), inspect execution attack surfaces with
igl tree --exec-surface, and quarantine fresh packages usingresolve.min-release-age.
No need to juggle a dozen external Cargo plugins. Igel includes built-in commands for cross-compilation (igl cross, igl build --cross <target>: on this machine when it can, in a warm container when it can't), outdated, upgrade, unused, watch, single-file script runners with embedded dependencies, explain (root-cause cache invalidation analysis), doctor (diagnostic recommendations), interactive timelines, dependency graphs, install, publish, and vendor — while maintaining full compatibility with all existing cargo-* subcommands.
curl -fsSL https://runepm.com/install.sh | shirm https://runepm.com/install.ps1 | iexThe installer verifies SHA-256 release checksums and places igl into ~/.igel/bin. Igel requires an active Rust toolchain (rustup). Keep your installation updated with igl self update.
For package managers, custom directories, and shell completions, check the Installation Guide.
Igel works immediately inside any existing Cargo project:
igl build # Compile the project (alias: igl b)
igl test # Run unit, integration, and doc tests
igl run -- --arg value # Build and execute your binary
igl check # Fast type-checking with build-cache reuse
igl add serde -F derive # Add a dependency with features
igl watch -x test # Auto-retest on every file modification
igl doctor # Inspect your environment for performance bottlenecksBecause Igel mirrors Cargo's CLI surface and manifest format, your codebase stays 100% compatible with standard cargo. Igel writes standard Cargo.lock files, reads .cargo/config.toml, and never pollutes your repository.
Igel supports the full breadth of the Rust ecosystem:
- Multi-member workspaces and inheritance
- Target-specific dependencies and platform configurations
- Advanced build scripts and procedural macros
- Native C/C++ bindings (
cc,bindgen,cxx,pyo3) - Alternative registries, sparse indexes, and vendor directories
[patch]and[replace]directives- Cross-compilation targets and custom profiles
- Standard toolchain files (
rust-toolchain.toml) andrust-analyzer
See the full Compatibility Reference for detailed platform coverage.
| Guide | Description |
|---|---|
| Installation | Install options, shell completions, and environment paths |
| Getting Started | First steps, workflow setup, and everyday commands |
| CLI Commands | Complete CLI reference, selection flags, and interactive pager |
| Testing & Coverage | Test runner, failure isolation, flaky retries, and coverage reports |
| Caching Deep Dive | Cache key mechanics, invalidation rules, and CAS management |
| CI & Remote Caching | Remote stores, Cairn servers, cache bundles, and matrix sharding |
| Configuration | Workspace and global settings via Igel.toml and CLI flags |
| Supply Chain Security | Sandboxing, advisory audits, and SBOM export |
| Cross-Compilation | igl cross and --cross: other targets, here or in warm containers |
| Performance Guide | Resource management, concurrency, and bottleneck diagnosis |
| hyprlnk Linker | Integrated next-generation linker for Linux, macOS, and Windows |
| rustc-runified | Advanced compiler driver for early linking and parallel frontends |
| Complete Docs Index | Overview of all topics, manifests, scripts, and architecture |
Igel 2027.0 is the first stable release line, tested against hundreds of real-world crates and validated across Linux, macOS, and Windows. Check out the Roadmap and Changelog to see where we're headed.
Licensed under either the Apache License, Version 2.0 or the MIT License, at your option.