Running DeepSeek Janus Pro 1B on macOS with ComfyUI (2026 Guide)

Last updated April 2026 — refreshed for current model/tool versions.

DeepSeek Janus Pro 1B is a compact multimodal model that handles both image understanding and text-to-image generation in a single unified architecture. This guide shows exactly how to install and run it on an Apple Silicon Mac using ComfyUI, covering every step from environment setup to workflow execution — with updated Python and macOS requirements, performance benchmarks, and current troubleshooting tips.

What changed since January 2025 — key updates for returning readersPython version: The original guide warned against Python 3.11+. That restriction is outdated. ComfyUI now runs on Python 3.12 (recommended) and Python 3.13 is also well-supported. Python 3.10 still works but is no longer the target.macOS requirement lifted to Sequoia: macOS Ventura 13.4 was the floor in January 2025. The current ComfyUI Desktop (still in Beta) requires Apple Silicon and macOS 12+ (Monterey minimum), but Sonoma 14 and Sequoia 15 are the tested-and-recommended versions. Some Sequoia 15.4 users have reported GPU-related crashes with specific custom nodes — use Sonoma if you encounter them.ComfyUI Desktop now available: A one-click installer for macOS Apple Silicon is available at comfy.org/download. It handles Python, dependencies, and updates automatically — the manual pyenv/venv path is still valid for advanced control but is no longer the only option.MLX backend option: Apple's MLX framework can accelerate standard diffusion models 50–70% faster than PyTorch MPS on Apple Silicon. Janus Pro uses a transformer-based autoregressive architecture (not a standard diffusion model), so MLX does not apply to it directly — MPS remains the correct backend. See the Performance section for current MPS numbers.Janus Pro is still the current model: As of April 2026, DeepSeek has not released a Janus-Pro successor. The 1B and 7B variants released January 27, 2025 remain the latest. DeepSeek's 2026 lineup (V4, V4 Flash, R1) focuses on text reasoning; the Janus-Pro line is still listed as the active multimodal offering.ComfyUI-Janus-Pro plugin: The CY-CHENYUE plugin remains the primary integration path. It has no formal versioned releases — install via ComfyUI Manager or git clone, then pip install its requirements.txt.

TL;DR — Quick Reference

Overview: What DeepSeek Janus Pro 1B Actually Is

Janus Pro is a Multimodal Large Language Model (MLLM) built by DeepSeek and open-sourced January 27, 2025. It is not a diffusion model — it uses an autoregressive transformer architecture, the same class of model that powers text LLMs like GPT-4 and Llama 4. What makes it unusual is the decoupled visual encoding approach: separate encoders handle understanding tasks (SigLIP-L, 384×384 input) and generation tasks (LlamaGen-based tokenizer, 16× downsample rate), but both feed into a single unified transformer. This sidesteps the common problem where optimizing the encoder for one task hurts the other.

The 1B variant is built on DeepSeek-LLM-1.5B-base. The 7B variant, built on DeepSeek-LLM-7B-base, is substantially more capable but requires more RAM and is slower on consumer hardware. This guide focuses on the 1B model, which runs comfortably on any M1/M2/M3/M4 Mac with 8 GB RAM.

Key Benchmarks (from the Janus-Pro paper, arXiv 2501.17811)

Note: The 1B model trades quality for speed and memory. On GenEval it scores the same as the original (non-Pro) Janus model. If output quality is the priority and you have ≥16 GB RAM, use the 7B model instead.

System Requirements

Hardware

Intel Macs are not supported. MPS (Metal Performance Shaders) requires Apple Silicon. The ComfyUI Desktop app makes this explicit.

Software

• macOS: 12 Monterey or later. Sonoma 14 or Sequoia 15 strongly recommended.
• Python: 3.12 recommended. Python 3.10, 3.11, and 3.13 all work. The old warning to avoid 3.11+ no longer applies to ComfyUI itself, though some third-party custom nodes may still have narrow version requirements.
• Git: Required for manual plugin installation. Pre-installed on Macs that have Xcode Command Line Tools.
• Homebrew: Optional but useful for managing pyenv and system dependencies.

Installation: Two Paths

Path A — ComfyUI Desktop (recommended for most users)

ComfyUI now ships an official Desktop app for Apple Silicon. It handles Python, dependencies, and auto-updates.

1. Download the macOS installer from comfy.org/download.
2. Double-click the .dmg, drag ComfyUI to Applications.
3. On first launch, the app installs Python dependencies automatically. Expect a few minutes.
4. Once running, open a browser to http://127.0.0.1:8188.

Important Desktop caveat: Do not place models or custom nodes inside /resource/ComfyUI/. That folder is wiped on updates. Use the user data directory shown in the app's settings instead.

