Two sessions: LTX-2.5 and YuE2-3B on an RTX 5060 Ti 16GB, schema v1

README.md

@@ -0,0 +1,73 @@
+---
+license: cc-by-sa-4.0
+pretty_name: Smeltcore GPU measurements
+tags:
+- benchmark
+- gpu
+- vram
+- local-ai
+- comfyui
+- llama-cpp
+configs:
+- config_name: runs
+  data_files: runs.csv
+  default: true
+---
+
+# Smeltcore GPU measurements
+
+Raw VRAM and timing measurements of AI models running locally on consumer GPUs, made by the
+operator of [smeltcore.com](https://smeltcore.com) on his own hardware. Every benchmark on
+smeltcore.com that says *measured by us* points at a session folder in this repository, so a
+reader can check the number against the trace it came from.
+
+This is not a leaderboard. It is the evidence behind specific claims — "this model fits on this
+card in this configuration" — published so that the claim can be audited rather than trusted.
+
+## The table
+
+`runs.csv` holds one row per generation across every session. The dataset viewer above shows it;
+filter by `model_slug` and `gpu_slug`. The full column list and the rules behind it are in
+[`SCHEMA.md`](SCHEMA.md).
+
+## Read these before comparing numbers
+
+- **Units are MiB, as the instrument reports them.** Nothing is converted to GB in this table.
+  `nvidia-smi` reports MiB; NVML reports bytes; neither is decimal gigabytes. Convert at the point
+  of use.
+- **These are whole-card figures.** They include whatever a monitor or another program holds on
+  the card. `display_attached` says whether a monitor was driven by the GPU. `idle_device_mib` is
+  the card's memory just before the run; `peak_device_mib − idle_device_mib` estimates the
+  workload's share, assuming the rest held steady.
+- **An empty cell means "not measured", never zero.** One session has no idle baseline; its idle
+  column is empty rather than guessed.
+- **A failed run is a row.** An out-of-memory run appears with `ok = false` and `failure = oom`.
+  A missing combination means it was not attempted.
+- **Cold and warm runs differ.** `cold_start` says whether models were unloaded first. A model
+  already resident from a previous job changes the memory profile of the next one.
+- **Unreplicated: one rig, one operator.** These are single-machine measurements. They show that
+  something ran, with what, and at what cost on that machine — not a population average.
+
+## Layout
+
+```
+runs.csv                      every run, one row each — the table the viewer shows
+SCHEMA.md                     the columns, and why each rule exists
+sessions/<session_id>/
+    README.md                 what was measured and what it found
+    session.json              environment, instrument, and caveats
+    raw/                      traces, the runtime's own output, and the harness that ran
+harness/                      the current measurement harnesses
+```
+
+## Sessions
+
+| session | model | card | runs | result |
+|---|---|---|---:|---|
+| [`2026-08-13_ltx-2-5_rtx-5060-ti`](sessions/2026-08-13_ltx-2-5_rtx-5060-ti) | LTX-2.5 (video) | RTX 5060 Ti 16GB | 15 | no OOM, up to 1920x1088 and 193 frames |
+| [`2026-09-10_yue2-3b_rtx-5060-ti`](sessions/2026-09-10_yue2-3b_rtx-5060-ti) | YuE2-3B (music) | RTX 5060 Ti 16GB | 4 | no OOM, including full context on two CFG branches |
+
+## Licence
+
+CC BY-SA 4.0, matching [Smeltcore/gpu-compatibility](https://huggingface.co/datasets/Smeltcore/gpu-compatibility).
+The model weights measured here carry their own licences; nothing from them is redistributed.

SCHEMA.md

@@ -0,0 +1,120 @@
+# Smeltcore measurements — schema v1
+
+This is the contract between three things: the harnesses that produce measurements, the
+`Smeltcore/measurements` dataset that publishes them, and the benchmark rows the site imports
+from them. Change it only by bumping the version and saying why.
+
+## Principles — each one is a scar
+
+1. **Store the instrument's native unit. Never a converted one.** `nvidia-smi` reports MiB;
+   store MiB as an integer. Every unit error in the 2026-09-10 round — GiB compared against a
+   nameplate, a device peak compared against a process ceiling — happened at a conversion. Convert
+   at the point of use, where the reader can see it happen.
+2. **Device and process are different measurements.** A whole-card peak includes whatever a
+   monitor, a browser or another process holds. `set_per_process_memory_fraction` and similar
+   limits bind the *process*. Record the device peak, the idle baseline before the run, and
+   whether a display was attached — always. Record a process peak where the runtime exposes one.
+3. **A failed run is a result.** An OOM is a row with `ok=false` and a `failure` reason, not a
+   gap in the table. Absence of a row means "not attempted", never "did not work".
+4. **Raw evidence travels with the result.** Every session keeps the raw trace, the runtime's own
+   log and a copy of the exact harness that ran. A number nobody can re-derive is a claim.
+5. **The benchmark row is a projection, not a source.** `runs.csv` holds measurements. Which
+   number becomes a headline `speed_value` on `/check` is decided when a benchmark row is
+   generated, not baked into the data.
+6. **One run is one row, and runs are cold by default.** Unload models before each run so every
+   row is independent. A warm run is legitimate but must say so (`cold_start=false`), because a
+   resident model changes the memory profile — the LTX-2.5 session showed a text encoder
+   re-entering VRAM on top of resident weights as the entire story behind its three worst peaks.
+
+## Layout
+
+```
+README.md                         dataset card; pins the viewer to runs.csv via `configs`
+runs.csv                          ONE table, one row per run, every session
+sessions/<session_id>/
+    session.json                  environment + method for the whole session
+    README.md                     human notes and caveats specific to this session
+    raw/                          traces, runtime logs, the workflow/config used, harness copy
+harness/                          the current harnesses (sessions carry their own copy)
+```
+
+`session_id` = `<YYYY-MM-DD>_<model_slug>_<gpu_slug>`, e.g.
+`2026-09-10_yue2-3b_rtx-5060-ti`. A second session for the same pair on the same day appends
+`_2`. Date first so the directory sorts chronologically.
+
+## `runs.csv`
+
+Columns in this order. Empty cell = not applicable or not measured — never zero.
+
+| column | type | meaning |
+|---|---|---|
+| `session_id` | str | joins to `sessions/<session_id>/` |
+| `run` | int | order within the session, from 1 |
+| `measured_at` | ISO 8601 UTC | when the run started |
+| `model_slug` | str | catalogue slug on smeltcore.com |
+| `gpu_slug` | str | catalogue slug on smeltcore.com |
+| `vertical` | str | the model's catalogue vertical |
+| `task` | str | `t2i` `i2i` `t2v` `i2v` `llm` `t2m` `tts` — same vocabulary as benchmark rows |
+| `runtime` | str | `comfyui` `llama.cpp` `vendor-python` … |
+| `runtime_version` | str | commit hash or version of the runtime itself |
+| `artifact` | str | the exact weights: HF repo + filename(s), `;`-separated |
+| `quantization` | str | as the artifact names it: `Q3_K_M`, `bf16`, `fp8_e4m3fn` … |
+| `width` | int | output pixels, read back from the produced file — not the requested size |
+| `height` | int | as above |
+| `frames` | int | output frame count, read back from the produced file |
+| `steps` | int | sampler steps; for multi-pass schedules the total, detail in `config_json` |
+| `context_tokens` | int | LLM: context size the runtime was started with |
+| `prompt_tokens` | int | LLM: prompt length processed |
+| `gen_tokens` | int | LLM: tokens generated |
+| `output_seconds` | float | duration of produced audio/video, read back from the file |
+| `config_json` | JSON str | every other knob that affects memory or speed, verbatim |
+| `cold_start` | bool | models unloaded before this run |
+| `ok` | bool | completed and produced an output file |
+| `failure` | str | empty when `ok`; else `oom` `crash` `timeout` `invalid-output` |
+| `wall_s` | float | the runtime's own execution time for this job |
+| `prefill_tokens_per_s` | float | LLM only |
+| `gen_tokens_per_s` | float | LLM only |
+| `idle_device_mib` | int | whole-card memory.used immediately before the run was queued |
+| `peak_device_mib` | int | highest whole-card memory.used sampled inside the run's window |
+| `peak_process_mib` | int | runtime-reported process peak, where available |
+| `vram_total_mib` | int | memory.total as the driver reports it |
+| `display_attached` | bool | a monitor was driven by this GPU during the run |
+| `gpu_name` | str | as the driver reports it |
+| `driver` | str | driver version |
+| `sample_ms` | int | VRAM sampling interval in milliseconds |
+| `notes` | str | one line; anything a reader needs to not misread this row |
+
+Derived quantities are **not** stored: headroom (`vram_total_mib - peak_device_mib`),
+real-time factor (`wall_s / output_seconds`), per-process estimate
+(`peak_device_mib - idle_device_mib`, which assumes idle held constant through the run).
+
+## `session.json`
+
+```json
+{
+  "schema_version": 1,
+  "session_id": "2026-09-10_yue2-3b_rtx-5060-ti",
+  "operator": "site operator, own hardware",
+  "gpu": {"slug": "rtx-5060-ti", "name": "NVIDIA GeForce RTX 5060 Ti",
+          "vram_total_mib": 16311, "driver": "591.86", "compute_capability": "12.0"},
+  "host": {"os": "Windows 11 + WSL2 Ubuntu 24.04", "ram_gib": 23},
+  "display_attached": true,
+  "runtime": {"name": "comfyui", "version": "<commit>", "extras": {}},
+  "instrument": {
+    "vram": "nvidia-smi --query-gpu=timestamp,memory.used,memory.total,utilization.gpu --format=csv,noheader,nounits -lms 500",
+    "scope": "whole-card",
+    "sample_ms": 500
+  },
+  "harness": "raw/harness/",
+  "caveats": ["one line each — what a future reader should not have to rediscover"]
+}
+```
+
+## Projection to a benchmark row
+
+One benchmark row per `(session_id, config)` headline, generated — never hand-typed — with
+`source_url` = the session folder on Hugging Face, e.g.
+`https://huggingface.co/datasets/Smeltcore/measurements/tree/main/sessions/<session_id>`.
+`peak_vram_gb` is **decimal GB** in that table: `peak_device_mib * 1048576 / 1e9`, converted
+exactly once, in the generator. `notes` names the session and states device vs process,
+display attached, and "unreplicated: one rig, one operator".

runs.csv

@@ -0,0 +1,20 @@
+session_id,run,measured_at,model_slug,gpu_slug,vertical,task,runtime,runtime_version,artifact,quantization,width,height,frames,steps,context_tokens,prompt_tokens,gen_tokens,output_seconds,config_json,cold_start,ok,failure,wall_s,prefill_tokens_per_s,gen_tokens_per_s,idle_device_mib,peak_device_mib,peak_process_mib,vram_total_mib,display_attached,gpu_name,driver,sample_ms,notes
+2026-08-13_ltx-2-5_rtx-5060-ti,1,,ltx-2-5,rtx-5060-ti,video,t2v,comfyui,b323a345,realrebelai/LTX-2.5_GGUFs:LTX-2.5-Distilled-Q3_K_M.gguf;Lightricks/LTX-2.5:text_encoders/gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-video-vae-conv-bf16.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-audio-vae-bf16.safetensors;Lightricks/LTX-2.5:latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors;Comfy-Org/gemma-4:text_encoders/gemma4_e2b_it_bf16.safetensors,Q3_K_M,576,320,49,11,,,,2.0,"{""schedule"": ""8 steps + 3 steps"", ""vae_decode"": ""VAEDecodeTiled 512"", ""prompt_enhancer"": false, ""encoder_reloaded"": true, ""scene"": ""blacksmith, cold start"", ""fps"": 24, ""comfyui_gguf"": ""6ea2651e""}",true,true,,60.55,,,,15038,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,500,"prompt changed, so the 14.3 GiB text encoder re-entered VRAM on top of the resident transformer"
+2026-08-13_ltx-2-5_rtx-5060-ti,2,,ltx-2-5,rtx-5060-ti,video,i2v,comfyui,b323a345,realrebelai/LTX-2.5_GGUFs:LTX-2.5-Distilled-Q3_K_M.gguf;Lightricks/LTX-2.5:text_encoders/gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-video-vae-conv-bf16.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-audio-vae-bf16.safetensors;Lightricks/LTX-2.5:latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors;Comfy-Org/gemma-4:text_encoders/gemma4_e2b_it_bf16.safetensors,Q3_K_M,640,320,97,11,,,,4.0,"{""schedule"": ""8 steps + 3 steps"", ""vae_decode"": ""VAEDecodeTiled 512"", ""prompt_enhancer"": false, ""encoder_reloaded"": true, ""scene"": ""character, head turn"", ""fps"": 24, ""comfyui_gguf"": ""6ea2651e""}",false,true,,57.75,,,,15504,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,500,"prompt changed, so the 14.3 GiB text encoder re-entered VRAM on top of the resident transformer"
+2026-08-13_ltx-2-5_rtx-5060-ti,3,,ltx-2-5,rtx-5060-ti,video,i2v,comfyui,b323a345,realrebelai/LTX-2.5_GGUFs:LTX-2.5-Distilled-Q3_K_M.gguf;Lightricks/LTX-2.5:text_encoders/gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-video-vae-conv-bf16.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-audio-vae-bf16.safetensors;Lightricks/LTX-2.5:latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors;Comfy-Org/gemma-4:text_encoders/gemma4_e2b_it_bf16.safetensors,Q3_K_M,768,448,97,11,,,,4.0,"{""schedule"": ""8 steps + 3 steps"", ""vae_decode"": ""VAEDecodeTiled 512"", ""prompt_enhancer"": false, ""encoder_reloaded"": false, ""scene"": ""character, head turn"", ""fps"": 24, ""comfyui_gguf"": ""6ea2651e""}",false,true,,47.67,,,,14815,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,500,
+2026-08-13_ltx-2-5_rtx-5060-ti,4,,ltx-2-5,rtx-5060-ti,video,t2v,comfyui,b323a345,realrebelai/LTX-2.5_GGUFs:LTX-2.5-Distilled-Q3_K_M.gguf;Lightricks/LTX-2.5:text_encoders/gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-video-vae-conv-bf16.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-audio-vae-bf16.safetensors;Lightricks/LTX-2.5:latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors;Comfy-Org/gemma-4:text_encoders/gemma4_e2b_it_bf16.safetensors,Q3_K_M,640,320,97,11,,,,4.0,"{""schedule"": ""8 steps + 3 steps"", ""vae_decode"": ""VAEDecodeTiled 512"", ""prompt_enhancer"": false, ""encoder_reloaded"": true, ""scene"": ""space"", ""fps"": 24, ""comfyui_gguf"": ""6ea2651e""}",false,true,,45.98,,,,15827,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,500,"prompt changed, so the 14.3 GiB text encoder re-entered VRAM on top of the resident transformer"
+2026-08-13_ltx-2-5_rtx-5060-ti,5,,ltx-2-5,rtx-5060-ti,video,t2v,comfyui,b323a345,realrebelai/LTX-2.5_GGUFs:LTX-2.5-Distilled-Q3_K_M.gguf;Lightricks/LTX-2.5:text_encoders/gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-video-vae-conv-bf16.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-audio-vae-bf16.safetensors;Lightricks/LTX-2.5:latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors;Comfy-Org/gemma-4:text_encoders/gemma4_e2b_it_bf16.safetensors,Q3_K_M,768,448,49,11,,,,2.0,"{""schedule"": ""8 steps + 3 steps"", ""vae_decode"": ""VAEDecodeTiled 512"", ""prompt_enhancer"": false, ""encoder_reloaded"": false, ""scene"": ""space"", ""fps"": 24, ""comfyui_gguf"": ""6ea2651e""}",false,true,,34.62,,,,14720,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,500,
+2026-08-13_ltx-2-5_rtx-5060-ti,6,,ltx-2-5,rtx-5060-ti,video,t2v,comfyui,b323a345,realrebelai/LTX-2.5_GGUFs:LTX-2.5-Distilled-Q3_K_M.gguf;Lightricks/LTX-2.5:text_encoders/gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-video-vae-conv-bf16.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-audio-vae-bf16.safetensors;Lightricks/LTX-2.5:latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors;Comfy-Org/gemma-4:text_encoders/gemma4_e2b_it_bf16.safetensors,Q3_K_M,768,448,97,11,,,,4.0,"{""schedule"": ""8 steps + 3 steps"", ""vae_decode"": ""VAEDecodeTiled 512"", ""prompt_enhancer"": false, ""encoder_reloaded"": false, ""scene"": ""space"", ""fps"": 24, ""comfyui_gguf"": ""6ea2651e""}",false,true,,41.92,,,,14705,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,500,
+2026-08-13_ltx-2-5_rtx-5060-ti,7,,ltx-2-5,rtx-5060-ti,video,t2v,comfyui,b323a345,realrebelai/LTX-2.5_GGUFs:LTX-2.5-Distilled-Q3_K_M.gguf;Lightricks/LTX-2.5:text_encoders/gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-video-vae-conv-bf16.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-audio-vae-bf16.safetensors;Lightricks/LTX-2.5:latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors;Comfy-Org/gemma-4:text_encoders/gemma4_e2b_it_bf16.safetensors,Q3_K_M,832,512,97,11,,,,4.0,"{""schedule"": ""8 steps + 3 steps"", ""vae_decode"": ""VAEDecodeTiled 512"", ""prompt_enhancer"": false, ""encoder_reloaded"": false, ""scene"": ""space"", ""fps"": 24, ""comfyui_gguf"": ""6ea2651e""}",false,true,,49.48,,,,14943,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,500,
+2026-08-13_ltx-2-5_rtx-5060-ti,8,,ltx-2-5,rtx-5060-ti,video,t2v,comfyui,b323a345,realrebelai/LTX-2.5_GGUFs:LTX-2.5-Distilled-Q3_K_M.gguf;Lightricks/LTX-2.5:text_encoders/gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-video-vae-conv-bf16.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-audio-vae-bf16.safetensors;Lightricks/LTX-2.5:latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors;Comfy-Org/gemma-4:text_encoders/gemma4_e2b_it_bf16.safetensors,Q3_K_M,1088,576,97,11,,,,4.0,"{""schedule"": ""8 steps + 3 steps"", ""vae_decode"": ""VAEDecodeTiled 512"", ""prompt_enhancer"": false, ""encoder_reloaded"": false, ""scene"": ""space"", ""fps"": 24, ""comfyui_gguf"": ""6ea2651e""}",false,true,,62.03,,,,14735,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,500,
+2026-08-13_ltx-2-5_rtx-5060-ti,9,,ltx-2-5,rtx-5060-ti,video,t2v,comfyui,b323a345,realrebelai/LTX-2.5_GGUFs:LTX-2.5-Distilled-Q3_K_M.gguf;Lightricks/LTX-2.5:text_encoders/gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-video-vae-conv-bf16.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-audio-vae-bf16.safetensors;Lightricks/LTX-2.5:latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors;Comfy-Org/gemma-4:text_encoders/gemma4_e2b_it_bf16.safetensors,Q3_K_M,1216,704,97,11,,,,4.0,"{""schedule"": ""8 steps + 3 steps"", ""vae_decode"": ""VAEDecodeTiled 512"", ""prompt_enhancer"": false, ""encoder_reloaded"": false, ""scene"": ""space"", ""fps"": 24, ""comfyui_gguf"": ""6ea2651e""}",false,true,,76.22,,,,14778,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,500,
+2026-08-13_ltx-2-5_rtx-5060-ti,10,,ltx-2-5,rtx-5060-ti,video,t2v,comfyui,b323a345,realrebelai/LTX-2.5_GGUFs:LTX-2.5-Distilled-Q3_K_M.gguf;Lightricks/LTX-2.5:text_encoders/gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-video-vae-conv-bf16.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-audio-vae-bf16.safetensors;Lightricks/LTX-2.5:latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors;Comfy-Org/gemma-4:text_encoders/gemma4_e2b_it_bf16.safetensors,Q3_K_M,1344,768,97,11,,,,4.0,"{""schedule"": ""8 steps + 3 steps"", ""vae_decode"": ""VAEDecodeTiled 512"", ""prompt_enhancer"": false, ""encoder_reloaded"": false, ""scene"": ""space"", ""fps"": 24, ""comfyui_gguf"": ""6ea2651e""}",false,true,,88.51,,,,14614,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,500,
+2026-08-13_ltx-2-5_rtx-5060-ti,11,,ltx-2-5,rtx-5060-ti,video,t2v,comfyui,b323a345,realrebelai/LTX-2.5_GGUFs:LTX-2.5-Distilled-Q3_K_M.gguf;Lightricks/LTX-2.5:text_encoders/gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-video-vae-conv-bf16.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-audio-vae-bf16.safetensors;Lightricks/LTX-2.5:latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors;Comfy-Org/gemma-4:text_encoders/gemma4_e2b_it_bf16.safetensors,Q3_K_M,1664,960,97,11,,,,4.0,"{""schedule"": ""8 steps + 3 steps"", ""vae_decode"": ""VAEDecodeTiled 512"", ""prompt_enhancer"": false, ""encoder_reloaded"": false, ""scene"": ""space"", ""fps"": 24, ""comfyui_gguf"": ""6ea2651e""}",false,true,,131.77,,,,15115,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,500,
+2026-08-13_ltx-2-5_rtx-5060-ti,12,,ltx-2-5,rtx-5060-ti,video,t2v,comfyui,b323a345,realrebelai/LTX-2.5_GGUFs:LTX-2.5-Distilled-Q3_K_M.gguf;Lightricks/LTX-2.5:text_encoders/gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-video-vae-conv-bf16.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-audio-vae-bf16.safetensors;Lightricks/LTX-2.5:latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors;Comfy-Org/gemma-4:text_encoders/gemma4_e2b_it_bf16.safetensors,Q3_K_M,1920,1088,97,11,,,,4.0,"{""schedule"": ""8 steps + 3 steps"", ""vae_decode"": ""VAEDecodeTiled 512"", ""prompt_enhancer"": false, ""encoder_reloaded"": false, ""scene"": ""space"", ""fps"": 24, ""comfyui_gguf"": ""6ea2651e""}",false,true,,183.12,,,,14512,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,500,
+2026-08-13_ltx-2-5_rtx-5060-ti,13,,ltx-2-5,rtx-5060-ti,video,i2v,comfyui,b323a345,realrebelai/LTX-2.5_GGUFs:LTX-2.5-Distilled-Q3_K_M.gguf;Lightricks/LTX-2.5:text_encoders/gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-video-vae-conv-bf16.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-audio-vae-bf16.safetensors;Lightricks/LTX-2.5:latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors;Comfy-Org/gemma-4:text_encoders/gemma4_e2b_it_bf16.safetensors,Q3_K_M,1344,768,145,11,,,,6.0,"{""schedule"": ""8 steps + 3 steps"", ""vae_decode"": ""VAEDecodeTiled 512"", ""prompt_enhancer"": false, ""encoder_reloaded"": true, ""scene"": ""character, exits car"", ""fps"": 24, ""comfyui_gguf"": ""6ea2651e""}",false,true,,143.39,,,,15912,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,500,"prompt changed, so the 14.3 GiB text encoder re-entered VRAM on top of the resident transformer"
+2026-08-13_ltx-2-5_rtx-5060-ti,14,,ltx-2-5,rtx-5060-ti,video,i2v,comfyui,b323a345,realrebelai/LTX-2.5_GGUFs:LTX-2.5-Distilled-Q3_K_M.gguf;Lightricks/LTX-2.5:text_encoders/gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-video-vae-conv-bf16.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-audio-vae-bf16.safetensors;Lightricks/LTX-2.5:latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors;Comfy-Org/gemma-4:text_encoders/gemma4_e2b_it_bf16.safetensors,Q3_K_M,1344,768,193,11,,,,8.0,"{""schedule"": ""8 steps + 3 steps"", ""vae_decode"": ""VAEDecodeTiled 512"", ""prompt_enhancer"": false, ""encoder_reloaded"": false, ""scene"": ""character, exits car"", ""fps"": 24, ""comfyui_gguf"": ""6ea2651e""}",false,true,,181.85,,,,14596,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,500,
+2026-08-13_ltx-2-5_rtx-5060-ti,15,,ltx-2-5,rtx-5060-ti,video,i2v,comfyui,b323a345,realrebelai/LTX-2.5_GGUFs:LTX-2.5-Distilled-Q3_K_M.gguf;Lightricks/LTX-2.5:text_encoders/gemma4-12b-with-proj-ltx-2.5-comfy-int8-convrot.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-video-vae-conv-bf16.safetensors;Lightricks/LTX-2.5:vae/ltx-2.5-audio-vae-bf16.safetensors;Lightricks/LTX-2.5:latent_upscale_models/ltx-2.5-latent-spatial-upscaler-x2-bf16-1.0.safetensors;Comfy-Org/gemma-4:text_encoders/gemma4_e2b_it_bf16.safetensors,Q3_K_M,1664,960,193,11,,,,8.0,"{""schedule"": ""8 steps + 3 steps"", ""vae_decode"": ""VAEDecodeTiled 512"", ""prompt_enhancer"": false, ""encoder_reloaded"": false, ""scene"": ""character, exits car"", ""fps"": 24, ""comfyui_gguf"": ""6ea2651e""}",false,true,,294.06,,,,14155,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,500,
+2026-09-10_yue2-3b_rtx-5060-ti,1,,yue2-3b,rtx-5060-ti,music,t2m,vendor-python,yue2_infer 0.1.5,m-a-p/YuE2-3B@1a96eca688d6ae5d7f0feb88573fec89920fcd19;m-a-p/YuE2-Vae,bf16,,,,,,,,201.04,"{""cot"": ""full"", ""vendor_quantization"": ""none"", ""ar_nar"": ""bf16"", ""vae"": ""fp32"", ""load_s"": 34.81, ""memory_budget_gib"": 24, ""budget"": ""default semantic budget (9000 tokens)""}",true,true,,205.23,,,788,10291,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,50,"MiB converted from 2-decimal GiB in RESULT.json, so each value carries +-5 MiB"
+2026-09-10_yue2-3b_rtx-5060-ti,2,,yue2-3b,rtx-5060-ti,music,t2m,vendor-python,yue2_infer 0.1.5,m-a-p/YuE2-3B@1a96eca688d6ae5d7f0feb88573fec89920fcd19;m-a-p/YuE2-Vae,bf16,,,,,,,,165.4,"{""cot"": ""off"", ""vendor_quantization"": ""none"", ""ar_nar"": ""bf16"", ""vae"": ""fp32"", ""load_s"": 31.36, ""memory_budget_gib"": 24, ""budget"": ""default semantic budget (9000 tokens)""}",true,true,,144.39,,,778,10516,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,50,"MiB converted from 2-decimal GiB in RESULT.json, so each value carries +-5 MiB"
+2026-09-10_yue2-3b_rtx-5060-ti,3,,yue2-3b,rtx-5060-ti,music,t2m,vendor-python,yue2_infer 0.1.5,m-a-p/YuE2-3B@1a96eca688d6ae5d7f0feb88573fec89920fcd19;m-a-p/YuE2-Vae,bf16,,,,,,,,299.96,"{""cot"": ""full"", ""vendor_quantization"": ""none"", ""ar_nar"": ""bf16"", ""vae"": ""fp32"", ""load_s"": 30.4, ""memory_budget_gib"": 24, ""kv_capacity"": 24576, ""prefix_tokens"": 5587, ""semantic_max_tokens"": 18989, ""semantic_tokens"": 7499, ""semantic_truncated"": false, ""lyrics_chars"": 2420, ""budget"": ""KV filled to CONTEXT - len(prefix)""}",true,true,,315.53,,,860,11786,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,50,"MiB converted from 2-decimal GiB in RESULT.json, so each value carries +-5 MiB"
+2026-09-10_yue2-3b_rtx-5060-ti,4,,yue2-3b,rtx-5060-ti,music,t2m,vendor-python,yue2_infer 0.1.5,m-a-p/YuE2-3B@1a96eca688d6ae5d7f0feb88573fec89920fcd19;m-a-p/YuE2-Vae,bf16,,,,,,,,345.68,"{""cot"": ""off"", ""vendor_quantization"": ""none"", ""ar_nar"": ""bf16"", ""vae"": ""fp32"", ""load_s"": 31.25, ""memory_budget_gib"": 24, ""kv_capacity"": 24576, ""prefix_tokens"": 1749, ""semantic_max_tokens"": 22827, ""semantic_tokens"": 8642, ""semantic_truncated"": false, ""lyrics_chars"": 2420, ""budget"": ""KV filled to CONTEXT - len(prefix)""}",true,true,,298.55,,,860,13804,,16311,true,NVIDIA GeForce RTX 5060 Ti,591.86,50,"MiB converted from 2-decimal GiB in RESULT.json, so each value carries +-5 MiB"

sessions/2026-08-13_ltx-2-5_rtx-5060-ti/README.md

@@ -0,0 +1,18 @@
+# LTX-2.5 on an RTX 5060 Ti 16GB — 2026-08-13
+
+Fifteen text-to-video and image-to-video generations in ComfyUI, from 576x320 to 1920x1088 and
+up to 193 frames, on a 16 GB card with a monitor attached. **No run ran out of memory.**
+
+The finding is the one the table was not expecting: peak memory did **not** follow frame size.
+The largest job of the session produced its lowest peak, and the three highest peaks are the
+three runs where the prompt changed, so the 14.3 GiB text encoder had to re-enter VRAM on top of
+a transformer that ComfyUI kept resident. On this card, memory pressure is decided by what is
+already loaded, not by how big the video is.
+
+- Rows: `runs.csv`, `session_id = 2026-08-13_ltx-2-5_rtx-5060-ti`
+- Method and caveats: `session.json`, and `raw/README-original.md`, written the day of the runs
+- Raw trace: `raw/vram-samples.csv` — 5,288 `nvidia-smi` samples at 500 ms
+- The recipe this backs: https://smeltcore.com/gpus/rtx-5060-ti/
+
+Read `session.json` → `caveats` before comparing these numbers with anything. In short: they are
+whole-card figures, there is no idle baseline, and the runs were warm rather than cold.

sessions/2026-08-13_ltx-2-5_rtx-5060-ti/raw/README-original.md

@@ -0,0 +1,60 @@
+# Measurement data — ltx-2-5 × rtx-5060-ti, 2026-08-13
+
+Raw evidence behind `state/experiment-ltx-2-5-rtx-5060-ti.md`. Nothing here is derived
+from a model's estimate; every row was produced by a run on the operator's own card.
+
+## `ltx-2-5-rtx-5060-ti-runs.csv`
+
+One row per generation, 15 rows. Columns:
+
+| column | meaning |
+|---|---|
+| `run` | order within the session |
+| `kind` | `t2v` or `i2v` |
+| `width`, `height` | actual pixel size of the produced mp4, read back with PyAV — not the requested size |
+| `frames` | actual frame count of the mp4 |
+| `wall_s` | ComfyUI's own `Prompt executed in N seconds` |
+| `peak_mib` | highest `memory.used` sampled inside that run's window |
+| `headroom_mib` | `16311 - peak_mib` |
+| `encoder_reloaded` | `yes` when the prompt text changed, so the 14.317 GiB text encoder had to re-enter VRAM |
+| `megapixels` | `width * height / 1048576` (binary, matching ComfyUI's own convention) |
+| `mpix_frames` | `megapixels * frames` — the work metric wall time is linear in |
+| `s_per_mpix_frame` | `wall_s / mpix_frames`; converges to 0.9709 over the eight runs above 50 MPix-frames |
+| `scene` | which prompt, for grouping — encoder reloads happen on scene changes |
+
+The three rows with `encoder_reloaded = yes` and headroom under 810 MiB are the whole
+story: nothing else in this table predicts memory pressure.
+
+## `ltx-2-5-rtx-5060-ti-vram-samples.csv`
+
+5288 raw `nvidia-smi` samples, one per 500 ms, spanning the whole session including idle
+gaps between runs. No header. Columns:
+
+```
+timestamp, memory.used [MiB], memory.total [MiB], utilization.gpu [%]
+```
+
+Produced by:
+
+```
+nvidia-smi --query-gpu=timestamp,memory.used,memory.total,utilization.gpu \
+           --format=csv,noheader,nounits -lms 500
+```
+
+These are **whole-card** figures — they include the Windows desktop's share, so they are not
+comparable to per-process figures. This trace has **no idle baseline**: it opens at 13,726 MiB,
+already mid-session, and its minimum across all 5288 rows is 2505 MiB with zero samples below
+900. (An earlier draft of this file claimed idle "sits around 700–800 MiB"; nothing here
+measures that.) To re-derive a per-run peak, pair each
+`got prompt` with its `Prompt executed` in `D:\ComfyUI\user\comfyui_8000.log` and take the
+maximum sample inside that window.
+
+## Caveats a future reader should not have to rediscover
+
+- Peaks are whole-card, so they are not directly comparable to per-process figures from
+  `torch.cuda.max_memory_allocated`.
+- ComfyUI keeps the transformer resident between jobs. A run measured immediately after a
+  cold start has a *different* memory profile from the same run measured second in a
+  queue — the encoder collides with resident weights in the latter case. Both appear in
+  this table; `encoder_reloaded` is what separates them.
+- Wall times include ComfyUI's own queue and node overhead, not just sampling.

sessions/2026-08-13_ltx-2-5_rtx-5060-ti/raw/runs-original.csv

@@ -0,0 +1,16 @@
+run,kind,width,height,frames,wall_s,peak_mib,headroom_mib,encoder_reloaded,megapixels,mpix_frames,s_per_mpix_frame,scene
+1,t2v,576,320,49,60.55,15038,1273,yes,0.1758,8.6,7.0298,"blacksmith, cold start"
+2,i2v,640,320,97,57.75,15504,807,yes,0.1953,18.9,3.0482,"character, head turn"
+3,i2v,768,448,97,47.67,14815,1496,no,0.3281,31.8,1.4977,"character, head turn"
+4,t2v,640,320,97,45.98,15827,484,yes,0.1953,18.9,2.4270,space
+5,t2v,768,448,49,34.62,14720,1591,no,0.3281,16.1,2.1532,space
+6,t2v,768,448,97,41.92,14705,1606,no,0.3281,31.8,1.3171,space
+7,t2v,832,512,97,49.48,14943,1368,no,0.4062,39.4,1.2556,space
+8,t2v,1088,576,97,62.03,14735,1576,no,0.5977,58.0,1.0700,space
+9,t2v,1216,704,97,76.22,14778,1533,no,0.8164,79.2,0.9625,space
+10,t2v,1344,768,97,88.51,14614,1697,no,0.9844,95.5,0.9270,space
+11,t2v,1664,960,97,131.77,15115,1196,no,1.5234,147.8,0.8917,space
+12,t2v,1920,1088,97,183.12,14512,1799,no,1.9922,193.2,0.9476,space
+13,i2v,1344,768,145,143.39,15912,399,yes,0.9844,142.7,1.0046,"character, exits car"
+14,i2v,1344,768,193,181.85,14596,1715,no,0.9844,190.0,0.9572,"character, exits car"
+15,i2v,1664,960,193,294.06,14155,2156,no,1.5234,294.0,1.0001,"character, exits car"

sessions/2026-08-13_ltx-2-5_rtx-5060-ti/session.json

@@ -0,0 +1,39 @@
+{
+  "schema_version": 1,
+  "session_id": "2026-08-13_ltx-2-5_rtx-5060-ti",
+  "operator": "site operator, own hardware",
+  "gpu": {
+    "slug": "rtx-5060-ti",
+    "name": "NVIDIA GeForce RTX 5060 Ti",
+    "vram_total_mib": 16311,
+    "driver": "591.86",
+    "compute_capability": "12.0"
+  },
+  "host": {
+    "os": "Windows 11 (ComfyUI native)",
+    "ram_gib": null
+  },
+  "display_attached": true,
+  "runtime": {
+    "name": "comfyui",
+    "version": "b323a345",
+    "extras": {
+      "ComfyUI-GGUF": "6ea2651e",
+      "torch": "2.12.0.dev+cu128"
+    }
+  },
+  "instrument": {
+    "vram": "nvidia-smi --query-gpu=timestamp,memory.used,memory.total,utilization.gpu --format=csv,noheader,nounits -lms 500",
+    "scope": "whole-card",
+    "sample_ms": 500
+  },
+  "harness": "none — runs were queued by hand in the ComfyUI UI; the trace was captured with the command in `instrument.vram`",
+  "caveats": [
+    "Whole-card figures: they include the Windows desktop's share and are not comparable with per-process figures.",
+    "No idle baseline was recorded. The trace opens mid-session at 13,726 MiB and never falls below 2,505 MiB, so idle_device_mib is empty rather than guessed.",
+    "Runs were warm, not cold: ComfyUI kept the transformer resident between jobs. Only run 1 started cold. Where the prompt text changed, the 14.3 GiB text encoder re-entered VRAM on top of the resident transformer - config_json.encoder_reloaded marks those runs, and they are the three highest peaks.",
+    "measured_at is empty: per-run times live in the ComfyUI log, which was not retained. The raw trace is timestamped.",
+    "output_seconds is computed as (frames - 1) / 24 from the workflow's 24 fps and the VAE's 1-mod-8 clip-length rule, not read from the container - the mp4s were not retained. frames, width and height WERE read back from the produced files with PyAV.",
+    "Peak memory did NOT scale with frame size: the largest job (1664x960, 193 frames) produced the lowest peak."
+  ]
+}

sessions/2026-09-10_yue2-3b_rtx-5060-ti/README.md

@@ -0,0 +1,26 @@
+# YuE2-3B on an RTX 5060 Ti 16GB — 2026-09-10
+
+Four full-song generations with the vendor's own Python runtime, one day after the model was
+published. The vendor's quick start asks for a 24 GB GPU. **All four runs completed on a 16 GB
+card, including the worst case the library can be put in.**
+
+| run | configuration | device peak | device peak − idle |
+|---|---|---:|---:|
+| 1 | `cot="full"`, default budget | 10,291 MiB | 9,503 MiB |
+| 2 | `cot="off"`, default budget | 10,516 MiB | 9,738 MiB |
+| 3 | `cot="full"`, KV filled to the full 24,576-token context | 11,786 MiB | 10,926 MiB |
+| 4 | `cot="off"`, full context **and** the second CFG branch | 13,804 MiB | 12,944 MiB |
+
+The library caps itself at `total − 2 GiB` per process — 14,263 MiB on this card (16,311 − 2,048) — and run 4
+stayed under it. Because the KV cache is sized by the budget rather than by the tokens actually
+generated, a longer song cannot cost more than run 4 does.
+
+**On the last column.** It is the right figure to hold against a per-process cap, but it is an
+*estimate*: it assumes the desktop's share of the card held steady during the run. It is not a
+measured process peak, which is why the dataset leaves `peak_process_mib` empty. Recipes on
+smeltcore.com that call this figure "in-process" are quoting this estimate.
+
+- Rows: `runs.csv`, `session_id = 2026-09-10_yue2-3b_rtx-5060-ti`
+- Method and caveats: `session.json`
+- Raw output and both harnesses: `raw/`
+- The recipe this backs: https://smeltcore.com/recipes/yue2-3b-on-rtx-5060-ti-16gb-measured-worst-case-included/

sessions/2026-09-10_yue2-3b_rtx-5060-ti/raw/RESULT.json

@@ -0,0 +1,118 @@
+{
+  "_note": [
+    "Two separate script invocations, not --both. run_one() frees nothing between runs, so a",
+    "second run in the same process reads the first run's still-resident allocator memory as its",
+    "NVML idle baseline. Measured on this card: pipeline loaded 7.92 GiB, after del+gc still",
+    "7.92 GiB, after torch.cuda.empty_cache() 1.14 GiB. Each entry below is the run_one block its",
+    "own fresh process printed, verbatim and unedited; only the two 'measured' arrays were joined.",
+    "measure_yue2.py was patched in the same commit: 'runs = [run_one(\"full\", base)]' was",
+    "unconditional, so --cot off ran a full pass first, threw its result away, and handed the off",
+    "run a contaminated idle baseline. The cot=full entry below predates the patch and is",
+    "unaffected by it (the patch cannot change the default path's single full run).",
+    "SUPERSEDED, see `long_song` below: this line said the max-context case was NOT measured and",
+    "whether a long song OOMs on a 16 GiB card was still open. The second commit answered it — full",
+    "context WITH the second CFG branch peaks at 13.48 GiB device / 12.64 in-process against a 13.93",
+    "ceiling, no OOM. Kept rather than deleted so the file records that it once contradicted itself.",
+    "Still true from the original note: the card was NOT headless (a display held ~0.77 GiB), which is",
+    "why nvml_peak_minus_idle_gib is reported alongside the device peak — and the clamp is",
+    "set_per_process_memory_fraction, so peak-minus-idle is the figure it actually binds."
+  ],
+  "vendor_reference": {
+    "card": "RTX 4090 24GB",
+    "cot_full_peak_gib": 11.18,
+    "max_context_peak_gib": 14.08,
+    "note": "vendor README, NVML full-run peak"
+  },
+  "measured": [
+    {
+      "cot": "full",
+      "load_s": 34.81,
+      "generate_s": 205.23,
+      "audio_s": 201.04,
+      "nvml_peak_device_gib": 10.05,
+      "nvml_peak_minus_idle_gib": 9.03,
+      "output": "song-cot-full.flac",
+      "gpu_name": "NVIDIA GeForce RTX 5060 Ti",
+      "vram_total_gib": 15.93,
+      "vram_idle_gib": 0.77,
+      "driver": "591.86",
+      "alloc_ceiling_gib": 13.93
+    },
+    {
+      "cot": "off",
+      "load_s": 31.36,
+      "generate_s": 144.39,
+      "audio_s": 165.4,
+      "nvml_peak_device_gib": 10.27,
+      "nvml_peak_minus_idle_gib": 9.25,
+      "output": "song-cot-off.flac",
+      "gpu_name": "NVIDIA GeForce RTX 5060 Ti",
+      "vram_total_gib": 15.93,
+      "vram_idle_gib": 0.76,
+      "driver": "591.86",
+      "alloc_ceiling_gib": 13.93
+    }
+  ],
+  "environment": {
+    "os": "Windows 11 26200.9445 + WSL2 Ubuntu 24.04 (kernel 6.6.87.2-microsoft-standard-WSL2)",
+    "python": "3.12.3",
+    "torch": "2.10.0+cu128",
+    "cuda": "12.8",
+    "compute_capability": "12.0 (sm_120, Blackwell)",
+    "bf16_supported": true,
+    "yue2_infer": "0.1.5",
+    "wsl_ram_gib": 23,
+    "note": "The vendor wheel is py3-none-any and declares no platform. The only Linux-specific code (fcntl, os.killpg) is in fast.py, the optional vLLM backend, imported lazily and unused by the default torch backend. WSL2 was used anyway, per the README."
+  },
+  "_failed": {
+    "happened": false,
+    "what_you_saw": "",
+    "full_traceback_or_last_20_lines": "",
+    "nvidia_smi_output": ""
+  },
+  "long_song": {
+    "_question": "The first commit left this open: both songs there peaked near 10 GiB with the default semantic budget of 9000 tokens, so the vendor's 14.08 GiB maximum-context case -- which sits 0.15 GiB ABOVE this card's 13.93 GiB ceiling -- was never exercised. Answered by measure_longsong.py, which fills the semantic budget to CONTEXT-len(prefix) exactly.",
+    "_why_the_budget_and_not_the_song": "cuda_graph.py:71,92-94 preallocates the KV cache as (branches, max(len(prefix)) + max_tokens, kv_heads, head_dim) per layer, keys and values. So the FOOTPRINT is set by the budget, not by how many tokens the model actually emits. From config.json (28 layers, 8 kv heads, head_dim 128, bf16) a full-context KV is 2.62 GiB on one branch and 5.25 GiB on two. Song length adds NAR and VAE CHUNKS, not larger tensors -- protocol.py:141-145 sizes each chunk from the context -- which is why a still longer song cannot exceed what is measured here.",
+    "_headroom_units": "The clamp is set_per_process_memory_fraction, so it binds the PROCESS: compare it against peak-minus-idle, not against the device peak, which also contains the display's ~0.8 GiB the clamp never sees. peak-minus-idle assumes idle held constant across the run.",
+    "answer": "No OOM, in any of the four cases, including the worst one.",
+    "runs": [
+      {
+        "cot": "full",
+        "kv_capacity": 24576,
+        "prefix_tokens": 5587,
+        "semantic_max_tokens": 18989,
+        "semantic_tokens": 7499,
+        "semantic_truncated": false,
+        "oom": false,
+        "audio_s": 299.96,
+        "load_s": 30.4,
+        "generate_s": 315.53,
+        "nvml_peak_device_gib": 11.51,
+        "nvml_peak_minus_idle_gib": 10.67,
+        "process_headroom_to_clamp_gib": 3.26,
+        "device_physical_free_at_peak_gib": 4.42,
+        "vram_idle_gib": 0.84,
+        "lyrics_chars": 2420
+      },
+      {
+        "cot": "off",
+        "kv_capacity": 24576,
+        "prefix_tokens": 1749,
+        "semantic_max_tokens": 22827,
+        "semantic_tokens": 8642,
+        "semantic_truncated": false,
+        "oom": false,
+        "audio_s": 345.68,
+        "load_s": 31.25,
+        "generate_s": 298.55,
+        "nvml_peak_device_gib": 13.48,
+        "nvml_peak_minus_idle_gib": 12.64,
+        "process_headroom_to_clamp_gib": 1.29,
+        "device_physical_free_at_peak_gib": 2.45,
+        "vram_idle_gib": 0.84,
+        "lyrics_chars": 2420,
+        "_note": "The worst case: full context AND the second CFG branch. 13.48 GiB device peak here closely reproduces the vendor's 14.08 GiB 'maximum context' figure on a card with a different idle, which suggests their number IS the two-branch full-context case."
+      }
+    ]
+  }
+}

sessions/2026-09-10_yue2-3b_rtx-5060-ti/raw/measure_longsong.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""Does a LONG song OOM on a 16 GiB card?
+
+measure_yue2.py leaves this open: both its songs peaked near 10 GiB with the default
+semantic budget of 9000 tokens, nowhere near the 13.93 GiB ceiling the vendor's clamp
+imposes here. The vendor's 14.08 GiB "maximum context" figure sits 0.15 GiB ABOVE that
+ceiling, so the interesting case was never exercised.
+
+cuda_graph.py:71,92-94 is why the budget, not the song, decides the footprint: the KV
+cache is preallocated as (branches, max(len(prefix)) + max_tokens, kv_heads, head_dim)
+per layer, keys and values. So this fills the budget to the context limit exactly, and
+also feeds long lyrics so the NAR and VAE stages -- which scale with real audio length,
+not with the budget -- are stressed too.
+
+Usage:  measure_longsong.py [--cot full|off]
+"""
+import argparse, gc, json, threading, time
+
+GIB = 1024 ** 3
+
+
+class NvmlPeak(threading.Thread):
+    """Whole-device NVML at 20 Hz -- the same instrument measure_yue2.py uses."""
+
+    def __init__(self, handle, pynvml):
+        super().__init__(daemon=True)
+        self.h, self.nv, self.peak, self.stop = handle, pynvml, 0, False
+
+    def run(self):
+        while not self.stop:
+            try:
+                self.peak = max(self.peak, self.nv.nvmlDeviceGetMemoryInfo(self.h).used)
+            except Exception:
+                pass
+            time.sleep(0.05)
+
+
+def long_lyrics(base, repeats):
+    """Repeat the demo's sections so the song itself is long, not just the budget."""
+    body = base.strip()
+    return "[Intro]\n\n" + "\n\n[Interlude]\n\n".join([body] * repeats) + "\n\n[Outro]\n"
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--cot", default="full", choices=["full", "melody", "off"])
+    ap.add_argument("--repeats", type=int, default=4)
+    a = ap.parse_args()
+
+    import pynvml, torch
+    from huggingface_hub import hf_hub_download
+    from yue2 import YuE2Pipeline
+    from yue2.protocol import CONTEXT, Sampling
+
+    pynvml.nvmlInit()
+    h = pynvml.nvmlDeviceGetHandleByIndex(0)
+    idle = pynvml.nvmlDeviceGetMemoryInfo(h).used
+    total = pynvml.nvmlDeviceGetMemoryInfo(h).total
+    ceiling = min(24 - 2, total / GIB - 2)
+    print(f"== long-song run: cot={a.cot!r}, lyrics x{a.repeats} ==")
+    print(f"  idle {idle / GIB:.2f} GiB | device total {total / GIB:.2f} GiB | alloc ceiling {ceiling:.2f} GiB")
+
+    demo = json.loads(open(hf_hub_download("m-a-p/YuE2-3B", "examples/tonight-awake.json")).read())
+    lyrics = long_lyrics(demo["lyrics"], a.repeats)
+    print(f"  lyrics {len(demo['lyrics'])} -> {len(lyrics)} chars")
+
+    sampler = NvmlPeak(h, pynvml)
+    sampler.start()
+    t0 = time.time()
+    result = {"cot": a.cot, "repeats": a.repeats, "lyrics_chars": len(lyrics),
+              "context": CONTEXT, "alloc_ceiling_gib": round(ceiling, 2),
+              "vram_idle_gib": round(idle / GIB, 2)}
+    try:
+        pipe = YuE2Pipeline.from_pretrained("m-a-p/YuE2-3B", device="cuda")
+        t_loaded = time.time()
+
+        plan = pipe.plan(style=demo["style"], lyrics=lyrics, cot=a.cot, seed=demo["seed"])
+        prefix_len = len(plan.prefix)
+        budget = CONTEXT - prefix_len            # sampling.py:62 rejects anything larger
+        capacity = prefix_len + budget           # == CONTEXT, the maximum-context case
+        result.update(prefix_tokens=prefix_len, semantic_max_tokens=budget,
+                      kv_capacity=capacity, abc_truncated=plan.truncated)
+        print(f"  prefix {prefix_len} tokens -> semantic budget {budget} "
+              f"(KV capacity {capacity} = full context)")
+
+        semantic = pipe.generate_semantic(
+            plan, sampling=Sampling(1.0, .95, 100, 1.2, 50, 200, budget))
+        result.update(semantic_tokens=len(semantic.tokens), semantic_truncated=semantic.truncated)
+        latents = pipe.synthesize(semantic)
+        audio = pipe.decode(latents)
+        t1 = time.time()
+
+        # Mirror SongResult.save exactly: audio is (samples, channels), FLAC is PCM_24.
+        out = f"long-song-cot-{a.cot}.flac"
+        import soundfile as sf
+        sf.write(out, audio, 48000, subtype="PCM_24")
+        result.update(oom=False, load_s=round(t_loaded - t0, 2),
+                      generate_s=round(t1 - t_loaded, 2),
+                      audio_s=round(len(audio) / 48000, 2), output=out)
+    except torch.cuda.OutOfMemoryError as e:
+        result.update(oom=True, error_type="torch.cuda.OutOfMemoryError", error=str(e)[:600])
+    except Exception as e:
+        result.update(oom=False, error_type=type(e).__name__, error=str(e)[:600])
+    finally:
+        sampler.stop = True
+        sampler.join()
+        result["nvml_peak_device_gib"] = round(sampler.peak / GIB, 2)
+        result["nvml_peak_minus_idle_gib"] = round((sampler.peak - idle) / GIB, 2)
+        # Two different headrooms, and conflating them is how a unit-broken conclusion
+        # gets published. The clamp (set_per_process_memory_fraction) binds THIS PROCESS,
+        # so compare it against the process's own peak -- device peak also contains the
+        # display's ~0.8 GiB, which the clamp never sees. The physical figure is separate.
+        process_peak = (sampler.peak - idle) / GIB
+        result["process_headroom_to_clamp_gib"] = round(ceiling - process_peak, 2)
+        result["device_physical_free_at_peak_gib"] = round((total - sampler.peak) / GIB, 2)
+        result["_headroom_note"] = ("process peak assumes idle held constant for the run; "
+                                    "the clamp applies to the process, the physical figure to the card")
+        gc.collect()
+
+    print("\n" + json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()

sessions/2026-09-10_yue2-3b_rtx-5060-ti/raw/measure_yue2.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+"""
+Measure YuE2-3B on THIS card, in the same unit the vendor used.
+
+Why this script and not `torch.cuda.max_memory_allocated()`:
+the vendor's figures ("11.18 GiB", "14.08 GiB") come from NVML, which counts the
+CUDA context and the allocator's reserved-but-unused blocks. Torch's allocator
+stats exclude both and land 0.4-0.8 GiB LOW. On a 16 GB card the whole question
+is a 0.88 GB headroom, so measuring with the wrong instrument would manufacture
+headroom that is not there. This samples NVML, like they did.
+
+Usage:
+    python3 measure_yue2.py              # cot=full  (the default, the mode that writes the score)
+    python3 measure_yue2.py --cot off    # answers the separate 12 GB question
+    python3 measure_yue2.py --both
+
+It prints a paste-ready block at the end. Send me that block verbatim.
+"""
+import argparse, json, os, platform, shutil, subprocess, sys, threading, time
+
+GIB = 1024 ** 3
+
+
+def die(msg):
+    print(f"\n  STOP: {msg}\n")
+    sys.exit(1)
+
+
+def preflight():
+    print("== preflight ==")
+    if platform.system() != "Linux":
+        die(f"the vendor wheel is Linux-only; this is {platform.system()}. WSL2 with CUDA counts as Linux.")
+    print(f"  os            {platform.system()} {platform.release()}")
+    if sys.version_info < (3, 10):
+        die(f"needs Python 3.10+, have {sys.version.split()[0]}")
+    print(f"  python        {sys.version.split()[0]}")
+    if not shutil.which("nvidia-smi"):
+        die("no nvidia-smi on PATH — this model is CUDA-only, there is no ROCm or Metal path.")
+    q = subprocess.run(
+        ["nvidia-smi", "--query-gpu=name,memory.total,memory.used,driver_version",
+         "--format=csv,noheader,nounits"], capture_output=True, text=True).stdout.strip()
+    print(f"  gpu           {q}")
+    name, total_mib, used_mib, driver = [x.strip() for x in q.split(",")]
+    total_gib = int(total_mib) / 1024
+    used_gib = int(used_mib) / 1024
+    print(f"  vram total    {total_gib:.2f} GiB   already in use {used_gib:.2f} GiB "
+          f"({'headless' if used_gib < 0.4 else 'a display or another process is attached'})")
+    # host RAM — the card is not the only floor: the card asks for 24 GB of host RAM too.
+    try:
+        mem = {l.split(":")[0]: int(l.split()[1]) for l in open("/proc/meminfo") if ":" in l}
+        avail = mem["MemAvailable"] / (1024 ** 2)
+        print(f"  host ram      {avail:.1f} GiB available   (the card asks for 24 GB available host RAM)")
+        if avail < 20:
+            print("    ! below the vendor's host-RAM ask — if it dies, this is the first suspect, not VRAM")
+    except Exception:
+        pass
+    # The vendor CLAMPS the allocator; know your ceiling before you run.
+    # pipeline.py:161-165  budget = min((memory_budget_gib - 2), total - 2) GiB
+    # with memory_budget_gib defaulting to 24. set_per_process_memory_fraction enforces it,
+    # so an OOM here can happen with physically free memory on the card.
+    budget_gib = min(24 - 2, total_gib - 2)
+    print(f"  alloc ceiling {budget_gib:.2f} GiB   (vendor clamp: min(24-2, total-2))")
+    print(f"                vendor's ordinary peak 11.18 GiB -> {budget_gib - 11.18:+.2f} GiB")
+    print(f"                vendor's max-context   14.08 GiB -> {budget_gib - 14.08:+.2f} GiB")
+    if budget_gib < 11.18:
+        die(f"the clamp gives this card only {budget_gib:.2f} GiB and the vendor's own ordinary "
+            f"peak is 11.18 GiB. It cannot run, and passing a bigger --budget will not help: "
+            f"the (total - 2) term caps it regardless.")
+    if budget_gib < 14.08:
+        print("    note: the MAX-CONTEXT case (14.08 GiB) does NOT fit this card's ceiling.")
+        print("    Context is fixed at 24576 (protocol.py:54), so the only lever is song length.")
+        print("    A long song can therefore OOM on this card while an ordinary one is fine —")
+        print("    that boundary is exactly what makes this measurement worth having.")
+    return {"gpu_name": name, "vram_total_gib": round(total_gib, 2),
+            "vram_idle_gib": round(used_gib, 2), "driver": driver,
+            "alloc_ceiling_gib": round(budget_gib, 2)}
+
+
+class NvmlPeak(threading.Thread):
+    """Sample whole-device NVML used-memory at 20 Hz. Same instrument as the vendor."""
+
+    def __init__(self, handle, pynvml):
+        super().__init__(daemon=True)
+        self.h, self.nv, self.peak, self.stop = handle, pynvml, 0, False
+
+    def run(self):
+        while not self.stop:
+            try:
+                self.peak = max(self.peak, self.nv.nvmlDeviceGetMemoryInfo(self.h).used)
+            except Exception:
+                pass
+            time.sleep(0.05)
+
+
+def run_one(cot, base):
+    import pynvml
+    from huggingface_hub import hf_hub_download
+    from yue2 import YuE2Pipeline
+
+    pynvml.nvmlInit()
+    h = pynvml.nvmlDeviceGetHandleByIndex(0)
+    idle = pynvml.nvmlDeviceGetMemoryInfo(h).used
+
+    print(f"\n== run: cot={cot!r} ==")
+    sampler = NvmlPeak(h, pynvml)
+    sampler.start()
+    t0 = time.time()
+
+    repo = "m-a-p/YuE2-3B"
+    demo = json.loads(open(hf_hub_download(repo, "examples/tonight-awake.json")).read())
+    pipe = YuE2Pipeline.from_pretrained(repo, device="cuda")
+    t_loaded = time.time()
+    song = pipe(style=demo["style"], lyrics=demo["lyrics"], cot=cot, seed=demo["seed"])
+    t1 = time.time()
+
+    sampler.stop = True
+    sampler.join()
+    out = f"song-cot-{cot}.flac"
+    song.save(out)
+
+    # audio duration, for the generation/audio ratio the vendor reports
+    audio_s = None
+    for attr in ("duration", "duration_s", "seconds"):
+        if hasattr(song, attr):
+            try:
+                audio_s = float(getattr(song, attr))
+                break
+            except Exception:
+                pass
+    if audio_s is None:
+        try:
+            import wave, contextlib
+            import soundfile as sf
+            info = sf.info(out)
+            audio_s = info.frames / info.samplerate
+        except Exception:
+            pass
+
+    r = {
+        "cot": cot,
+        "load_s": round(t_loaded - t0, 2),
+        "generate_s": round(t1 - t_loaded, 2),
+        "audio_s": round(audio_s, 2) if audio_s else None,
+        "nvml_peak_device_gib": round(sampler.peak / GIB, 2),
+        "nvml_peak_minus_idle_gib": round((sampler.peak - idle) / GIB, 2),
+        "output": out,
+    }
+    r.update(base)
+    print(json.dumps(r, indent=2))
+    return r
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--cot", default="full", choices=["full", "melody", "off"])
+    ap.add_argument("--both", action="store_true", help="run cot=full then cot=off")
+    a = ap.parse_args()
+
+    base = preflight()
+
+    try:
+        import pynvml  # noqa
+        import yue2  # noqa
+    except ImportError:
+        print("\n== installing (once) ==")
+        print("  run these, then re-run this script:\n")
+        print("    # A DEDICATED VENV IS NOT OPTIONAL: the wheel pins torch==2.10.0 exactly and")
+        print("    # will silently downgrade whatever torch you have. Someone has already had")
+        print("    # their ComfyUI broken by this. The package is also on NO PyPI index under")
+        print("    # any name - do not `pip install yue2`, that is a different project.")
+        print("    python3 -m venv .yue2 && source .yue2/bin/activate")
+        print("    python -m pip install -U pip nvidia-ml-py soundfile huggingface-hub==0.36.2")
+        print("    hf download m-a-p/YuE2-3B yue2_infer-0.1.5-py3-none-any.whl --local-dir .")
+        print("    python -m pip install ./yue2_infer-0.1.5-py3-none-any.whl\n")
+        sys.exit(2)
+
+    # This replaced an unconditional `runs = [run_one("full", base)]`, which ran a full
+    # pass even for `--cot off` and then discarded its result -- and, worse, left torch's
+    # caching allocator holding the first run's memory, so the SECOND run_one read that as
+    # its NVML `idle` baseline and reported a peak-minus-idle ~7 GiB too low. Measured on
+    # 2026-09-10 (RTX 5060 Ti): pipeline loaded 7.92 GiB, after `del pipe; gc.collect()`
+    # still 7.92 GiB, after `torch.cuda.empty_cache()` 1.14 GiB. The allocator returns
+    # nothing to the driver on its own, and NVML counts what the driver has handed out.
+    # A separate PROCESS per mode is still the cleanest measurement -- empty_cache() leaves
+    # the CUDA context behind (~0.1 GiB above a cold baseline) -- so prefer two invocations
+    # over --both when the number matters.
+    modes = ["full", "off"] if a.both else [a.cot]
+    runs = []
+    for index, mode in enumerate(modes):
+        if index:
+            import gc
+            import torch
+            gc.collect()
+            torch.cuda.empty_cache()
+        runs.append(run_one(mode, base))
+
+    print("\n" + "=" * 68)
+    print("PASTE THIS BACK VERBATIM")
+    print("=" * 68)
+    print(json.dumps({"vendor_reference": {"card": "RTX 4090 24GB", "cot_full_peak_gib": 11.18,
+                                           "max_context_peak_gib": 14.08,
+                                           "note": "vendor README, NVML full-run peak"},
+                      "measured": runs}, indent=2))
+
+
+if __name__ == "__main__":
+    main()

sessions/2026-09-10_yue2-3b_rtx-5060-ti/session.json

@@ -0,0 +1,40 @@
+{
+  "schema_version": 1,
+  "session_id": "2026-09-10_yue2-3b_rtx-5060-ti",
+  "operator": "site operator, own hardware",
+  "gpu": {
+    "slug": "rtx-5060-ti",
+    "name": "NVIDIA GeForce RTX 5060 Ti",
+    "vram_total_mib": 16311,
+    "driver": "591.86",
+    "compute_capability": "12.0"
+  },
+  "host": {
+    "os": "Windows 11 + WSL2 Ubuntu 24.04 (kernel 6.6.87.2-microsoft-standard-WSL2)",
+    "ram_gib": 23
+  },
+  "display_attached": true,
+  "runtime": {
+    "name": "vendor-python",
+    "version": "yue2_infer 0.1.5",
+    "extras": {
+      "torch": "2.10.0+cu128",
+      "cuda": "12.8",
+      "python": "3.12.3"
+    }
+  },
+  "instrument": {
+    "vram": "NVML nvmlDeviceGetMemoryInfo(handle).used, sampled at 20 Hz in a background thread for the whole run",
+    "scope": "whole-card",
+    "sample_ms": 50
+  },
+  "harness": "raw/measure_yue2.py (default-budget runs) and raw/measure_longsong.py (full-context runs)",
+  "caveats": [
+    "Whole-card NVML figures, the same instrument the vendor used for its own numbers - directly comparable with them, not with torch allocator statistics, which exclude the CUDA context and read 0.4-0.8 GiB low.",
+    "The model's allocator is clamped per PROCESS (pipeline.py: min(memory_budget_gib - 2, total - 2) GiB via set_per_process_memory_fraction; 13.93 GiB on this card). The honest comparison against that clamp is peak_device_mib minus idle_device_mib, which ASSUMES the desktop's usage held steady through the run. It is an estimate, not a measured process peak, so it is not stored; recipes that call it 'in-process' are quoting this estimate.",
+    "Each run was a separate process. In one process, 7.92 GiB stayed resident after del+gc and only fell to 1.14 GiB after torch.cuda.empty_cache(), which would contaminate the next run's baseline.",
+    "Values are converted from 2-decimal GiB in RESULT.json, so each MiB figure carries +-5 MiB.",
+    "The KV cache is preallocated by BUDGET, not by tokens emitted (cuda_graph.py), and song length adds decode chunks rather than larger tensors - so the full-context runs bound what a longer song can cost.",
+    "Run 4 (full context AND the second CFG branch) is the worst case the library can be put in. It did not OOM."
+  ]
+}