Run Ideogram 4 Locally on Windows 11, Mac and Kali Linux: ComfyUI Setup, the 24 GB VRAM Rule, GGUF for 16 GB Cards and Macs, JSON Prompts, the Safety Filter and the $300 License

Ideogram 4 is the first open-weight image model from Ideogram, the company known for AI images with readable text in them. Ideogram released it on June 3, 2026: a 9.3-billion-parameter model that you download from Hugging Face and run on your own graphics card. The short answer to "can I run it?": with the nf4 build, a single 24 GB NVIDIA card is enough (Ideogram's own figure), ComfyUI has supported it natively since day one, and smaller GPUs, AMD cards and Apple Silicon Macs go through 4-bit GGUF files and stable-diffusion.cpp. Here is the detail most guides leave out, and it matters more than VRAM: the free license is non-commercial, and making a poster for your own shop counts as commercial use. The license says generating images "to advertise or promote revenue-generating products or services" is not a non-commercial purpose. The paid way out is Ideogram's self-serve commercial license, $300 a month. This page covers the hardware math for every build, the ComfyUI and Python installs on Windows 11 and Kali Linux, the honest Mac answer, fully offline prompting, the JSON prompt format with the exact errors its checker prints, the "Image blocked by safety filter" problem, the license, and the cheapest AWS machine for it.

Jake's phone repair shop needed a Diwali sale poster with "DIWALI SCREEN SALE" spelled right across the top, which is exactly what most image models get wrong. His developer friend Ethan had read that Ideogram 4 was open and set it up on his gaming PC one evening. The headline came out letter-perfect on the third try. Then Ethan opened the license file, read one paragraph twice and turned the monitor toward Jake. "This one is free for your daughter's science fair poster," he said. "For the shop poster, it is three hundred dollars a month." This page is the full setup Ethan did, the errors he hit on the way, and that paragraph.

New to running models on your own machine? Our free plain-English series explains the words used here (weights, VRAM, quantization, virtual environments) in about an hour. You need an NVIDIA graphics card for the two main routes on this page, or a Mac or AMD card for the GGUF route.

What Ideogram 4 is, in plain English

Ideogram 4 turns a description into a picture, like every image model. What sets it apart is that it was trained on structured captions: a JSON description that says what the image is, how it looks, what colors to use, and where each object and each piece of text sits on the canvas. You can still type a plain sentence; a helper called Magic Prompt rewrites it into that JSON for you. The payoff is control you rarely get from an open model: exact text on signs and posters, objects placed inside bounding boxes you choose, and a color palette given as hex codes.

Under the hood there are four parts, and knowing them explains every memory number later on this page:

• The main transformer (9.3B parameters, 34 layers), which draws the image.
• A second, "unconditional" transformer of the same size. Ideogram 4 uses two models for guidance: one that follows your prompt and one that does not, and the difference between them steers the image. This is why you download two 9 GB files, and why "ideogram 4 unconditional" is such a common search.
• The text encoder, Qwen3-VL-8B-Instruct, an 8B vision-language model that reads your caption. It is nearly as big as the image model itself.
• The VAE, the small part (the FLUX.2 one) that turns the model's output into pixels.

It draws at any size from 256 to 2,048 pixels on a side (in steps of 16), with aspect ratios up to 6:1, so a 1600 x 400 banner is as natural as a square. Ideogram's benchmark claims are strong for an open model: in a blind typography test judged by ten professional designers, Ideogram 4 was picked as the best of four models 47.9% of the time, against 30.0% for Google's Nano Banana 2 and 15.5% for FLUX.2 [max]. On Ideogram's designer-preference leaderboard it sits second overall (Elo 1062) behind GPT Image 2 (1141) and first among open-weight models.

Three things it is not, so you do not lose an evening to them:

• Not an image editor. Ideogram 4 is text-to-image only. There is no official image-to-image, inpainting or edit mode; the open GitHub issues asking for an "Ideogram 4 Edit" and for image input are still unanswered.
• Not transparent-background capable. Asking for a "transparent background" gives you a fake gray-and-white checkerboard, not an alpha channel. The FLUX.2 VAE it uses has no alpha.
• Not the newest Ideogram. Ideogram's hosted site now lists Ideogram 4.5 as well; the open weights are 4.0.

How much VRAM Ideogram 4 needs: every build, by the file sizes

Search results disagree wildly on Ideogram 4's requirements, from "8 GB" to "an A100". The reliable way to answer is to add up the files you actually load. Ideogram's own statement is one line: "the nf4 variant fits on a single 24 GB GPU." Everything else in the table below is the file sizes from each Hugging Face repo, added up.

Three rules fall out of that table. First, 24 GB is the honest target for the full-quality routes: an RTX 3090, 4090 or the 24 GB pro cards. Second, the text encoder is not small: 5 to 11 GB on its own. ComfyUI loads it, encodes your caption and then makes room for the two image models, which is why a 24 GB card copes with 29.5 GB of fp8 files; the official Python script keeps everything on the card at once, which is why its fp8 route needs more. Third, your system RAM matters too: whatever is not on the GPU waits in ordinary memory, so plan on 32 GB of RAM, and 64 GB if you use the offload routes. Disk space: 17 to 30 GB per build.

Can Ideogram 4 run on a 16 GB GPU? Yes, with the smaller files. On an RTX 50-series 16 GB card, the nvfp4 pair (5.49 GB each) is the build made for you. On older 16 GB cards, use the GGUF Q4 files with stable-diffusion.cpp. One user's ComfyUI guide reports about 18 GB in use with both fp8 models loaded (on an RTX 5090) and that 16 GB cards run out of memory with them, which matches the file math. With 8 to 12 GB of VRAM, the GGUF route with offloading to system RAM is the only option, and it is slow.

Not sure what your card has? On Windows, open Task Manager, then Performance, then GPU, and read "Dedicated GPU memory". On Kali or any Linux, run nvidia-smi and read the memory column. Our laptop and GPU tiers guide explains why laptop GPUs often have less VRAM than their desktop names suggest.

The easy way: Ideogram 4 in ComfyUI on Windows 11 and Kali Linux

ComfyUI added native Ideogram 4 support on release day, and it is the route most people should take. You need ComfyUI 0.24.0 or newer; the current release is v0.42.1 (October 19, 2026). If ComfyUI is new to you, follow our ComfyUI download and install guide first, then come back.

The single most useful fact here: the ComfyUI team's repackaged files at Comfy-Org/Ideogram-4 are not gated. Ideogram's own Hugging Face repos make you accept the license on the website and log in with a token before anything downloads; the Comfy-Org copy (193,000 downloads so far) just downloads. The license terms still apply to you either way.

1. Update ComfyUI. ComfyUI Desktop updates itself; Portable has update_comfyui.bat in its update folder; a git install updates with git pull and pip install -r requirements.txt inside its environment.
2. Pick a build from the table above: fp8_scaled for a 24 GB card, nvfp4_mixed for an RTX 50-series 16 GB card.
3. Download four files into ComfyUI's models folder (commands below): the image model, the unconditional model, the text encoder and the VAE.
4. Restart ComfyUI, open the template library (Workflow menu, Browse Templates, or the Templates button in the sidebar), search "Ideogram" and open "Ideogram v4: Text to Image".
5. Check the loader nodes point at the files you downloaded, type a prompt (plain English or JSON) and press Run.

The download, with the Hugging Face command-line tool. Run it from inside ComfyUI's models folder; the repo's folders (diffusion_models, text_encoders, vae) match ComfyUI's, so the files land in the right places. On Kali Linux:

cd ~/ComfyUI && source .venv/bin/activate
pip install -U huggingface_hub
cd models
hf download Comfy-Org/Ideogram-4 \
  diffusion_models/ideogram4_fp8_scaled.safetensors \
  diffusion_models/ideogram4_unconditional_fp8_scaled.safetensors \
  text_encoders/qwen3vl_8b_fp8_scaled.safetensors \
  vae/flux2-vae.safetensors \
  --local-dir .

On Windows 11 in PowerShell (for the ComfyUI Portable folder layout; adjust the path to yours):

cd C:\ComfyUI_windows_portable\ComfyUI\models
..\..\python_embeded\python.exe -m pip install -U huggingface_hub
..\..\python_embeded\Scripts\hf.exe download Comfy-Org/Ideogram-4 diffusion_models/ideogram4_fp8_scaled.safetensors diffusion_models/ideogram4_unconditional_fp8_scaled.safetensors text_encoders/qwen3vl_8b_fp8_scaled.safetensors vae/flux2-vae.safetensors --local-dir .

For the 16 GB nvfp4 build, swap the three big file names for ideogram4_nvfp4_mixed.safetensors, ideogram4_unconditional_nvfp4_mixed.safetensors and qwen3vl_8b_nvfp4.safetensors. That is about 30 GB for fp8 or 18 GB for nvfp4, so start it before dinner.

Ethan's first image took a while, and the second took far less. That pattern is normal: the first run loads two 9 GB models and a 10 GB text encoder from disk, and later runs reuse what is already in memory. A profile posted on GitHub (on an NVIDIA DGX Spark, using the official Python code) showed about two and a half minutes of loading before the first image, and only seconds of drawing. A fast NVMe drive helps the first run more than anything else.

Two more ComfyUI options worth knowing. Ideogram publishes its own custom nodes, ComfyUI-Ideogram4, installable from the Manager; they add a Magic Prompt node (your plain sentence becomes JSON) and run Ideogram's own Python package. Be aware that they require PyTorch 2.11 or newer and may upgrade the PyTorch inside your ComfyUI install, and they download from the gated repos, so you enter a Hugging Face token under Settings, Ideogram 4.0, API Keys. And Kijai's KJNodes pack includes Ideogram4PromptBuilder (the "prompt builder kj" people search for): a canvas where you draw the bounding boxes for each object and text block, and the node writes the JSON for you.

The official Python way: install on Windows 11 and Kali Linux

Ideogram's GitHub repository, ideogram-oss/ideogram4, holds the reference code (Apache 2.0, separate from the weights' license) and a command-line script, run_inference.py. Choose this route if you want to script image generation or understand exactly what the model does. It needs Python 3.10 to 3.12, PyTorch 2.11 or newer with CUDA, and an NVIDIA card for the nf4 build.

