---
license: other
license_name: open-data-attribution-training-disclosure-license-odatl-1.0
license_link: LICENSE
language:
- en
tags:
- benchmark
- bench
- corpus
- coding
- code
- english
---

# Coding-Corpus-Bench

A benchmark dataset for evaluating language-semantics reasoning across systems programming and low-level programming languages.

## Overview

**Coding-Corpus-Bench** contains 100 curated programming-language questions designed to test whether a model can reason precisely about language semantics rather than rely on superficial pattern matching or observed behavior.

The benchmark covers:

* Rust
* Go
* C
* C++
* Zig
* V
* CUDA

Questions focus on subtle semantic rules including ownership, lifetimes, type systems, overload resolution, memory models, evaluation order, synchronization, representation validity, and compiler behavior under explicitly stated language/toolchain versions.

Each example provides both a question and a rubric describing the reasoning and conclusion expected from a high-quality answer.

## Dataset Statistics

| Language  | Examples |
| --------- | -------: |
| Rust      |       15 |
| Go        |       15 |
| C         |       14 |
| C++       |       14 |
| Zig       |       14 |
| V         |       14 |
| CUDA      |       14 |
| **Total** |  **100** |

## Dataset Format

The dataset is provided as **JSONL**. Each line represents one benchmark item.

```json
{
  "id_aa": "rust_001",
  "title": "GAT higher-ranked implied static",
  "category": "Rust",
  "prompt": "...",
  "system_prompt": "...",
  "rubric": "...",
  "expected_deliverables": "",
  "reference_files": ""
}
```

### Fields

| Field                   | Description                                                                                            |
| ----------------------- | ------------------------------------------------------------------------------------------------------ |
| `id_aa`                 | Unique identifier for the benchmark item.                                                              |
| `title`                 | Short description of the semantic issue being tested.                                                  |
| `category`              | Programming language or platform category.                                                             |
| `prompt`                | The question presented to the model, often including a code fragment and explicit version assumptions. |
| `system_prompt`         | Task-specific instruction describing the required reasoning perspective.                               |
| `rubric`                | Evaluation criteria for judging the answer.                                                            |
| `expected_deliverables` | Reserved field for expected deliverables; currently empty for all examples.                            |
| `reference_files`       | Reserved field for supporting references; currently empty for all examples.                            |

## What the Benchmark Tests

The corpus emphasizes questions where a superficially plausible answer can be wrong without precise knowledge of the language specification.

### Rust

Examples cover topics such as:

* Generic associated types and higher-ranked trait bounds
* Lifetime inference and implied `'static` requirements
* Drop timing
* Wildcard patterns
* Method-call receiver adjustment and autoref
* Closure capture and closure traits
* Two-phase borrows
* Trait coherence
* `ManuallyDrop`
* Type validity and undefined behavior
* Trait-object method dispatch
* `Self: Sized` and dyn compatibility
* Non-lexical lifetimes
* Borrowing through `ref` patterns
* Compile-time evaluation
* Trait bounds

### Go

Examples test areas including:

* `select` operand evaluation
* Typed nil values inside interfaces
* Slice range semantics
* Generic type sets
* Named return values and `defer`
* Channel synchronization and happens-before
* Method sets
* Buffered-channel synchronization
* Deferred argument evaluation
* Slice capacity
* Approximation elements such as `~int`
* Closed-channel receive semantics
* Untyped constants and representability

### C

Examples address ISO C semantics such as:

* Object representation and byte size
* `CHAR_BIT`
* Relational comparison of pointers
* Integer promotions
* Unsigned arithmetic
* Pointer representation and object-pointer sizes

### C++

Examples cover:

* Mutable lambda captures
* Guaranteed copy elision
* Deleted copy constructors
* Overload resolution
* Character literal types

### Zig

Examples cover:

* Bit size versus ABI size
* Pointer constness coercion
* Typed shifts
* Tagged-union active-field rules

### V

Examples cover:

* String byte length
* Mutability of struct fields and bindings
* Array slicing
* `if` expressions

### CUDA

Examples cover:

* Warp shuffle operations
* Memory fences versus execution synchronization
* Kernel launch cardinality
* Block-level versus grid-level barriers

## Version-Specific Reasoning

Questions explicitly state the relevant language or toolchain version where the answer depends on version-specific semantics.

Examples include:

* **Rust 1.85.0, edition 2021**
* **Go 1.23**
* **ISO C17**
* **ISO C++20**
* **Zig 0.13.0**
* **V 0.4.10**
* **CUDA 12.x**

Evaluations should therefore be performed against the assumptions stated in each individual item rather than against an unspecified "latest" language version.

## Evaluation

The `rubric` field contains the expected evaluation criteria.

Rubrics generally distinguish between:

1. **The final conclusion** — whether code compiles, what it prints, whether behavior is defined, etc.
2. **The decisive reasoning** — whether the answer identifies the particular language rule responsible for that conclusion.

For example, a benchmark item may require both:

* the exact output; and
* an explanation of why evaluation order, borrowing, synchronization, or destructor timing produces that output.

This makes the dataset suitable for evaluating **reasoning quality**, not merely final-answer accuracy.

### Example

A Rust item concerning a reborrow expects the answer to recognize that the program compiles because the reborrow's lifetime ends at its last use under non-lexical lifetimes, rather than incorrectly rejecting the program merely because two mutable references appear in the same scope.

## Intended Uses

The dataset can be used for:

* Evaluating LLM coding and reasoning models
* Testing language-semantics competence
* Comparing models across programming languages
* Building automated benchmark/evaluation pipelines
* Studying hallucination and specification-reasoning errors
* Evaluating whether models provide decisive explanations rather than unsupported conclusions

## Recommended Evaluation Protocol

For each item:

1. Provide the `prompt` to the model under the assumptions stated in the prompt.
2. Preserve the relevant language/toolchain version.
3. Evaluate the response against the associated `rubric`.
4. Score the requested conclusion separately from the supporting reasoning where the rubric provides separate criteria.
5. Do not award correctness merely because a model happens to give the expected output without explaining the semantic rule when the rubric explicitly requires that explanation.

## Data Integrity

The supplied corpus contains:

* **100** benchmark items
* **7** language/platform categories
* An empty `expected_deliverables` field for every item
* An empty `reference_files` field for every item

The benchmark is therefore self-contained at the example/rubric level; no external reference files are specified by the dataset entries themselves.

## License

Open Data Attribution Training Disclosure License (ODATL‑1.0)