---
license: apache-2.0
pretty_name: "OpenWorld · Coding Worlds (World-Time Compute)"
task_categories:
  - text-generation
  - other
tags:
  - world-models
  - world-time-compute
  - code-generation
  - program-synthesis
  - reproducibility
  - synthetic
size_categories:
  - n<1K
configs:
  - config_name: default
    data_files:
      - split: train
        path: sft_train.jsonl
      - split: test
        path: test_tasks.jsonl
  - config_name: tasks
    data_files: tasks.jsonl
language:
  - en
---

# OpenWorld · Coding Worlds (World-Time Compute)

**A family of **verified coding worlds** — a function to implement plus a test-suite oracle — for the *world-time-compute* realism check: fine-tune on many worlds, generalize to held-out tasks (and HumanEval/MBPP).**

[![Built with OpenWorld](https://img.shields.io/badge/built%20with-OpenWorld-0f766e.svg)](https://github.com/quome-cloud/openworld)
[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-1d4ed8.svg)](https://opensource.org/licenses/Apache-2.0)
[![Paper: World-time compute](https://img.shields.io/badge/paper-world--time%20compute-b45309.svg)](https://github.com/quome-cloud/openworld)
[![Oracle: test suites](https://img.shields.io/badge/oracle-executable%20tests-brightgreen.svg)](#what-it-is)

## Load it

```python
from datasets import load_dataset

ds = load_dataset("Quome/openworld-coding")            # sft train/test
# tasks = load_dataset("Quome/openworld-coding", "tasks")  # all 219 verified tasks
```

---

A family of **verified coding worlds** — function-implementation tasks, each a world whose
**oracle is its test suite** — for the world-time-compute realism check on a *different* use
case than diagnosis (OpenWorld experiment E77; paper §"World-time compute").

## What it is

Each task is a tiny verified-code world: a function to implement (prompt = signature +
docstring) and a set of `assert`-based unit tests that define correctness. A solution is
"right" iff it passes **all** tests — the cleanest possible oracle (this is the
HumanEval/MBPP setup). The transferable skill is *coding*; held-out tasks measure
generalization.

## Provenance

Tasks are **LLM-authored** (Gemini 2.5 Flash) across 12 topics (strings, arrays, dicts,
math, recursion, sorting, parsing, matrices, intervals, stacks/queues, greedy, simple DP),
then **verified in a sandboxed subprocess** — the reference solution must pass its own tests
before the task is admitted (~58% of generated candidates passed verification and were
kept). This contrasts with the synthetic-parametric `openworld-diagnosis` family: here the
worlds are *authored by a model* (the "Claude-Code-style" realism check), and the oracle is
executable tests rather than a Bayes-optimal classifier.

## Contents (JSONL)

| File | Rows | Schema |
|---|---|---|
| `tasks.jsonl` | 219 | `{name, topic, prompt, solution, tests[]}` (all verified) |
| `sft_train.jsonl` | 164 | `{prompt, completion}` — `prompt` = instruction + signature/docstring; `completion` = reference solution |
| `test_tasks.jsonl` | 55 | `{id, prompt, tests[], kind}` — held-out tasks for pass@k |

Task-level (world-level) train/test split: the 55 test tasks are held out from fine-tuning.

## How to use

Fine-tune on `sft_train.jsonl`; evaluate **pass@1 / pass@k** on `test_tasks.jsonl` (run the
model's code against each task's `tests` in a sandbox). For real-benchmark transfer, also
evaluate on **HumanEval / MBPP** (fetched by `experiments/e77_gen.py`'s benchmark step;
adapters in `experiments/e77_eval.py`).

## Reproduce

```
python experiments/e77_gen.py     # author + verify tasks (needs GEMINI_API_KEY in .env)
python experiments/e77_data.py    # split + SFT
```
Generation uses an LLM, so the exact task set is not bit-reproducible (unlike the seeded
diagnosis family); the committed `tasks.jsonl` is the canonical set used in E77.

## Results (E77, paper §world-time compute)

`experiments/results/e77_coding.json`. Headline: world-time compute helps **in-domain
pass@k at every model size** (e.g. 7B pass@5 0.84→0.95) and transfers **positively to
HumanEval at pass@5** (7B 0.866→0.909) from just 164 worlds — though it *hurts* greedy
pass@1 on HumanEval. Consistent with E76's world-count law (more worlds → more gain), 164
is below the threshold where transfer becomes strong.

## License

Apache 2.0 (same as the OpenWorld repository). Tasks/tests are LLM-generated; treated as synthetic.


---

## From the OpenWorld project

This dataset is produced by **OpenWorld** — a framework for *verified symbolic world models*, where a world's dynamics are explicit, auditable Python code (no training, no GPU). "World-time compute" is the idea that **traversing many verified worlds** of a domain and fine-tuning on that experience makes a model generalize to **unseen** worlds from fewer real examples.

- 💻 **Code, experiments & paper:** https://github.com/quome-cloud/openworld

## Citation

```bibtex
@software{openworld_coding_2026,
  title  = {OpenWorld · Coding Worlds (World-Time Compute)},
  author = {Schwoebel, Jim},
  year   = {2026},
  url    = {https://github.com/quome-cloud/openworld},
  note   = {Hugging Face dataset: Quome/openworld-coding}
}
```