name stringlengths 26 84 | instruction stringclasses 1
value | description stringlengths 61 119 | keywords listlengths 5 5 | schema_version stringclasses 1
value | config unknown | metadata unknown | files listlengths 17 31 | location stringlengths 15 73 |
|---|---|---|---|---|---|---|---|---|
programgym/packtpublishing--asynchronous-programming-in-rust.5482ae5 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for PacktPublishing/Asynchronous-Programming-in-Rust | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "PacktPublishing__Asynchronous-Programming-in-Rust.5482ae5",
"repository": "PacktPublishing/Asynchronous-Programming-in-Rust",
"commit": "5482ae5f060ed3c6e7ed7858b5f0c711c00a1dfa",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.9292145037,
"test_... | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/download.sh"... | packtpublishing--asynchronous-programming-in-rust.5482ae5 |
programgym/packtpublishing--cpp17-stl-cookbook.b56b954 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for PacktPublishing/Cpp17-STL-Cookbook | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "PacktPublishing__Cpp17-STL-Cookbook.b56b954",
"repository": "PacktPublishing/Cpp17-STL-Cookbook",
"commit": "b56b954c9c17852160aa60c3ab100c1867f42878",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.7021719509,
"test_branches": 1,
"test_count":... | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | packtpublishing--cpp17-stl-cookbook.b56b954 |
programgym/packtpublishing--practical-system-programming-for-rust-developers.c35c5db | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for PacktPublishing/Practical-System-Programming-for-Rust-Developers | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "PacktPublishing__Practical-System-Programming-for-Rust-Developers.c35c5db",
"repository": "PacktPublishing/Practical-System-Programming-for-Rust-Developers",
"commit": "c35c5dbb47673f2617567bff0ceb8aa11736ba49",
"language": "rust",
"difficulty": "easy",
"difficult... | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | packtpublishing--practical-system-programming-for-rust-developers.c35c5db |
programgym/packyme--privacy-filter.64b8de3 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for packyme/privacy-filter | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "packyme__privacy-filter.64b8de3",
"repository": "packyme/privacy-filter",
"commit": "64b8de3c206059b187d65381189b70c267550392",
"language": "go",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 4,
"test_count": 654
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | packyme--privacy-filter.64b8de3 |
programgym/padok-team--yatas.10ffdfe | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for padok-team/yatas | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "padok-team__yatas.10ffdfe",
"repository": "padok-team/yatas",
"commit": "10ffdfe7309ba705e46ef60c099fbc26fe45de5d",
"language": "go",
"difficulty": "medium",
"difficulty_score": 2.5094041603,
"test_branches": 6,
"test_count": 303
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_mo... | padok-team--yatas.10ffdfe |
programgym/patwie--cppnumericalsolvers.14a997b | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for PatWie/CppNumericalSolvers | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "PatWie__CppNumericalSolvers.14a997b",
"repository": "PatWie/CppNumericalSolvers",
"commit": "14a997b1368d1647d0b026ab533e6a3f6c41df1e",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.7824009525000002,
"test_branches": 4,
"test_count": 595
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | patwie--cppnumericalsolvers.14a997b |
programgym/pauldreik--rdfind.e50c817 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pauldreik/rdfind | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pauldreik__rdfind.e50c817",
"repository": "pauldreik/rdfind",
"commit": "e50c817ea28fac58810cbefddd2c5b0551a30b44",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.4637437212,
"test_branches": 4,
"test_count": 494
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | pauldreik--rdfind.e50c817 |
programgym/paulftw--hiberlite.ffd558a | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for paulftw/hiberlite | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "paulftw__hiberlite.ffd558a",
"repository": "paulftw/hiberlite",
"commit": "ffd558a4917b33668d1001b4bba8e11b508be06a",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.4659773683,
"test_branches": 4,
"test_count": 281
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | paulftw--hiberlite.ffd558a |
programgym/paullouisageneau--violet.42b9457 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for paullouisageneau/violet | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"c"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "paullouisageneau__violet.42b9457",
"repository": "paullouisageneau/violet",
"commit": "42b9457b8daee029ae0499580c4a9864899fc90e",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.203576775,
"test_branches": 4,
"test_count": 861
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | paullouisageneau--violet.42b9457 |
programgym/pboettch--json-schema-validator.9e26e99 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pboettch/json-schema-validator | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pboettch__json-schema-validator.9e26e99",
"repository": "pboettch/json-schema-validator",
"commit": "9e26e992069d766852cd87abfa868834357812e5",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.8516252032,
"test_branches": 5,
"test_count": 309
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | pboettch--json-schema-validator.9e26e99 |
programgym/pcarrier--gauth.0711b62 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pcarrier/gauth | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pcarrier__gauth.0711b62",
"repository": "pcarrier/gauth",
"commit": "0711b6217a91ba1105f9737428b45f71d2592428",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.66133934,
"test_branches": 2,
"test_count": 172
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | pcarrier--gauth.0711b62 |
programgym/pcasteran--terraform-graph-beautifier.4eee6c2 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pcasteran/terraform-graph-beautifier | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pcasteran__terraform-graph-beautifier.4eee6c2",
"repository": "pcasteran/terraform-graph-beautifier",
"commit": "4eee6c252dc48d08aa92048c9a83e788c1b57188",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6956567598999999,
"test_branches": 5,
"tes... | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | pcasteran--terraform-graph-beautifier.4eee6c2 |
programgym/pcwalton--cxx-async.098fbfc | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pcwalton/cxx-async | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pcwalton__cxx-async.098fbfc",
"repository": "pcwalton/cxx-async",
"commit": "098fbfc0537719ea6258f3082d8caf2b1b5caf19",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.4709981697,
"test_branches": 4,
"test_count": 818
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | pcwalton--cxx-async.098fbfc |
programgym/pearkes--gethub.c74295b | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pearkes/gethub | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pearkes__gethub.c74295b",
"repository": "pearkes/gethub",
"commit": "c74295bdf57cf0a72283173d2508c3b10f56f430",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.9623693357,
"test_branches": 4,
"test_count": 195
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | pearkes--gethub.c74295b |
programgym/pebal--sgcl.cc5bd4b | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pebal/sgcl | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pebal__sgcl.cc5bd4b",
"repository": "pebal/sgcl",
"commit": "cc5bd4b71544da8e67b0e9c6de70f33c411148bf",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.8365772748,
"test_branches": 3,
"test_count": 193
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | pebal--sgcl.cc5bd4b |
programgym/pelletier--go-toml.21f8286 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pelletier/go-toml | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pelletier__go-toml.21f8286",
"repository": "pelletier/go-toml",
"commit": "21f82865ddb1a26d0e5b66e12487fddbeb676de2",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9398685445,
"test_branches": 4,
"test_count": 1026
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | pelletier--go-toml.21f8286 |
programgym/pentestpad--subzy.f2e2ec7 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for PentestPad/subzy | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "PentestPad__subzy.f2e2ec7",
"repository": "PentestPad/subzy",
"commit": "f2e2ec708433a33ab7a4f958f8c57035d49113cb",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5430742350000002,
"test_branches": 4,
"test_count": 267
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_mo... | pentestpad--subzy.f2e2ec7 |
programgym/percona-lab--mysql_random_data_load.de8eef0 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for Percona-Lab/mysql_random_data_load | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "Percona-Lab__mysql_random_data_load.de8eef0",
"repository": "Percona-Lab/mysql_random_data_load",
"commit": "de8eef03fddd476b8c197a4b54c13889efc91ea8",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.2472365495,
"test_branches": 4,
"test_count": ... | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_configure_java_mirrors.sh",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-go.tar.gz",
"environme... | percona-lab--mysql_random_data_load.de8eef0 |
programgym/percona-lab--promhouse.b88c31e | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for Percona-Lab/PromHouse | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "Percona-Lab__PromHouse.b88c31e",
"repository": "Percona-Lab/PromHouse",
"commit": "b88c31eaf97f65c0db5950a28bb6c3c8b3920404",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5024271200000001,
"test_branches": 4,
"test_count": 155
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_configure_java_mirrors.sh",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-go.tar.gz",
"environme... | percona-lab--promhouse.b88c31e |
programgym/perplexityai--bumblebee.cc57710 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for perplexityai/bumblebee | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "perplexityai__bumblebee.cc57710",
"repository": "perplexityai/bumblebee",
"commit": "cc57710eeaf685e7b89924a36c8583cad0a378fe",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9164013036,
"test_branches": 4,
"test_count": 576
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | perplexityai--bumblebee.cc57710 |
programgym/petejkim--goop.78b83e4 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for petejkim/goop | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "petejkim__goop.78b83e4",
"repository": "petejkim/goop",
"commit": "78b83e479865435dffcec36f2a26f5c1d501c2f0",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.8762178406000001,
"test_branches": 4,
"test_count": 205
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | petejkim--goop.78b83e4 |
programgym/peter-winter--ctpg.624b4d1 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for peter-winter/ctpg | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "peter-winter__ctpg.624b4d1",
"repository": "peter-winter/ctpg",
"commit": "624b4d1fa407a19f863841673b07563ec4b83ac9",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.8518696007000002,
"test_branches": 2,
"test_count": 367
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-gcc13.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated... | peter-winter--ctpg.624b4d1 |
programgym/petermichaux--bootstrap-scheme.eaa98de | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for petermichaux/bootstrap-scheme | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"c"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "petermichaux__bootstrap-scheme.eaa98de",
"repository": "petermichaux/bootstrap-scheme",
"commit": "eaa98de2c96635eaed06ec73b20c96826e360f10",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.2501759480999999,
"test_branches": 2,
"test_count": 1131
... | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | petermichaux--bootstrap-scheme.eaa98de |
programgym/pezmaster31--bamtools.7e5c183 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pezmaster31/bamtools | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pezmaster31__bamtools.7e5c183",
"repository": "pezmaster31/bamtools",
"commit": "7e5c183cdf37a6ab216402b26c07296807416472",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 2.8957428996,
"test_branches": 7,
"test_count": 475
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | pezmaster31--bamtools.7e5c183 |
programgym/philip82148--cpp-dump.aabd98d | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for philip82148/cpp-dump | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "philip82148__cpp-dump.aabd98d",
"repository": "philip82148/cpp-dump",
"commit": "aabd98dd8a4b5ae3f62cf12387a68a9f6591197e",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.7417816960999999,
"test_branches": 4,
"test_count": 844
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-gcc13.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated... | philip82148--cpp-dump.aabd98d |
programgym/phillbush--jvm.3b601a0 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for phillbush/jvm | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"c"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "phillbush__jvm.3b601a0",
"repository": "phillbush/jvm",
"commit": "3b601a0a2aee54531c26d4267c2a19633a8f05c6",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.8019522349,
"test_branches": 4,
"test_count": 995
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | phillbush--jvm.3b601a0 |
programgym/phkaeser--wlmaker.e7261a0 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for phkaeser/wlmaker | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"c"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "phkaeser__wlmaker.e7261a0",
"repository": "phkaeser/wlmaker",
"commit": "e7261a0954be32ee8e22e3d81d9756cec59a7497",
"language": "c",
"difficulty": "medium",
"difficulty_score": 3.3780634199,
"test_branches": 5,
"test_count": 900
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | phkaeser--wlmaker.e7261a0 |
programgym/pierrec--lz4.a296161 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pierrec/lz4 | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pierrec__lz4.a296161",
"repository": "pierrec/lz4",
"commit": "a296161b6e73e177e902d9cdafbd3e8b9ffaa68f",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5462958351,
"test_branches": 4,
"test_count": 586
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | pierrec--lz4.a296161 |
programgym/pijng--prep.bb7c85d | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pijng/prep | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pijng__prep.bb7c85d",
"repository": "pijng/prep",
"commit": "bb7c85dfafa68caf44cf3e37c3c9c1b5ebb970b7",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.4073909045000002,
"test_branches": 2,
"test_count": 36
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | pijng--prep.bb7c85d |
programgym/pilagod--gorm-cursor-paginator.d077284 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pilagod/gorm-cursor-paginator | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pilagod__gorm-cursor-paginator.d077284",
"repository": "pilagod/gorm-cursor-paginator",
"commit": "d077284390d037a0a50fd6f7f3da470858a0b68b",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6967057809,
"test_branches": 4,
"test_count": 113
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_mo... | pilagod--gorm-cursor-paginator.d077284 |
programgym/pippy360--transformationinvariantimagesearch.10800ac | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pippy360/transformationInvariantImageSearch | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pippy360__transformationInvariantImageSearch.10800ac",
"repository": "pippy360/transformationInvariantImageSearch",
"commit": "10800ace74441382a41be1a48fe2e01cd8e89a9f",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.7899330809,
"test_branches": ... | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | pippy360--transformationinvariantimagesearch.10800ac |
programgym/pjsip--pjproject.3923fad | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pjsip/pjproject | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"c"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pjsip__pjproject.3923fad",
"repository": "pjsip/pjproject",
"commit": "3923fad2e4f6f3403c3d6f1176b113c1c1b91066",
"language": "c",
"difficulty": "medium",
"difficulty_score": 3.9281883861,
"test_branches": 7,
"test_count": 1505
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_configure_java_mirrors.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.m... | pjsip--pjproject.3923fad |
programgym/pkg--browser.5ac0b6a | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pkg/browser | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pkg__browser.5ac0b6a",
"repository": "pkg/browser",
"commit": "5ac0b6a4141c771a0d3a081c36b87c977cf9c7db",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.4593924878,
"test_branches": 4,
"test_count": 105
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | pkg--browser.5ac0b6a |
programgym/pksunkara--cargo-workspaces.4165711 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pksunkara/cargo-workspaces | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pksunkara__cargo-workspaces.4165711",
"repository": "pksunkara/cargo-workspaces",
"commit": "41657116ce4648a7e1a537a5907adf7ed26f1023",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.6370892735,
"test_branches": 4,
"test_count": 457
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | pksunkara--cargo-workspaces.4165711 |
programgym/plankcipher--kabmat.0251870 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for PlankCipher/kabmat | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "PlankCipher__kabmat.0251870",
"repository": "PlankCipher/kabmat",
"commit": "02518704976d108a356d685bf351de17142dd76f",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.6039018317,
"test_branches": 4,
"test_count": 527
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | plankcipher--kabmat.0251870 |
programgym/plibither8--2048.cpp.ad931d9 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for plibither8/2048.cpp | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "plibither8__2048.cpp.ad931d9",
"repository": "plibither8/2048.cpp",
"commit": "ad931d991e27819463dbd3d27a05411ea3cee061",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.5947239464,
"test_branches": 4,
"test_count": 207
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-gcc13.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated... | plibither8--2048.cpp.ad931d9 |
programgym/pmp-library--pmp-library.2a2ad50 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pmp-library/pmp-library | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pmp-library__pmp-library.2a2ad50",
"repository": "pmp-library/pmp-library",
"commit": "2a2ad502743724ba90e09af816364c84032f9015",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 3.970544914,
"test_branches": 6,
"test_count": 607
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | pmp-library--pmp-library.2a2ad50 |
programgym/pointlander--peg.792d23c | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pointlander/peg | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pointlander__peg.792d23c",
"repository": "pointlander/peg",
"commit": "792d23c3bf85af878faf2541feef19a66cf4363a",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.7581546220000002,
"test_branches": 4,
"test_count": 279
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_configure_java_mirrors.sh",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-go.tar.gz",
"environme... | pointlander--peg.792d23c |
programgym/polachok--fahrenheit.3f2f133 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for polachok/fahrenheit | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "polachok__fahrenheit.3f2f133",
"repository": "polachok/fahrenheit",
"commit": "3f2f13399f37efb4aef1d645ac874ffd13c9a7e1",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.475525915,
"test_branches": 4,
"test_count": 284
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | polachok--fahrenheit.3f2f133 |
programgym/poseidon-fan--gung.73b990c | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for Poseidon-fan/Gung | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "Poseidon-fan__Gung.73b990c",
"repository": "Poseidon-fan/Gung",
"commit": "73b990c7f45fb95569a9df35cca32c9216f5a02e",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.5332635168,
"test_branches": 3,
"test_count": 166
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_configure_java_mirrors.sh",
"environment/harbor_prepare_download_env.sh",
"environment/harbor_prepare_rust_env.sh",
"env... | poseidon-fan--gung.73b990c |
programgym/posener--complete.9a4745a | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for posener/complete | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "posener__complete.9a4745a",
"repository": "posener/complete",
"commit": "9a4745ac49b29530e07dc2581745a218b646b7a3",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.8036619232,
"test_branches": 5,
"test_count": 424
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | posener--complete.9a4745a |
programgym/postcss-rs--postcss-rs.838f444 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for postcss-rs/postcss-rs | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "postcss-rs__postcss-rs.838f444",
"repository": "postcss-rs/postcss-rs",
"commit": "838f444a8a2f0a34fb0366360fb9592e6dd1ddfa",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.3916407035,
"test_branches": 4,
"test_count": 662
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_configure_java_mirrors.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.m... | postcss-rs--postcss-rs.838f444 |
programgym/pottava--aws-s3-proxy.e0c3c78 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pottava/aws-s3-proxy | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pottava__aws-s3-proxy.e0c3c78",
"repository": "pottava/aws-s3-proxy",
"commit": "e0c3c7855adb981b3fac9a7d38a3eabb51d72127",
"language": "go",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 3,
"test_count": 262
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_02.tar.gz",
"tests/blobs/tests/generated_... | pottava--aws-s3-proxy.e0c3c78 |
programgym/presburger--qmc-decoder.fb1e04b | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for presburger/qmc-decoder | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "presburger__qmc-decoder.fb1e04b",
"repository": "presburger/qmc-decoder",
"commit": "fb1e04b03246db406e9fc15c4426b79ed321e4f5",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 0.3598354823,
"test_branches": 1,
"test_count": 98
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | presburger--qmc-decoder.fb1e04b |
programgym/preshing--flexiblereflection.c8425c7 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for preshing/FlexibleReflection | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "preshing__FlexibleReflection.c8425c7",
"repository": "preshing/FlexibleReflection",
"commit": "c8425c70089ab2c3244416bf89a326408bdc9243",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 0.3654879849,
"test_branches": 3,
"test_count": 210
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | preshing--flexiblereflection.c8425c7 |
programgym/preshing--plywood.0bdafdc | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for preshing/plywood | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "preshing__plywood.0bdafdc",
"repository": "preshing/plywood",
"commit": "0bdafdcf122f00a4b83f4deb958e0db30d33ccee",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 2.4012626476,
"test_branches": 3,
"test_count": 619
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | preshing--plywood.0bdafdc |
programgym/priseborough--inertialnav.037c5c3 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for priseborough/InertialNav | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "priseborough__InertialNav.037c5c3",
"repository": "priseborough/InertialNav",
"commit": "037c5c3acb66e84d7a9d5fe03262455312e11d55",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 2.324755599,
"test_branches": 2,
"test_count": 47
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | priseborough--inertialnav.037c5c3 |
programgym/probonopd--linuxdeployqt.7e7a01d | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for probonopd/linuxdeployqt | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "probonopd__linuxdeployqt.7e7a01d",
"repository": "probonopd/linuxdeployqt",
"commit": "7e7a01d565dde3c5e116c9369026c27a2903bb9d",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.4680517915,
"test_branches": 4,
"test_count": 397
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | probonopd--linuxdeployqt.7e7a01d |
programgym/procursusteam--ldid.c50e84e | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for ProcursusTeam/ldid | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "ProcursusTeam__ldid.c50e84e",
"repository": "ProcursusTeam/ldid",
"commit": "c50e84e18532044b23ec5e971d55ab0cdd4b6685",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.6779717528,
"test_branches": 2,
"test_count": 303
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | procursusteam--ldid.c50e84e |
programgym/programatik29--rust-web-benchmarks.a3d2c37 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for programatik29/rust-web-benchmarks | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "programatik29__rust-web-benchmarks.a3d2c37",
"repository": "programatik29/rust-web-benchmarks",
"commit": "a3d2c37f3077fe69784af6b6aa9cb8c0d1488b95",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 0.7916906490000001,
"test_branches": 3,
"test_co... | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | programatik29--rust-web-benchmarks.a3d2c37 |
programgym/programmingrust--mandelbrot.2ba8479 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for ProgrammingRust/mandelbrot | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "ProgrammingRust__mandelbrot.2ba8479",
"repository": "ProgrammingRust/mandelbrot",
"commit": "2ba847967eebf95800716fe7c03d780b5130a8f8",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 0.8920946027000001,
"test_branches": 1,
"test_count": 285
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/download.sh"... | programmingrust--mandelbrot.2ba8479 |
programgym/progrium--go-basher.53c8165 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for progrium/go-basher | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "progrium__go-basher.53c8165",
"repository": "progrium/go-basher",
"commit": "53c816550d4f0ac46ecc7f86c03fa8868865c562",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.2187979981,
"test_branches": 4,
"test_count": 596
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | progrium--go-basher.53c8165 |
programgym/projectchrono--chrono.d8a4949 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for projectchrono/chrono | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "projectchrono__chrono.d8a4949",
"repository": "projectchrono/chrono",
"commit": "d8a494987155db6cdb1aa97d9a7dee9e9d9ed1e8",
"language": "cpp",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 5,
"test_count": 600
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | projectchrono--chrono.d8a4949 |
programgym/projectdiscovery--wappalyzergo.efb75ce | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for projectdiscovery/wappalyzergo | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "projectdiscovery__wappalyzergo.efb75ce",
"repository": "projectdiscovery/wappalyzergo",
"commit": "efb75ceb931f003b6c224d414fb0cba3116c0b08",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9906052114000001,
"test_branches": 4,
"test_count": 281
... | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | projectdiscovery--wappalyzergo.efb75ce |
programgym/prometheus--prom2json.8ccc6fa | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for prometheus/prom2json | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "prometheus__prom2json.8ccc6fa",
"repository": "prometheus/prom2json",
"commit": "8ccc6faa6cf47c55e2d5d2e913d76d7daa48a5f3",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9327273673,
"test_branches": 4,
"test_count": 409
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | prometheus--prom2json.8ccc6fa |
programgym/proofrock--ws4sqlite.eb139e3 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for proofrock/ws4sqlite | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "proofrock__ws4sqlite.eb139e3",
"repository": "proofrock/ws4sqlite",
"commit": "eb139e3831e15e51d05c2f8b67b55e7bca5037e2",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.1945143419,
"test_branches": 4,
"test_count": 278
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | proofrock--ws4sqlite.eb139e3 |
programgym/proxytunnel--proxytunnel.66fa1e2 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for proxytunnel/proxytunnel | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"c"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "proxytunnel__proxytunnel.66fa1e2",
"repository": "proxytunnel/proxytunnel",
"commit": "66fa1e2734750a83945cec727d31106a8ae95e25",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.5859117103,
"test_branches": 4,
"test_count": 785
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | proxytunnel--proxytunnel.66fa1e2 |
programgym/prydonius--karn.7307672 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for prydonius/karn | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "prydonius__karn.7307672",
"repository": "prydonius/karn",
"commit": "73076726231b1b0dad6ef2c0a295f280ddd452ce",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.1804126328,
"test_branches": 4,
"test_count": 163
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | prydonius--karn.7307672 |
programgym/psankar--simplefs.4dc8ce2 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for psankar/simplefs | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"c"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "psankar__simplefs.4dc8ce2",
"repository": "psankar/simplefs",
"commit": "4dc8ce211f98f65ee512c302239b6f65ab1cfb7e",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.1149444157,
"test_branches": 2,
"test_count": 280
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | psankar--simplefs.4dc8ce2 |
programgym/puerkitobio--fetchbot.b01e8f8 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for PuerkitoBio/fetchbot | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "PuerkitoBio__fetchbot.b01e8f8",
"repository": "PuerkitoBio/fetchbot",
"commit": "b01e8f8bd328c42e354e7724ebd90d59195fd1d3",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5290451708,
"test_branches": 4,
"test_count": 112
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | puerkitobio--fetchbot.b01e8f8 |
programgym/pwaller--go2ll-talk.a577581 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pwaller/go2ll-talk | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pwaller__go2ll-talk.a577581",
"repository": "pwaller/go2ll-talk",
"commit": "a577581b83eae0b5b641400d7ae269bb8730a220",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.6646419756,
"test_branches": 2,
"test_count": 272
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | pwaller--go2ll-talk.a577581 |
programgym/pwnesia--dnstake.3d9d96e | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pwnesia/dnstake | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pwnesia__dnstake.3d9d96e",
"repository": "pwnesia/dnstake",
"commit": "3d9d96ef75139202fd25ba5c01292d8a94cd0682",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.572639297,
"test_branches": 4,
"test_count": 248
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | pwnesia--dnstake.3d9d96e |
programgym/pwnwriter--kanha.df75df5 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pwnwriter/kanha | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pwnwriter__kanha.df75df5",
"repository": "pwnwriter/kanha",
"commit": "df75df539e9c04bd795887e9be54a06dae2559ef",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.9478256844000001,
"test_branches": 5,
"test_count": 395
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | pwnwriter--kanha.df75df5 |
programgym/pyk--cmake-tutorial.1aeb653 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for pyk/cmake-tutorial | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "pyk__cmake-tutorial.1aeb653",
"repository": "pyk/cmake-tutorial",
"commit": "1aeb65366be4ff2daafb74e1dc5ff866143994dd",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 0.0334237555,
"test_branches": 3,
"test_count": 202
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-gcc13.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated... | pyk--cmake-tutorial.1aeb653 |
programgym/q191201771--naza.185b380 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for q191201771/naza | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "q191201771__naza.185b380",
"repository": "q191201771/naza",
"commit": "185b380cba1819cf628bbf8de8b12bc0c14c573a",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9204364066,
"test_branches": 3,
"test_count": 106
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | q191201771--naza.185b380 |
programgym/qaware--protocurl.cf82eeb | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for qaware/protocurl | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "qaware__protocurl.cf82eeb",
"repository": "qaware/protocurl",
"commit": "cf82eeb7b9e33c153c266864112c934788785760",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.0831441431,
"test_branches": 5,
"test_count": 173
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | qaware--protocurl.cf82eeb |
programgym/qihoo360--mysql-sniffer.86e06b8 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for Qihoo360/mysql-sniffer | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"c"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "Qihoo360__mysql-sniffer.86e06b8",
"repository": "Qihoo360/mysql-sniffer",
"commit": "86e06b81b8ee7ee81c6ba2a9fa79e92f91b35e57",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.8736692927,
"test_branches": 4,
"test_count": 698
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | qihoo360--mysql-sniffer.86e06b8 |
programgym/qihoo360--phptrace.16ea058 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for Qihoo360/phptrace | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"c"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "Qihoo360__phptrace.16ea058",
"repository": "Qihoo360/phptrace",
"commit": "16ea0587804ebad95bd4ccea35acbfbe2ad8cb10",
"language": "c",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 3,
"test_count": 320
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | qihoo360--phptrace.16ea058 |
programgym/qntfy--kazaam.f202606 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for qntfy/kazaam | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "qntfy__kazaam.f202606",
"repository": "qntfy/kazaam",
"commit": "f202606c434998062d5e3a9637c1413ad58539ca",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5920656704,
"test_branches": 4,
"test_count": 557
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | qntfy--kazaam.f202606 |
programgym/quackduck--uniclip.02f28f1 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for quackduck/uniclip | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "quackduck__uniclip.02f28f1",
"repository": "quackduck/uniclip",
"commit": "02f28f13455e219deb3c2d0be6352e405bb415ba",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.1332194567,
"test_branches": 1,
"test_count": 91
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_configure_java_mirrors.sh",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-go.tar.gz",
"environme... | quackduck--uniclip.02f28f1 |
programgym/quasilyte--phpgrep.11a7680 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for quasilyte/phpgrep | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "quasilyte__phpgrep.11a7680",
"repository": "quasilyte/phpgrep",
"commit": "11a7680098f4706d5852143a5b9e585fa39e90fa",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6826864782,
"test_branches": 4,
"test_count": 349
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_mo... | quasilyte--phpgrep.11a7680 |
programgym/quest-kit--quest.9d7618d | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for QuEST-Kit/QuEST | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "QuEST-Kit__QuEST.9d7618d",
"repository": "QuEST-Kit/QuEST",
"commit": "9d7618d7263e3bfba433b88cf1eac0647f08fa0a",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 3.4104667916,
"test_branches": 6,
"test_count": 950
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | quest-kit--quest.9d7618d |
programgym/quickwit-oss--whichlang.6c1c8b6 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for quickwit-oss/whichlang | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "quickwit-oss__whichlang.6c1c8b6",
"repository": "quickwit-oss/whichlang",
"commit": "6c1c8b63ea61720306a19bee1bb555ec4646b635",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.9168222846,
"test_branches": 2,
"test_count": 343
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | quickwit-oss--whichlang.6c1c8b6 |
programgym/quii--mockingjay-server.7b93ee8 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for quii/mockingjay-server | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "quii__mockingjay-server.7b93ee8",
"repository": "quii/mockingjay-server",
"commit": "7b93ee8a98b7863322809695297f2a64e6cb9db9",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.2400497721,
"test_branches": 4,
"test_count": 249
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_configure_java_mirrors.sh",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-go.tar.gz",
"environme... | quii--mockingjay-server.7b93ee8 |
programgym/quininer--unzrip.14ba4b4 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for quininer/unzrip | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "quininer__unzrip.14ba4b4",
"repository": "quininer/unzrip",
"commit": "14ba4b4c9ff9c80444ecef762d665acaa5aecfce",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.9874875061,
"test_branches": 5,
"test_count": 785
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | quininer--unzrip.14ba4b4 |
programgym/r00tman--corrupter.d7aecbb | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for r00tman/corrupter | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "r00tman__corrupter.d7aecbb",
"repository": "r00tman/corrupter",
"commit": "d7aecbb8b622a2c6fafe7baea5f718b46155be15",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.3384564936,
"test_branches": 1,
"test_count": 51
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_configure_java_mirrors.sh",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-go.tar.gz",
"environme... | r00tman--corrupter.d7aecbb |
programgym/r4d10n--retrogram-rtlsdr.931cb5d | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for r4d10n/retrogram-rtlsdr | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "r4d10n__retrogram-rtlsdr.931cb5d",
"repository": "r4d10n/retrogram-rtlsdr",
"commit": "931cb5d5b2c01f019eb5e78b70f8058299dde698",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 0.942008053,
"test_branches": 2,
"test_count": 333
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | r4d10n--retrogram-rtlsdr.931cb5d |
programgym/race604--clock-tui.97d7c02 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for race604/clock-tui | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "race604__clock-tui.97d7c02",
"repository": "race604/clock-tui",
"commit": "97d7c02192fabf3ca26f55747a1c4423ace2b58a",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.1583624921,
"test_branches": 4,
"test_count": 997
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | race604--clock-tui.97d7c02 |
programgym/radj307--arrcon.0859b1b | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for radj307/ARRCON | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "radj307__ARRCON.0859b1b",
"repository": "radj307/ARRCON",
"commit": "0859b1b6e21d31573407001ed88d29b86de46fec",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.0962145853,
"test_branches": 4,
"test_count": 455
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | radj307--arrcon.0859b1b |
programgym/rails--rails-new.0c97c81 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rails/rails-new | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "rails__rails-new.0c97c81",
"repository": "rails/rails-new",
"commit": "0c97c8193437c12442fea84699cfead4ac7adfe2",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.2237554537,
"test_branches": 4,
"test_count": 590
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | rails--rails-new.0c97c81 |
programgym/rakyll--go-test-trace.d5d0002 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rakyll/go-test-trace | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "rakyll__go-test-trace.d5d0002",
"repository": "rakyll/go-test-trace",
"commit": "d5d0002685b041d634896bed261a99bc76c9d76a",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.4413808849,
"test_branches": 3,
"test_count": 212
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | rakyll--go-test-trace.d5d0002 |
programgym/rakyll--gotest.2b76d60 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rakyll/gotest | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "rakyll__gotest.2b76d60",
"repository": "rakyll/gotest",
"commit": "2b76d60c5af49b510a4d92e5f739671f87fc19c6",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.0107238654,
"test_branches": 2,
"test_count": 203
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | rakyll--gotest.2b76d60 |
programgym/rakyll--govalidate.85a79ff | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rakyll/govalidate | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "rakyll__govalidate.85a79ff",
"repository": "rakyll/govalidate",
"commit": "85a79ffbadda3c6854265c56edc57bbd48ee1b90",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.9474337219000001,
"test_branches": 4,
"test_count": 102
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | rakyll--govalidate.85a79ff |
programgym/rakyll--hey.5626f79 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rakyll/hey | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "rakyll__hey.5626f79",
"repository": "rakyll/hey",
"commit": "5626f79b8698df6daf9b25799c9805c6acc96740",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5125509929,
"test_branches": 4,
"test_count": 225
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | rakyll--hey.5626f79 |
programgym/rakyll--statik.f8ac636 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rakyll/statik | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "rakyll__statik.f8ac636",
"repository": "rakyll/statik",
"commit": "f8ac636f7f4cf7198fba40a157d1e1735e9fbaaf",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.8401060945000001,
"test_branches": 4,
"test_count": 199
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_mo... | rakyll--statik.f8ac636 |
programgym/ramilito--kubesess.7bbfd43 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for Ramilito/kubesess | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "Ramilito__kubesess.7bbfd43",
"repository": "Ramilito/kubesess",
"commit": "7bbfd43f29aa74750e6e359609579b2bad051425",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.9390197764,
"test_branches": 5,
"test_count": 721
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | ramilito--kubesess.7bbfd43 |
programgym/ramosbugs--oauth2-rs.72ce744 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for ramosbugs/oauth2-rs | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "ramosbugs__oauth2-rs.72ce744",
"repository": "ramosbugs/oauth2-rs",
"commit": "72ce74401c26eb4dc85dcbfde587bbcfc149e3ae",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.9568884547,
"test_branches": 4,
"test_count": 521
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | ramosbugs--oauth2-rs.72ce744 |
programgym/randerson112--craft.31db37c | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for randerson112/craft | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"c"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "randerson112__craft.31db37c",
"repository": "randerson112/craft",
"commit": "31db37cccabd51c9d0d90de147fa2b1f72db8598",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.9798669226,
"test_branches": 4,
"test_count": 689
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | randerson112--craft.31db37c |
programgym/randygaul--impulseengine.8d5f4d9 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for RandyGaul/ImpulseEngine | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "RandyGaul__ImpulseEngine.8d5f4d9",
"repository": "RandyGaul/ImpulseEngine",
"commit": "8d5f4d9113876f91a53cfb967879406e975263d1",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.445915414,
"test_branches": 3,
"test_count": 264
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | randygaul--impulseengine.8d5f4d9 |
programgym/ravendevteam--alternet.a4aa96b | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for ravendevteam/alternet | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "ravendevteam__alternet.a4aa96b",
"repository": "ravendevteam/alternet",
"commit": "a4aa96b25c38e276b55b89e46f091288ba1dd97d",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.8059084551,
"test_branches": 1,
"test_count": 249
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_configure_java_mirrors.sh",
"environment/harbor_prepare_download_env.sh",
"environment/harbor_prepare_rust_env.sh",
"env... | ravendevteam--alternet.a4aa96b |
programgym/raysan5--rres.5f2a731 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for raysan5/rres | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"c"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "raysan5__rres.5f2a731",
"repository": "raysan5/rres",
"commit": "5f2a7310197f8b7843ab5b024277a14da83f68f9",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.9999565684,
"test_branches": 1,
"test_count": 168
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_configure_java_mirrors.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.m... | raysan5--rres.5f2a731 |
programgym/rbsec--sslscan.1f02241 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rbsec/sslscan | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"c"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "rbsec__sslscan.1f02241",
"repository": "rbsec/sslscan",
"commit": "1f02241e5fa360d491924bad6ca9bf70b6dc97ca",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.8880671134,
"test_branches": 4,
"test_count": 824
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | rbsec--sslscan.1f02241 |
programgym/realalexandreai--json-repair.8d5f54f | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for RealAlexandreAI/json-repair | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "RealAlexandreAI__json-repair.8d5f54f",
"repository": "RealAlexandreAI/json-repair",
"commit": "8d5f54f0bd6dd70389539b59aadc0c4e709fe5a9",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.0182843084,
"test_branches": 3,
"test_count": 444
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | realalexandreai--json-repair.8d5f54f |
programgym/redcanaryco--chain-reactor.51c25c4 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for redcanaryco/chain-reactor | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"c"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "redcanaryco__chain-reactor.51c25c4",
"repository": "redcanaryco/chain-reactor",
"commit": "51c25c4c9dfdc73085c35882d6bbb58e56c006a7",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.2773799747,
"test_branches": 4,
"test_count": 338
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | redcanaryco--chain-reactor.51c25c4 |
programgym/redcode-labs--snowcrash.32e62f9 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for redcode-labs/SNOWCRASH | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "redcode-labs__SNOWCRASH.32e62f9",
"repository": "redcode-labs/SNOWCRASH",
"commit": "32e62f9ff7d3dda9fac8acfc56176f1f2a70d066",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.4969296481,
"test_branches": 1,
"test_count": 30
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_configure_java_mirrors.sh",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-go.tar.gz",
"environme... | redcode-labs--snowcrash.32e62f9 |
programgym/redhuntlabs--bucketloot.7062f49 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for redhuntlabs/BucketLoot | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "redhuntlabs__BucketLoot.7062f49",
"repository": "redhuntlabs/BucketLoot",
"commit": "7062f49f6ae175f9c619519a812a8b955e545d7c",
"language": "go",
"difficulty": "medium",
"difficulty_score": 2.1120013955,
"test_branches": 6,
"test_count": 495
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_mo... | redhuntlabs--bucketloot.7062f49 |
programgym/redrrx--ps3dec.39bc160 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for Redrrx/ps3dec | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "Redrrx__ps3dec.39bc160",
"repository": "Redrrx/ps3dec",
"commit": "39bc160072938c1a03eec68d07e734a5fdcd3ab4",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.7697464672,
"test_branches": 4,
"test_count": 340
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | redrrx--ps3dec.39bc160 |
programgym/redspread--spread.382198a | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for redspread/spread | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "redspread__spread.382198a",
"repository": "redspread/spread",
"commit": "382198ac9350d771facc76f4242ab76ca774acb9",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.7430391548,
"test_branches": 4,
"test_count": 382
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | redspread--spread.382198a |
programgym/redux-rs--redux-rs.2865896 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for redux-rs/redux-rs | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "redux-rs__redux-rs.2865896",
"repository": "redux-rs/redux-rs",
"commit": "2865896f358bdd364b204c72433de815f55683b4",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.9329808219,
"test_branches": 4,
"test_count": 708
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/... | redux-rs--redux-rs.2865896 |
programgym/refcell--subway-rs.5682b9f | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for refcell/subway-rs | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "refcell__subway-rs.5682b9f",
"repository": "refcell/subway-rs",
"commit": "5682b9f3c3d9fe93634e8403cc2d1aedf8d01346",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.117933835,
"test_branches": 4,
"test_count": 276
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | refcell--subway-rs.5682b9f |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.