Ollama + Image Generation unter Linux: So funktioniert lokale KI-Bildgenerierung 2026

Ollama gehört inzwischen zu den beliebtesten Werkzeugen, wenn Large Language Models lokal unter Linux betrieben werden sollen. Ein Befehl, ein Modell und schon laufen Qwen, Gemma, Llama oder andere offene Modelle auf dem eigenen Rechner.

Doch was ist mit Bildern? Kann man mit Ollama unter Linux Bilder generieren?

Die Antwort ist im August 2026 etwas ungewöhnlich: Ja – Ollama besitzt mittlerweile eine eigene experimentelle Image-Generation-Funktion. Aber nein – diese native Funktion steht unter Linux offiziell noch nicht zur Verfügung.

Ollama kündigte die eigene Bildgenerierung am 20. Januar 2026 zunächst für macOS an. Unterstützt werden unter anderem Z-Image Turbo und FLUX.2 Klein. Windows- und Linux-Unterstützung werden auf der offiziellen Ollama-Seite weiterhin als kommende Funktionen genannt.

Linux-Nutzer müssen deshalb allerdings keineswegs auf lokale Bildgenerierung verzichten. Im Gegenteil: Mit Ollama, Open WebUI und ComfyUI lässt sich heute bereits eine leistungsfähige, vollständig lokale KI-Umgebung aufbauen, in der ein Sprachmodell den Prompt versteht und optimiert und ein Bildmodell anschließend das gewünschte Bild erzeugt. Genau diese Umgebung bauen wir in diesem Tutorial auf.

Das Ziel: Ein lokales ChatGPT für Text und Bilder

Unsere Architektur besteht aus drei Komponenten:

Der entscheidende Vorteil dieser Architektur besteht darin, dass jede Software genau das erledigt, worin sie besonders gut ist. Ollama verarbeitet Sprache und kann aus einer einfachen Beschreibung beispielsweise einen detaillierten Image Prompt erzeugen. ComfyUI kümmert sich anschließend um Diffusion, Sampling, Auflösung, Seeds, Modelle und die eigentliche Bilddatei. Open WebUI verbindet beide Welten zu einer Oberfläche.

Das Ergebnis fühlt sich im Alltag fast wie ein multimodaler Cloud-KI-Dienst an – läuft aber auf dem eigenen Linux-System.

Kann Ollama selbst Bilder generieren?

Seit Januar 2026 lautet die Antwort grundsätzlich: ja. Ollama hat eine experimentelle Image-Generation-Funktion eingeführt. Unter anderem stehen die Modelle Z-Image Turbo und FLUX.2 Klein im experimentellen x/-Namensraum zur Verfügung.

Auf einem unterstützten System kann beispielsweise ein Image-Modell direkt mit Ollama aufgerufen werden:

ollama run x/z-image-turbo

oder:

ollama run x/flux2-klein

Die erzeugten Dateien werden im aktuellen Verzeichnis gespeichert. Ollama unterstützt außerdem Einstellungen für Auflösung, Seed, Anzahl der Schritte und Negative Prompts.

Der Haken für Linux

Genau diese Funktion ist laut Ollamas eigener Dokumentation derzeit noch nicht offiziell für Linux freigegeben. Und das ist wichtig: Im Internet finden sich inzwischen zahlreiche Anleitungen, die den Eindruck vermitteln, man müsse unter Ubuntu oder Debian lediglich ollama run x/flux2-klein eingeben. Stand 31. August 2026 entspricht das nicht dem offiziell dokumentierten Linux-Support von Ollama.

Deshalb setzen wir für dieses Tutorial nicht auf einen experimentellen Workaround, sondern auf eine Kombination, die unter Linux tatsächlich funktioniert.

Warum ComfyUI?

ComfyUI ist wesentlich mehr als eine Oberfläche für Stable Diffusion. Das System arbeitet mit sogenannten Nodes. Daraus lassen sich Bild-Pipelines aufbauen, die von einer einfachen Text-to-Image-Generierung bis zu komplexen Workflows mit LoRA, ControlNet, Inpainting, Referenzbildern oder mehreren Modellen reichen.

