Cuarzo-AI/cuarzo-100k-v2

Cuarzo-100K v2

99,683 bidirectional deterministically verified Python to human language pairs across English, Spanish, French, and Mandarin Chinese. Released by Cuarzo AI.

This is the second public release from Aether, our proprietary engine for generating deterministic paired data between code and human language. v2 delivers Mandarin Chinese as a full fourth language surface, expands the verification schema to per-language roundtrip checks across all four surfaces, and adds complete provenance instrumentation at the record level.

The Aether engine is under active development. More source languages, more human languages, larger volumes, and tighter verification are all in progress.

What's new in v2

• Mandarin Chinese added. Every record now includes a plaincode_zh surface generated directly from the AST — not translated from English. The engine handles advanced Python constructs including async def, await, context managers, and decorator patterns.
• Per-language verification. v2 expands roundtrip validation to all four language surfaces independently. Every record carries separate AST equality, compilation, and exact-match checks for EN, ES, FR, and ZH.
• Improved human language phrasing for Spanish and French. The ES and FR representations in v2 reflect refinements to Aether's structured grammar for both languages.
• Full provenance instrumentation. Each record includes processing timestamps, engine build identifiers, per-surface SHA256 hashes, and byte/character counts — enabling end-to-end independent auditability.
• 100% acceptance across all checks. All 99,683 records pass every verification gate across all four language surfaces.

What makes this different

Most code-language datasets fall into one of three buckets:

• Scraped from the web (docstrings, READMEs) — noisy, inconsistent, frequently wrong.
• Generated by LLMs — fast and cheap, but probabilistic and unverifiable.
• Hand-annotated by humans — accurate but slow, expensive, and structurally English-dominant.

Cuarzo takes a different path. Feed in a supported source language, and our Aether engine returns the functionally equivalent intent in another supported language — not a loose summary, not an approximate rewriting, but a verifiable, bidirectional, deterministically controlled alignment across surfaces. The same input always produces the same output. Every pair has to meet strict acceptance standards and is checked structurally before acceptance.

The pipeline

Cuarzo-100K was curated from StarCoderData's Python stream using a multi-stage acceptance pipeline:

1. Hard filters on source quality, structure, and licensing.
2. Multi-stage deduplication — both raw and structural — within the corpus, our own internal datasets, and all future releases.
3. Compile checks on source to ensure parseability.
4. Aether translation to structured human language representations in EN, ES, FR, and ZH.
5. Roundtrip validation per language — regenerate Python from each human language representation, then verify functional equivalence to the source independently for each surface.
6. Strict acceptance gates — only records that pass every check across all four surfaces make it into the dataset.

What's in each record

Core content

Field	Description
source_code	Original Python from StarCoderData
plaincode_en	Aether's structured English representation
plaincode_es	Aether's structured Spanish representation
plaincode_fr	Aether's structured French representation
plaincode_zh	Aether's structured Mandarin Chinese representation
translation_status	Pipeline status flag (ok for all accepted records)

Verification — per language

Field	Description
roundtrip_python_from_en/es/fr/zh	Python regenerated from each language representation
roundtrip_ast_ok	Boolean: source AST matches roundtrip AST (aggregate across all surfaces)
roundtrip_ast_ok_en/es/fr/zh	Boolean: AST equality check per language surface
roundtrip_compile_ok	Boolean: all roundtrips compile (aggregate)
roundtrip_compile_ok_en/es/fr/zh	Boolean: compilation check per language roundtrip
roundtrip_exact_ok_en/es/fr/zh	Boolean: exact structural match per language roundtrip
roundtrip_error_en/es/fr/zh	Error message if roundtrip failed; null for all accepted records
source_compile_ok	Boolean: original source compiles
source_compile_error	Compile error if source failed; null for all accepted records
all_required_exact_ok	Boolean: all four language surfaces passed all verification gates
required_exact_languages	Languages required to pass for acceptance (value: en,es,fr,zh for all records)
failed_required_exact_languages	Languages that failed, if any; null for all accepted records
failure_reasons	Failure description if any gate failed; null for all accepted records

Provenance & hashes

Field	Description
source_sha256	SHA256 of the original source file
roundtrip_sha256_from_en/es/fr/zh	SHA256 of each roundtrip Python output
hashes	Full provenance hash bundle (artifact hash, normalized source hash)
artifact_hash	Hash of the Aether engine configuration used to generate this record
source_metadata	Source repo name, file path, GitHub stars

Size metrics

Field	Description
source_byte_count	Byte length of source
source_char_count	Character length of source
roundtrip_byte_count_from_en/es/fr/zh	Byte length of each roundtrip Python output
roundtrip_char_count_from_en/es/fr/zh	Character length of each roundtrip Python output

Composition

Verification

All 99,683 records pass every check across all four language surfaces.

