code-rlvr-15k

Code RLVR 15K is a 15,001-example coding dataset prepared for reinforcement learning with verifiable rewards (RLVR). It is derived from Kwai-Klear/KlearReasoner-CodeSub-15K and uses the same top-level prompt, label, and metadata organization as wflying/math-rlvr-15k.

Each example contains a single user prompt, a set of tests for verifying generated code, and metadata for reward routing and source tracking. Prompts are primarily English programming problems; many explicitly request a Python solution. The dataset contains problem statements and test targets, with no separate model-response or chain-of-thought field.

Dataset summary

Property	Value
Examples	15,001; “15K” is the rounded dataset name
Split	train only
File	code-rlvr-15k.jsonl
Format	UTF-8 JSON Lines; one object per line
File size	7,936,183,333 bytes (approximately 7.39 GiB)
Unique prompts, exact text	13,575
Unique prompts, whitespace-normalized	13,568
Prompt shape	One user message per example
Prompt length in characters	min 44; median 1,747; P95 3,225; max 9,363
Input/output test records	14,958
Functional-test records	43
Input/output test pairs	1,667,186 across all released records
Functional test strings	1,225 across all released records

All 15,001 lines parse as JSON and share the same top-level and metadata field names. Test payloads have two different structures, described below. The release contains repeated prompts and is not deduplicated.

Upstream source

The source is Kwai-Klear/KlearReasoner-CodeSub-15K. Its dataset card describes it as a cleaned and filtered subset of Klear-Reasoner's code RL data, derived from RL data used in the rllm project. The upstream training and performance claims belong to that project; this card documents the released data and its structure.

This release reorganizes the source fields as follows:

Upstream field	Released field
prompt	prompt
JSON-encoded reward_model.ground_truth	Parsed object in both label and metadata.ground_truth
reward_model.style	metadata.style
data_source	metadata.data_source
ability	metadata.ability
hash	metadata.hash
Added routing field	metadata.data_type, set to "code"

Every record has metadata.data_source: "coder1_longcot". This is an inherited source tag, not a claim that this release includes long chain-of-thought responses. The immediate upstream repository is KlearReasoner-CodeSub-15K; the tag does not identify the original problem website for each record.

Data format

An input/output record follows this structure. This illustration abbreviates the first problem and retains only two of its tests:

{
  "prompt": [
    {
      "role": "user",
      "content": "<coding problem and solution instructions>"
    }
  ],
  "label": {
    "inputs": ["1 1\n", "2 2\n"],
    "outputs": ["0\n", "8\n"]
  },
  "metadata": {
    "data_type": "code",
    "data_source": "coder1_longcot",
    "ability": "code",
    "style": "rule",
    "hash": "7b3a48823cd08358ca1e725ab940354c",
    "ground_truth": {
      "inputs": ["1 1\n", "2 2\n"],
      "outputs": ["0\n", "8\n"]
    }
  }
}

Fields

• prompt: A list containing exactly one message with role: "user" and a non-empty content string. Problem statements, language instructions, and required interfaces vary by example.
• label: A JSON object containing either paired inputs and outputs lists or a functional list. It is a test specification, not reference solution code or a scalar answer.
• metadata.ground_truth: The verifier target. It is identical to label for all 15,001 examples and is already a parsed JSON object.
• metadata.data_type: The reward-routing identifier; always "code".
• metadata.data_source: The inherited source tag; always "coder1_longcot".
• metadata.ability: The task category; always "code".
• metadata.style: The evaluation-style tag; always "rule".
• metadata.hash: An inherited identifier. There are 13,575 distinct values, so it is not a unique row ID. Its generation procedure is not recorded in this release.

Test formats

Input/output tests — 14,958 records. inputs[i] pairs with outputs[i]. Each record has between 16 and 1,226 pairs, with a median of 102. Most values are strings representing program input and expected output. Three records contain a total of four list-valued inputs and four corresponding list-valued outputs alongside string values. For example, a test value may be ["123"] instead of "123". Preserve or explicitly normalize these values according to the problem and verifier interface.

Functional tests — 43 records. The functional list contains Python test strings, such as assertions that call the requested function. The abbreviated example below comes from a Mersenne-prime task:

{
  "functional": [
    "assert valid_mersenne(2) == True",
    "assert valid_mersenne(11) == False"
  ]
}

Functional records have between 17 and 127 test strings, with a median of 23. The same object appears in both label and metadata.ground_truth; these records do not contain inputs or outputs keys in the raw JSONL.

Loading the dataset

The file is approximately 7.39 GiB. Download it with huggingface_hub and iterate over the JSONL to preserve the original nested values without relying on Arrow schema inference:

import json
from huggingface_hub import hf_hub_download

path = hf_hub_download(
    repo_id="wflying/code-rlvr-15k",
    filename="code-rlvr-15k.jsonl",
    repo_type="dataset",
)