ComfyUI unterstützt Linux sowie NVIDIA-, AMD- und Intel-GPUs. Die aktuelle Dokumentation empfiehlt für manuelle Installationen ein isoliertes Python-Environment und unterstützt aktuelle Python- und PyTorch-Versionen. Besonders interessant ist die Kombination mit Open WebUI: Open WebUI unterstützt ComfyUI direkt als Image-Generation-Backend.

Schritt 1: Ollama unter Linux installieren

Unter Ubuntu, Debian, Linux Mint und vielen anderen Distributionen lässt sich Ollama über das offizielle Installationsskript installieren. Wie du Ollama grundlegend unter Linux installierst, GPU-Unterstützung einrichtest und die lokale API nutzt, zeigt bereits der Grundlagenartikel Ollama unter Linux installieren: KI lokal betreiben (Zum Artikel). Für dieses Tutorial genügt der Kurzweg:

curl -fsSL https://ollama.com/install.sh | sh

Anschließend prüfen wir:

ollama --version
ollama list

Falls der Ollama-Dienst nicht automatisch läuft:

ollama serve

Auf typischen Linux-Installationen läuft die Ollama-API anschließend lokal über Port 11434.

Schritt 2: Ein Sprachmodell installieren

Für die Bildgenerierung benötigen wir Ollama nicht als Diffusion-Engine, sondern zunächst als intelligentes Sprachmodell. Ein vernünftiger Einstieg ist beispielsweise:

ollama pull qwen3:8b

Qwen3:8b benötigt laut Ollama derzeit ungefähr 5,2 GB Speicherplatz für das Modell und eignet sich hervorragend für allgemeine Textaufgaben. Test:

ollama run qwen3:8b

Anschließend beispielsweise:

Erstelle einen detaillierten englischen Image Prompt für ein
fotorealistisches Rechenzentrum bei Nacht mit blauer Beleuchtung.

Damit funktioniert bereits der erste Teil unserer Pipeline: Benutzer → Ollama → optimierter Image Prompt. Jetzt fehlt noch der Bildgenerator.

Schritt 3: ComfyUI unter Linux installieren

Für einen Linux-Server oder eine Workstation bevorzugen wir die manuelle Installation innerhalb eines Python-Virtual-Environments. Unter Debian oder Ubuntu installieren wir zunächst die benötigten Pakete:

sudo apt update
sudo apt install -y git python3 python3-venv python3-pip

Anschließend ComfyUI herunterladen:

git clone https://github.com/Comfy-Org/ComfyUI.git
cd ComfyUI

Virtuelle Python-Umgebung erstellen:

python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip

Jetzt kommt der GPU-spezifische Teil.

NVIDIA unter Linux

Für aktuelle NVIDIA-Systeme empfiehlt das ComfyUI-Projekt eine aktuelle PyTorch-CUDA-Version. Beispielsweise:

pip install torch torchvision torchaudio \
  --extra-index-url https://download.pytorch.org/whl/cu130
pip install -r requirements.txt

Ob die NVIDIA-GPU grundsätzlich vom System erkannt wird, lässt sich vorher bequem prüfen:

nvidia-smi

Zeigt dieser Befehl keine GPU an, sollte zunächst die NVIDIA-Treiberinstallation korrigiert werden.

AMD unter Linux

Auch AMD-GPUs werden unterstützt. Für die derzeit dokumentierte stabile ROCm-Variante verwendet ComfyUI beispielsweise:

pip install torch torchvision torchaudio \
  --index-url https://download.pytorch.org/whl/rocm7.2
pip install -r requirements.txt

Die offizielle ComfyUI-Dokumentation beschreibt außerdem spezielle Builds für verschiedene RDNA-Generationen.

Intel Arc unter Linux

Auch Intel-GPUs sind inzwischen deutlich interessanter für lokale KI geworden. Für Intel XPU kann PyTorch beispielsweise so installiert werden:

