Your results will only match this course if your tools match the ones the examples ran on. A different version can word a message differently, warn where yours stays quiet, or fail a step that passed here. Guessing about versions wastes evenings.
How do you know your tools are the ones this course was tested with?
Each tool below owns one job in the course loop. Learn the job first and the name sticks to it:
Icarus Verilog (`iverilog` and `vvp`) compiles and runs simulations. You write hardware in SystemVerilog, the language this course designs in, and Icarus turns it into a run you can check. The compiler is iverilog; the runtime that plays the compiled run is vvp.
Verilator lints and also simulates. To lint means to read code without running it and flag risky patterns. Verilator is strict, fast, and the course uses it as the second opinion on every design.
Yosys synthesizes. To synthesize means to translate your RTL, the register-transfer description of hardware, into gates from a real library. Yosys answers the question simulation cannot: what hardware did my code really describe?
Make runs the steps in order. A Makefile is a recipe file that names each step and its inputs. One make command then runs lint, simulation, and synthesis in the right order, every time.
Git saves history. You met Git in the previous lesson: it records versions, compares them, and undoes mistakes. The course keeps every example under Git so any run can be repeated from a known state.
GTKWave draws waveforms. A waveform is the picture of signals changing over time. GTKWave only matters from lesson 4.3 on, so install it now but expect to open it later.
Look at the six boxes below. Each box names one tool and its one-line job. The first five do the daily work; the sixth waits in the corner until waveforms arrive.
Install every tool through your system's package manager: Homebrew on macOS, apt on Ubuntu. Make and Git may already be present, so check before you install. The commands below are the ones this course used; package names are stable, but if a command fails, read its message and check the package manager's own documentation.
# macOS: install Homebrew first from https://brew.sh, then
brew install icarus-verilog verilator yosys git python
# GNU Make 3.81 ships with Apple's command line tools: xcode-select --install
# Ubuntu 24.04 (and Ubuntu inside WSL)
sudo apt update
sudo apt install -y iverilog verilator yosys make git python3 unzip gtkwaveTwo details. GTKWave is optional (every lesson shows its waveforms on the page); on macOS the Homebrew package for it has been discontinued, so use Ubuntu or WSL if you want the viewer. And Homebrew installs the newest release, which can be newer than the table below; that is normally fine, and the next lesson's check script tells you what you got.
On Windows, install WSL first, which means Windows Subsystem for Linux: open PowerShell as administrator, run wsl --install -d Ubuntu-24.04, restart when asked, open the Ubuntu app, and run the Ubuntu commands above inside it. Do all course work inside that Ubuntu shell. This path is described from Microsoft’s documentation and has not been tested for this course. Every command in this course assumes a Linux shell, and native Windows shells are out of scope.
The example project carries a script that checks the bench for you. Read it top to bottom before you run it:
#!/usr/bin/env bash
# Print the version of every tool the flow needs. Exit 1 if any is missing.
set -u
missing=0
check() { # name, command that prints a version on its first line
if command -v "$1" >/dev/null 2>&1; then
printf '%-10s %s\n' "$1" "$($2 2>&1 | head -n 1)"
else
printf '%-10s MISSING\n' "$1"; missing=1
fi
}
check iverilog "iverilog -V"
check vvp "vvp -V"
check verilator "verilator --version"
check yosys "yosys -V"
check make "make --version"
check git "git --version"
exit $missingThis listing is the checker: for each tool it shows the first version line, or MISSING, and it exits 1 when anything is missing.
The check helper takes a tool name and the version command for it. command -v asks whether the shell can find the tool at all. PATH is the list of folders your shell searches for programs, so a tool that is installed but not on PATH counts as missing here. The script ends with exit $missing, which hands back 0 when every tool answered and 1 otherwise. An exit status is the number a program returns when it finishes: 0 means success and anything else means failure.
# captured terminal output
$ bash scripts/check_tools.sh
iverilog Icarus Verilog version 13.0 (stable) (v13_0)
vvp Icarus Verilog runtime version 13.0 (stable) (v13_0)
verilator Verilator 5.048 2026-04-26 rev vUNKNOWN-built20260426
yosys Yosys 0.69+post (git sha1 143eb14f9cc55d6f8927e68523b0c9d2166ed02c, Release, AppleClang clang++ 21.0.0.21000101)
make GNU Make 3.81
git git version 2.54.0 (Apple Git-157)This output came from Icarus Verilog 13.0 on macOS. Read it line by line against the script.
Each row pairs a tool with the first line of its own version report. iverilog and vvp are the two halves of Icarus, compiler and runtime, and they report the same version, 13.0. Verilator answers 5.048, Yosys answers 0.69+post, Make answers 3.81, and Git answers 2.54.0. No row says MISSING, so the script exits 0. GTKWave has no row because the script cannot ask a window program for a version line; install it and open it once instead.
Only the rows for tools that live inside /usr/bin or /bin still report. On that Mac those are Make and Git, so four rows turn to MISSING and the exit status becomes 1. The point of the exercise: a tool can be installed and still invisible when PATH does not include it.
The same script runs with a stripped PATH, so most tools cannot be found even though nothing was uninstalled:
# captured terminal output
$ PATH=/usr/bin:/bin bash scripts/check_tools.sh
iverilog MISSING
vvp MISSING
verilator MISSING
yosys MISSING
make GNU Make 3.81
git git version 2.54.0 (Apple Git-157)
[exit status 1]This output came from the same Mac with PATH narrowed to /usr/bin:/bin. Compare it row by row with the report above.
Four rows now read MISSING: iverilog, vvp, verilator, and yosys. Make and Git still answer because on that machine they live inside the narrowed PATH. The last line is the verdict: exit status 1, so any step chained after this check stops here. The fix is not to reinstall anything. Restore the normal PATH, or open a fresh shell, and run the script again until the exit status is 0.
# captured terminal output
$ bash scripts/check_tools.sh
iverilog Icarus Verilog version 12.0 (stable) ()
vvp Icarus Verilog runtime version 12.0 (stable) ()
verilator Verilator 5.020 2024-01-01 rev (Debian 5.020-1)
yosys Yosys 0.33 (git sha1 2584903a060)
make GNU Make 4.3
git git version 2.43.0This output came from Ubuntu 24.04 inside a container, from the same command as above. Read the versions, not just the tool names.
Every tool answers, so the bench is complete and the exit status is 0. But each version is older than its macOS twin: Icarus 12.0 against 13.0, Verilator 5.020 against 5.048, Yosys 0.33 against 0.69, Make 4.3 against 3.81, Git 2.43.0 against 2.54.0. The same project passes on both benches, measured on 2026-10-21, so older does not mean broken here. Match the tested set for your platform instead of chasing the newest release.
Every version below is measured on its platform on 2026-10-21. Compare your own report against your platform's row:
Platform | Icarus | Verilator | Yosys | Make | Git |
|---|---|---|---|---|---|
macOS (Homebrew) | 13.0 | 5.048 | 0.69+post | 3.81 | 2.54.0 |
Ubuntu 24.04 (apt) | 12.0 | 5.020 | 0.33 | 4.3 | 2.43.0 |
Not yet tested, so expect no promises there:
x86-64 Linux, the architecture most CI runners use.
Windows with WSL.
The GTKWave version, on any platform.
The CI workflow itself.
Reading an older version's message as a different problem. Ubuntu's older tools word some messages slightly differently than the transcripts in this course. When a message puzzles you, compare your versions against the table above before assuming your code differs.
Installing a tool but not putting it on PATH. Package managers usually wire this up, but a manual install can leave the program where the shell never looks. The symptom is a MISSING row for a tool you just installed; the fix is to add its folder to PATH and rerun the script until the exit status is 0.
Rule: run the checker yourself, and trust only a report that exits 0.
Install the two missing tools through your package manager, then rerun the script. Repeat until every row shows a version and the exit status is 0. Do not skip ahead to simulation with a partial bench: later lessons assume every tool answers.
No. The Ubuntu row of the table is a tested configuration, and the same project passes on both platforms, measured on 2026-10-21. Install the version your package manager carries, confirm it matches your platform's row, and spend the saved evening on the design loop instead.
make --version answers, but the script still says MISSING for iverilog right after you installed it. What happened, and what is the first thing to try?The tool is installed but not on PATH, so the shell cannot find it. Open a fresh shell first, because installers often update PATH only for new shells, then rerun the script. If the row is still MISSING, find where the installer put the program and add that folder to PATH.
Six tools form the bench: Icarus simulates, Verilator lints and simulates, Yosys synthesizes, Make orders the steps, Git saves history, GTKWave draws waveforms.
check_tools.sh prints each tool's version line and exits 1 when anything is missing, including tools hidden by a broken PATH.
The same project passes on the tested macOS and Ubuntu 24.04 versions, measured on 2026-10-21, so match your platform's row instead of chasing newest.