Hugging Face's logo

Datasets:
lumees
/
hdl-corpus

Size:
10M<n<100M
Tags:
verilog
systemverilog
vhdl
hdl
rtl
eda
License:
Dataset card Files
xet
 Community

Request access

This repository is publicly accessible, but you have to accept the conditions to access its files and content.

This dataset is a collection of publicly hosted GitHub repositories, assembled by Lumees Lab to test our hardware-lint tool and for internal research. It is not a licensed redistribution of its source repositories: 82% of the repositories carry no license of any kind, and the remainder keep whatever license their own author chose (see the license column of the repos and files tables). Access is manually reviewed, and granted only for non-commercial research, lint-tool benchmarking, and evaluation, on these conditions:

  • You will not use this data, in whole or in part, to train, fine-tune, or
    distill any AI/ML model.
  • You will treat the absence of a license as "no rights granted," not as
    public domain, and you will not redistribute files from a repository whose
    license is empty beyond what GitHub's own Terms of Service already permit.
  • You will keep the per-file full_name / path intact if you share derived
    results, so provenance back to the original repository is never lost.
  • If you are the rights holder of an included repository and want it removed,
    open a discussion on this dataset or contact the email on the Lumees Lab
    organization page.

Log in or Sign Up to review the conditions and access this dataset content.

HDL Corpus — Verilog / SystemVerilog / VHDL

A collection of 284,177 public GitHub repositories written in Verilog, SystemVerilog or VHDL, filtered down to the files relevant to hardware design and verification: RTL source, testbenches (UVM, plain SV/V/VHDL, cocotb, VUnit), golden/reference models, vendor IP configuration, the data files those sources read at simulation time, and each project's own documentation and build scripts.

It was built for two purposes: a test corpus for Lumees Lab's HDL lint tool, and a source corpus for internal model research. It is not licensed for AI training by anyone who requests access — see Licensing and usage below.

Why this exists

Lint tools and language-model training both need large, realistic bodies of real-world HDL, not synthetic examples. GitHub is the largest public source of that, but a raw clone of "every Verilog repository" is mostly dead weight: synthesized netlists, vendor tool caches, waveforms, IDE metadata. This dataset keeps the files that carry design intent and drops the rest, while recording why each dropped file was dropped, so the filtering can be audited and refined later.