pip install torch torchvision torchaudio \
  --index-url https://download.pytorch.org/whl/xpu
pip install -r requirements.txt

Damit ist ComfyUI grundsätzlich installiert.

Schritt 4: ComfyUI starten

Für einen reinen lokalen Test genügt:

python main.py

Für die Verbindung zu Open WebUI sollte ComfyUI allerdings über das Netzwerk erreichbar sein. Deshalb starten wir:

python main.py --listen 0.0.0.0

ComfyUI lauscht normalerweise auf http://SERVER-IP:8188. Open WebUI weist für seine ComfyUI-Integration ausdrücklich darauf hin, ComfyUI mit --listen erreichbar zu machen.

Sicherheit beachten

Port 8188 sollte nicht einfach ungeschützt ins Internet veröffentlicht werden. Wenn Ollama, Open WebUI und ComfyUI auf demselben Server laufen, sollte der Zugriff möglichst über internes Docker-Networking, localhost, Firewall-Regeln oder einen entsprechend abgesicherten Reverse Proxy erfolgen.

Schritt 5: Welches Bildmodell verwenden?

Jetzt benötigen wir ein echtes Image-Generation-Modell. Für dieses Tutorial bietet sich FLUX.1 Schnell an. Warum? FLUX.1 Schnell ist auf schnelle Generierung ausgelegt und benötigt nur wenige Sampling-Schritte. Die Variante steht unter Apache 2.0, während bei verschiedenen anderen FLUX-Modellen restriktivere Lizenzbedingungen gelten können.

Wer möglichst unkompliziert starten möchte, kann die FP8-Checkpoint-Version verwenden. Die Datei flux1-schnell-fp8.safetensors gehört nach ComfyUI/models/checkpoints/:

ComfyUI/
└── models/
    └── checkpoints/
        └── flux1-schnell-fp8.safetensors

ComfyUI dokumentiert diese Ein-Datei-Variante ausdrücklich als einfacheren Einstieg für FLUX.1 Schnell. FP8 reduziert den Speicherbedarf, kann gegenüber höherer Präzision allerdings etwas Bildqualität kosten.

Alternativ: Die vollständige FLUX-Version

Wer über leistungsfähigere Hardware verfügt, kann auch die vollständige Pipeline verwenden. Dann werden unter anderem folgende Dateien benötigt: clip_l.safetensors, t5xxl_fp8_e4m3fn.safetensors, ae.safetensors und flux1-schnell.safetensors. Die Verzeichnisstruktur sieht dann ungefähr so aus:

ComfyUI/
└── models/
    ├── diffusion_models/
    │   └── flux1-schnell.safetensors
    ├── text_encoders/
    │   ├── clip_l.safetensors
    │   └── t5xxl_fp8_e4m3fn.safetensors
    └── vae/
        └── ae.safetensors

Diese Struktur entspricht dem offiziellen FLUX-Workflow von ComfyUI. Für den ersten Versuch ist die FP8-Checkpoint-Version jedoch wesentlich unkomplizierter.

Schritt 6: Einen FLUX-Workflow in ComfyUI starten

ComfyUI bringt inzwischen Workflow-Templates beziehungsweise dokumentierte Beispiel-Workflows für zahlreiche Modelle mit, darunter FLUX.1 Schnell, FLUX.1 Dev, FLUX.2 Dev, FLUX.2 Klein, verschiedene Qwen-Image-Modelle sowie weitere aktuelle Bildmodelle.

Nach dem Laden des passenden FLUX-Workflows prüft man zunächst, ob das richtige Modell ausgewählt wurde. Anschließend einen Prompt eingeben, beispielsweise:

A futuristic Linux server room, dark environment,
blue and cyan LED lighting, multiple rack servers,
realistic photography, cinematic lighting,
high detail, professional technology photography

Danach: Queue beziehungsweise Ctrl + Enter. Nach erfolgreicher Berechnung erscheint das Bild im Workflow und wird im ComfyUI-Output-Verzeichnis gespeichert.