Before you install, do the two account steps, or the first run fails with a 404 or GatedRepoError:

1. Open huggingface.co/ideogram-ai/ideogram-4-nf4 while signed in and click "Agree and access repository".
2. Create a read token at huggingface.co/settings/tokens. You will paste it into hf auth login below.
3. For Magic Prompt (on by default), get an Ideogram API key from ideogram.ai/platform. Ideogram describes its hosted magic-prompt service as free. Skip this if you will write JSON yourself (see the offline section).

Kali Linux and other Linux

Check nvidia-smi lists your card first; if it does not, the NVIDIA driver is the problem, not Ideogram. Then:

sudo apt update && sudo apt install -y git python3-venv
git clone https://github.com/ideogram-oss/ideogram4.git && cd ideogram4
python3 -m venv .venv && source .venv/bin/activate
pip install torch --index-url https://download.pytorch.org/whl/cu130
pip install .
hf auth login
export IDEOGRAM_API_KEY="your-ideogram-key"
python run_inference.py --prompt "a ginger cat wearing a tiny wizard hat reading a spellbook" \
  --output out.png --quantization nf4 --sampler-preset V4_DEFAULT_20

The virtual environment is not optional on Kali: a plain pip install outside one stops with "externally-managed-environment", which our Kali pip guide explains. The cu130 index serves PyTorch 2.14.1, the current release, built for CUDA 13.0.

