---
language:
- en
pretty_name: One Layer Deeper submissions
size_categories:
- 10K<n<100K
tags:
- code
- competition
- neural-networks
- modular-arithmetic
configs:
- config_name: default
  data_files:
  - split: easy
    path: data/easy.parquet
  - split: medium
    path: data/medium.parquet
  - split: hard
    path: data/hard.parquet
---

# One Layer Deeper submissions

This dataset archives **15,602 accepted uploads from 206 GitHub accounts** to the [One Layer Deeper competition](https://onelayerdeeper.ai/). It contains **9,627 distinct source files**, all upload metadata, and stored evaluation results. Snapshot: **September 7, 2026, 21:48 UTC**, after the August 31 submission deadline.

| Split | Uploads | Succeeded | Failed |
|---|---:|---:|---:|
| easy | 11,961 | 11,112 | 849 |
| medium | 2,704 | 2,509 | 195 |
| hard | 937 | 847 | 90 |

All accepted uploads are included: practice runs, failures, identical resubmissions, and superseded or excluded entries. “Succeeded” is the evaluator's run status, not a claim of task correctness or rule compliance. GitHub accounts do not necessarily represent distinct people. Rejected requests and local experiments are outside this archive.

## Load the data

This is a **private dataset under GPUMODE**. Access requires an authorized Hugging Face account. Run `hf auth login` first; `datasets` uses that local authentication for the download.

```python
from datasets import load_dataset

hard = load_dataset("GPUMODE/one-layer-deeper-submissions", split="hard")
row = hard[0]
print(row["id"], row["github_login"], row["status"])
print(row["source"][:500])
```

Install the `datasets` package to use this example. Loading reads participant source as text; executing that source is unnecessary for archive analysis.

Each row has these fields:

| Field | Meaning |
|---|---|
| `id` | Accepted submission UUID |
| `tier` | `easy`, `medium`, or `hard` |
| `github_login` | Submitting account label |
| `created_at` | Stored upload timestamp, including UTC offset |
| `status` | Stored evaluator run status |
| `sha256` | SHA-256 of the original UTF-8 source bytes |
| `source_bytes` | Original source length in bytes |
| `leaderboard_rank` | Rank of this exact upload in the archived public leaderboard, or null |
| `source` | Complete original `submission.py` decoded as UTF-8, preserving line endings |
| `metadata_json` | Complete original `metadata.json` file as a UTF-8 string, preserving formatting |
| `result_json` | Complete original `result.json` file as a UTF-8 string, preserving formatting |

A failed run may have JSON `null` in `result_json`; use `json.loads(row["result_json"])` to interpret it. Scores are recorded evaluator outcomes, not independent reproductions. A high score does not establish rule compliance or generalization beyond the recorded tests.

## Original files and integrity

```text
data/{easy,medium,hard}.parquet   One row per accepted upload
archives/{easy,medium,hard}.tar.gz
  submissions/<tier>/<id>/submission.py
  submissions/<tier>/<id>/metadata.json
  submissions/<tier>/<id>/result.json
inventory/manifest.json
inventory/export_summary.json
inventory/statistics.json
inventory/engagement.json
inventory/leaderboard.json
verification.json               Local packaging verification report
checksums.json                  File SHA-256 hashes and sizes
SHA256SUMS                      Checksums of every other packaged file
```

The tar archives preserve all three files byte for byte. Archive order and timestamps are normalized; the files' content bytes are unchanged. Parquet strings also round-trip exactly to the original bytes via UTF-8 encoding, including CRLF line endings and JSON whitespace.

```python
import hashlib
import json

source_bytes = row["source"].encode("utf-8")
assert len(source_bytes) == row["source_bytes"]
assert hashlib.sha256(source_bytes).hexdigest() == row["sha256"]
metadata = json.loads(row["metadata_json"])
result = json.loads(row["result_json"])
```

Packaging verified every Parquet source hash, every metadata/result string against its original bytes, every archive entry against its original file, and exact submission-ID coverage in each split. `checksums.json` maps every substantive file path to its SHA-256 and byte length, excluding the two checksum manifests. `SHA256SUMS` additionally covers `checksums.json`; it does not hash itself. With the repository downloaded locally, run `sha256sum -c SHA256SUMS` (or `shasum -a 256 -c SHA256SUMS` on macOS).

## Provenance and scope

The original export used a read-only, repeatable-read transaction against the organizer database. Every source matched the database's `md5(source)` value, and SHA-256 was saved per upload. The public leaderboard was fetched separately immediately before that transaction. `inventory/export_summary.json` records the snapshot and exclusions; `inventory/manifest.json` retains per-upload provenance.

This release explicitly includes only the submission files, five listed inventory files, and packaging documentation. It does not include dataset inputs, trained checkpoints, raw service logs, metric histories, moderation records, credentials, or email fields. Participant source is retained as submitted. Moderation status is not a row-level classification in this release, and absence from the leaderboard alone does not establish a reason for exclusion.

Participant files retain their existing ownership and terms. **No blanket license or relicensing is asserted for these uploads.** The upstream service's Apache license does not automatically apply to participant submissions.

The packaging script reads code as bytes and text and never imports or executes participant source. Rebuilding with the same inputs and Python/PyArrow versions produces deterministic archive content and packaging metadata; the exact runtime versions are recorded in `verification.json`.