Damit wissen wir: ComfyUI + FLUX funktioniert. Jetzt verbinden wir es mit Ollama.

Schritt 7: Open WebUI installieren

Wer Ollama bereits mit Open WebUI betreibt, kann diesen Schritt überspringen. Wie du Open WebUI und Ollama unter Linux grundsätzlich per Docker installierst, verbindest und absicherst, zeigt ausführlich Open WebUI + Ollama unter Linux: Eigene ChatGPT-Alternative lokal betreiben (Zum Artikel). Für die Bildgenerierung bietet sich eine Docker-Installation mit direkt aktivierter ComfyUI-Anbindung an:

docker run -d \
  -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -e COMFYUI_BASE_URL=http://host.docker.internal:8188/ \
  -e ENABLE_IMAGE_GENERATION=True \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main

Der wichtige Linux-spezifische Parameter ist --add-host=host.docker.internal:host-gateway. Bei nativem Docker unter Linux existiert host.docker.internal nicht in jedem Szenario automatisch. Open WebUI dokumentiert deshalb genau dieses Host-Gateway-Mapping für die Verbindung mit einem auf dem Docker-Host laufenden ComfyUI.

Open WebUI ist anschließend normalerweise erreichbar über http://SERVER-IP:3000.

Schritt 8: ComfyUI in Open WebUI einrichten

Nun öffnen wir in Open WebUI: Admin Settings → Experience → Images. Dort aktivieren wir die Bildgenerierung. Als Engine wählen wir ComfyUI. Die Base URL lautet bei unserem Docker-Beispiel http://host.docker.internal:8188/.

Anschließend die Verbindung über den Refresh- beziehungsweise Test-Button prüfen. Open WebUI unterstützt ComfyUI offiziell als Image Generation Engine und kann unter anderem Modell, Bildgröße, Schritte und Seed an den Workflow übergeben.

Schritt 9: Den ComfyUI-Workflow exportieren

Jetzt kommt einer der wichtigsten Schritte. Open WebUI benötigt nicht den normalen ComfyUI-Workflow, sondern dessen API-Version. In ComfyUI öffnen wir deshalb die Einstellungen und aktivieren Enable Dev Mode Options. Danach exportieren wir den funktionierenden Workflow über Export (API) beziehungsweise abhängig von der ComfyUI-Version Save (API Format).

Nicht den normalen Workflow-Export verwenden. Diese JSON-Datei laden wir anschließend in Open WebUI unter der ComfyUI-Konfiguration hoch.

Schritt 10: Die Nodes zuordnen

Open WebUI muss wissen, welcher ComfyUI-Node welchen Parameter enthält. Typische Parameter sind:

Die Node-IDs sind allerdings vom verwendeten Workflow abhängig. Deshalb sollte man keine Node-IDs blind aus irgendeinem Internet-Tutorial übernehmen. In der exportierten API-JSON findet sich beispielsweise:

"6": {
  "inputs": { "text": "Prompt" }
}

Dann wäre Node 6 der entsprechende Prompt-Node. Oder:

"3": {
  "inputs": { "seed": 42, "steps": 20 }
}

Dann werden Seed und Steps über Node 3 gesteuert. Open WebUI beschreibt genau dieses Mapping-Verfahren in seiner aktuellen ComfyUI-Dokumentation. Bei FLUX-Workflows können für einzelne Einstellungen auch mehrere Node-IDs erforderlich sein.

Schritt 11: Das erste Bild direkt im Chat erzeugen

Jetzt wird es interessant. Wir wählen in Open WebUI unser Ollama-Modell, beispielsweise qwen3:8b. Anschließend aktivieren wir in den Chat-Integrationen die Image-Funktion. Jetzt können wir schreiben:

Erstelle ein fotorealistisches Bild eines modernen
Linux-Rechenzentrums bei Nacht. Dunkle Server-Racks,
blaue Beleuchtung, professioneller Technologie-Look, 16:9.

