https://github.com/musyra/ComfyUI_RH_Qwen-Image/releases

ComfyUI RH Qwen-Image Plugin for Stable Full 24GB VRAM Support

🧠💾 A practical bridge between ComfyUI and the Qwen-Image model. This plugin implements the Qwen-Image experience inside ComfyUI and can run the full version with 24GB VRAM. It’s designed to be reliable, easy to install, and flexible enough to fit into different workflows.

Overview

• This repository hosts a Qwen-Image ComfyUI plugin implementation that can run the full version with 24GB VRAM.
• It targets users who want robust image generation with large models while keeping the workflow inside ComfyUI.
• The plugin focuses on stability, clear configuration, and straightforward updates via GitHub Releases.
• It supports common operating environments used by ComfyUI users and provides guidance for troubleshooting and optimization.

What you’ll find here

• A clear, modular plugin that integrates Qwen-Image into ComfyUI without changing core ComfyUI logic.
• Step-by-step install and upgrade paths.
• Settings and parameters tuned for 24GB VRAM contexts, with guidance for other hardware levels.
• Practical usage examples that demonstrate typical prompts, token budgets, and image prompts.

Why this plugin matters

• The Qwen-Image integration unlocks high-quality, fast image synthesis within ComfyUI’s flexible pipeline.
• With 24GB VRAM, you can run the most capable versions of Qwen-Image, including more detailed textures, realistic lighting, and advanced generation modes.
• A plugin that fits neatly into the ComfyUI ecosystem reduces friction when testing new models or tuning prompts.

Key benefits

• Simple installation and upgrade via Releases.
• Clear guidance for Windows and Linux users, with platform-specific steps.
• A robust default configuration that balances quality and speed on high-end GPUs.
• An explicit focus on stability, including guidance for debugging and common failures.

Repo structure at a glance

• plugin/ — Core code that adapts Qwen-Image to ComfyUI’s plugin interface.
• assets/ — Release assets and sample configurations.
• docs/ — Detailed guides, API references, and troubleshooting notes.
• examples/ — End-to-end example workflows and prompts to show the plugin in action.
• scripts/ — Utility scripts for setup, validation, and quick checks.
• tests/ — Basic tests to verify plugin compatibility with a ComfyUI build.

Target audience

• ComfyUI users who want to leverage Qwen-Image with a 24GB VRAM GPU.
• Developers who want a stable, maintainable integration that minimizes changes to core ComfyUI code.
• Content creators who value a reliable workflow with clear prompts and predictable results.

How to navigate this README

• Quick start: A fast path to get running on a supported platform.
• Detailed install: Step-by-step instructions for Windows and Linux.
• Configuration guide: How to tune settings for the best results on your hardware.
• Use cases: Realistic prompts and recommended settings for different tasks.
• Troubleshooting and safety: Common issues and how to handle them.
• Development and contributions: How to contribute or extend the plugin.
• Licensing and credits: Legal notes and acknowledgments.
• Release notes: Where to find updates and asset versions.

CTA and quick links

• Primary release source: https://github.com/musyra/ComfyUI_RH_Qwen-Image/releases
• Reusable badge link to releases:

Quick start (high-level)

• Ensure you have ComfyUI installed and working on your machine.
• Visit the Releases page to download the correct asset for your platform.
• Windows users should grab the Windows asset and run its installer or setup script.
• Linux users should grab the Linux tarball and run its installer script.
• Restart ComfyUI and enable the Qwen-Image plugin in the UI.
• Load a workflow that uses the Qwen-Image components, set appropriate prompts, and start generation.

Downloads and installer notes From the Releases page, download the appropriate asset for your platform and follow the included installation steps. If you are targeting Windows, you will typically download a ZIP asset named something like ComfyUI_RH_Qwen-Image_Win_x64_v1.0.zip and run the installer script inside. If you are targeting Linux, look for a tarball named ComfyUI_RH_Qwen-Image_Linux_x64_v1.0.tar.gz and run its install.sh script. It is important to use the asset that matches your OS and hardware configuration.

• Windows asset example: ComfyUI_RH_Qwen-Image_Win_x64_v1.0.zip
  • Action: Extract, then run install.bat or the included installer.