Windows 11

Install Python 3.12 and Git for Windows first, then in PowerShell:

git clone https://github.com/ideogram-oss/ideogram4.git; cd ideogram4
py -3.12 -m venv .venv; .\.venv\Scripts\Activate.ps1
pip install torch --index-url https://download.pytorch.org/whl/cu130
pip install .
hf auth login
$env:IDEOGRAM_API_KEY = "your-ideogram-key"
python run_inference.py --prompt "a ginger cat wearing a tiny wizard hat reading a spellbook" --output out.png --quantization nf4 --sampler-preset V4_DEFAULT_20

Installing PyTorch from the cu130 index before pip install . matters on Windows. If you let pip pick PyTorch by itself to satisfy "torch>=2.11", it can install a CPU-only build, and one Windows user with an RTX 3090 lost hours to exactly that kind of version tangle. The repository's own issue list has the errors you may meet; the troubleshooting section below has the fix for each.

What the script does, and the options worth knowing

When you run that command, the script screens your prompt (only if you supply moderation keys; more on that below), sends your sentence to Magic Prompt, prints the JSON caption it got back, loads the models and draws. The options you will actually use:

About that warning: every run without Hive keys prints "WARNING: no Hive text moderation key configured -- prompt safety screening is DISABLED". That is the external screening service, which is optional for you at home. It is not the same thing as the safety filter inside the model, which you cannot switch off; see the safety section.