How it was collected

  1. Enumeration. GitHub's search API was walked in date-bisected windows (its search endpoint caps results at 1,000 per query) for language:Verilog, language:SystemVerilog and language:VHDL, collecting every public, non-fork repository and its metadata.
  2. Selective fetch. Each repository's default branch was cloned with git clone --filter=blob:none (blobless, so the full file tree costs only a few hundred KB), then a sparse checkout pulled the contents of only the files that might be kept — by extension and name, minus known vendor-generated directories (Vivado .runs/.cache/.srcs/**/ip, Quartus databases, IP-user-files, Platform Designer submodules, Eclipse .metadata, …). This downloaded roughly 20% of each repository's bytes instead of 100%.
  3. Filtering and classification. Every candidate file was read once and sorted into a category (see below) or marked as dropped, with a reason: generated, netlist, binary, too large (>5 MB for HDL, >1 MB otherwise), a Git LFS pointer, a symlink, a submodule, or simply not a file type this dataset wants. Synthesized gate-level netlists are detected by filename convention and by port- connection density for files too large to be plausible hand-written RTL. Vendor IP configuration (.xci, .qip, .qsys, IP-XACT component.xml) and the tiny port-only "stub" files Vivado writes for each IP block survive the generated-folder drop, deduplicated by content hash, because a lint tool needs them to resolve IP instances. Files that kept HDL names in $readmemh/$readmemb, `include, or file-open calls (memory images, test vectors) were fetched too, even where they lived outside the normal source tree.
  4. Conversion. The kept files were turned into the Parquet tables described below and uploaded shard by shard; the raw per-repository files were deleted from the build machine as each shard was confirmed uploaded, so building this dataset never needed to hold more than ~1 GB of raw text on disk at once.

Full detail, including the exact regular expressions used for classification, is in the pipeline scripts referenced in Reproducing / auditing.

Categories

Every kept file in the files table carries one category:

Category What it is
rtl Synthesizable design source (Verilog/SystemVerilog/VHDL, not matched as a testbench)
tb Testbenches: UVM, plain self-checking Verilog/VHDL, VUnit, Verilator C++
cocotb cocotb/pyuvm Python testbenches and their helper modules
golden Reference/golden models: C/C++ DPI, SystemC, Python, MATLAB
ip Vendor IP configuration and port stubs (.xci, .qip, .qsys, IP-XACT, *_stub.v)
data Memory images, test vectors and include files that kept HDL names at simulation time
info READMEs, licenses, build scripts, filelists, constraints, lint configs/waivers, vendor project files

tags adds detail within a category, e.g. uvm, ral (UVM register layer), vhdl/sv/v, verilator, systemc, dpi, pyuvm, vunit, stub, readmem/fopen/include/literal (how a data file was referenced), lint/project (which kind of info file).

The table below is measured on a 1,000-repository random sample taken before the full run (the full run's exact per-category counts are in the manifest table, which records every file GitHub had — kept or not — with its category or drop reason):

Category Share of kept files Share of kept bytes
rtl ~45% ~55%
info ~32% ~13%
tb ~13% ~11%
ip ~6% ~14%
data ~1% ~7%
golden <1% <1%
cocotb <1% <1%

Dataset structure

Three tables ("configs" in Hugging Face datasets terms), each loadable on its own:

from datasets import load_dataset

files    = load_dataset("lumees/hdl-corpus", "files",    split="train")  # the content
manifest = load_dataset("lumees/hdl-corpus", "manifest", split="train")  # every file, kept or not
repos    = load_dataset("lumees/hdl-corpus", "repos",    split="train")  # one row per repository

files — the dataset itself, one row per kept file

Column Type Meaning
repo_id int64 GitHub repository id; joins to repos.repo_id and manifest.repo_id
full_name string owner/repo
license string SPDX id GitHub detected for the whole repository, or null — read this before using the row
path string File's path inside the repository, exactly as on GitHub
category string One of the categories above
tags list<string> Extra classification detail, see above
size int64 File size in bytes, as fetched
oid string Git blob id (content hash) — identical across repos for identical files
sha256 string SHA-256 of the file content
content string The file's text, UTF-8 decoded with errors="replace" for the rare non-UTF-8 byte

manifest — every file GitHub had for this repository, kept or not

Lets you recover the full project structure, including what was deliberately left out and why, without re-cloning anything.

Column Type Meaning
repo_id int64 Joins to repos.repo_id
path string File path
oid string Git blob id
kept bool Whether this file made it into files
size int64 or null Only measured for files that were read (null for generated/not-selected paths, since fetching them was skipped entirely)
category string or null Set when kept is true
tags list<string> or null Set when kept is true
reason string or null Set when kept is false: generated, netlist, not_selected, too_large, binary, symlink, submodule, lfs_pointer, fetch_missing, duplicate, read_error
referenced_by list<string> or null For category=data rows: which HDL files named this one
duplicate_of string or null For reason=duplicate rows: the path of the IP-config file this one is an exact copy of

repos — one row per repository

Column Type Meaning
repo_id, full_name, owner, name Identity
language string GitHub's primary-language detection at enumeration time
stars, forks, size_kb int64 GitHub repository stats
license string or null SPDX id, or null if GitHub detected none
topics list<string> Repository topics
default_branch string Branch that was fetched
is_fork, archived bool
created_at, updated_at, pushed_at string ISO timestamps from GitHub
description, homepage, html_url string
commit_sha, fetched_branch string Exact commit this snapshot was taken at
files_total, files_kept, bytes_kept int64 Per-repository totals, matching manifest/files
fetched_at string When this repository was fetched

Licensing and usage

This is not a cleanly licensed dataset. It is a research snapshot of public GitHub repositories, most of which (82%, by repository count) have no license at all. GitHub's Terms of Service let anyone view and fork a public repository; they do not grant a license to reuse its contents, and a missing license is not the same as public domain.

Because of that:

  • Access is gated and manually reviewed, not automatic.
  • No AI training. Whoever is granted access agrees not to use this data, in whole or in part, to train, fine-tune, or distill any AI/ML model. This dataset exists for hardware-lint-tool testing and for research reading, not for redistribution into model weights.
  • Check the license column before reusing any file's content beyond that research use. A null license means the repository's author granted no rights beyond what GitHub's platform features (viewing, forking) already provide.
  • Takedown. If you are the author or rights holder of an included repository and want it removed from this dataset, open a discussion here or contact Lumees Lab. Repositories are tracked by repo_id, so a specific removal is quick to action.

Known gaps

  • Sizes aren't recorded for most dropped files. manifest.size is null for generated and not_selected rows, because computing it would have meant downloading them — the whole point of the sparse-checkout approach.
  • data references are resolved heuristically. Only file names written as string literals in the HDL are followed; names built at simulation run time ($sformatf, concatenation) can't be. An ambiguous bare name is matched first next to the file that referenced it, then by trailing path anywhere in the repository; a name matching more than 20 files in a repository is skipped rather than guessed.
  • No cross-repository deduplication yet. Many repositories are copies of the same course assignment or the same open core. files.oid and files.sha256 are exact content hashes, so exact duplicates across repositories can be found from the data as published, but that pass hasn't been run yet.
  • No commit history. Each repository is a single snapshot at commit_sha. Bug-fix commit pairs (a real defect, and the commit that fixed it) would be valuable supervised data for the lint tool specifically, and are a planned follow-up, not included here.
  • ~580 repositories created after the enumeration finished (3 Oct 2026) are not included, nor are any repositories deleted or made private between enumeration and fetching (98 repositories, recorded as such in the pipeline's own log, not in this dataset).

Reproducing / auditing

The collection and conversion pipeline (enumeration, filtering rules, fetcher, and the script that built these Parquet shards) is plain Python, kept alongside this dataset's source tree at Lumees Lab, and can be made available on request for anyone who wants to audit the exact filtering and classification logic rather than take this card's word for it.
Downloads last month
-
Total file size:
35.7 MB