terraform-multicloud

78,912 natural-language → Terraform (HCL) pairs, drawn from 25,264 public GitHub repositories across 15 provider families. Every target is human-written HCL that passes terraform validate. Every row carries its source repository, licence and file path.

Built by the SASVA AI Model Cognition Labs (MCL) Team and used to train SASVAAI/qwen38-27b-terraform.

What one row looks like

One complete row from data/train.jsonl, reproduced in full with nothing elided:

{
  "instruction": "Write a Terraform configuration for AWS that satisfies the requirement below. Emit only HCL — no explanation, no markdown fences.",
  "input": "Create a VPC with a CIDR block specified by the `vpc_cidr` variable, enable IPv6 assignment, and ensure DNS support and DNS hostnames are both enabled; tag the VPC with the project name provided via the `project_name` variable.",
  "output": "\n# Create a VPC to launch our instances into\nresource \"aws_vpc\" \"kubernetes\" {\n  assign_generated_ipv6_cidr_block = true\n  cidr_block                       = var.vpc_cidr\n\n  # ENPOINT fix\n  enable_dns_support   = true\n  enable_dns_hostnames = true\n\n  \n\n  tags = {\n    Name = \"${var.project_name}\"\n  }\n}",
  "repo": "dvogt/aws-kube-sandbox",
  "license": "Apache-2.0",
  "file_path": "aws-kube-tf-kubernetes/modules/network/vpc.tf",
  "provider_family": "aws",
  "resource_types": [
    "aws_vpc"
  ],
  "signature": "fa677c3c8d1c83372b1079db5d480539"
}

The output field above is a single JSON string; rendered, it is the file exactly as its author committed it:

# Create a VPC to launch our instances into
resource "aws_vpc" "kubernetes" {
  assign_generated_ipv6_cidr_block = true
  cidr_block                       = var.vpc_cidr

  # ENPOINT fix
  enable_dns_support   = true
  enable_dns_hostnames = true

  

  tags = {
    Name = "${var.project_name}"
  }
}

Field	Type	Meaning
instruction	string	The task directive. Names the provider family, forbids prose.
input	string	Plain-language description of the infrastructure wanted.
output	string	The target .tf file, verbatim as its author wrote it.
repo	string	Source repository, owner/name. Attribution.
license	string	That repository's SPDX licence id.
file_path	string	Path of the file within the repository.
provider_family	string	Build lane the row came from (one of 15, below).
resource_types	list[string]	Terraform resource types declared in the output.
signature	string	Order-insensitive hash of the declared resources. Dedup and contamination key.

output is human-written. instruction and input are model-written — see Provenance.

Statistics

	train	validation	total
Rows	74,909	4,003	78,912
Size on disk	241,099,954 B	12,705,591 B	253,805,545 B
Distinct source repos	23,806	1,458	25,264
Repo overlap	—	—	0
Distinct resource types	4,784	1,354	4,841
Tokens (Qwen3.8 tokenizer)	54,233,060	2,847,868	57,080,928
Tokens: median / p90 / p99 / max	501 / 1,486 / 3,739 / 8,490	504 / 1,421 / 3,466 / 7,166
output chars: median / p90 / max	1,329 / 4,806 / 27,910	1,346 / 4,714 / 27,724

Provider families

provider_family is the build lane — the extraction pass a row came from — not a parse of the instruction text. The two can disagree for cross-cutting configs (an EKS module is built in the k8s lane but its instruction says AWS).

Family	Train	Val		Family	Train	Val
aws	45,123	2,337		ibm	710	45
gcp	8,610	492		yandex	686	36
azure	8,546	468		vault	576	19
k8s	4,330	298		docker	458	24
oci	2,111	117		openstack	362	19
alicloud	1,274	46		vsphere	283	17
github	869	42		cloudflare	210	8
digitalocean	761	35

The corpus is AWS-heavy — roughly 60% of rows, about 3:2 against every other family combined.

How it was built

TerraDS archive  →  extract  →  verify  →  dedup  →  back-translate  →  seal  →  split

1. Extract. Candidate module directories pulled from the TerraDS archive (Zenodo 10.5281/zenodo.20339474), filtered to a 15-licence permissive allowlist.
2. Verify. terraform init -backend=false + terraform validate at the module-directory level, against a one-version offline provider mirror. Terraform resolves references across every .tf file in a directory, so the directory is the only thing that can be validated — but a training pair is one resource-bearing .tf file. Files without a resource block (variables.tf, outputs.tf, versions.tf) are kept as sibling context and never become pairs.
3. Dedup. By signature, an order-insensitive hash over resource and data blocks. HCL is declarative: the same resources in a different order are the same config. Scoped to resource/data blocks only — including provider/terraform scaffolding made the contamination seal nearly inert.
4. Back-translate. A teacher model reads the HCL and writes the plain-language description. Runs after dedup, so the teacher is never paid for rows about to be discarded.
5. Seal. Rows whose signature collides with an IaC-Eval reference configuration are removed, so a model trained here can still be scored on that benchmark honestly.
6. Split. Grouped by repository, never by row.