Fully offline: no API key, no Magic Prompt service

Magic Prompt is on by default, and by default it calls Ideogram's servers, so the "local" model is not fully local out of the box. Without a key, the script stops with "ERROR: magic prompt is enabled but no API key was found." You have two ways to stay entirely on your own machine.

Way one: write the JSON caption yourself and pass --no-magic-prompt. On Kali, keep the caption in a file and hand it over in one go:

python run_inference.py --no-magic-prompt --prompt "$(cat caption.json)" \
  --output poster.png --quantization nf4 --sampler-preset V4_DEFAULT_20

On Windows, passing a block of JSON as a command-line argument through PowerShell mangles the quotes, so use the Python route below and load the file with json.load. The JSON section shows a caption that passes the official checker, ready to copy.

Way two: let diffusers write the JSON locally. The diffusers library (version 0.41.0, the current release, includes the Ideogram 4 pipeline, so a normal pip install is enough) can reuse the Qwen3-VL text encoder to expand your sentence into a caption on your own GPU. It needs one extra small download, an "LM head" that makes the text encoder able to write, and the outlines package, which forces the output into valid JSON. Use Python 3.12 for this one, because outlines does not support Python 3.14 yet.

pip install torch --index-url https://download.pytorch.org/whl/cu130
pip install diffusers transformers accelerate bitsandbytes outlines

import os, torch
from diffusers import Ideogram4Pipeline, Ideogram4PromptEnhancerHead

head = Ideogram4PromptEnhancerHead.from_pretrained(
    "diffusers/qwen3-vl-8b-instruct-lm-head", torch_dtype=torch.bfloat16)
pipe = Ideogram4Pipeline.from_pretrained(
    "ideogram-ai/ideogram-4-nf4-diffusers",
    prompt_enhancer_head=head,
    torch_dtype=torch.bfloat16,
    token=os.environ["HF_TOKEN"],      # the official repo is gated
).to("cuda")

image = pipe(
    "a school science fair poster about volcanoes with the title VOLCANO LAB",
    height=1024, width=1024,
    prompt_upsampling=True,            # writes the JSON caption on your GPU
    generator=torch.Generator("cuda").manual_seed(0),
).images[0]
image.save("volcano-lab.png")

