Hey there! I've been playing around with this cool new tool called ComfyUI 3D Pack, and I want to tell you all about it. It's basically like having a 3D artist in your computer - but one that works really fast and doesn't need coffee breaks!

## What's This All About?

You know how making 3D stuff usually means spending hours learning complicated software? Well, this tool changes everything. It's like having a magic wand that turns regular pictures into 3D models. I'm not kidding - you can take a photo of your cat and turn it into a 3D model that you can spin around and look at from any angle!

The best part? It works right inside ComfyUI, which is already super popular for making AI art. If you're already using ComfyUI, you'll feel right at home.

## Cool Stuff You Can Do

Let me tell you about some of the awesome things this pack can do. It's like having a whole toolkit of 3D magic tricks:

## Single-Stage Models

### 1. TRELLIS (microsoft/TRELLIS)
- **Purpose**: Single image to 3D mesh with RGB texture
- **Model Location**: huggingface.co/JeffreyXiang/TRELLIS-image-large
- **Input**: Single image
- **Output**: Textured 3D mesh

**TRELLIS** introduces a structured 3D latent representation (SLAT) that combines sparse 3D grids with dense multi-view visual features from foundation models, enabling high-quality 3D generation across multiple formats (Radiance Fields, 3D Gaussians, meshes). The method employs Rectified Flow Transformers trained on 500K 3D assets, achieving state-of-the-art results through:

1. **Unified Representation** - SLAT's hybrid structure preserves both geometric detail (via sparse active voxels) and textural richness (through vision model features)
2. **Scalable Architecture** - 2B parameter model supporting text/image-conditioned generation
3. **Versatile Outputs** - Native support for different 3D representations without post-processing
4. **Editing Capabilities** - Enables asset variants and local manipulations through latent space operations


### 2. StableFast3D (Stability-AI/stable-fast-3d)
- **Purpose**: Quick single image to 3D mesh conversion
- **Special Note**: Requires Stability-AI terms agreement
- **Location**: Under Checkpoints/StableFast3D
- **Requirements**: Huggingface token in system.conf

**Stable Fast 3D** is Stability AI's real-time 3D generation model that converts single images into textured 3D meshes in 500ms. Key features:

1. **Ultra-Fast Conversion** - Generates UV-unwrapped meshes with material parameters in 0.5s (7GB VRAM) vs previous 10-minute generation times
2. **Enhanced Outputs** - Produces:
   - Illumination-reduced albedo textures
   - Optional quad/triangle remeshing (+100-200ms)
   - Normal maps and material parameters
3. **Applications** - Targets game development (background assets), AR/VR prototyping, e-commerce 3D modeling, and architectural visualization
4. **Access** - Available through:
   - Hugging Face (Community License for ≤$1M revenue)
   - Stability AI API
   - Stable Assistant chatbot with AR preview
5. **Technical Base** - Built on TripoSR architecture with retrained weights and mesh generation improvements

The model demonstrates a 1200x speed improvement over previous SV3D while maintaining output quality, positioning it as a rapid prototyping tool for 3D content creation.


## Two-Stage Models

### 3. Hunyuan3D_V2 (tencent/Hunyuan3D-2)
**Stage 1**: Single image → 3D mesh shape
**Stage 2**: Shape + reference image → Textured 3D mesh
- **Weights**: huggingface.co/tencent/Hunyuan3D-2/tree/main

**Hunyuan3D-2** is Tencent's scalable 3D generation system combining a 2.6B parameter shape model (Hunyuan3D-DiT) and 1.3B parameter texture model (Hunyuan3D-Paint). Key technical features:

1. **Architecture**  
   - Shape Generation: Flow-based diffusion transformer produces meshes from images/text
   - Texture Synthesis: Geometry-aware diffusion model (1024px+ resolution)
   - Unified pipeline supports both generated and custom meshes

2. **Performance**  
   - Outperforms SOTA in metrics: CMMD (3.193), FID_CLIP (49.165), CLIP-score (0.809)
   - Processes shape+texture in 24.5GB VRAM

3. **Deployment**  
   - Blender integration via addon
   - API server with GLB output

4. **Ecosystem**  
   - Community contributions: Windows tools, ComfyUI plugins
   - Enterprise platform (Hunyuan3D Studio) for asset management
   - Active development with TensorRT optimization roadmap

The system demonstrates state-of-the-art performance in conditional 3D asset generation while maintaining practical usability through multiple integration pathways.


### 4. Hunyuan3D_V1 (tencent/Hunyuan3D-1)
**Stage 1**: Single image → multi-views
**Stage 2**: Multi-views → Textured 3D mesh
- **Weights**: huggingface.co/tencent/Hunyuan3D-1/tree/main