Check	Records passing
source_compile_ok	99,683 / 99,683 (100.00%)
roundtrip_compile_ok (aggregate)	99,683 / 99,683 (100.00%)
roundtrip_compile_ok_en	99,683 / 99,683 (100.00%)
roundtrip_compile_ok_es	99,683 / 99,683 (100.00%)
roundtrip_compile_ok_fr	99,683 / 99,683 (100.00%)
roundtrip_compile_ok_zh	99,683 / 99,683 (100.00%)
roundtrip_ast_ok (aggregate)	99,683 / 99,683 (100.00%)
roundtrip_ast_ok_en	99,683 / 99,683 (100.00%)
roundtrip_ast_ok_es	99,683 / 99,683 (100.00%)
roundtrip_ast_ok_fr	99,683 / 99,683 (100.00%)
roundtrip_ast_ok_zh	99,683 / 99,683 (100.00%)
all_required_exact_ok	99,683 / 99,683 (100.00%)

Multilingual coverage

Language	Records with non-empty representation
English (plaincode_en)	99,683 / 99,683 (100.00%)
Spanish (plaincode_es)	99,683 / 99,683 (100.00%)
French (plaincode_fr)	99,683 / 99,683 (100.00%)
Mandarin Chinese (plaincode_zh)	99,683 / 99,683 (100.00%)

Every record contains all five surfaces: Python source plus four natural-language representations, each independently verified.

Source diversity

Property	Value
Source corpus	StarCoderData Python stream
Unique source repositories	83,489
Average records per repository	1.2

The dataset is drawn from the long tail of public Python code rather than concentrated in a small number of large repositories. The average of 1.2 records per repository means most source files come from distinct projects; concentration is minimal.

Source code size distribution

Size (characters)	Records	Share
< 500	13,217	13.26%
500 – 2,000	45,648	45.79%
2,000 – 5,000	26,208	26.29%
5,000 – 10,000	9,644	9.67%
10,000 – 20,000	3,628	3.64%
> 20,000	1,347	1.35%

Source code statistics: minimum 250 chars, maximum 288,385 chars, mean 3,067 chars, median 1,534 chars.

ML and Deep Learning composition

Category	Records	Share
Records using any ML library	15,832	15.88%
Records using a deep learning framework	4,887	4.90%

Top libraries by record count:

Library	Records
numpy	10,238
pandas	3,514
torch	2,811
tensorflow	1,570
sklearn	1,192
cv2	1,188
keras	588
nltk	276
transformers	125
spacy	104

Records may use multiple libraries; library counts can sum to more than the total number of records using any ML library.

Multilingual parity

Global enterprises do not operate in one language, but most public code-language datasets do. Cuarzo-100K v2 gives AI teams verified Python-to-language training records across English, Spanish, French, and Mandarin Chinese — with additional languages planned in future releases.

Each language surface is generated from the same verified semantic foundation — the AST — not translated from another language surface. Teams can train multilingual code understanding without sacrificing consistency, auditability, or behavioral grounding. The Mandarin surface is generated from the same verified semantic foundation as the other language surfaces, with independent per-surface roundtrip verification applied.

Example (excerpt):

Python source:

def connection(host, port, username, password):
    try:
        connection = get_connection(host=host, port=port, username=username, password=password, use_tls=True)
        return connection
    except Exception as e:
        print(e)

English representation:

Define method connection with parameters host, port, username, password:
    Attempt the following:
        Set connection to get_connection with host set to host, port set to port, ...
        Return connection.
    If an error of type Exception occurs, bound as e:
        Print e.

Spanish representation:

Definir método connection con parámetros host, port, username, password:
    Intentar lo siguiente:
        Establecer connection como get_connection con host establecido a host, port establecido a port, ...
        Devolver connection.
    Si ocurre un error de tipo Exception, como e:
        Imprimir e.

French representation:

Définir méthode connection avec paramètres host, port, username, password:
    Essayer ce qui suit:
        Affecter connection à get_connection avec host défini à host, port défini à port, ...
        Retourner connection.
    Si une erreur du type Exception survient, lié comme e:
        Afficher e.

Mandarin Chinese representation:

定义方法 connection，参数为 host、port、username、password：
    尝试以下操作：
        将 connection 设置为 get_connection，其中 host 设为 host，port 设为 port，...
        返回 connection。
    若发生 Exception 类型的错误，绑定为 e：
        打印 e。

Why we're releasing this

Curating high quality code-language data is a huge bottleneck for the AI industry today, and every known existing source forces the same tradeoff: cheap and unreliable, or accurate and unscalable without heavy expenses. The teams pushing the frontier of code generation, code understanding, and multilingual AI are all hitting the same ceiling at once.

The team at Cuarzo AI takes a fundamentally different approach: verifiable alignment between code and natural language, with functional equivalence guaranteed and verified by construction rather than estimated by sampling. The same input always produces the same output. Every pair is checked before release — and in v2, checked independently across all four language surfaces.

We're releasing this dataset so the field can build on it. Better training data, better evaluation, and better cross-lingual alignment all start with pairs that are actually consistent — and the only way to prove that is to put the data in researchers' hands and invite them to verify it. Use it. Stress-test it. Tell us what you find.

Intended uses

Cuarzo-100K v2 is designed for:

• Training and fine-tuning code-language models with verified, multilingual pairs
• Multilingual code generation, explanation, and translation research
• Evaluation and benchmarking of code-language models, especially in non-English settings
• Cross-lingual alignment research between Latin-script and CJK-script representations of code semantics
• Provenance and reproducibility research, given the full per-record instrumentation

