A premium, zero-configuration local AI studio and offline GUI for Stable Diffusion (Image Generation), LLMs (Chat), Whisper (Speech-to-Text), and Kokoro (Text-to-Speech). Powered by hardware-accelerated GPU and NPU execution on Windows, Linux, and macOS.

🎥 Watch the Setup & Demo Video: https://youtu.be/qvamkqmLPn8

• What is Uncensored AI Studio?
• Key Features
• Workspace & Engine Architecture
• Supported Models
• Folder Architecture
• Getting Started
  • Windows Setup
  • Linux Setup
  • macOS Setup
• Hardware Compatibility & Acceleration
• Troubleshooting & FAQ
• Building From Source
• Licensing

Uncensored AI Studio is a completely offline, zero-setup, self-contained AI studio for Windows, Linux, and macOS. Unlike cloud-based AI systems, it runs entirely on your own hardware with no censorship, tracking, subscriptions, or login requirements.

It unifies four major local AI capabilities into one high-performance desktop interface:

1. 🎨 Image Generation (Stable Diffusion): Generate and edit high-quality images offline using .safetensors, .gguf, or .ckpt model weights.
2. 💬 Text Chat (LLMs): Converse privately with open-source language models (GGUF format) powered by official, high-performance llama.cpp backends.
3. 🎙️ Speech-to-Text (Whisper): Transcribe voice recordings and speech to text in real-time with an integrated whisper.cpp engine.
4. 🗣️ Text-to-Speech (Kokoro TTS): Convert text outputs into highly natural, lifelike vocal audio offline using the Kokoro-82M ONNX model.

• 100% Offline & Private: Run inferences locally. No internet, telemetry, cloud logging, or API keys required.
• Zero-Install Portability: Entire runtime (Node.js, models, GPU backends) is self-contained. Zero global system environment changes.
• Auto-Configured Acceleration: Auto-detects hardware specs to load CUDA (Nvidia), ROCm (AMD), Vulkan (Intel/AMD/NVIDIA), Metal (macOS), or OpenVINO (Intel NPU) backends.
• Integrated Model Manager: Paste Hugging Face URLs to download weights directly, or drag-and-drop local weights to import them.
• Live Performance Monitor: Track CPU, RAM, GPU, and VRAM utilization in real-time directly inside the web UI.
• Local Output Gallery: Saves generated images side-by-side with prompt parameters and metadata JSON files.

To avoid exhausting system RAM or VRAM, text and image engines are mutually exclusive by default. You can switch between workspaces inside the UI:

• Image Generation Workspace: Uses a dedicated stable-diffusion.cpp backend node. Model weights are stored in app/models/.
• Text Chat Workspace: Uses a portable llama.cpp server backend. Model weights (.gguf) are stored in app/llm-models/. A small Qwen2.5 Coder starter model can be downloaded directly from the Text Chat panel.
• Speech Worker (Whisper): Runs a localized whisper-cli process to convert your vocal input to text.
• Audio Output (Kokoro TTS): Utilizes kokoro-js locally on the server side to read responses in natural voices.

The app is designed around single-file local models that can be loaded directly by the bundled backend engines.

Known-good image models available from the Model Manager:

Uncensored-AI-Studio/
├── windows.bat                # Windows Launcher (Double-click entrypoint)
├── linux.sh                   # Linux Launcher (Terminal entrypoint)
├── mac.sh                     # macOS Launcher (Terminal entrypoint)
├── LICENSE                    # MIT Open Source License
├── .gitignore                 # Excludes models and output images from version control
├── README.md                  # Detailed system documentation
├── scripts/
│   ├── setup/                 # Platform setup and backend installers
│   ├── reset/                 # Clean install & environment repair
│   ├── server/                # UI web server and backend lifecycle manager
│   ├── workers/               # Local worker processes
│   ├── build/                 # Optional source build helpers
│   └── config/                # Runtime configuration catalogs
└── app/
    ├── frontend/              # UI source code (Vite + React)
    ├── models/                # Place image weights here (.safetensors, .gguf, .ckpt)
    ├── llm-models/            # Place text GGUF weights here
    └── outputs/               # Saved images and parameters metadata

