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/reimunotmoe--ydotool.708e96f | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for ReimuNotMoe/ydotool | [
"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": "ReimuNotMoe__ydotool.708e96f",
"repository": "ReimuNotMoe/ydotool",
"commit": "708e96ff27e381a8c549418a9d34cdde12305317",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.1989318699,
"test_branches": 4,
"test_count": 811
} | [
"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/... | reimunotmoe--ydotool.708e96f |
programgym/remind101--assume-role.06a34b0 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for remind101/assume-role | [
"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": "remind101__assume-role.06a34b0",
"repository": "remind101/assume-role",
"commit": "06a34b06d24a610291bb0952f2a24341e67a9b6e",
"language": "go",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 1,
"test_count": 122
} | [
"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... | remind101--assume-role.06a34b0 |
programgym/remind101--ssm-env.85ce595 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for remind101/ssm-env | [
"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": "remind101__ssm-env.85ce595",
"repository": "remind101/ssm-env",
"commit": "85ce59500f02d685df14c82430b7500b4a647155",
"language": "go",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 2,
"test_count": 236
} | [
"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_... | remind101--ssm-env.85ce595 |
programgym/remotemobprogramming--mob.6efd2d0 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for remotemobprogramming/mob | [
"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": "remotemobprogramming__mob.6efd2d0",
"repository": "remotemobprogramming/mob",
"commit": "6efd2d0d667bd70e46e0a9878d34da075675618d",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5074510609,
"test_branches": 4,
"test_count": 352
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | remotemobprogramming--mob.6efd2d0 |
programgym/resibots--limbo.43c67a6 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for resibots/limbo | [
"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": "resibots__limbo.43c67a6",
"repository": "resibots/limbo",
"commit": "43c67a6999a40a3349aa6d0f152f853e028ed509",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 2.2980448426,
"test_branches": 6,
"test_count": 588
} | [
"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... | resibots--limbo.43c67a6 |
programgym/resyncgg--armada.d1df00a | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for resyncgg/armada | [
"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": "resyncgg__armada.d1df00a",
"repository": "resyncgg/armada",
"commit": "d1df00a266baec5e308327092459fae63fe14e1b",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.2557547866,
"test_branches": 4,
"test_count": 644
} | [
"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/... | resyncgg--armada.d1df00a |
programgym/retinify--retinify.a7ae039 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for retinify/retinify | [
"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": "retinify__retinify.a7ae039",
"repository": "retinify/retinify",
"commit": "a7ae0390ba42de2a608c6f4c1cfd2fcc2d8ea1b5",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 2.063183188,
"test_branches": 5,
"test_count": 61
} | [
"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... | retinify--retinify.a7ae039 |
programgym/reugn--async.533dc33 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for reugn/async | [
"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": "reugn__async.533dc33",
"repository": "reugn/async",
"commit": "533dc33a7b8bc8443ae75b75ac0cd3cd0720f7a5",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.2046625117,
"test_branches": 4,
"test_count": 88
} | [
"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_... | reugn--async.533dc33 |
programgym/reugn--go-quartz.139dd89 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for reugn/go-quartz | [
"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": "reugn__go-quartz.139dd89",
"repository": "reugn/go-quartz",
"commit": "139dd893183179ae3820dd78c26fdec9613ee31f",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.5303277898,
"test_branches": 4,
"test_count": 104
} | [
"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_... | reugn--go-quartz.139dd89 |
programgym/revng--pagebuster.2eeb694 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for revng/pagebuster | [
"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": "revng__pagebuster.2eeb694",
"repository": "revng/pagebuster",
"commit": "2eeb6948572d938504df39db6b4e44d43e89659a",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.0199466817,
"test_branches": 2,
"test_count": 302
} | [
"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/... | revng--pagebuster.2eeb694 |
programgym/rhysd--dot-github.5f7c33c | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rhysd/dot-github | [
"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": "rhysd__dot-github.5f7c33c",
"repository": "rhysd/dot-github",
"commit": "5f7c33c80f16f7ddfb08d722299cf877f8ec0f55",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.3222192947,
"test_branches": 4,
"test_count": 157
} | [
"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_... | rhysd--dot-github.5f7c33c |
programgym/rhysd--vim-startuptime.e805bd8 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rhysd/vim-startuptime | [
"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": "rhysd__vim-startuptime.e805bd8",
"repository": "rhysd/vim-startuptime",
"commit": "e805bd8f255835a2940233a99eeb2601871aa9a1",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.946452265,
"test_branches": 4,
"test_count": 171
} | [
"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_... | rhysd--vim-startuptime.e805bd8 |
programgym/ribice--glice.6751fcb | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for ribice/glice | [
"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": "ribice__glice.6751fcb",
"repository": "ribice/glice",
"commit": "6751fcb890e76264c1a322ebbef84a2e745739b0",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9245893857,
"test_branches": 3,
"test_count": 155
} | [
"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_... | ribice--glice.6751fcb |
programgym/richardanaya--executor.5e3b7c2 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for richardanaya/executor | [
"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": "richardanaya__executor.5e3b7c2",
"repository": "richardanaya/executor",
"commit": "5e3b7c22c27d32d5da85b95a3ac43b897b14e4ce",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 0.7715874809000001,
"test_branches": 2,
"test_count": 176
} | [
"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/... | richardanaya--executor.5e3b7c2 |
programgym/richgel999--miniz.e78dfd2 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for richgel999/miniz | [
"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": "richgel999__miniz.e78dfd2",
"repository": "richgel999/miniz",
"commit": "e78dfd22d0a9521d1b8019f3642357b59d1261fb",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.9744195739000001,
"test_branches": 5,
"test_count": 378
} | [
"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... | richgel999--miniz.e78dfd2 |
programgym/richox--orz.29414c6 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for richox/orz | [
"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": "richox__orz.29414c6",
"repository": "richox/orz",
"commit": "29414c69566529b1d87c2347889f36280c20b962",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.8980666606,
"test_branches": 4,
"test_count": 1057
} | [
"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/... | richox--orz.29414c6 |
programgym/ricoberger--vault-secrets-operator.64391df | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for ricoberger/vault-secrets-operator | [
"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": "ricoberger__vault-secrets-operator.64391df",
"repository": "ricoberger/vault-secrets-operator",
"commit": "64391df925bc25f02bb7e5964bdab6848b4b11fe",
"language": "go",
"difficulty": "medium",
"difficulty_score": 3.4348242963,
"test_branches": 6,
"test_count": ... | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_configure_java_mirrors.sh",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-go.tar.gz",
"environme... | ricoberger--vault-secrets-operator.64391df |
programgym/riza--linx.0447a72 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for riza/linx | [
"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": "riza__linx.0447a72",
"repository": "riza/linx",
"commit": "0447a7266ce898f79bd9a943584ffed0836e97fc",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6707095952,
"test_branches": 4,
"test_count": 274
} | [
"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_... | riza--linx.0447a72 |
programgym/rjeczalik--interfaces.4586dff | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rjeczalik/interfaces | [
"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": "rjeczalik__interfaces.4586dff",
"repository": "rjeczalik/interfaces",
"commit": "4586dfff9fe69b16dec7037a4b7e211fed7b08f3",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.3372595398,
"test_branches": 4,
"test_count": 239
} | [
"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_... | rjeczalik--interfaces.4586dff |
programgym/rkoval--alfred-aws-console-services-workflow.4f0e46d | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rkoval/alfred-aws-console-services-workflow | [
"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": "rkoval__alfred-aws-console-services-workflow.4f0e46d",
"repository": "rkoval/alfred-aws-console-services-workflow",
"commit": "4f0e46db45e6ca0f69fa4e46cc841b2de1d29050",
"language": "go",
"difficulty": "medium",
"difficulty_score": 3.2363256047,
"test_branches":... | [
"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... | rkoval--alfred-aws-console-services-workflow.4f0e46d |
programgym/rnitta--commit_artist.1111111 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rnitta/commit_artist | [
"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": "rnitta__commit_artist.1111111",
"repository": "rnitta/commit_artist",
"commit": "1111111f4e33516d53e42b4cef00c4662a15154c",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.4674601095,
"test_branches": 4,
"test_count": 261
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | rnitta--commit_artist.1111111 |
programgym/robiot--rustcat.3f80eaf | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for robiot/rustcat | [
"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": "robiot__rustcat.3f80eaf",
"repository": "robiot/rustcat",
"commit": "3f80eaf968a4bf046dc329acf9a6154f388a5f79",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.568670978,
"test_branches": 4,
"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... | robiot--rustcat.3f80eaf |
programgym/roblaszczak--go-cleanarch.03b9605 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for roblaszczak/go-cleanarch | [
"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": "roblaszczak__go-cleanarch.03b9605",
"repository": "roblaszczak/go-cleanarch",
"commit": "03b96056c4c9ff2a739629f1e39f32715d3f9e65",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.48429983930000003,
"test_branches": 3,
"test_count": 225
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | roblaszczak--go-cleanarch.03b9605 |
programgym/roblaszczak--vgt.ff6da83 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for roblaszczak/vgt | [
"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": "roblaszczak__vgt.ff6da83",
"repository": "roblaszczak/vgt",
"commit": "ff6da830ded5156807e724f0bba8b9312b5ddccc",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9185021396000002,
"test_branches": 4,
"test_count": 198
} | [
"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_... | roblaszczak--vgt.ff6da83 |
programgym/roboticslibrary--rl.91df9f2 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for roboticslibrary/rl | [
"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": "roboticslibrary__rl.91df9f2",
"repository": "roboticslibrary/rl",
"commit": "91df9f231ba08dfd6c540edee2838d75508ca848",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 2.9652863873,
"test_branches": 7,
"test_count": 1699
} | [
"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... | roboticslibrary--rl.91df9f2 |
programgym/rogersce--cnpy.4e8810b | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rogersce/cnpy | [
"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": "rogersce__cnpy.4e8810b",
"repository": "rogersce/cnpy",
"commit": "4e8810b1a8637695171ed346ce68f6984e585ef4",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.123198075,
"test_branches": 2,
"test_count": 183
} | [
"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... | rogersce--cnpy.4e8810b |
programgym/rogpeppe--godef.5634abc | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rogpeppe/godef | [
"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": "rogpeppe__godef.5634abc",
"repository": "rogpeppe/godef",
"commit": "5634abc2f36e9be5b4cd4310eaf40cb1e70673d6",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.7900739484,
"test_branches": 4,
"test_count": 385
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | rogpeppe--godef.5634abc |
programgym/ronsoros--rvm.d79a016 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for ronsoros/rvm | [
"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": "ronsoros__rvm.d79a016",
"repository": "ronsoros/rvm",
"commit": "d79a016c1fc1c7ec252450d82e60f9e22c4d653f",
"language": "c",
"difficulty": "easy",
"difficulty_score": 0.6232492904,
"test_branches": 1,
"test_count": 308
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/download.sh"... | ronsoros--rvm.d79a016 |
programgym/roogle-rs--roogle.9b4627d | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for roogle-rs/roogle | [
"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": "roogle-rs__roogle.9b4627d",
"repository": "roogle-rs/roogle",
"commit": "9b4627de58c2627e21799edd3128c01722f538ce",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.2092468487999999,
"test_branches": 3,
"test_count": 231
} | [
"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/... | roogle-rs--roogle.9b4627d |
programgym/ropnop--kerbrute.9cfb81e | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for ropnop/kerbrute | [
"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": "ropnop__kerbrute.9cfb81e",
"repository": "ropnop/kerbrute",
"commit": "9cfb81e4fab8037acb44c678773ca3f93bc2b39c",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.8455321175,
"test_branches": 4,
"test_count": 217
} | [
"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... | ropnop--kerbrute.9cfb81e |
programgym/rorosen--zeekstd.1804380 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rorosen/zeekstd | [
"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": "rorosen__zeekstd.1804380",
"repository": "rorosen/zeekstd",
"commit": "180438029281db712763f69393947340278d2992",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.7082508886,
"test_branches": 4,
"test_count": 605
} | [
"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/... | rorosen--zeekstd.1804380 |
programgym/rrwick--filtlong.8389367 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rrwick/Filtlong | [
"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": "rrwick__Filtlong.8389367",
"repository": "rrwick/Filtlong",
"commit": "83893671ed26a271880973e87dfd3f3088ea9c09",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.6887756553000002,
"test_branches": 5,
"test_count": 664
} | [
"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... | rrwick--filtlong.8389367 |
programgym/rs--jaggr.0f5ada6 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rs/jaggr | [
"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": "rs__jaggr.0f5ada6",
"repository": "rs/jaggr",
"commit": "0f5ada6eeda811f62a4b8e913ccbf6c2804cd273",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.4261858252000001,
"test_branches": 4,
"test_count": 656
} | [
"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_... | rs--jaggr.0f5ada6 |
programgym/rsasaki0109--kalman_filter_localization_ros2.86ad8fd | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rsasaki0109/kalman_filter_localization_ros2 | [
"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": "rsasaki0109__kalman_filter_localization_ros2.86ad8fd",
"repository": "rsasaki0109/kalman_filter_localization_ros2",
"commit": "86ad8fd8be6fb6402406a0b3b9bfb75f4d6b4306",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.509874285,
"test_branches": 3... | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | rsasaki0109--kalman_filter_localization_ros2.86ad8fd |
programgym/rsasaki0109--li_slam_ros2.6f44808 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rsasaki0109/li_slam_ros2 | [
"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": "rsasaki0109__li_slam_ros2.6f44808",
"repository": "rsasaki0109/li_slam_ros2",
"commit": "6f448087b8b7805d0221cec3b58de423d6b54d69",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.8108371510999999,
"test_branches": 3,
"test_count": 449
} | [
"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... | rsasaki0109--li_slam_ros2.6f44808 |
programgym/rsc--2fa.3b314a2 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rsc/2fa | [
"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": "rsc__2fa.3b314a2",
"repository": "rsc/2fa",
"commit": "3b314a29f85f448059c2facbc9c77cada5e6f806",
"language": "go",
"difficulty": "unknown",
"difficulty_score": 0,
"test_branches": 2,
"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_... | rsc--2fa.3b314a2 |
programgym/rsc--goversion.3a30cee | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rsc/goversion | [
"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": "rsc__goversion.3a30cee",
"repository": "rsc/goversion",
"commit": "3a30cee7003ec5dc0903682e79b3059c8e101952",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.0802656273,
"test_branches": 4,
"test_count": 164
} | [
"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... | rsc--goversion.3a30cee |
programgym/rt64--rt64.f0728a2 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rt64/rt64 | [
"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": "rt64__rt64.f0728a2",
"repository": "rt64/rt64",
"commit": "f0728a2520d5aa735886240de3fee75cc805f6d6",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 3.365356928,
"test_branches": 6,
"test_count": 200
} | [
"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... | rt64--rt64.f0728a2 |
programgym/rub-nds--terrapin-scanner.e50b408 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for RUB-NDS/Terrapin-Scanner | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "RUB-NDS__Terrapin-Scanner.e50b408",
"repository": "RUB-NDS/Terrapin-Scanner",
"commit": "e50b4081e912f9470333c71ab59b4396e0e6ab43",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.4284587735,
"test_branches": 2,
"test_count": 121
} | [
"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... | rub-nds--terrapin-scanner.e50b408 |
programgym/rubengooj--stvo-pl.baecb5f | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rubengooj/stvo-pl | [
"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": "rubengooj__stvo-pl.baecb5f",
"repository": "rubengooj/stvo-pl",
"commit": "baecb5f684cae8f71d60d5d230a5e908292434a8",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 2.8133808067,
"test_branches": 5,
"test_count": 106
} | [
"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... | rubengooj--stvo-pl.baecb5f |
programgym/rubiojr--awesome-restic.ef61f3c | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rubiojr/awesome-restic | [
"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": "rubiojr__awesome-restic.ef61f3c",
"repository": "rubiojr/awesome-restic",
"commit": "ef61f3cb1900cf6bc2b331903df7ad0e08a4ba01",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.0572856444,
"test_branches": 4,
"test_count": 303
} | [
"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_... | rubiojr--awesome-restic.ef61f3c |
programgym/rust-cli--confy.b5319f6 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rust-cli/confy | [
"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": "rust-cli__confy.b5319f6",
"repository": "rust-cli/confy",
"commit": "b5319f6a302915109016ffc9a5fa792bcc104f8e",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.9378687966,
"test_branches": 2,
"test_count": 233
} | [
"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/... | rust-cli--confy.b5319f6 |
programgym/rust-db--refinery.bc1a829 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rust-db/refinery | [
"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": "rust-db__refinery.bc1a829",
"repository": "rust-db/refinery",
"commit": "bc1a829d6d50bef16ce9279a6ebfab4910a17d86",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.5689054150000001,
"test_branches": 4,
"test_count": 505
} | [
"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/... | rust-db--refinery.bc1a829 |
programgym/rust-github--template.daf20b3 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rust-github/template | [
"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": "rust-github__template.daf20b3",
"repository": "rust-github/template",
"commit": "daf20b342487c110d1e4a2c9d1712f4643e24094",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 0,
"test_branches": 4,
"test_count": 375
} | [
"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/... | rust-github--template.daf20b3 |
programgym/rust-ml--book.a7e764b | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rust-ml/book | [
"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": "rust-ml__book.a7e764b",
"repository": "rust-ml/book",
"commit": "a7e764bc8a6c207740ed1849b926f3aad42ad913",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 0.9912260757,
"test_branches": 1,
"test_count": 46
} | [
"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"... | rust-ml--book.a7e764b |
programgym/rust-scraper--scraper.07e485f | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rust-scraper/scraper | [
"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": "rust-scraper__scraper.07e485f",
"repository": "rust-scraper/scraper",
"commit": "07e485f3333e0d4f63ea1863ba1aae7aec86d4e7",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.3647385551,
"test_branches": 4,
"test_count": 1666
} | [
"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/... | rust-scraper--scraper.07e485f |
programgym/rustaudio--dsp-chain.b9838d0 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for RustAudio/dsp-chain | [
"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": "RustAudio__dsp-chain.b9838d0",
"repository": "RustAudio/dsp-chain",
"commit": "b9838d078adedf4cfdfd2ae06e14972797d0ee87",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.4323277923,
"test_branches": 4,
"test_count": 552
} | [
"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... | rustaudio--dsp-chain.b9838d0 |
programgym/rustaudio--vst3-sys.f3e8f01 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for RustAudio/vst3-sys | [
"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": "RustAudio__vst3-sys.f3e8f01",
"repository": "RustAudio/vst3-sys",
"commit": "f3e8f01c3de6d5df2f503c920c9f2bf8166a771b",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.8769103113,
"test_branches": 4,
"test_count": 1708
} | [
"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/... | rustaudio--vst3-sys.f3e8f01 |
programgym/rusticstuff--simdutf8.641d57f | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rusticstuff/simdutf8 | [
"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": "rusticstuff__simdutf8.641d57f",
"repository": "rusticstuff/simdutf8",
"commit": "641d57f313df57354246d2b68d4778c092e076c3",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.9913146982,
"test_branches": 5,
"test_count": 3690
} | [
"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/... | rusticstuff--simdutf8.641d57f |
programgym/rustls--rustls-native-certs.c13fbd6 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rustls/rustls-native-certs | [
"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": "rustls__rustls-native-certs.c13fbd6",
"repository": "rustls/rustls-native-certs",
"commit": "c13fbd6f6b63b8d34fd32aba9af1a59ae94c528b",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.5024271200000001,
"test_branches": 5,
"test_count": 488
} | [
"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/... | rustls--rustls-native-certs.c13fbd6 |
programgym/rustls--tokio-rustls.c1dc318 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rustls/tokio-rustls | [
"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": "rustls__tokio-rustls.c1dc318",
"repository": "rustls/tokio-rustls",
"commit": "c1dc3187d730e4370db2a0fb2a5ad4f9fa07bce1",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.7297315953,
"test_branches": 5,
"test_count": 544
} | [
"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/... | rustls--tokio-rustls.c1dc318 |
programgym/ruuda--hound.ad4ce81 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for ruuda/hound | [
"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": "ruuda__hound.ad4ce81",
"repository": "ruuda/hound",
"commit": "ad4ce81d06358d7bb6eb9c040934d3c695a1062a",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.5146805441,
"test_branches": 3,
"test_count": 336
} | [
"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/... | ruuda--hound.ad4ce81 |
programgym/rverton--webanalyze.ad06133 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rverton/webanalyze | [
"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": "rverton__webanalyze.ad06133",
"repository": "rverton/webanalyze",
"commit": "ad06133a839ded2d396ca952a7a904b3d89583e7",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.7833317629,
"test_branches": 4,
"test_count": 238
} | [
"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_... | rverton--webanalyze.ad06133 |
programgym/ryanhaining--cppitertools.531b3d7 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for ryanhaining/cppitertools | [
"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": "ryanhaining__cppitertools.531b3d7",
"repository": "ryanhaining/cppitertools",
"commit": "531b3d753d2bbfe3b0ababe61c2e95e965c54a66",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.7444494574,
"test_branches": 5,
"test_count": 733
} | [
"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... | ryanhaining--cppitertools.531b3d7 |
programgym/rygorous--ryg_rans.c9d162d | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for rygorous/ryg_rans | [
"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": "rygorous__ryg_rans.c9d162d",
"repository": "rygorous/ryg_rans",
"commit": "c9d162d996fd600315af9ae8eb89d832576cb32d",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.3615389713,
"test_branches": 2,
"test_count": 507
} | [
"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... | rygorous--ryg_rans.c9d162d |
programgym/sabhiram--go-wol.eaddd4c | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sabhiram/go-wol | [
"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": "sabhiram__go-wol.eaddd4c",
"repository": "sabhiram/go-wol",
"commit": "eaddd4c1797277cd0372ca27fa8f0bdf44749476",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6437486854999999,
"test_branches": 4,
"test_count": 201
} | [
"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... | sabhiram--go-wol.eaddd4c |
programgym/sachaos--tcpterm.36627dc | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sachaos/tcpterm | [
"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": "sachaos__tcpterm.36627dc",
"repository": "sachaos/tcpterm",
"commit": "36627dca097f642dbbe7b23defd92d5063d76d25",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.3510228525999999,
"test_branches": 3,
"test_count": 99
} | [
"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_... | sachaos--tcpterm.36627dc |
programgym/sad0p--d0zer.8d714b9 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sad0p/d0zer | [
"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": "sad0p__d0zer.8d714b9",
"repository": "sad0p/d0zer",
"commit": "8d714b9cd73e01ead7025beb0009a242e37df1ee",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.1861083798,
"test_branches": 4,
"test_count": 259
} | [
"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_... | sad0p--d0zer.8d714b9 |
programgym/sahilb315--atomixdb.93f53aa | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for Sahilb315/AtomixDB | [
"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": "Sahilb315__AtomixDB.93f53aa",
"repository": "Sahilb315/AtomixDB",
"commit": "93f53aa323368c759c88d27bc2ee3e8f279e50b0",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.8616538702,
"test_branches": 4,
"test_count": 340
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_configure_java_mirrors.sh",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-go.tar.gz",
"environme... | sahilb315--atomixdb.93f53aa |
programgym/sahilm--fuzzy.89d593d | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sahilm/fuzzy | [
"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": "sahilm__fuzzy.89d593d",
"repository": "sahilm/fuzzy",
"commit": "89d593d2aa056a0fcb5c7081e6285ede3d4cd72e",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.026941628,
"test_branches": 3,
"test_count": 91
} | [
"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_... | sahilm--fuzzy.89d593d |
programgym/sam-astro--astro8-computer.0000ba2 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sam-astro/Astro8-Computer | [
"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": "sam-astro__Astro8-Computer.0000ba2",
"repository": "sam-astro/Astro8-Computer",
"commit": "0000ba29a2dcd35b0e210390373445e807ea32f5",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.9237101944,
"test_branches": 4,
"test_count": 558
} | [
"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/... | sam-astro--astro8-computer.0000ba2 |
programgym/sameer--svg2gcode.81893c0 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sameer/svg2gcode | [
"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": "sameer__svg2gcode.81893c0",
"repository": "sameer/svg2gcode",
"commit": "81893c0a0e1f38ec1ed614d2f94f93bb78308b89",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.8954777963,
"test_branches": 4,
"test_count": 669
} | [
"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/... | sameer--svg2gcode.81893c0 |
programgym/samhocevar--portable-file-dialogs.c12ea8c | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for samhocevar/portable-file-dialogs | [
"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": "samhocevar__portable-file-dialogs.c12ea8c",
"repository": "samhocevar/portable-file-dialogs",
"commit": "c12ea8c9a727f5320a2b4570aee863bbede2a204",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.2757719002,
"test_branches": 2,
"test_count": 254... | [
"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... | samhocevar--portable-file-dialogs.c12ea8c |
programgym/samuel--go-thrift.7b67f98 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for samuel/go-thrift | [
"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": "samuel__go-thrift.7b67f98",
"repository": "samuel/go-thrift",
"commit": "7b67f98e972fff643decea89f37246f661635cdb",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.9039577085000001,
"test_branches": 4,
"test_count": 625
} | [
"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_... | samuel--go-thrift.7b67f98 |
programgym/sari3l--poc-monitor.8f30435 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sari3l/Poc-Monitor | [
"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": "sari3l__Poc-Monitor.8f30435",
"repository": "sari3l/Poc-Monitor",
"commit": "8f30435894c6838106276870774831268536e9f4",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6637009254000001,
"test_branches": 2,
"test_count": 66
} | [
"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... | sari3l--poc-monitor.8f30435 |
programgym/sarsko--creusat.8528e5c | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sarsko/CreuSAT | [
"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": "sarsko__CreuSAT.8528e5c",
"repository": "sarsko/CreuSAT",
"commit": "8528e5c9eb65c693168199ba2204edaaad2275b4",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.9989129044,
"test_branches": 5,
"test_count": 775
} | [
"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/... | sarsko--creusat.8528e5c |
programgym/saschagrunert--indextree.b9c8ff1 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for saschagrunert/indextree | [
"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": "saschagrunert__indextree.b9c8ff1",
"repository": "saschagrunert/indextree",
"commit": "b9c8ff11f5d0888066986e1df9531354ef824e5e",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.6213840285,
"test_branches": 4,
"test_count": 1205
} | [
"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/... | saschagrunert--indextree.b9c8ff1 |
programgym/sashabaranov--pike.e403533 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sashabaranov/pike | [
"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": "sashabaranov__pike.e403533",
"repository": "sashabaranov/pike",
"commit": "e4035331bdeecc106c69f418be3e323b0822413c",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.339252634,
"test_branches": 4,
"test_count": 246
} | [
"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... | sashabaranov--pike.e403533 |
programgym/savant117--avbd-demo2d.74699a1 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for savant117/avbd-demo2d | [
"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": "savant117__avbd-demo2d.74699a1",
"repository": "savant117/avbd-demo2d",
"commit": "74699a11f8586d3ac34474c92b1ef8feb5f587de",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.6956567598999999,
"test_branches": 3,
"test_count": 204
} | [
"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... | savant117--avbd-demo2d.74699a1 |
programgym/sballin--alfred-search-notes-app.959049b | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sballin/alfred-search-notes-app | [
"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": "sballin__alfred-search-notes-app.959049b",
"repository": "sballin/alfred-search-notes-app",
"commit": "959049bf0525c8bf62cd4eb02cc189ccf66c88e4",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.8337843747,
"test_branches": 3,
"test_count": 243
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/programgym-go.tar.gz",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_01.tar.gz",
"tests/blobs/tests/generated_... | sballin--alfred-search-notes-app.959049b |
programgym/sbeamer--gapbs.b5e3e19 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sbeamer/gapbs | [
"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": "sbeamer__gapbs.b5e3e19",
"repository": "sbeamer/gapbs",
"commit": "b5e3e19c2845f22fb338f4a4bc4b1ccee861d026",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.57863921,
"test_branches": 5,
"test_count": 397
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests... | sbeamer--gapbs.b5e3e19 |
programgym/scanberg--viamd.34a21b6 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for scanberg/viamd | [
"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": "scanberg__viamd.34a21b6",
"repository": "scanberg/viamd",
"commit": "34a21b6c40914bde9a0a82dfbe5d0eb49b398ecc",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 3.4766055859,
"test_branches": 4,
"test_count": 42
} | [
"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... | scanberg--viamd.34a21b6 |
programgym/scarvalhojr--aoc-cli.ebb1069 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for scarvalhojr/aoc-cli | [
"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": "scarvalhojr__aoc-cli.ebb1069",
"repository": "scarvalhojr/aoc-cli",
"commit": "ebb1069b2946320c76ed676cf26f0a287d4f64fd",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.8997110946,
"test_branches": 3,
"test_count": 616
} | [
"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/... | scarvalhojr--aoc-cli.ebb1069 |
programgym/scc-tw--vmpilot.4f9d182 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for scc-tw/VMPilot | [
"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": "scc-tw__VMPilot.4f9d182",
"repository": "scc-tw/VMPilot",
"commit": "4f9d182b1053a06a26741b1b8a01a59bc8a0f8b4",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 2.4434038169,
"test_branches": 5,
"test_count": 686
} | [
"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... | scc-tw--vmpilot.4f9d182 |
programgym/schizofreny--middle-out.0bbe73b | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for schizofreny/middle-out | [
"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": "schizofreny__middle-out.0bbe73b",
"repository": "schizofreny/middle-out",
"commit": "0bbe73b5375b652ab3f355a2aa903b0e506979ac",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.2195845262,
"test_branches": 4,
"test_count": 650
} | [
"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... | schizofreny--middle-out.0bbe73b |
programgym/schollz--closestmatch.1fbe626 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for schollz/closestmatch | [
"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": "schollz__closestmatch.1fbe626",
"repository": "schollz/closestmatch",
"commit": "1fbe626be92eb4c347d182cae9f8f00a046bf2f4",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.9484129658,
"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_... | schollz--closestmatch.1fbe626 |
programgym/schollz--peerdiscovery.e0ee252 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for schollz/peerdiscovery | [
"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": "schollz__peerdiscovery.e0ee252",
"repository": "schollz/peerdiscovery",
"commit": "e0ee252378e1b36c6e9a70727043141556fc0d99",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.2523675145,
"test_branches": 4,
"test_count": 34
} | [
"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... | schollz--peerdiscovery.e0ee252 |
programgym/schwehr--libais.02a801a | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for schwehr/libais | [
"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": "schwehr__libais.02a801a",
"repository": "schwehr/libais",
"commit": "02a801a6386c6a8587fb9bcf13306372ffac448f",
"language": "cpp",
"difficulty": "medium",
"difficulty_score": 2.8148001037,
"test_branches": 5,
"test_count": 123
} | [
"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... | schwehr--libais.02a801a |
programgym/scipipe--scipipe.4d29035 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for scipipe/scipipe | [
"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": "scipipe__scipipe.4d29035",
"repository": "scipipe/scipipe",
"commit": "4d29035e8538d7d5362227eff037a1dd22d1e186",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.7764105888000001,
"test_branches": 3,
"test_count": 178
} | [
"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_... | scipipe--scipipe.4d29035 |
programgym/sciplot--sciplot.75d813a | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sciplot/sciplot | [
"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": "sciplot__sciplot.75d813a",
"repository": "sciplot/sciplot",
"commit": "75d813a362e5ef4a43e671ca84517748060f3b25",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.5223137952,
"test_branches": 5,
"test_count": 386
} | [
"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... | sciplot--sciplot.75d813a |
programgym/scutclient--scutclient.8c81f5d | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for scutclient/scutclient | [
"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": "scutclient__scutclient.8c81f5d",
"repository": "scutclient/scutclient",
"commit": "8c81f5d8968420e9dc13181a5f9295d2de10b14a",
"language": "c",
"difficulty": "easy",
"difficulty_score": 1.3121773563999999,
"test_branches": 4,
"test_count": 765
} | [
"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/... | scutclient--scutclient.8c81f5d |
programgym/segmentio--asm.1cfacc8 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for segmentio/asm | [
"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": "segmentio__asm.1cfacc8",
"repository": "segmentio/asm",
"commit": "1cfacc81a878d4a07b13f51f2368cd86893d23fa",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.7339992865,
"test_branches": 4,
"test_count": 422
} | [
"environment/Dockerfile",
"environment/docker-compose.yaml",
"environment/download.sh",
"environment/executable",
"environment/harbor_configure_apt_mirror.sh",
"environment/harbor_configure_java_mirrors.sh",
"environment/harbor_prepare_download_env.sh",
"environment/programgym-go.tar.gz",
"environme... | segmentio--asm.1cfacc8 |
programgym/sentriz--cliphist.25cc3e4 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sentriz/cliphist | [
"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": "sentriz__cliphist.25cc3e4",
"repository": "sentriz/cliphist",
"commit": "25cc3e4affb6d24398cbcb2f42d8e8cf9cf62823",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.6559064182,
"test_branches": 2,
"test_count": 188
} | [
"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_... | sentriz--cliphist.25cc3e4 |
programgym/sepehrdaddev--xerxes.d4c4c92 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sepehrdaddev/Xerxes | [
"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": "sepehrdaddev__Xerxes.d4c4c92",
"repository": "sepehrdaddev/Xerxes",
"commit": "d4c4c927f04cd7901f4c4f8195f84dfa5872bb6d",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.782544284,
"test_branches": 3,
"test_count": 263
} | [
"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... | sepehrdaddev--xerxes.d4c4c92 |
programgym/serge1--elfio.1dd5b4c | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for serge1/ELFIO | [
"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": "serge1__ELFIO.1dd5b4c",
"repository": "serge1/ELFIO",
"commit": "1dd5b4c94dc5a1814b02d8ca95438d823b202aba",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.9686697017,
"test_branches": 4,
"test_count": 615
} | [
"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... | serge1--elfio.1dd5b4c |
programgym/sergiusthebest--plog.2ab53dc | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for SergiusTheBest/plog | [
"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": "SergiusTheBest__plog.2ab53dc",
"repository": "SergiusTheBest/plog",
"commit": "2ab53dc768507fae46a30426e82e8018d093416b",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.6845760874,
"test_branches": 5,
"test_count": 738
} | [
"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... | sergiusthebest--plog.2ab53dc |
programgym/serhack--pdf-diff.e4277cb | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for serhack/pdf-diff | [
"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": "serhack__pdf-diff.e4277cb",
"repository": "serhack/pdf-diff",
"commit": "e4277cb22337157d7aa078f5b1957df95fefac5e",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.40140054080000004,
"test_branches": 1,
"test_count": 59
} | [
"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... | serhack--pdf-diff.e4277cb |
programgym/seriousm4x--upsnap.8f52541 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for seriousm4x/UpSnap | [
"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": "seriousm4x__UpSnap.8f52541",
"repository": "seriousm4x/UpSnap",
"commit": "8f52541fe7d06939342c3dd848f4e3dd5da751a0",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.660865478,
"test_branches": 4,
"test_count": 186
} | [
"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... | seriousm4x--upsnap.8f52541 |
programgym/seungheonoh--pot.f6e7208 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for SeungheonOh/pot | [
"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": "SeungheonOh__pot.f6e7208",
"repository": "SeungheonOh/pot",
"commit": "f6e72083081c74a0a573b79574e4137afeb74996",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.3982873054,
"test_branches": 4,
"test_count": 189
} | [
"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... | seungheonoh--pot.f6e7208 |
programgym/sgeisler--cargo-remote.a768024 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sgeisler/cargo-remote | [
"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": "sgeisler__cargo-remote.a768024",
"repository": "sgeisler/cargo-remote",
"commit": "a7680240a11795a1b3f554e9d4fcdd6a6d201fc2",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.4724638966,
"test_branches": 2,
"test_count": 188
} | [
"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/... | sgeisler--cargo-remote.a768024 |
programgym/sgreben--http-file-server.76dab1e | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sgreben/http-file-server | [
"programgym",
"synthetic",
"reverse-engineering",
"cleanroom",
"go"
] | 1.3 | {
"schema_version": "1.3",
"source": "ProgramGym",
"artifacts": [
"/logs/verifier/programgym_eval.json",
"/logs/verifier/harbor_diagnostics.json",
"/logs/verifier/programgym_eval.log",
"/logs/verifier/reward.json",
"/logs/verifier/reward.txt",
{
"source": "/workspace",
"exclude... | {
"source": "ProgramGym",
"instance_id": "sgreben__http-file-server.76dab1e",
"repository": "sgreben/http-file-server",
"commit": "76dab1e045b6cf520d744cb5e408c7e74e515f8e",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.7817553747,
"test_branches": 4,
"test_count": 206
} | [
"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_... | sgreben--http-file-server.76dab1e |
programgym/sgreben--jp.5e551d1 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sgreben/jp | [
"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": "sgreben__jp.5e551d1",
"repository": "sgreben/jp",
"commit": "5e551d10fba930729382096bdf0034901b0b7fe3",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.4989993636,
"test_branches": 4,
"test_count": 359
} | [
"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_... | sgreben--jp.5e551d1 |
programgym/shabarkin--aws-enumerator.4f2a983 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for shabarkin/aws-enumerator | [
"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": "shabarkin__aws-enumerator.4f2a983",
"repository": "shabarkin/aws-enumerator",
"commit": "4f2a98387b02fb03f3bf84ac0d82faf0d299f29b",
"language": "go",
"difficulty": "medium",
"difficulty_score": 3.3491026086,
"test_branches": 5,
"test_count": 407
} | [
"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... | shabarkin--aws-enumerator.4f2a983 |
programgym/shanghai-edu--multissh.3f32c3a | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for shanghai-edu/multissh | [
"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": "shanghai-edu__multissh.3f32c3a",
"repository": "shanghai-edu/multissh",
"commit": "3f32c3a325f17c7c8b79f984eab54e4cd8cbec17",
"language": "go",
"difficulty": "easy",
"difficulty_score": 1.2992893341,
"test_branches": 4,
"test_count": 203
} | [
"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... | shanghai-edu--multissh.3f32c3a |
programgym/shangjingbo1226--autophrase.62f7548 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for shangjingbo1226/AutoPhrase | [
"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": "shangjingbo1226__AutoPhrase.62f7548",
"repository": "shangjingbo1226/AutoPhrase",
"commit": "62f7548e477e3ab09a247b7f3e465df7abc0d35b",
"language": "cpp",
"difficulty": "easy",
"difficulty_score": 1.6734816971000002,
"test_branches": 4,
"test_count": 351
} | [
"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... | shangjingbo1226--autophrase.62f7548 |
programgym/sharkdp--diskus.90196e9 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sharkdp/diskus | [
"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": "sharkdp__diskus.90196e9",
"repository": "sharkdp/diskus",
"commit": "90196e950017d25b2940e8e0fda51a321ca66e1a",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.4502491083,
"test_branches": 5,
"test_count": 804
} | [
"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/... | sharkdp--diskus.90196e9 |
programgym/sharkdp--vivid.165bbbb | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for sharkdp/vivid | [
"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": "sharkdp__vivid.165bbbb",
"repository": "sharkdp/vivid",
"commit": "165bbbbe9613e4a8b2dad781c8ff1e34fd052d0d",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.8093576702,
"test_branches": 5,
"test_count": 652
} | [
"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/... | sharkdp--vivid.165bbbb |
programgym/shellwen--v8_killer.ceff389 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for ShellWen/v8_killer | [
"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": "ShellWen__v8_killer.ceff389",
"repository": "ShellWen/v8_killer",
"commit": "ceff3894dff0b21945a6a3072a73b4021fa9f017",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.033825694,
"test_branches": 4,
"test_count": 342
} | [
"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/... | shellwen--v8_killer.ceff389 |
programgym/shemnei--punktf.306efa5 | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for Shemnei/punktf | [
"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": "Shemnei__punktf.306efa5",
"repository": "Shemnei/punktf",
"commit": "306efa5a0c2eb901f57cef49f62e4aee6cc42ee9",
"language": "rust",
"difficulty": "easy",
"difficulty_score": 1.9443839576,
"test_branches": 3,
"test_count": 421
} | [
"environment/Dockerfile",
"environment/download.sh",
"environment/executable",
"environment/harbor_prepare_download_env.sh",
"environment/workspace.tar.gz",
"instruction.md",
"solution/solve.sh",
"task.toml",
"tests/Dockerfile",
"tests/blobs/tests/generated_module_02.tar.gz",
"tests/blobs/tests/... | shemnei--punktf.306efa5 |
programgym/shiena--ansicolor.a9deabd | You are a helpful assistant that can interact with a computer.
This is a reverse-engineering benchmark. You are given a compiled binary and its documentation.
Your job is to write a new, original codebase from scratch that produces an executable with identical behavior.
You must figure out the behavior solely by runni... | Synthetic ProgramGym cleanroom reconstruction task for shiena/ansicolor | [
"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": "shiena__ansicolor.a9deabd",
"repository": "shiena/ansicolor",
"commit": "a9deabde6e02631323eccc1f623994c354f8211b",
"language": "go",
"difficulty": "easy",
"difficulty_score": 0.7041505168000001,
"test_branches": 3,
"test_count": 214
} | [
"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... | shiena--ansicolor.a9deabd |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.