---

license: apache-2.0 language:

• en base_model: Linum-AI/pjit-21k base_model_relation: quantized pipeline_tag: text-to-image tags:
• comfyui
• text-to-image
• image-generation
• diffusion
• pjit
• low-vram
• safetensors
• bf16
• rebel-ai

---

P-JiT 21K — ComfyUI | Rebel AI

P-JiT 21K model weights and custom ComfyUI integration, brought to the community by Rebel AI.

This repository provides P-JiT 21K model files for use with a dedicated ComfyUI implementation. The custom nodes integrate Linum's P-JiT architecture, Qwen3.5-4B text conditioning, and the original Euler/APG sampling pipeline.

The goal is to make P-JiT 21K easier to run locally, including on consumer GPUs.

Custom ComfyUI Nodes

GitHub: https://github.com/RealRebelAI/ComfyUI-PJiT21K-Rebel

Install the custom nodes from GitHub to use the model in ComfyUI.

cd ComfyUI/custom_nodes
git clone https://github.com/RealRebelAI/ComfyUI-PJiT21K-Rebel.git

Follow the installation instructions in the GitHub repository to install the required dependencies and upstream P-JiT implementation.

Model Downloads

Hugging Face: https://huggingface.co/realrebelai/P-JiT-21k_ComfyUI

Download the appropriate model checkpoint from the repository's Files and versions tab.

Place the checkpoint in the model directory supported by the custom nodes.

Required Components

• P-JiT 21K diffusion transformer checkpoint
• Qwen3.5-4B text encoder with compatible tokenizer and configuration
• Rebel AI P-JiT 21K ComfyUI custom nodes
• NVIDIA CUDA GPU for inference

Important: The text encoder must be Qwen3.5-4B. Other Qwen variants are not interchangeable.

P-JiT uses hidden states from transformer layers 7, 15, and 27, concatenated into 7,680-dimensional conditioning.

Recommended Sampling Settings

The following are the official upstream release settings, not independently optimized Rebel AI settings.

The model also supports other aspect ratios and resolutions through the custom node interface.

Low-VRAM Support

The custom nodes provide two execution modes:

Whole Model on GPU

Loads the P-JiT transformer onto CUDA for inference. Recommended when sufficient VRAM is available.

Layerwise CPU Offloading

Moves model components between CPU and GPU during execution to reduce peak GPU memory requirements.

This mode is experimental and may be slower than full GPU execution.

Actual memory requirements depend on resolution, hardware, CUDA allocations, and other loaded models.

Implementation Details

The ComfyUI integration uses:

• Linum's original P-JiT architecture
• BF16 model execution
• Qwen3.5-4B multi-layer text conditioning
• Original Euler sampling implementation
• Adaptive Projected Guidance
• CPU/GPU memory management
• ComfyUI-compatible image output

The implementation is intended to preserve the original model's sampling behavior rather than introduce a replacement sampler.

Current Status

Experimental community release

The integration has been tested locally, but additional testing and optimization are ongoing.

Known considerations:

• Output quality may vary by prompt and sampling configuration.
• Layerwise offloading requires further validation.
• Native quantized inference kernels are not currently included.
• Qwen3.5-4B is required for compatible text conditioning.

Issues and contributions are welcome through GitHub.

Credits and Attribution

Original P-JiT architecture and implementation: Linum

ComfyUI integration and community packaging: Rebel AI

Rebel AI does not claim authorship of the original P-JiT architecture or its pretrained weights.

The upstream source files identify Apache 2.0 licensing. Model-weight and dependency licenses should be reviewed separately before redistribution.

Rebel AI

Making powerful AI models accessible to everyone.

• GitHub: https://github.com/RealRebelAI/ComfyUI-PJiT21K-Rebel
• Hugging Face: https://huggingface.co/realrebelai
• YouTube: https://youtube.com/@realrebelai
• X: https://x.com/realrebelai

---

Rebel AI — Making powerful AI models accessible to everyone.