Two people, 64 Nvidia H100 GPUs and roughly $21,000 in compute. That’s what it took Linum, a two-person research lab run by brothers Sahil and Manu Chopra, to train P-JiT 21K, a 2-billion-parameter text-to-image model they’ve now put out with open weights under the Apache 2.0 license. In a field where the headline numbers usually come with a lot more zeros, that price tag is the real story here.
The weights went up on Hugging Face on November 3, the lab’s Field Notes write-up followed on November 4, and the release is now picking up wider coverage, including a GIGAZINE piece dated November 9. The inference code is on GitHub. Before anyone gets too excited, Linum is upfront that this is a research checkpoint, not a polished Stable Diffusion or FLUX competitor. But it’s an interesting one, and the reasons why matter for anyone who cares about AI that small teams and hobbyists can actually build and run.
What makes P-JiT different
Most modern image generators don’t work on pixels directly. They lean on a separate compression model, usually a variational autoencoder (VAE), that squeezes an image into a smaller “latent” representation. The diffusion model does its work in that latent space, and the VAE decodes the result back into a picture at the end. It’s efficient, but it means the image model is stuck with whatever compression the VAE was built for.
Linum’s bet is to throw the VAE out entirely. P-JiT (short for Pyramid-JiT) is a pixel-space diffusion transformer: it chops an image into 32×32-pixel patches and learns its own compression as part of generating the image. According to the lab, that lets it represent a 512×512 image with the same number of tokens its previous model, Linum v2, needed for a 256×256 one. Since attention cost grows with the square of the token count, fewer tokens is a big deal. Linum says the architecture uses a 4× smaller attention context and converged in about 11× fewer training samples than Linum v2.
The “pyramid” part comes from extra readout heads placed partway through the network that predict quarter- and half-resolution versions of the final image during training. The idea, per Linum, is to give the early layers a stronger learning signal so the model gets to good results faster. Those helper heads are only used in training and aren’t part of the released model, which works out to about 2.18 billion parameters. Text understanding comes from a frozen Qwen3.5-4B language model acting as the text encoder.
Where the $21K actually went is laid out in unusual detail. Pretraining took 8,139 H100-hours on 64 GPUs: 610 million samples at 512px, then 50 million at 1024px. Post-training added another 276 H100-hours. At the $2.50-per-hour rate Linum used for its math, that’s $20,348 plus $690, or $21,038 total, restarts included. That’s a sensible way to report it, though it’s worth remembering it’s a compute bill. It doesn’t count the salaries, the data pipeline, or the earlier experiments that got the architecture to this point.
The sample gallery is genuinely good for a model this size. Portraits, food, animals, landscapes and storybook-style illustrations all look clean and natural in the official examples. As always with a lab’s own picks, those are the best results, not the average one.
The fine print: no text, short prompts and NVIDIA-only
This is where the grounded part comes in, because the limitations are real and Linum doesn’t hide them.
First, P-JiT can’t render text. At all. The team deliberately filtered infographics, slides, posters and book pages out of the training data because they don’t help its long-term goal of animation tools. If you ask for a sign, logo or title card, the included prompt helper returns an error instead of trying. If you were hoping for a free poster or thumbnail generator, this isn’t it.
Second, it struggles with the stuff small models always struggle with. Linum lists full-body shots, scenes with many objects (six cars, crowds), multiple people interacting, and world knowledge like the right number of guitar strings or the dots on a die. The write-up even shows a sprinter with mangled legs on the starting blocks as an example failure. The team thinks a bigger model of around 7B parameters and more post-training would help.
Third, prompting takes some work. The model was trained on dense, 50- to 80-word captions, and short prompts give noticeably worse images. By default, the included script sends your prompt to Anthropic’s Claude Opus 5.5 through OpenRouter to rewrite it into a long caption, which needs an API key and a paid cloud call. You can skip that with a flag and write the detailed caption yourself, and that’s what I’d recommend if the whole point for you is running locally. Still, it’s a little ironic that a model pitched on cheap, local generation leans on a big cloud model by default.
Fourth, hardware. The README says it needs a CUDA GPU, so it’s built for NVIDIA cards. The image model weights are 8.7 GB in FP32 and the text encoder adds about 8 GB in BF16, plus memory for the actual generation. Linum doesn’t publish a minimum VRAM figure, but with nearly 17 GB of weights before activations, this doesn’t look like an 8 GB-card model as shipped. Owners of other GPUs will have to wait for community ports. Generation also isn’t quick by today’s distilled standards: the default sampler runs 50 steps at about 1 megapixel, and Linum doesn’t give speed numbers for consumer cards.
One more piece of transparency that’s easy to miss: Linum says the GitHub repo and Hugging Face model card were written by Claude, which pulled the inference code out of the lab’s internal experiment repository. The model, training and review are credited to Linum. It’s a sign of how small teams are shipping in 2026, and I’d rather a lab say so than leave people guessing.
Cody’s take
I’m excited about this one, but not because P-JiT is going to replace anyone’s go-to image model. It won’t. It can’t write a word, it trips over crowds and full-body shots, and its default setup depends on a paid cloud API. If you just want the best pictures on your own PC today, the established open models with big community ecosystems are still the practical choice.
What gets me is the receipt. Linum published the architecture, the training schedule, the noise curriculum, the hardware and a line-by-line cost breakdown, then released the weights under Apache 2.0 so anyone can poke at them commercially or otherwise. That’s rare. Most image model launches tell you how good the results are and almost nothing about what it cost to get there. A credible “$21K for a 2B model” data point gives university labs, indie researchers and small startups a realistic target.
It’s also a stepping stone, not the destination. Linum says the whole point is cheaper, more controllable video generation for animation tools, and this image model is the “learn the nouns before the verbs” phase. Whether the VAE-free, pixel-space approach holds up at video scale is the real test, and we won’t know until that model shows up. Until then, P-JiT 21K is a fun download for anyone with a capable NVIDIA card and a willingness to write long prompts, and a pretty strong argument that you don’t need a giant lab to do meaningful generative AI research.
