ComfyUI on Fedora 43: Two Virtual Environments + One-Click Start (March 2026)

ComfyUI on Fedora 43: Two Virtual Environments + One-Click Start (March 2026)
Date: March 2026
OS: Fedora 43
Goal: Keep two Python venvs (e.g., 3.12 + 3.14) for compatibility, but start ComfyUI automatically with a clean, lightweight setup.
Enterprise Delivery Operating System
This guide is part of the Enterprise Delivery Operating System series. Use these category hubs to navigate the full stack (infra → workflows → governance).
ArchitectureReference architecture for the Enterprise Delivery Operating System.
DevOps & RuntimeDeployments, services, ports, runtime operations, and repeatability.
AI Tooling & AutomationLocal AI stack, orchestration, automation, and stable workflows.
Security & CompliancePermissions, hardening, and safe defaults for local AI systems.
Observability & PerformancePerformance tuning, monitoring, VRAM/RAM budgeting, and stability.
Why keep two venvs?
AI tooling moves fast. Some nodes and wheels lag behind the newest Python, while others require it.
- Python 3.12 venv → “boring but compatible” (TensorRT/LW wheels/Lightning often happier)
- Python 3.14 venv → newest features, but more missing wheels / import issues are common
Rule: never mix installs between venvs. Always run ComfyUI from the venv you intend.
Setup: One script per venv
Create a small launcher script that:
1) switches into ComfyUI folder
2) activates the chosen venv
3) runs ComfyUI on localhost
1) Create a launcher for Python 3.12 venv
mkdir -p ~/.local/bin
cat > ~/.local/bin/comfyui-start-312.sh <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
cd /home/x/ai/ComfyUI
source /home/x/ai/ComfyUI/.venv312/bin/activate
exec python main.py --listen 127.0.0.1 --port 8188
EOF
chmod +x ~/.local/bin/comfyui-start-312.sh
2) (Optional) Create a launcher for Python 3.14 venv
cat > ~/.local/bin/comfyui-start-314.sh <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
cd /home/x/ai/ComfyUI
source /home/x/ai/ComfyUI/.venv/bin/activate
exec python main.py --listen 127.0.0.1 --port 8189
EOF
chmod +x ~/.local/bin/comfyui-start-314.sh
Now you can run either version without thinking:
- ~/.local/bin/comfyui-start-312.sh
- ~/.local/bin/comfyui-start-314.sh
Autostart: systemd user service (best option)
This starts ComfyUI at login, restarts on crash, and stays minimal (no root, no heavy wrappers).
1) Create the user service for 3.12
mkdir -p ~/.config/systemd/user
cat > ~/.config/systemd/user/comfyui312.service <<'EOF'
[Unit]
Description=ComfyUI (Python 3.12 venv)
After=network.target
[Service]
Type=simple
WorkingDirectory=/home/x/ai/ComfyUI
ExecStart=/home/x/.local/bin/comfyui-start-312.sh
Restart=on-failure
RestartSec=2
Environment=PYTHONUNBUFFERED=1
[Install]
WantedBy=default.target
EOF
2) Enable + start
systemctl --user daemon-reload
systemctl --user enable --now comfyui312.service
systemctl --user status comfyui312.service --no-pager
3) Logs (debug)
journalctl --user -u comfyui312.service -f
(If you also want the 3.14 service, repeat with comfyui314.service and the other script.)
One click GUI: Desktop launcher (open ComfyUI in browser)
This creates an app entry in your menu. Clicking it:
1) starts the service
2) opens the UI in your browser
mkdir -p ~/.local/share/applications
cat > ~/.local/share/applications/comfyui.desktop <<'EOF'
[Desktop Entry]
Type=Application
Name=ComfyUI (Local)
Comment=Start ComfyUI and open the UI
Exec=sh -lc 'systemctl --user start comfyui312.service; xdg-open http://127.0.0.1:8188'
Icon=utilities-terminal
Terminal=false
Categories=Graphics;AI;
EOF
Notes that prevent common mistakes
- If you see pip installing into ~/.local/..., you’re not in the right venv (or you didn’t activate it).
- If a node fails with pkg_resources missing → install setuptools inside the chosen venv:source /home/x/ai/ComfyUI/.venv312/bin/activatepython -m pip install -U pip setuptools wheel
- TensorRT node failures are normal on newer Python builds: if you don’t need it, disable that custom node folder.
Next reads
If you want to go deeper, these guides connect directly to the setup above:
ComfyUI nodes: dependency fixes (Lightning, pkg_resources, ffmpeg)Fix common node import failures and keep your ComfyUI stack stable across updates.
Two venvs, two ports, zero confusionRun multiple ComfyUI instances cleanly: ports, services, and predictable profiles.
VRAM budgeting: what actually reduces OOMPractical VRAM tactics: attention modes, model sizes, batching, and real-world limits.
Local AI hardening: permissions, sandboxing, and safe defaultsReduce risk on local AI systems: file permissions, service isolation, and safer defaults.
Tradeoffs (quick)
systemd user service
- ✅ stable, auto-restart, low overhead, clean
- ⛔ needs initial setup once
desktop launcher
- ✅ one click workflow
- ⛔ still depends on the browser UI
two venvs
- ✅ best of both worlds (compat + latest)
- ⛔ you must keep ports/services separated to avoid confusion
Related Articles

