In this categoryLocal AI · 75
More guides
Local AIIntermediate

How to Run Linum-AI/pjit-21k Locally: A Text-to-Image Model Trained for $21,000

pjit-21k is a 2.18 billion parameter text-to-image research model from Linum, trained for about $21,000 in compute and released November 3, 2026 under Apache 2.0. It runs from a Python script with a Claude-powered prompt upsampler, but it cannot render text, signs, or posters.

7 minIntermediate

pjit-21k, also called P-JiT 21K, is a 2.18 billion parameter text-to-image model from the two-person research lab Linum. It was trained on 660 million images for roughly $21,000 in compute and released November 3, 2026 under the Apache 2.0 license. It runs from a single Python script on a CUDA GPU, writes dense scene descriptions rather than short tags, and by its own model card cannot render text, signs, or posters.

Linum built it as a stepping stone toward a video model, not as a finished product. The appeal for anyone running local AI is the price tag: a 2 billion parameter diffusion model that produces coherent portraits and scenes for the kind of compute budget a hobbyist project might actually hit, released with the weights, the code, and the training recipe out in the open.

Written by Priya Raghunathan, local-AI hardware reviewer. I verify parameter counts, licenses, hardware requirements and every command against the primary source before recommending a setup path.

At time of writing, the Linum-AI/pjit-21k model page shows 49 likes and 212 downloads. The GitHub repo has 52 stars, and the top linked Hugging Face Space, a VRAM and GPU cost calculator, has 31 likes. It's a small research drop only days old, but the training cost story is unusual enough to climb the trending list fast.

Specs at a glance

FieldValue
PublisherLinum (Linum-AI)
PipelineText-to-image
Parameters2.18B (DiT, safetensors)
Weightsmodel.safetensors, fp32, 8.7 GB
ArchitectureP-JiT (Pyramid-JiT), post-trained with a FDFO variant
Text encoderQwen3.5-4B, frozen, downloads separately
Training data660M samples (610M at 512px, 50M at 1024px)
Training costAbout $21,000 in compute
Output sizes1024x1024, 864x1216, 1152x864, 1248x832, 1280x720
LicenseApache 2.0
Release dateNovember 3, 2026
Research checkpoint, and it can't write text
Linum's own model card calls this an experimental research artifact, not a production model, and warns of rough edges. It also cannot render text, signs, logos, or posters, because the training data had infographics, book pages, slides, and posters filtered out on purpose. Prompts asking for words on screen or in the scene will not work.

Why a $21,000 training run is the headline

Most open text-to-image models with useful output quality come from labs running training budgets in the hundreds of thousands to millions of dollars. pjit-21k is a direct test of how far a small team can push a 2 billion parameter diffusion transformer on a fraction of that, using the P-JiT architecture and 660 million training samples split across 512px and 1024px resolutions. Linum frames the result as encouragement for other small teams to experiment with efficient training methods instead of assuming scale is the only lever.

Research checkpoint: this is an experimental research artifact, not a production model.

pjit-21k model card README (Hugging Face)

Setting it up

The model ships as a single DiT checkpoint plus a config file, run through a Python script that handles sampling. Clone the repo and install it in editable mode first.

bash - clone and install pjit-21k
$git clone https://github.com/Linum-AI/pjit-21k && cd pjit-21k
$pip install -e .
$

The model was trained on dense captions of 50 to 80 words, not short tags, so prompts need to describe a scene in that kind of detail to get good results. The repo includes a working example that generates a portrait using a full caption and the --no_upsample flag, which skips the prompt rewriting step entirely.

bash - generate from a full caption, no upsampling
$PROMPT="Close-up portrait of an elderly Middle Eastern woman looking calmly into the lens, her face filling the tall frame. A cream headscarf and the collar of a dark green cardigan frame her chin. Soft overcast daylight smooths the fine lines of her skin, and the olive grove behind melts into silvery blur."
$python generate.py --no_upsample --aspect_ratio tall --seeds 2 --prompt "$PROMPT"
writes outputs/seed_2.png
$

Writing short prompts instead, with the Claude-powered upsampler

Typing a 50 to 80 word caption for every image gets old fast, so the repo ships a prompt upsampler that rewrites a short prompt into a dense caption using Claude Opus 5.5 through OpenRouter. That path needs an OpenRouter API key set as an environment variable; leaving upsampling on is the default, and --no_upsample is what turns it off.

bash - generate from a short prompt with upsampling on
$export OPENROUTER_API_KEY=...
$python generate.py --prompt "oil painting of weathered fisherman smoking a pipe" --aspect_ratio square --seeds 0
$
Sampling defaults
The model samples with 50 Euler steps, adaptive projected guidance at scale 15 against an empty negative prompt, and initial noise at scale 4. Text is encoded by a frozen Qwen3.5-4B, which downloads separately from the 8.7 GB DiT checkpoint, so plan for both when sizing a GPU.

Because the DiT and the text encoder are separate downloads with separate memory footprints, it's worth checking total VRAM before buying hardware for this specifically. The VRAM and GPU cost calculator Space linked from the model card is built for exactly that kind of estimate.

Where it falls short

A 2 billion parameter DiT paired with a 4 billion parameter text encoder is small by current text-to-image standards, and the model card is direct about the tradeoffs. It struggles with full-body shots, scenes with many entities like six cars or a crowd, interactions between several people, and world knowledge of the kind that trips up small models generally, such as the number of strings on a guitar or the dots on a die.

FAQ

What is Linum-AI/pjit-21k?

It is a 2.18 billion parameter text-to-image diffusion model from the research lab Linum, trained for about $21,000 in compute and released November 3, 2026 under the Apache 2.0 license. Linum built it as a step toward a future video model.

Can pjit-21k generate text, logos, or posters?

No. The training data had images containing rendered text filtered out on purpose, so the model has little to no ability to produce readable words, signs, logos, or posters.

Do I need an OpenRouter API key to use it?

Only if you want to type short prompts and let the bundled upsampler expand them into the dense 50 to 80 word captions the model was trained on. Pass --no_upsample and write the full caption yourself to skip that dependency.

Is pjit-21k ready for production use?

No. Linum's model card labels it a research checkpoint, not a production model, and says to expect rough edges.

Where to go from here

Local models run better with more VRAM. CompareRTX GPUs on Amazonbefore you upgrade.(affiliate link. We may earn a commission at no extra cost. Disclosure)

Watch related tutorials

Free weekly email

Weekly local AI drops

New models, what runs on your hardware, and the guides to set them up. One email a week, unsubscribe any time.

Tags
#linum-ai pjit-21k#p-jit 21k text-to-image#run pjit-21k locally#cheap text-to-image model training#apache 2.0 diffusion model#pyramid-jit architecture