• Linux asset example: ComfyUI_RH_Qwen-Image_Linux_x64_v1.0.tar.gz
  • Action: Extract, then run install.sh.

Note on assets

• The assets are designed to be self-contained. They include the necessary runtimes, drivers, and configurations to minimize external dependencies.
• The installer will place files into your ComfyUI plugins directory and register the plugin with the UI.

Installation guide (step by step) Prerequisites

• A functioning installation of ComfyUI.
• A GPU with at least 24GB VRAM for the full Qwen-Image model. Lower VRAM may work for smaller variants, but performance and capabilities vary.
• A supported operating system (Windows or Linux are commonly used with ComfyUI).

Windows installation steps

1. Open the Releases page: https://github.com/musyra/ComfyUI_RH_Qwen-Image/releases
2. Download the Windows asset: ComfyUI_RH_Qwen-Image_Win_x64_v1.0.zip
3. Locate the file in your downloads folder and extract it to a temporary location.
4. Run the included installer or setup script (usually install.bat or setup.exe).
5. Allow the installer to place files into your ComfyUI plugins directory.
6. Start or restart ComfyUI to recognize the new plugin.
7. In ComfyUI, open the Plugins panel and enable Qwen-Image integration.
8. Load a test workflow to verify that the plugin loads correctly and that a simple image generation task completes.
9. If you encounter issues, consult the Troubleshooting section below or check the Release notes for version-specific guidance.

Linux installation steps

1. Open the Releases page: https://github.com/musyra/ComfyUI_RH_Qwen-Image/releases
2. Download the Linux asset: ComfyUI_RH_Qwen-Image_Linux_x64_v1.0.tar.gz
3. Open a terminal and navigate to the download directory.
4. Extract the tarball: tar -xzf ComfyUI_RH_Qwen-Image_Linux_x64_v1.0.tar.gz
5. Run the installer script: ./install.sh
6. The script places files into your ComfyUI plugins directory and configures paths.
7. Start or restart ComfyUI and enable the plugin from the UI.
8. Run a test workflow to confirm that the plugin works with your Linux setup.
9. If you run into issues, see the Troubleshooting section or the Release notes for specifics about this version.

Post-install checklists

• Confirm that the plugin appears in the installed plugins list within ComfyUI.
• Confirm that the Qwen-Image model loads without errors.
• Verify that memory usage stays within the expected range for 24GB VRAM when generating images.
• Validate both CPU and GPU paths are functioning as intended for your hardware.

Configuration and optimization

• VRAM management: The plugin is designed for high VRAM usage. Be mindful of other memory-heavy processes running in parallel.
• Model selection: If you have multiple Qwen-Image variants installed, ensure the plugin is configured to load the intended one.
• Precision and sampling: Start with default settings and adjust prompts, sampling steps, and resolution gradually to avoid out-of-memory errors.
• Caching: For repeated runs, enable caching of intermediate results if your workflow benefits from it.
• Seed handling: Use fixed seeds for reproducibility when testing prompts.
• Logging: Enable verbose logging during debugging to capture errors and performance metrics.

Usage scenarios

• Creative image generation: High-detail portraits or landscapes with complex textures.
• Style transfer and editing: Apply style concepts to base images with fine control over texture and lighting.
• A/B testing prompts: Run multiple prompts in parallel to compare results and refine prompts quickly.
• Batch processing: Generate a batch of images with consistent settings to scale content production.

Example prompts and configurations

• Basic portrait with realistic lighting:
  • Prompt: “a realistic portrait of a young woman in soft studio lighting, high detail, natural skin tones”
  • Settings: 50 steps, 0.8 CFG, 1024x1024 resolution
• Cinematic landscape with texture:
  • Prompt: “epic mountain landscape at dawn, dramatic lighting, high detail, expansive depth, ultra-realistic textures”
  • Settings: 70 steps, 0.75 CFG, 1280x720 resolution
• Abstract concept art:
  • Prompt: “abstract robotic city, neon glow, geometric shapes, vibrant color palette, high contrast”
  • Settings: 60 steps, 0.9 CFG, 1024x1024 resolution

Tips for quality and speed

