How to Use Open Generative AI: A Real Setup Guide for the 600-Model Studio (2026)

Open Generative AI is one of those projects that makes you double-check the star count. It is a self-hosted image and video generation studio that bundles a very large model catalogue into one app, it is MIT licensed, and at the time of writing it sits at roughly 27.7k stars and 4.9k forks. The pitch is simple: instead of paying five different platforms for five different generators, you run one studio on your own machine and point it at whichever model you want.

This guide is the practical version. What it actually is, what you need installed, the exact commands, the difference between the three ways it can generate, and the two platform-specific problems that waste people an evening.

What Open Generative AI actually is

The repository is Anil-matcha/Open-Generative-AI, and it ships as both a desktop app (Electron, with installers for macOS on Intel and Apple Silicon, Windows x64, and Linux as AppImage or .deb) and a web build you run locally with Next.js.

The catalogue is the headline. The project advertises 600+ models, broken down roughly as 70+ text-to-image, 70+ image-to-image, 85+ text-to-video, and 120+ image-to-video, plus a set of dedicated lip-sync models where you supply a portrait and an audio track and get a talking-head clip back.

One fact worth stating plainly rather than burying: the project describes itself as unrestricted, with no content filters. That is a deliberate design choice by its authors, and it means the responsibility for what you generate, and for the rights to the faces and products you feed it, sits entirely with you.

What you need before you start

• Git, and specifically the ability to clone with submodules.
• Node.js v18 or newer. The setup script and both builds depend on it.
• A GPU worth the name if you want local generation. Apple Silicon uses Metal; Linux and Windows use CUDA, Vulkan, or ROCm.
• A Muapi.ai access key, only if you want the hosted cloud models rather than local ones.

If you would rather not install anything, skip to the honest note near the end.

Installing it

The single most common failure is cloning the repository without its submodules. Do it this way:

git clone --recurse-submodules https://github.com/Anil-matcha/Open-Generative-AI.git
cd Open-Generative-AI
npm run setup

Then pick a build. For the desktop app:

npm run electron:dev

For the web version, which opens at http://localhost:3000:

npm run dev

If you already cloned it the plain way and the build is failing in confusing places, you do not need to start over. Run git submodule update --init --recursive inside the folder, then npm run setup again.

If you only want to use the app and never touch the source, the release page has prebuilt desktop installers for all three platforms. The source route is for people who want to modify it or run the web build.

The three ways it generates, and which one you want

This is the part that confuses new users, because the same app offers three very different backends.

1. Local with sd.cpp (bundled). This runs entirely on your machine with no keys and no per-image cost. It covers SD 1.5, SDXL, and Z-Image. It is the right starting point: you can confirm the install works before you introduce any external dependency.

2. Local with Wan2GP (you host it). This is a separate Gradio server you stand up yourself, and it unlocks Flux, Qwen-Image, and the video models including Wan 2.2, Hunyuan, and LTX. It is more setup and much more VRAM, but it is where the video generation actually lives. Treat it as a second project, not a checkbox.

3. Hosted cloud models via Muapi.ai. You paste an access key and get the big commercial models through the same interface. One small detail that trips people up: enter only the key value, not the key name or label. This path costs money per generation, billed by that provider, not by the app.

The mental model that saves time: sd.cpp proves your install, Wan2GP is the real video engine, and Muapi is the convenience lane you pay for.

The two gotchas that will actually bite you

These are documented, and both cost real time if you meet them cold.

Z-Image on a base 8GB M-series Mac is known to hang the system. Not fail gracefully, hang. If you are on 8GB Apple Silicon, stay on SD 1.5 and treat Z-Image as unavailable to you.

Ubuntu 24.04 and newer may block the AppImage because of an AppArmor restriction on unprivileged user namespaces. You have two clean options: install the .deb package instead, or disable kernel.apparmor_restrict_unprivileged_userns. The .deb is the less invasive answer.

Using it with Claude Code, Cursor, or Codex

Open Generative AI is a graphical studio, not an agent-first tool, so a coding agent will not click through it for you. What an agent is genuinely good at here is everything around the app:

• Running the clone, submodule, and setup steps and reading the errors back to you when a native dependency fails to build.
• Patching configuration so a specific local model is the default and you stop re-selecting it.
• Writing a small script that drives the local web build in batch, so a folder of product photos becomes a folder of image-to-video clips instead of 40 manual runs.
• Diagnosing the platform gotchas above from the actual error text rather than from a forum guess.

Open the repository folder in your agent, tell it what you are trying to run, and let it own the setup loop. That is the highest-leverage way to use an agent with a project like this.

Realistic expectations

A 600-model catalogue is a discovery problem, not just a capability. Most people use three or four models and ignore the rest, and that is the correct outcome. Pick one text-to-image model and one image-to-video model, learn what they do badly, and stop shopping.

Local video generation is also a different weight class from local image generation. Images on SD 1.5 will feel quick. Video through Wan2GP will make you aware of your GPU in a way images never did.

And a studio gives you generation, not judgment. It will happily produce a technically clean clip that no one watches, because nothing in the tool has an opinion about structure, pacing, or why a particular video earned attention in the first place.

A short, honest note

If your goal is to learn generative video, run models locally, and own the whole stack, this project is an excellent place to spend a weekend. Go star it.

If your goal is to ship short-form video that actually performs, the bottleneck usually is not model access. It is knowing which structure to build on. That is the problem Riffkit works on: you give it one video that already won, it models the emotion formula underneath, and it rebuilds that formula as your own video with your product and your character. Same formula, new story, and no local GPU involved.

If you like the open-source route, the closest neighbour to this project is the agentic one: see our setup guide for OpenMontage, which drives video production through your coding assistant instead of a studio UI. And if you are weighing this project against hosted tools, we wrote that comparison separately in Open Generative AI alternatives.

Get the Riffkit skill

If you already live in Claude Code or Cursor, you can riff a winning video without leaving the terminal. The Riffkit skill takes one source link and a sentence of direction, and returns a finished video plus caption. It is the same idea as running a studio locally, minus the GPU.