Linum, a Two-Person Lab, Open-Sources a Text-to-Image Model Trained for $21K

TL;DR

P-JiT 21K is a 2.18B-parameter, pixel-space text-to-image model that Linum, a lab run by two brothers, trained end to end for $21,038 and released November 4 under Apache 2.0. Weights, inference code, and a write-up that publishes every training setting down to the EMA half-life are all public. The 249-image gallery is well above what two people and $21K were supposed to buy. It cannot render text, it mangles crowds, and no external benchmark exists, but as a datapoint on what training an image model costs, this is the cleanest public artifact in months.

What the release contains

Three pieces, all Apache 2.0. The weights are on Hugging Face: an 8.7 GB fp32 DiT plus a frozen Qwen3.5-4B text encoder that downloads separately. The inference repo clones and runs; generate.py works with no API key if you hand it a full caption. And the field-notes post publishes the recipe: losses, noise schedules, optimizer settings, batch sizes, EMA half-lives, and the invoice.

The model generates at five roughly 1 MP sizes, from 1024x1024 to 1280x720, sampling 50 Euler steps with adaptive projected guidance at scale 15. It was trained on dense captions of 50 to 80 words, so short prompts degrade; the repo ships an upsampler that expands your prompt into a proper caption using Claude Opus 5.5 through OpenRouter, and --no_upsample skips it. The Hacker News thread reached 161 points.

One disclosure you rarely see: the authors, Sahil and Manu Chopra, state that Claude Opus 5.5 wrote the repo and model card from their internal experiment code, with both brothers reviewing. The training itself ran the old-fashioned way, two humans and 64 rented H100s.

No VAE, no decoder

Nearly every image model you can name is a latent diffusion model. A separately trained VAE squeezes images into a compact space, the diffusion model learns to generate inside that space, and a VAE decoder turns latents back into pixels. The compression is what makes attention affordable, and attention, being O(n²), decides the bill.

Linum's argument, built up over earlier posts, is that the borrowed latent space has a ceiling: VAEs compress only so far, and better reconstruction can even produce worse downstream generations. Standard latent diffusion is editing a photo through a JPEG a stranger compressed for you: cheaper to move, and the artifacts never come out. P-JiT works on the raw pixels.

Mechanically: images are cut into 32x32 patches, each a 3,072-value RGB block projected into 1,024 dimensions, a 4x more aggressive reduction than the 16x16 grid their previous model and most latent models use. A 512² image becomes 256 image tokens instead of 1,024. During training, readout heads after trunk blocks 10 and 16 predict the clean image at quarter and half resolution, which hands the early layers a gradient signal instead of making them wait for the end of the network. The authors report the architecture converges in 11x fewer samples than their previous latent model, Linum v2. That figure is a comparison against their own baseline, so read it as a claim with an invoice attached.

The bill, to the dollar

Pretraining cost $20,348: 8,139 H100-hours at $2.50 an hour, 610M samples at 512² followed by 50M at 1024², run on 64 H100s under FSDP2. Post-training, a variant of FDFO with human judges in the loop, added $690. Total: $21,038, or 8,415 H100-hours, roughly a frontier lab's coffee budget.

The optimizer pairing is Muon on the 2D weight matrices with AdamW on everything else, and the appendix documents details like a spike-aware EMA that pauses for 250 steps when the gradient norm jumps 10x. A separate repo, pyramid-jit, holds the reference implementation of the pretraining objective. Reproducing the run is not free, but nothing about it is secret, which is rarer than it should be.

The failure gallery

The release ships its own mugshots. Full-body poses bend legs the wrong way, six cars morph into one another, crowds grow extra hands, and a die comes up sixes on every face. The model has seen almost no rendered text, because Linum filtered infographics, PDFs and slides out of the dataset as useless for animation, so prompts asking for words or posters return a text_requested error rather than garbage glyphs. Commenters on HN flagged oversmoothing and an uncanny shine, and asked where 660M training images came from. At the time of writing, the brothers had not answered in the thread.

Running it on a Mac mini

The reference path wants a CUDA GPU: 8.7 GB for the DiT in fp32, plus 8 GB for the text encoder. The more interesting port for homelab people is the third-party MLX export that appeared within a day. On a Mac mini M4 Pro it renders one 1152x864 image in 72 seconds at 6.7 GB peak memory, 5.6 GB with the low-memory flag, through the pjit-mlx runner. The port reproduces Linum's gallery images from the published seeds, median PSNR 35 dB across 15 tested prompts.

A 2B DiT with a frozen 4B text encoder is small enough to own outright, and that framing is what the HN thread picked up. One commenter argued big labs avoid efficiency work precisely because compute is their moat, while a two-person shop lives on it.

What to steal if you train things

• Publish the invoice next to the claim. "$21K" lands because 8,415 H100-hours at $2.50 an hour sit directly under it.
• Curate failures, not only wins. Named failure modes with example images are what made the gallery believable.
• Question the two-stage pipeline. If a VAE caps compression, the expensive part of video modeling, deleting it is now a tested option with public code.
• Train on the captions you will serve. Dense 50-80 word captions made a better model and cost one API call at inference.

Caveats

• No external benchmark appears anywhere in the release. "Decent" is the authors' adjective, backed by a curated gallery and in-house judges.
• The 11x convergence figure compares P-JiT to Linum's own earlier model, not to a public baseline.
• The training dataset is undisclosed, and licensing questions in the HN thread were unanswered at the time of writing.
• Adoption is a day old: 68 downloads and 21 likes on Hugging Face, 25 stars on GitHub, 15 comments on HN.

Key Takeaways

• Linum, a two-person lab run by brothers Sahil and Manu Chopra, released P-JiT 21K on November 4: a 2.18B-parameter pixel-space text-to-image model trained for $21,038, under Apache 2.0, with weights, code and the full training recipe public.
• The bill: $20,348 for pretraining (8,139 H100-hours at $2.50, 660M samples across 512² and 1024² stages on 64 H100s) plus $690 of FDFO-style post-training with human judges.
• No VAE anywhere: 32x32 patches turn a 512² image into 256 tokens, 4x fewer than a 16x16 latent grid, and readout heads after blocks 10 and 16 keep early layers learning.
• Stated limits: no text rendering (that data was filtered out on purpose), and full-body poses, many-entity scenes and world knowledge fail in documented ways.
• A third-party MLX port runs it on Apple Silicon: 72 seconds per 1152x864 image on an M4 Pro at 6.7 GB peak memory, seed-exact against the release gallery.
• The Hacker News reception, 161 points, treats it as a training-economics datapoint: two people, from scratch, 8,415 H100-hours.

Sources: Linum field notes, GitHub repo, Hugging Face model card, Hacker News thread, MLX port, pjit-mlx runner