--- language: - en license: cc-by-4.0 task_categories: - text-generation pretty_name: SWE-rebench-V2-Filtered-Verified tags: - software-engineering - code - swe - rl configs: - config_name: default data_files: - split: train path: data/train-* dataset_info: features: - name: base_commit dtype: string - name: created_at dtype: string - name: image_name dtype: string - name: instance_id dtype: string - name: interface dtype: string - name: language dtype: string - name: license dtype: string - name: patch dtype: string - name: pr_description dtype: string - name: problem_statement dtype: string - name: repo dtype: string - name: test_patch dtype: string - name: FAIL_TO_PASS list: string - name: PASS_TO_PASS list: string - name: install_config struct: - name: base_image_name dtype: string - name: docker_specs struct: - name: _variant dtype: string - name: bazel_version dtype: string - name: bun_version dtype: string - name: cargo_version dtype: string - name: deno_version dtype: string - name: docker_version dtype: string - name: erlang_version dtype: string - name: gcc_version dtype: string - name: go_version dtype: string - name: helm_version dtype: string - name: java_version dtype: string - name: jdk_version dtype: string - name: llvm_version dtype: string - name: lua_version dtype: string - name: luajit_version dtype: string - name: neovim_version dtype: string - name: node_version dtype: string - name: npm_version dtype: string - name: nvim_version dtype: string - name: pnpm_version dtype: string - name: python_image dtype: string - name: python_version dtype: string - name: redis_version dtype: string - name: ruby_version dtype: string - name: rust_version dtype: string - name: rustc_version dtype: string - name: solana_version dtype: string - name: sqlite_version dtype: string - name: install list: string - name: log_parser dtype: string - name: test_cmd dtype: string - name: meta struct: - name: llm_metadata struct: - name: code dtype: string - name: confidence dtype: float64 - name: detected_issues struct: - name: B1 dtype: bool - name: B2 dtype: bool - name: B3 dtype: bool - name: B4 dtype: bool - name: B5 dtype: bool - name: B6 dtype: bool - name: difficulty dtype: string - name: external_urls list: string - name: intent_completeness dtype: string - name: pr_categories list: string - name: reasoning dtype: string - name: test_alignment_issues list: string - name: num_modified_files dtype: int64 - name: num_modified_lines dtype: int64 - name: pr_author dtype: string - name: pr_labels list: string - name: pr_url dtype: string splits: - name: train num_bytes: 276137448 num_examples: 6272 download_size: 226272977 dataset_size: 276137448 --- # SWE-rebench-V2-Filtered-Verified [![GitHub](https://img.shields.io/badge/research--environments-swerebench__v2__v1-181717?logo=github)](https://github.com/PrimeIntellect-ai/research-environments/tree/main/environments/swe/swerebench_v2_v1) Filtered and gold-patch-verified subset of Nebius's [SWE-rebench-V2](https://huggingface.co/datasets/nebius/SWE-rebench-V2) ([paper](https://arxiv.org/abs/2602.23866)): **6,272 / 32,079** freshly-mined GitHub PR tasks across 17 languages. Default dataset of the `swerebench_v2_v1` taskset. ## Changes vs upstream **Filtered** (selection — the bulk of the cut): * Upstream's own per-row LLM-judge metadata: `difficulty` labeled easy/medium/hard, judge grade `code == "A"` (clearly solvable), `intent_completeness == "complete"`, no `detected_issues`, judge `confidence ≥ 0.95`. * Leak hygiene: `external_urls == []`, plus a regex scrub dropping rows whose problem statement contains inline `#1234` / `gh-1234` / `/pull/1234`-style references (the fixing PR is look-up-able otherwise). * Wholesale language drops — Julia, C++, Clojure images are broken for scoring (missing runtimes / wholesale-failing suites); a manual image blocklist (including 29 C#/Go images that deterministically fail Prime sandbox-image conversion, so every kept row has a runnable public Prime-registry image); a `statamic/cms` repo drop (its tasks run unrelated JS suites, scoring 1.0 without the fix). **Verified** (our passes, the final gate): * Gold-patch validation pass 1 via SolveEnv — reward 1.0 required. * Independent pass 2 — flaky rows removed. * No-edit pass — rows solvable with zero edits removed. * RL always-fail audit (2026-07) — instances that scored 0.0 in every 16-rollout group across independent GLM-5.2 RL samplings were re-gold-validated twice; 2 deterministically unresolvable + 1 flaky removed. Per-row outcomes ship with this repo (`swe-rebench-v2-validation.jsonl`, `swe-rebench-v2-flaky-instances.json`, `swe-rebench-v2-no-edit-pass-exclusions.jsonl`, `swe-rebench-v2-rl-alwaysfail-exclusions.json`). `image_name` is rewritten to the public Prime image registry (`prime/primeintellect/...`) so sandbox rollouts avoid Docker Hub rate limits and get fast pulls. Schema is otherwise unchanged. License mirrors upstream: CC-BY-4.0. ## Splits | Split | Rows | |---|---:| | `train` | 6,272 | ## How to use Install the [`swerebench_v2_v1`](https://github.com/PrimeIntellect-ai/research-environments/tree/main/environments/swe/swerebench_v2_v1) taskset from [research-environments](https://github.com/PrimeIntellect-ai/research-environments), then run it end-to-end with [verifiers](https://github.com/PrimeIntellect-ai/verifiers): ```bash uv pip install --prerelease=allow "git+https://github.com/PrimeIntellect-ai/research-environments.git#subdirectory=environments/swe/swerebench_v2_v1" uv run eval --taskset.id swerebench_v2_v1 -m -n 100 -r 4 ``` ## Generation
Reproduction script — swe-rebench-v2-filtered-verified.py This dataset was created by running: ````bash uv run datasets/swe-rebench-v2-filtered-verified.py -H ```` ````python # swe-rebench-v2-clean.py """Filter `nebius/SWE-rebench-V2` (32k) to a clean RL-trainable subset. Filters (all applied conjunctively against `meta.llm_metadata`, which Nebius populates per row using the `meta_info.j2` LLM-judge rubric — see https://github.com/SWE-rebench/SWE-rebench-V2/blob/main/prompts/annotations/meta_info.j2): * `difficulty in {"easy", "medium", "hard"}` — drops only ``null`` / unannotated rows. Each difficulty is validated independently below; ``meta.llm_metadata.difficulty`` remains on every row so downstream consumers can still partition by difficulty if they want. * `code == "A"` — judge graded the instance SOLVABLE (problem clearly specified, tests align with stated requirements). B1–B6 grades flag test-suite coupling, implicit naming, missing external-URL info, ambiguous spec, patch artifacts, or implicit domain knowledge. * `intent_completeness == "complete"` — problem statement provides sufficient detail (vs. partial / insufficient). * `detected_issues` all false — no B1–B6 environment/spec problems detected. * `confidence >= --min-confidence` (default 0.95) — judge classification certainty. * `external_urls == []` — judge extracted no referenced URLs from the issue text. B3 already drops cases where the URL info is *essential* and missing; this extra filter drops cases where any URL is present (paranoid, since the V2 problem_statement is the raw GitHub issue body and incidental URLs there are still a solvability risk). Plus one regex pass on `problem_statement` itself, since `external_urls` is URL-only and misses inline GitHub-style issue/PR references like `#1234`, `gh-1234`, `PR #1234`, `/issues/1234`, `/pull/1234`. Any such reference drops the row. Plus a manually-curated image blocklist at ``swe-rebench-v2-exclude-images.json`` (sibling of this file) — drops rows whose ``image_name`` matches. This includes 29 C#/Go images (microsoft-kiota, devlooped-moq, microsoft-typescript-go, asynkron-protoactor-dotnet, btcpayserver, spectreconsole) whose Docker Hub images deterministically fail Prime platform sandbox-image conversion (3 independent attempts, 2026-07) — excluded so every kept row has a runnable public image in the Prime registry. Plus a wholesale lang drop (``_DROP_LANGS``: julia, cpp, clojure): SolveEnv pass-1 found these were 0/N because Nebius's images for these langs miss the runtime / have wholesale-broken test setups. Plus a SolveEnv gold-patch validation gate: only instances where applying the gold patch and running the upstream ``test_cmd`` yields reward 1.0 are kept. Per-row outcomes (reward, reason, elapsed, test_output_tail tail) live in ``swe-rebench-v2-validation.jsonl`` for posterity / reproducibility. The file is the union of two passes (one over the hard+medium split, one over the easy split). Plus a flaky-instance blocklist at ``swe-rebench-v2-flaky-instances.json``: instances that passed pass 1 but failed an independent re-validation. The hard/medium half of the list is conservative (only ``test_failed`` / ``gold_apply_failed`` reasons retained); the easy half includes all non-passing reasons including infra-noise (sandbox_error, timeout, None) plus one explicit hang row (``brazilian-utils__brutils-python-126``). Plus a manual repo blocklist (``_DROP_REPOS``) for repositories discovered to have systematically non-discriminating tests after validation. Plus a no-edit pass blocklist at ``swe-rebench-v2-no-edit-pass-exclusions.jsonl``: instances where the no-edit debugger got reward 1.0, meaning the tests pass without applying any agent edit. Plus an RL always-fail audit blocklist at ``swe-rebench-v2-rl-alwaysfail-exclusions.json``: instances flagged during GLM-5.2 RL training (every 16-rollout group scored 0.0 across independent samplings) and then gold-validated twice via the ``swerebench_v2_v1`` taskset's ``validate`` hook (2026-07-17). Two are deterministically unresolvable under the current verifier (graded FAIL_TO_PASS tests the row's ``test_cmd`` never runs, or tests needing JDK toolchains absent from the image) and one is flaky (2,422 all-or-nothing tests spawning servers/ports). Per-row verdicts and reasons live in the file. After filtering, ``image_name`` is rewritten from ``docker.io/swerebenchv2/:`` to the public Prime image registry at ``prime/primeintellect/:`` (the ``swerebenchv2/`` namespace is stripped) so sandbox rollouts avoid Docker Hub rate limits and get fast pulls. Field source notes: * `problem_statement` (V2) is the raw GitHub issue body. * `pr_description` (V2) is the raw merged PR description (NOT LLM-rewritten — contrary to what one might assume from `pr_description.j2`, which is what Nebius uses to generate the `problem_statement` of the *separate* 126k `nebius/SWE-rebench-V2-PRs` release, not V2's pr_description). """ # /// script # requires-python = ">=3.12" # dependencies = ["datasets>=4.0.0", "jinja2"] # /// import argparse import json import re import sys import time from pathlib import Path from typing import cast from huggingface_hub import create_repo, upload_file, whoami from datasets import Dataset, load_dataset SOURCE_REPO = "nebius/SWE-rebench-V2" # Inline GitHub issue/PR references not captured by `external_urls` # (which is URL-only). Catches `#1234`, `gh-1234`, `PR #1234`, # `issue #1234`, `/issues/1234`, `/pull/1234`. _RE_ISSUE_REF = re.compile( r"(#\d{2,}|gh-\d+|PR\s*#?\d+|issue\s*#?\d+|/issues/\d+|/pull/\d+|/pulls/\d+)", re.IGNORECASE, ) _EXCLUDE_IMAGES_PATH = Path(__file__).parent / "swe-rebench-v2-exclude-images.json" _EXCLUDE_IMAGES = frozenset(json.loads(_EXCLUDE_IMAGES_PATH.read_text())) # Wholesale-drop languages that had 0/N pass rate in SolveEnv pass-1 # validation (Nebius's images for these langs are missing the runtime # or have wholesale-broken test setups). Verified across the easy split; # applied to all difficulties uniformly since the underlying images are # shared across difficulties. _DROP_LANGS = frozenset({"julia", "cpp", "clojure"}) # SolveEnv gold-patch validation outcomes, one row per instance_id. Built by # running `vf-eval solve_swe -a '{"task_type":"swerebench-v2",...}' -m none` # over the prior post-filter set; kept here for reproducibility / posterity. # Only instances with reward == 1.0 are retained downstream. _VALIDATION_PATH = Path(__file__).parent / "swe-rebench-v2-validation.jsonl" _VALIDATION_PASSING = frozenset( json.loads(line)["instance_id"] for line in _VALIDATION_PATH.read_text().splitlines() if json.loads(line).get("reward") == 1.0 ) # Flaky instances: passed gold-patch validation in pass 1 but failed (or hung) # in an independent pass 2 with the same args, no retries. Removed downstream # so training rollouts don't see noisy reward signal. _FLAKY_PATH = Path(__file__).parent / "swe-rebench-v2-flaky-instances.json" _FLAKY = frozenset(entry["instance_id"] for entry in json.loads(_FLAKY_PATH.read_text())) _NO_EDIT_PASS_PATH = Path(__file__).parent / "swe-rebench-v2-no-edit-pass-exclusions.jsonl" _NO_EDIT_PASSING = frozenset( json.loads(line)["instance_id"] for line in _NO_EDIT_PASS_PATH.read_text(encoding="utf-8").splitlines() if line ) # RL always-fail audit exclusions: instances whose reward was 0.0 in every # 16-rollout group across independent GLM-5.2 RL samplings, then gold-validated # twice (2026-07-17) — two deterministically unresolvable, one flaky. _RL_ALWAYSFAIL_PATH = Path(__file__).parent / "swe-rebench-v2-rl-alwaysfail-exclusions.json" _RL_ALWAYSFAIL = frozenset(entry["instance_id"] for entry in json.loads(_RL_ALWAYSFAIL_PATH.read_text())) # statamic/cms rows add PHP tests but run unrelated JS suites, so base + # test_patch can score reward 1.0 without the issue fix. _DROP_REPOS = frozenset({"statamic/cms"}) _DOCKERHUB_PREFIX = "docker.io/swerebenchv2/" _PRIME_PREFIX = "prime/primeintellect/" def _normalize_image(image_name: str) -> str: # Dataset rows carry e.g. ``docker.io/swerebenchv2/foo-bar:tag``; the # exclusion list omits the ``docker.io/`` prefix. Strip it for comparison. prefix = "docker.io/" return image_name[len(prefix) :] if image_name.startswith(prefix) else image_name def _rewrite_image_to_prime_registry(image_name: str) -> str: # Subset images are re-transferred as PUBLIC images to the Prime platform # registry under ``prime/primeintellect/`` (the Docker Hub ``swerebenchv2/`` # namespace is stripped); pulls from there avoid Docker Hub rate limits and # are much faster from sandbox hosts. if image_name.startswith(_DOCKERHUB_PREFIX): return _PRIME_PREFIX + image_name[len(_DOCKERHUB_PREFIX) :] return image_name def _coerce_llm_metadata(meta: dict) -> dict: # `meta.llm_metadata` is a dict in the current revision; tolerate JSON-string variants too. llm = meta.get("llm_metadata") if isinstance(llm, str): return json.loads(llm) assert isinstance(llm, dict), f"unexpected llm_metadata type: {type(llm).__name__}" return llm def _passes_filter(example: dict, min_confidence: float) -> bool: llm = _coerce_llm_metadata(example["meta"]) if llm.get("difficulty") not in ("easy", "medium", "hard"): return False if llm.get("code") != "A": return False if llm.get("intent_completeness") != "complete": return False if any(llm.get("detected_issues", {}).values()): return False if llm.get("external_urls"): return False confidence = llm.get("confidence") if confidence is None or confidence < min_confidence: return False if _RE_ISSUE_REF.search(example.get("problem_statement") or ""): return False if _normalize_image(example.get("image_name") or "") in _EXCLUDE_IMAGES: return False if example.get("language") in _DROP_LANGS: return False if example.get("instance_id") not in _VALIDATION_PASSING: return False if example.get("instance_id") in _FLAKY: return False if example.get("instance_id") in _NO_EDIT_PASSING: return False if example.get("instance_id") in _RL_ALWAYSFAIL: return False if (example.get("repo") or "").lower() in _DROP_REPOS: return False return True def prepare_data(min_confidence: float) -> Dataset: ds = cast(Dataset, load_dataset(SOURCE_REPO, split="train")) filtered = ds.filter( lambda ex: _passes_filter(ex, min_confidence), num_proc=8, load_from_cache_file=False, ) filtered = filtered.map( lambda ex: {"image_name": _rewrite_image_to_prime_registry(ex["image_name"])}, num_proc=8, load_from_cache_file=False, ) return filtered def _swe_card(key: str): """Build this dataset's card from the shared SWE card registry (swe_cards.py).""" sys.path.insert(0, str(Path(__file__).resolve().parent)) from swe_cards import build_card return build_card(key) def push_card_to_hub(repo_name: str, push_to_hub: bool): _, dataset_name = repo_name.split("/") card = _swe_card("swe-rebench-v2-filtered-verified") if push_to_hub: print(f"Pushing card to `{repo_name}`") card.push_to_hub(repo_name, repo_type="dataset") print(f"✅ Pushed card to `{repo_name}` to HF Hub") else: print("ℹ️ Skipped pushing card to HF Hub. To push, use the `--push-to-hub` or `-H` flag.") def main(repo_name: str, push_to_hub: bool, private: bool, min_confidence: float, also_report_090: bool): print(f"⚙️ Filtering {SOURCE_REPO} (confidence >= {min_confidence})") start_time = time.time() dataset = prepare_data(min_confidence) elapsed = time.time() - start_time print(f"✅ Filtered to {len(dataset):,} rows in {elapsed:.2f} seconds") if also_report_090 and len(dataset) < 50: print("ℹ️ <50 rows at confidence >= 0.95; also reporting confidence >= 0.90") start_time = time.time() dataset_090 = prepare_data(0.90) elapsed = time.time() - start_time print(f"✅ At confidence >= 0.90: {len(dataset_090):,} rows in {elapsed:.2f} seconds") if push_to_hub: create_repo(repo_name, private=private, repo_type="dataset", exist_ok=True) push_card_to_hub(repo_name, push_to_hub) dataset.push_to_hub(repo_name, private=private) for sidecar in (_NO_EDIT_PASS_PATH, _RL_ALWAYSFAIL_PATH): upload_file( path_or_fileobj=str(sidecar), path_in_repo=sidecar.name, repo_id=repo_name, repo_type="dataset", ) print(f"✅ Pushed dataset to https://huggingface.co/datasets/{repo_name}") def check_write_access(org: str): is_authed = False try: info = whoami() token = info["auth"]["accessToken"]["displayName"] for entity in info["auth"]["accessToken"]["fineGrained"]["scoped"]: if entity["entity"]["name"] == org and "repo.write" in entity["permissions"]: is_authed = True except Exception: raise ValueError("❌ You are not logged in. Please run `hf auth login` or `export HF_TOKEN=...`") if not is_authed: raise ValueError(f"❌ Your current token `{token}` does not have write access to `{org}`") print(f"✅ Confirmed write access with token `{token}` to `{org}`") if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument( "--username", "-U", default="PrimeIntellect", type=str, help="The username to push the dataset to." ) parser.add_argument( "--dataset-name", "-D", default="SWE-rebench-V2-Filtered-Verified", type=str, help="The dataset name." ) parser.add_argument("--dataset-private", "-p", action="store_true", help="Whether to make the dataset private.") parser.add_argument("--push-to-hub", "-H", action="store_true", help="Whether to push the dataset to the hub.") parser.add_argument( "--min-confidence", "-c", default=0.95, type=float, help="Minimum llm_metadata.confidence to keep." ) parser.add_argument( "--also-report-090", action="store_true", default=True, help="If <50 rows at the chosen confidence, also report the count at >= 0.90.", ) args = parser.parse_args() assert len(args.dataset_name.split("/")) == 1, "Dataset name must not include the username" if args.push_to_hub: check_write_access(args.username) main( repo_name=f"{args.username}/{args.dataset_name}", push_to_hub=args.push_to_hub, private=args.dataset_private, min_confidence=args.min_confidence, also_report_090=args.also_report_090, ) ````
## Original Dataset Card Snapshot of the [`nebius/SWE-rebench-V2`](https://huggingface.co/datasets/nebius/SWE-rebench-V2) card at card-build time — see the live card for updates.
Original nebius/SWE-rebench-V2 dataset card # SWE-rebench-V2 ## Dataset Summary SWE-rebench-V2 is a curated dataset of software-engineering tasks derived from real GitHub issues and pull requests. The dataset contains 32,079 samples covering Python, Go, TypeScript, JavaScript, Rust, Java, PHP, Kotlin, Julia, Elixir, Scala, Swift, Dart, C, C++, C#, R, Clojure, OCaml, and Lua. For log parser functions, base Dockerfiles, and the prompts used, please see https://github.com/SWE-rebench/SWE-rebench-V2 The detailed technical report is available at [“SWE-rebench V2: Language-Agnostic SWE Task Collection at Scale”](https://arxiv.org/abs/2602.23866). ## Quick Start ```python from datasets import load_dataset ds = load_dataset("nebius/SWE-rebench-V2", split="train") print(len(ds)) # 32079 ``` ## Dataset Structure | Field | Type | Description | |---|---|---| | `instance_id` | `string` | Unique identifier for the instance | | `repo` | `string` | GitHub repository in `owner/repo` format | | `base_commit` | `string` | Git commit SHA of the base before the fix | | `patch` | `string` | The gold patch that resolves the issue | | `test_patch` | `string` | Diff adding or modifying tests that verify the fix | | `problem_statement` | `string` | Issue description the patch addresses | | `pr_description` | `string` | Full pull request description | | `created_at` | `int64` | Unix timestamp (milliseconds) of the issue/PR creation | | `image_name` | `string` | Docker image name used for the evaluation environment | | `language` | `string` | Primary programming language of the repository | | `interface` | `string` | Description of the code interface changed by the patch | | `license` | `string` | SPDX license identifier of the repository | | `FAIL_TO_PASS` | `list[string]` | Test IDs that fail before the patch and pass after | | `PASS_TO_PASS` | `list[string]` | Test IDs that pass both before and after the patch | | `install_config` | `struct` | Configuration needed to reproduce the test environment | | `meta` | `struct` | Metadata and LLM-generated quality annotations | # License The dataset is licensed under the Creative Commons Attribution 4.0 license. However, please respect the license of each specific repository on which a particular instance is based. To facilitate this, the license of each repository at the time of the commit is provided for every instance. # Citation ```bibtex @misc{badertdinov2026swerebenchv2languageagnosticswe, title={SWE-rebench V2: Language-Agnostic SWE Task Collection at Scale}, author={Ibragim Badertdinov and Maksim Nekrashevich and Anton Shevtsov and Alexander Golubev}, year={2026}, eprint={2602.23866}, archivePrefix={arXiv}, primaryClass={cs.SE}, url={https://arxiv.org/abs/2602.23866}, }