Open WebUI kann daraus einen Image Prompt erzeugen beziehungsweise das Sprachmodell dazu verwenden, einen geeigneten Prompt für das angeschlossene Image-Backend zu formulieren. Der Workflow sieht dann vereinfacht so aus:

Benutzer
  |
  v
Open WebUI
  |
  +--> Ollama / Qwen
  |      |
  |      Prompt verstehen und optimieren
  |
  v
ComfyUI
  |
  v
FLUX
  |
  v
fertiges Bild

Und alles kann auf der eigenen Linux-Hardware laufen.

Wie viel GPU-Speicher brauche ich?

Bei lokaler Bildgenerierung ist VRAM wichtiger als bei vielen kleineren Ollama-Sprachmodellen. Als grobe Orientierung:

Die tatsächliche Speicherbelegung hängt allerdings stark von Modell, Quantisierung, Auflösung, Text Encoder, Batch-Größe und ComfyUI-Workflow ab. Gerade FP8-Varianten sind deshalb für Consumer-GPUs interessant. Die ComfyUI-Dokumentation bietet bei FLUX explizit quantisierte Varianten zur Reduzierung des Speicherbedarfs an.

Warum Ollama überhaupt verwenden, wenn ComfyUI das Bild erzeugt?

Eine berechtigte Frage. Man könnte den Prompt schließlich auch direkt in ComfyUI eingeben. Ollama macht die Umgebung aber wesentlich intelligenter. Aus „Mach mir ein Bild von einem Serverraum.“ kann ein lokales Sprachmodell beispielsweise einen erheblich detaillierteren Prompt erzeugen:

Professional cinematic photograph of a modern enterprise
data center, symmetrical server racks, dark environment,
blue LED illumination, realistic cabling, subtle reflections,
volumetric lighting, high dynamic range, ultra detailed,
professional technology photography, no people.

Dadurch übernimmt Ollama gewissermaßen die Rolle des Prompt Engineers. Und weil Open WebUI beide Systeme miteinander verbindet, muss der Benutzer diesen Prozess nicht ständig manuell durchführen.

Open WebUI kann noch mehr

Die ComfyUI-Integration ist nicht auf einfache Text-to-Image-Generierung beschränkt. Open WebUI unterstützt inzwischen auch Bildbearbeitung über entsprechend konfigurierte ComfyUI-Workflows. Damit werden beispielsweise Szenarien wie folgende möglich: „Ändere den Hintergrund dieses Bildes in ein Rechenzentrum.“ oder „Entferne das Objekt links und ersetze es durch einen Server-Rack.“

Für solche Funktionen benötigt man allerdings einen passenden Image-Editing-Workflow und ein Modell, das Inpainting oder Image-to-Image unterstützt. Open WebUI führt Image Generation und Image Editing inzwischen als getrennte Engines beziehungsweise Konfigurationen.

Häufiger Fehler: Open WebUI erreicht ComfyUI nicht

Wenn Open WebUI in Docker läuft und ComfyUI direkt auf dem Linux-Host gestartet wurde, funktioniert diese Adresse im Container nicht: http://localhost:8188. Denn localhost bezeichnet dort den Open-WebUI-Container selbst.

Deshalb verwenden wir http://host.docker.internal:8188 und starten Open WebUI unter Linux mit --add-host=host.docker.internal:host-gateway. Genau dafür enthält das offizielle Open-WebUI-Tutorial eine eigene Linux-Anweisung.

Häufiger Fehler: ComfyUI lauscht nur auf localhost

Wird ComfyUI einfach mit python main.py gestartet, kann der Dienst abhängig von der Konfiguration nur lokal erreichbar sein. Für die Integration verwenden wir deshalb python main.py --listen 0.0.0.0. Danach sollte geprüft werden:

ss -tulpen | grep 8188

Häufiger Fehler: Der Workflow funktioniert in ComfyUI, aber nicht in Open WebUI