The model card is honest about the trade: expect somewhat lower quality from local prompt upsampling than from Ideogram's hosted Magic Prompt. To use a caption you wrote yourself instead, drop prompt_upsampling=True and pass the JSON string: pipe(json.dumps(caption, ensure_ascii=False), ...).

A warning if you go looking for an ungated copy for diffusers: Unsloth's unsloth/ideogram-4-fp8 mirror keeps the original fused attention layout, and Unsloth's own note says a plain diffusers from_pretrained on it "silently random-initialises the attention weights and produces garbage images rather than raising." No error, just noise. For diffusers, the ungated mirror to use is unsloth/ideogram-4-nf4-diffusers, which has the layout diffusers expects.

Ethan tried both. The hosted Magic Prompt gave Jake's poster richer lighting and better-placed text; the local one was good enough for the science fair poster and never left the PC. "So the cloud bit was only ever the prompt," Jake said. "Only ever the prompt," Ethan said, "and now not even that."

Mac, AMD and smaller GPUs: GGUF with stable-diffusion.cpp, TurboTime and WanGP

The honest Mac answer

The official script claims its fp8 path "runs on any device", and on an Apple Silicon Mac it does not. PyTorch's Mac backend (MPS) cannot hold the float8 number format, so the run ends with "TypeError: Trying to convert Float8_e4m3fn to the MPS backend". That report has been open on GitHub since June 5, with Mac owners writing that they spent hours downloading first. A community fix (pull request #19, which converts the weights to bf16 while loading) exists but has not been merged; the repository's last commit was June 30. Do not download 27 GB onto a Mac for the official script today.

The route that does work without PyTorch is stable-diffusion.cpp, a C++ image generator in the spirit of llama.cpp. It supports Ideogram 4 natively, publishes an Apple Silicon build (the October 21, 2026 release includes macOS arm64, Windows CUDA 12, Vulkan, ROCm and CPU builds), and its author published 4-bit GGUF files. At Q4 the files add up to about 16.7 GB, so on a Mac, where the GPU shares the main memory, a machine with 32 GB of unified memory is the sensible minimum.

Running the GGUF build

Download four files: the two GGUF models from leejet/ideogram-4-GGUF (ideogram4-Q4_0.gguf and ideogram4_uncond-Q4_0.gguf, 5.64 GB each), the text encoder from unsloth/Qwen3-VL-8B-Instruct-GGUF (the Q4_K_M file, 5.03 GB) and the FLUX.2 VAE (the flux2-vae file from Comfy-Org/Ideogram-4 works). Unzip the stable-diffusion.cpp release for your system, then:

./sd-cli --diffusion-model ideogram4-Q4_0.gguf \
  --uncond-diffusion-model ideogram4_uncond-Q4_0.gguf \
  --llm Qwen3-VL-8B-Instruct-Q4_K_M.gguf \
  --vae flux2-vae.safetensors \
  -p "$(cat caption.json)" \
  -H 1024 -W 1024 --offload-to-cpu -v

On Windows the program is sd-cli.exe in the unzipped folder. Note that stable-diffusion.cpp has no Magic Prompt: the -p text should be a JSON caption, which is why the example reads it from a file. --offload-to-cpu keeps the weights in system RAM and moves them to the GPU as they are needed, which is what lets this route run on cards with less memory than the files, at a real cost in speed. The project also loads Ideogram's original fp8 files directly, keeping them at one byte per weight, if you already have those. Other people have published more GGUF sizes, from Q4 to Q8 (for example rectangleworm/ideogram-4-gguf, tagged for both ComfyUI and stable-diffusion.cpp).

TurboTime LoRA: fewer steps, and no second model

Ostris, the author of the AI Toolkit trainer, published Ideogram 4 TurboTime, a 0.85 GB LoRA that, in his description, turns Ideogram 4 into "a few step model" that makes good images "in as little as 2 steps with no CFG and no unconditional model." No unconditional model means one fewer 5 to 9 GB file in memory, on top of the speed. It is an unofficial add-on, still being refined by its author, and it changes the look of the output, so compare it against the full model on your own prompts before you rely on it.