Path B — Manual Installation (for more control)

# Install Homebrew if not present
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install pyenv to manage Python versions
brew install pyenv

# Install Python 3.12 (recommended)
pyenv install 3.12.3
pyenv global 3.12.3

# Verify
python --version  # Should show 3.12.x

# Clone ComfyUI
git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI

# Create isolated virtual environment
python -m venv venv
source venv/bin/activate

# Install PyTorch with MPS support (stable build)
pip install torch torchvision torchaudio

# Install ComfyUI dependencies
pip install -r requirements.txt

Verify MPS is available before proceeding:

python -c "import torch; print('MPS available:', torch.backends.mps.is_available())"
# Expected output: MPS available: True

Installing the Janus Pro Plugin

Method A — ComfyUI Manager (recommended)

1. Launch ComfyUI. In the interface, click Manager.
2. Select Install Custom Nodes.
3. Search for Janus-Pro. Select the entry by author CY-CHENYUE.
4. Click Install, then restart ComfyUI.

Method B — Manual git clone

# From inside your ComfyUI directory, with venv activated
cd custom_nodes
git clone https://github.com/CY-CHENYUE/ComfyUI-Janus-Pro
pip install -r ComfyUI-Janus-Pro/requirements.txt

Restart ComfyUI after installation. The plugin nodes — JanusModelLoader, JanusImageUnderstanding, and JanusImageGeneration — will appear in the node browser.

Downloading the Model

1. Go to the Hugging Face model page: deepseek-ai/Janus-Pro-1B
2. Download all files. The total size is approximately 3 GB.
3. Place the files in the following structure inside your ComfyUI directory:

ComfyUI/
└── models/
    └── Janus-Pro/
        └── Janus-Pro-1B/
            ├── config.json
            ├── pytorch_model.bin   (or sharded model files)
            ├── tokenizer.json
            ├── tokenizer_config.json
            ├── special_tokens_map.json
            └── generation_config.json

Alternatively, use the Hugging Face CLI for a cleaner download:

pip install huggingface_hub
huggingface-cli download deepseek-ai/Janus-Pro-1B \
  --local-dir ComfyUI/models/Janus-Pro/Janus-Pro-1B

After placing the files, launch ComfyUI and open the JanusModelLoader node — the model should appear in the dropdown.

Running Your First Workflow

Text-to-Image Generation

In the ComfyUI graph editor, create the following node chain:

1. JanusModelLoader — set Model Path to Janus-Pro-1B
2. JanusImageGeneration — connect from loader; set your prompt and resolution (512×512 is a practical starting point for the 1B model)
3. PreviewImage — connect to the output

Example prompt: A quiet forest clearing at dusk, watercolor style, soft light

Useful generation parameters:

• guidance_scale: 7.0–7.5 for prompt adherence; lower (3–5) for more varied output
• temperature: 1.0 default; reducing to 0.8 produces more conservative, less creative images
• num_image_tokens: default 576; higher values increase resolution but also RAM usage

Image Understanding (Image-to-Text)

1. LoadImage — load any image from disk
2. JanusModelLoader
3. JanusImageUnderstanding — connect image and model; set your question prompt
4. ShowText (or similar text output node)

Example question: Describe this image in detail, including colors, objects, and mood.

Performance on Apple Silicon

Measured Generation Times (MPS backend)

M4 performance data is estimated from community reports; M1/M2 data from the original benchmarks and updated community tests. Exact times vary with prompt complexity and macOS background load. The M1 and M2 generation chips show similar per-core throughput for this model size.

Memory Optimization

Set this environment variable before starting ComfyUI to prevent MPS memory over-allocation:

export PYTORCH_MPS_HIGH_WATERMARK_RATIO=0.0
python main.py --use-mps

If you are on a Mac with 8 GB RAM and running other apps simultaneously, also set:

export PYTORCH_MPS_HIGH_WATERMARK_RATIO=0.0
export PYTORCH_ENABLE_MPS_FALLBACK=1

The fallback flag allows operations that are not yet implemented in MPS to silently fall back to CPU rather than crashing.

Advanced Configuration

# If editing ComfyUI/config.yaml directly
janus_pro:
  device: mps       # Metal Performance Shaders (Apple Silicon)
  precision: fp16   # Half-precision for lower memory use
  cache_dir: ~/janus_cache  # Cache model weights for faster subsequent loads

1B vs 7B: How to Choose

Both models use the same ComfyUI plugin. To switch, download the 7B weights and point the JanusModelLoader to Janus-Pro-7B.

Common Pitfalls and Troubleshooting

Diagnostic Commands

