Installation

Jacquard is three tools; install only what your task needs:

Availability. The prebuilt-binary, Homebrew, and PyPI channels go live with the first tagged release (v0.1.0). Until then, build the simulator from source and run netlist-graph from the repo with uv run. The design behind this layout is ADR 0018.

The simulator (jacquard + opensta-to-ir)

Homebrew — macOS / Apple Silicon (Metal)

brew install gpu-eda/tap/jacquard      # installs jacquard + opensta-to-ir

The cleanest path on a Mac. Requires an Apple Silicon machine with a Metal GPU. The Homebrew formula is built with --features synth, so behavioral RTL input works out of the box — see Accepted RTL surface.

To try a release candidate before it ships, install from the prerelease tap instead (it tracks the latest -rc tag):

brew install gpu-eda/tap-prerelease/jacquard

cargo binstall — prebuilt binary, no toolchain build

brew install llvm     # runtime dependency — see note below
cargo binstall --git https://github.com/gpu-eda/Jacquard jacquard-sim \
  --disable-strategies compile,quick-install

Installs the jacquard binary (+ timing_analysis) on macOS/Metal. The crate is the jacquard-sim package (the binary it installs is still jacquard); the --git form is required because it's not on crates.io (its dependencies are a vendored fork carrying in-flight patches), so binstall reads the [package.metadata.binstall] pkg-url straight from the repo.

Why jacquard-sim, not jacquard. The package is named jacquard-sim because the crate name jacquard is taken on crates.io by an unrelated project (an AT-Protocol client library) — so cargo install jacquard would build that, not this. Naming our package jacquard-sim makes resolution unambiguous. --disable-strategies compile,quick-install is kept as belt-and-suspenders: it turns a missing prebuilt binary into a clean hard error rather than any source-build fallback. (validate-install.yml uses the same guard.) Linux is not binstall-able: there are two GPU backends (CUDA, HIP) for one target triple, so it can't be auto-selected — use the release tarball for your backend, a container, or build from source.

Release binaries are built with --features synth and support behavioral RTL input directly.

Runtime dependency — Homebrew LLVM. The prebuilt macOS binary links Homebrew LLVM's libc++ and libomp (the build uses LLVM clang for OpenMP, via the mt-kahypar partitioner), so it needs brew install llvm to run. The Homebrew install handles this automatically (depends_on "llvm"); binstall and the raw tarball do not, so install LLVM first.

Prebuilt release tarball

Download jacquard-<version>-<target>.tar.gz from the releases page, extract, and put jacquard, timing_analysis, and opensta-to-ir on your PATH. The GPU kernel is embedded, but the binary still needs Homebrew LLVM at runtime (brew install llvm) — see the note above.

From source (any backend)

The portable path, and the only one for Linux CUDA / HIP today. Needs the Rust toolchain and the GPU SDK for your backend.

git clone https://github.com/gpu-eda/Jacquard.git
cd Jacquard
git submodule update --init --recursive

cargo build -r --features metal --bin jacquard         # macOS / Apple Silicon
cargo build -r --features cuda  --bin jacquard         # NVIDIA (CUDA toolkit)
cargo build -r --features hip   --bin jacquard         # AMD (ROCm)

The binary lands at target/release/jacquard. See the README's Dependencies table for optional tooling (flatc, mdbook, OpenSTA).

Behavioral RTL on-ramp (jacquard sim design.v …) requires the synth feature (embedded YoWASP Yosys engine). Add it to your build:

cargo build -r --features metal,synth --bin jacquard   # macOS + RTL synthesis
cargo build -r --features cuda,synth  --bin jacquard   # NVIDIA + RTL synthesis
cargo build -r --features hip,synth   --bin jacquard   # AMD + RTL synthesis

A binary built without synth still simulates pre-synthesized gate-level netlists; it gives an actionable error if handed behavioral RTL.

Providing yosys.wasm for RTL synthesis — the synth engine needs the YoWASP Yosys wasm module. Discovery order:

1. --yosys-wasm <path> flag on sim/cosim (overrides the rest).
2. JACQUARD_YOSYS_WASM=/path/to/yosys.wasm environment variable.
3. Installed yowasp-yosys Python package, found automatically:

   pip install yowasp-yosys
   

4. Fetch-from-release is a planned follow-up (not yet implemented).

Prebuilt and Homebrew binaries include the synth feature; the wasm is still found via the flag, env var, or installed Python package until auto-fetch ships.

The signal-analysis companion (netlist-graph)

Pure Python — install from PyPI, no GPU or Rust needed:

uvx netlist-graph search design.gv psel     # one-off, no install
pip install netlist-graph                    # or install it

From a Jacquard checkout you can also run it without installing: uv run netlist-graph … (it's a workspace member). See signal tracing for what it's used for.

The timing path (opensta-to-ir + a PDK)

For post-PnR timing simulation you also need PDK Liberty files, fetched with volare/ciel (pinned in the root pyproject.toml). opensta-to-ir converts SDF to the Jacquard timing IR (.jtir) that jacquard sim --timing-ir / cosim --timing-ir consume. Pure functional (pre-PnR) runs need none of this — see signal tracing § pre-PnR functional runs.

Verify

jacquard --version
# A quick self-contained cosim (from a Jacquard checkout):
jacquard cosim tests/apb_trace/apb_trace_synth.gv \
    --config tests/apb_trace/sim_config.json \
    --top-module apb_trace --max-clock-edges 200 \
    --bus-trace-csv /tmp/apb.csv

Then head to Getting Started to run bundled designs, Accepted RTL surface to simulate your own behavioral RTL, or Synthesis Flow to prepare a high-QoR gate-level netlist.