# Open Generative AI GitHub Repo: A Self-Hosting Teardown (2026)

> Source: <https://dev.to/larssaleh/open-generative-ai-github-repo-a-self-hosting-teardown-2026-ajg>
> Published: 2026-10-07 03:13:24+00:00

**TL;DR:** If you search "open generative ai github" in 2026, the repo you land on is `Anil-matcha/Open-Generative-AI`: an MIT-licensed Next.js and Electron studio for image, video, and lip sync generation, at roughly 29.7k stars and 5.4k forks as of October 6. The UI is open source and self-hostable. Most of the models behind it are not. Cloud generation goes through the Muapi.ai API with your own key, and truly local inference only exists in the desktop app, through two engines with real hardware requirements.

Some context on why I care. I build media features into client apps, mostly backend work: queues, webhooks, storage. When a client wants text-to-video in production, I usually call a hosted API such as [AI Video API](https://aivideoapi.com/?utm_source=devto&utm_medium=ugc&utm_campaign=larssaleh&utm_content=open-generative-ai-github-intro) rather than run video models on our own GPUs. Open Generative AI keeps coming up as the "free, self-hosted" alternative, so I read through the repo, the package scripts, and the release assets to see what you actually get.

The dev.to article that currently ranks for this search is a January 2025 list of three image projects: CompVis Stable Diffusion, DALL-E Mini, and StyleGAN3. Those are model repos. Open Generative AI is a different kind of thing: a front end that puts hundreds of hosted models behind one interface.

From the README and `package.json`:

`packages/studio` component library holds the studios, and `packages/studio/src/models.js` is the single list of model definitions.`npm run dev`), an Electron desktop build, and a hosted copy on muapi.ai.
The same `packages/studio` library powers the hosted version on muapi.ai, which explains why the model list moves so fast. Model updates land in one file and ship to both.

This is the part the repo description ("Self-hosted, MIT licensed") glosses over.

| Layer | Where it runs | What you need | 
|---|---|---|
| UI (all studios) | Your machine or server | Node.js 18+, or the desktop installer | 
| Cloud models (Flux, Kling, Veo, Sora, Seedance, Midjourney...) | Muapi's API | A Muapi access key, billed by Muapi | 
| sd.cpp local engine | Your machine, desktop app only | CPU works; Metal on Apple Silicon, CUDA/Vulkan/ROCm elsewhere | 
| Wan2GP local engine | Your GPU box, desktop app only | Your own Wan2GP install on a CUDA or ROCm GPU | 
| Hosted web version | muapi.ai | A free account; always uses cloud APIs | 

The API flow is documented in the README. The app submits a job with `POST /api/v1/{model-endpoint}`, then polls `GET /api/v1/predictions/{request_id}/result` until the status is `completed`, authenticating with an `x-api-key` header. Your key sits in browser `localStorage` and, per the README, is only sent to Muapi.

So "free" means the code costs nothing. Generations on the big commercial models cost whatever Muapi charges for them. That's a perfectly reasonable design, a bring-your-own-key client, but you should budget for it before you tell a stakeholder it's free.

The README is clear that most people should grab a prebuilt installer. If you want to hack on it, this is the path, and I checked each script name against `package.json`:

```
# submodules are required for the workflow and agent packages
git clone --recurse-submodules https://github.com/Anil-matcha/Open-Generative-AI.git
cd Open-Generative-AI

# "setup" = git submodule update + npm install + build all workspace packages
# plain `npm install` is not enough
npm run setup

# then ONE of these
npm run electron:dev   # desktop app (Vite build, then Electron)
npm run dev            # web version on http://localhost:3000

# production web build
npm run build && npm run start
```

If Next.js complains it can't find a `pages` directory, you're either not in the repo root or you cloned without submodules. Re-run `npm run setup` if `packages/Vibe-Workflow` or `packages/agents` are empty.

Local generation is desktop-only. The hosted and web builds always call cloud APIs.

**sd.cpp (bundled).** Built on stable-diffusion.cpp. You install it with one click under Settings, then Local Models. It handles image models only: Dreamshaper 8, Realistic Vision 5.1, and Anything v5 (SD 1.5, about 2.1 GB each), SDXL Base 1.0 (6.9 GB), and Z-Image Turbo and Base, which also need a 2.4 GB Qwen3-4B text encoder and a 335 MB FLUX VAE. The README warns that Z-Image is known to hang a base 8 GB M-series Mac and recommends 16 GB of RAM. On 8 GB, stick to SD 1.5.

