P-JiT-21K-ComfyUI

P-JiT-21K-ComfyUI

Generates images from text prompts inside ComfyUI, using Linum's 2B-parameter P-JiT 21K model in bf16 and int8 files that run from 4 GB of free VRAM. It suits ComfyUI users with modest GPUs.

Made by PedroMarinhoDev on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: P-JiT-21K-ComfyUI packages Linum's P-JiT 21K text-to-image model as bf16 and int8 files for ComfyUI. P-JiT is a 2B-parameter model that draws straight in pixels and needs no VAE. Through the ComfyUI-PJiT nodes, generation uses ComfyUI's regular sampler and memory handling and needs only 4 GB of free VRAM.

Who it suits: It suits ComfyUI users who want to generate images on a modest GPU and are happy to install custom nodes.

Industry | Who uses it | How they use it | Example
Design | Visual designers | Generate concept images from written captions | A caption about a Mediterranean street after rain
Creative hobby | ComfyUI enthusiasts | Run a small pixel-space model on a mid-range card | Using the int8 files on a 4 GB card
Research | Image model researchers | Compare file precisions and text encoders | Reading the card's comparison of bf16, int8 and fp32

People who use other front ends can skip it, since the files are made for ComfyUI.

Where to use it:

• ComfyUI version 0.44 or newer, with the ComfyUI-PJiT custom nodes
• A computer with a GPU, from 4 GB of free VRAM
• Windows, macOS or Linux, wherever ComfyUI runs

Use case | Who | What they get back
Text to image | Designers and hobbyists | Images drawn from captions of 50 to 80 words
Refining an image | ComfyUI users | A refiner pass that reworks an image at low denoise
Prompt upsampling | Casual users | A workflow that expands a short prompt into a caption

How to set it up:

• ComfyUI 0.44 or newer
• The ComfyUI-PJiT custom nodes, cloned into the custom_nodes folder with no pip install
• A GPU with at least 4 GB of free VRAM
• Disk space for the model and a text encoder, from about 2.33 GB and 3.16 GB

1. Install the ComfyUI-PJiT nodes and restart ComfyUI.
2. Download the model and a text encoder files into the models folder.
3. Open the pjit_text_to_image template and run it.

pip install -U huggingface_hub

cd ComfyUI/models
hf download PedroMarinhoDev/P-JiT-21K-ComfyUI diffusion_models/pjit_21k_bf16.safetensors --local-dir .
hf download Comfy-Org/Qwen3.5 text_encoders/qwen3.5_4b_bf16.safetensors --local-dir .

How to use it: Open the ComfyUI-PJiT templates and pick pjit_text_to_image. Linum's settings are already filled in, with 50 steps, the euler sampler, the simple scheduler, a cfg of 15 and an empty negative prompt. Write captions of 50 to 80 words. There is no VAE file, because the built-in pixel_space option in Load VAE serves as the VAE.

Tool | What it does
pjit_21k_bf16 | The main model at 4.37 GB, matching Linum's fp32 pixels at half the size
pjit_21k_int8_convrot | A 2.33 GB model, about 1.8 times faster on GPUs with int8 kernels
qwen3.5_4b_int8_convrot | A text encoder of 4.72 GB, with caption embeddings 2 percent off
qwen3.5_4b_w4a8 | The smallest text encoder at 3.16 GB, with embeddings 14 to 16 percent off

Example: You write a 60-word caption of a lighthouse at sunset and run the template with the default settings. The model draws the image directly in pixels after 50 steps. On an RTX 3090 at 1024 by 1024, the card measures about 0.34 seconds per step for the bf16 file.

For newcomers and experts: A text-to-image model turns a written description into a picture. A good first step is to use the bf16 model with the bf16 text encoder and the default template, then try the int8 files if you need more speed.

P-JiT works in pixel space, so no VAE decodes the result. The card says bf16 gives the same pixels as the fp32 release at half the size, while int8 trades some fine detail for speed. Among the text encoders, the W4A8 file changes faces the most.

You write a 50 to 80 word caption
Qwen3.5-4B text encoder reads it
P-JiT draws directly in pixels
Optional refiner pass polishes the image

Good to know:

• License: Apache 2.0.
• Cost to run: none named. You need your own GPU with at least 4 GB of free VRAM.
• Data it reaches: it downloads files from the Hugging Face Hub, then generates images on your own machine.
• Not for: other front ends, or work that needs the finest facial detail with the smallest text encoder.

Title: Seconds per step on an RTX 3090 at 1024 by 1024
pjit_21k_bf16: 0.34 seconds
pjit_21k_int8_convrot: 0.19 seconds
Linum's fp32 release: 0.35 seconds

On Hugging Face, 13 November 2026

• Task: text to image
• Library: comfyui
• Downloads in the last 30 days: 0
• Likes: 3
• License: apache-2.0
• Based on: Linum-AI/pjit-21k
• Tags: comfyui, text-to-image, pixel-space, pjit, int8, convrot

Links

• Model: https://huggingface.co/PedroMarinhoDev/P-JiT-21K-ComfyUI
• Files: https://huggingface.co/PedroMarinhoDev/P-JiT-21K-ComfyUI/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download PedroMarinhoDev/P-JiT-21K-ComfyUI

Then follow the usage in its model card. Nothing in this kit runs by itself.