Ensure you have a modern web browser installed. Follow the quick guide below for your platform:

1. Launch: Double-click windows.bat.

   [!NOTE] On the first run, the script will automatically download a portable Node.js runtime and configure pre-compiled GPU/CPU backend binaries.

2. Add Models: Drop .safetensors, .gguf, or .ckpt weights into app/models/ (or download them via the Model Manager tab in the UI).
3. Generate: Open http://localhost:1420 in your browser, select your model, and write a prompt.

1. Make executable: Open a terminal in the project folder and make the script executable:

   chmod +x linux.sh

2. Launch: Run ./linux.sh.
   • NVIDIA GPU Users: You will be prompted to set up the high-performance CUDA backend (downloads prebuilt or automatically compiles from source as a fallback).
   • AMD Radeon Performance: Run with ./linux.sh --max-perf to add the ROCm backend (~1.3 GB download).
   • Intel Core Ultra NPU: Run with ./linux.sh --setup-openvino to configure Intel NPU support (requires Intel Linux NPU driver).
3. Add Models: Drop your weights into app/models/ or download them via the Model Manager tab.
4. Generate: Open http://localhost:1420 in your browser.

1. Make executable: Open a terminal in the project folder and make the script executable:

   chmod +x mac.sh

2. Launch: Run ./mac.sh.

   [!IMPORTANT] The prebuilt macOS backend is optimized for Apple Silicon (M1 or newer) and uses Metal GPU acceleration. (macOS Intel hardware is completely unsupported).

3. Add Models: Drop your weights into app/models/ or download them via the Model Manager tab.
4. Generate: Open http://localhost:1420 in your browser.

The setup script (scripts/setup/setup.sh) now automates building and setting up the CUDA backend from source when selected. If you want to manually build all backends (CPU, Vulkan, and CUDA) at once, you can run the included scripts/build/build_from_source.sh script.

For macOS, the included scripts/build/build_from_source.sh builds the Metal backend and copies it to app/backend/mac/sd.

• git, cmake, make (or ninja), and a C++17 compiler (g++ / clang++).
• For CUDA: the NVIDIA CUDA toolkit (nvcc) must be on your PATH.
• For Vulkan: the Vulkan SDK / loader and a compatible driver.
• For ROCm: AMD ROCm development libraries.
• For macOS Metal: Apple Command Line Tools or Xcode.

# 1. Clone upstream
git clone https://github.com/leejet/stable-diffusion.cpp.git
cd stable-diffusion.cpp
mkdir build && cd build

# 2. Configure for your backend (pick ONE)
# CPU only
cmake .. -DSD_BUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=Release

# CUDA
cmake .. -DSD_CUDA=ON -DSD_BUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=Release

# Vulkan
cmake .. -DSD_VULKAN=ON -DSD_BUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=Release

# ROCm
cmake .. -DSD_HIPBLAS=ON -DSD_BUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=Release

# macOS Metal
cmake .. -DSD_METAL=ON -DSD_BUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=Release

# 3. Build
cmake --build . --config Release -j$(getconf _NPROCESSORS_ONLN 2>/dev/null || sysctl -n hw.ncpu)

# 4. Copy the binaries into this project
cp bin/sd* /path/to/Uncensored-AI-Studio/app/backend/linux/<backend>/

After copying, rename the server binary to match what scripts/server/serve.cjs expects:

• Vulkan: sd → sd-vulkan
• ROCm: sd → sd-rocm

Then restart the app with ./linux.sh (Linux) or ./mac.sh (macOS).

This project is licensed under the MIT License - see the LICENSE file. Bundles stable-diffusion.cpp (MIT License). Model weights are subject to their respective creators' licenses.