| --- |
| 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 |
|
|
| [](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 <your-model> -n 100 -r 4 |
| ``` |
|
|
| ## Generation |
|
|
| <details> |
| <summary>Reproduction script — <code>swe-rebench-v2-filtered-verified.py</code></summary> |
|
|
| 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/<name>:<tag>`` to the public Prime image registry at |
| ``prime/primeintellect/<name>:<tag>`` (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, |
| ) |
| |
| ```` |
|
|
| </details> |
|
|
|
|
|
|
| ## 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. |
|
|
| <details> |
| <summary>Original <code>nebius/SWE-rebench-V2</code> dataset card</summary> |
|
|
| # 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}, |
| } |
| |
| </details> |
| |