In diesem Fall ist sehr häufig das falsche JSON exportiert worden. Benötigt wird der API-Workflow. Also: Dev Mode aktivieren → Export (API) → JSON in Open WebUI hochladen. Danach die Node-Zuordnung kontrollieren.

Besonders bei FLUX kann der Key für einen Parameter von klassischen Stable-Diffusion-Workflows abweichen. Open WebUI weist beispielsweise darauf hin, dass Seeds je nach Workflow auch unter einem Namen wie noise_seed auftauchen können.

Datenschutz: Warum diese Lösung für Unternehmen interessant ist

Die Architektur hat einen entscheidenden Vorteil: Prompts und Bilder müssen das eigene System grundsätzlich nicht verlassen. Ollama kann das Sprachmodell lokal betreiben. ComfyUI kann das Bildmodell lokal ausführen. Open WebUI kann selbst gehostet werden.

Damit entsteht eine interessante Grundlage für Unternehmen, Entwickler oder kreative Teams, die keine vertraulichen Produktideen, Entwürfe, interne Informationen oder Prompts an einen externen Image-Generation-Dienst übermitteln möchten.

Dabei gilt natürlich weiterhin: Lokaler Betrieb allein macht ein System noch nicht automatisch sicher. Authentifizierung, Netzwerksegmentierung, Updates, Modelllizenzen, Backup, Benutzerrechte und die Absicherung von Open WebUI und ComfyUI bleiben wichtige Aufgaben. Insbesondere ComfyUI sollte nicht einfach mit Port 8188 öffentlich ins Internet gestellt werden.

Ollama Image Generation unter Linux: Wie geht es weiter?

Spannend ist, dass dieser Aufbau möglicherweise zukünftig noch einfacher wird. Ollamas eigene Image Generation kann bereits mit Modellen wie Z-Image Turbo und FLUX.2 Klein arbeiten. FLUX.2 Klein ist beispielsweise speziell auf schnelle Bildgenerierung ausgelegt und besitzt Varianten mit 4 und 9 Milliarden Parametern. Ollama hebt außerdem die Fähigkeiten bei lesbarem Text innerhalb erzeugter Bilder hervor.

Sobald Ollama seine native Image Generation offiziell für Linux veröffentlicht, könnte in einigen Szenarien aus „Ollama + Open WebUI + ComfyUI + FLUX“ tatsächlich „Ollama + Image Model“ werden. Für einfache Text-to-Image-Aufgaben wäre das enorm komfortabel. ComfyUI dürfte trotzdem relevant bleiben: Wer LoRAs, ControlNet, Inpainting, komplexe Workflows, mehrere Modelle, Referenzbilder oder reproduzierbare Produktions-Pipelines benötigt, erhält mit ComfyUI erheblich mehr Kontrolle.

Ollama oder ComfyUI? Die falsche Frage

Ollama und ComfyUI sind keine direkten Konkurrenten. Sie lösen unterschiedliche Probleme. Ollama ist hervorragend darin, offene Sprach- und multimodale Modelle unkompliziert lokal bereitzustellen. ComfyUI ist hervorragend darin, komplexe generative Bild-Pipelines auszuführen. Open WebUI verbindet beide.

Gerade unter Linux ist deshalb momentan nicht die Frage „Ollama oder ComfyUI?“, sondern: „Warum nicht Ollama und ComfyUI zusammen?“

Fazit: Lokale KI-Bildgenerierung unter Linux funktioniert bereits hervorragend

Native Ollama Image Generation unter Linux ist Stand 31. August 2026 offiziell noch nicht verfügbar. Das bedeutet aber keineswegs, dass Linux-Nutzer warten müssen. Mit Ollama, Open WebUI, ComfyUI und FLUX lässt sich bereits heute eine leistungsfähige lokale KI-Plattform aufbauen: Ollama versteht die Anfrage, das Sprachmodell erstellt oder verbessert den Prompt, Open WebUI orchestriert den Prozess, ComfyUI führt den Workflow aus und FLUX erzeugt das Bild. Und das alles kann auf der eigenen Hardware stattfinden.

