stable-diffusion.cppC/C++ inference for Stable Diffusion, Flux, Qwen-Image and Wan video models7.8k starsMITlast commit Oct 2026
19
100
90
70
70 out of 100score
#7
infinite-canvasBrowser-based infinite canvas for AI image and video generation8.9k starsMITlast commit Oct 2026
27
100
94
30
69 out of 100score
#8
ltx-2Text and image to video model with synchronized audio, plus pipelines and trainer
Live demo ↗
(opens in a new tab)9.9k starscustom licenselast commit Oct 2026
35
100
87
15
68 out of 100score
#9
mochidiffusionNative macOS app for generating images offline with Stable Diffusion and FLUX.2 Klein8k starsGPL-3.0last commit Sep 2026
22
100
83
30
65 out of 100score
#10
stabilitymatrixDesktop package manager and built-in inference UI for Stable Diffusion tools9k starsAGPL-3.0last commit Oct 2026
29
100
86
0
64 out of 100score
#11
dramaclawNode-canvas and pipeline for producing AI short dramas from script to final cut6.4k starscustom licenselast commit Oct 2026
8
100
89
45
64 out of 100score
#12
modlyDesktop app that generates 3D meshes from photos using local models8.3k starscustom licenselast commit Oct 2026
25
100
75
0
60 out of 100score
#13
AI ToolkitLoRA and LoKr training suite for image, video and audio diffusion models12.4k starsMITlast commit Oct 2026
44
100
53
0
59 out of 100score
#14
sanaEfficient diffusion models and training code for high-resolution image and video
Live demo ↗
(opens in a new tab)9.6k starsApache-2.0last commit Oct 2026
33
100
64
0
59 out of 100score
#15
faceswapPython tool that trains neural models to swap faces in images and video57.6k starsGPL-3.0last commit Aug 2026
duix-avatarOffline talking-avatar video generator with voice cloning and lip-sync16.1k starscustom licenselast commit Apr 2026
59
58
2
0
36 out of 100score
#29
FluxGymWeb UI for training FLUX LoRAs on 12 to 20 GB GPUs3.3k starsMITlast commit Jul 2026
2
100
19
0
36 out of 100score
#30
video2xVideo upscaler and frame interpolator using Real-ESRGAN, Real-CUGAN, RIFE and Anime4K
Live demo ↗
(opens in a new tab)22.4k starsAGPL-3.0last commit Mar 2026
72
34
1
0
32 out of 100score
#31
generative-modelsStability AI reference code for SDXL, Stable Video Diffusion, SV3D and SV4D27.3k starsMITlast commit Dec 2025
cogvideoOpen-weight text-to-video and image-to-video diffusion models with inference and LoRA code
Live demo ↗
(opens in a new tab)13.1k starsApache-2.0last commit Nov 2025
51
3
0
0
16 out of 100score
#37
fast-stable-diffusionGoogle Colab notebooks for running ComfyUI, AUTOMATIC1111 and DreamBooth7.9k starsMITlast commit Nov 2025
21
13
6
0
12 out of 100score
Momentum, Verified build, Docs and Privacy are not measured yet; their weight goes to the signals shown. A dash means the signal is not scored for that kind of project. Hover a number for its rating in words.
Generates short videos from a topic, with script, footage, voiceover and subtitles
134.7k starsMITlast commit Oct 2026
MoneyPrinterTurbo takes a topic or keywords and produces a finished short video. It writes the script with a configurable LLM, pulls footage from Pexels, Pixabay or Coverr (or generates clips through video APIs), then adds TTS voiceover, subtitles and background music. Output is 9:16, 16:9 or 1:1, driven from a WebUI, API, CLI or AI agent.
Strengths
Covers the full pipeline: script, footage, voiceover, subtitles, music and render
Many LLM providers, including OpenAI, Claude, Gemini, DeepSeek and local Ollama
Edge TTS voiceover needs no API key; GPU is not required
WebUI, API and CLI, plus batch generation of multiple videos
Weaknesses
Stock footage sources and AI video generators need their own API keys
Main README is Chinese-first and carries many sponsor promotions
Footage is matched by keyword, so clips may not fit the script closely
Local faster-whisper transcription is slow without a GPU
RAM ≥ 4 GB
GPU optional
Docker + Compose
Needs Python 3.11+, LLM API or Ollama, Pexels/Pixabay/Coverr API key, Edge TTS or other TTS service
Models: OpenAI, Anthropic Claude, Google Gemini, DeepSeek, Kimi
Node-graph editor for running diffusion image, video, audio and 3D workflows
142.5k starsGPL-3.0last commit Oct 2026
ComfyUI is a node-graph interface and execution engine for diffusion and other generative models, covering image, video, audio, 3D and text workflows. It runs on NVIDIA, AMD, Intel, Apple Silicon and Ascend hardware, and uses weight streaming and offloading to fit large models in small VRAM. Workflows save as JSON and can be driven through a local API, with custom nodes for extension.
Strengths
Native support for many models: SDXL, Flux, Wan 2.x, LTX-Video, HunyuanVideo, ACE-Step
README claims large models run on 4GB VRAM with 8GB RAM via weight streaming
Desktop app, Windows portable builds, comfy-cli and manual install; NVIDIA, AMD, Intel, Apple GPUs
Workflows save as JSON, are recoverable from generated media, and can be called through an API
Weaknesses
Node graph has a learning curve compared with form-based generation UIs
Commits between stable tags may be unstable and break many custom nodes
Partner/API nodes for closed models are paid; --offline disables them
Desktop app only for Windows and macOS; Linux needs manual install
Web UI for diffusion image generation with inpainting canvas and node workflows
28.8k starsApache-2.0last commit Oct 2026
Invoke runs a local web server with a React UI for generating and editing images with diffusion models. It includes a Unified Canvas for in/out-painting, a node-based workflow editor, a gallery with prompt metadata recall, and a model manager. It loads ckpt, diffusers and some GGUF models, covering SD 1.5, SDXL, SD 3.5, Flux.1/Flux.2, Qwen Image and Z-Image.
Strengths
Unified Canvas with in/out-painting and brush tools for iterative editing
Node-based workflow editor for building and sharing generation pipelines
Broad model list: SD 1.5 through Flux.2, Qwen Image, Z-Image, SAM/SAM2 segmentation
Gallery stores prompt and settings metadata in images for recall
Weaknesses
README gives no RAM, VRAM or GPU requirements
Nano Banana, GPT Image and Wan are API-only, not local
GGUF support is partial, described only as 'some gguf models'
README points to a separate Launcher app for install, with no manual or Docker steps
Infinite-canvas tool for AI short drama and comic video production
19.2k starsMITlast commit Oct 2026
Toonflow is a Vue/TypeScript app on Bun where scripts, storyboards, character and scene assets, and generated video clips live as nodes on one infinite canvas. Text, image and video generation go through third-party APIs or a local ComfyUI/LLM, and it can be extended with MCP, an agent/A2A interface and a plugin market. It ships as desktop clients, an Android ARM64 APK, Docker and a Linux server install.
Strengths
Covers script, storyboard, asset and video-clip steps on a single canvas
Models are configurable: third-party APIs, local ComfyUI workflows or local LLMs
MIT license with no commercial restrictions; extensible via MCP, A2A and plugins
Desktop, Android ARM64, Docker Compose and bare Bun server install paths
Weaknesses
No login or auth on the web UI or API; needs a firewall or authenticated proxy
Port 3000 is fixed and not configurable
README, docs and tutorials are primarily in Chinese (Feishu docs)
Generation quality and cost depend on external paid model APIs; hardware needs for local use unknown
GPU optional
Docker + Compose
Needs Bun 1.3.14, FFmpeg, Docker (optional), Third-party model APIs or ComfyUI
Models: Third-party LLM, image and video APIs, ComfyUI workflows, Local LLMs
Generative media studio with separate Image, Video, Audio, Lip Sync and Cinema workspaces. Most generation goes through the MuAPI cloud service, with the README claiming 200+ models (the headline says 600+). The desktop app can also run local models: bundled stable-diffusion.cpp for SD 1.5, SDXL and Z-Image, or a user-installed Wan2GP for video.
Strengths
Local inference in desktop app via bundled sd.cpp (Metal, CUDA, Vulkan, ROCm) with no API key
Wan2GP integration for local video, including a remote MCP server so Macs can offload to a GPU box
Accepts up to 14 reference images on compatible edit models
Installers for macOS, Windows and Linux (AppImage, deb) plus a hosted version
Weaknesses
Cloud generation depends on MuAPI, a paid third-party service, not self-hosted models
Local inference is desktop-only; the web version always uses cloud APIs
Installers are unsigned: macOS needs xattr workaround, Windows shows SmartScreen warning
Model count is inconsistent in the README (600+ vs 200+), and README promotes a paid white-label plan
RAM ≥ 16 GB
GPU optional
Docker + Compose
Needs MuAPI API key (cloud models), Wan2GP (optional, local video; CUDA/ROCm GPU), Node.js (build from source)
Models: MuAPI hosted models (Flux, Kling, Veo, Sora, Wan 2.2), sd.cpp: SD 1.5, SDXL, Z-Image, Wan2GP: Wan 2.1/2.2, Hunyuan Video 1.5, LTX-2, Flux.1 Dev, Qwen Image
C/C++ inference for Stable Diffusion, Flux, Qwen-Image and Wan video models
7.8k starsMITlast commit Oct 2026
Runs diffusion models for image and video generation in plain C/C++ on top of ggml, the same way llama.cpp does for LLMs. It loads ckpt, safetensors and GGUF weights and runs on CPU, CUDA, Vulkan, Metal, OpenCL or SYCL. The main interface is the sd-cli command-line tool, and the README mentions an embedded web UI.
Strengths
Backends: CPU (AVX/AVX2/AVX512), CUDA, Vulkan, Metal, OpenCL and SYCL
Covers SD1.x to SDXL, SD3, FLUX, Qwen-Image, Z-Image, plus Wan and LTX video
Reads .ckpt, .safetensors and .gguf; convert mode writes .gguf or .safetensors
Flash attention, VAE tiling and TAESD cut memory use; bindings for Go, C#, Python, Rust
Weaknesses
README warns API and command-line options may change frequently
ControlNet support is stated only for SD 1.5
Shorter sampler list than stable-diffusion-webui
No node-graph UI in the README; separate projects supply GUIs
Browser-based infinite canvas for AI image and video generation
8.9k starsMITlast commit Oct 2026
A React and Vite web workbench where images, prompts and chat nodes are laid out on a pannable canvas and wired together. The browser calls your own OpenAI-compatible Base URL and API Key for text-to-image, image editing, text, audio and video. Canvases, assets and keys are stored in the browser; an optional local Canvas Agent lets Codex or Claude Code edit the canvas over MCP.
Strengths
Browser calls the API directly; keys, canvases and assets stay in local browser storage
Custom scripts adapt image and video calls to non-standard OpenAI-compatible relays
Remote node plugins installable by URL, with a TypeScript SDK
Local Canvas Agent exposes the canvas to Codex or Claude Code through MCP
Weaknesses
Generates nothing itself; needs an external OpenAI-compatible image or video API
README warns of development stage; local storage formats may change without compatibility
Data lives in the browser, so no server-side sync or multi-user accounts are described
Docs and README are mostly in Chinese; README is heavy with sponsor ads
no GPU
Docker + Compose
Needs OpenAI-compatible API endpoint and key
Models: OpenAI-compatible image, text, audio and video APIs
LTX-2 is a 22B-parameter DiT model from Lightricks that generates video with synchronized audio from text, images or input audio. The repo is a Python monorepo with ltx-core, ltx-pipelines (distilled, DFR, two-stage, retake, IC-LoRA, HDR, dubbing) and ltx-trainer for LoRA and full fine-tuning. Weights are downloaded separately from Hugging Face, about 66 GiB for the quick-start set.
Strengths
Generates audio and video together in one model, including speech
Many pipelines: distilled, DFR, keyframe, audio-to-video, retake, HDR/EXR, dubbing
Includes a trainer for LoRA, full fine-tuning and IC-LoRA
FP8 quantization and CPU or disk offload flags for limited GPU memory
Weaknesses
Quick-start weights are about 66 GiB and gated behind Hugging Face terms
Exact VRAM requirements are not stated in the README
License is not identified by tooling (NOASSERTION); check the repo terms
Fastest VAE backend (natten) is Linux and CUDA only; CLI-driven, no built-in UI
Native macOS app for generating images offline with Stable Diffusion and FLUX.2 Klein
8k starsGPL-3.0last commit Sep 2026
Mochi Diffusion is a SwiftUI macOS app that generates images locally using Apple's Core ML Stable Diffusion, with optional ControlNet and image-to-image, and the Iris pipeline for FLUX.2 Klein models on Metal. Output is saved as PNG with generation settings embedded, and a built-in gallery handles import, save and sync. It collects no telemetry and sends nothing to the cloud.
Strengths
Runs fully offline; README states no data or telemetry is collected
Uses Neural Engine via Core ML for low memory use on Apple Silicon
Supports FLUX.2 Klein 4B and 9B without model conversion, with up to 4 input images
PNG output embeds settings readable by AUTOMATIC1111-compatible tools and Civitai
Weaknesses
macOS only: requires Apple Silicon and macOS 15.6 or later
Core ML Stable Diffusion models have a fixed image size set at conversion
Models must be downloaded or converted and placed manually in a model folder
First use of a model can take up to 2 minutes to compile for the Neural Engine
GPU required
Needs Apple Core ML Stable Diffusion, iris.c, Xcode 26.0 or later (to build)
Models: Core ML Stable Diffusion (split_einsum, original), ControlNet (Core ML), FLUX.2 Klein 4B, FLUX.2 Klein 9B
Desktop package manager and built-in inference UI for Stable Diffusion tools
9k starsAGPL-3.0last commit Oct 2026
Stability Matrix is a C# desktop app for Windows, Linux and Apple Silicon macOS that installs and updates Stable Diffusion front-ends such as ComfyUI, Forge, SD.Next, Fooocus, InvokeAI and trainers like Kohya's GUI. It bundles Git and Python, shares one model directory across packages, and includes its own tabbed Inference UI for image generation.
Strengths
One-click install and update for many SD front-ends, including ComfyUI, Forge, SD.Next and InvokeAI
Embedded Git and Python, so neither needs a global install
Shared checkpoint directory across packages, with CivitAI and HuggingFace model browser
Portable data directory; downloads can pause and resume after closing the app
Weaknesses
Binaries are under a separate EULA, while source is AGPL-3.0
Plugin and extension management covers only A1111, ComfyUI, SD Web UI-UX and SD.Next
No Docker or server deployment; desktop install only
Hardware requirements (RAM, VRAM) are not stated in the README
Node-canvas and pipeline for producing AI short dramas from script to final cut
6.4k starscustom licenselast commit Oct 2026
DramaClaw is a source-available production line for AI short drama. It pairs a node-based canvas (XiaHua) with a series pipeline (XiaJi) that takes a manuscript or screenplay through episode planning, scripts, storyboards, voice-over and video export. A built-in agent, Xia Director, plans and runs canvas workflows. Inference goes through an OpenAI-compatible gateway, not local models.
Strengths
Covers the whole chain: ingest, episode planning, storyboards, voice-over, subtitles and video export
Canvas with 18 node types plus an agent that builds and runs graphs after confirmation
Light local footprint: 2 vCPU / 4 GB recommended, GPU only for the optional world extra
Agent Kit exposes workflows to Codex, Claude Code, OpenClaw and other MCP clients
Weaknesses
Elastic License 2.0 with a Powered by DramaClaw notice; hosted SaaS use not permitted
Previz 3D stage and interactive stories are closed beta, not in the main branch
Needs an external OpenAI-compatible gateway; no models run locally
Tuned for drama and short-form video; sample works are in Chinese
RAM ≥ 4 GB
GPU optional
Docker + Compose
Needs OpenAI-compatible gateway (RelayClaw or dramaclaw-gateway), Docker
Models: OpenAI-compatible API, Seedance 2.5, open-weight models via gateway
Desktop app that generates 3D meshes from photos using local models
8.3k starscustom licenselast commit Oct 2026
Modly is an Electron and TypeScript desktop app with a Python FastAPI backend that turns an image into a 3D mesh using open models on your own GPU. Models such as Hunyuan3D 2 Mini, TripoSG and Trellis2 GGUF are installed as extensions from GitHub repositories. It has a node-based workflow editor, in-app mesh smoothing and decimation, and a CLI for scripts and agents.
Strengths
Model extensions install from a GitHub URL; official ones cover Hunyuan3D 2 Mini, TripoSG, Trellis2 GGUF
Runs on Windows, Linux and Apple Silicon macOS; AMD GPUs supported via ROCm
Node-based workflows are validated before run; meshes can be smoothed and decimated in-app
Stdlib-only CLI exposes generate, workflow-run and model commands for scripts and agents
Weaknesses
Focused on image-to-3D; no general image or video generation described
Hugging Face is the only supported model weight provider
RAM and VRAM requirements are not stated in the README
Detected license is NOASSERTION; README says MIT with a required attribution credit for forks
GPU required
Needs Node.js, Python, Hugging Face (model weights)
Models: Hunyuan3D 2 Mini, Hunyuan3D 2 Mini Turbo, Hunyuan3D 2 Mini Fast, TripoSG, Trellis2 GGUF
LoRA and LoKr training suite for image, video and audio diffusion models
12.4k starsMITlast commit Oct 2026
AI Toolkit trains LoRA and LoKr adapters for diffusion models, driven by YAML configs through `python run.py` or a web UI on port 8675. It covers image, instruction/edit, video and audio models, including FLUX.1/2, Qwen-Image, Z-Image, Wan 2.1/2.2, LTX-2 and Ace Step. It targets consumer Nvidia GPUs and has setup notes for RunPod and Modal.
Strengths
Supports many recent models: FLUX.2, Qwen-Image, Wan 2.2, LTX-2, Ace Step
Same jobs run from the CLI with YAML configs or from the web UI
Layer targeting with only_if_contains and ignore_if_contains; LoKr supported
Bucketing resizes images automatically, so no manual cropping is needed
Weaknesses
Manual install requires an Nvidia GPU; Apple Silicon support is marked experimental
AI Toolkit Manager installer is labelled experimental
Datasets limited to jpg, jpeg and png; webp has issues
Ctrl+C during a checkpoint save will likely corrupt that checkpoint
GPU required
Docker + Compose
Needs PyTorch, Node.js >20 (UI), Hugging Face model weights, git
SANA is NVIDIA's research codebase for linear-attention diffusion models, covering text-to-image up to 4K, one/few-step SANA-Sprint, and video models (SANA-Video, SANA-Video 2.0, SANA-WM, SANA-Streaming). It includes training and inference pipelines, DDP/FSDP, LoRA, ControlNet, and RL post-training recipes. Weights are on Hugging Face, with diffusers, ComfyUI and SGLang integrations.
Strengths
Full training and inference code, not only weights, including DDP/FSDP and RL post-training
Runs in diffusers, ComfyUI and SGLang (OpenAI-compatible serving)
4-bit and 8-bit variants; README says SANA runs within 8GB VRAM
Public demos for image, ControlNet, Sprint and SANA-Video 2.0
Weaknesses
Research repo with many sub-projects; no single UI or one-command install
Some newer pieces (Sol-Engine, H3) live on a separate branch
Large video and world models need high-end GPUs; exact VRAM is not stated
Docs are spread across project pages and a separate docs site
Python tool that trains neural models to swap faces in images and video
57.6k starsGPL-3.0last commit Aug 2026
FaceSwap is a Python program with three stages run through `faceswap.py`: extract faces from photos or video frames, train a model on two sets of faces, and convert source media with the trained model. It ships a Tkinter-style GUI (`faceswap.py gui`) alongside the CLI, and includes models such as Villain and Phaze-A. It runs on Windows, Linux and macOS, with CUDA GPUs recommended and some AMD support via ROCm on Linux.
Strengths
Covers the full workflow: extract, train and convert, via CLI or GUI
Multiple model architectures named in the README, including Villain, Phaze-A, DFL-H128 and DFaker
Runs on Windows, Linux and macOS; AMD GPUs supported via ROCm on Linux
Existing models can be reused to shorten training on new faces
Weaknesses
Training requires a modern CUDA GPU for acceptable speed; exact VRAM needs are unknown
No Docker or compose setup in the repo
Setup problems are directed to the forum and Discord, not GitHub issues
Manual workflow: gathering and curating face data is left to the user
DiffSynth-Studio is a Python framework from the ModelScope community for inference and training of diffusion models covering image, video and audio generation, plus image quality metrics. It schedules weights across disk, RAM and VRAM and supports NF4 and INT8 quantization so large models run on small GPUs. Most models that support inference also support LoRA or full training.
Strengths
Inference and training for most supported models, including LoRA and adapter models
VRAM offloading and quantization (bitsandbytes, torchao, EntroPack) for low-VRAM GPUs
Broad model coverage: Wan, LTX-2, Qwen-Image, FLUX, ACE-Step, Stable Diffusion
Separate ComfyUI node package and LoRA training WebUI built on it
Weaknesses
Code-first library; the README describes no built-in web UI
Only two main maintainers; README warns of slow issue responses
Major version update dropped some older features
Last release was 2025-11-18, while new models land on the main branch
Web UI for generating and editing images and video with diffusion models
7.4k starsApache-2.0last commit Oct 2026
SD.Next is a Python web interface, forked from AUTOMATIC1111's Stable Diffusion WebUI, for text-to-image, image-to-image, text-to-video and image-to-video generation. It adds editing, inpainting, outpainting, LoRA, ControlNet, IP-Adapters, captioning and upscaling. It runs on NVIDIA, AMD, Intel Arc, Apple Silicon, OpenVINO devices or CPU, and a built-in installer handles dependencies and updates.
Strengths
Covers NVIDIA CUDA, AMD ROCm/ZLUDA, Intel XPU, OpenVINO, Apple MPS and CPU-only
Handles image and video generation, plus captioning, tagging, upscaling and interpolation
SDNQ quantization and CPU/GPU offloading help fit models into limited memory
Built-in installer and updater; Windows launcher exe and Docker recipes available
Weaknesses
README gives no RAM or VRAM minimums
No tagged release; the quick start installs by cloning the repo
First launch installs dependencies, which can take a while
Supported model list lives in external docs, not the README
Wan2.2 is Alibaba's video diffusion model family with a generate.py CLI for text-to-video, image-to-video, speech-to-video and character animation. It ships a MoE A14B pair for 480P/720P and a 5B TI2V model at 720P/24fps with a 16x16x4 compression VAE. Weights are on Hugging Face and ModelScope, and multi-GPU inference uses FSDP with DeepSpeed Ulysses.
Strengths
Covers T2V, I2V, TI2V, speech-to-video and character animation in one repo
TI2V-5B runs 720P at 24fps on a single 24GB GPU such as an RTX 4090
Multi-GPU inference with FSDP and DeepSpeed Ulysses is included
Integrated into ComfyUI and Diffusers, with weights on Hugging Face and ModelScope
Weaknesses
A14B single-GPU inference needs at least 80GB VRAM
CLI scripts only; no built-in web UI or server
Prompt extension needs a Dashscope API key or a local Qwen model
Requires torch >= 2.4.0 and flash_attn, which can fail to install
Gradio web UI for local text, image, audio, video and 3D generation
1.2k starsGPL-3.0last commit Oct 2026
biniou is a self-hosted Gradio web UI that bundles dozens of Hugging Face based modules: a llama-cpp chatbot for GGUF models, Whisper speech-to-text, Stable Diffusion and Flux image generation, MusicGen audio, video modules and Shap-E 3D. It runs on CPU from 8GB RAM, with optional CUDA or experimental ROCm, and can work offline once models are downloaded. Install is via one-click scripts for several Linux distributions, a Windows installer, or a Dockerfile.
Strengths
Covers text, image, audio, video and 3D generation in one UI
Runs on CPU only, from 8GB RAM; CUDA and experimental ROCm optional
Output of one module can be sent as input to another
Built-in model manager, LoRA and textual inversion support, and offline use after downloads
Weaknesses
AMD64 CPUs only; macOS support is untested and experimental
Python 3.10 or 3.11 required; Windows install pulls in many system components
Many modules need 16GB+ RAM; about 200GB disk with default models
No release tags; updates are weekly commits, mostly new model entries
RAM ≥ 8 GB
GPU optional
Docker
Needs Python 3.10/3.11, git, ffmpeg, openssl, gcc, Hugging Face model downloads
Topic-to-short-video pipeline built on ComfyUI workflows and TTS
29.3k starsApache-2.0last commit Jun 2026
Turns a topic into a short video: an LLM (GPT, Qwen, DeepSeek, Ollama) writes the script, ComfyUI or RunningHub workflows or direct APIs (DashScope Wan, GPT Image, Seedream, Seedance, Kling) produce per-sentence images or clips, Edge-TTS or Index-TTS voices it, and HTML templates lay out each frame. Streamlit UI on port 8501, plus digital-human and image-to-video modules. For creators already running ComfyUI.
Strengths
Zero-cost path: Ollama for the LLM plus a local ComfyUI instance
Image, video, TTS and VLM steps are swappable ComfyUI workflows or direct APIs
Custom HTML templates for static, image-backed and video-backed layouts
Windows one-click package bundles Python, uv and ffmpeg
Weaknesses
README and docs are Chinese first; an English README exists separately
Local image or video generation needs a running ComfyUI server (default port 8188)
Last commit June 2026; update log stops at 2026-06-01
Heavy local footprint: ComfyUI plus diffusion and TTS models
Docker + Compose
Needs uv, ffmpeg, ComfyUI or RunningHub (workflow-based generation), LLM API or Ollama
Agent pipeline that turns ideas, scripts or novels into multi-shot videos
12.7k starsMITlast commit Sep 2026
ViMax chains LLM, image and video generation APIs to turn a short idea, a screenplay or a novel into a multi-scene video. It handles scriptwriting, character references, storyboards, shot design and final assembly. It ships a TUI, a local Web UI with named projects and render previews, and direct Python entrypoints (Idea2Video, Script2Video, Novel2Video, AutoCameo).
Strengths
Covers script, storyboard, shot design and assembly in one pipeline, not just clip generation
Separate entrypoints for idea, screenplay and novel input, plus reference-photo cameo
Generates 2 keyframe candidates and picks one with a vision chat model; configurable
Local Web UI and TUI with session resume; MIT licensed
Weaknesses
Needs external LLM, image and video API keys; no local model path documented
API cost rises with image selection, which generates 2 candidates per keyframe by default
No Docker or compose files; setup is uv sync plus Node.js 18+ for the Web UI
README lists Linux and Windows only; hardware requirements and output length limits are unknown
no GPU
Needs uv, Python 3.12, Node.js 18+ (Web UI), LLM API key, image generation API key, video generation API key
Models: OpenAI-compatible chat APIs, OpenRouter, Google Gemini / Nano Banana, Google Veo, Seedance 2.0 Fast
Tencent's 13B-parameter text-to-video model, released with PyTorch model definitions, pretrained weights and inference code. It uses a dual-stream to single-stream transformer, an MLLM text encoder and a causal 3D VAE. The repo includes a Gradio demo, xDiT multi-GPU parallel inference, FP8 weights and a prompt-rewrite model.
Strengths
Open weights plus inference code, with Diffusers and ComfyUI integrations
FP8 weights and xDiT sequence-parallel inference for multi-GPU speedup
Includes Gradio web demo and prompt-rewrite model with Normal and Master modes
Active ecosystem of community accelerators, GGUF quantizations and LoRAs
Weaknesses
Needs 45GB GPU memory at 544x960, 60GB at 720x1280 for 129 frames
NVIDIA CUDA only; tested on Linux only
License is not a standard SPDX identifier (NOASSERTION); check terms before use
Tencent has since released HunyuanVideo-1.5, a newer successor model
GPU required
Needs PyTorch 2.7.1, CUDA 11.8 or 12.6, flash-attention 2.8.3, xfuser 0.4.0, conda
Open-Sora is a text-to-video and image-to-video generation project that publishes model checkpoints, inference scripts and training code. The latest release, Open-Sora 2.0, has 11B parameters, and the README reports a training cost of about $200K and VBench results comparable to HunyuanVideo (11B) and Step-Video (30B). Earlier versions (1.0 to 1.3) are kept on separate branches, and a Hugging Face Spaces Gradio demo is linked.
Strengths
Checkpoints and training code released together, with a stated ~$200K training cost for 2.0
Supports text-to-video, image-to-video and video-to-video in earlier versions (1.1 documented)
Includes a video data processing pipeline and technical reports for each version
Apache-2.0 license; Hugging Face Spaces demo and sample gallery available
Weaknesses
Last tagged release is 2025-02-21, before the 2.0 announcement in March 2025
No Docker or compose files detected
Hardware requirements are not stated in the visible README; 11B model likely needs a large GPU
Older versions live on separate branches with different checkpoints and instructions
Desktop image upscaler using Real-ESRGAN models over Vulkan
50.9k starsAGPL-3.0last commit Mar 2026
Upscayl is an Electron desktop app that enlarges low-resolution images with Real-ESRGAN-based models run through an NCNN Vulkan backend. It supports batch upscaling, GPU selection by ID, and custom models converted from other formats. Installers cover Windows 10+, macOS 12+ and Linux (AppImage, Flatpak, Snap, deb, rpm).
Strengths
Native installers for Windows, macOS and Linux, including Flatpak, Snap, AUR and Homebrew
Batch upscaling and selectable GPU ID in the GUI
Custom models can be added; a separate repo of extra models and a conversion guide exist
Separate upscayl-ncnn CLI backend is open source under AGPLv3
Weaknesses
Requires a Vulkan-compatible GPU; many integrated GPUs do not work
Cannot de-blur or fix focus; it only enhances low-resolution or pixelated images
Last tagged release is 2024-12-25, though commits continue into 2026
Image upscaling only; no video or generation features described
Gradio GUI and CLI for Kohya diffusion training scripts
12.6k starsApache-2.0last commit Jul 2026
Wraps kohya-ss/sd-scripts in a Gradio UI that builds the training command for LoRA, LoHa, LoKr, DreamBooth, full fine-tuning, Textual Inversion and LECO concept erasure. Base models include SD 1.5/2.x, SDXL, SD3, Flux.1, Lumina Image 2.0, Anima and HunyuanImage-2.1. Installs with uv or pip, runs headless over SSH on a port such as 7860, ships Docker, Runpod and Colab paths, and suits people training their own LoRAs.
Strengths
Covers LoRA, LoHa, LoKr, DreamBooth, fine-tune, Textual Inversion and LECO
GUI shell runs offline after install; no CDN assets or analytics by default
config.toml presets default paths and Gradio allowed_paths
Sample image generation during training with per-prompt seed, size and CFG flags
Weaknesses
Needs a GPU-equipped machine; README gives no VRAM figures per model
Without --headless, OS file dialogs on the server can block training over SSH
macOS support is community-maintained and may vary
Last commit July 2026; sd-scripts submodule pinned to v0.11.1
Official PyTorch implementation of the LivePortrait paper. It animates a source image or video of a human, cat or dog using motion from a driving video or a precomputed .pkl motion template. It ships CLI scripts (inference.py, inference_animals.py) and a Gradio app with pose and regional editing, and pretrained weights are hosted on Hugging Face.
Strengths
Accepts image or video sources, including portrait video editing and image-driven mode
Motion templates (.pkl) speed up inference and avoid sharing the driving video
Gradio UI, Windows one-click installer and a Hugging Face Space demo are provided
Optional torch.compile gives 20-30% faster inference per the README (not on Windows or macOS)
Weaknesses
Animals mode needs X-Pose and a compiled CUDA op; tested only with NVIDIA GPUs
Apple Silicon is not supported for Animals mode and is about 20x slower than an RTX 4090
Needs conda, FFmpeg and a manual weight download; no Docker setup
License is not detected automatically (NOASSERTION); check the repo before commercial use
HivisionIDPhotos cuts out the person with ONNX matting models (MODNet, hivision_modnet, RMBG-1.4, BiRefNet-v1-lite), detects the face, then crops and resizes to standard ID photo sizes with a chosen background color. It also produces print layout sheets (6-inch, 5-inch, A4, 3R, 4R). It runs as a Gradio demo, a CLI script, or a REST API, and the default models run on CPU.
Strengths
Default MODNet + MTCNN runs on CPU: about 410MB RAM and 0.2s per image on an M1 Max
Gradio UI, inference.py CLI and deploy_api.py REST API all included
Fully offline; Face++ cloud face detection is optional
Preset sizes and colors editable through CSV files
Weaknesses
BiRefNet-v1-lite, the most accurate matting option, needs about 6GB RAM and ~16GB VRAM on GPU
Model weights must be downloaded separately before running
README and docs are mainly Chinese; English is in a separate file
Last release is 2025-01-21; the smart outfit-change feature is still marked waiting
Offline talking-avatar video generator with voice cloning and lip-sync
16.1k starscustom licenselast commit Apr 2026
Duix.Avatar clones a person's face and voice from a short video, then renders lip-synced videos driven by text or audio. It runs as an Electron client plus Docker services for ASR (fun-asr), TTS (fish-speech-ziming) and video synthesis, all on a local NVIDIA GPU. The services expose local HTTP endpoints for voice synthesis (port 18180) and video synthesis (port 8383).
Strengths
Runs fully offline; all compute is local, so no footage leaves the machine
Exposes local HTTP APIs for audio synthesis (18180) and video synthesis (8383)
Scripts supported in eight languages, including English, Chinese, Japanese and Spanish
Clients for Windows (installer) and Ubuntu 22.04 (AppImage); lite compose file available
Weaknesses
Requires an NVIDIA GPU; services will not start without one
Heavy setup: about 70GB of image downloads and 100GB free disk recommended
Non-real-time only; interactive avatars are routed to the paid duix.com service
Custom license: enterprises above 100,000 users or 10M USD revenue need a commercial agreement
Web UI for training FLUX LoRAs on 12 to 20 GB GPUs
3.3k starsMITlast commit Jul 2026
Gradio front end (forked from AI-Toolkit) over Kohya sd-scripts that trains FLUX.1-dev LoRAs with 12 GB, 16 GB or 20 GB VRAM presets. Upload images, caption them with a trigger word and press start; base models download automatically and an Advanced tab exposes every sd-scripts flag. Runs via Pinokio, a manual venv or docker compose on port 7860, for hobbyists training FLUX LoRAs on consumer GPUs.
Strengths
VRAM presets for 12, 16 and 20 GB cards
Advanced tab is generated from sd-scripts flags, so every option is reachable
Sample images every N steps with fixed seeds to watch the LoRA evolve
Publish trained LoRAs to Hugging Face from the UI
Weaknesses
FLUX.1 only (dev, dev2pro, schnell); schnell results are called not recommended
Manual install clones sd-scripts separately and uses PyTorch nightly builds
Docker image must be built locally; PUID and PGID must match your user
Last commit July 2026
GPU required
Docker + Compose
Needs kohya-ss/sd-scripts (sd3 branch)
Models: Flux1-dev, Flux1-dev2pro, Flux1-schnell, custom bases via models.yaml
Video2X is a C/C++ tool that upscales video and interpolates frames using Anime4K v4, Real-ESRGAN, Real-CUGAN and RIFE, running through ncnn and Vulkan. It ships a Qt6 GUI and installer for Windows, plus AUR packages and an AppImage for Linux. The README states it needs no extra disk space during processing beyond the final output.
Strengths
Runs on any Vulkan GPU from NVIDIA, AMD or Intel, not just CUDA cards
Supports upscaling and frame interpolation, plus custom MPV-compatible GLSL shaders
Windows GUI installer, Linux AppImage and AUR packages, and a container image
Temporary files are not written during processing, per the README
Weaknesses
Precompiled binaries require a CPU with AVX2 support
Last tagged release is 2025-01-24, older than recent commits
AGPL-3.0 license may constrain use in hosted services
Bundled demo videos are marked outdated in the README
Stability AI reference code for SDXL, Stable Video Diffusion, SV3D and SV4D
27.3k starsMITlast commit Dec 2025
Config-driven PyTorch codebase (the `sgm` package) from Stability AI for sampling and training diffusion models: SDXL 0.9/1.0, SDXL-Turbo, Stable Video Diffusion, SV3D and SV4D 2.0. It ships Streamlit and Gradio demos plus standalone sampling scripts, with PyTorch Lightning training configs. Weights are downloaded separately from Hugging Face into `checkpoints/`.
Strengths
Covers text-to-image, image-to-video, multi-view (SV3D) and video-to-4D (SV4D 2.0) in one repo
Config-driven modules via YAML and instantiate_from_config, with example training configs
Streamlit and Gradio demos plus simple CLI sampling scripts
Low-VRAM flags such as --encoding_t, --decoding_t and --img_size for video models
Weaknesses
Last release was 2023-07-27; newer models are announced only in the README
Weights not bundled; several have research-only or RAIL++-M licenses separate from the MIT code
Tested on Python 3.10 only; package does not declare dependencies
Manual install of PyTorch, requirements and sdata; no Docker image
GPU required
Needs PyTorch 2.0, PyTorch Lightning, Streamlit, Hugging Face model weights, Stability-AI/datapipelines (sdata), rembg (optional)
Models: SDXL-base-1.0, SDXL-refiner-1.0, SDXL-Turbo, Stable Video Diffusion (SVD, SVD-XT), SV3D_u
Official repository for LTX-Video, a diffusion-transformer video generation model in 2B and 13B sizes, with distilled and FP8 variants. It provides an inference.py script and Python API for text-to-video, image-to-video, keyframe conditioning and video extension, plus ComfyUI and Diffusers integrations. The README says active development has moved to LTX-2, which adds synchronized audio.
Strengths
Multiple checkpoints: 13B dev, 13B and 2B distilled, plus FP8 quantized versions
Supports image-to-video, multi-keyframe conditioning, video extension and video-to-video
Depth, pose and canny IC-LoRA control models published on Hugging Face
Works through ComfyUI and Diffusers as well as its own inference script
Weaknesses
README states LTX-2 is now the primary home for development
README says inference.py does not yet match ComfyUI output quality
No release tags; setup is a manual pip install in a venv
VRAM and RAM requirements are not stated in the README
Open text-to-video diffusion models and training code, reproducing Sora
12.2k starsMITlast commit Mar 2026
Open-Sora Plan releases text-to-video and image-to-video diffusion transformer checkpoints (v1.0.0 to v1.5.0) along with the WF-VAE video autoencoder and a prompt refiner. Version 1.5.0 uses an 8B sparse DiT (SUV) and an 8x8x8 WF-VAE, and is trained and run on Ascend 910 NPUs via the MindSpeed-MM branch. The GPU version is listed as coming soon.
Strengths
Weights published for every version v1.0.0 through v1.5.0 on Hugging Face
v1.3.0 supports 93x480p generation within 24G VRAM
WF-VAE with 8x8x8 downsampling; README claims higher PSNR than the Wan2.1 VAE
Includes image-to-video checkpoints, a prompt refiner, and technical reports per version
Weaknesses
v1.5.0 weights only work with NPU plus MindSpeed-MM; GPU instructions say coming soon
Main branch has no runnable setup; code lives on the mindspeed_mmdit branch
No Docker, web UI or hosted demo; research-style checkpoints only
README license badge says Apache while detected license is MIT
GPU required
Needs Ascend 910 NPU (v1.5.0), MindSpeed-MM
Models: Text-to-video, Image-to-video, WF-VAE, SUV sparse DiT
Infinite-canvas agent for generating images and video from prompts or sketches
6.7k starscustom licenselast commit Mar 2026
Jaaz is a desktop app (Windows, macOS) with an infinite canvas and a chat agent that generates images and video. It calls cloud models such as GPT-4o, Midjourney, VEO3 and Kling, or local ones through ComfyUI and Ollama. The server is Python 3.12+ and the front end is React, so it can also be built manually on Linux.
Strengths
Works with both cloud video/image APIs and local ComfyUI models
Sketch and arrow input on the canvas, so prompts are optional
Manual build path from source: React front end plus Python server
Prebuilt Windows and macOS releases on GitHub
Weaknesses
License is not identified (NOASSERTION); commercial terms unclear, with a separate paid enterprise edition
README gives no RAM, VRAM or hardware requirements
No Docker image in the repo; Docker is only offered with the paid edition
Last release is 2025-08-09; manual install steps clone a different repo name (localart)
SkyReels V2 provides weights and Python inference scripts for autoregressive diffusion-forcing video models at 1.3B and 14B parameters, at 540P and 720P. It supports text-to-video, image-to-video, video extension and start/end frame control, with clips generated in chunks to reach 30 to 60 seconds. Models are on Hugging Face and ModelScope, and Diffusers pipelines are included.
Strengths
Diffusion-forcing models extend length by chunking; README gives frame counts for 10s to 60s clips
Covers T2V, I2V, video extension and start/end frame control from one script
CogVideoX is a family of open text-to-video and image-to-video transformer models (2B and 5B, plus 1.5 versions) from Zhipu AI/THUDM, with inference scripts for diffusers and SAT. The repo also includes LoRA fine-tuning code, a 3D causal VAE and prompt-optimization examples. Diffusers inference runs from about 4GB (2B) or 5GB (5B) VRAM with offloading enabled.
Strengths
Low VRAM paths: 2B from 4GB, 5B from 5GB with diffusers offloading, INT8 via torchao
Covers text-to-video, image-to-video and video continuation; 1.5 adds 10-second clips
Includes inference, LoRA fine-tuning and DDIM inversion code in one repo
Two inference stacks: diffusers and SAT, with weights on HuggingFace and ModelScope
Weaknesses
Prompts must be English and long; README recommends LLM rewriting, with a 224-226 token limit
Slow: CogVideoX1.5-5B takes about 1000 seconds for 5 seconds of video on one A100
Memory figures only tested on A100/H100; peak is about 3x without offloading
Last release was 2024-11-08; newer work is moving to the separate CogKit repo
Google Colab notebooks for running ComfyUI, AUTOMATIC1111 and DreamBooth
7.9k starsMITlast commit Nov 2025
Three Jupyter notebooks that launch ComfyUI, AUTOMATIC1111 and a DreamBooth fine-tuning workflow on Google Colab. The README is only badges and links, so it gives no setup steps, model list or requirements. The author also advertises a paid Flux and SDXL trainer via X.
Strengths
Separate Colab notebooks for ComfyUI, AUTOMATIC1111 and DreamBooth
MIT license
No local GPU needed, since the notebooks target Google Colab
Weaknesses
README has no usage instructions, requirements or supported model list
Tied to Google Colab; no local or Docker setup documented
No releases; last commit 2025-11-29
Advanced Flux and SDXL trainers are sold separately, not in this repo