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/tsoding--snitch.da4c8d5 | 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 tsoding/snitch | [
"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": "tsoding__snitch.da4c8d5",
"repository": "tsoding/snitch",
"commit": "da4c8d5c1ca9b7d72dcdaa61f9d93bc2e12b7a5e",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.7676010681,
"test_branches": 4,
"test_count": 290
} | [
"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_... | tsoding--snitch.da4c8d5 |
programgym/tsoding--tula.e77e05a | 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 tsoding/tula | [
"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": "tsoding__tula.e77e05a",
"repository": "tsoding/tula",
"commit": "e77e05a70b91f3fc936895db924c974fc51b4ba3",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.6182573448,
"test_branches": 5,
"test_count": 922
} | [
"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/... | tsoding--tula.e77e05a |
programgym/tspooner--rl_markets.2de4cbb | 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 tspooner/rl_markets | [
"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": "tspooner__rl_markets.2de4cbb",
"repository": "tspooner/rl_markets",
"commit": "2de4cbb0936dd01cf5611e457f7bc2453403ef7d",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.8649854607,
"test_branches": 1,
"test_count": 78
} | [
"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_02.tar.gz",
"tests/blobs/tests/... | tspooner--rl_markets.2de4cbb |
programgym/ttk592--spline.5894bea | 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 ttk592/spline | [
"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": "ttk592__spline.5894bea",
"repository": "ttk592/spline",
"commit": "5894beaf91e9adbfdbe5c6c9a1c60770e380e8e8",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 0.9763499790000001,
"test_branches": 2,
"test_count": 270
} | [
"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... | ttk592--spline.5894bea |
programgym/tvrzna--emptty.9beb781 | 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 tvrzna/emptty | [
"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": "tvrzna__emptty.9beb781",
"repository": "tvrzna/emptty",
"commit": "9beb78194a1c3043223177342cbe74f891c43dd7",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.8754085601,
"test_branches": 4,
"test_count": 695
} | [
"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_... | tvrzna--emptty.9beb781 |
programgym/tweedegolf--mailcrab.f631533 | 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 tweedegolf/mailcrab | [
"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": "tweedegolf__mailcrab.f631533",
"repository": "tweedegolf/mailcrab",
"commit": "f6315337ffcc02fd82c606959e8f2d9922c4932c",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.4225898399,
"test_branches": 3,
"test_count": 598
} | [
"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/... | tweedegolf--mailcrab.f631533 |
programgym/twistlock--authz.2fa4df2 | 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 twistlock/authz | [
"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": "twistlock__authz.2fa4df2",
"repository": "twistlock/authz",
"commit": "2fa4df2972a0407a13648694fc50306972863e36",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.9947569446000001,
"test_branches": 4,
"test_count": 616
} | [
"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_... | twistlock--authz.2fa4df2 |
programgym/twpayne--go-jsonstruct.3bc2d7b | 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 twpayne/go-jsonstruct | [
"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": "twpayne__go-jsonstruct.3bc2d7b",
"repository": "twpayne/go-jsonstruct",
"commit": "3bc2d7bd7e05bad26a86ca3d1e9fb027753d556f",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9017851452999999,
"test_branches": 4,
"test_count": 585
} | [
"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_... | twpayne--go-jsonstruct.3bc2d7b |
programgym/txn2--txeh.b1816bc | 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 txn2/txeh | [
"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": "txn2__txeh.b1816bc",
"repository": "txn2/txeh",
"commit": "b1816bc4833c6fc8cac831cf7f28eba51a071865",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9185545306,
"test_branches": 5,
"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_... | txn2--txeh.b1816bc |
programgym/tylerbrock--saw.00fd4b4 | 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 TylerBrock/saw | [
"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": "TylerBrock__saw.00fd4b4",
"repository": "TylerBrock/saw",
"commit": "00fd4b4c7df009add8af2b7d6c1629cd174217fe",
"language": "go",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 3,
"test_count": 302
} | [
"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_... | tylerbrock--saw.00fd4b4 |
programgym/tylertreat--comcast.145d021 | 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 tylertreat/comcast | [
"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": "tylertreat__comcast.145d021",
"repository": "tylertreat/comcast",
"commit": "145d02155cffc03bb4ed878c9d6441dc49f3cdaa",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.2741578493,
"test_branches": 4,
"test_count": 257
} | [
"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... | tylertreat--comcast.145d021 |
programgym/tylous--zipexec.f8d661f | 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 Tylous/ZipExec | [
"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": "Tylous__ZipExec.f8d661f",
"repository": "Tylous/ZipExec",
"commit": "f8d661fab20cb4d52e47f140f48f9ea34d176acb",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.0877814178,
"test_branches": 1,
"test_count": 20
} | [
"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_... | tylous--zipexec.f8d661f |
programgym/uber--arachne.c5fcff7 | 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 uber/arachne | [
"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": "uber__arachne.c5fcff7",
"repository": "uber/arachne",
"commit": "c5fcff73f1eea2cde109c5cec2bc6f806291e31b",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5354207181000001,
"test_branches": 4,
"test_count": 146
} | [
"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... | uber--arachne.c5fcff7 |
programgym/uber--astro.a16ed4d | 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 uber/astro | [
"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": "uber__astro.a16ed4d",
"repository": "uber/astro",
"commit": "a16ed4ddcc66eeeeea8b9db5a26ef4a8412e3cec",
"language": "go",
"difficulty": "medium",
"difficulty_score": 3.2464616494,
"test_branches": 6,
"test_count": 371
} | [
"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... | uber--astro.a16ed4d |
programgym/uber--ringpop-go.dc480c0 | 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 uber/ringpop-go | [
"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": "uber__ringpop-go.dc480c0",
"repository": "uber/ringpop-go",
"commit": "dc480c0aeadc0ae3dfe1c10b47024250014b6aa9",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9955913243,
"test_branches": 4,
"test_count": 243
} | [
"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_... | uber--ringpop-go.dc480c0 |
programgym/uber-go--sally.b6c35a1 | 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 uber-go/sally | [
"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": "uber-go__sally.b6c35a1",
"repository": "uber-go/sally",
"commit": "b6c35a1200554018798a2725215bc027320acc8d",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5007851729000001,
"test_branches": 3,
"test_count": 223
} | [
"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_... | uber-go--sally.b6c35a1 |
programgym/ugeneunipro--ugene.e177f75 | 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 ugeneunipro/ugene | [
"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": "ugeneunipro__ugene.e177f75",
"repository": "ugeneunipro/ugene",
"commit": "e177f75f3deebf8d659f9a24f1214aa0c61f84b0",
"language": "cpp",
"difficulty": "hard",
"difficulty_score": 4.4972595312,
"test_branches": 8,
"test_count": 242
} | [
"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... | ugeneunipro--ugene.e177f75 |
programgym/umair9747--genzai.b2e2fec | 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 umair9747/Genzai | [
"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": "umair9747__Genzai.b2e2fec",
"repository": "umair9747/Genzai",
"commit": "b2e2feca5c26bf39c0ec41b0e191a49c2b3a4118",
"language": "go",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 4,
"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_... | umair9747--genzai.b2e2fec |
programgym/umskt--umskt.77c7eb5 | 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 UMSKT/UMSKT | [
"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": "UMSKT__UMSKT.77c7eb5",
"repository": "UMSKT/UMSKT",
"commit": "77c7eb5ca209cc3a81515564e5b78cb4d235b110",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 2.0836101052,
"test_branches": 5,
"test_count": 810
} | [
"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... | umskt--umskt.77c7eb5 |
programgym/umutcamliyurt--pingrat.d6714b8 | 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 umutcamliyurt/PingRAT | [
"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": "umutcamliyurt__PingRAT.d6714b8",
"repository": "umutcamliyurt/PingRAT",
"commit": "d6714b8ad20dd4bbaa23b195d7f4ec3091714d79",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.7972675408000001,
"test_branches": 1,
"test_count": 29
} | [
"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... | umutcamliyurt--pingrat.d6714b8 |
programgym/umutphp--awesome-cli.fb83c2f | 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 umutphp/awesome-cli | [
"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": "umutphp__awesome-cli.fb83c2f",
"repository": "umutphp/awesome-cli",
"commit": "fb83c2f82052482b6ef3cd837b24f49a1566ae04",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.7611758132,
"test_branches": 5,
"test_count": 226
} | [
"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_... | umutphp--awesome-cli.fb83c2f |
programgym/undeadsec--dockerspy.030b422 | 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 UndeadSec/DockerSpy | [
"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": "UndeadSec__DockerSpy.030b422",
"repository": "UndeadSec/DockerSpy",
"commit": "030b4224f4280596ff4ebafa774ecf3277a5c4be",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.42894429,
"test_branches": 2,
"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_... | undeadsec--dockerspy.030b422 |
programgym/uneedcrydear--yolov8-opencv-onnxruntime-cpp.ddd906c | 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 UNeedCryDear/yolov8-opencv-onnxruntime-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": "UNeedCryDear__yolov8-opencv-onnxruntime-cpp.ddd906c",
"repository": "UNeedCryDear/yolov8-opencv-onnxruntime-cpp",
"commit": "ddd906cd9e5e459f2bc9788985fc8516476b5aba",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.7894396846,
"test_branches": 3,... | [
"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... | uneedcrydear--yolov8-opencv-onnxruntime-cpp.ddd906c |
programgym/unixpickle--gobfuscate.1379633 | 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 unixpickle/gobfuscate | [
"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": "unixpickle__gobfuscate.1379633",
"repository": "unixpickle/gobfuscate",
"commit": "13796335c727f53349ac9c3aa3d2fc812fa8c2d4",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.3360592779,
"test_branches": 4,
"test_count": 75
} | [
"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_... | unixpickle--gobfuscate.1379633 |
programgym/unknwon--bra.1e3013e | 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 unknwon/bra | [
"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": "unknwon__bra.1e3013e",
"repository": "unknwon/bra",
"commit": "1e3013ecaff8fb5d27abc2bb6d6be3a5f07c622f",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9275756547,
"test_branches": 4,
"test_count": 120
} | [
"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_... | unknwon--bra.1e3013e |
programgym/upmc-enterprises--kubernetes-secret-manager.eafcc00 | 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 upmc-enterprises/kubernetes-secret-manager | [
"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": "upmc-enterprises__kubernetes-secret-manager.eafcc00",
"repository": "upmc-enterprises/kubernetes-secret-manager",
"commit": "eafcc00c612c9be837c9b52e10a5c15e18891f23",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.0261245167,
"test_branches": 4,
... | [
"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_... | upmc-enterprises--kubernetes-secret-manager.eafcc00 |
programgym/upmc-enterprises--registry-creds.b2e8fec | 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 upmc-enterprises/registry-creds | [
"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": "upmc-enterprises__registry-creds.b2e8fec",
"repository": "upmc-enterprises/registry-creds",
"commit": "b2e8fec4e549c2b39ac9896d6a25e1b612e421d8",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.922725458,
"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_... | upmc-enterprises--registry-creds.b2e8fec |
programgym/usnistgov--frvt.18c2f84 | 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 usnistgov/frvt | [
"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": "usnistgov__frvt.18c2f84",
"repository": "usnistgov/frvt",
"commit": "18c2f84d80c0636cede6ff1db0479fe068aedac4",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.8668188029000001,
"test_branches": 3,
"test_count": 256
} | [
"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... | usnistgov--frvt.18c2f84 |
programgym/utilforever--cubbyflow.5b786fe | 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 utilForever/CubbyFlow | [
"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": "utilForever__CubbyFlow.5b786fe",
"repository": "utilForever/CubbyFlow",
"commit": "5b786fee61dba958a5a2c9e5f123739f32592293",
"language": "cpp",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 7,
"test_count": 910
} | [
"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... | utilforever--cubbyflow.5b786fe |
programgym/utilforever--rosettastone.09f4347 | 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 utilForever/RosettaStone | [
"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": "utilForever__RosettaStone.09f4347",
"repository": "utilForever/RosettaStone",
"commit": "09f4347e5402248a8ad2990b489e2d0b0e67bc55",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 3.7150217318000003,
"test_branches": 5,
"test_count": 299
} | [
"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_02.tar.gz",
"tests/blobs/tests/... | utilforever--rosettastone.09f4347 |
programgym/utkarshkukreti--markup.rs.41d5418 | 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 utkarshkukreti/markup.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": "utkarshkukreti__markup.rs.41d5418",
"repository": "utkarshkukreti/markup.rs",
"commit": "41d541819a29230b7857ee1c59cfd5816ad82076",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.1398790864000001,
"test_branches": 4,
"test_count": 863
} | [
"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/... | utkarshkukreti--markup.rs.41d5418 |
programgym/utkarshkukreti--select.rs.be366b1 | 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 utkarshkukreti/select.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": "utkarshkukreti__select.rs.be366b1",
"repository": "utkarshkukreti/select.rs",
"commit": "be366b12ccf18b45e6b0bf343b6369d49972941e",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.6132073520999999,
"test_branches": 5,
"test_count": 808
} | [
"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... | utkarshkukreti--select.rs.be366b1 |
programgym/utkusen--urlhunter.39f2051 | 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 utkusen/urlhunter | [
"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": "utkusen__urlhunter.39f2051",
"repository": "utkusen/urlhunter",
"commit": "39f2051895b95f93f1dadeba2cfd235d920f945e",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9620376866,
"test_branches": 1,
"test_count": 25
} | [
"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/download.sh",
"tests... | utkusen--urlhunter.39f2051 |
programgym/uudashr--gocognit.5b8ec1c | 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 uudashr/gocognit | [
"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": "uudashr__gocognit.5b8ec1c",
"repository": "uudashr/gocognit",
"commit": "5b8ec1cd6a28032e4e38356b6e913ea5fe7a8d63",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.8340390182,
"test_branches": 4,
"test_count": 322
} | [
"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_... | uudashr--gocognit.5b8ec1c |
programgym/v-e-o--rdp2tcp.0a54991 | 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 V-E-O/rdp2tcp | [
"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": "V-E-O__rdp2tcp.0a54991",
"repository": "V-E-O/rdp2tcp",
"commit": "0a54991e669e8636b129a60e9ff5baa2fc91d1af",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.8451600777000001,
"test_branches": 4,
"test_count": 709
} | [
"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/... | v-e-o--rdp2tcp.0a54991 |
programgym/v2fly--domain-list-community.2f29418 | 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 v2fly/domain-list-community | [
"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": "v2fly__domain-list-community.2f29418",
"repository": "v2fly/domain-list-community",
"commit": "2f294188c3e0e0db33c44d8376b8ac0fc305e956",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6685722692,
"test_branches": 1,
"test_count": 90
} | [
"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/download.sh",
"tests... | v2fly--domain-list-community.2f29418 |
programgym/v4l2loopback--v4l2loopback.9ef83fb | 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 v4l2loopback/v4l2loopback | [
"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": "v4l2loopback__v4l2loopback.9ef83fb",
"repository": "v4l2loopback/v4l2loopback",
"commit": "9ef83fb9bc88e8f841786753c362ac52c580defc",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.7638770315,
"test_branches": 3,
"test_count": 555
} | [
"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/... | v4l2loopback--v4l2loopback.9ef83fb |
programgym/vakuum--tcptunnel.1e8ee4c | 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 vakuum/tcptunnel | [
"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": "vakuum__tcptunnel.1e8ee4c",
"repository": "vakuum/tcptunnel",
"commit": "1e8ee4c674bd25fc5f699a840624b042cc74bcd1",
"language": "c",
"difficulty": "easy",
"difficulty_score": 0.7641761324,
"test_branches": 1,
"test_count": 79
} | [
"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... | vakuum--tcptunnel.1e8ee4c |
programgym/vector-of-bool--bpt.f05f82c | 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 vector-of-bool/bpt | [
"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": "vector-of-bool__bpt.f05f82c",
"repository": "vector-of-bool/bpt",
"commit": "f05f82c5be88eb2279cdd2f5772d033a221f5607",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 3.5972409133000003,
"test_branches": 7,
"test_count": 972
} | [
"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... | vector-of-bool--bpt.f05f82c |
programgym/veggiedefender--torrent-client.e0f58e0 | 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 veggiedefender/torrent-client | [
"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": "veggiedefender__torrent-client.e0f58e0",
"repository": "veggiedefender/torrent-client",
"commit": "e0f58e0b16e4a9d1bd889f8cb61d835b8ec13385",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.4146391467,
"test_branches": 4,
"test_count": 145
} | [
"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... | veggiedefender--torrent-client.e0f58e0 |
programgym/viaduct-ai--kustomize-sops.d9442dc | 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 viaduct-ai/kustomize-sops | [
"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": "viaduct-ai__kustomize-sops.d9442dc",
"repository": "viaduct-ai/kustomize-sops",
"commit": "d9442dc3153d9c16e517a68ce8926c9507386429",
"language": "go",
"difficulty": "medium",
"difficulty_score": 2.7489009254,
"test_branches": 2,
"test_count": 79
} | [
"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... | viaduct-ai--kustomize-sops.d9442dc |
programgym/victoriametrics--prometheus-benchmark.f8c344d | 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 VictoriaMetrics/prometheus-benchmark | [
"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": "VictoriaMetrics__prometheus-benchmark.f8c344d",
"repository": "VictoriaMetrics/prometheus-benchmark",
"commit": "f8c344d7e24bcab47121d0d6d8c0012720de569c",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.4048337166,
"test_branches": 1,
"test_coun... | [
"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/download.sh",
"tests... | victoriametrics--prometheus-benchmark.f8c344d |
programgym/victorvde--jpeg2png.04054a2 | 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 victorvde/jpeg2png | [
"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": "victorvde__jpeg2png.04054a2",
"repository": "victorvde/jpeg2png",
"commit": "04054a2ee78b08cfbe69c71f84f9d84c0aedd9f3",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.3624824748,
"test_branches": 4,
"test_count": 618
} | [
"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/... | victorvde--jpeg2png.04054a2 |
programgym/vietjtnguyen--argagg.aab29c3 | 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 vietjtnguyen/argagg | [
"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": "vietjtnguyen__argagg.aab29c3",
"repository": "vietjtnguyen/argagg",
"commit": "aab29c364a68890e0d438ce06f26268b5e1a70fb",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.2951270853,
"test_branches": 3,
"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... | vietjtnguyen--argagg.aab29c3 |
programgym/vimpostor--blobdrop.ef5b842 | 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 vimpostor/blobdrop | [
"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": "vimpostor__blobdrop.ef5b842",
"repository": "vimpostor/blobdrop",
"commit": "ef5b842cfd9af240649c089c09944cd3207a514e",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.5866998016,
"test_branches": 4,
"test_count": 331
} | [
"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... | vimpostor--blobdrop.ef5b842 |
programgym/vincent-therrien--gpu-arena.c631290 | 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 Vincent-Therrien/gpu-arena | [
"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": "Vincent-Therrien__gpu-arena.c631290",
"repository": "Vincent-Therrien/gpu-arena",
"commit": "c6312907c90e64548ca37c594937d464f247a67a",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.4463818122,
"test_branches": 4,
"test_count": 302
} | [
"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... | vincent-therrien--gpu-arena.c631290 |
programgym/visit1985--mdp.da63304 | 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 visit1985/mdp | [
"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": "visit1985__mdp.da63304",
"repository": "visit1985/mdp",
"commit": "da6330468f28292af493a6d2454285dc8aafbc92",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.5002364747999999,
"test_branches": 4,
"test_count": 968
} | [
"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... | visit1985--mdp.da63304 |
programgym/visma-prodsec--confused.96fb2e4 | 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 visma-prodsec/confused | [
"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": "visma-prodsec__confused.96fb2e4",
"repository": "visma-prodsec/confused",
"commit": "96fb2e46047e9c0c4b7dfa29d03f36463fd54b2b",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.9813655091000001,
"test_branches": 4,
"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_01.tar.gz",
"tests/blobs/tests/generated_... | visma-prodsec--confused.96fb2e4 |
programgym/vitaut--zmij.c5998fb | 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 vitaut/zmij | [
"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": "vitaut__zmij.c5998fb",
"repository": "vitaut/zmij",
"commit": "c5998fb9a7ec37a55d931ef05138d296074962cc",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.5618166643,
"test_branches": 4,
"test_count": 560
} | [
"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... | vitaut--zmij.c5998fb |
programgym/vividboarder--vaultwarden_ldap.7bf91f3 | 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 ViViDboarder/vaultwarden_ldap | [
"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": "ViViDboarder__vaultwarden_ldap.7bf91f3",
"repository": "ViViDboarder/vaultwarden_ldap",
"commit": "7bf91f3ec42708717a8bcc26d70fa39da5cbff23",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.8217099973000002,
"test_branches": 3,
"test_count": 26... | [
"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/... | vividboarder--vaultwarden_ldap.7bf91f3 |
programgym/vividcortex--siesta.99bec23 | 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 VividCortex/siesta | [
"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": "VividCortex__siesta.99bec23",
"repository": "VividCortex/siesta",
"commit": "99bec23e0323737e60e902b0dc1be48f415cbc69",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.1519823955,
"test_branches": 4,
"test_count": 293
} | [
"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_... | vividcortex--siesta.99bec23 |
programgym/vivkin--gason.c9c4aa6 | 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 vivkin/gason | [
"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": "vivkin__gason.c9c4aa6",
"repository": "vivkin/gason",
"commit": "c9c4aa632bd313ac92c185e0e0abf3b882be9d81",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 0.9628426812,
"test_branches": 3,
"test_count": 736
} | [
"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/... | vivkin--gason.c9c4aa6 |
programgym/vjeantet--grok.e39bbec | 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 vjeantet/grok | [
"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": "vjeantet__grok.e39bbec",
"repository": "vjeantet/grok",
"commit": "e39bbec1767113580e4bec1219205cffc8ba371c",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.8122446968,
"test_branches": 4,
"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_... | vjeantet--grok.e39bbec |
programgym/vladimirvivien--learning-go.a19a03f | 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 vladimirvivien/learning-go | [
"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": "vladimirvivien__learning-go.a19a03f",
"repository": "vladimirvivien/learning-go",
"commit": "a19a03fea47fa593960ec429c054fc433557c8c9",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.975385849,
"test_branches": 4,
"test_count": 385
} | [
"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_... | vladimirvivien--learning-go.a19a03f |
programgym/voultapher--self_cell.3b0f5c3 | 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 Voultapher/self_cell | [
"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": "Voultapher__self_cell.3b0f5c3",
"repository": "Voultapher/self_cell",
"commit": "3b0f5c363ca8adbece7cb3c93c978e6153e3a4b7",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.5309676816,
"test_branches": 4,
"test_count": 676
} | [
"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... | voultapher--self_cell.3b0f5c3 |
programgym/voutcn--megahit.c77d45c | 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 voutcn/megahit | [
"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": "voutcn__megahit.c77d45c",
"repository": "voutcn/megahit",
"commit": "c77d45c1f516e4f4a90c255c5c6d0c8ba27c017f",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 2.985475874,
"test_branches": 4,
"test_count": 541
} | [
"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... | voutcn--megahit.c77d45c |
programgym/vpenso--prometheus-slurm-exporter.895c7c6 | 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 vpenso/prometheus-slurm-exporter | [
"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": "vpenso__prometheus-slurm-exporter.895c7c6",
"repository": "vpenso/prometheus-slurm-exporter",
"commit": "895c7c6b8fec16dc45ea2f97e9e2c2202606c30c",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.7867514221,
"test_branches": 4,
"test_count": 236
... | [
"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... | vpenso--prometheus-slurm-exporter.895c7c6 |
programgym/vrsperanza--cpy.27502db | 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 vrsperanza/CPY | [
"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": "vrsperanza__CPY.27502db",
"repository": "vrsperanza/CPY",
"commit": "27502dbe796d51c182788ecef54124e9e8eb8e79",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.3984608496,
"test_branches": 4,
"test_count": 278
} | [
"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... | vrsperanza--cpy.27502db |
programgym/vxfemboy--ghostport.74d0844 | 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 vxfemboy/ghostport | [
"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": "vxfemboy__ghostport.74d0844",
"repository": "vxfemboy/ghostport",
"commit": "74d0844020ef1349d5e66db65a02dd470ee1c6e4",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.3944516808,
"test_branches": 3,
"test_count": 494
} | [
"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/... | vxfemboy--ghostport.74d0844 |
programgym/vygr--chrysalisp.fcaa0e2 | 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 vygr/ChrysaLisp | [
"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": "vygr__ChrysaLisp.fcaa0e2",
"repository": "vygr/ChrysaLisp",
"commit": "fcaa0e2099d603dac6ce519602c25478f3019141",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.6026025204,
"test_branches": 2,
"test_count": 374
} | [
"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... | vygr--chrysalisp.fcaa0e2 |
programgym/w4--pisshoff.b6882c1 | 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 w4/pisshoff | [
"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": "w4__pisshoff.b6882c1",
"repository": "w4/pisshoff",
"commit": "b6882c17e0e36d85efce3004826cc9042b76fc4e",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.6620964454,
"test_branches": 4,
"test_count": 493
} | [
"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... | w4--pisshoff.b6882c1 |
programgym/wadackel--vim-dogrun.167a718 | 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 wadackel/vim-dogrun | [
"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": "wadackel__vim-dogrun.167a718",
"repository": "wadackel/vim-dogrun",
"commit": "167a7181f5151927a18f93dcc7a67f8219d4d5ba",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.3087777737000001,
"test_branches": 4,
"test_count": 1396
} | [
"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/... | wadackel--vim-dogrun.167a718 |
programgym/waldjohannau--3rscan.12f040d | 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 WaldJohannaU/3RScan | [
"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": "WaldJohannaU__3RScan.12f040d",
"repository": "WaldJohannaU/3RScan",
"commit": "12f040d3dc849e394ed366acd7b54e63acb49205",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.8679975103,
"test_branches": 1,
"test_count": 74
} | [
"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... | waldjohannau--3rscan.12f040d |
programgym/walle--wiki.9ef1ae3 | 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 walle/wiki | [
"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": "walle__wiki.9ef1ae3",
"repository": "walle/wiki",
"commit": "9ef1ae3de61a9f8298434c69c80403069d57de12",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.9809119378000001,
"test_branches": 4,
"test_count": 162
} | [
"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_... | walle--wiki.9ef1ae3 |
programgym/walter-cd--walter.faf3786 | 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 walter-cd/walter | [
"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": "walter-cd__walter.faf3786",
"repository": "walter-cd/walter",
"commit": "faf37864b9535e97f2f69fea295e519be8f4c950",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.9247959958,
"test_branches": 3,
"test_count": 229
} | [
"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_... | walter-cd--walter.faf3786 |
programgym/wandercn--hotbuild.e1b9474 | 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 wandercn/hotbuild | [
"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": "wandercn__hotbuild.e1b9474",
"repository": "wandercn/hotbuild",
"commit": "e1b9474cb2ee2f0499303941a1035697d8420206",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.4763968267,
"test_branches": 4,
"test_count": 235
} | [
"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_... | wandercn--hotbuild.e1b9474 |
programgym/wantguns--bin.a03bb47 | 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 wantguns/bin | [
"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": "wantguns__bin.a03bb47",
"repository": "wantguns/bin",
"commit": "a03bb47b806e285e91344f8d80e8f08bcefac87a",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.9222062774,
"test_branches": 3,
"test_count": 398
} | [
"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... | wantguns--bin.a03bb47 |
programgym/wasplang--wasp.9cc072c | 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 wasplang/wasp | [
"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": "wasplang__wasp.9cc072c",
"repository": "wasplang/wasp",
"commit": "9cc072c663f6f9ff7cf95e526be2083dd5b4ae32",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.1737688231,
"test_branches": 2,
"test_count": 275
} | [
"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/... | wasplang--wasp.9cc072c |
programgym/waywardgeek--sonic.b93885d | 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 waywardgeek/sonic | [
"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": "waywardgeek__sonic.b93885d",
"repository": "waywardgeek/sonic",
"commit": "b93885dcb70aae50c6f76b0fe4e0868f029a077e",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.6801541417,
"test_branches": 4,
"test_count": 618
} | [
"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/... | waywardgeek--sonic.b93885d |
programgym/webassembly--wabt.2b2fb60 | 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 WebAssembly/wabt | [
"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": "WebAssembly__wabt.2b2fb60",
"repository": "WebAssembly/wabt",
"commit": "2b2fb60ff9c3a87c47480c0010536f172e851d9c",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 3.5357497003000002,
"test_branches": 7,
"test_count": 3051
} | [
"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/... | webassembly--wabt.2b2fb60 |
programgym/webui-dev--go-webui.bae0d37 | 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 webui-dev/go-webui | [
"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": "webui-dev__go-webui.bae0d37",
"repository": "webui-dev/go-webui",
"commit": "bae0d37631b08661720412a973a652736c54d95b",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.1541195255,
"test_branches": 3,
"test_count": 50
} | [
"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... | webui-dev--go-webui.bae0d37 |
programgym/wendigo--chrome-protocol-proxy.c247f44 | 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 wendigo/chrome-protocol-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": "wendigo__chrome-protocol-proxy.c247f44",
"repository": "wendigo/chrome-protocol-proxy",
"commit": "c247f44dc31192ea901f8f86580da9edd772888f",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.7920413107000002,
"test_branches": 4,
"test_count": 232
... | [
"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_... | wendigo--chrome-protocol-proxy.c247f44 |
programgym/wernerd--gortp.e9fed0e | 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 wernerd/GoRTP | [
"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": "wernerd__GoRTP.e9fed0e",
"repository": "wernerd/GoRTP",
"commit": "e9fed0e9ccf72b31cbb4b16cf38f5c9434afbf95",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.612465964,
"test_branches": 4,
"test_count": 87
} | [
"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... | wernerd--gortp.e9fed0e |
programgym/wetube--bitcloud.75036a2 | 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 wetube/bitcloud | [
"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": "wetube__bitcloud.75036a2",
"repository": "wetube/bitcloud",
"commit": "75036a2dde59012b14a26d98bfe221dba0e9e940",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.4413808849,
"test_branches": 4,
"test_count": 682
} | [
"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... | wetube--bitcloud.75036a2 |
programgym/whytheplatypus--switchboard.96dc398 | 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 whytheplatypus/switchboard | [
"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": "whytheplatypus__switchboard.96dc398",
"repository": "whytheplatypus/switchboard",
"commit": "96dc39893f81acca7e1b90f30c0b97bf0894ae39",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.8825814536,
"test_branches": 4,
"test_count": 183
} | [
"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_... | whytheplatypus--switchboard.96dc398 |
programgym/willdoescode--nat.48ba135 | 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 willdoescode/nat | [
"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": "willdoescode__nat.48ba135",
"repository": "willdoescode/nat",
"commit": "48ba1352cf2113e4152cadc3ff5a2c9b2b348499",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.7724684031,
"test_branches": 4,
"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/... | willdoescode--nat.48ba135 |
programgym/windytan--redsea.bc8cae4 | 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 windytan/redsea | [
"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": "windytan__redsea.bc8cae4",
"repository": "windytan/redsea",
"commit": "bc8cae4dc3121dede8f9fa1e29ffa6b83a15079f",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.9802761411,
"test_branches": 2,
"test_count": 375
} | [
"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... | windytan--redsea.bc8cae4 |
programgym/wjakob--filesystem.c5f9de3 | 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 wjakob/filesystem | [
"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": "wjakob__filesystem.c5f9de3",
"repository": "wjakob/filesystem",
"commit": "c5f9de30142453eb3c6fe991e82dfc2583373116",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 0.7634279936,
"test_branches": 4,
"test_count": 318
} | [
"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... | wjakob--filesystem.c5f9de3 |
programgym/wjwwood--serial.69e0372 | 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 wjwwood/serial | [
"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": "wjwwood__serial.69e0372",
"repository": "wjwwood/serial",
"commit": "69e0372cf0d3796e84ce9a09aff1d74496f68720",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.9238654752,
"test_branches": 5,
"test_count": 253
} | [
"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... | wjwwood--serial.69e0372 |
programgym/wollomatic--socket-proxy.730fea8 | 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 wollomatic/socket-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": "wollomatic__socket-proxy.730fea8",
"repository": "wollomatic/socket-proxy",
"commit": "730fea8c84a340731da6f1256e6b7407b4f12f68",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.4423229557,
"test_branches": 4,
"test_count": 263
} | [
"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... | wollomatic--socket-proxy.730fea8 |
programgym/woodrush--lisp-in-life.34954f4 | 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 woodrush/lisp-in-life | [
"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": "woodrush__lisp-in-life.34954f4",
"repository": "woodrush/lisp-in-life",
"commit": "34954f47ce378a3b06c5bfc83d9d711526ff57ae",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.193958978,
"test_branches": 1,
"test_count": 381
} | [
"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"... | woodrush--lisp-in-life.34954f4 |
programgym/wpmed92--mednes.19e5b47 | 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 wpmed92/MedNES | [
"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": "wpmed92__MedNES.19e5b47",
"repository": "wpmed92/MedNES",
"commit": "19e5b47dbd176ed8ca52f0805e392a7cbdc6aee4",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.5721743136000002,
"test_branches": 5,
"test_count": 485
} | [
"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/... | wpmed92--mednes.19e5b47 |
programgym/wtarreau--bootterm.a83ddbc | 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 wtarreau/bootterm | [
"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": "wtarreau__bootterm.a83ddbc",
"repository": "wtarreau/bootterm",
"commit": "a83ddbc5a34c4fdc677e798d6f072e5b8b23adc2",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.3948017772,
"test_branches": 1,
"test_count": 308
} | [
"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"... | wtarreau--bootterm.a83ddbc |
programgym/wubingzheng--memleax.fd42a3d | 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 WuBingzheng/memleax | [
"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": "WuBingzheng__memleax.fd42a3d",
"repository": "WuBingzheng/memleax",
"commit": "fd42a3d990e2fd3e248decba578f0e1533ce51fa",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.7489628613,
"test_branches": 4,
"test_count": 666
} | [
"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/... | wubingzheng--memleax.fd42a3d |
programgym/wwwg--wasmdec.3d9e5ca | 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 wwwg/wasmdec | [
"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": "wwwg__wasmdec.3d9e5ca",
"repository": "wwwg/wasmdec",
"commit": "3d9e5ca66ece79efe8f6550fd03623bd1dea3ec5",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.332034277,
"test_branches": 4,
"test_count": 365
} | [
"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... | wwwg--wasmdec.3d9e5ca |
programgym/wybiral--tube.13ffd71 | 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 wybiral/tube | [
"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": "wybiral__tube.13ffd71",
"repository": "wybiral/tube",
"commit": "13ffd7117180d1a3093ff291481caeb07a8b71de",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.948901761,
"test_branches": 4,
"test_count": 199
} | [
"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... | wybiral--tube.13ffd71 |
programgym/xarantolus--filtrite.692d855 | 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 xarantolus/filtrite | [
"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": "xarantolus__filtrite.692d855",
"repository": "xarantolus/filtrite",
"commit": "692d855af409fb97350c91d7a50fdf3fb7cc09c8",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.5237464668,
"test_branches": 4,
"test_count": 153
} | [
"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_... | xarantolus--filtrite.692d855 |
programgym/xcuri0--rebaruefi.9c80fdb | 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 xCuri0/ReBarUEFI | [
"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": "xCuri0__ReBarUEFI.9c80fdb",
"repository": "xCuri0/ReBarUEFI",
"commit": "9c80fdb2cd3db94bdd19c58bd00d5ecf822f6430",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.3242824553,
"test_branches": 1,
"test_count": 495
} | [
"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... | xcuri0--rebaruefi.9c80fdb |
programgym/xfiftyone--sts2g.bc655d6 | 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 xfiftyone/STS2G | [
"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": "xfiftyone__STS2G.bc655d6",
"repository": "xfiftyone/STS2G",
"commit": "bc655d60107e05550c52027e0ce27fe47b07c703",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6159500517,
"test_branches": 4,
"test_count": 199
} | [
"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_... | xfiftyone--sts2g.bc655d6 |
programgym/xiaohuiyan--btm.66cc9b4 | 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 xiaohuiyan/BTM | [
"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": "xiaohuiyan__BTM.66cc9b4",
"repository": "xiaohuiyan/BTM",
"commit": "66cc9b475afec81f3e74bb393b874b3fe5d5a148",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.1880843737,
"test_branches": 4,
"test_count": 340
} | [
"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... | xiaohuiyan--btm.66cc9b4 |
programgym/xlzd--gotp.1546cf1 | 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 xlzd/gotp | [
"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": "xlzd__gotp.1546cf1",
"repository": "xlzd/gotp",
"commit": "1546cf172da88cbf9db039f1035c468a44d16e1a",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.5037906831,
"test_branches": 4,
"test_count": 90
} | [
"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... | xlzd--gotp.1546cf1 |
programgym/xmba15--onnx_runtime_cpp.f3f40a0 | 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 xmba15/onnx_runtime_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": "xmba15__onnx_runtime_cpp.f3f40a0",
"repository": "xmba15/onnx_runtime_cpp",
"commit": "f3f40a04fdb1074bf8de596edf92fbdbaa802660",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.6642658001,
"test_branches": 2,
"test_count": 180
} | [
"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_03.tar.gz",
"tests/blobs/tests/... | xmba15--onnx_runtime_cpp.f3f40a0 |
programgym/xuemian168--domain-scanner.1ef81ec | 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 xuemian168/domain-scanner | [
"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": "xuemian168__domain-scanner.1ef81ec",
"repository": "xuemian168/domain-scanner",
"commit": "1ef81ecca4386111edcfb51e306fb9ea30b770e6",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9857856178,
"test_branches": 4,
"test_count": 459
} | [
"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_... | xuemian168--domain-scanner.1ef81ec |
programgym/xwjdsh--manssh.a7b987e | 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 xwjdsh/manssh | [
"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": "xwjdsh__manssh.a7b987e",
"repository": "xwjdsh/manssh",
"commit": "a7b987ecdbf187a1b6c02af7018482bdce0ef8be",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9960736545,
"test_branches": 4,
"test_count": 313
} | [
"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_... | xwjdsh--manssh.a7b987e |
programgym/xyproto--png2svg.0bd9e09 | 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 xyproto/png2svg | [
"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": "xyproto__png2svg.0bd9e09",
"repository": "xyproto/png2svg",
"commit": "0bd9e0969b1ee96bad7680d62d5c0f8fc430fcb1",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9542425094,
"test_branches": 4,
"test_count": 176
} | [
"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... | xyproto--png2svg.0bd9e09 |
programgym/y-256--libdivsufsort.5f60d6f | 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 y-256/libdivsufsort | [
"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": "y-256__libdivsufsort.5f60d6f",
"repository": "y-256/libdivsufsort",
"commit": "5f60d6f026c30fb4ac296f696b3c8b0eb71bd428",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.377852419,
"test_branches": 4,
"test_count": 2085
} | [
"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/... | y-256--libdivsufsort.5f60d6f |
programgym/yahoo--webseclab.c418d54 | 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 yahoo/webseclab | [
"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": "yahoo__webseclab.c418d54",
"repository": "yahoo/webseclab",
"commit": "c418d54ced8f5604719c99117f6d89e1cd785328",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5368108660000002,
"test_branches": 4,
"test_count": 269
} | [
"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... | yahoo--webseclab.c418d54 |
programgym/yamafaktory--jql.36ff57b | 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 yamafaktory/jql | [
"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": "yamafaktory__jql.36ff57b",
"repository": "yamafaktory/jql",
"commit": "36ff57ba46010fd4be8853efaa90fc38ba304aa2",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.4905203094,
"test_branches": 4,
"test_count": 1327
} | [
"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/... | yamafaktory--jql.36ff57b |
programgym/yangjiaolong--go-icp.937f114 | 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 yangjiaolong/Go-ICP | [
"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": "yangjiaolong__Go-ICP.937f114",
"repository": "yangjiaolong/Go-ICP",
"commit": "937f114590f7df8b003d05f594b55527e230fef0",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.7214808548,
"test_branches": 4,
"test_count": 305
} | [
"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... | yangjiaolong--go-icp.937f114 |
programgym/yannh--redis-dump-go.bd39059 | 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 yannh/redis-dump-go | [
"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": "yannh__redis-dump-go.bd39059",
"repository": "yannh/redis-dump-go",
"commit": "bd3905900de92c322bbcec37bd6eca9f4657fc66",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.3725438008,
"test_branches": 4,
"test_count": 123
} | [
"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... | yannh--redis-dump-go.bd39059 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.