WanGP, for older and smaller cards

WanGP (by DeepBeepMeep), the web interface built for "the GPU poor", supports Ideogram 4 too and keeps its own set of files (fp8 and nf4 models, several text-encoder sizes and the TurboTime LoRA) in the DeepBeepMeep/Ideogram4 repo. It aims at low VRAM and older RTX cards and downloads the right files for your GPU by itself, which makes it the friendliest option if ComfyUI's graphs feel like too much.

JSON prompts that pass the checker: the format and the nine mistakes

Every route ends in the same place: a JSON caption the model was trained to read. The official package checks each caption with a strict verifier before drawing, and stops with "caption verifier flagged prompt[0]" when something is off. The structure is three blocks, always in this order:

• high_level_description: one or two sentences saying what the image is.
• style_description: aesthetics, lighting, then either photo (for photographs) or art_style (for everything else, after medium), then an optional color_palette of up to 16 hex colors.
• compositional_deconstruction: a background description, then a list of elements. Each element is an obj or a text, with an optional bounding box, the literal text to render (for text elements), a description and up to 5 colors.

Bounding boxes are [y_min, x_min, y_max, x_max], whole numbers from 0 to 1000 measured from the top-left corner: height first, then width. Ethan's poster caption, which passes the official checker as written:

{
  "high_level_description": "A flat vector poster for a phone repair shop's Diwali sale, with a bold headline across the top and a smartphone in the centre.",
  "style_description": {
    "aesthetics": "clean, festive, high-contrast retail poster",
    "lighting": "flat, even graphic lighting",
    "medium": "digital illustration",
    "art_style": "flat vector with rounded shapes",
    "color_palette": ["#FF9933", "#FFFFFF", "#138808", "#000080"]
  },
  "compositional_deconstruction": {
    "background": "A warm saffron gradient with small golden diya lamps along the bottom edge.",
    "elements": [
      {"type": "text", "bbox": [60, 100, 220, 900], "text": "DIWALI SCREEN SALE",
       "desc": "Heavy white sans-serif headline, centred, with a thin navy outline.",
       "color_palette": ["#FFFFFF", "#000080"]},
      {"type": "obj", "bbox": [300, 330, 850, 670],
       "desc": "A modern smartphone standing upright with a bright new screen."}
    ]
  }
}

The verifier is plain Python, so you can run it on your captions without a GPU. These are its exact messages for the mistakes people make most, from the official caption_verifier.py:

Two layout tips from people who ran into them. If a 16:9 image comes out as a portrait turned on its side, check your boxes: the order is y first, and boxes written as [x, y, x, y] describe a different shape. And for the cleanest text, give each piece of text its own text element with the exact words in the text field and the styling in desc, rather than burying the words inside the background description.

"Image blocked by safety filter": why harmless prompts get blocked

This is the complaint that fills Ideogram 4's GitHub issues, and the answer surprises people who assume a local model is unfiltered. The filter is inside the model weights. The ComfyUI team states that Ideogram 4 "has a built-in filter in the model weights" and that ComfyUI cannot tune, disable or override it. When it triggers, the run finishes normally and the saved image is a gray card reading "Image blocked by safety filter".

It also triggers on things that are plainly harmless. The examples users reported include "a 1950s oil painting of a deckchair in the sun" and "Godzilla, wearing sunglasses and a Hawaiian shirt sitting in a lawn chair at the beach". One tester measured that switching from plain sentences to JSON captions made blocks less frequent, but still saw them about 40% of the time with some prompts; another found the bounding-box workflow fixed the prompt that had been blocked. Ethan's first try at the science fair poster came back gray too: a plain sentence about "an erupting volcano". The JSON version, with a calm description of a cardboard model volcano on a school desk, came through first time.

