Freedomform/wet-ink-v5

🌊 Wet-Ink v5

A sliding-window frontier decoder for diffusion language models

Ink is wet near the frontier — and dries with distance.

Wet-Ink is an inference-time decoding method for diffusion language models (dLLMs). A diffusion frontier opens tokens strictly left-to-right, one token per step — the AR end of the published AR↔diffusion spectrum (BD3-LM, Set Diffusion). Behind the frontier, a sliding window of W tokens stays editable: the base model's own trained T2T gate (Levenshtein Editing, L-EBPO) may rewrite them while the "ink is wet". At distance W the ink dries hard — a token that leaves the window is never touched again.

No retraining. No new formulas — every mechanism is reused verbatim from the base model; the only new thing is the decoding schedule (which position opens, which window stays wet per step).

This repository documents the method, its full experimental evaluation on inclusionAI/LLaDA2.2-mini, and the honest result: quality is pair-identical to the stock parallel decoder (exact McNemar p = 1.0) at a structural ×4.88 NFE cost — a negative result published as such.

📖 The paper is also available as an interactive website in three languages (EN / RU / UZ): wetink.space-z.ai.

---

📊 Results

GSM8K (first 45 tasks, greedy T=0, gen_length=160), paired against the completed v4b baseline run (same model, same 4-bit quantization, same prompts). Full statistics: exact McNemar on paired tasks, Wilson 95% CIs, NFE accounting.

Arm	n	Accuracy	Wilson 95% CI	Mean NFE	Rewrites / task
wetink_w16 (the method, W=16)	45	24.4%	[14.2, 38.7]	206.6	6.9
noedit_w16 (frontier only, no rewrites)	22	13.6%	[4.7, 33.3]	201.1	0
wetink_w8 (narrow window)	10	20.0%	[5.7, 51.0]	202.7	5.6
stock_b32 (v4b baseline)	80	22.5%	[14.7, 32.8]	42.5	—
noedit_b32 (v4b baseline, editing off)	80	23.8%	[15.8, 34.1]	50.1	—

Paired exact McNemar (by task index): wetink_w16 vs stock_b32 — 11/45 vs 11/45 (2 fixed / 2 broken, p = 1.0) at ×4.88 NFE (42 → 207 paired). The frontier-only control vs stock: also p = 1.0. On the 22 tasks common to both v5 arms, window rewrites flipped not a single outcome (0 discordant pairs), although rewrites genuinely happen (6.9 per task, churn 5.6).

A methodological finding worth publishing: the raw +10.8 pp gap between wetink_w16 (24.4%) and its own control (13.6%) is a task-composition artifact — the control arm stopped early on the hard tasks 0–21 (every arm scores 13.6% there), while the main arm also covered the easy tasks 22–44 (34.8% there). Segment-level accuracies are identical across arms; the editing window moved nothing.

The w32 and HumanEval arms were skipped honestly by the time-budget scheduler (n_run=5 < 8, "skipped: time budget"), not silently dropped.

---

🚀 Key features