Weights default to Electron's app-data folder (`~/Library/Application Support/open-generative-ai/local-ai` on macOS, `~/.config/open-generative-ai/local-ai` on Linux). If you'd rather keep multi-GB weights on another drive, set `OPEN_GENERATIVE_AI_LOCAL_AI_DIR` before launch.

**Wan2GP (bring your own).** This is where video lives. The app doesn't bundle Python or weights. You install Wan2GP yourself on a CUDA or ROCm machine, and the app either runs `wgp.py` from a local folder or talks to Wan2GP's MCP server on another box:

```
python wgp.py --mcp --mcp-api-version 1 --mcp-transport streamable-http \
  --mcp-host 0.0.0.0 --mcp-port 7866
```

You paste `http://<host>:7866/mcp` into the settings panel. The Gradio UI on port 7860 won't work for this. Only bind to `0.0.0.0` on a network you trust.

The remote mode is the clever part. Wan2GP has no Apple Silicon path, so a Mac user can keep the desktop app and push inference to a Linux GPU box or a rented instance. Supported models include Wan 2.1 1.3B (480p, about 8 GB VRAM, the lightest option), Wan 2.2 14B T2V/I2V, Hunyuan Video 1.5, LTX-2 Distilled (720p), plus Flux.1 Dev and Qwen Image for stills.

`models.js` yourself if the number matters to you.`.dmg` builds for arm64 and Intel, a Windows `.exe`, an `.AppImage`, and a `.deb`. Go to the Releases page directly.` xattr -cr "/Applications/Open Generative AI.app"` or the "Open Anyway" button; on Windows, SmartScreen's "Run anyway."`apparmor_restrict_unprivileged_userns`. The | Repo | Stars (Oct 2026) | Last push | What it is | 
|---|---|---|---|
| Anil-matcha/Open-Generative-AI | 29.7k | Oct 2026 | Multi-model studio UI, BYO key plus local engines | 
| CompVis/stable-diffusion | 73.5k | Jun 2024 | Original SD research code | 
| borisdayma/dalle-mini | 14.7k | Nov 2023 | DALL-E Mini model code | 
| NVlabs/stylegan3 | 6.9k | Sep 2023 | GAN research code, NVIDIA GPU | 
| deepbeepmeep/Wan2GP | 10.1k | Oct 2026 | Local video/image runtime for modest GPUs | 
| leejet/stable-diffusion.cpp | 7.5k | Oct 2026 | C++ diffusion inference, powers the sd.cpp engine | 

The 2025 list is still useful as history. If you want to generate something this week, the three bottom rows are where the activity is, and the top row ties them together behind a UI.

**Is Open Generative AI on GitHub really free?**

The code is MIT licensed and free. Cloud generations go through Muapi with your own key, which is billed. Local generation through sd.cpp or Wan2GP costs only your hardware.

**Can I run Open Generative AI fully offline?**

Only in the desktop app, using sd.cpp for images or a Wan2GP install for video. The web build and the hosted version always use cloud APIs.

**What GPU do I need for local video?**

Wan2GP needs a CUDA or ROCm GPU. Wan 2.1 1.3B at 480p is listed at about 8 GB VRAM. Larger models such as Wan 2.2 14B are noted as slow on consumer cards.

**Is Open Generative AI the same as Stable Diffusion?**

No. Stable Diffusion is a model. Open Generative AI is a studio that can run SD 1.5 and SDXL locally and also calls hundreds of hosted models.

For prototyping and comparing models side by side, Open Generative AI is the most complete open-source front end I've looked at, and the Wan2GP-over-MCP setup is worth stealing even if you never use the UI. For a production feature where a user clicks "generate" and expects a video back through a webhook, I still prefer a narrower hosted service. For that job I reach for [AI Video API](https://aivideoapi.com/?utm_source=devto&utm_medium=ugc&utm_campaign=larssaleh&utm_content=open-generative-ai-github-outro), which handles text-to-video and image-to-video with callback webhooks, so my backend stays a queue and a handler. The repo is at [github.com/Anil-matcha/Open-Generative-AI](https://github.com/Anil-matcha/Open-Generative-AI) if you want to read `models.js` yourself.