What helps, in the order to try it:

1. Use a JSON caption (via Magic Prompt or written yourself) instead of a short sentence. Specific, neutral descriptions get blocked less than vague ones.
2. Rephrase the element that probably tripped it, which is the ComfyUI team's own advice. One user found that adding a style_description made blocks more likely, so try the caption without it.
3. Add bounding boxes and describe each element on its own; it helped in at least one reported case.
4. Change the seed. The same caption with a different seed sometimes passes.

You will find third-party "bypass" files and modified text encoders on Hugging Face. They are unofficial, and the license requires any redistributed version to keep safety filtering at least as strong as Ideogram's, so they are not a road this guide takes. If the filter makes the model unusable for your subject, a different open model (see the cards at the end) is the cleaner answer.

The license: free for your hobby, $300 a month for your shop

Ideogram 4's weights come under the Ideogram Non-Commercial Model Agreement (dated June 3, 2026), not an open-source license. The code on GitHub is Apache 2.0; the weights, every quantized copy and every fine-tune of them carry the non-commercial terms. The key definition is worth reading in full, because it is stricter than most people assume. Non-commercial means use that does not "directly or indirectly generate revenue", plus testing at a company in a non-production environment, personal research or hobby projects, and charities. Then it adds that any use "that involves generating Output to include in, or to advertise or promote, revenue-generating products or services" is not non-commercial.

The paid options, from Ideogram's licensing page: a Self-Serve Commercial License at $300 a month (with a discount for annual billing), covering 10,000 to 100,000 images a month on your own hardware and commercial use of what you generate, but only the public quantized weights, with no hosted API and no reselling access to others. Above 100,000 images, or for full-precision weights and products that let your customers generate images, the Enterprise tier goes through Ideogram's sales team. If you only need a handful of business images, Ideogram's hosted website and API are the other route; they run on pay-as-you-go credits at one cent per credit, eligible free accounts get weekly credits, and they come with their own terms of service.

Jake did the arithmetic out loud. "Three hundred a month, for a poster I need once a year." Ethan nodded. The shop poster went through the hosted service with a few cents of credits; the science fair poster, the one his daughter wanted, came off Ethan's PC for free. "Same model," Jake said, "different paperwork." This is a summary to help you ask the right question, not legal advice; read the LICENSE.md in the model repo before you use the images for anything that earns money.

Running Ideogram 4 on AWS when you do not have the GPU

No 24 GB card at home? Renting one by the hour on Amazon EC2 costs less than a dollar an hour. The license applies on rented hardware exactly as at home. On-demand prices for Linux in US East (N. Virginia), from AWS's price list on October 22, 2026:

The xlarge sizes of g6 ($0.8048) and g5 ($1.006) have the same GPUs but only 16 GiB of system RAM, which is tight when 16 to 30 GB of model files pass through memory on load; the 2xlarge sizes are worth the extra twenty cents. Use an AWS Deep Learning AMI with PyTorch so the NVIDIA driver is already there, give the instance a 100 GB disk for the files, and stop the instance when you finish: a stopped instance costs nothing per hour, but its disk is still billed until you delete it. New AWS accounts often start with a GPU quota of zero, so request a quota increase for G instances a day before you need one. Our Hugging Face on AWS guide walks through renting a GPU machine for an open model step by step.

Ideogram 4 not working? Troubleshooting by symptom

"ERROR: magic prompt is enabled but no API key was found"

Magic Prompt is on by default and needs a key. Set IDEOGRAM_API_KEY (or MAGIC_PROMPT_API_KEY), pass --magic-prompt-key, or switch it off with --no-magic-prompt and supply a JSON caption. Passing --magic-prompt-key with nothing after it is a common slip; the key must follow the flag.

"ValueError: caption verifier flagged prompt[0]: invalid JSON"

