---
pretty_name: SyzPilot Dataset
license: cc-by-4.0
language:
- code
size_categories:
- 1M<n<10M
tags:
- syzkaller
- linux-kernel
- fuzzing
- program-analysis
- code
configs:
- config_name: default
  data_files:
  - split: train
    path: data/train-*.parquet
---

# SyzPilot Dataset

The SyzPilot Dataset contains 2,236,878 programs generated by the
[syzkaller](https://github.com/google/syzkaller) kernel fuzzer and the kernel
coverage trace paired with each program. It is the corpus used to train the
tokenizer and continue pretraining for
[SyzEncoder](https://huggingface.co/zzra1n/SyzEncoder).

The original corpus consists of 4,473,756 small files split between
`programs/` and `coverages/`. This release pairs those files by ID and stores
them in 448 Parquet shards. No program or coverage text was cleaned or
normalized during packaging.

## Dataset structure

The repository has one `train` split containing the full corpus. It does not
define a canonical validation or test set.

| Field | Type | Description |
| --- | --- | --- |
| `id` | string | The 40-character ID used as the filename in the original corpus. |
| `program` | string | Complete syz program text. |
| `coverage` | string | Newline-separated hexadecimal kernel coverage addresses. |
| `program_size_bytes` | int32 | Size of the original program file. |
| `coverage_size_bytes` | int32 | Size of the original coverage file. |
| `coverage_count` | int32 | Number of addresses in `coverage`. |

The rows are sorted lexicographically by `id` across all shards. The text
columns preserve the original UTF-8 program bytes and ASCII coverage bytes,
including whitespace and line terminators.

## Dataset size

| Item | Value |
| --- | ---: |
| Paired samples | 2,236,878 |
| Coverage address occurrences | 7,091,071,453 |
| Original program text | 10,601,758,347 bytes |
| Original coverage text | 134,730,357,528 bytes |
| Parquet shards | 448 |
| Parquet size | 23,208,272,480 bytes (21.61 GiB) |

## Loading the dataset

Install the `datasets` package and stream rows without downloading every
shard first:

```python
from datasets import load_dataset

dataset = load_dataset(
    "zzra1n/SyzPilot-dataset",
    split="train",
    streaming=True,
)

sample = next(iter(dataset))
program = sample["program"]
coverage = [int(address, 16) for address in sample["coverage"].splitlines()]

print(sample["id"])
print(program)
print(len(coverage))
```

For a local checkout:

```python
from datasets import load_dataset

dataset = load_dataset(
    "parquet",
    data_files="data/train-*.parquet",
    split="train",
    streaming=True,
)
```

## Collection context

The corpus was collected from fuzzing Linux v6 kernels. The archived source
directories do not contain a precise Linux commit, syzkaller commit, or build
configuration, so this release cannot supply those details after the fact.
Coverage addresses should be treated as observations from the original test
environment, not as stable identifiers across kernel builds.

SyzEncoder training used only the `program` field. Coverage records were not
part of the masked language modeling objective. The model training pipeline
created its own deterministic 90/10 split; this dataset keeps the complete
corpus in one split so users can define a split suited to their experiment.

## Packaging and integrity

The conversion script is included at `scripts/build_parquet.py`. It verifies
that every program has a coverage file with the same ID, sorts all IDs, reads
the source bytes without newline conversion, and writes Zstandard-compressed
Parquet files. The process is resumable at shard boundaries.

`manifest.json` records the row count, source byte counts, coverage count,
compressed size, ID range, and SHA-256 digest for every shard.

To rebuild the release from the original directory layout:

```bash
python3 -m venv .venv
.venv/bin/pip install -r requirements.txt
.venv/bin/python scripts/build_parquet.py \
  --source /path/to/dataset_224w \
  --output .
```

## Intended use

This dataset is meant for research on syz-program representation learning,
kernel-fuzzing program analysis, and coverage modeling. It can also be used to
train a tokenizer or an encoder for syzkaller inputs.

## Limitations

- The corpus comes from one kernel generation and one fuzzing setup. Its
  distribution may differ from newer kernels or syzkaller versions.
- Coverage addresses depend on the matching kernel image and build settings.
  They cannot be mapped back to source locations without the corresponding
  binary and symbols.
- Fuzzer-generated corpora contain repeated and near-duplicate programs. This
  release does not deduplicate them.
- The dataset does not provide bug labels, reachability labels, or a benchmark
  split.
- The corpus has not undergone an independent privacy or sensitive-data audit.

## License

The dataset contents, including the Parquet shards and manifest, are licensed
under the [Creative Commons Attribution 4.0 International license](https://creativecommons.org/licenses/by/4.0/).
The conversion script in `scripts/` is licensed under the
[Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0).

When redistributing the data or publishing work based on it, cite this dataset
and indicate whether you changed the data.

## Citation

```bibtex
@misc{syzpilot_dataset_2026,
  author       = {SyzPilot Authors},
  title        = {SyzPilot Dataset},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/zzra1n/SyzPilot-dataset}}
}
```