Datasets:

bunnycore
/

code-reasoning-distillation

---
license: cc-by-4.0
language:
- en
task_categories:
- text-generation
tags:
- code
- distillation
- synthetic
- reasoning
- sft
size_categories:
- n<1K
configs:
- config_name: default
  data_files:
  - split: train
    path: code-reasoning-distillation.parquet
---

# code-reasoning-distillation

178 SFT / distillation coding samples for small language models, in one train split:

- 150 single-turn (user → assistant) reasoning-focused coding samples
- 28 multi-turn (user ↔ assistant × 2) browser-game samples

Every assistant reply starts with a `<think>` block that derives the solution from first
principles (zero-knowledge style, no template phases), followed by a concise explanation
and a complete, runnable program.

## Format

Single Parquet file (`code-reasoning-distillation.parquet`, zstd compression), one row per sample,
schema:

```
messages: list<struct<role: string, content: string>>
```

Each `messages` is `[user, assistant]` for the 150 single-turn samples and
`[user, assistant, user, assistant]` for the 28 multi-turn games. Single-turn rows: the
user turn is a coding task/brief and the assistant turn is one complete program. Multi-turn
rows: the first pair builds a complete browser game, the second pair adds a feature or
fixes a bug and returns the full updated file.

```
<think>
We need ... Let's figure out ... (first-person derivation, no section headers)
... state transitions written with real values, e.g. dq: [] -> [0] ...
... at least two explicit "if I had done X instead, here is the wrong result" fixes ...
</think>

<2-4 sentence explanation>

<complete runnable code in one fenced block>
```

### Think-block style (zero-knowledge derivation)

The think block is written as if the author has no memorized solution and derives
everything from the problem statement:

- First person, exploratory voice ("Let's figure out...", "Wait - ..."). No numbered
  phases, no headings, no fixed DECONSTRUCTION / ARCHITECTURE template.
- Every constant, coordinate, index, and boundary is derived from literal arithmetic on
  the concrete demo input, not asserted.
- Loop boundaries and off-by-one cases are tested with real numbers (first iteration,
  last iteration, empty input).
- State changes are spelled out as `before -> after` with actual values; each block
  contains at least six such transitions.
- At least two explicit wrong-behaviour corrections: what a plausible wrong
  implementation would return, and why that is wrong.
- Every variable, function, and DOM id mentioned is defined in the code that follows.
- 350-550 words, plain ASCII.

## Games: 28 multi-turn game samples

Every row in the `games` slice is a four-message conversation that builds a playable
browser game and then extends or repairs it:

```
user      -> build brief for a single-file HTML/CSS/JS game
assistant -> think block + explanation + complete game file
user      -> one feature request or bug report
assistant -> think block + explanation + complete updated game file
```

| Slice | Games |
|---|---|
| Retro action | snake, tetris, pong, breakout, space-invaders, asteroids |
| Arcade | flappy-bird, doodle-jump, frogger, pac-man-lite, bomberman-lite |
| Board | chess, checkers, connect-four-ai, tic-tac-toe-ai |
| Puzzle/logic | sudoku, 2048, minesweeper, memory-match, lights-out, sokoban |
| Misc | blackjack, simon, whack-a-mole, tower-defense-lite |
| 3D / simulation | maze-escape-3d (ray caster), solar-system-3d (software projection), stack-3d (orthographic projection) |

All games are vanilla, single-file, dependency-free, and expose a small `window.__game` debug
API (`state()`, `start()`, `reset()`, `tick(ms)`, plus game actions) so the core rules can be
exercised without a browser driver. Every game was loaded in Chromium with zero console
errors and smoke-tested through the debug API (input, ticks, scoring, lives, persistence).
Think blocks follow the same zero-knowledge style as the single-turn samples.

## Composition

| Slice | Count | Language | Delivery |
|---|---|---|---|
| Games | 53 | HTML/JS + 3D/canvas | 25 single-turn games + 28 multi-turn browser games |
| Apps | 50 | HTML/JS (single file, vanilla) | timers, calculators, converters, localStorage tools |
| Interactive tools/viz | 25 | HTML/JS + Canvas + Web Audio | sort/pathfinding visualizers, Web Audio synths |
| Algorithms | 50 | Python 3 (stdlib only) | DP, parsing, graphs, heaps, with `if __name__ == "__main__"` demos |

No external libraries, fonts, images, CDNs, or assets anywhere in the samples.
`localStorage` access is wrapped in `try/catch`; `preventDefault` on game keys.

## Loading

```python
from datasets import load_dataset

ds = load_dataset("bunnycore/code-reasoning-distillation", split="train")
print(ds)          # Dataset({features: ['messages'], num_rows: 178})
print(ds[0]["messages"][0]["content"][:200])
```

Rows with exactly 2 messages are the single-turn coding tasks; rows with exactly 4 are the
multi-turn browser games. Filter with `ds.filter(lambda r: len(r["messages"]) == 4)`.

Or directly:

```python
import pandas as pd
df = pd.read_parquet("code-reasoning-distillation.parquet")
```

## Verification performed

Every row was machine-checked before upload:

- `<think>…</think>` tags present; exactly one fenced code block per assistant turn;
  no `TODO`/`FIXME` markers in code.
- HTML entries: all `<script>` blocks pass `node --check`; every
  `getElementById('x')` resolves to an `id="x"` in the same entry's markup.
- Python entries: code blocks pass `ast.parse`; every embedded
  `if __name__ == "__main__":` demo **executes** and prints the annotated expected output.
- No duplicate topics or duplicate user prompts; think blocks 350-550 words with at
  least six `->` transitions each.

## Honest limitations

- **Not human-reviewed.** These are machine-generated and machine-checked samples.
  The 28 browser games were smoke-tested in Chromium through a `window.__game` debug
  API; the other 150 entries have no browser testing — canvas/audio behavior there is
  traced, not observed.
- Two near-duplicate mechanics (`stroop-test`, `color-reaction`) slipped through review.
- Small sample (n=178) — a seed set to iterate on, not a training-ready corpus.
  Expect several percent of entries to need manual repair before training.
- Assistant code follows the stated constraints (single file, stdlib-only) and encodes
  one reference style; style diversity is low by construction.

## License

CC-BY-4.0.