# Verify MPS is active
python -c "import torch; print('MPS:', torch.backends.mps.is_available()); print('PyTorch:', torch.__version__)"

# Check available VRAM
system_profiler SPDisplaysDataType | grep VRAM

# Check macOS version
sw_vers -productVersion

Practical Workflow Patterns

Batch API via ComfyUI REST

ComfyUI exposes a REST API at http://localhost:8188 for programmatic control. This is useful for scripted batch jobs:

import requests, json

workflow_json = {
    # Your saved ComfyUI workflow, exported as JSON
}

response = requests.post(
    "http://localhost:8188/prompt",
    json={"prompt": workflow_json}
)
print(response.json())

Hybrid Captioning + Regeneration Workflow

A productive pattern is to use Janus-Pro-1B for fast captioning (image understanding) to generate prompt text, then feed that text back into the generation pathway for variations. This round-trip runs in seconds on M2/M3/M4 hardware and does not require any additional models.

Where Janus Pro Fits in the Local AI Landscape

If your primary goal is running autonomous AI agents locally rather than single-model image tasks, see the OpenClaw + Ollama setup guide for running local AI agents — it covers orchestrating multiple local models including vision-language models into agentic pipelines on Apple Silicon.

For teams building production workflows on top of local models, Codersera connects companies with vetted remote AI engineers who specialize in exactly this kind of applied ML infrastructure.

FAQ

Does Janus Pro 1B work on Intel Macs?

No. The ComfyUI MPS backend requires Apple Silicon. On an Intel Mac, the model would run on CPU only — impractically slow for image generation. If you have an Intel Mac, consider running the model through a cloud inference endpoint or upgrading hardware.

Is Janus Pro free to use commercially?

The plugin code is MIT licensed. The model weights use the DeepSeek Model License, which allows research and commercial use but prohibits using DeepSeek outputs to train competing models and places restrictions on high-volume API services. Read the full license at the Hugging Face model page before deploying commercially.

Can I run both image understanding and generation in the same ComfyUI session?

Yes. The JanusModelLoader loads a single model instance that handles both tasks. You can build a graph that uses the same loaded model for both JanusImageUnderstanding and JanusImageGeneration nodes simultaneously without reloading weights.

What is the difference between Janus 1.3B and Janus Pro 1B?

Janus-1.3B was the original release (October 2024). Janus-Pro-1B is the improved version released January 2025, with a better training strategy, more data, and improved stability for text-to-image generation. Always use the Pro variant — the original is retained on Hugging Face but superseded.

Is there a Janus Pro 2 or newer version?

As of April 2026, DeepSeek has not released a Janus-Pro-2 or a successor multimodal generation model. The Janus-Pro-1B and 7B released in January 2025 remain the current versions. DeepSeek's 2026 model releases (V4, R1) are text-focused; the Janus line is maintained but not yet updated. Watch the official GitHub repository for announcements.

Why is ComfyUI-Janus-Pro not finding my model?

The most common cause is a path capitalization mismatch. The plugin expects the exact path models/Janus-Pro/Janus-Pro-1B/ with those exact capital letters. Linux and macOS file systems are case-sensitive. Rename the folder if needed and restart ComfyUI.

Can I use the MLX backend for Janus Pro on Apple Silicon?

Not directly. MLX acceleration in ComfyUI targets standard diffusion models (Stable Diffusion, FLUX). Janus Pro is an autoregressive transformer, not a diffusion model, so ComfyUI-MLX extensions do not apply to it. It runs on PyTorch with the MPS backend, which is still significantly faster than CPU-only inference.

How does Janus Pro 1B compare to running a vision model like LLaVA locally?

LLaVA (and its 2025/2026 successors like LLaVA-NeXT and Llama 4's vision variant) focus on image understanding only. Janus Pro 1B does both understanding and generation in one model, which is its key differentiator. For pure captioning or visual QA tasks where you do not need generation, LLaVA-style models via Ollama may be easier to integrate into existing text pipelines.

References and Further Reading

• Janus-Pro-1B — Hugging Face Model Card (deepseek-ai)
• Janus-Pro: Unified Multimodal Understanding and Generation with Data and Model Scaling — arXiv 2501.17811
• deepseek-ai/Janus — Official GitHub Repository
• CY-CHENYUE/ComfyUI-Janus-Pro — ComfyUI Plugin
• ComfyUI Desktop for macOS — Official Documentation
• ComfyUI crash on macOS Sequoia 15.4 — Known Issue Tracker
• DeepSeek Janus Pro ComfyUI Workflow — ComfyUI Wiki
• ComfyUI MLX Extension Guide — Apple Silicon Acceleration (Apatero)