Ollama Is Not the Product: Building Production-Ready Open-LLM Applications
Running a local model with Ollama is easy. Building a production-ready Open-LLM application is harder: it requires RAG, access control, provider abstraction, evaluation, logging, deployment discipline and a controlled application layer around the model.

What Is an AI Solution Architect? System Boundaries, Responsibilities and Trade-offs
An AI Solution Architect turns business requirements into a production-ready AI system across data, models, tools, security, runtime, evaluation and operations.

Google I/O 2026: Antigravity, AI Studio, and the Shift to Agentic DevTools
Google I/O 2026 made one thing clear for engineers: AI tooling is moving beyond autocomplete into managed agentic execution. This article breaks down Antigravity 2.0, the expanding role of Google AI Studio, Gemini 3.5 Flash, and the real trade-offs around orchestration, lock-in, verification, and developer workflow design.

How to Know Whether an AI Agent Actually Used the Right Evidence
An AI agent can cite sources and still use the wrong evidence. This article introduces a practical method for checking claim support, source authority, applicability, provenance, and whether the evidence actually influenced the answer.

Comprehensive Guide to Rollback Triggers in Enterprise AI Runbooks
This guide explores Rollback Triggers, essential mechanisms in enterprise AI runbooks that automatically detect anomalies and initiate rollbacks to maintain system stability. Learn how to configure, monitor, and optimize these triggers for robust AI deployments.

Google I/O 2026: Gemini Omni, Gemini 3.5, and the Compute Layer Behind Agentic AI
Google I/O 2026 put Gemini Omni and Gemini 3.5 at the center of Google’s agentic AI strategy. This article breaks down the difference between multimodal creation and action-grade intelligence, why Gemini 3.5 Flash matters for agents and coding, and how these models power the wider Google I/O 2026 platform shift.

Comprehensive Metrics Guide for Delivery and Change Management
This guide provides a detailed overview of essential metrics for enterprise delivery and change management, helping teams measure performance, optimize processes, and drive continuous improvement. Discover key indicators, calculation methods, and best practices to align your metrics with business outcomes.

Migrating from OpenAI Agents SDK to the Agents API: What Actually Changes Architecturally?
Migrating from the OpenAI Agents SDK to the new Agents API is not an import rename. The runtime boundary changes: the agent loop, durable session, orchestration, context compaction and recovery move toward a managed harness. This guide shows what should move, what should stay in your application, and how to prove the migration before cutover.

MCP Explained: What It Connects, What It Does Not Do and Where It Fits
Model Context Protocol connects AI applications to external tools, resources and prompts through a standard client-server boundary. Learn what MCP does, what it does not do, and where it fits in agent architecture.

Enterprise Start Here: Your Gateway to Operational Excellence
New to our enterprise platform? This guide provides a structured onboarding path, from foundational reference models to actionable playbooks, runbooks, and assessments designed for seamless implementation.

Beyond Prompt Engineering: A Methodology for More Reliable AI Reasoning
Large language models do not necessarily fail because they lack reasoning capability. They often fail because the reasoning process is not sufficiently constrained, challenged, or verified. This article presents a domain-independent methodology that turns prompting into a structured epistemic process: separating facts from assumptions, generating competing hypotheses, testing counter-evidence, applying falsification, and checking whether conclusions remain stable under alternative framings. The goal is not to make the model “agree less,” but to make its conclusions less dependent on the user’s initial framing.

Can Evidence Survive the AI Pipeline? — The Evidence Preservation Chain
Evidence can be correct at the source and still become unreliable after parsing, normalization, chunking, retrieval and context assembly. The Evidence Preservation Chain tracks whether identity, provenance, scope and meaning survive the entire AI pipeline.