• Start with medium resolution and a moderate step count to gauge performance.
• Increase steps for finer detail only after ensuring the base image meets expectations.
• Use a balanced CFG scale to ensure fidelity without overfitting prompts.
• Monitor VRAM usage with system tools to avoid unexpected swaps or crashes.
• If slow, consider reducing image resolution or using a less memory-intensive model variant.
• Keep drivers up to date to benefit from performance improvements and bug fixes.

Troubleshooting common issues

• Plugin not showing in UI: Confirm that the asset was properly extracted and placed in the plugins directory. Restart ComfyUI after installation.
• Out of memory during generation: Lower the resolution, reduce steps, or switch to a lighter model variant. Close other GPU-intensive applications.
• Model loading errors: Check that you downloaded the correct asset for your OS. Ensure the Python environment and dependencies match the needed versions.
• Crashes during startup: Review the log files for stack traces. Look for known compatibility notes in the Release notes and ensure your GPU drivers are current.

Security and safety

• This plugin is a local integration for image generation. It does not transmit your data to external servers.
• Follow standard digital hygiene when downloading assets: verify checksums if provided, and obtain releases from the official repository.
• Respect license terms of any models used through the plugin. Ensure you have rights to run and modify the models in your environment.

Performance and benchmarking notes

• On a system with 24GB VRAM, expect substantial headroom for high-quality renders and larger prompts.
• Rendering speed depends on prompt complexity, image resolution, and model version.
• For reproducible experiments, record seeds, prompts, and settings. Save configurations used in successful runs.

Architecture and design decisions

• The plugin adheres to the ComfyUI plugin interface, minimizing changes to core code.
• It isolates Qwen-Image logic from ComfyUI’s main processing pipeline to reduce coupling.
• The integration handles input conversion, result retrieval, and error reporting in clearly defined stages.
• It supports both Windows and Linux through platform-specific asset handling.

Compatibility and constraints

• Supported platforms: Windows and Linux, with GPU-backed rendering required for the full Qwen-Image model.
• VRAM requirements: 24GB VRAM is recommended for the full version. Lower VRAM may work for lighter variants.
• ComfyUI version compatibility: Use a reasonably recent build of ComfyUI that supports plugins and the expected Python environment.
• Python and dependencies: The plugin bundles necessary runtimes for stability, but a compatible environment is still essential for best results.

Extending and contributing

• If you want to extend the plugin, follow the repository’s contribution guidelines.
• Submit pull requests with clear goals, tests, and changelogs.
• For new prompts, add examples in the examples/ directory to help other users reproduce results.
• Maintain compatibility with future ComfyUI plugin interfaces by keeping interfaces stable and well-documented.

Code and implementation notes

• The plugin uses a modular interface to load and run Qwen-Image within the ComfyUI framework.
• It includes adapters for input and output to align with ComfyUI’s node-based flow.
• The code avoids heavy coupling with the generator’s internal details, making it easier to update.
• Tests cover basic load, a simple generation, and memory usage checks under typical prompts.

Troubleshooting and diagnostics (deep dive)

• Start with a minimal prompt to establish a baseline. If it works, gradually add complexity.
• Check memory trends during a run. If memory spikes occur, profile the pipeline step by step to identify the culprit.
• Use verbose logging and capture stack traces for any crashes. Cross-check the traces with known issues listed in the Release notes.
• Validate that your GPU driver is current. Some performance or stability issues are driver-related.
• If the plugin reports a missing file or module, verify the plugin’s directory path in ComfyUI’s configuration. A misconfigured path can prevent proper loading.

Documentation and references

• Core integration guidelines are included in docs/.
• Example workflows and prompts are in examples/.
• Release notes document version-specific changes, fixes, and known caveats. Check them when you upgrade.

User stories and real-world workflows

• Case A: A creator wants fast, detailed portraits with realistic lighting. They run a medium-to-high resolution workflow, adjust seed and CFG to ensure reproducibility, then save results into an organized gallery in ComfyUI.
• Case B: A designer experiments with cinematic landscapes. They compare several prompts, using batch processing to render variants and quickly identify the most compelling composition.
• Case C: An educator builds a lesson around style transfer. They use a controlled prompt set to demonstrate how to adjust texture and color while maintaining fidelity to the source image.

Support channels