Für Linux-Enthusiasten ist diese Kombination deshalb möglicherweise sogar interessanter als eine reine Image-Generation-Funktion innerhalb von Ollama: Sie verbindet die einfache lokale LLM-Verwaltung von Ollama mit der enormen Flexibilität von ComfyUI. Sobald Ollama seine native Bildgenerierung offiziell für Linux freigibt, wird sich diese Landschaft erneut verändern. Bis dahin ist Ollama + Open WebUI + ComfyUI einer der praktischsten Wege, Sprachmodelle und lokale KI-Bildgenerierung unter Linux in einer gemeinsamen Umgebung zu betreiben.

Kurzantwort für Google / Featured Snippet

Kann Ollama unter Linux Bilder generieren? Ollama besitzt seit Januar 2026 eine experimentelle native Image-Generation-Funktion mit Modellen wie Z-Image Turbo und FLUX.2 Klein. Diese wird offiziell jedoch noch nicht für Linux angeboten. Unter Linux lässt sich Bildgenerierung bereits heute über Ollama zusammen mit Open WebUI und ComfyUI realisieren. Ollama übernimmt dabei das Sprachmodell und Prompting, während ComfyUI beispielsweise FLUX zur eigentlichen Bildgenerierung ausführt.

Häufige Fragen zu Ollama und Bildgenerierung unter Linux

Kann Ollama 2026 Bilder erzeugen?

Ja. Ollama führte im Januar 2026 experimentelle Image Generation ein. Unterstützt werden unter anderem Z-Image Turbo und FLUX.2 Klein. Die native Funktion wurde zunächst für macOS veröffentlicht.

Funktioniert Ollama Image Generation unter Linux?

Die native Ollama-Image-Generation wird laut offizieller Ollama-Dokumentation derzeit noch nicht für Linux angeboten. Unter Linux kann Ollama jedoch problemlos mit ComfyUI und Open WebUI kombiniert werden.

Kann ich FLUX unter Linux lokal betreiben?

Ja. ComfyUI unterstützt verschiedene FLUX-Versionen unter Linux, darunter FLUX.1 Schnell, FLUX.1 Dev und neuere FLUX-Modelle.

Benötige ich eine NVIDIA-Grafikkarte?

Nein. ComfyUI unterstützt neben NVIDIA auch AMD- und Intel-GPUs. Die Installation und Beschleunigung unterscheiden sich jedoch je nach Hardware.

Läuft die Bildgenerierung komplett lokal?

Ja, wenn Ollama, Open WebUI, ComfyUI und das verwendete Bildmodell lokal betrieben werden. Für bestimmte Modelle oder Nodes können allerdings externe APIs genutzt werden; für einen vollständig lokalen Betrieb müssen solche Cloud-Komponenten vermieden werden.

Welches Modell eignet sich für den Einstieg?

Für einen einfachen lokalen Einstieg ist FLUX.1 Schnell in einer FP8-Variante interessant. Das Modell arbeitet mit wenigen Generierungsschritten und die FP8-Version reduziert den Speicherbedarf gegenüber höherpräzisen Varianten.

Kann Open WebUI Bilder direkt im Chat generieren?

Ja. Open WebUI unterstützt unter anderem ComfyUI als Image-Generation-Backend. Nach erfolgreicher Konfiguration kann die Bildgenerierung direkt aus dem Chat heraus aufgerufen werden.

Weiterführende Themen

Ollama unter Linux installieren: KI lokal betreiben (Zum Artikel)

Open WebUI + Ollama unter Linux: Eigene ChatGPT-Alternative lokal betreiben (Zum Artikel)

Quellen und Aktualität: Stand des Artikels: 31. August 2026. Für die technische Prüfung wurden insbesondere die aktuelle offizielle Ankündigung von Ollama zur experimentellen Bildgenerierung, die ComfyUI-Installationsdokumentation für NVIDIA-, AMD- und Intel-GPUs sowie die Open-WebUI-Dokumentation zur ComfyUI-Integration herangezogen.