Split discipline

The split is repo-disjoint and verified: 0 of 25,264 repositories appear on both sides. This matters more than usual here. The corpus has a high near- duplicate rate between repositories that copied each other's modules, so a row-level split would put near-identical configs on both sides and turn any eval loss into a recall measurement.

Per-family splits were merged with a resolver rather than concatenated: 5.8% of repositories appear in more than one family lane, and independent per-family splits put 42 repositories train-side in one file and val-side in another. The resolver drops the train-side rows and keeps validation — never the reverse, because shrinking validation changes the eval set and losses are not comparable across eval-set sizes.

Provenance

The HCL is human-written and unaltered. Each output is the source file exactly as its author committed it. The verification stage rewrites dead syntax (stale version pins, 0.11-era type constraints) only inside a throwaway work directory so that terraform init can run offline; those rewrites are discarded and the candidate's original text is what ships.

The instructions are model-written. instruction and input were back-translated from the HCL by a teacher model — the model read the answer and wrote a description of it.

Teacher model. Qwen/Qwen3-Coder-Next.

Licensing

This dataset is released under CC-BY-4.0, inherited from TerraDS, its upstream source.

The code inside remains under its original licences. Every row carries repo, license and file_path, and ATTRIBUTION.csv lists all 25,264 source repositories with their licence and row count, so attribution is possible per-row and in bulk.

Source repositories were filtered to a permissive allowlist before extraction, so unlike a header-based label this is a repository-level licence:

Licence	Rows	Share
MIT	49,211	62.36%
Apache-2.0	24,750	31.36%
UPL-1.0	1,222	1.55%
Unlicense	937	1.19%
MIT-0	904	1.15%
BSD-3-Clause	892	1.13%
CC0-1.0	472	0.60%
BSD-2-Clause	277	0.35%
WTFPL	141	0.18%
ISC	97	0.12%
0BSD	8	0.01%
BSD-3-Clause-Clear	1	0.00%

76,450 rows (96.9%) are under licences that require attribution and retention of the licence text. If you redistribute this dataset or a derivative of it, carry ATTRIBUTION.csv with it. If you redistribute generated HCL, note that MIT and Apache-2.0 obligations attach to the training material, not automatically to model output — but the two are close enough here that the conservative reading is the safe one.

Apache-2.0 §4(b) requires retention of NOTICE files. Those files are not carried in this dataset: the unit is a single .tf file, and repository-root NOTICE files were outside the extraction. ATTRIBUTION.csv plus repo is the route back to them.

Removal requests

If your repository appears in ATTRIBUTION.csv and you want it removed, open a discussion on this dataset. Removals are applied by repo across both splits and the file is regenerated.

Intended use

Supervised fine-tuning for natural-language → Terraform generation. The training rendering used for the reference model is:

<|im_start|>system
{SYSTEM}<|im_end|>
<|im_start|>user
{instruction}

```
{input}
```<|im_end|>
<|im_start|>assistant
{output}<|im_end|>

The user turn's payload is fenced. The reference model additionally trained with an empty <think></think> block before the answer.

from datasets import load_dataset
ds = load_dataset("SASVAAI/terraform-multicloud")           # train: 74,909 · validation: 4,003
aws = ds["train"].filter(lambda r: r["provider_family"] == "aws")

Out of scope. This is not a benchmark. The validation split is a held-out sample of the same distribution, scored by loss; it has no execution harness, no Rego policies and no pass/fail oracle. For scored evaluation use IaC-Eval, which this corpus is deliberately disjoint from.

Citation

@misc{terraform_multicloud_2026,
  title  = {terraform-multicloud: Natural-language to Terraform pairs from permissively licensed repositories},
  author = {{SASVA AI Model Cognition Labs (MCL) Team}},
  year   = {2026},
  url    = {https://huggingface.co/datasets/SASVAAI/terraform-multicloud}
}

@dataset{terrads,
  title     = {TerraDS: A Dataset for Terraform HCL Programs},
  year      = {2025},
  publisher = {Zenodo},
  doi       = {10.5281/zenodo.20339474}
}

@inproceedings{iaceval2024,
  title     = {IaC-Eval: A Code Generation Benchmark for Infrastructure-as-Code Programs},
  booktitle = {NeurIPS Datasets and Benchmarks},
  year      = {2024}
}