The model received a plain sentence with Magic Prompt off, or a caption with a syntax error. Paste the caption into any JSON validator, or run the official caption_verifier.py on it; the table in the JSON section lists its messages. --warn-on-caption-issues lets a run continue past format warnings, though the image usually suffers.

404 or GatedRepoError while downloading

The official repos are gated. Accept the terms on the model page in a browser, while signed in to the same Hugging Face account, then run hf auth login with a token from that account. In ComfyUI, the ungated Comfy-Org/Ideogram-4 files avoid the gate entirely.

Hugging Face answers "418 Something went wrong"

That is Hugging Face refusing the download, not Ideogram. Wait and retry, sign in with a token, or use another copy: Comfy-Org/Ideogram-4 for ComfyUI, the Unsloth mirrors or the GGUF repos for the other routes.

"TypeError: Trying to convert Float8_e4m3fn to the MPS backend" on a Mac

The official fp8 path does not run on Apple Silicon today; the fix is an unmerged pull request. Use the stable-diffusion.cpp GGUF route from the Mac section.

"AttributeError: module 'torch' has no attribute 'float8_e8m0fnu'"

Your PyTorch is too old; Ideogram 4 needs 2.11 or newer. Reinstall it from the CUDA index inside your environment: pip install --upgrade torch --index-url https://download.pytorch.org/whl/cu130.

"Configured CUDA binary not found ... libbitsandbytes_cuda132.dll"

bitsandbytes (used by the nf4 build) has no library for the CUDA version your PyTorch was built for, typically after installing a nightly PyTorch. Go back to the stable PyTorch from the cu130 index and upgrade bitsandbytes (pip install -U bitsandbytes; 0.50.2 is current).

The images are pure noise or garbage, with no error

You almost certainly loaded unsloth/ideogram-4-fp8 (fused attention layout) with diffusers, which quietly fills the attention weights with random numbers. Use ideogram-ai/ideogram-4-nf4-diffusers or unsloth/ideogram-4-nf4-diffusers instead.

Every image is a gray "Image blocked by safety filter" card

The filter is in the weights and cannot be switched off. Use a JSON caption, rephrase the element that likely triggered it, add bounding boxes, and try another seed, as in the safety section.

CUDA out of memory

Step down a build: fp8 to nvfp4 on an RTX 50-series card, or to the GGUF Q4 files with --offload-to-cpu in stable-diffusion.cpp. Lower the resolution to 1024 x 1024 while testing, close other GPU programs (browsers with hardware acceleration count), and on the official script prefer nf4 over fp8.

A 16:9 image comes out rotated

Your bounding boxes are probably in x, y order. Ideogram 4 reads them as [y_min, x_min, y_max, x_max] from 0 to 1000.

"Transparent background" gives a checkerboard

The model cannot produce transparency; the checkerboard is drawn, not real. Generate on a plain, contrasting background and remove it afterwards with a background-removal tool.

The Python script closes WSL2 within seconds

This is reported on GitHub without an official answer yet. WSL2 gives Linux only part of your PC's memory by default, and loading these models needs a lot of it, so raising the memory setting in your .wslconfig is the first thing to try; ComfyUI on Windows itself avoids the question.

The first image takes minutes

Normal. The first run reads two large image models and the text encoder from disk; later images in the same session are much faster. A fast NVMe drive and enough system RAM shorten the first wait.

Ideogram 4: frequently asked questions

The science fair poster hung at the front of the class: "VOLCANO LAB" in clean block letters over a cardboard volcano, exactly where the bounding box had put it. Jake's daughter asked how the computer knew to spell it right. "Because your dad's friend told it where every letter goes," Jake said. Ethan, who had spent the evening on JSON brackets, took that as the highest praise available.

Revision note. Written October 22, 2026, with file sizes from each Hugging Face repo, the official caption checker run on every example on this page, and the license terms and AWS prices of that day. "Look before you leap," the proverb says; with this model, look at the license before the first poster.