Tencent Hunyuan3D-1.0 ([GitHub](https://github.com/Tencent/Hunyuan3D-1)) is a unified framework for 3D content generation that supports both text and image inputs. The system uses a novel two-stage pipeline:

1. **Multi-view Generation**: A diffusion model rapidly produces multi-view RGB images (4 seconds)
2. **3D Reconstruction**: A neural network converts these views into textured 3D meshes (7 seconds)

Key advantages include:
- Dual support for text/image prompts through integration with Hunyuan-DiT
- Significant speed improvements (10-25s generation time)
- Quality preservation through noise-handling reconstruction
- Open-source implementation with pre-trained models
- Commercial-friendly license (except baking module)

The framework offers lite and standard versions, with the standard model achieving superior quality while maintaining practical generation speeds. Installation requires CUDA-enabled GPUs and dependencies like PyTorch3D, with pre-trained models available via Hugging Face Hub.


## Advanced Multi-Stage Models

### 5. Unique3D (AiuniAI/Unique3D)
**Four-Stage Pipeline**:
1. Single image → 4 views (256x256)
2. Upscale to 512x512 → 2048x2048
3. Generate normal maps
4. Create textured 3D mesh

**Required Models**:
- sdv1.5-pruned-emaonly
- controlnet-tile
- ip-adapter_sd15
- OpenCLIP-ViT-H-14
- RealESRGAN_x4plus

**[Unique3D](https://github.com/AiuniAI/Unique3D)** ([Project Page](https://wukailu.github.io/Unique3D/)) is an open-source framework for rapid 3D mesh generation from single images, featuring:

**Core Capabilities**  
- 🚀 30-second generation of textured 3D meshes  
- 🖼️ Handles both object-centric and scene-level images  
- 🔄 Two-stage pipeline: Multi-view synthesis → Mesh reconstruction  

**Technical Highlights**  
- Hybrid architecture combining diffusion models with geometric processing  
- Adaptive view selection mechanism  
- Normal-map guided mesh refinement  

**Implementation Features**  
- Multiple deployment options:  
  - Local Gradio interface ([Demo](https://huggingface.co/spaces/AiuniAI/Unique3D))  
  - ComfyUI integration  
  - Docker support  
- Windows/Linux compatibility  
- MIT-licensed commercial use  

The system achieves 1280×1280 resolution outputs while maintaining 10× speed advantage over previous methods, though performance depends on input image quality and object orientation. Current limitations include sensitivity to occlusions and requirement for clear object boundaries in input images.


### 6. Era3D MVDiffusion
- **VRAM**: Minimum 16GB required
- **Output**: 6 multi-view images + normal maps (512x512)
- **Source**: pengHTYX/Era3D


**[Era3D](https://github.com/pengHTYX/Era3D)** ([Project Page](https://penghtyx.github.io/Era3D/)) introduces a high-resolution 3D generation framework with these key features:

**Core Innovation**  
- 🖼️ 512×512 multiview synthesis using row-wise attention  
- 🔄 Two-phase generation:  
  1. Multi-view RGB/Normal maps (4s)  
  2. Instant-NSR mesh reconstruction (7s)  

**Technical Highlights**  
- Orthogonal projection variant for input-view consistency  
- Hybrid training strategy combining 2D/3D supervision  
- Memory-efficient architecture (8GB VRAM usage)  

**Implementation**  
- Requirements:  
  - CUDA 11.8 + RTX 3090/4090 GPUs  
  - Specialized dependencies (xformers, nvdiffrast)  
- Deployment options:  
  - Local inference scripts  
  - Pre-trained models via Hugging Face  
  - Background removal integration  

The system achieves 3D reconstruction in ~11 seconds total while handling complex textures, though requires careful background preprocessing. Current limitations include AGPL-3.0 license constraints and sensitivity to input image perspective distortions.


### 7. InstantMesh Reconstruction
- **Input**: Multi-view images (white background)
- **Output**: RGB textured 3D mesh
- **Compatibility**: Works with Zero123++ and CRM MVDiffusion


**[InstantMesh](https://github.com/TencentARC/InstantMesh)** ([Paper](https://arxiv.org/abs/2404.07191)) is an efficient framework for single-image 3D generation with these key features:

**Core Architecture**  
- 🕒 30-second generation pipeline:  
  1. Multi-view synthesis (4s)  
  2. Sparse-view reconstruction (26s)  
- 🔄 Dual representation:  
  - Neural Radiance Fields (NeRF)  
  - Explicit textured meshes  

**Technical Highlights**  
- Hybrid mesh baking combining vertex colors & texture maps  
- Memory-optimized attention mechanisms (8GB VRAM usage)  
- Background-aware reconstruction via rembg integration  

**Implementation**  
- Multiple deployment options:  
  - Local Gradio/CLI  
  - Docker containers  
  - ComfyUI plugin  
- Training support for:  
  - Custom reconstruction models  
  - Zero123++ fine-tuning  
- Apache 2.0 licensed commercial use  

The system achieves 512×512 resolution outputs while maintaining 10× speed advantage over optimization-based methods, though requires high-quality input images for best results. Current limitations include dependency on CUDA 12.1+ and sensitivity to input image perspective.



## Specialized Models

### 8. CharacterGen (zjp-shadow/CharacterGen)
- **Purpose**: Character modeling from front view
- **Feature**: Works with Unique3D for enhanced results

**[CharacterGen](https://github.com/zjp-shadow/CharacterGen)** ([Paper](https://dl.acm.org/doi/10.1145/3658217)) introduces an anime-style 3D character generation system with these key features:

**Core Architecture**  
- 🎭 Two-phase generation:  
  1. Pose-canonicalized multi-view synthesis  
  2. Geometry-consistent 3D reconstruction  
- 🔄 VRM format support for animation-ready outputs  

**Technical Highlights**  
- Multi-view pose normalization for consistency  
- Hybrid rendering pipelines:  
  - Blender VRM add-on  
  - Three.js implementation  
- Anime3D dataset compatibility  

**Implementation**  
- Deployment options:  
  - Integrated Gradio web interface  
  - Modular 2D/3D stage separation  
- Requirements:  
  - CUDA-enabled GPUs  
  - PyTorch3D dependencies  
- Apache 2.0 licensed commercial use  

The system achieves 512×512 resolution character generation while maintaining anatomical consistency through pose calibration. Current limitations include dependency on VRM model preprocessing and requirement for high-quality input images. Pre-trained weights are available via [Hugging Face](https://huggingface.co/zjpshadow/CharacterGen).


### 9. Zero123++ (SUDO-AI-3D/zero123plus)
- **Output**: 6 view images (320x320)
- **Views**: Front, Back, Left, Right, Top, Down


**[Zero123++](https://github.com/SUDO-AI-3D/zero123plus)** ([Paper](https://arxiv.org/abs/2310.15110)) is a multi-view diffusion model for 3D generation with these key features:

**Core Architecture**  
- 🖼️ Single-image to 6-view synthesis (5GB VRAM)  
- 📐 Fixed camera parameters:  
  - Azimuth: 30° increments  
  - Elevation: 20°/-10° (v1.2)  
  - FOV: 30° fixed output  

**Technical Highlights**  
- Depth ControlNet for geometric consistency  
- Normal map generation for alpha matting  
- Adaptive step scheduling (28-100 steps)  

**Implementation**  
- Deployment options:  
  - Diffusers custom pipeline  
  - Streamlit/Gradio interfaces  
  - Hugging Face integration  
- Requirements:  
  - CUDA-enabled GPUs  
  - Torch 2.0+ recommended  

The model achieves 512×512 resolution outputs with CC-BY-NC licensed weights, requiring square input images (≥320px). Current limitations include non-commercial license restrictions and fixed viewpoint outputs. Pre-trained models available via [Hugging Face](https://huggingface.co/sudo-ai).


### 10. TripoSR
- **Function**: NeRF to 3D mesh conversion
- **Method**: Marching cubes algorithm
- **Source**: VAST-AI-Research/TripoSR

**[TripoSR](https://github.com/VAST-AI-Research/TripoSR)** ([Paper](https://arxiv.org/abs/2403.02151)) is a state-of-the-art open-source model for rapid 3D reconstruction from single images, featuring:

**Core Architecture**  
- ⚡️ 0.5-second generation on A100 GPUs  
- 🔄 Two-phase processing:  
  1. Multi-view synthesis  
  2. Feed-forward 3D reconstruction  

**Technical Highlights**  
- MIT-licensed commercial use  
- 6GB VRAM requirement per image  
- Texture baking support (up to 2048px)  

**Implementation**  
- Requirements:  
  - CUDA version matching PyTorch's CUDA version  
  - Python 3.8+  
- Deployment options:  
  - Command-line interface  
  - Local Gradio web demo  
  - Batch processing support  

The model achieves real-time performance while maintaining quality through its LRM-based architecture. Current limitations include dependency on CUDA version alignment and requirement for square input images. Pre-trained weights are included in the repository under MIT license.


### 11. Wonder3D
- **Output**: 6 consistent views + normal maps
- **Source**: xxlong0/Wonder3D

**[Wonder3D++](https://github.com/xxlong0/Wonder3D)** ([Project Page](https://www.xxlong.site/Wonder3D/)) introduces a cross-domain diffusion framework for 3D generation with these key features:

**Core Architecture**  
- 🕒 3-minute generation pipeline:  
  1. Multi-view RGB/Normal synthesis (2m)  
  2. Cascaded mesh reconstruction (1m)  
- 🔄 Cross-domain attention mechanism  

**Technical Highlights**  
- AGPL-3.0 licensed code (commercial restrictions)  
- Iterative refinement through `num_refine` parameter  
- Camera projection support:  
  - Orthographic (`--camera_type ortho`)  
  - Perspective (`--camera_type persp`)  

**Implementation**  
- Training requirements:  
  - 8x A100 GPUs (stage 1-3)  
  - Custom dataset preparation  
- Inference options:  
  - Local CLI/Gradio  
  - Hugging Face integration  
  - Colab demo via @camenduru  

The system achieves 512×512 resolution outputs while maintaining geometric consistency through multi-view attention. Current limitations include AGPL license constraints and dependency on accurate foreground masks. Pre-trained models require commercial licensing agreements.


### 12. Large Multiview Gaussian (3DTopia/LGM)
- **Speed**: Under 30 seconds on RTX3080
- **Feature**: Gaussian to mesh conversion
- **Source**: ashawkey/LGM

**[LGM (Large Multi-View Gaussian Model)](https://github.com/3DTopia/LGM)** ([Project Page](https://me.kiui.moe/lgm/)) introduces a 3D generation framework using Gaussian Splatting, featuring:

**Core Architecture**  
- 🌟 Dual-mode generation:  
  - Text-to-3D via MVDream/ImageDream  
  - Image-to-3D through multi-view synthesis  
- ⚡️ Real-time Gaussian Splatting reconstruction  

**Technical Highlights**  
- Modified depth-aware rasterization pipeline  
- Hybrid training strategy:  
  - 80K Objaverse subset pre-training  
  - Multi-GPU distributed training  
- MIT-licensed commercial use  

**Implementation**  
- Requirements:  
  - CUDA 11.8 + xformers  
  - RTX 3090/4090 GPUs recommended  
- Deployment options:  
  - Local Gradio interface  
  - Replicate API integration  
  - Mesh conversion to *.ply format  

The system achieves 512×512 resolution outputs while maintaining 10GB VRAM usage through optimized Gaussian parameterization. Current limitations include dependency on specific CUDA versions and requirement for square input images. Pre-trained weights available via [Hugging Face](https://huggingface.co/ashawkey/LGM).


### 13. Triplane Gaussian Transformers
- **Speed**: Under 10 seconds on RTX3080
- **Feature**: Quick Gaussian generation
- **Source**: VAST-AI-Research/TriplaneGaussian


**[TriplaneGaussian](https://github.com/VAST-AI-Research/TriplaneGaussian)** ([Paper](https://arxiv.org/abs/2312.09147)) introduces a hybrid 3D reconstruction framework with these key features:

**Core Architecture**  
- ⚡️ Sub-second reconstruction (A100 GPU)  
- 🔄 Dual representation:  
  * Triplane features (implicit)  
  * 3D Gaussian Splatting (explicit)  

**Technical Highlights**  
- Transformer-based geometry prediction  
- Adaptive camera distance parameter (1.9-2.1)  
- SAM integration for background removal  
- Apache 2.0 licensed commercial use  

**Implementation**  
- Requirements:  
  * CUDA-enabled GPUs  
  * PyTorch3D + diff-gaussian-rasterization  
- Deployment options:  
  * [Colab Notebook](https://colab.research.google.com/drive/1UyS_7RvQQaefC0HmGjsNHPUfQn2MlIcD)  
  * Local Gradio with [custom renderer](https://github.com/dylanebert/gradio-splatting)  
  * Hugging Face [model integration](https://huggingface.co/VAST-AI/TriplaneGaussian)  

The system achieves real-time performance through optimized Gaussian parameterization, though requires careful camera distance tuning for optimal results. Current limitations include dependency on foreground segmentation and training dataset scale constraints.


But wait - there's more! You can also:
- Make 3D models look smooth and professional
- Create spinning videos of your 3D models
- Save your work in different 3D file formats
- Fix up models that aren't quite right

## Getting Started Is Dead Easy

Want to try it yourself? Here's how:

1. The simplest way is through ComfyUI-Manager. It's like installing an app on your phone - just click and you're done!

2. If you're more of a DIY person, you can download it yourself from GitHub. Just copy a few commands, and you're ready to go.

3. Got a Windows PC? There's even a special version called Comfy3D-WinPortable that's super easy to set up.

## What's Coming Next?

The folks making this tool have big plans:
- They're working on making it even better at turning 3D point clouds into proper models
- New ways to estimate camera positions from photos
- More cool features for working with multiple views of objects

## Tips from Someone Who's Used It

Here are some things I learned while playing with it:

1. If you get any OpenGL errors (those annoying technical messages), just tick the 'force_cuda_rasterize' box. Works like a charm!

2. Having trouble with the coordinates? Remember it uses a system where:
   - Up is +y
   - Right is +x
   - Forward is +z
   
It's like a video game coordinate system - once you get it, it makes total sense!

## Wrapping Up

This tool is honestly amazing for anyone interested in 3D creation. Whether you're making game assets, doing 3D printing, or just playing around with 3D art, it makes everything so much easier.

The best part? It's always getting better. The team behind it is constantly adding new features and making improvements. And because it's open source, you can even help make it better if you're into coding!

Give it a try - you might be surprised at how easy it is to start creating cool 3D stuff!

github: https://github.com/MrForExample/ComfyUI-3D-Pack


Turn any image into professional 3D models instantly with ComfyUI 3D Pack. 13+ AI models, simple workflow, and no complex software needed. Start creating amazing 3D art today!

teaser.jpg

Best 3D Models With Comfyui

Hey there! I've been playing around with Ruyi-Models lately, and I'm excited to show you how this cool AI tool can transform your images into smooth, high-quality videos. 

## What is Ruyi-Models?

Ruyi is an open-source image-to-video model that does something pretty amazing - it takes your still images and turns them into cinematic videos. Here's what makes it special:

- Creates videos at 768 resolution (that's really crisp!)
- Runs at 24 frames per second (just like movies)
- Makes 5-second videos with 120 total frames
- Lets you control camera movement and motion effects
- Works great on RTX 3090 or 4090 GPUs

## Getting Started

Installing Ruyi is pretty straightforward. Just run these commands:

```bash
git clone https://github.com/IamCreateAI/Ruyi-Models
cd Ruyi-Models
pip install -r requirements.txt
```

### For ComfyUI Users

You've got two ways to set this up:

1. **The Easy Way**: Use ComfyUI Manager
   - Install the manager
   - Search for "Ruyi"
   - Click install
   - Also grab "ComfyUI-VideoHelperSuite"

2. **Manual Setup**:
```bash
cd ComfyUI/custom_nodes/
git clone https://github.com/IamCreateAI/Ruyi-Models.git
pip install -r Ruyi-Models/requirements.txt
```

## Making Your First Video

The simplest way to start is:

```python
python3 predict_i2v.py
```

This will:
- Download the model automatically
- Use sample images from the assets folder
- Generate a video based on those images

### Pro Tips

- Got a beefy GPU with 24GB+ memory? Use `predict_i2v_80g.py` for faster generation
- Working with less memory? No worries - there are optimization settings to help you out

## FAQ

**Q: What GPU do I need?**
A: An RTX 3090 or 4090 works best, but you can run it on less powerful cards with memory optimization.

**Q: How long does video generation take?**
A: It varies by settings and hardware, but expect anywhere from 1-20 minutes for a 5-second clip.

**Q: Can I control the camera movement?**
A: Yep! You can set different camera motions like pan, tilt, and zoom.

github:[https://github.com/IamCreateAI/Ruyi-Models](https://github.com/IamCreateAI/Ruyi-Models)


Learn how to transform still images into cinematic 24fps videos with Ruyi-Models, an open-source AI tool. This guide covers installation, usage tips, and best practices for generating high-quality 768p videos from images. 

example_03.jpg

Ruyi-Models: Turn Still Images into Cinematic Videos

G'day! I recently stumbled upon something pretty scary while making AI art with ComfyUI, and I reckon you should know about it. Someone tried to use my computer to mine cryptocurrency without asking! Let me tell you what happened and how to keep yourself safe.

## The Day I Discovered Something Fishy 🕵️

I was just minding my own business, playing around with ComfyUI to create some cool AI art. You know how it goes - installing extensions to get more features. But then my computer started acting proper weird. The fan was going mental, and everything was running slow as molasses.

After some digging (and a lot of head-scratching), I found the culprit hiding in a package called Ultralytics. It was being super sneaky, using my computer to mine crypto without even asking! The nerve of some people, right?

Here's what this cheeky program was up to:
- Hiding in a legitimate-looking package
- Running secret mining operations
- Trying to connect to dodgy websites
- Covering its tracks like a proper criminal

## How These Sneaky Miners Work 🦊

Think of it like someone sneaking into your house and using your electricity to run their business - but on your computer! These crypto miners are proper clever about it too. They hide in normal-looking software that you install willingly.

The one I found was tucked away in something called the ComfyUI-Impact-Pack. When you install it, it brings along this dodgy Ultralytics package that's been tampered with. It's like ordering a pizza and getting an unwanted side of trouble!

## Warning Signs That Something's Not Right 🚩

Keep your eyes peeled for these tell-tale signs:
- Your computer's running hot enough to fry an egg
- Everything's moving slower than a tortoise in treacle
- Fan's making more noise than a vacuum cleaner
- High CPU or GPU usage when you're not doing much
- Strange network connections you didn't ask for

## Protecting Your Computer from These Sneaky Blighters 🛡️

Here's what you can do to keep safe:
1. Only download extensions from trusted sources
2. Keep your antivirus up to date
3. Check what's running on your computer regularly
4. Be suspicious if things start running slowly
5. Use a proper firewall

## What to Do If You've Been Affected 🆘

Found something suspicious? Don't panic! Here's your action plan:

1. Uninstall the dodgy software:
```bash
pip uninstall ultralytics ultralytics-thop
```

2. Remove any suspicious extensions (in my case, the ComfyUI-Impact-Pack)

3. Run a proper virus scan

4. Check your computer's not still trying to connect to any weird websites

## Frequently Asked Questions 🤔

**Q: How do I know if I've got this specific mining problem?**
A: Check if you've got the ComfyUI-Impact-Pack installed and look for unusual CPU/GPU usage.

**Q: Will uninstalling the software fix everything?**
A: Usually yes, but it's best to run a full virus scan just to be sure.

**Q: Can this damage my computer?**
A: It might wear out your hardware faster if left running for ages.

**Q: Should I stop using ComfyUI?**
A: Nah, just be careful about which extensions you install.


Discovered a sneaky crypto mining attack hiding in ComfyUI's AI art tools? Learn how to spot these attacks, protect your computer, and remove malicious miners. Real experience, simple solutions. 🚨

Comfyuiweb.jpg

Sneaky Crypto Mining Attack in ComfyUI Custom Nodes

BlackForestLabs has exciting news to share. The company is expanding its FLUX.1 AI image platform with a powerful new suite of tools that takes everything to the next level.

## What's New in BlackForestLabs' FLUX.1 Family?

Building on the success of their FLUX.1 text-to-image model, BlackForestLabs has developed four new tools that give users even more creative control:

1. **FLUX.1 Fill** - An advanced addition to the FLUX.1 platform for smart image editing
2. **FLUX.1 Depth** - Their new 3D-aware image understanding system
3. **FLUX.1 Canny** - BlackForestLabs' edge-preservation technology
4. **FLUX.1 Redux** - A fresh way to remix and enhance FLUX.1 generations

Following BlackForestLabs' commitment to the community, they're releasing each tool in two flavors: open-access [dev] versions and professional [pro] versions through their BFL API.

## FLUX.1 Fill: Taking BlackForestLabs' Image Tech Further

BlackForestLabs built FLUX.1 Fill to complement their base FLUX.1 model perfectly. 

Here's what makes their latest tool special:
- Outperforms other solutions like Ideogram 2.0 (check out their benchmarks!)
- Seamlessly integrates with existing FLUX.1 generations
- Adds powerful outpainting capabilities to their FLUX.1 ecosystem

The benchmarks are in: BlackForestLabs' FLUX.1 Fill [pro] is leading the pack, with their [dev] version coming in strong second!
![flux-tools-inpaint.jpeg](https://api.comfyuiweb.com/uploads/flux_tools_inpaint_4b77a7e6fa.jpeg)
![flux-tools-outputpaint.jpeg](https://api.comfyuiweb.com/uploads/flux_tools_outputpaint_c7670df51e.jpeg)

## Structural Control with FLUX.1 Depth and Canny

These tools represent the next evolution of the FLUX.1 platform.

BlackForestLabs has developed two approaches to maintain precise control:

- **FLUX.1 Depth** adds 3D awareness to FLUX.1 generations
- **FLUX.1 Canny** preserves structural integrity during edits

Their team benchmarked these against competitors (including Midjourney ReTexture), and both tools showcase BlackForestLabs' leadership in AI image technology.

![flux-tools-depth.jpeg](https://api.comfyuiweb.com/uploads/flux_tools_depth_4821c51aed.jpeg)
![flux-tools-canny.jpeg](https://api.comfyuiweb.com/uploads/flux_tools_canny_4938fd3407.jpeg)

## FLUX.1 Redux: The Future of Image Generation

This tool takes everything great about FLUX.1 and adds new creative possibilities:
- Generate variations of any FLUX.1 output
- Mix FLUX.1 generations with new prompts
- Create high-resolution 4MP images
- Work with flexible aspect ratios

It's fully integrated with their latest FLUX1.1 [pro] Ultra model for the best possible results!
![flux-tools-remix1.jpeg](https://api.comfyuiweb.com/uploads/flux_tools_remix1_2ba0c1bbd7.jpeg)
![flux-tools-remix2.jpeg](https://api.comfyuiweb.com/uploads/flux_tools_remix2_bc37e2afbd.jpeg)

## FAQ

**Q: How does FLUX.1 Tools fit into the BlackForestLabs ecosystem?**
A: These tools are built specifically to enhance their FLUX.1 platform, giving users more control over generations.

**Q: Which tool works best with the base FLUX.1 model?**
A: FLUX.1 Fill integrates most naturally with existing FLUX.1 workflows.

**Q: Can I use these with existing FLUX.1 projects?**
A: Yes! All tools are designed to work seamlessly with FLUX.1 generations.

## Start Creating with BlackForestLabs' Complete FLUX.1 Suite

BlackForestLabs continues to expand the FLUX.1 platform with tools that serve both their open-source community and professional users. These additions represent their ongoing commitment to advancing AI image technology while keeping it accessible.

For a deep dive into how these tools enhance the FLUX.1 platform, visit [blackforestlabs.ai/flux-1-tools/](blackforestlabs.ai/flux-1-tools/)

You can also access the model on fal.ai, Replicate, Together.ai, Freepik and krea.ai.

🔥 BlackForestLabs Just Broke the AI Image Game - See The Tool That's Making Midjourney Sweat!

flux-tools-remix2.jpeg

BlackForestLabs' FLUX.1 Tools: A Game-Changing Update to Their AI Image Platform

Hey there! I've been testing out Recraft V3 for the past few weeks, and I gotta tell you - it's pretty amazing what this thing can do. Let me break it down for you.

## What's Recraft V3 All About?
![leaderboard.png](https://api.comfyuiweb.com/uploads/leaderboard_fc00b66a6f.png)
You know how creating custom images for your business can be a total pain? That's exactly what Recraft V3 fixes.

It's like having a super-smart design assistant that actually gets what you're trying to do. 

Here's what makes it different:
- It doesn't just generate random images - it actually understands text placement
- You can create unlimited designs (well, within your daily credits)
- It's way faster than other AI tools I've tried

The cool thing? More and more designers are switching to it. I've seen loads of posts on Twitter showing off what they've made with it.

## The Features That Actually Matter

### Text That Actually Looks Good
Remember when AI-generated text in images looked totally fake? Not anymore.

What I love about Recraft V3:
![recraftv3-example2.jpg](https://api.comfyuiweb.com/uploads/recraftv3_example2_fab1388421.jpg)
- You can add as much text as you want
- The text actually goes where you tell it to
- It doesn't do that weird AI thing where letters look like alien symbols

I tried making a social media post yesterday - took me literally 2 minutes to get the text placement perfect. That would've been at least 30 minutes in Photoshop.

### Making Things Look Exactly How You Want

The control you get with Recraft V3 is pretty wild:
- Want square images? Done
- Need something super wide for a banner? Easy
- Got specific brand colors? Just plug 'em in

It's like they actually asked designers what they needed instead of just guessing.

### Speed and Quality (Finally Together)

Look, I'm not gonna pretend every image comes out perfect. But here's what I've found:
- Most images take about 15 seconds to generate
- The quality is consistently good (not that hit-or-miss stuff you get with other tools)
- Details actually look realistic, not like some weird AI dream

## Using Recraft V3: The Simple Guide

I remember feeling pretty lost when I first opened Recraft V3. But trust me, it's way simpler than it looks.

Here's how I use it:
1. Type what you want (be specific but not too wordy)
2. Pick your size
3. Hit generate
4. Tweak if needed

That's literally it. No fancy stuff needed.

## The Real-World Stuff You Can Make

Let me share what I've actually used it for:
- Instagram posts that don't look AI-generated
- Quick logo concepts for clients
- Book covers that actually look professional
- Product mockups that saved me hours

## Tips That Actually Work

After messing around with it for weeks, here's what I've learned:
- Short, clear prompts work better than long ones
- Start simple, then add details
- If something looks off, regenerate instead of trying to fix it
- Use the edit tools for small tweaks only

## Why I Picked Recraft V3 Over Others

I've tried pretty much everything out there. Here's the real talk:
- MidJourney: Great but expensive
- DALL-E: Good but limited control
- Recraft V3: Best balance of control and cost

The free credits every 24 hours (50 of them) are usually enough for my daily needs.

## FAQs About Recraft V3

**Is Recraft V3 really free?**
Yep, you get 50 credits daily with the free version.

**Can I use these images commercially?**
Yes, but double-check their latest terms just to be safe.

**Do I need design experience?**
Nah, but it helps to know basic design principles.

**How does it compare to Photoshop?**
It's not a Photoshop replacement - think of it as a quick design generator.

## Final Thoughts

Look, Recraft V3 isn't perfect. But for quickly creating professional-looking images? It's pretty hard to beat.

My advice? Try the free version. Play around with it. See if it fits your workflow.

Just remember: it's a tool, not magic. But it's a pretty darn good tool.

Discover how Recraft V3 beats DALL-E & Midjourney at image generation. Get my exact prompts + see real results from 50 free daily credits 🎨

recraftv3-example.webp

Getting Started with Recraft V3: The AI Image Tool That's Actually Easy to Use



Hey there! 👋 

I just spent hours digging into the new IC-Light V2 updates, and wow - there's some cool stuff happening.

In this guide, I'll break down everything you need to know about this AI image model (in plain English, I promise).

Let's dive in.

## What's New in IC-Light V2?

You know how frustrating it is when AI messes up the details in your images?

Well, that's exactly what IC-Light V2 fixes.

Here's the deal:

* They've added a 16-channel VAE (fancy way of saying it keeps more detail)
* It handles high-res images way better than before
* You can actually keep your image style without the AI going crazy with changes

The best part? It's all built on something called Flux (more on that in a sec).

## The Real-World Performance

Look, I've tested a ton of AI image models.

And here's what makes IC-Light V2 different:
![ic-light-v2.jpg](https://api.comfyuiweb.com/uploads/ic_light_v2_3534302dd5.jpg)
1. **Detail preservation is insane**
   * Compared to SD1.5, it keeps way more of the original image intact
   * No more weird artifacts in faces
   * Textures actually look real
![ic-light-v1.jpg](https://api.comfyuiweb.com/uploads/ic_light_v1_eac7aff012.jpg)
2. **Style handling**
   * Remember how old models would completely change your art style?
   * This one actually respects your original style
   * Perfect for artists who want to keep their unique look

I tested it with some tricky images, and honestly? It's pretty impressive.

## License Stuff (Important!)

Here's something you need to know:

The new version has a non-commercial license. 

What does this mean for you?

* Can't use it to make money (by default)
* Need special permission for commercial stuff
* Perfect for personal projects though

Pro tip: If you need it for commercial use, there's a way to get permission. Just reach out to the team.

## What Users Are Saying

I've been following the GitHub discussion, and here's what people are loving:

"Finally, something that doesn't destroy my art style!" - Digital Artist

"The detail preservation is next level" - AI Developer

Common questions I'm seeing:

### FAQ

**Q: Can I use this for my art portfolio?**
A: Yes, as long as it's not for commercial purposes.

**Q: How does it compare to Stable Diffusion?**
A: Better detail preservation, more natural style handling.

**Q: Will there be a commercial version?**
A: Possibly - the team's considering options.

## What's Coming Next?

Based on the discussion, here's what's in the pipeline:

* More model variations
* Better foreground handling
* Possible commercial options

## Bottom Line

IC-Light V2 is a major step up from V1.

If you're into AI art and want better detail preservation, this is worth checking out.

Just remember the license limitations before diving in.

### Quick Tips for Getting Started

1. Start with high-res images
2. Test the style preservation
3. Join the community discussions

Related Resources:
[IC-Light GitHub Project](https://github.com/lllyasviel/IC-Light)
[IC-Light Demo](https://huggingface.co/spaces/lllyasviel/IC-Light)
[IC-LightV2 Discussion](https://github.com/lllyasviel/IC-Light/discussions/98)

Discover the groundbreaking features of IC-Light V2 in this complete guide! Learn how this AI image model enhances detail preservation, respects your unique style, and outperforms previous versions like Stable Diffusion.

ic-light-v2.jpg

IC-Light V2 Update: Game-Changing AI Detail You'll Love

Hey there! 👋 

I've spent countless hours training LoRA models, and lemme tell you - it's way simpler than most people make it sound. Today I'm gonna show you exactly how to train your own LoRA model using FLUX.1 and [Vast.ai](https://cloud.vast.ai/?ref_id=90893).

## Why Should You Care About FLUX.1?

FLUX.1 is blowing up right now, and for good reason.

Think of it as your creative Swiss Army knife - it can generate almost anything you throw at it. But here's the cool part: with LoRA training, you can teach it to be even better at specific things.

## Getting Your Dataset Ready

Here's the deal with datasets:

- You'll need at least 10-20 images
- Make sure you've got the rights to use these images

Pro tip: Don't just grab random images off Google. You might run into copyright issues. Use proper  databases or open-source collections.

## The Step-by-Step Training Process

### 1. Getting Your Hands on a GPU

Look, I'll be straight with you - you need some serious hardware for this.

Two main options:
- Rent from [Vast.ai](https://cloud.vast.ai/?ref_id=90893) (my go-to)
- Use your own setup if you've got a beefy GPU

What you need:
- RTX 3060, 3090 or 4090 (don't even bother with less)
- At least 8GB VRAM

Here's how to get started on [Vast.ai](https://cloud.vast.ai/?ref_id=90893):
1. Create an account
2. Pick a template with the right GPU
![1.png](https://api.comfyuiweb.com/uploads/1_73948ef891.png)
![2.png](https://api.comfyuiweb.com/uploads/2_37f715f137.png)
![3.png](https://api.comfyuiweb.com/uploads/3_b35a001a9b.png)
3. Fire up Jupyter Notebook and Comfyui
![4.png](https://api.comfyuiweb.com/uploads/4_589dec5422.png)
![5.png](https://api.comfyuiweb.com/uploads/5_1053646f79.png)
![6.png](https://api.comfyuiweb.com/uploads/6_d46036b364.png)
4. Download model on Jupyter Notebook
![7.png](https://api.comfyuiweb.com/uploads/7_f407fe3b6e.png)
![8.png](https://api.comfyuiweb.com/uploads/8_564659db4c.png)
![9.png](https://api.comfyuiweb.com/uploads/9_43b1d29981.png)
![10.png](https://api.comfyuiweb.com/uploads/10_0b178a32cb.png)

You can use below text to download the fp8 model.

```
!wget https://huggingface.co/XLabs-AI/flux-dev-fp8/resolve/main/flux-dev-fp8.safetensors -O /workspace/ComfyUI/models/unet
!wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/t5xxl_fp8_e4m3fn.safetensors -O /workspace/ComfyUI/models/clip
!wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/clip_l.safetensors -O /workspace/ComfyUI/models/clip
!wget https://huggingface.co/black-forest-labs/FLUX.1-dev/resolve/main/ae.safetensors -O /workspace/ComfyUI/models/vae
```

### 2. Prepping Your Images

Time to get organized:

1. Create a new folder, my folder named "m22"
2. Upload your images
3. (Optional)Create caption files (same name as image, but .txt)

Example:
```
m22/
  ├── m22_001.png
  ├── m22_001.txt
  ├── m22_002.png
  └── m22_002.txt
```
![11.png](https://api.comfyuiweb.com/uploads/11_1bef77567d.png)

### 3. The Training Part

This is where the magic happens. Here's my tried-and-tested setup:

You can load my workflow for lora training.

[workflow](https://api.comfyuiweb.com/uploads/flux_lora_trainer_vastai_31295a56d2.json)

![18.png](https://api.comfyuiweb.com/uploads/18_bdd01a14a8.png)

Then setup the lora training configuration.

![12.png](https://api.comfyuiweb.com/uploads/12_29101bfa62.png)
![13.png](https://api.comfyuiweb.com/uploads/13_9b956469a5.png)

You need to set the output location to "/workspace/ComfyUI/models/loras"

Then you can click the queue button to start training about 30 minutes.

After training done, You can see the results in the workflow.

### 4. Using the lora model

Once you're done training, you might want to use the lora model to generate the images you wanted.

You can use the below workflow to generate images using lora model.

[workflow](https://api.comfyuiweb.com/uploads/workflow_inference_59d8dd8490.json)

![17.png](https://api.comfyuiweb.com/uploads/17_e33b72cfe4.png)

## What to Expect from Your Results

I've trained dozens of these models, and here's what I've learned:

- First results might look weird - that's normal
- Play with your prompts
- The trigger word is super important
- Sometimes less training is more

## Quick Tips for Better Results

- Start with default settings
- Train for longer if results are blurry
- Use clear, consistent captions
- Keep your dataset focused

## FAQs

**Q: How long does training usually take?**
A: About 30 minutes-1 hour with a 4090.

**Q: Can I use fewer images?**
A: You can, but results won't be as good. 10-20 is the sweet spot for object and 30+ is great for style.

**Q: Do I need to use Vast.ai?**
A: Nope! Any GPU setup with enough VRAM works.

## Final Thoughts

Training a LoRA isn't rocket science - it just needs a bit of patience and the right setup.

Remember: Start small, experiment lots, and have fun with it!

Got questions? Hit me up in the email. I personally answer every single one.

support@comfyuiweb.com





Learn how to train your own LoRA model with FLUX.1 in this step-by-step guide. Perfect for beginners, includes GPU setup, dataset preparation, and expert tips. 

18.png

How to train flux lora using comfyui on vast.ai?

# Introduction to Pyramid Flow AI Video Model

Yo, have you heard about Pyramid Flow? It's this cool new AI video model that's causing a stir.

I've been playing around with it, and I gotta say, it's pretty slick.

The best part? It's open source. You can download it and run it on your own beefy hardware or private server.

No need to rely on cloud services or worry about usage limits.

Let's dive in and see what this bad boy can do.


# 1. Integration with Comfy UI
![videoframe_3141.jpg](https://api.comfyuiweb.com/uploads/videoframe_3141_0d28df0077.jpg)

So, Pyramid Flow plays nice with Comfy UI. That's a big deal.

Comfy UI's got these custom nodes for Pyramid Flow that make life easier.

I've been messing with the Comfy UI Pyramid Flow wrapper, and it's a game-changer.

Here's the deal:

- You get a visual interface for Pyramid Flow
- It's way easier to experiment with different settings
- You can chain Pyramid Flow with other AI models

It's like having a playground for AI video generation. Pretty sweet, right?

# 2. Installation Process
![videoframe_576.jpg](https://api.comfyuiweb.com/uploads/videoframe_576_690507655a.jpg)

Getting Pyramid Flow up and running is a breeze. Here's how I did it:

1. Used Comfy UI Manager (easiest way, hands down)
2. Installed requirements.txt and did some manual pip installs
3. Downloaded models from HuggingFace and dropped 'em in Comfy UI

The whole process took me about 15 minutes. Not bad at all.

Pro tip: Make sure you've got enough disk space. These models are chunky.

# 3. Custom Node Wrapper Features
![videoframe_6609.jpg](https://api.comfyuiweb.com/uploads/videoframe_6609_0c55a05816.jpg)

The custom node wrapper for Pyramid Flow is where the magic happens.

There's this "Download Pyramid Flow models" node that's a lifesaver.

I also found a Python script that makes downloading files a walk in the park.

Here's what I love about the wrapper:

- It's user-friendly
- You can tweak settings on the fly
- It integrates seamlessly with other Comfy UI nodes

It's like having a Swiss Army knife for AI video generation.

# 4. Running AI Video Models in Comfy UI

Alright, let's get to the good stuff. Running Pyramid Flow in Comfy UI is where things get exciting.

I've been playing with text-to-video and image-to-video examples. It's wild.

Here's what I've learned:

- Start with simple prompts and work your way up
- Adjust parameters gradually to see their impact
- Don't be afraid to experiment – you might stumble onto something cool

I had a blast trying different settings. It's like being a mad scientist, but with videos.

# 5. Performance and Results

So, how does Pyramid Flow stack up? Pretty darn well, if you ask me.

I've been testing all sorts of text prompts and settings. Here's the scoop:

- Simple scenes work best (for now)
- Nature and abstract concepts yield impressive results
- Human characters are still a bit... let's say "quirky"

Compared to the demo page, my results were hit or miss. But that's the fun part, right?

The quality of the generated videos is impressive, considering it's running locally.

If you're into AI and video generation, give Pyramid Flow a shot. You won't regret it.

github: [https://github.com/kijai/ComfyUI-PyramidFlowWrapper](https://github.com/kijai/ComfyUI-PyramidFlowWrapper)

model: [https://huggingface.co/rain1011/pyramid-flow-sd3/tree/main](https://huggingface.co/rain1011/pyramid-flow-sd3/tree/main)

more demos: [https://pyramid-flow.github.io/](https://pyramid-flow.github.io/)

# FAQs

Q: Can Pyramid Flow run on my laptop?

A: Depends on your specs, mate. You'll need a beefy GPU to get decent results.

Q: How long does it take to generate a video?

A: Varies wildly. Simple scenes might take a few minutes, complex ones could take hours.

Q: Is Pyramid Flow better than other AI video models?

A: It's got its strengths, but "better" is subjective. Give it a try and see for yourself!

Q: Can I use Pyramid Flow for commercial projects?

A: Check the license, buddy. As of now, it's for non-commercial use only.

Q: How often is Pyramid Flow updated?

A: The devs are pretty active. I'd say check for updates every couple of weeks.

Explore Pyramid Flow, the open-source AI video model. Learn how to install, run locally, and create stunning videos using Comfy UI. Dive into text-to-video and image-to-video examples, performance insights, and future updates.

videoframe_5622.jpg

ComfyUI-PyramidFlowWrapper Introduction


## What's ComfyUI-PuLID-Flux All About?

So you're curious about ComfyUI-PuLID-Flux, huh? Let me break it down for ya.

It's this cool thing that lets you use PuLID-Flux models in ComfyUI to make and tweak images. 

Pretty neat, right?

I stumbled across it the other day and thought, "Wow, this could be a game-changer!"

Here's the deal:
- It's built on top of ComfyUI
- You can use PuLID-Flux models
- It's all about generating and editing images

The folks behind it keep updating it too. 

Like, in version 0.1.0, they added these work nodes with weight support and start/end positions. 

But heads up - attention masks aren't working yet. They're still tinkering with that.

I gotta say, it's pretty exciting to see how it's evolving. 

Every update feels like Christmas morning for us image generation nerds!

### FAQ: What can I do with ComfyUI-PuLID-Flux?

You can do all sorts of cool stuff:
- Generate images using PuLID-Flux models
- Edit existing images
- Play around with different model settings

It's like having a digital art studio right at your fingertips!

## Getting Started: What You Need to Know

Okay, let's talk about the nitty-gritty of using this bad boy.

First up, you gotta pick your Flux model. 

They've got a few options:

1. 32-bit/16-bit versions (these are hungry beasts - they'll gobble up about 22GB of VRAM)
2. 8-bit GGUF versions (bit lighter, only needs about 12GB VRAM)
3. 8-bit FP8 versions (also around 12GB VRAM)

I've tried 'em all, and honestly, they each have their quirks.

The 32-bit ones are like the Rolls-Royce of the bunch - smooth and powerful, but man, do they eat up memory!

The 8-bit versions are more like zippy little sports cars. They get the job done and don't hog all your resources.

Now, here's the kicker - you need more than just the Flux model. 

You gotta have:
- CLIP
- VAE
- EVA CLIP model
- PuLID Flux pre-trained model
- facexlib model
- InsightFace model

Sounds like a lot, right? Don't worry, I'll walk you through it.

### How to Get Everything Set Up

1. First things first, clone the repo into your ComfyUI/custom_nodes folder.

2. Install all the packages listed in requirements.txt. 

   Pro tip: Use a virtual environment if you're feeling fancy.

3. Download the Flux.1-dev model files. 
   - Stick the model in ComfyUI/models/unet
   - CLIP and encoder go in ComfyUI/models/clip
   - VAE goes in ComfyUI/models/vae

4. Grab the PuLID Flux pre-trained model and pop it in ComfyUI/models/pulid/.

5. Don't forget the EVA-CLIP model (EVA02-CLIP-L-14-336). That one goes in ComfyUI/models/clip.

6. Install facexlib. Don't sweat the model - it'll download itself when you first use it.

7. Last but not least, install InsightFace and unzip the AntelopeV2 model into ComfyUI/models/insightface/models/antelopev2.

Phew! That's a lot, but trust me, it's worth it.

### FAQ: Do I really need all these models?

Yep, you do. Each one plays a part in the image generation process. It's like a band - take out one instrument, and the whole sound changes.

## Heads Up: Known Issues

Alright, let's talk about some of the quirks you might run into.

First off, if your hardware's CUDA compute capability is below 8.0, you're gonna have a bad time with the ApplyPulidFlux node. 

Especially if you're using the Flux FP8 model - that bad boy needs bfloat16 support.

Here's a weird one: even if you disconnect the ApplyPulidFlux node after running it once, it'll still affect the Flux model. 

Kinda like that one friend who shows up uninvited to parties - always making an impact, even when they're not supposed to be there.

Oh, and the attention mask feature? Yeah, that's still in the works. So don't get your hopes up for that just yet.

But hey, that's the fun of cutting-edge tech, right? Always something new to look forward to!

### FAQ: Will these issues be fixed soon?

The devs are working on it, but no promises on when. These things take time, ya know?

## Wrapping It Up

So there you have it - ComfyUI-PuLID-Flux in a nutshell.

It's a powerful tool, but it's got its quirks.

If you're into image generation and don't mind a bit of tinkering, give it a shot.

Who knows? You might just create the next digital masterpiece!

Remember, the tech world moves fast. By the time you read this, there might be new updates or changes.

Always check the official repo for the latest info.

Happy generating, folks!

source: [https://github.com/balazik/ComfyUI-PuLID-Flux](https://github.com/balazik/ComfyUI-PuLID-Flux)

Discover ComfyUI-PuLID-Flux, a powerful tool for image generation in ComfyUI using the PuLID-Flux model. 

Latest News for ComfyUI