pavlichenko/bux-timeline

bux timeline: open data

Every training run of the bux timeline study ("2020 to 2026, one change at a time", docs/tutorials/timeline.md in bux), with its final metrics, its logged curves, the exact .bux that defined it, and the vLLM serving measurements the study's equal-cost targets come from. You can browse it, refit it, and retrain any run with bux, without access to the study's W&B project.

• 1129 runs: 47 .bux files, 206 variants, widths 512 to 1280, trained on NVIDIA B300 GPUs from 2026-10-27 to 2026-10-30.
• 5232 serving lanes: 259 served families and widths, short and long context, bf16 and FP8.
• Built 2026-10-30 against bux main at 03d5031.

Browse the runs online, or open index.html from a download: filter the runs, see a run's curves and its .bux, and compare two runs. It needs no server and fetches nothing.

Download the whole pack, or read one table straight from the Hub:

hf download pavlichenko/bux-timeline --repo-type dataset --local-dir bux-timeline

import pandas as pd

runs = pd.read_parquet("hf://datasets/pavlichenko/bux-timeline/runs.parquet")

Files

Path	What it is
runs.csv, runs.parquet	one row per run: what it is, how it trained, its final metrics, its status in the fit
curves/<bux_id>.parquet	a run's logged history, one row per logged step
configs/<bux_id>/run.bux	the run as one self-contained .bux file, every setting resolved
configs/<bux_id>/run.json	bux json of run.bux: the run's full IR (model, training, data)
configs/<bux_id>/logged-config.json	the config the trainer logged when the run started
configs/<bux_id>/job.json	the job: the sweep file, --only, the statements it added, and the rerun commands
configs/sources/examples/experiments/timeline/	the study's .bux files at 03d5031
serving/lanes.csv, serving/lanes.parquet	every measured vLLM lane, one row each
serving/lanes.jsonl	the same lanes in full: the layers vLLM built, their quantization, the load
serving/targets-measured.json	the equal-cost targets per family at the study's agentic load
serving/targets-measured-longctx.json	the same by context, from 16k to 256k
serving/serving-measured.md, serving/serving-longctx-table.md	the targets as tables, with each family's widths and match
fit/input-final.jsonl, fit/input-lfm2.jsonl	the two refits' inputs, one RESULT line per run, as fit.py reads them
fit/report-final.md, fit/report-lfm2.md	the two refits' reports: the laws, the tables, the predictions at equal serving cost
fit/*.json	the refits' other inputs: the serving targets, each candidate's parent, the measured MFU, and the parameter counts
index.html	a static browser over the runs, their curves and their .bux

The objective

Every run is scored by one number, lower is better:

objective = 0.5 code_bpb + 0.3 repo_bpb + 0.2 web_bpb

Each term is bits per byte on held-out text:

• code_bpb: Stack-Edu code files, 40 batches of 64 rows of 2048 tokens.
• repo_bpb: whole Stack-Edu Python repositories, 16 batches of 8 rows of 16384 tokens. repo_bpb_0, repo_bpb_2k and repo_bpb_8k split it by position: targets 0 to 2047, 2048 to 8191, and 8192 on.
• web_bpb: FineWeb-Edu's held-out last 0.1%.

Evals run every 2000 steps and at the last step. A run's final metrics are its last eval's.

runs.csv

One row per bux id: of several W&B runs with the same id, the pack keeps the finished one, then the one with the most steps, then the newest, as the fit's export does.

Column	What it is
wandb_id	the run's W&B id, an opaque id
bux_id	bux's id of the run: a hash of its resolved settings; names curves/ and configs/
name	family[arm, rung, overrides], as bux names a point of a sweep
family	the .bux file the run comes from, without .bux
arm	the variant within the file (empty for a file with one)
fit_key	the fit's name for the variant: family/arm, or family
rung	the width label: d512, d768, d1024, d1280
d_model	the model's width
budget	the token-scan label (t5 to t80, tokens per parameter); empty is the default t20
seed	the seed of the init and the data order
lr, optimizer	the peak learning rate and the optimizer
steps, step	the steps the run was set to train, and the last step it logged
batch, seq_len	rows per step and tokens per row, before the long-context phase
state	done, or stopped short of steps
status	used, excluded or stopped (see Status and exclusions)
exclusion_reason	why an excluded or stopped run is out of the fit
in_fit_final	in the input of the final refit, the source of the tutorial's tables
in_fit_lfm2	in the input of the refit with the LFM2 arms (lfm2.bux) added
fit_note	a point or seed the fit itself leaves out, and why
params, active_params	all parameters, and those a token goes through
gpus, gpu_type	GPUs the run trained on (its mesh), and their model
created, runtime_s	when the run started (UTC), and its wall time in seconds
bux_file, only, overrides	the sweep file, the job's --only text, and the statements the job added (a JSON list)
file_commit, file_commit_when	the bux commit on main of the run's .bux file: its last change before the run started, or (after start) its first commit after
rerun_file_ok	the file at 03d5031 plus overrides compiles to the run's bux_id
rerun_resolved_ok	run.bux compiles at 03d5031 to the run's bux_id
config_dir	configs/<bux_id>
objective, code_bpb, repo_bpb, web_bpb, repo_bpb_*	the eval metrics above
code_loss, repo_loss, web_loss, repo_loss_*	the same evals' cross-entropy in nats a token
loss	the first head's training cross-entropy at the last logged step
z_loss	the mean log Z² of the head's logits
balance_loss, indexer_loss, prefix_loss	what layers report, summed over layers: MoE balance, sparse-attention indexer, prefix loss
tokens	tokens trained on
tokens_per_s, mfu, time/step_ms, time/compile_s, mem/peak_gib	throughput, model FLOPs utilization, step time, compile time and peak memory per GPU, at the last log

curves/

One file per run, named by bux_id, one row per logged step (every 10 steps), with NaN where a metric wasn't logged at that step:

• Training: loss, lm_loss/t+k and mtp with more than one head, z_loss, balance_loss, grad_norm (before clipping at 1.0), lr, tokens, tokens_per_s, mfu, time/*, mem/*, runtime_s. The fraction of steps clipped isn't logged.
• Evals: the objective, *_bpb and *_loss columns, at each eval step.
• Per layer: act/*, attn/*, grad/norm/*, param/norm/*, update/*, router/*, every 500 steps, named group/what/layer (bux's Observing a run).

A run with more than 2000 logged rows keeps every eval row and every per-layer row and an evenly spaced subset of the rest, 2000 rows in all. Values are float32.

configs/ and rerunning a run

Get bux and the data first:

git clone https://github.com/pilot7747/bux && cd bux && git checkout 03d5031 && uv sync

The runs read data/stack-edu/ and data/fineweb-edu/ under the working directory: step 3 of the "Old against new" tutorial (docs/tutorials/old-vs-new.md) fetches them to those paths, and bux prepare packs them.

Then train the run from its resolved file, which compiles to the run's own id for 1121 of the 1129 runs:

bux train configs/<bux_id>/run.bux 'log.trackers = []'

Or as its job did, from the sweep file, which gives the run's id for 1112 runs:

bux launch examples/experiments/timeline/factorial.bux --only "[r1v1k1f0p0s0, d1280]" \
  'mesh = mesh(data=1, fsdp=4)' 'methods = methods(remat=full, microbatches=3)' \
  'checkpoint = checkpoint(every=1000, keep=1)' 'optimizer.lr = 0.00201' 'log.trackers = []'

job.json holds both commands for its run. 'log.trackers = []' turns off the W&B logging the files set. A run that trained on more than one GPU has its mesh among its statements, as this 4-GPU run does. The runs that no longer compile to their id:

• 8 residuals[mhc, ...] runs (excluded, collapsed init): the mHC layer's init has been fixed since, so both commands train the fixed layer. These runs have no run.json.
• 9 learned-position norms runs (excluded): their sweep file has moved to RoPE. Their run.bux still reproduces them.

Every run joins to its .bux: none is missing a file, a run.bux or a commit.

Refitting

fit/report-final.md is the final refit, the source of the tutorial's tables, and fit/report-lfm2.md the same fit with the LFM2 arms added. Each report opens with its command: run it from bux's root with fit/ pointing at this pack's fit/, and --out at a new directory. The fit takes about 40 minutes on a laptop's CPU; --reps 0 skips the bootstrap.

Status and exclusions

status	Runs	What it means
used	1071	in the fit's input; the fit picks each variant's best learning rate and averages its seeds there
excluded	25	out of the fit, for the reason below
stopped	33	stopped short of its steps (a time limit); its metrics are the last eval before the stop, and the fit skips it

The final refit has 375 points (191 variants at their rungs), each the mean of the runs at its chosen learning rate: 793 runs in all. The other used runs are the learning-rate scans that chose it. The LFM2 refit adds 8 points and 20 runs.

Excluded and stopped runs keep their metrics, curves and configs. The excluded runs:

• learned-position side run (9): norms runs trained with learned positions; the family's runs use RoPE, and the fit takes the RoPE run of the same name.
• gr debug (7): residuals[gr, ...] runs at extra seeds, used to debug the gr residual.
• gr before the fence (1): residuals[gr, d768], trained before the fix for an XLA miscompile of gr.
• collapsed init (bug) (8): residuals/mhc, whose mHC init collapsed.

fit_note marks what the fit leaves out on its own: seeds over 5% above their point's best run (muon_2020 d512 seed 0, zoo/dyt d512 seeds 1 and 2), points worse than fewer tokens (baseline d512 t40 and t80, positions/nope_power d768), and baseline's other token scans, which take their parent's data term. Debug runs of m2025_qwen3next were deleted from W&B before the export and aren't in the pack.

W&B holds 1277 runs in all: these 1129, 21 finished runs superseded by a later run of the same id, 69 finished without an eval, 47 crashed or failed, 2 still running, and 9 analysis runs.

serving/

The study sizes every family to the serving cost of a 2022-style dense model at d_model 4096, measured in vLLM on B300 GPUs at an agentic coding load (docs/tutorials/timeline.md, section 5). A lane is one model, width, quantization and concurrency, timed end to end.

Column of lanes.csv	What it is
lane	the lane's id in this pack: its sweep, its kind and its row
kind, context	short (the agentic load) or long, with its context length in tokens
sweep	the id of the sweep that measured it
family, arm, d_model, tag	the served family (+fp8 for FP8 weights), its arm, its width, and the exported model's tag
quant, kv_cache	the weights' quantization (bf16, fp8, fp8_per_channel, fp8_per_block) and the KV cache's dtype setting
tp, dp, gpus	tensor and data parallelism, and the GPUs of the lane
params, active_params	the served model's parameters, and those a token goes through
kv_bytes_per_token, state_bytes	KV cache a token and recurrent state a sequence
concurrency, sessions, seconds	sessions at once, sessions timed, and the lane's wall time
sessions_per_hour, sessions_per_hour_per_gpu	the throughput the targets use
ttft_*_s, tpot_*_ms	time to first token and time per output token, median and 90th percentile; ttft_first_* for a session's first turn
output_tok_s, prompt_tok_s, prefilled_tok_s, cache_hit	token rates and the prefix-cache hit rate
max_model_len, long_context, kv_blocks, block_size	the lane's context and cache
weights_gib, kv_cache_dtype	the FP8 proof: the weights' size in vLLM and the cache's dtype
fp8_layers, unquantized_layers	the FP8 proof: the layers vLLM built with an FP8 method, and without
predicted_sessions_per_hour	the analytic serving model's prediction for the lane
excluded	why the lane is out of the targets, if it is

165 lanes are excluded: the copy pointer's lanes before its decode-graph fix (the void rows) and with its two-pass kernel, zero experts before their GEMM skip, a keys-only K=V cache, and one stack5 width whose decode ran 50% slower than its next width. lanes.jsonl has every lane in full; the two targets-*.json files hold, per family, the matched width and parameters, how the match was made, and the reason a family is kernel-limited.

Privacy

The pack holds no W&B entity, run URLs, hostnames, cluster, queue or reservation names, or private paths. Exported model paths are cut to exported/<tag>.

License

The data is under CC BY 4.0. The .bux files in configs/sources/ are bux's own, under its Apache-2.0 license.