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/hashicorp--serf.32f656e | 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 hashicorp/serf | [
"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": "hashicorp__serf.32f656e",
"repository": "hashicorp/serf",
"commit": "32f656e77368236c57047b38618217187dfa1784",
"language": "go",
"difficulty": "medium",
"difficulty_score": 3.7562411847,
"test_branches": 6,
"test_count": 674
} | [
"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... | hashicorp--serf.32f656e |
programgym/hashicorp--terraform-provider-tls.282a513 | 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 hashicorp/terraform-provider-tls | [
"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": "hashicorp__terraform-provider-tls.282a513",
"repository": "hashicorp/terraform-provider-tls",
"commit": "282a513900aea0b3d51e11481bb63ae11d182e72",
"language": "go",
"difficulty": "medium",
"difficulty_score": 3.3770511374,
"test_branches": 6,
"test_count": 45... | [
"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... | hashicorp--terraform-provider-tls.282a513 |
programgym/hasit--bolter.68d80ba | 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 hasit/bolter | [
"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": "hasit__bolter.68d80ba",
"repository": "hasit/bolter",
"commit": "68d80baa762063bfc42fd3cefd8c41089ba034b6",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.4661258704,
"test_branches": 3,
"test_count": 204
} | [
"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_... | hasit--bolter.68d80ba |
programgym/hayorov--helm-gcs.f895119 | 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 hayorov/helm-gcs | [
"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": "hayorov__helm-gcs.f895119",
"repository": "hayorov/helm-gcs",
"commit": "f8951197fa5ce3b644a636f427e3ec340377035e",
"language": "go",
"difficulty": "medium",
"difficulty_score": 3.1206726233,
"test_branches": 3,
"test_count": 180
} | [
"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... | hayorov--helm-gcs.f895119 |
programgym/hazbo--httpu.01c0eb4 | 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 hazbo/httpu | [
"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": "hazbo__httpu.01c0eb4",
"repository": "hazbo/httpu",
"commit": "01c0eb40bf5b59f9e3fb4c9e009bb0a6c307915e",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.2395497208,
"test_branches": 4,
"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_... | hazbo--httpu.01c0eb4 |
programgym/hazcod--ransomwhere.3a763ee | 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 hazcod/ransomwhere | [
"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": "hazcod__ransomwhere.3a763ee",
"repository": "hazcod/ransomwhere",
"commit": "3a763ee0c6100d3c3c24e0dbf2681979d85b8921",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.3588862044,
"test_branches": 4,
"test_count": 207
} | [
"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... | hazcod--ransomwhere.3a763ee |
programgym/hcs64--ww2ogg.14ed9b0 | 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 hcs64/ww2ogg | [
"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": "hcs64__ww2ogg.14ed9b0",
"repository": "hcs64/ww2ogg",
"commit": "14ed9b0dd62e815a38702b5f03c57006cbe2501b",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.4192947218,
"test_branches": 2,
"test_count": 102
} | [
"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-gcc13.tar.gz",
"enviro... | hcs64--ww2ogg.14ed9b0 |
programgym/hdm--nextnet.2c66df3 | 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 hdm/nextnet | [
"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": "hdm__nextnet.2c66df3",
"repository": "hdm/nextnet",
"commit": "2c66df3a6aba8b17305a7f96b8ef3c1c829071c5",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.2111205413000001,
"test_branches": 4,
"test_count": 195
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | hdm--nextnet.2c66df3 |
programgym/hdoc--hdoc.387456d | 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 hdoc/hdoc | [
"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": "hdoc__hdoc.387456d",
"repository": "hdoc/hdoc",
"commit": "387456d7d116224d478233cb426e3162cf5e9208",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.7399676968,
"test_branches": 4,
"test_count": 484
} | [
"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/... | hdoc--hdoc.387456d |
programgym/heapwolf--ldb.f289a71 | 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 heapwolf/ldb | [
"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": "heapwolf__ldb.f289a71",
"repository": "heapwolf/ldb",
"commit": "f289a716b4e403e335da908d696f031c4ece920c",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.3829171351,
"test_branches": 4,
"test_count": 506
} | [
"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... | heapwolf--ldb.f289a71 |
programgym/heitzmann--gdstk.29c86f9 | 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 heitzmann/gdstk | [
"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": "heitzmann__gdstk.29c86f9",
"repository": "heitzmann/gdstk",
"commit": "29c86f96f900182e104b2533a1166e2c4317dc2a",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 3.0952949124,
"test_branches": 5,
"test_count": 558
} | [
"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... | heitzmann--gdstk.29c86f9 |
programgym/henvic--httpretty.3b8d127 | 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 henvic/httpretty | [
"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": "henvic__httpretty.3b8d127",
"repository": "henvic/httpretty",
"commit": "3b8d12782835e6fdfecbaab7342c26134f0af285",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.4480876667,
"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_... | henvic--httpretty.3b8d127 |
programgym/heppu--gkill.4e8ea22 | 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 heppu/gkill | [
"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": "heppu__gkill.4e8ea22",
"repository": "heppu/gkill",
"commit": "4e8ea226b120b9710ea65debaeb670cba43f9d99",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.414973348,
"test_branches": 3,
"test_count": 143
} | [
"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_... | heppu--gkill.4e8ea22 |
programgym/heroku--terrier.ed59392 | 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 heroku/terrier | [
"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": "heroku__terrier.ed59392",
"repository": "heroku/terrier",
"commit": "ed5939210e384fcc782fd74942cdae0ab6a25980",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.0342272608,
"test_branches": 2,
"test_count": 89
} | [
"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_... | heroku--terrier.ed59392 |
programgym/hexilee--async-io-demo.5b82514 | 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 Hexilee/async-io-demo | [
"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": "Hexilee__async-io-demo.5b82514",
"repository": "Hexilee/async-io-demo",
"commit": "5b82514025778d1d44c071d8493b3bef46a1aaa8",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.8200700343,
"test_branches": 2,
"test_count": 178
} | [
"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/... | hexilee--async-io-demo.5b82514 |
programgym/hherman1--gq.71a8797 | 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 hherman1/gq | [
"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": "hherman1__gq.71a8797",
"repository": "hherman1/gq",
"commit": "71a8797d7f50d848505ccb9badccbcbb766fb23f",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.9425041062,
"test_branches": 4,
"test_count": 361
} | [
"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_... | hherman1--gq.71a8797 |
programgym/hhyyrylainen--godotpcktool.e6256f8 | 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 hhyyrylainen/GodotPckTool | [
"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": "hhyyrylainen__GodotPckTool.e6256f8",
"repository": "hhyyrylainen/GodotPckTool",
"commit": "e6256f89c69d1aaac2fd7d84a7068f5878d2c32e",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.3656751405,
"test_branches": 4,
"test_count": 468
} | [
"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-gcc13.tar.gz",
"enviro... | hhyyrylainen--godotpcktool.e6256f8 |
programgym/hickford--git-credential-oauth.031d9b7 | 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 hickford/git-credential-oauth | [
"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": "hickford__git-credential-oauth.031d9b7",
"repository": "hickford/git-credential-oauth",
"commit": "031d9b7e782a4e56e71e209ea9e587f3f73adaee",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.2450188707,
"test_branches": 2,
"test_count": 181
} | [
"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_... | hickford--git-credential-oauth.031d9b7 |
programgym/hidu--mysql-schema-sync.730df92 | 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 hidu/mysql-schema-sync | [
"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": "hidu__mysql-schema-sync.730df92",
"repository": "hidu/mysql-schema-sync",
"commit": "730df92ef0c0fecdf2d509f6ae7fa6be5028f6af",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9152942830000002,
"test_branches": 4,
"test_count": 242
} | [
"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... | hidu--mysql-schema-sync.730df92 |
programgym/highperformancecoder--minsky.76245af | 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 highperformancecoder/minsky | [
"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": "highperformancecoder__minsky.76245af",
"repository": "highperformancecoder/minsky",
"commit": "76245af38cdc9eb063e8b78f70db39b56d74a422",
"language": "cpp",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 7,
"test_count": 3242
} | [
"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... | highperformancecoder--minsky.76245af |
programgym/hillu--go-yara.50b5a02 | 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 hillu/go-yara | [
"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": "hillu__go-yara.50b5a02",
"repository": "hillu/go-yara",
"commit": "50b5a022de1bd7138886d234197980d1ef13bf3f",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.3848907965000001,
"test_branches": 4,
"test_count": 416
} | [
"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... | hillu--go-yara.50b5a02 |
programgym/hisbaan--didyoumean.4d19bab | 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 hisbaan/didyoumean | [
"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": "hisbaan__didyoumean.4d19bab",
"repository": "hisbaan/didyoumean",
"commit": "4d19bab45cbf26ee7edb616b920babd48effab8b",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.9724805499,
"test_branches": 4,
"test_count": 716
} | [
"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/... | hisbaan--didyoumean.4d19bab |
programgym/hjson--hjson-go.23908b1 | 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 hjson/hjson-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": "hjson__hjson-go.23908b1",
"repository": "hjson/hjson-go",
"commit": "23908b1b28ce317b3f79151c7769cf5c2fa0f4ab",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.467312063,
"test_branches": 4,
"test_count": 822
} | [
"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_... | hjson--hjson-go.23908b1 |
programgym/hkalbasi--zngur.1d07ff0 | 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 hkalbasi/zngur | [
"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": "hkalbasi__zngur.1d07ff0",
"repository": "hkalbasi/zngur",
"commit": "1d07ff065544d2a3d238ec16efeb10a3e8273091",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.9605659028,
"test_branches": 4,
"test_count": 288
} | [
"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/... | hkalbasi--zngur.1d07ff0 |
programgym/hmarr--codeowners.b0f609d | 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 hmarr/codeowners | [
"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": "hmarr__codeowners.b0f609d",
"repository": "hmarr/codeowners",
"commit": "b0f609d21eb672b5cb2973f47a80210185102504",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6508900779,
"test_branches": 4,
"test_count": 352
} | [
"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_... | hmarr--codeowners.b0f609d |
programgym/hoangnb24--repository-harness.f07cd06 | 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 hoangnb24/repository-harness | [
"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": "hoangnb24__repository-harness.f07cd06",
"repository": "hoangnb24/repository-harness",
"commit": "f07cd06db8f329cbe4009b730704d67ed8c3016e",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.78582792,
"test_branches": 4,
"test_count": 562
} | [
"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/... | hoangnb24--repository-harness.f07cd06 |
programgym/hoanhan101--algo.46d524f | 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 hoanhan101/algo | [
"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": "hoanhan101__algo.46d524f",
"repository": "hoanhan101/algo",
"commit": "46d524ff83ff5fc2f4c6d2a63daa1f7b11a883ae",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.7573960288,
"test_branches": 2,
"test_count": 55
} | [
"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_... | hoanhan101--algo.46d524f |
programgym/horsicq--nauz-file-detector.d3ac7e7 | 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 horsicq/Nauz-File-Detector | [
"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": "horsicq__Nauz-File-Detector.d3ac7e7",
"repository": "horsicq/Nauz-File-Detector",
"commit": "d3ac7e785e0652a7bbc59a6d5501371aa51f8536",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 0.8488047011000001,
"test_branches": 1,
"test_count": 265
} | [
"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"... | horsicq--nauz-file-detector.d3ac7e7 |
programgym/hoto--jenkins-credentials-decryptor.19e39dd | 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 hoto/jenkins-credentials-decryptor | [
"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": "hoto__jenkins-credentials-decryptor.19e39dd",
"repository": "hoto/jenkins-credentials-decryptor",
"commit": "19e39dd2ca22af97a75c13d93e206cedc5b0c600",
"language": "go",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 5,
"test_count": 363
} | [
"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_... | hoto--jenkins-credentials-decryptor.19e39dd |
programgym/houseabsolute--ubi.edfac51 | 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 houseabsolute/ubi | [
"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": "houseabsolute__ubi.edfac51",
"repository": "houseabsolute/ubi",
"commit": "edfac51cbca79d7c85fbb56b322904b43f2c53f1",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.819280647,
"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_configure_java_mirrors.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.m... | houseabsolute--ubi.edfac51 |
programgym/hoytech--quadrable.4f44437 | 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 hoytech/quadrable | [
"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": "hoytech__quadrable.4f44437",
"repository": "hoytech/quadrable",
"commit": "4f44437dc9b951a91986ad69e2856938387be614",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.7007037171000001,
"test_branches": 4,
"test_count": 701
} | [
"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... | hoytech--quadrable.4f44437 |
programgym/hoytech--vmtouch.af86e27 | 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 hoytech/vmtouch | [
"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": "hoytech__vmtouch.af86e27",
"repository": "hoytech/vmtouch",
"commit": "af86e27675843b3c7e4ddfee66ddbaf44eff43c4",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.0334237555,
"test_branches": 1,
"test_count": 205
} | [
"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"... | hoytech--vmtouch.af86e27 |
programgym/hpcloud--tail.a1dbeea | 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 hpcloud/tail | [
"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": "hpcloud__tail.a1dbeea",
"repository": "hpcloud/tail",
"commit": "a1dbeea552b7c8df4b542c66073e393de198a800",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.1417632303,
"test_branches": 4,
"test_count": 233
} | [
"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... | hpcloud--tail.a1dbeea |
programgym/hrydgard--minitrace.242da50 | 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 hrydgard/minitrace | [
"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": "hrydgard__minitrace.242da50",
"repository": "hrydgard/minitrace",
"commit": "242da50d4bc757ca79ca4925690683612f0e7457",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.2164298309000001,
"test_branches": 3,
"test_count": 271
} | [
"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/... | hrydgard--minitrace.242da50 |
programgym/huagoufdog--fdogserialize.0d71889 | 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 HuaGouFdog/FdogSerialize | [
"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": "HuaGouFdog__FdogSerialize.0d71889",
"repository": "HuaGouFdog/FdogSerialize",
"commit": "0d7188906817a6c59b469b1edad1df8b07603a3d",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.6151079874,
"test_branches": 4,
"test_count": 416
} | [
"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... | huagoufdog--fdogserialize.0d71889 |
programgym/huderlem--poryscript.d9bc56b | 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 huderlem/poryscript | [
"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": "huderlem__poryscript.d9bc56b",
"repository": "huderlem/poryscript",
"commit": "d9bc56bc84db479dc14c872a5b65e1e773fce69b",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.7487305561,
"test_branches": 4,
"test_count": 422
} | [
"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... | huderlem--poryscript.d9bc56b |
programgym/huggingface--llm-ls.1c52b94 | 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 huggingface/llm-ls | [
"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": "huggingface__llm-ls.1c52b94",
"repository": "huggingface/llm-ls",
"commit": "1c52b94f30fa8293741d8b68c7fa48074b7f6589",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.6689447345000001,
"test_branches": 4,
"test_count": 546
} | [
"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/... | huggingface--llm-ls.1c52b94 |
programgym/hugo-dz--spritefusion-pixel-snapper.5c20a0f | 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 Hugo-Dz/spritefusion-pixel-snapper | [
"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": "Hugo-Dz__spritefusion-pixel-snapper.5c20a0f",
"repository": "Hugo-Dz/spritefusion-pixel-snapper",
"commit": "5c20a0f21db005e64231edb6a912fefdae255ed9",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.9865926068,
"test_branches": 1,
"test_count"... | [
"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"... | hugo-dz--spritefusion-pixel-snapper.5c20a0f |
programgym/huichen--sego.c87651e | 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 huichen/sego | [
"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": "huichen__sego.c87651e",
"repository": "huichen/sego",
"commit": "c87651ea5c76a4bf7db76f86cf6e444de6200f0c",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5751878448999999,
"test_branches": 4,
"test_count": 401
} | [
"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... | huichen--sego.c87651e |
programgym/hunterloftis--pbr.68e04d9 | 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 hunterloftis/pbr | [
"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": "hunterloftis__pbr.68e04d9",
"repository": "hunterloftis/pbr",
"commit": "68e04d94766d651a905baf7b1966261cd3031d2d",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5459253294000002,
"test_branches": 4,
"test_count": 345
} | [
"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... | hunterloftis--pbr.68e04d9 |
programgym/hutusi--rethink-c.6d182b3 | 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 hutusi/rethink-c | [
"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": "hutusi__rethink-c.6d182b3",
"repository": "hutusi/rethink-c",
"commit": "6d182b39584d5aca9ef7cc7b4f57a465fc0ab08e",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.9474827366,
"test_branches": 5,
"test_count": 1295
} | [
"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/... | hutusi--rethink-c.6d182b3 |
programgym/hybridgroup--go-haystack.647f778 | 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 hybridgroup/go-haystack | [
"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": "hybridgroup__go-haystack.647f778",
"repository": "hybridgroup/go-haystack",
"commit": "647f77880e1cc84d5355f68285aeb25baeccb786",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9353056902999999,
"test_branches": 4,
"test_count": 167
} | [
"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_... | hybridgroup--go-haystack.647f778 |
programgym/hybridgroup--gort.4b56fad | 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 hybridgroup/gort | [
"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": "hybridgroup__gort.4b56fad",
"repository": "hybridgroup/gort",
"commit": "4b56fade062f28f867fc0dd72526b5c4af2d0fe9",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.2595938789,
"test_branches": 4,
"test_count": 168
} | [
"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_... | hybridgroup--gort.4b56fad |
programgym/hydro-project--rust-sitter.c262f29 | 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 hydro-project/rust-sitter | [
"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": "hydro-project__rust-sitter.c262f29",
"repository": "hydro-project/rust-sitter",
"commit": "c262f29b816eb66b2a9777dca1c9f67f94de6bc9",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.3818367999999999,
"test_branches": 3,
"test_count": 542
} | [
"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/... | hydro-project--rust-sitter.c262f29 |
programgym/hyperboloide--lk.b291812 | 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 hyperboloide/lk | [
"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": "hyperboloide__lk.b291812",
"repository": "hyperboloide/lk",
"commit": "b291812e321652989e934e347803847f53c13612",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6604860158,
"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_... | hyperboloide--lk.b291812 |
programgym/hyperion-cs--dpi-checkers.4420e07 | 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 hyperion-cs/dpi-checkers | [
"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": "hyperion-cs__dpi-checkers.4420e07",
"repository": "hyperion-cs/dpi-checkers",
"commit": "4420e07e97aacf5d3f0f6d2c88bbe430465a030b",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.8612953935,
"test_branches": 4,
"test_count": 127
} | [
"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_... | hyperion-cs--dpi-checkers.4420e07 |
programgym/i5ting--learn-rust-for-fe.678e26a | 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 i5ting/learn-rust-for-fe | [
"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": "i5ting__learn-rust-for-fe.678e26a",
"repository": "i5ting/learn-rust-for-fe",
"commit": "678e26a661965b7a4f2328ce347d731e2452f7e6",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 0,
"test_branches": 1,
"test_count": 88
} | [
"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"... | i5ting--learn-rust-for-fe.678e26a |
programgym/iangcarroll--cookiemonster.074e770 | 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 iangcarroll/cookiemonster | [
"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": "iangcarroll__cookiemonster.074e770",
"repository": "iangcarroll/cookiemonster",
"commit": "074e770e0cad2b22a74bd7996ae118dc96774d12",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6005372944,
"test_branches": 4,
"test_count": 268
} | [
"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... | iangcarroll--cookiemonster.074e770 |
programgym/iann0036--iamlive.3ec1a40 | 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 iann0036/iamlive | [
"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": "iann0036__iamlive.3ec1a40",
"repository": "iann0036/iamlive",
"commit": "3ec1a40e560c2f00ec82c50223add810e2567efb",
"language": "go",
"difficulty": "medium",
"difficulty_score": 2.4729318864,
"test_branches": 5,
"test_count": 335
} | [
"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... | iann0036--iamlive.3ec1a40 |
programgym/ibnishak--timimi.a51706f | 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 ibnishak/Timimi | [
"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": "ibnishak__Timimi.a51706f",
"repository": "ibnishak/Timimi",
"commit": "a51706f03feb983741d86251d1587d9dc3a9c88a",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.0398105541,
"test_branches": 4,
"test_count": 221
} | [
"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_... | ibnishak--timimi.a51706f |
programgym/ibob--picobench.8ca5a5c | 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 iboB/picobench | [
"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": "iboB__picobench.8ca5a5c",
"repository": "iboB/picobench",
"commit": "8ca5a5ca369560d987f2701daeae53b9b08fb8fe",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.2427898095,
"test_branches": 3,
"test_count": 258
} | [
"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... | ibob--picobench.8ca5a5c |
programgym/icecrime--poule.8fb4044 | 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 icecrime/poule | [
"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": "icecrime__poule.8fb4044",
"repository": "icecrime/poule",
"commit": "8fb40443d3e0448656479ccf6cb5b923321625d7",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6194064109,
"test_branches": 4,
"test_count": 261
} | [
"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... | icecrime--poule.8fb4044 |
programgym/icholy--ttygif.17042ee | 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 icholy/ttygif | [
"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": "icholy__ttygif.17042ee",
"repository": "icholy/ttygif",
"commit": "17042ee05ab3941b56f2ebbd4f02b9ef9863e493",
"language": "c",
"difficulty": "easy",
"difficulty_score": 0.8662873391,
"test_branches": 4,
"test_count": 614
} | [
"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/... | icholy--ttygif.17042ee |
programgym/iffse--pay-respects.dcecac8 | 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 iffse/pay-respects | [
"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": "iffse__pay-respects.dcecac8",
"repository": "iffse/pay-respects",
"commit": "dcecac80aa9bdb8efcfea309f3ba86699527bfd6",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.8575134148,
"test_branches": 5,
"test_count": 566
} | [
"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/... | iffse--pay-respects.dcecac8 |
programgym/igrr--mkspiffs.f248296 | 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 igrr/mkspiffs | [
"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": "igrr__mkspiffs.f248296",
"repository": "igrr/mkspiffs",
"commit": "f2482965703b9b4031a5d4797bfd7458016bf3d2",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.8302035989,
"test_branches": 2,
"test_count": 217
} | [
"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-gcc13.tar.gz",
"enviro... | igrr--mkspiffs.f248296 |
programgym/ikalnytskyi--termcolor.89f2009 | 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 ikalnytskyi/termcolor | [
"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": "ikalnytskyi__termcolor.89f2009",
"repository": "ikalnytskyi/termcolor",
"commit": "89f20096bef51de347ec6f99345f65147359bd7c",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 0.9894498177000001,
"test_branches": 2,
"test_count": 119
} | [
"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... | ikalnytskyi--termcolor.89f2009 |
programgym/illarion--lockenv.d0ecc55 | 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 illarion/lockenv | [
"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": "illarion__lockenv.d0ecc55",
"repository": "illarion/lockenv",
"commit": "d0ecc5574805dfc4fd562870e8d9ae67b0bde42d",
"language": "go",
"difficulty": "medium",
"difficulty_score": 2.6453240016,
"test_branches": 6,
"test_count": 603
} | [
"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... | illarion--lockenv.d0ecc55 |
programgym/ilyakaznacheev--cleanenv.fbd44b4 | 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 ilyakaznacheev/cleanenv | [
"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": "ilyakaznacheev__cleanenv.fbd44b4",
"repository": "ilyakaznacheev/cleanenv",
"commit": "fbd44b4eb2b4cc8e2b8944f14937d3194943abc9",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5526682161,
"test_branches": 3,
"test_count": 336
} | [
"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_... | ilyakaznacheev--cleanenv.fbd44b4 |
programgym/imsoo--fight_detection.f6a435c | 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 imsoo/fight_detection | [
"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": "imsoo__fight_detection.f6a435c",
"repository": "imsoo/fight_detection",
"commit": "f6a435ce03bda03d1f722058c1fce44b231da254",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.7500453120000001,
"test_branches": 2,
"test_count": 106
} | [
"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/... | imsoo--fight_detection.f6a435c |
programgym/inksha--rust-tutorial.714dc1a | 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 InkSha/rust-tutorial | [
"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": "InkSha__rust-tutorial.714dc1a",
"repository": "InkSha/rust-tutorial",
"commit": "714dc1ab103ee1b703062ceeebf1d59aaddc363a",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.4580331925,
"test_branches": 4,
"test_count": 1013
} | [
"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/... | inksha--rust-tutorial.714dc1a |
programgym/inochi2d--inox2d.df8413e | 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 Inochi2D/inox2d | [
"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": "Inochi2D__inox2d.df8413e",
"repository": "Inochi2D/inox2d",
"commit": "df8413e6b0c525dbb880b4dca2bdf0a5d4b9aaba",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.7154183226000002,
"test_branches": 4,
"test_count": 1164
} | [
"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... | inochi2d--inox2d.df8413e |
programgym/inotify-tools--inotify-tools.a8f024d | 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 inotify-tools/inotify-tools | [
"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": "inotify-tools__inotify-tools.a8f024d",
"repository": "inotify-tools/inotify-tools",
"commit": "a8f024da45b8cc2c4c040a7165841f06841a00ad",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.9832653526000001,
"test_branches": 3,
"test_count": 262
} | [
"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... | inotify-tools--inotify-tools.a8f024d |
programgym/integrii--flaggy.e0a0096 | 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 integrii/flaggy | [
"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": "integrii__flaggy.e0a0096",
"repository": "integrii/flaggy",
"commit": "e0a0096c5f3c2cdf11ac97455ec375f0dcca5fed",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5679669068000002,
"test_branches": 4,
"test_count": 682
} | [
"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_... | integrii--flaggy.e0a0096 |
programgym/intel--intel-qs.5ec66c1 | 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 intel/intel-qs | [
"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": "intel__intel-qs.5ec66c1",
"repository": "intel/intel-qs",
"commit": "5ec66c1ed23357e037b362a457184fa39d473291",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 2.8254520838,
"test_branches": 6,
"test_count": 699
} | [
"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/... | intel--intel-qs.5ec66c1 |
programgym/interact-rs--interact.d3f0ed9 | 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 interact-rs/interact | [
"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": "interact-rs__interact.d3f0ed9",
"repository": "interact-rs/interact",
"commit": "d3f0ed94d42fcdb9820db39e8eca48f99f49988e",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.7442147248,
"test_branches": 4,
"test_count": 947
} | [
"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... | interact-rs--interact.d3f0ed9 |
programgym/interactivecomputergraphics--splishsplash.8dc80c0 | 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 InteractiveComputerGraphics/SPlisHSPlasH | [
"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": "InteractiveComputerGraphics__SPlisHSPlasH.8dc80c0",
"repository": "InteractiveComputerGraphics/SPlisHSPlasH",
"commit": "8dc80c0f5bab9fbb60b4284fbd7ac2aad713c874",
"language": "cpp",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 2,
"test_cou... | [
"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... | interactivecomputergraphics--splishsplash.8dc80c0 |
programgym/interagent--schematic.0a37911 | 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 interagent/schematic | [
"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": "interagent__schematic.0a37911",
"repository": "interagent/schematic",
"commit": "0a37911b7938928079fe2fea98f0ad45160d0ecf",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.0722498976,
"test_branches": 4,
"test_count": 351
} | [
"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_... | interagent--schematic.0a37911 |
programgym/intigriti--misconfig-mapper.396e5b2 | 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 intigriti/misconfig-mapper | [
"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": "intigriti__misconfig-mapper.396e5b2",
"repository": "intigriti/misconfig-mapper",
"commit": "396e5b28740e896c89fffe6a964cb17ae5e81d21",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6068111469000002,
"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_... | intigriti--misconfig-mapper.396e5b2 |
programgym/ioi--isolate.cf03a90 | 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 ioi/isolate | [
"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": "ioi__isolate.cf03a90",
"repository": "ioi/isolate",
"commit": "cf03a9025adaec7d281b7fce805592e41a1d955a",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.5177235948,
"test_branches": 4,
"test_count": 947
} | [
"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/... | ioi--isolate.cf03a90 |
programgym/iqlusioninc--abscissa.721fb34 | 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 iqlusioninc/abscissa | [
"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": "iqlusioninc__abscissa.721fb34",
"repository": "iqlusioninc/abscissa",
"commit": "721fb340417578c00b3838098bb7990b7bd0f400",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.6906390117,
"test_branches": 4,
"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/blobs/tests/... | iqlusioninc--abscissa.721fb34 |
programgym/irevenko--tsukae.8111ddd | 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 irevenko/tsukae | [
"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": "irevenko__tsukae.8111ddd",
"repository": "irevenko/tsukae",
"commit": "8111dddd67e4b4f83ae4bca7d7305f6dc64e77cd",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.3121773563999999,
"test_branches": 3,
"test_count": 390
} | [
"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_... | irevenko--tsukae.8111ddd |
programgym/irevenko--what-anime-cli.5f212ca | 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 irevenko/what-anime-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": "irevenko__what-anime-cli.5f212ca",
"repository": "irevenko/what-anime-cli",
"commit": "5f212cab4cefd4109ef342797a2c942cc850e3e3",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.2108533653,
"test_branches": 4,
"test_count": 134
} | [
"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_... | irevenko--what-anime-cli.5f212ca |
programgym/itensor--itensor.ea88f51 | 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 ITensor/ITensor | [
"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": "ITensor__ITensor.ea88f51",
"repository": "ITensor/ITensor",
"commit": "ea88f512d258ef23b5554950639c5acedf4df1f0",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 2.895698727,
"test_branches": 5,
"test_count": 122
} | [
"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... | itensor--itensor.ea88f51 |
programgym/itsubaki--q.b781ece | 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 itsubaki/q | [
"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": "itsubaki__q.b781ece",
"repository": "itsubaki/q",
"commit": "b781ece81c11e74c1af27b54827dc7aa2165604b",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6090605499000001,
"test_branches": 4,
"test_count": 649
} | [
"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_... | itsubaki--q.b781ece |
programgym/itzg--rcon-cli.bba5168 | 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 itzg/rcon-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": "itzg__rcon-cli.bba5168",
"repository": "itzg/rcon-cli",
"commit": "bba5168ef39878872072e34cad2a33f0bc10ba84",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.7450747916,
"test_branches": 3,
"test_count": 135
} | [
"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... | itzg--rcon-cli.bba5168 |
programgym/ivaaaan--smug.52a7c12 | 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 ivaaaan/smug | [
"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": "ivaaaan__smug.52a7c12",
"repository": "ivaaaan/smug",
"commit": "52a7c1240962ef6f4a023abad9195fe28604154f",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5819496584000001,
"test_branches": 4,
"test_count": 219
} | [
"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_... | ivaaaan--smug.52a7c12 |
programgym/j-f-liu--pom.0fd011c | 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 J-F-Liu/pom | [
"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": "J-F-Liu__pom.0fd011c",
"repository": "J-F-Liu/pom",
"commit": "0fd011c736ea77b06c6215da8f3fc7140087a719",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.5881596164,
"test_branches": 4,
"test_count": 367
} | [
"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/... | j-f-liu--pom.0fd011c |
programgym/j123b567--scpi-parser.8866159 | 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 j123b567/scpi-parser | [
"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": "j123b567__scpi-parser.8866159",
"repository": "j123b567/scpi-parser",
"commit": "886615902b2777b71860445305bfe5a3faef4f3e",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.8953672888000002,
"test_branches": 3,
"test_count": 1199
} | [
"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... | j123b567--scpi-parser.8866159 |
programgym/jacking75--examples_cmake.1622f1e | 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 jacking75/examples_CMake | [
"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": "jacking75__examples_CMake.1622f1e",
"repository": "jacking75/examples_CMake",
"commit": "1622f1ea420f2e1747d1d71a82a58b4ba0a59f9f",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.0941215958,
"test_branches": 3,
"test_count": 300
} | [
"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... | jacking75--examples_cmake.1622f1e |
programgym/jacobdeichert--mask.0ba24c1 | 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 jacobdeichert/mask | [
"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": "jacobdeichert__mask.0ba24c1",
"repository": "jacobdeichert/mask",
"commit": "0ba24c1eff6a48e58e93f13ce7b633db7ce19458",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.0090257421,
"test_branches": 4,
"test_count": 846
} | [
"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/... | jacobdeichert--mask.0ba24c1 |
programgym/james-barrow--golang-ipc.cd515d1 | 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 james-barrow/golang-ipc | [
"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": "james-barrow__golang-ipc.cd515d1",
"repository": "james-barrow/golang-ipc",
"commit": "cd515d151eb51b599c5a86c80ba51068e9543657",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6042260531,
"test_branches": 4,
"test_count": 70
} | [
"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_... | james-barrow--golang-ipc.cd515d1 |
programgym/jarro2783--cxxopts.b613531 | 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 jarro2783/cxxopts | [
"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": "jarro2783__cxxopts.b613531",
"repository": "jarro2783/cxxopts",
"commit": "b6135315a54deb2b556219906eda8346f69bf703",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.5300715688,
"test_branches": 3,
"test_count": 298
} | [
"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... | jarro2783--cxxopts.b613531 |
programgym/jason0x43--alfred-toggl.09f24d2 | 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 jason0x43/alfred-toggl | [
"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": "jason0x43__alfred-toggl.09f24d2",
"repository": "jason0x43/alfred-toggl",
"commit": "09f24d2c9cf8ef618d5c81e47d57cf91621781cc",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9325752235,
"test_branches": 4,
"test_count": 187
} | [
"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... | jason0x43--alfred-toggl.09f24d2 |
programgym/jasonshin--fp-core.rs.d020d6d | 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 JasonShin/fp-core.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": "JasonShin__fp-core.rs.d020d6d",
"repository": "JasonShin/fp-core.rs",
"commit": "d020d6d607d5d270bef7fc60d22fee5662a8dcd4",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.2245330626,
"test_branches": 4,
"test_count": 771
} | [
"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... | jasonshin--fp-core.rs.d020d6d |
programgym/javalsai--lidm.fc90ba9 | 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 javalsai/lidm | [
"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": "javalsai__lidm.fc90ba9",
"repository": "javalsai/lidm",
"commit": "fc90ba96bb87f582b8e515f23cf76fc3dad4c98f",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.5535189401,
"test_branches": 2,
"test_count": 337
} | [
"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/... | javalsai--lidm.fc90ba9 |
programgym/jckuester--awsweeper.09952ce | 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 jckuester/awsweeper | [
"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": "jckuester__awsweeper.09952ce",
"repository": "jckuester/awsweeper",
"commit": "09952cea9426d8649b82ab46fce1e0413e80c557",
"language": "go",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 5,
"test_count": 548
} | [
"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_... | jckuester--awsweeper.09952ce |
programgym/jedisct1--dnsblast.1be795a | 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 jedisct1/dnsblast | [
"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": "jedisct1__dnsblast.1be795a",
"repository": "jedisct1/dnsblast",
"commit": "1be795afc203143155d2269b92bb4588d19fb261",
"language": "c",
"difficulty": "easy",
"difficulty_score": 0.6919651028,
"test_branches": 3,
"test_count": 525
} | [
"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/... | jedisct1--dnsblast.1be795a |
programgym/jehiah--json2csv.0bd0bb4 | 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 jehiah/json2csv | [
"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": "jehiah__json2csv.0bd0bb4",
"repository": "jehiah/json2csv",
"commit": "0bd0bb4e06a282ff4c9ec979a52159c379bf9652",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.9319661147,
"test_branches": 4,
"test_count": 257
} | [
"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_... | jehiah--json2csv.0bd0bb4 |
programgym/jerome-pouiller--reredirect.b85df39 | 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 jerome-pouiller/reredirect | [
"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": "jerome-pouiller__reredirect.b85df39",
"repository": "jerome-pouiller/reredirect",
"commit": "b85df395e18d09b54e1fb73dfe344f8f04224a83",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.0565237241,
"test_branches": 4,
"test_count": 687
} | [
"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/... | jerome-pouiller--reredirect.b85df39 |
programgym/jesseduffield--horcrux.5e848ab | 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 jesseduffield/horcrux | [
"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": "jesseduffield__horcrux.5e848ab",
"repository": "jesseduffield/horcrux",
"commit": "5e848abcca49a7ad359f5a24ef4ca7e0eda80889",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.9795483747,
"test_branches": 4,
"test_count": 171
} | [
"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... | jesseduffield--horcrux.5e848ab |
programgym/jessfraz--dockfmt.1455059 | 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 jessfraz/dockfmt | [
"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": "jessfraz__dockfmt.1455059",
"repository": "jessfraz/dockfmt",
"commit": "1455059b8bb53ab4723ef41946c43160583a8333",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5110808455,
"test_branches": 4,
"test_count": 448
} | [
"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_... | jessfraz--dockfmt.1455059 |
programgym/jessfraz--gitable.9f5f372 | 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 jessfraz/gitable | [
"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": "jessfraz__gitable.9f5f372",
"repository": "jessfraz/gitable",
"commit": "9f5f3727ca9c4d3f8a2aee4c889d41c42d49a787",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.8234742292,
"test_branches": 2,
"test_count": 175
} | [
"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_... | jessfraz--gitable.9f5f372 |
programgym/jessfraz--gmailfilters.8787f1a | 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 jessfraz/gmailfilters | [
"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": "jessfraz__gmailfilters.8787f1a",
"repository": "jessfraz/gmailfilters",
"commit": "8787f1a22fa854c4215470c4a98f3e13c63ceddb",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.8515029528,
"test_branches": 4,
"test_count": 249
} | [
"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_... | jessfraz--gmailfilters.8787f1a |
programgym/jessfraz--netscan.b457232 | 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 jessfraz/netscan | [
"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": "jessfraz__netscan.b457232",
"repository": "jessfraz/netscan",
"commit": "b4572329b98932e441bf759e165e0d703defa3b1",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.57863921,
"test_branches": 2,
"test_count": 221
} | [
"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... | jessfraz--netscan.b457232 |
programgym/jesusprubio--up.51ff50d | 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 jesusprubio/up | [
"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": "jesusprubio__up.51ff50d",
"repository": "jesusprubio/up",
"commit": "51ff50dcbecb0b7794e155c8eb067b9f9e6cc886",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6090605499000001,
"test_branches": 4,
"test_count": 158
} | [
"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_... | jesusprubio--up.51ff50d |
programgym/jetify-com--typeid.661c863 | 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 jetify-com/typeid | [
"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": "jetify-com__typeid.661c863",
"repository": "jetify-com/typeid",
"commit": "661c8639faec1f5598036e548cc1e06a51ac958d",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.0153597554,
"test_branches": 4,
"test_count": 221
} | [
"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_... | jetify-com--typeid.661c863 |
programgym/jez--as-tree.0036c20 | 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 jez/as-tree | [
"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": "jez__as-tree.0036c20",
"repository": "jez/as-tree",
"commit": "0036c20f66795774eb9cda3ccbae6ca1e1c19444",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.0835026198,
"test_branches": 3,
"test_count": 354
} | [
"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/... | jez--as-tree.0036c20 |
programgym/jfeliu007--goplantuml.81d136b | 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 jfeliu007/goplantuml | [
"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": "jfeliu007__goplantuml.81d136b",
"repository": "jfeliu007/goplantuml",
"commit": "81d136b30c93094a3a54e46940f9e9ef3bf0ee18",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.8181598864000001,
"test_branches": 4,
"test_count": 295
} | [
"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... | jfeliu007--goplantuml.81d136b |
programgym/jgautheron--goconst.bc93868 | 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 jgautheron/goconst | [
"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": "jgautheron__goconst.bc93868",
"repository": "jgautheron/goconst",
"commit": "bc93868fdc5e4f49deab5c76ac6f87daba2f83b6",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.3251049830000001,
"test_branches": 4,
"test_count": 240
} | [
"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_... | jgautheron--goconst.bc93868 |
programgym/jgavris--rs-git-fsmonitor.2ca1588 | 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 jgavris/rs-git-fsmonitor | [
"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": "jgavris__rs-git-fsmonitor.2ca1588",
"repository": "jgavris/rs-git-fsmonitor",
"commit": "2ca1588caf8b3506e8e4ea850088d47d5bc92625",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.0034605321,
"test_branches": 1,
"test_count": 276
} | [
"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"... | jgavris--rs-git-fsmonitor.2ca1588 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.