README.md

---
license: apache-2.0
pipeline_tag: text-to-image
library_name: jit-ddt
tags:
  - diffusion-transformer
  - pixel-space
  - text-to-image
---

# JiT-DDT

**Code:** [github.com/Linum-AI/jit-ddt](https://github.com/Linum-AI/jit-ddt)
 ·  **Blog post:** [Training Text-to-Image Models 3.6x Faster](https://www.linum.ai/field-notes/jit-ddt)

![Linum v2 versus JiT-DDT on the same prompt, with GPU-hours and samples seen](assets/summary.png)

*The same prompt from Linum v2 (2.0B latent-space DiT + VAE, 256x256) and from JiT-DDT
(pixel-space, 512x512). JiT-DDT reached this quality in 3.6x fewer GPU-hours and 4.2x fewer
samples, at 4x the pixels. The write-up is in the
[blog post](https://www.linum.ai/field-notes/jit-ddt).*

> **This is a research artifact, not a full model release.** This model was
> trained for 138M samples and has not been post-trained. Rather, this is a research preview on
> the road to our v3 model. We're releasing it because we want to share our preliminary findings
> with the broader field and encourage others to explore efficient training methods like ours.

JiT-DDT is a 2.5B-parameter pixel-space text-to-image diffusion transformer from Linum: an
encoder DiT (64x64-pixel patches, produces a structural plan) and a decoder DiT (32x32-pixel
patches, consumes the plan in-context) trained jointly, generating 512x512 RGB images with
no VAE. Captions are encoded with Qwen3.5-4B (hidden layers 7/15/27 concatenated).

Code, sampler, reference loss, and the inference code:
[github.com/Linum-AI/jit-ddt](https://github.com/Linum-AI/jit-ddt).

## Files

| File | Contents |
|---|---|
| `model.safetensors` | EMA weights, fp32, 598 tensors, 2,487,506,290 parameters (9.95 GB). Keep fp32: the model runs its fp32 master weights under bf16 autocast, which is what the samples in this card were generated with. |
| `config.json` | Architecture, text-encoder recipe, sampler defaults, and provenance (source checkpoint step, EMA half-life). |
| `export_manifest.json` | Export audit: dropped training-only tensors, key renames, weights SHA256. |

## Usage

```bash
git clone https://github.com/Linum-AI/jit-ddt && cd jit-ddt && pip install -e .
PROMPT="A close-up portrait of a young white woman with vibrant, fiery red hair cascading over \
her shoulders in soft waves, framed from the shoulders up and centered against a softly blurred \
warm-toned background. Her fair, lightly freckled complexion sets off piercing green eyes and a \
subtle, closed-lipped smile. Soft natural light enters from the left of the frame, highlighting \
the texture of her hair and the curve of her cheek while leaving the right side in gentle shadow. \
A shallow depth of field renders the background into smooth, neutral bokeh. Lights dangle out of \
focus on the left side of the frame."
python generate.py --weights Linum-AI/jit-ddt --qwen_model_path Qwen/Qwen3.5-4B \
    --prompt "$PROMPT" --seeds 42
```

```python
from jit_ddt import JitDDT, QwenTextEncoder, SamplerConfig, generate

model = JitDDT.from_pretrained("Linum-AI/jit-ddt")          # downloads from the Hub
text_encoder = QwenTextEncoder("Qwen/Qwen3.5-4B")
prompt = (
    "A close-up portrait of a young white woman with vibrant, fiery red hair cascading over her "
    "shoulders in soft waves, framed from the shoulders up and centered against a softly blurred "
    "warm-toned background. Her fair, lightly freckled complexion sets off piercing green eyes and "
    "a subtle, closed-lipped smile. Soft natural light enters from the left of the frame, "
    "highlighting the texture of her hair and the curve of her cheek while leaving the right side "
    "in gentle shadow. A shallow depth of field renders the background into smooth, neutral bokeh. "
    "Lights dangle out of focus on the left side of the frame."
)
images = generate(model=model, text_encoder=text_encoder, prompt=prompt, seeds=[42],
                  sampler=SamplerConfig())
```

The prompt above is the `woman_red_hair` validation prompt used throughout training and in the
blog post.

Sampling: 50 Euler steps, adaptive projected guidance at scale 15, initial noise scale 2.

## Provenance

Weights are the EMA (half-life 6,594 steps) trained on 138M image samples in two stages
(logit-normal timesteps (0.8, 0.8) then (-0.2, 1.0)).

The 241M-parameter PixelREPA masked transformer adapter (training-only, the representation-
alignment loss's projection head) is not included; a reference implementation is in the
code repository's `loss.py`.

## Authorship

This model card, and the code repository it points to, were written by Claude (Anthropic's
Fable 5.1 model, running in Claude Code) at Linum's request: it extracted the model, inference
code and training loss from Linum's internal experiment repository, exported these weights,
and verified that they reproduce the training-time validation images bit-for-bit. The model,
its training, and the review of this release are Linum's.

## License

Apache-2.0. Copyright 2026 Linum Inc.