sjkim1127/decbench-multilang-corpus

DecBench Multilang Corpus

Raw upstream-only acquisition. Primary program code comes from actual open-source repositories at fixed commits. Dataset-authored sample programs and collector-written program wrappers/harnesses are prohibited. C, C++, Rust, Go, Zig, Swift, Fortran, D and Nim now have bounded raw compiled-product collections. Original sources, licenses, toolchains/options, binaries and debug/build evidence are retained; metric/function qualification remains false.

The following section describes the original C/C++ pilot.

Initial C/C++ pilot

That pilot contains C and C++ only; later campaigns cover all nine listed languages.

Two real upstream projects (cJSON and pugixml), four optimization profiles each, two clean builds per profile. Artifacts are shared libraries built directly from one translation unit per project, not complete upstream project builds. Linux x86-64 ELF / System V AMD64 ABI only. Compiler/OS/tool versions, flags, driver verbose logs, source licenses and raw ELF/DWARF are in each manifest/shard. See builds.jsonl or the builds Parquet configuration for all records.

Access

Read metadata using load_dataset("sjkim1127/decbench-multilang-corpus", "builds", split="raw"). Payload member paths and SHA-256 values are in artifact-index.jsonl. Fetch tar shards using hf_hub_download(..., repo_type="dataset"). Both replay attempts are retained. Source archives retain upstream license files.

Qualification and limitations

All records have qualified=false and no metric readiness. No generated program was executed. No semantic test scores, normalized function mappings or machine CFGs are claimed. Raw DWARF is evidence, not a validated function-level oracle. All driver arguments are captured; GCC verbose output preserves child-command evidence, but an execve trace and normalized child argv table are not collected. CPU/ABI/OS declarations are build provenance, not proof of minimum runtime compatibility. No train/test split is assigned; repository-family grouping is retained for later deduplication and split assignment.

Licenses

Each upstream source and derived artifact retains its own project license. The initial cJSON/pugixml pilot uses MIT licenses; later campaigns include MIT, BSD, zlib and other reviewed upstream licenses. Exact notices are kept with source snapshots. There is no blanket relicensing of the corpus.

Source-backed obfuscation pilot

Go tomlv has three source-backed clean/garble pairs: Linux x86-64, Windows x86-64, macOS ARM64. All six final builds succeeded. Original and transformed sources, fixed seed, Go 1.25.5, garble v0.15.0 tool identities and compiler logs are retained in obfuscated/go-garble-2026-10-23/. No semantic execution, replay reproducibility or source/function mapping qualification is claimed.

Rust full CLI collection

Raw ripgrep and hyperfine Linux ARM64 CLI builds retain fixed source commits, Cargo.lock, vendored dependency source/licenses, exact Rust 1.99.1 Docker identity, full build logs and split debug artifacts. Compilation is offline; Cargo build scripts and procedural macro tools execute inside the limited container, while final corpus CLIs are never run. Opt0/opt2 each have two independent attempts. This is raw collection, without function mapping or semantic validation. Earlier collector configuration failures are retained in the campaign history. See rust/cli-batch1-2026-10-23/summary.json.

Native cross-platform campaigns

The initial C/C++ Linux pilot above is supplemented by native raw attempts. Use config native_attempts; replay attempts are separate rows, not extra distinct builds. See native/platforms-batch2-2026-10-23/summary.json for actual collected OS/format/architecture counts. Source snapshots retain per-file upstream licenses (MIT, BSD, zlib and other original notices). Source discovery candidates and obfuscation policy are not built obfuscated artifacts. All native records remain unqualified; PE/PDB links are raw evidence and dSYM UUIDs are checked.

Coverage targets and continued raw acquisition

The target policy is Linux/ELF 40%, Windows/PE 35%, macOS/Mach-O 25%. Across the first two hosted C/C++ campaigns, 180 successful distinct variants have a 40%/33.3%/26.7% OS mix. Replays are not extra variants. The second campaign attempted 108 variants (216 attempts): 96 variants succeeded and 12 failed. All 24 failed MSVC attempts for btree/SDS retain their original diagnostics. Filter status == "success" when selecting actual binaries.

