VulnTune: A Multi-Language Instruction-Tuning Dataset for LLM Vulnerability Detection

VulnTune is a multi-language corpus of 179,704 source-code samples labelled VULNERABLE or NOT VULNERABLE, formatted for instruction-tuning (SFT / LoRA / PEFT) of large language models for source-code vulnerability detection.

It merges and deduplicates public vulnerability datasets into one schema, with a CWE identifier, a short natural-language reason, and source provenance on every record. You can also use it as a standard binary classification benchmark (vulnerable vs. not vulnerable) for encoder models such as CodeBERT or UniXcoder.

Main use case: fine-tuning code LLMs to act as a vulnerability verifier, for example as a second stage that filters false positives from SAST tools (CodeQL, Semgrep, etc.) in CI/CD pipelines.

Dataset at a glance

Total records	179,704 (deduplicated by function hash)
Splits	train 144,007 / validation 17,927 / test 17,770 (≈ 80/10/10)
Label balance	19,983 VULNERABLE (≈ 11.1%) / 159,721 NOT VULNERABLE
Languages	20+ language tags (C/C++-dominant, see below)
Task	Single-task binary detection with a short reason
Format	JSONL, one record per line

Label distribution per split

Split	VULNERABLE	NOT VULNERABLE	Total	% vulnerable
train	16,048	127,959	144,007	11.1%
validation	1,945	15,982	17,927	10.8%
test	1,990	15,780	17,770	11.2%

Language distribution (all splits)

Language	Records	Share
C/C++	162,626	90.50%
PHP	4,411	2.45%
Python	3,321	1.85%
JavaScript	2,803	1.56%
Java	2,396	1.33%
Ruby	933	0.52%
Go	497	0.28%
C#	351	0.20%
Swift	161	0.09%
Fortran	144	0.08%
Kotlin	72	0.04%
Other code (shell, Scala, Rust, Perl, ActionScript, CoffeeScript)	228	0.13%
Non-code / config (xml, json, html, yaml, css)	604	0.34%
unknown	1,157	0.64%

Data fields

Field	Type	Description
input	string	The source code to analyse (usually a single function or file fragment).
output	string	Target label: VULNERABLE or NOT VULNERABLE.
reason	string	Short explanation of the label (e.g. the weakness involved, or "No exploitable security flaw identified").
language	string	Programming language of input.
cwe	string	Associated CWE identifier (e.g. CWE-1021). For NOT VULNERABLE samples this is the CWE of the matching vulnerable (pre-patch) version, where one exists.
source	string	Upstream dataset the record comes from (e.g. CrossVul, Juliet, CVEfixes).
func_hash	string	MD5 hash of the normalised code, used for deduplication.

Example (abbreviated)

{
  "input": "func (as *AdminServer) registerRoutes() { ... }",
  "output": "VULNERABLE",
  "reason": "The router does not apply security-header middleware, so responses lack X-Frame-Options / CSP and the admin UI can be framed (clickjacking).",
  "language": "Go",
  "cwe": "CWE-1021",
  "source": "CrossVul",
  "func_hash": "880bcc1a969ff1790a7270ce88b9f766",
}

Many vulnerable samples have a matching patched version labelled NOT VULNERABLE (for example, the same Go router with mid.ApplySecurityHeaders added). This helps the model learn the actual fix instead of surface-level patterns.

Intended use

1. Instruction-tuning an LLM (main use)

The corpus is single-task, so the instruction is not repeated in every row. Apply it once as a system prompt when you format the data:

from datasets import load_dataset

ds = load_dataset("moayadterro/VulnTune")

SYSTEM_PROMPT = (
    "You are a security code reviewer. Analyse the given code and answer "
    "VULNERABLE or NOT VULNERABLE, followed by a one-sentence reason."
)  # replace with the exact prompt that you would use

def to_chat(ex):
    return {
        "messages": [
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": f"Language: {ex['language']}\n\n```\n{ex['input']}\n```"},
            {"role": "assistant", "content": f"{ex['output']}\nReason: {ex['reason']}"},
        ]
    }

chat_ds = ds.map(to_chat, remove_columns=ds["train"].column_names)
# -> ready for TRL SFTTrainer / LoRA fine-tuning

2. Binary classification

ds = ds.map(lambda ex: {"label": int(ex["output"] == "VULNERABLE")})

Because only about 11% of samples are vulnerable, report precision, recall, F1 and MCC for the vulnerable class, not just accuracy. Also consider class weighting or resampling during training.

Source datasets

Source	Origin	Licence
CrossVul	Hugging Face	Apache-2.0
CVEfixes	Zenodo	CC BY 4.0
code-security-vulnerability-dataset (ayshajavd)	Hugging Face

The VulnTune compilation (schema, splits, and the reason/metadata fields) is released under MIT. Individual records keep the licence of their upstream source. Please also cite the original datasets when you use VulnTune.

Construction

1. Each source is loaded and normalised into the common schema.
2. Language tags are normalised and CWE IDs are mapped to the CWE-<n> format.
3. Samples are deduplicated using func_hash, both within and across sources.
4. Records are split into stratified 80/10/10 train/validation/test splits.
5. The detection-only target (VULNERABLE / NOT VULNERABLE) and a short reason are attached to each record.

Citation

@misc{terro2026vulntune,
  title        = {VulnTune: A Multi-Language Instruction-Tuning Dataset for LLM-Based Vulnerability Detection},
  author       = {Terro, Moayad},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/moayadterro/VulnTune}}
}