def iter_examples(path):
    with open(path, "r", encoding="utf-8") as f:
        for line in f:
            yield json.loads(line)

examples = iter_examples(path)
example = next(examples)
examples.close()

prompt = example["prompt"]
tests = example["metadata"]["ground_truth"]

if "functional" in tests:
    functional_tests = tests["functional"]
else:
    test_pairs = list(zip(tests["inputs"], tests["outputs"]))

For an existing local copy, set path = "code-rlvr-15k.jsonl" and use the same iterator. Iteration reads one record at a time, but the Hub download above retrieves the entire file.

The mixed string/list values in three records can cause schema-inference errors in Arrow-backed JSON loaders, including datasets.load_dataset. Before converting to a uniform tabular format, handle both test structures and normalize the exceptional values consistently in label and metadata.ground_truth.

For RLVR training, pass only prompt to the model, extract its generated solution, and evaluate it against the associated tests. Input/output tasks require an execution harness that follows the problem's input/output contract; functional tasks require the expected function definitions to be available to the tests. Execute generated code and test strings in an isolated sandbox with time and memory limits. Output normalization, execution limits, and reward aggregation are choices for the training pipeline and are not specified by this dataset.

Data quality and validation

The statistics in this card were computed from the released JSONL. Its SHA-256 matches the file checksum recorded by the Hub:

6624d4cb0a25ea0a96b772bc6a0880c1b245e15a8734bcf113db28a351565103

• 15,001 of 15,001 lines are valid JSON.
• Every record contains exactly prompt, label, and metadata at the top level.
• Every prompt contains exactly one user message with non-empty text.
• label == metadata.ground_truth for every record.
• Every input/output record has non-empty, equally sized inputs and outputs lists.
• Every functional record has a non-empty list of test strings.
• All metadata routing and source values match the constants documented above.
• There are 13,575 distinct prompt strings: 1,426 rows repeat an earlier exact prompt. Collapsing whitespace with " ".join(prompt.split()) yields 13,568 distinct prompts.
• Three input/output records contain mixed string/list test values, at zero-based row indices 11,367, 12,567, and 14,571.

Prompt lengths count characters in prompt[0]["content"]; P95 uses the nearest-rank method. Test totals count the released rows, including repeated prompts.

These checks establish structural properties. They do not establish that every problem is well specified, every expected output is correct, or every test suite is sufficient to verify a solution.

Intended use

This dataset is intended for research and development involving:

• reinforcement learning with execution-based, verifiable code rewards;
• code-generation and programming-reasoning post-training;
• testing code extraction, execution harnesses, and reward functions;
• experiments using a shared prompt / label / metadata schema across math and code tasks.

Limitations

• The dataset provides only a training split. Repeated prompts should be accounted for when creating validation or test partitions.
• Test cases may be incomplete, incorrect, or sensitive to formatting and runtime behavior. Passing the provided tests does not prove general correctness.
• The two test structures and the mixed string/list values require explicit handling by loaders and verifiers.
• Problem statements and instructions are not fully standardized. Some contain external references or image placeholders; the released file has no separate image field.
• label duplicates metadata.ground_truth, contributing to the large file size. Some examples contain many or large test cases.
• The inherited hash and source tag do not provide full per-problem provenance, and this card makes no claim of benchmark decontamination.
• There is no separate reference-solution or model-response field for supervised fine-tuning.

License and attribution

The upstream KlearReasoner-CodeSub-15K dataset card declares the Apache License 2.0. This card uses the same apache-2.0 license identifier and attributes the source to the Kwai-Klear team and the rllm data lineage described upstream.

When redistributing or using the data, retain applicable license and attribution notices and review any terms associated with the original problem sources. Reformatting the data does not remove those obligations.

Citation

Please attribute Kwai-Klear/KlearReasoner-CodeSub-15K and cite the papers requested by its dataset card:

@article{su2025klearreasoner,
  title={Klear-Reasoner: Advancing Reasoning Capability via Gradient-Preserving Clipping Policy Optimization},
  author={Zhenpeng Su and Leiyu Pan and Xue Bai and Dening Liu and Guanting Dong and Jiaming Huang and Wenping Hu and Fuzheng Zhang and Kun Gai and Guorui Zhou},
  journal={CoRR},
  volume={abs/2508.07629},
  year={2025},
  url={https://arxiv.org/abs/2508.07629}
}

@misc{su2025cegppocontrollingentropygradientpreserving,
  title={CE-GPPO: Controlling Entropy via Gradient-Preserving Clipping Policy Optimization in Reinforcement Learning},
  author={Zhenpeng Su and Leiyu Pan and Minxuan Lv and Yuntao Li and Wenping Hu and Fuzheng Zhang and Kun Gai and Guorui Zhou},
  year={2025},
  eprint={2509.20712},
  archivePrefix={arXiv},
  primaryClass={cs.LG},
  url={https://arxiv.org/abs/2509.20712}
}