The continued batch adds six C/C++ source projects plus full ripgrep/hyperfine Rust CLI builds: 100 new successful variants and 200 successful attempts. Rust's four variants had identical unstripped, stripped and debug hashes across fresh offline build workspaces. Earlier collector configuration failures are retained separately in Rust history. This remains raw source/binary acquisition; qualification flags are false. No benchmark eligibility, semantic scoring or validated function mapping is asserted. Standard-library source coverage remains partial even where application/dependency source is bundled.

New paths: native/platforms-batch2-2026-10-23/ and rust/cli-batch1-2026-10-23/.

Verified original upstream language products

The upstream_languages config adds original Mint (Swift), ZLS (Zig), JSON-Fortran, DustMite (D), and Nimble (Nim) products. Every primary product has a reviewed GitHub repository, fixed full commit, original source archive and license hash, and byte checks that tracked program sources remained unchanged. Dataset-authored programs, collector-created entrypoint wrappers and harnesses are excluded. Compiler/upstream generated intermediate files are derived evidence only. See opensource/languages-batch1-2026-10-23/summary.json and per-language configs/*/manifest.json for actual collected counts and file indexes. Original-source archives, frozen dependencies, binaries and debug artifacts are preserved. All records remain raw/unqualified, without benchmark scores or validated function mappings. Earlier acquisition and debug-derivation failures remain history. The user-provided noelo-lab dataset was inspected as a packaging reference; its scores and corpus were not copied.

Architecture and language views

Choose all_records, an architecture config (architecture_aarch64, architecture_armv7, architecture_riscv64, architecture_x86, architecture_x86_64), or a language_ config (c, cpp, rust, go, zig, swift, fortran, d, nim). Every config uses split raw. For example: load_dataset("sjkim1127/decbench-multilang-corpus", "architecture_aarch64", split="raw"). Filter columns language, arch, isa_mode, os, format, abi, profile, build_scope, status, compiler_family, compiler_version, compiler_target, linker_family to select intersections. aarch64 is the canonical ARM64 spelling.

These views reference existing payloads without duplicating binaries. Original metadata is pinned to dataset revision 9b1c68bd308ccf9473a069a446e77b04a92c6383. Use source_dataset_revision when downloading payload_repo_path and artifact_index_repo_path; tar member hashes are in that artifact index. Full compiler/options/environment evidence remains in manifest_json and original_metadata_json. Missing tool, ABI, or triple values remain null; compiler/linker columns only report evidence actually captured. project_id and revision_id group the same repository/revision; family_id remains unreviewed/null because forks and related projects are not yet mapped. No train/test split has been assigned.

Rows preserve original granularity: initial pilot rows contain two replays; other rows are individual attempts. Read row_grain, attempt, and physical_attempt_count; row totals are neither unique binaries nor functions. Failed build attempts stay visible; filter status == "success" for available products. All records remain raw/unqualified. See views/summary.json for counts and views/README.md for download/filter examples. Views are a frozen snapshot and must be regenerated when new campaigns are published.

ARMv7 and RISC-V64 raw campaign

Six pinned upstream C/C++ projects were compiled for ARMv7 ARM and Thumb modes and RISC-V64 with GCC and Clang. O0/O1/O2/O3/Os/Oz, O2-noinline, O2-LTO and Clang O2-ThinLTO are retained; inspect the campaign summary for actual counts. Each attempt includes original/stripped ELF, external debug, raw execve traces, normalized observed child argv, flags, toolchain/image identity and logs. GNU debuglink CRC and stripped .text equality are checked; none proves semantics. See native/cross-isa-2026-10-28/summary.json. Its qualification pilot contains source/DWARF/symbol candidates with zero qualified functions. When present, config qualification_candidates_cjson exposes the 113 unqualified pilot rows.

Windows PE and PDB verification

For 396 MSVC/clang-cl build attempts, original PE CodeView GUID/age matches the corresponding PDB. The .text bytes within each PE's declared virtual size match its llvm-objcopy --strip-debug copy; 394 raw section byte ranges differ in padding. All 396 stripped copies retain CodeView metadata and are not fully stripped. These checks do not validate other sections or source/function mapping. See evidence/windows-pdb-2026-10-28/ for per-binary hashes and results. The windows_pdb_evidence config exposes those records as a raw Parquet dataset; the original evidence JSONL is preserved at the path above.