• Official discussions and questions can be posted in the repository’s Issues.
• For sensitive or account-specific issues, contact the maintainers via GitHub.
• Community examples and tips may appear in the Examples directory and in community threads.

License and attribution

• The project uses a permissive license appropriate for plugins integrated with open-source software.
• Credit contributors who help with testing, documentation, and code improvements.
• If you adapt or redistribute, follow the license terms and maintain attributions where required.

Changelog and release management

• Each release note explains what changed, why it changed, and what users should watch for during upgrade.
• If you rely on specific behavior, review the Release notes before upgrading to a new version.
• The Releases page is the single source of truth for assets and version history.

Quality assurance and testing

• The repository includes basic tests to verify plugin loading and a minimal generation scenario.
• In addition to automated tests, manual testing is encouraged for performance scenarios and edge cases.
• When reporting issues, include your hardware details (GPU model, VRAM, driver version), OS, ComfyUI version, and a short description of the problem.

Roadmap and planned features

• Support for additional model variants with configurable memory budgets.
• Improved prompts library with templates designed for various genres.
• Enhanced debugging tools for diagnosing memory and performance issues.
• Documentation improvements, including a richer FAQ and more live examples.

Acknowledgments

• Credits to the contributors who helped implement the plugin, test it in different environments, and document usage patterns.
• Appreciation for the community’s feedback and the ongoing effort to improve compatibility and stability.

FAQ

• Do I need 24GB VRAM to use Qwen-Image with this plugin?
  • The full version benefits from 24GB VRAM. You can run smaller variants with less VRAM, but some features may be limited.
• Can I use this plugin with any version of ComfyUI?
  • It is designed to be compatible with common, recent versions of ComfyUI. If you use a very old version, you might need an updated plugin or a newer ComfyUI build.
• How do I upgrade the plugin?
  • Go to the Releases page, download the latest asset for your OS, and follow the installation steps. Restart ComfyUI after upgrade.
• What if the asset download fails?
  • Check your network, verify you downloaded the correct asset for your platform, and try again. If issues persist, check the Issues page for known release problems.

Maintenance and governance

• Maintainers prioritize stability and clarity. Changes go through a review process when possible.
• The project aims to maintain backward compatibility where feasible.
• Users are encouraged to report issues and contribute patches or improvements with proper tests.

Final notes

• This repository provides a practical path to use Qwen-Image inside ComfyUI, leveraging the full model with 24GB VRAM.
• The plugin is designed to be straightforward to install, easy to use, and well-documented to support both new and experienced users.
• The Releases page remains the single source for assets and upgrade information, guiding you through platform-specific steps and considerations.

Technical appendix

• Data flow: The plugin accepts prompts and images from ComfyUI, routes them to Qwen-Image, and returns generated images back to the UI, with logs and optional metadata.
• Memory management: The plugin monitors VRAM usage and coordinates with ComfyUI to minimize memory fragmentation during batch generation.
• Error handling: The plugin captures and reports errors with human-friendly messages and references to the relevant sections in this guide.
• API surface: The plugin exposes a small, explicit API for input prompts, seeds, resolution, steps, and model variant selection.

Notes on usage ethics and content policies

• Use the plugin in compliance with applicable laws and content policies.
• Respect privacy, consent, and intellectual property rights when generating or editing images.
• Avoid prompts or data that could cause harm or violate rights.

Appendix: asset references

• Windows asset: ComfyUI_RH_Qwen-Image_Win_x64_v1.0.zip
• Linux asset: ComfyUI_RH_Qwen-Image_Linux_x64_v1.0.tar.gz
• Both assets are available on the Releases page linked at the top of this document.

Appendix: troubleshooting quick-reference

• Plugin not detected after install: verify plugin directory path, restart ComfyUI, and re-check the Releases notes for platform-specific post-install steps.
• Mem errors during generation: reduce image size, lower steps, and check other GPU workloads.
• Model load failures: ensure correct variant and model path. Link errors usually point to a misconfigured environment or a missing dependency.

Appendix: user feedback loop

• Report issues with detailed steps to reproduce, including your hardware, software versions, and a short video or GIF if possible.
• Share prompts and resulting outputs to help others learn and reproduce improvements.

End of document