Permissively licensed under Apache 2.0 for commercial and non-commercial use.

Known limitations

We declare these openly so users can plan around them.

• AST equivalence, not full runtime semantic equivalence. Verification confirms that source and roundtrip produce identical normalized ASTs. This is a strong correctness guarantee for nearly all practical purposes, but does not cover all runtime scenarios involving evaluation order of side effects or implementation-defined behavior.

• Comments are preserved verbatim. Source code comments (#-prefixed) are treated as literal annotations and preserved across language representations rather than translated. This is intentional — comment translation introduces ambiguity around author intent and is out of scope for this release.

• StarCoderData distribution. Source files inherit the composition of StarCoderData's Python stream. Long-tail repository content is well represented; highly popular code patterns may be relatively underrepresented compared to popularity-weighted scraped datasets.

• ML/DL composition is minoritarian. 15.88% of records use general ML libraries; 4.90% use deep learning frameworks. Users with ML-specific needs may want to filter accordingly.

• Python only in this release. Aether currently supports Python paired with EN/ES/FR/ZH. Additional source languages (C++, Go, Rust) and additional human languages (Hindi, Japanese, German, and beyond) are on the roadmap.

How to load

from datasets import load_dataset

ds = load_dataset("Cuarzo-AI/cuarzo-100k-v2")

# Each record contains five language surfaces plus full per-language verification
sample = ds["train"][0]
print(sample["source_code"])
print(sample["plaincode_zh"])
print(sample["roundtrip_ast_ok_zh"])  # True for all accepted records

Try it. Tell us what you find.

We invite AI labs, research teams, and code-tooling companies to fine-tune or evaluate models on Cuarzo-100K and share results. Standard code benchmarks (HumanEval, MBPP, MultiPL-E) and multilingual evaluations are particularly relevant given the dataset's structural properties. We're especially interested in head-to-head comparisons against fine-tunes on web-scraped or LLM-generated paired data, and in evaluations that specifically test non-English and CJK code understanding.

The per-record provenance fields enable a class of evaluation that isn't possible with other datasets: you can filter by engine build, by processing time, by roundtrip character count, and verify any individual record's equivalence chain independently. We'd like to see that capability used.

If you find that models trained on Cuarzo-100K produce stronger results — or weaker ones — we want to hear about it.

The Aether engine

Cuarzo-100K v2 is a snapshot of what the Aether engine produces at public-release scale. The engine itself is significantly more capable than this dataset reflects.

Volume. Aether is designed for industrial-scale generation. The pipeline that produced this dataset operates throughputs that make hundreds of millions of records commercially viable. The 99,683 records in this release represent a controlled public sample, not a ceiling. AI labs and enterprises requiring training corpora in the tens or hundreds of millions of verified pairs should contact us directly.

Language coverage. The current public release covers Python paired with EN, ES, FR, and ZH. Aether's architecture is language-agnostic at the source and target levels. Additional programming languages — including C++, Go, and Rust — and additional human languages — including Hindi, Portuguese, German — are in active development. Labs with specific language-pair requirements can work with us to prioritize and schedule production runs for their exact needs.

Domain and codebase customization. Aether can be targeted at specific domains, libraries, or internal codebases. A lab building a code model for biomedical Python, for financial analytics tooling, or for a proprietary internal framework can receive verified paired data scoped precisely to that domain — not a general-purpose corpus filtered after the fact. The engine generates from your source material with the same deterministic verification guarantees as the public dataset. For labs with proprietary codebases, Aether is available as an API: the engine runs against your code on your infrastructure, and no source code is transmitted to or stored by Cuarzo AI. You receive verified paired data without exposing your codebase.

Evaluation and benchmark data. Beyond training data, Aether can generate held-out evaluation sets with known provenance and verified correctness properties. For labs that need benchmark data with formal equivalence guarantees rather than crowd-sourced annotations, this is a meaningful structural improvement.

Custom verification thresholds. Acceptance criteria are configurable. Labs with stricter requirements — tighter AST matching, higher exact-match thresholds, or additional compile-time checks — can request production runs with those parameters applied.

Reach out at hello@cuarzoai.com to discuss volume, language coverage, and customization. We respond to every legitimate inquiry within two business days.

Citation

If you use this dataset in research or product work, please cite:

@dataset{cuarzo_100k_v2_2026,
  title  = {Cuarzo-100K: Deterministically Paired Python and Multilingual Human-Language Code Representations},
  author = {Cuarzo AI},
  year   = {2026},
  url    = {https://huggingface.co/datasets/Cuarzo-AI/cuarzo-100k-v2}
}

License

Released under the Apache License 2.0.

Source code is sourced from StarCoderData (Python stream) under its respective license. The source_metadata field preserves the originating repository name, file path, and stars count for each record. Users should review individual source repository licenses for any downstream use of specific source files.

---

Cuarzo-100K-v2 is a public release from the Cuarzo AI team. We work with AI labs, code-tooling companies, and multilingual AI programs that need training and evaluation data with verifiable and provable consistency.