• Sliding wet window, hard dry edge — open tokens in [f−W, f) behind the frontier stay revisable; editing_confidence = −∞ outside the window ("ink dries with distance").
• One-token frontier — each diffusion step opens exactly the leftmost remaining mask and commits it AR-style. Progress is guaranteed: one mask fewer per step. No churn explosion (v1 of this project churned at 13× NFE; v5's cost is structural and predictable).
• Trained gate, not a training-free heuristic — rewrites go through LLaDA2.2's own T2T gate p0 > editing_threshold AND old != x0, plus its trained SPLIT/DELETE operations, anti-loop resampler and block-diagonal attention — all reused verbatim.
• Zero-formula-invention policy — every component carries provenance (see the table below); the decoding schedule is the only new variable, which BD3-LM / Set Diffusion identify as a legitimate free inference-time variable.
• Full telemetry — per-task steps / opened / rewrites / resid; bit-exact W=0≡stock equivalence checks; paired exact McNemar + Wilson CIs + NFE accounting on every comparison.

---

🔍 Method overview

step t:   [ frozen forever | wet window W | frontier ▶ | masked ··· ]
              (dry ink)      (T2T gate may      opens ONE     unknown
                              rewrite tokens)    token/step    tokens

Component	Mechanism (verbatim source)
Frontier	AR commit of the leftmost mask; 1 token/step schedule (BD3-LM, ICLR 2025; Set Diffusion 2026 — schedule as a free variable)
Revision	LLaDA2.2 trained T2T gate p0 > editing_threshold & old != x0 (L-EBPO), windowed to [f−W, f)
Edit ops	SPLIT/DELETE via the model's _apply_edit_operations_with_tracking (Levenshtein Transformer lineage)
Anti-loop	The model's own _resample_to_escape_loop
Attention	The model's own block-diagonal formula, unmodified
Post-phase	Up to max_post_steps=4 steps keep the last W positions wet, then the block freezes (stock semantics, smaller budget)

Why this design? Three prior experimental rounds showed training-free revision rules are neutral-to-harmful on this model family (RemeDi: −12.5 to −26 pp, p < 0.001; CoDR: neutral), matching "Re-evaluating Confidence Remasking" (NeurIPS 2026). The trained gate was the most effective published mechanism available — so v5 wires it into the owner's wet-ink idea.

---

🔬 Experimental setup

• Base model: inclusionAI/LLaDA2.2-mini (16B MoE / 1.4B active, Apache-2.0), trust_remote_code=True
• Hardware: 2× Tesla T4 (Kaggle), one full model copy per GPU, two independent workers, priority queue + adaptive scheduler (plan_n)
• Quantization: 4-bit NF4 (bitsandbytes, double-quant, fp16 compute), eager attention
• Stack: torch 2.11.0+cu130, transformers 5.2.0, CUDA 13.0
• Protocol: GSM8K first 45 tasks, greedy T=0, gen_length=160, block_length=32, max_post_steps=4; paired offline against the completed v4b run (identical model, quant, prompts)
• Run: started 2026-11-07 11:46:56 UTC; 6 h 04 m of a 7.5 h budget; 77 generations across 3 arms; mechanics verified (ids_equal=True, resid=0 in all 77 generations)

---

🤗 Usage

The decoder is a self-contained Kaggle kernel (kernel_v5.py in this repo, 1 153 lines: two-GPU workers, benchmark harness, telemetry, McNemar analysis). The core API:

from kernel_v5 import wetink_generate

out_ids, nfe, stats = wetink_generate(
    model,                    # LLaDA2.2-mini, trust_remote_code=True, NF4
    input_ids,
    gen_length=160,           # generation budget
    block_length=32,          # block-diagonal attention blocks
    window=16,                # W: wet window behind the frontier (v5 main arm)
    editing_threshold=0.0,    # the model's own trained T2T gate threshold
    max_post_steps=4,         # drying-tail steps after the block resolves
    temperature=0.0,          # greedy (deterministic)
    eos_early_stop=True,
)

Reproduce the full GSM8K evaluation on Kaggle (2×T4, ~7.5 h): push kernel_v5.py as a Kaggle script kernel with GPU + internet enabled; it writes results_v5.json. Baselines and the paired analysis live in the GitHub repo (results/results_v4.json, scripts/analyze_v5.py).

Best practices

1. window=16 is the default arm; window=8 halves the wet span at no measured quality change (n=10).
2. Expect NFE ≈ one forward per committed token (~160–210 per task at gen_length=160) — budget accordingly.
3. Keep temperature=0.0 for determinism; the equivalence checks assume greedy decoding.
4. trust_remote_code=True and eager attention are required (SDPA rejects the bf16 editing mask).

---

⚠️ Limitations (honest)

1. Quality-neutral, cost-positive. Third consecutive round where inference-time revision does not beat the stock decoder on this family: training-free rules hurt (v3), the trained stock gate is neutral (v4b), the sliding window with the same gate is neutral (v5, p = 1.0). The ×4.88 NFE is structural.
2. Small n. 45 / 22 / 10 tasks per arm; Wilson CIs are wide (±12 pp). Detecting a ±5 pp effect needs n ≥ 500 per arm.
3. Truncation confound. gen_length=160 truncates most generations; in v4b, among naturally EOS-terminated generations 96% were correct — absolute accuracies here underestimate the model.
4. Untried regimes. Long blocks (64/128), larger W on longer generations, and a k>1-token frontier (NFE ÷ k) are future work (v6 direction).

---

🗺️ Version history (the full journey is in the GitHub repo)

Version	Base	Approach	Outcome
v1	Nemotron-Labs-Diffusion-3B	confidence-gate re-masking each stock step	+quality, 13× NFE churn explosion (broke the termination invariant)
v2	Nemotron-Labs-Diffusion-3B	full published revision cycles (RemeDi / CoDR)	guaranteed termination; RemeDi harmful at short blocks
v3	Nemotron-Labs-Diffusion-3B	full benchmark, n=200+164	RemeDi −19.5..−31.5 pp (p<0.001), CoDR neutral
v4b	LLaDA2.2-mini	stock generate() parameter study (12 arms, n=403)	stock T2T gate neutral, −15% NFE; stock ≠ wet-ink (window doesn't slide)
v5	LLaDA2.2-mini	own wet-ink frontier decoder (this work)	paired-identical to stock (p=1.0) at ×4.88 NFE; mechanism fully verified

---

📄 Paper

Read the paper as a website — wetink.space-z.ai: title, abstract, all sections, linked artifacts, citation export and a discussion board, in three languages (English · Русский · Oʻzbek), in the style of a Hugging Face Papers page.

📚 Provenance — every formula has a source

Element	Source (used verbatim)
T2T gate p0 > editing_threshold & old != x0	LLaDA2.2 _joint_decode_block (L-EBPO)
SPLIT/DELETE edit operations	LLaDA2.2 _apply_edit_operations_with_tracking (Levenshtein Transformer lineage, Gu et al. 2019)
Block-diagonal attention, _diffusion_sample, KV-crop	LLaDA2.2 generate() / _crop_dynamic_cache
1-token/step left-to-right schedule	BD3-LM (Arriola et al., ICLR 2025), Set Diffusion (2026) — schedule as a free variable
Calibration of expectations	"Re-evaluating Confidence Remasking" (arXiv:2606.12232, NeurIPS 2026)
Rejected after measurement	RemeDi (arXiv:2509.23653), CoDR (arXiv:2610.08833), ProSeCo, GIDD, Diffusion Forcing

Base model: inclusionAI/LLaDA2.2-mini — Levenshtein Editing via L-EBPO, Apache-2.0. Its weights are not redistributed here; load them from the original repo.

---

🤝 Contact & collaboration

Code, full data (v1→v5), tests and the technical report: github.com/Asilbekov/Explore · Paper website (EN / RU / UZ): wetink.space-z.ai

Questions, replications and counter-experiments are welcome — open an issue on GitHub.

Citation

@techreport{asilbekov2026wetink,
  title  = {Wet-Ink: a Sliding-Window Frontier Decoder for Diffusion Language Models},
  author = {Asilbekov, Ozodbek},
  year   = {2026},
  url    = {https://github.com/Asilbekov/Explore},
  note   = {Technical report; paired evaluation on GSM8K with LLaDA2.2-mini}
}

License

Code in this repository: MIT. The base model's weights remain under their original license (inclusionAI / Apache-2.0) and are not included.