GHDL: a real compiler for VHDL, not an interpreter pretending to be one
VHDL 2008/93/87 simulator
At a glance
- What is it?
- The open-source analyzer, simulator and experimental synthesizer for VHDL, backed by LLVM, GCC or a built-in x86_64/i386 code generator, and wired into Yosys, cocotb, ngspice and the usual VHDL verification libraries.
- Who is it for?
- GHDL earns its position because it treats VHDL as a compiled language. Full coverage of the 1987, 1993 and 2002 IEEE 1076 revisions, partial coverage of 2008 and 2019, native machine code through LLVM, GCC or a built-in x86_64/i386 generator, and a waveform path that emits GHW, VCD or FST.
- Can I use it commercially?
- Yes, with conditions. GPL-2.0 is a copyleft licence: if you distribute software that includes it, you must release that software's source code under the same licence. Running it internally without distributing it does not trigger that obligation.
- Is it still maintained?
- Yes. The repository last received commits 3 days ago.
- What is it written in?
- Mainly VHDL, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 21, 2026, and from our analysis. They are not legal advice.
Star history
- ghdl/ghdl2,931 ★ · +32
| Repository | 2026-10-07 | 2026-11-21 |
|---|---|---|
| ghdl/ghdl | 2.9k | 2.9k |
32 Stars in the last 45 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Why the compiler framing matters more than the simulator framing
The README's opening paragraph makes a point that is unusual for a simulator to insist on: GHDL is not an interpreter. It allows you to analyse and elaborate sources for generating machine code from your design, and native program execution is the only way for high-speed simulation. That is a performance argument dressed as a clarification, and it is the reason the project bothers with multiple code generators at all.
The consequence is that GHDL behaves like a compiler in the ways that matter for a large design. Analysis and elaboration are separate steps from execution. The README cites leon3/grlib as an example of the very large designs it can handle.
The repository tree supports this framing. There is a `src/` directory, a `configure` script, `Makefile.in`, a `build.rs` and a `ghdl.gpr.in` template, which is the shape of a project built from source on several platforms rather than a Python package with a native extension. The repository also has a `Cargo.toml`, though it declares no dependencies.
So the honest summary is that GHDL is a compiler that ships a simulator, rather than a simulator that happens to compile things. Everything else follows from which of those two it is.
Which VHDL revisions are actually covered
The support statement is precise and worth reading exactly. GHDL has full support for the 1987, 1993 and 2002 versions of the IEEE 1076 VHDL standard, and partial support for the 2008 and 2019 revisions.
That distribution is not arbitrary. VHDL-93 and VHDL-2000 are the revisions that ASIC and FPGA toolchains converged on, and a large body of existing IP is written against them. The 2008 revision added a substantial set of features, and partial coverage of 2019 on top of it means the newest language constructs are the ones you may have to work around.
Partial support of PSL, the Property Specification Language, sits alongside this. PSL matters for formal verification and assertion-based checking, so a team migrating from a commercial simulator with heavy PSL assertions may find the gap.
None of this is a criticism of the project. Full coverage of a language revision that keeps gaining features, across several code generators and architectures, is a large amount of work. It is simply the constraint that determines whether a given design will compile on the first try, and the only way to find out for a specific design is to point the analyzer at it.
Four backends and seven kinds of release asset
Backend choice is a real decision here. The README describes the generator set as LLVM, GCC, or, for x86_64 and i386 only, a built-in one, and says that using a code generator makes it much faster than any interpreted simulator.
The README lists the ways to get prebuilt GHDL: the default package manager on most major Linux distributions (Debian/Ubuntu, Fedora, Arch Linux, Guix), MSYS2 and WinGet; nightly tarballs/zipfiles for Ubuntu and Windows (MSYS2), updated after each successful CI run; and Docker images from ghdl/docker.
Architecturally the README claims GNU/Linux, Windows and macOS, across x86, x86_64, armv6, armv7, aarch32, aarch64 and ppc64. Getting GHDL is a matter of downloading a nightly asset, pulling an OCI image for Docker or Podman, or building from source. One inconsistency is worth flagging: the `Cargo.toml` in the repository root still declares version 5.0.0-dev, while the latest versioned release is v6.0.0. The crate manifest is not the authority on the current version.
Waveform output and the testbench libraries it plugs into
Simulation output is not the bottleneck for most VHDL work, and GHDL treats it that way. It writes waveforms to GHW, its own format, to VCD, or to FST. Paired with a GUI-based waveform viewer and a decent editor, the README calls this a very powerful setup for writing, testing and simulating code.
Co-simulation with foreign applications goes through the Verilog Procedural Interface, or VPI, and VHPIDIRECT, which GHDL describes as supporting either mechanism. That is the hook for co-simulation with foreign applications. The README points to a separate ghdl-cosim documentation site for the details.
The verification integrations are where a modern team spends most of its time. OSVVM, UVVM and VUnit are named as supported frameworks, and the README attributes to them constrained random verification, functional coverage and automated regression testing. cocotb gets its own paragraph: it is a coroutine-based co-simulation framework that allows Python-driven testing of VHDL designs.
For Python integration inside the project itself there is `pyGHDL/`, and the `pyproject.toml` shows how seriously it is taken. It builds with setuptools and pyTooling, runs mypy in strict mode with python_version 3.15, formats with black at a 120-character line length, and treats any DeprecationWarning as an error in the pytest configuration. The `setup.py` header carries the GPL notice and an SPDX identifier of GPL-2.0-or-later.
From simulation to synthesis, and where it stops
The README describes GHDL as an analyzer, compiler, simulator and experimental synthesizer. That word experimental is load-bearing and should be read literally.
What synthesis does exist is specific. GHDL can synthesize arbitrarily complex VHDL designs into a VHDL 1993 netlist, which can then be used implicitly or explicitly in open-source or vendor synthesis frameworks. So GHDL is a front end that produces a netlist, not a place-mapping or timing tool. The output language being VHDL 1993 rather than something like Verilog tells you how conservative that path is.
The realistic way to use synthesis is through Yosys. The ghdl-yosys-plugin lets GHDL act as a front-end for Yosys, which the README describes as one of the key integrations, enabling VHDL designs to be synthesized directly and letting you move from simulation to synthesis without leaving the GHDL environment.
For mixed-signal work the README notes that ngspice supports device models with behaviour defined by VHDL code, using GHDL. That is a narrower integration than the Yosys one, but it is the one you need if your design has analog behaviour in it.
The honest evaluation of the synthesis story is that it exists and is used, but simulation is what this project is good at. Treat synthesis as a path that requires the Yosys plugin and a real integration effort, not as a feature you switch on.
Licensing, governance signals and what the project does not claim
GHDL's licence is GPL-2.0, stated in the repository description and covered by `COPYING.md` at the root. The documentation is covered by a separate licence file, doc/COPYING_DOC.md, and the README adds that some of the runtime libraries carry different terms, so the licence file of an individual source file is what governs if you are shipping a binary. GPL obligations on a tool you use to produce hardware designs are a different question from GPL obligations on software you distribute, and the README does not attempt to answer that, so nobody should take this paragraph as legal advice.
The repository carries badges worth noticing. There is a CII Best Practices badge linking to the Linux Foundation's project entry, There is also a Test workflow on GitHub Actions and a separate AppVeyor project. The last push was on 2026-11-02, so development is current.
The 340 open issues are the number most likely to make a newcomer hesitate, and for a project of this age and scope it is unremarkable. The more useful signal is the release pattern: version 6.0.0 shipped on 2026-03-07, with a release candidate earlier the same day, and a nightly release continues past that. A project shipping regular versioned releases plus nightly artifacts is doing version management deliberately.
The README describes VHDL 2008 and 2019 support as partial, and the partial PSL support means assertion-heavy verification flows are worth scoping carefully before you commit.
Editorial conclusion
GHDL earns its position because it treats VHDL as a compiled language. Full coverage of the 1987, 1993 and 2002 IEEE 1076 revisions, partial coverage of 2008 and 2019, native machine code through LLVM, GCC or a built-in x86_64/i386 generator, and a waveform path that emits GHW, VCD or FST. Two limits are worth pricing in before you commit. VHDL 2008 and 2019 features are partial, so a design written against the newest revision may need trimming, and synthesis is labelled experimental in the README itself, with output limited to a VHDL 1993 netlist for downstream tools. For Python-driven testbenches start with cocotb or pyGHDL, for synthesis start with the ghdl-yosys-plugin, and for the language questions the README leaves open, ghdl.github.io/ghdl is where the reference lives.
Frequently asked questions
What language standard versions does GHDL support?
Full support for the 1987, 1993 and 2002 versions of the IEEE 1076 VHDL standard, and partial support for the 2008 and 2019 revisions. PSL, the Property Specification Language, is also partially supported, which matters if your verification flow relies on assertions or formal properties.
Which code generation backends can GHDL be built with?
The README names LLVM, GCC and, for x86_64 and i386 only, a built-in code generator.
How do I get GHDL binaries for my platform?
The README lists package managers on most major Linux distributions, MSYS2 and WinGet; nightly tarballs/zipfiles for Ubuntu and Windows (MSYS2) from the GitHub releases page; and OCI/Docker images from ghdl/docker. You can also build from source, and the repository has a `configure` script and `Makefile.in`.
Can GHDL write testbenches in Python?
Through cocotb, which the README describes as a coroutine-based co-simulation framework allowing Python-driven testing of VHDL designs with real-time interaction. Co-simulation with foreign applications also works through the Verilog Procedural Interface or VHPIDIRECT, and the project ships a pyGHDL binding for Python-side integration.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/ghdl-ghdl)Star history chart for your README
[](https://hysenlabs.com/projects/ghdl-ghdl)Was this useful?