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/jgm--peg-markdown.0e0e9e5 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jgm/peg-markdown | [
"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": "jgm__peg-markdown.0e0e9e5",
"repository": "jgm/peg-markdown",
"commit": "0e0e9e5d7b5e133bd28849e1d72e9636a3b49109",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.681331706,
"test_branches": 4,
"test_count": 1173
} | [
"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/... | jgm--peg-markdown.0e0e9e5 |
programgym/jgrahamc--httpdiff.7e439a2 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jgrahamc/httpdiff | [
"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": "jgrahamc__httpdiff.7e439a2",
"repository": "jgrahamc/httpdiff",
"commit": "7e439a23a8b9f1d26f0c1617e9e479dcc921ec7f",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.46834733040000004,
"test_branches": 1,
"test_count": 107
} | [
"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... | jgrahamc--httpdiff.7e439a2 |
programgym/jgrahamc--webwatch.3a7e5a0 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jgrahamc/webwatch | [
"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": "jgrahamc__webwatch.3a7e5a0",
"repository": "jgrahamc/webwatch",
"commit": "3a7e5a0b563be8f32b5e0e4326e2dbc4508fd68f",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.0043213738,
"test_branches": 1,
"test_count": 28
} | [
"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... | jgrahamc--webwatch.3a7e5a0 |
programgym/jhasse--poly2tri.bf2be13 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jhasse/poly2tri | [
"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": "jhasse__poly2tri.bf2be13",
"repository": "jhasse/poly2tri",
"commit": "bf2be13216445181452bf3937410973a6dbb122f",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.5684364144,
"test_branches": 3,
"test_count": 418
} | [
"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... | jhasse--poly2tri.bf2be13 |
programgym/jibsen--tinf.57ffa1f | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jibsen/tinf | [
"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": "jibsen__tinf.57ffa1f",
"repository": "jibsen/tinf",
"commit": "57ffa1f1d5e3dde19011b2127bd26d01689b694b",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.2895889525,
"test_branches": 4,
"test_count": 820
} | [
"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/... | jibsen--tinf.57ffa1f |
programgym/jito-labs--searcher-examples.f710c30 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jito-labs/searcher-examples | [
"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": "jito-labs__searcher-examples.f710c30",
"repository": "jito-labs/searcher-examples",
"commit": "f710c30b0ec7449b5122f827b0997218ab1a0315",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 0.9571281977,
"test_branches": 4,
"test_count": 633
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_configure_java_mirrors.sh",
"environment/harbor_prepare_download_env.sh",
"environment/harbor_prepare_rust_env.sh",
"env... | jito-labs--searcher-examples.f710c30 |
programgym/jjinux--gotetris.b2768d5 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jjinux/gotetris | [
"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": "jjinux__gotetris.b2768d5",
"repository": "jjinux/gotetris",
"commit": "b2768d581d065e4e4fb60bd501abe4ceae7dddec",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.0499928569,
"test_branches": 3,
"test_count": 106
} | [
"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... | jjinux--gotetris.b2768d5 |
programgym/jklmnn--imagejs.a442f94 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jklmnn/imagejs | [
"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": "jklmnn__imagejs.a442f94",
"repository": "jklmnn/imagejs",
"commit": "a442f94e9ccf42b2021133520132b0d3cc6c4a42",
"language": "c",
"difficulty": "easy",
"difficulty_score": 0.7218106152,
"test_branches": 4,
"test_count": 830
} | [
"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/... | jklmnn--imagejs.a442f94 |
programgym/jmhodges--jsonpp.4b3b9ea | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jmhodges/jsonpp | [
"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": "jmhodges__jsonpp.4b3b9ea",
"repository": "jmhodges/jsonpp",
"commit": "4b3b9eac8de6fb77cd3605ebd6578ac41c621875",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.1789769473,
"test_branches": 2,
"test_count": 267
} | [
"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_... | jmhodges--jsonpp.4b3b9ea |
programgym/jmhodges--justrun.6272027 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jmhodges/justrun | [
"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": "jmhodges__justrun.6272027",
"repository": "jmhodges/justrun",
"commit": "6272027ef411f02c33d605382d501893ba014549",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.233757363,
"test_branches": 4,
"test_count": 120
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | jmhodges--justrun.6272027 |
programgym/jnewmano--grpc-json-proxy.ec24556 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jnewmano/grpc-json-proxy | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "jnewmano__grpc-json-proxy.ec24556",
"repository": "jnewmano/grpc-json-proxy",
"commit": "ec24556ec851d04367eb1906bd6a37135afd0a2e",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5494937132,
"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_... | jnewmano--grpc-json-proxy.ec24556 |
programgym/joexbayer--c-web-modules.a4a06d9 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for joexbayer/c-web-modules | [
"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": "joexbayer__c-web-modules.a4a06d9",
"repository": "joexbayer/c-web-modules",
"commit": "a4a06d9e31f8f9e9b5c97ded68dd4ccf8734fc56",
"language": "c",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 2,
"test_count": 157
} | [
"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... | joexbayer--c-web-modules.a4a06d9 |
programgym/johnthagen--min-sized-rust.24233f9 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for johnthagen/min-sized-rust | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"rust"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "johnthagen__min-sized-rust.24233f9",
"repository": "johnthagen/min-sized-rust",
"commit": "24233f98d9a8a484302408ed6b5431ed8f720321",
"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"... | johnthagen--min-sized-rust.24233f9 |
programgym/joho--godotenv.97a2850 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for joho/godotenv | [
"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": "joho__godotenv.97a2850",
"repository": "joho/godotenv",
"commit": "97a2850142438b3c357c1d3439e325181afdcc1d",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.7839035793,
"test_branches": 4,
"test_count": 297
} | [
"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_... | joho--godotenv.97a2850 |
programgym/joiningdata--lollipops.2587aad | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for joiningdata/lollipops | [
"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": "joiningdata__lollipops.2587aad",
"repository": "joiningdata/lollipops",
"commit": "2587aaded33dccb84d2d90f5bf79872492df355b",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9935244032,
"test_branches": 4,
"test_count": 242
} | [
"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... | joiningdata--lollipops.2587aad |
programgym/jolehuit--clother.c2fbfe0 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jolehuit/clother | [
"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": "jolehuit__clother.c2fbfe0",
"repository": "jolehuit/clother",
"commit": "c2fbfe02c739b637de5caa95b703a708a4d8643d",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5872618497,
"test_branches": 4,
"test_count": 397
} | [
"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_... | jolehuit--clother.c2fbfe0 |
programgym/jonasvinther--medusa.4c2237d | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jonasvinther/medusa | [
"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": "jonasvinther__medusa.4c2237d",
"repository": "jonasvinther/medusa",
"commit": "4c2237db8123d83db964313c78e63c63f2807acd",
"language": "go",
"difficulty": "medium",
"difficulty_score": 2.8133808067,
"test_branches": 6,
"test_count": 491
} | [
"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... | jonasvinther--medusa.4c2237d |
programgym/jondot--goweight.624b44a | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jondot/goweight | [
"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": "jondot__goweight.624b44a",
"repository": "jondot/goweight",
"commit": "624b44a7a73a54fe24a2061cca7030ff8855d488",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.1553360375,
"test_branches": 2,
"test_count": 187
} | [
"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_... | jondot--goweight.624b44a |
programgym/jondot--groundcontrol.97a1afd | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jondot/groundcontrol | [
"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": "jondot__groundcontrol.97a1afd",
"repository": "jondot/groundcontrol",
"commit": "97a1afdb34067349984d1a4a7d32f67a377b3fe6",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.8512583487000001,
"test_branches": 4,
"test_count": 146
} | [
"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_... | jondot--groundcontrol.97a1afd |
programgym/jonegil--gui-with-gio.fc68f4d | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jonegil/gui-with-gio | [
"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": "jonegil__gui-with-gio.fc68f4d",
"repository": "jonegil/gui-with-gio",
"commit": "fc68f4dd94d3e97102fd02829111030a96d48054",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.4104397862,
"test_branches": 2,
"test_count": 67
} | [
"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_... | jonegil--gui-with-gio.fc68f4d |
programgym/jonhoo--roget.b00cf03 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jonhoo/roget | [
"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": "jonhoo__roget.b00cf03",
"repository": "jonhoo/roget",
"commit": "b00cf03afdcb8afac73d933e803680702946e478",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.6661434273,
"test_branches": 5,
"test_count": 1152
} | [
"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/... | jonhoo--roget.b00cf03 |
programgym/jordanlewis--gcassert.ad3fae1 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jordanlewis/gcassert | [
"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": "jordanlewis__gcassert.ad3fae1",
"repository": "jordanlewis/gcassert",
"commit": "ad3fae17affe12f6e5ac5055af42d891e944b848",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6884198220000002,
"test_branches": 3,
"test_count": 80
} | [
"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_... | jordanlewis--gcassert.ad3fae1 |
programgym/josephspurrier--goversioninfo.b66839b | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for josephspurrier/goversioninfo | [
"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": "josephspurrier__goversioninfo.b66839b",
"repository": "josephspurrier/goversioninfo",
"commit": "b66839b92ddd6c4098296d76c155715510a1563c",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9958983236,
"test_branches": 4,
"test_count": 241
} | [
"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_... | josephspurrier--goversioninfo.b66839b |
programgym/josue87--gotator.8555480 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for Josue87/gotator | [
"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": "Josue87__gotator.8555480",
"repository": "Josue87/gotator",
"commit": "85554801a28a7c3a4a405fbdbb3e675c2c7813f1",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.5809249757,
"test_branches": 1,
"test_count": 53
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/download.sh",
"tests... | josue87--gotator.8555480 |
programgym/journeymidnight--yig.3e8dc4d | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for journeymidnight/yig | [
"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": "journeymidnight__yig.3e8dc4d",
"repository": "journeymidnight/yig",
"commit": "3e8dc4d2f21ff4401cbf1fe40fc55bd1f16d4eac",
"language": "go",
"difficulty": "medium",
"difficulty_score": 3.6769888295,
"test_branches": 1,
"test_count": 75
} | [
"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... | journeymidnight--yig.3e8dc4d |
programgym/jpaver--opengametools.dcabf82 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jpaver/opengametools | [
"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": "jpaver__opengametools.dcabf82",
"repository": "jpaver/opengametools",
"commit": "dcabf82345979a2d937a5ea29a0b14683a3aa838",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.8728552447,
"test_branches": 3,
"test_count": 456
} | [
"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... | jpaver--opengametools.dcabf82 |
programgym/jpmens--jo.15d20a9 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jpmens/jo | [
"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": "jpmens__jo.15d20a9",
"repository": "jpmens/jo",
"commit": "15d20a9ca21354bce636cad5de319ca316275c4b",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.4085791254,
"test_branches": 4,
"test_count": 1048
} | [
"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/... | jpmens--jo.15d20a9 |
programgym/jprochazk--garde.c67cda4 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jprochazk/garde | [
"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": "jprochazk__garde.c67cda4",
"repository": "jprochazk/garde",
"commit": "c67cda4573fee55865811eefc7fb7f22a692336c",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.7868933253,
"test_branches": 4,
"test_count": 757
} | [
"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/... | jprochazk--garde.c67cda4 |
programgym/jpschroeder--pipe-to-me.3753361 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jpschroeder/pipe-to-me | [
"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": "jpschroeder__pipe-to-me.3753361",
"repository": "jpschroeder/pipe-to-me",
"commit": "37533617decc4fddca0029b5b3cca9bbb2f725cb",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.9479236198000001,
"test_branches": 3,
"test_count": 180
} | [
"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_... | jpschroeder--pipe-to-me.3753361 |
programgym/jrhouston--tfk8s.0f1a168 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jrhouston/tfk8s | [
"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": "jrhouston__tfk8s.0f1a168",
"repository": "jrhouston/tfk8s",
"commit": "0f1a1681b8373a60825468b0868d04a9cfdedd64",
"language": "go",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 3,
"test_count": 284
} | [
"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_... | jrhouston--tfk8s.0f1a168 |
programgym/jrnxf--fsrx.713ebbc | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jrnxf/fsrx | [
"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": "jrnxf__fsrx.713ebbc",
"repository": "jrnxf/fsrx",
"commit": "713ebbc895ff150d28c544dbbbd631830c06940b",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 0.9822712330000001,
"test_branches": 1,
"test_count": 355
} | [
"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"... | jrnxf--fsrx.713ebbc |
programgym/jroimartin--gocui.0e75b37 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jroimartin/gocui | [
"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": "jroimartin__gocui.0e75b37",
"repository": "jroimartin/gocui",
"commit": "0e75b37a4ce7cb6e09f23ccd71a7d466301a7467",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.8898617213,
"test_branches": 3,
"test_count": 58
} | [
"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_... | jroimartin--gocui.0e75b37 |
programgym/jrouwe--joltphysics.f26e382 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jrouwe/JoltPhysics | [
"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": "jrouwe__JoltPhysics.f26e382",
"repository": "jrouwe/JoltPhysics",
"commit": "f26e382dd06653d8bf9de71371c4ccd92ab667d1",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 3.2015964716,
"test_branches": 5,
"test_count": 1083
} | [
"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... | jrouwe--joltphysics.f26e382 |
programgym/jschauma--jass.59b4f9a | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jschauma/jass | [
"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": "jschauma__jass.59b4f9a",
"repository": "jschauma/jass",
"commit": "59b4f9a84ece701827e3ef7f7546153f5c05381c",
"language": "go",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 2,
"test_count": 149
} | [
"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_... | jschauma--jass.59b4f9a |
programgym/jserv--facebooc.f59c3c6 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jserv/facebooc | [
"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": "jserv__facebooc.f59c3c6",
"repository": "jserv/facebooc",
"commit": "f59c3c6cf6331fb50b576cfc5487f3166b58314d",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.4833019524,
"test_branches": 4,
"test_count": 661
} | [
"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... | jserv--facebooc.f59c3c6 |
programgym/jsiebens--hashi-up.80a83e8 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jsiebens/hashi-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": "jsiebens__hashi-up.80a83e8",
"repository": "jsiebens/hashi-up",
"commit": "80a83e8584db143b8ef4ec2f8253aa871577679c",
"language": "go",
"difficulty": "medium",
"difficulty_score": 2.8436562735,
"test_branches": 6,
"test_count": 605
} | [
"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... | jsiebens--hashi-up.80a83e8 |
programgym/jskorepa--fbx.7b40057 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jskorepa/fbx | [
"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": "jskorepa__fbx.7b40057",
"repository": "jskorepa/fbx",
"commit": "7b40057cf25df1f10e9218460c904cad2b9413b3",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.1341771076,
"test_branches": 4,
"test_count": 783
} | [
"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... | jskorepa--fbx.7b40057 |
programgym/jsonrpcx--json-rpc-cxx.a0e195b | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jsonrpcx/json-rpc-cxx | [
"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": "jsonrpcx__json-rpc-cxx.a0e195b",
"repository": "jsonrpcx/json-rpc-cxx",
"commit": "a0e195b575d62cb07016321ac9cd7e1b9e048fe5",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.1492191127,
"test_branches": 5,
"test_count": 80
} | [
"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... | jsonrpcx--json-rpc-cxx.a0e195b |
programgym/jstrieb--quickserv.a347726 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jstrieb/quickserv | [
"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": "jstrieb__quickserv.a347726",
"repository": "jstrieb/quickserv",
"commit": "a3477261a6fe902b4f10df7ca0de8cc171c0ac1f",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.3636119799,
"test_branches": 1,
"test_count": 95
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/download.sh",
"tests... | jstrieb--quickserv.a347726 |
programgym/jtripper--dns-tcp-socks-proxy.6ecfb12 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jtripper/dns-tcp-socks-proxy | [
"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": "jtripper__dns-tcp-socks-proxy.6ecfb12",
"repository": "jtripper/dns-tcp-socks-proxy",
"commit": "6ecfb121009cad5ea316121a6d81247bea46d9eb",
"language": "c",
"difficulty": "easy",
"difficulty_score": 0.5301996982,
"test_branches": 1,
"test_count": 126
} | [
"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"... | jtripper--dns-tcp-socks-proxy.6ecfb12 |
programgym/jtsiomb--kdtree.384f9eb | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jtsiomb/kdtree | [
"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": "jtsiomb__kdtree.384f9eb",
"repository": "jtsiomb/kdtree",
"commit": "384f9eba646018f99fe37c1f5d0c9e21a63d5057",
"language": "c",
"difficulty": "easy",
"difficulty_score": 0.9876662649000001,
"test_branches": 2,
"test_count": 1161
} | [
"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... | jtsiomb--kdtree.384f9eb |
programgym/judwhite--go-svc.a2deda2 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for judwhite/go-svc | [
"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": "judwhite__go-svc.a2deda2",
"repository": "judwhite/go-svc",
"commit": "a2deda217eb3db0e1264c3386d5e41f8c8b08207",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.7543483357,
"test_branches": 3,
"test_count": 40
} | [
"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_... | judwhite--go-svc.a2deda2 |
programgym/julien-r44--cli-candlestick-chart.9ea785c | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for Julien-R44/cli-candlestick-chart | [
"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": "Julien-R44__cli-candlestick-chart.9ea785c",
"repository": "Julien-R44/cli-candlestick-chart",
"commit": "9ea785c1a9fe5e2357bfe1411150ad0a7e009135",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.7764105888000001,
"test_branches": 4,
"test_coun... | [
"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... | julien-r44--cli-candlestick-chart.9ea785c |
programgym/jumpseclabs--tokensmith.5aebff1 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for JumpsecLabs/TokenSmith | [
"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": "JumpsecLabs__TokenSmith.5aebff1",
"repository": "JumpsecLabs/TokenSmith",
"commit": "5aebff1b91efd339ef4451b7d2f9eddcc90df90d",
"language": "go",
"difficulty": "unknown",
"difficulty_score": 0,
"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_... | jumpseclabs--tokensmith.5aebff1 |
programgym/junyu-w--corgi.7d807b3 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for junyu-w/corgi | [
"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": "junyu-w__corgi.7d807b3",
"repository": "junyu-w/corgi",
"commit": "7d807b3b6bc2c8d18a146638cbbb23876b2c4296",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.1978316933,
"test_branches": 3,
"test_count": 263
} | [
"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_... | junyu-w--corgi.7d807b3 |
programgym/justinhj--astar-algorithm-cpp.72d8b0a | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for justinhj/astar-algorithm-cpp | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "justinhj__astar-algorithm-cpp.72d8b0a",
"repository": "justinhj/astar-algorithm-cpp",
"commit": "72d8b0a620221fd8b1d8ae85fc0c568b501b3917",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.3832766504,
"test_branches": 3,
"test_count": 1286
} | [
"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/... | justinhj--astar-algorithm-cpp.72d8b0a |
programgym/justmao945--mallory.acabe6b | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for justmao945/mallory | [
"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": "justmao945__mallory.acabe6b",
"repository": "justmao945/mallory",
"commit": "acabe6b26e52940fda9989a7c7e2a303a8f21c9c",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.757244151,
"test_branches": 4,
"test_count": 203
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | justmao945--mallory.acabe6b |
programgym/jwaldrip--odin.b258408 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jwaldrip/odin | [
"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": "jwaldrip__odin.b258408",
"repository": "jwaldrip/odin",
"commit": "b2584086c5b5629ad26f4f82d704b08ff6fc2f4c",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.2452658395,
"test_branches": 4,
"test_count": 697
} | [
"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_... | jwaldrip--odin.b258408 |
programgym/jwilberding--bcp.8afa131 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for jwilberding/bcp | [
"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": "jwilberding__bcp.8afa131",
"repository": "jwilberding/bcp",
"commit": "8afa1318710a83d18b33e2eaa822b2eaaf48db5e",
"language": "c",
"difficulty": "easy",
"difficulty_score": 0.6394864893000001,
"test_branches": 1,
"test_count": 127
} | [
"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"... | jwilberding--bcp.8afa131 |
programgym/kaegi--alass.874f02d | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kaegi/alass | [
"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": "kaegi__alass.874f02d",
"repository": "kaegi/alass",
"commit": "874f02d9577182752a0f969b6d6b98fd65bdf1fc",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.870286829,
"test_branches": 4,
"test_count": 401
} | [
"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/... | kaegi--alass.874f02d |
programgym/kahroba-lang--kahroba.808fde3 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kahroba-lang/kahroba | [
"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": "kahroba-lang__kahroba.808fde3",
"repository": "kahroba-lang/kahroba",
"commit": "808fde36586886691dd42c4fe90606898a5615bd",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.3900514965,
"test_branches": 4,
"test_count": 647
} | [
"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_... | kahroba-lang--kahroba.808fde3 |
programgym/kanaka--wac.8c9da26 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kanaka/wac | [
"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": "kanaka__wac.8c9da26",
"repository": "kanaka/wac",
"commit": "8c9da26b4fee6d1a320f944e3a55cc37d5ff1e09",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.7392558033,
"test_branches": 4,
"test_count": 1106
} | [
"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/... | kanaka--wac.8c9da26 |
programgym/karrick--godirwalk.9a7752c | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for karrick/godirwalk | [
"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": "karrick__godirwalk.9a7752c",
"repository": "karrick/godirwalk",
"commit": "9a7752c108e7ea76255201b9f47bd4d4d2df868e",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.1312977966,
"test_branches": 4,
"test_count": 166
} | [
"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_... | karrick--godirwalk.9a7752c |
programgym/kataras--golog.768605c | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kataras/golog | [
"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": "kataras__golog.768605c",
"repository": "kataras/golog",
"commit": "768605c801e1d4a857d6ce906211ae378b8a26d2",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.7883098121,
"test_branches": 4,
"test_count": 293
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | kataras--golog.768605c |
programgym/kazuho--picojson.111c9be | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kazuho/picojson | [
"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": "kazuho__picojson.111c9be",
"repository": "kazuho/picojson",
"commit": "111c9be5188f7350c2eac9ddaedd8cca3d7bf394",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.233757363,
"test_branches": 2,
"test_count": 459
} | [
"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... | kazuho--picojson.111c9be |
programgym/kdab--codebrowser.ebe91a8 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for KDAB/codebrowser | [
"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": "KDAB__codebrowser.ebe91a8",
"repository": "KDAB/codebrowser",
"commit": "ebe91a86e4d06a23f5f7709d081f83e2cc14ef26",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.8878984881,
"test_branches": 4,
"test_count": 287
} | [
"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... | kdab--codebrowser.ebe91a8 |
programgym/kdab--kdbindings.f4924de | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for KDAB/KDBindings | [
"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": "KDAB__KDBindings.f4924de",
"repository": "KDAB/KDBindings",
"commit": "f4924de754a63ce44d1532d6d245289210bc4441",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.5504729571,
"test_branches": 5,
"test_count": 255
} | [
"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... | kdab--kdbindings.f4924de |
programgym/kdab--kddockwidgets.4d1b9ea | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for KDAB/KDDockWidgets | [
"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": "KDAB__KDDockWidgets.4d1b9ea",
"repository": "KDAB/KDDockWidgets",
"commit": "4d1b9ea6042e215858af000e2e4c35ec693b0972",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 3.6819409732,
"test_branches": 6,
"test_count": 912
} | [
"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... | kdab--kddockwidgets.4d1b9ea |
programgym/kdr2--redis-leveldb.e807fe2 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for KDr2/redis-leveldb | [
"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": "KDr2__redis-leveldb.e807fe2",
"repository": "KDr2/redis-leveldb",
"commit": "e807fe2d2ab9106b779550fe770f791a91de58bc",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.436480695,
"test_branches": 3,
"test_count": 374
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | kdr2--redis-leveldb.e807fe2 |
programgym/keats--rust-bcrypt.270d3cb | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for Keats/rust-bcrypt | [
"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": "Keats__rust-bcrypt.270d3cb",
"repository": "Keats/rust-bcrypt",
"commit": "270d3cb8cc867242cde7d37726339f235bcb800b",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.7702627382,
"test_branches": 3,
"test_count": 432
} | [
"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/... | keats--rust-bcrypt.270d3cb |
programgym/keenerd--jshon.d919aea | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for keenerd/jshon | [
"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": "keenerd__jshon.d919aea",
"repository": "keenerd/jshon",
"commit": "d919aeaece37962251dbe6c1ee50f0028a5c90e4",
"language": "c",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 1,
"test_count": 221
} | [
"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"... | keenerd--jshon.d919aea |
programgym/keidarcy--e1s.81e0815 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for keidarcy/e1s | [
"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": "keidarcy__e1s.81e0815",
"repository": "keidarcy/e1s",
"commit": "81e08154804eb86b73c189cddb8d58d47533429b",
"language": "go",
"difficulty": "medium",
"difficulty_score": 3.6584788467,
"test_branches": 6,
"test_count": 534
} | [
"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... | keidarcy--e1s.81e0815 |
programgym/kelbon--anyany.560301c | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kelbon/AnyAny | [
"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": "kelbon__AnyAny.560301c",
"repository": "kelbon/AnyAny",
"commit": "560301c278e46bb527e49b1739dcb841035a9932",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.6983615661,
"test_branches": 3,
"test_count": 97
} | [
"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... | kelbon--anyany.560301c |
programgym/kelseyhightower--grpc-hello-service.4be93eb | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kelseyhightower/grpc-hello-service | [
"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": "kelseyhightower__grpc-hello-service.4be93eb",
"repository": "kelseyhightower/grpc-hello-service",
"commit": "4be93eb92cbc1f21b3ed2519cdc9f1d3ef5e9143",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.8055008582000001,
"test_branches": 2,
"test_co... | [
"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... | kelseyhightower--grpc-hello-service.4be93eb |
programgym/kennylevinsen--greetd.d3b45e7 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kennylevinsen/greetd | [
"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": "kennylevinsen__greetd.d3b45e7",
"repository": "kennylevinsen/greetd",
"commit": "d3b45e7398d3eed65b39c532c713ea052a5b9278",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.5712428506,
"test_branches": 3,
"test_count": 262
} | [
"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/... | kennylevinsen--greetd.d3b45e7 |
programgym/keroro824--hashingdeeplearning.c928349 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for keroro824/HashingDeepLearning | [
"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": "keroro824__HashingDeepLearning.c928349",
"repository": "keroro824/HashingDeepLearning",
"commit": "c9283490ffe34ba97005ec6e11800fdcdf165d79",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.9869955397,
"test_branches": 3,
"test_count": 268
} | [
"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... | keroro824--hashingdeeplearning.c928349 |
programgym/kevin-hanselman--dud.1b99eff | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kevin-hanselman/dud | [
"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": "kevin-hanselman__dud.1b99eff",
"repository": "kevin-hanselman/dud",
"commit": "1b99eff4946977c4774cfabc56de2a3f9fbfe2cb",
"language": "go",
"difficulty": "medium",
"difficulty_score": 3.2159176631,
"test_branches": 5,
"test_count": 632
} | [
"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... | kevin-hanselman--dud.1b99eff |
programgym/kevinburke--go-bindata.409a9b0 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kevinburke/go-bindata | [
"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": "kevinburke__go-bindata.409a9b0",
"repository": "kevinburke/go-bindata",
"commit": "409a9b060f3d38f464e0989fc9bd69a4f3fdb8db",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.7466341989,
"test_branches": 4,
"test_count": 283
} | [
"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_... | kevinburke--go-bindata.409a9b0 |
programgym/kevincoooool--ks_v3s.802014b | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for Kevincoooool/KS_V3S | [
"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": "Kevincoooool__KS_V3S.802014b",
"repository": "Kevincoooool/KS_V3S",
"commit": "802014bd72c97e67821e37187f441749ccdcbea8",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.1643528558,
"test_branches": 1,
"test_count": 68
} | [
"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"... | kevincoooool--ks_v3s.802014b |
programgym/khronosgroup--collada2gltf.4043a37 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for KhronosGroup/COLLADA2GLTF | [
"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": "KhronosGroup__COLLADA2GLTF.4043a37",
"repository": "KhronosGroup/COLLADA2GLTF",
"commit": "4043a37892e2dd642c89b3bc6e7c2431d1318c26",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.9495851513,
"test_branches": 5,
"test_count": 189
} | [
"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... | khronosgroup--collada2gltf.4043a37 |
programgym/kigster--cmake-project-template.6022475 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kigster/cmake-project-template | [
"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": "kigster__cmake-project-template.6022475",
"repository": "kigster/cmake-project-template",
"commit": "602247571baf269a8290de3c25c296bba5ab0c19",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 0.0530784435,
"test_branches": 4,
"test_count": 666
} | [
"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... | kigster--cmake-project-template.6022475 |
programgym/kisielk--godepgraph.7a3cd9a | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kisielk/godepgraph | [
"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": "kisielk__godepgraph.7a3cd9a",
"repository": "kisielk/godepgraph",
"commit": "7a3cd9aa776736b0356ddd90b70ac6f64139c8ae",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.5954962218000001,
"test_branches": 3,
"test_count": 119
} | [
"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_... | kisielk--godepgraph.7a3cd9a |
programgym/kistler-group--sdbus-cpp.0b9b15c | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for Kistler-Group/sdbus-cpp | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"cpp"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "Kistler-Group__sdbus-cpp.0b9b15c",
"repository": "Kistler-Group/sdbus-cpp",
"commit": "0b9b15cbac4fe6be22cbbf248c79fb2f4c40be13",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 2.7363008672999998,
"test_branches": 6,
"test_count": 1845
} | [
"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... | kistler-group--sdbus-cpp.0b9b15c |
programgym/kitops-ml--kitops.6b8162a | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kitops-ml/kitops | [
"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": "kitops-ml__kitops.6b8162a",
"repository": "kitops-ml/kitops",
"commit": "6b8162ae5da4d46f1d2af2beb43e7fb077f052f4",
"language": "go",
"difficulty": "medium",
"difficulty_score": 3.9258492115,
"test_branches": 6,
"test_count": 976
} | [
"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... | kitops-ml--kitops.6b8162a |
programgym/kiwix--kiwix-tools.f76e38b | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kiwix/kiwix-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": "kiwix__kiwix-tools.f76e38b",
"repository": "kiwix/kiwix-tools",
"commit": "f76e38bdc06b86b73ba8e84a5de234a0d6c3fa3d",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 0.949877704,
"test_branches": 2,
"test_count": 379
} | [
"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... | kiwix--kiwix-tools.f76e38b |
programgym/kjk--the-code.c20ee18 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kjk/the-code | [
"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": "kjk__the-code.c20ee18",
"repository": "kjk/the-code",
"commit": "c20ee18c9581ae26ed3851be9684a439b795c8e4",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.4344092076,
"test_branches": 1,
"test_count": 12
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/download.sh",
"tests... | kjk--the-code.c20ee18 |
programgym/kkdai--chatgpt.ef1116e | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kkdai/chatgpt | [
"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": "kkdai__chatgpt.ef1116e",
"repository": "kkdai/chatgpt",
"commit": "ef1116e155eeb396ede4d7a9522c4484870b156d",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.7201593034,
"test_branches": 1,
"test_count": 71
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/download.sh",
"tests... | kkdai--chatgpt.ef1116e |
programgym/kkoomen--vim-doge.03a8407 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kkoomen/vim-doge | [
"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": "kkoomen__vim-doge.03a8407",
"repository": "kkoomen/vim-doge",
"commit": "03a84072ef21b205237c77986c78914395d646c3",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.4922014514000002,
"test_branches": 4,
"test_count": 706
} | [
"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... | kkoomen--vim-doge.03a8407 |
programgym/klauspost--asmfmt.ef134b9 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for klauspost/asmfmt | [
"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": "klauspost__asmfmt.ef134b9",
"repository": "klauspost/asmfmt",
"commit": "ef134b9cec704e2b7b336fb02153b7d1a58247da",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.9532763367,
"test_branches": 3,
"test_count": 237
} | [
"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_... | klauspost--asmfmt.ef134b9 |
programgym/klauspost--cpuid.8590c16 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for klauspost/cpuid | [
"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": "klauspost__cpuid.8590c16",
"repository": "klauspost/cpuid",
"commit": "8590c161fbc87954548d2aedb65e2aad4e5137d1",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.845718018,
"test_branches": 4,
"test_count": 464
} | [
"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_... | klauspost--cpuid.8590c16 |
programgym/klaxa--mkvserver_mk2.8e303e0 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for klaxa/mkvserver_mk2 | [
"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": "klaxa__mkvserver_mk2.8e303e0",
"repository": "klaxa/mkvserver_mk2",
"commit": "8e303e020bc8fa238637d190f510312d87c7f539",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.2255677134,
"test_branches": 4,
"test_count": 560
} | [
"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/... | klaxa--mkvserver_mk2.8e303e0 |
programgym/klirichek--zj-58.6474356 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for klirichek/zj-58 | [
"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": "klirichek__zj-58.6474356",
"repository": "klirichek/zj-58",
"commit": "64743565df4379098b68a197d074c86617a8fc0a",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.0492180227,
"test_branches": 1,
"test_count": 175
} | [
"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"... | klirichek--zj-58.6474356 |
programgym/kljensen--snowball.80af012 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kljensen/snowball | [
"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": "kljensen__snowball.80af012",
"repository": "kljensen/snowball",
"commit": "80af012a384a793519cfa4f6b42ba9f791c29ac1",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6109793799,
"test_branches": 4,
"test_count": 1167
} | [
"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... | kljensen--snowball.80af012 |
programgym/knadh--stuffbin.aa6399d | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for knadh/stuffbin | [
"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": "knadh__stuffbin.aa6399d",
"repository": "knadh/stuffbin",
"commit": "aa6399d254a7d2fccb74bc19b3f55927d4b462da",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.9943171527,
"test_branches": 4,
"test_count": 284
} | [
"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_... | knadh--stuffbin.aa6399d |
programgym/kndndrj--nvim-dbee.dda5176 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kndndrj/nvim-dbee | [
"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": "kndndrj__nvim-dbee.dda5176",
"repository": "kndndrj/nvim-dbee",
"commit": "dda517694889a5d238d7aa407403984da9f80cc0",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.8055008582,
"test_branches": 4,
"test_count": 378
} | [
"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_... | kndndrj--nvim-dbee.dda5176 |
programgym/knqyf263--utern.9028601 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for knqyf263/utern | [
"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": "knqyf263__utern.9028601",
"repository": "knqyf263/utern",
"commit": "90286013bbf90b6f4e5f0b2bcf7e46a109d778ed",
"language": "go",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 4,
"test_count": 607
} | [
"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_... | knqyf263--utern.9028601 |
programgym/knrt10--asciiconvert.0acdaf8 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for knrt10/asciiConvert | [
"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": "knrt10__asciiConvert.0acdaf8",
"repository": "knrt10/asciiConvert",
"commit": "0acdaf8529967f603dcc0fbf2c45c6bdb0d51fc6",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.8976270913000001,
"test_branches": 2,
"test_count": 121
} | [
"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_... | knrt10--asciiconvert.0acdaf8 |
programgym/koba789--human-in-the-loop.6f95553 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for KOBA789/human-in-the-loop | [
"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": "KOBA789__human-in-the-loop.6f95553",
"repository": "KOBA789/human-in-the-loop",
"commit": "6f955531ebca5092130ac11c63788792cc424488",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.377852419,
"test_branches": 3,
"test_count": 328
} | [
"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... | koba789--human-in-the-loop.6f95553 |
programgym/koenbollen--jl.ef5e34c | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for koenbollen/jl | [
"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": "koenbollen__jl.ef5e34c",
"repository": "koenbollen/jl",
"commit": "ef5e34cf2da30d65a40adc7ec1a4cde4bc7e798f",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9189734305,
"test_branches": 4,
"test_count": 564
} | [
"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_... | koenbollen--jl.ef5e34c |
programgym/koenrh--s3enum.1e95b89 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for koenrh/s3enum | [
"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": "koenrh__s3enum.1e95b89",
"repository": "koenrh/s3enum",
"commit": "1e95b89e7532005be8f94bedd516ce7b28c67a8f",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.4954055631,
"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_... | koenrh--s3enum.1e95b89 |
programgym/koihik--luaformatter.29afe10 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for Koihik/LuaFormatter | [
"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": "Koihik__LuaFormatter.29afe10",
"repository": "Koihik/LuaFormatter",
"commit": "29afe1046ad015de96ffdb6d361a21882356e801",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.5149460053000001,
"test_branches": 5,
"test_count": 1465
} | [
"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... | koihik--luaformatter.29afe10 |
programgym/kongaskristjan--fire-hpp.7d000fd | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kongaskristjan/fire-hpp | [
"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": "kongaskristjan__fire-hpp.7d000fd",
"repository": "kongaskristjan/fire-hpp",
"commit": "7d000fd65375503bc7c8bb2add9c97b0f0110613",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.1586639808,
"test_branches": 2,
"test_count": 206
} | [
"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... | kongaskristjan--fire-hpp.7d000fd |
programgym/korovkin--limiter.004398a | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for korovkin/limiter | [
"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": "korovkin__limiter.004398a",
"repository": "korovkin/limiter",
"commit": "004398ae789561591d4991626dbbfb9691b8171b",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.29907126,
"test_branches": 4,
"test_count": 218
} | [
"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... | korovkin--limiter.004398a |
programgym/kovacsv--occt-import-js.41e4708 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kovacsv/occt-import-js | [
"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": "kovacsv__occt-import-js.41e4708",
"repository": "kovacsv/occt-import-js",
"commit": "41e470890ae0f9dc69ac50ffd5fc73e03576f4eb",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.1251558296,
"test_branches": 3,
"test_count": 493
} | [
"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... | kovacsv--occt-import-js.41e4708 |
programgym/kovetskiy--manul.b036c31 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kovetskiy/manul | [
"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": "kovetskiy__manul.b036c31",
"repository": "kovetskiy/manul",
"commit": "b036c31e292f34236b4dd30146b62e3b826d53c1",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.0534626049,
"test_branches": 5,
"test_count": 284
} | [
"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_... | kovetskiy--manul.b036c31 |
programgym/kpcyrd--rshijack.acf2bc8 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kpcyrd/rshijack | [
"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": "kpcyrd__rshijack.acf2bc8",
"repository": "kpcyrd/rshijack",
"commit": "acf2bc844eef9d0789bfc6ed2951881e6401d9b2",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.7615519886,
"test_branches": 3,
"test_count": 314
} | [
"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... | kpcyrd--rshijack.acf2bc8 |
programgym/kreuzwerker--envplate.ec00ede | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kreuzwerker/envplate | [
"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": "kreuzwerker__envplate.ec00ede",
"repository": "kreuzwerker/envplate",
"commit": "ec00ede3ca03c6bbbe0412bf4b84eacdcdabba11",
"language": "go",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 5,
"test_count": 405
} | [
"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_... | kreuzwerker--envplate.ec00ede |
programgym/krylovsk--mqtt-benchmark.f46efba | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for krylovsk/mqtt-benchmark | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "krylovsk__mqtt-benchmark.f46efba",
"repository": "krylovsk/mqtt-benchmark",
"commit": "f46efba1a710a117c80d0ba94281e0a99e7b96a4",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.3993275322,
"test_branches": 2,
"test_count": 100
} | [
"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... | krylovsk--mqtt-benchmark.f46efba |
programgym/kthohr--optim.5453f48 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for kthohr/optim | [
"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": "kthohr__optim.5453f48",
"repository": "kthohr/optim",
"commit": "5453f48aca695e6fef123677f35cb4d22e356e73",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.8606374168,
"test_branches": 5,
"test_count": 292
} | [
"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... | kthohr--optim.5453f48 |
programgym/ku-nlp--jumanpp.34aa52c | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for ku-nlp/jumanpp | [
"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": "ku-nlp__jumanpp.34aa52c",
"repository": "ku-nlp/jumanpp",
"commit": "34aa52cffbeb0ca94110a842966c9583cb151104",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 3.4317544534,
"test_branches": 7,
"test_count": 2060
} | [
"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... | ku-nlp--jumanpp.34aa52c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.