Skip to content

SyntheticAutonomicMind/ALICE

BranchesTags

Repository files navigation

ALICE - Artificial Latent Image Composition Engine

Local AI image generation that runs on your hardware. No subscription, no cloud uploads, no per-image cost.

I built ALICE for fun. I wanted to generate images on my own hardware without paying per image or uploading prompts to someone else's server. ALICE is a standalone Stable Diffusion service with a web interface, an OpenAI-compatible API, and native integration with SAM. Your prompts and images never leave your hardware.

Use ALICE on its own through the web interface, connect it to SAM for image generation, or integrate it with any client that supports the OpenAI image API.

ALICE is part of Synthetic Autonomic Mind.

License: GPL v3 Python FastAPI Part of Synthetic Autonomic Mind

Website | GitHub | Issues

What You Can Do With ALICE

  • Generate images locally - Stable Diffusion runs on your hardware. No subscription, no cloud uploads, no per-image cost.
  • Standalone web interface - Browse, generate, and manage images at http://localhost:8080/web/. No other software needed.
  • Use with SAM - SAM connects to ALICE for image generation. Ask SAM to create an image and ALICE handles it.
  • OpenAI-compatible API - Any client that speaks the OpenAI image API can use ALICE. Generate images, list models, manage galleries - all via REST.
  • Browse and download models - Search CivitAI and HuggingFace from ALICE's web interface. One-click download.
  • Private by default - Generated images are private. Share selectively with time-based expiration.
  • Works on your hardware - NVIDIA (CUDA), AMD (ROCm, including Steam Deck), Apple Silicon (Metal), or CPU fallback.

Quick Install

ALICE needs two things: the software (installed below) and at least one Stable Diffusion model. See Getting Models after installing.

macOS (SAM integration)

Apple Silicon Macs (M1/M2/M3/M4) get GPU-accelerated generation via Metal. Intel Macs run CPU-only.

Prerequisites: Homebrew and Python 3.10+

# Install Homebrew if you don't have it
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install Python 3.10+
brew install python

Install ALICE:

git clone https://github.com/SyntheticAutonomicMind/ALICE.git && cd ALICE

# Background service (recommended - starts automatically at login):
./scripts/install_macos.sh

# Or install without the background service (start manually):
./scripts/install_macos.sh --manual

The installer detects your Mac's architecture, installs PyTorch with the right backend (MPS for Apple Silicon, CPU for Intel), and sets up the service. It runs entirely as your user account.

Service management:

launchctl start com.alice          # Start
launchctl stop com.alice           # Stop
tail -f ~/Library/Logs/alice/alice.log  # Logs

Connect to SAM:

  1. Make sure ALICE is running - open http://localhost:8080/health to check
  2. In SAM go to Settings > Image Generation
  3. Set the server URL to http://localhost:8080
  4. Download a model (see Getting Models)
  5. Ask SAM to generate an image

For a full macOS setup guide, see docs/MACOS-DEPLOYMENT.md.

Linux (one-liner)

TAG="$(curl -s https://api.github.com/repos/SyntheticAutonomicMind/ALICE/releases/latest | python3 -c "import sys,json;print(json.load(sys.stdin)['tag_name'])")"
VERSION="${TAG#v}"
curl -sL "https://github.com/SyntheticAutonomicMind/ALICE/releases/download/${TAG}/alice-${VERSION}.tar.gz" | tar xz && cd alice-* && sudo ./scripts/install.sh

Installs as a systemd service to /opt/alice. Detects AMD (ROCm), NVIDIA (CUDA), and CPU-only automatically.

Docker

git clone https://github.com/SyntheticAutonomicMind/ALICE.git && cd ALICE
make docker-up-cuda   # NVIDIA
make docker-up-rocm   # AMD
make docker-up        # CPU only

Getting Models

ALICE needs at least one Stable Diffusion model to generate images. Models are large files (2-10GB) that contain the AI's learned knowledge. ALICE doesn't ship with models - you download them separately.

Recommended: SDXL

SDXL produces high-quality images at 1024x1024. Requires about 6-8GB of memory (unified memory on Apple Silicon).

For Macs with 8GB or less: SD 1.5

SD 1.5 models are smaller (2-4GB) and work well on lower-memory systems. Native resolution is 512x512.

How to download

Option 1 - ALICE web interface (easiest)

Open http://localhost:8080/web/ and go to the Download tab. Search for a model on CivitAI or HuggingFace and click Download.

Option 2 - Download manually

Download a .safetensors file from CivitAI or HuggingFace and place it in:

  • macOS: ~/Library/Application Support/alice/data/models/
  • Linux: /var/lib/alice/models/ (system install) or ~/.local/share/alice/models/ (SteamOS)

ALICE auto-discovers models on startup. In the web interface, go to Models > Refresh to pick up new models.

Screenshots

Dashboard & Control Center

Real-time system status, GPU monitoring, and quick generation access

Advanced Generation Interface

Full parameter controls: model selection, schedulers, guidance scale, dimensions

Private Image Gallery

Organize and manage generated images with privacy controls and metadata

Hardware Support

Platform Backend Notes
NVIDIA CUDA 12.4 Recommended. 8GB+ VRAM
AMD ROCm 6.2 Full support including Steam Deck. See AMD Deployment Guide
Apple Silicon MPS M1/M2/M3/M4. Automatic acceleration
CPU Fallback Works on any system. Significantly slower

Supported Models

  • Stable Diffusion 1.5 - 512x512 native resolution
  • Stable Diffusion 2.x - 768x768 native resolution
  • SDXL - 1024x1024 native resolution
  • FLUX - High-quality model with extended capabilities
  • Custom models - Any Stable Diffusion variant
  • Formats - Diffusers directory or single .safetensors file

API

ALICE provides an OpenAI-compatible API. Generate images, list models, manage the gallery, and download models - all via REST endpoints.

For complete API documentation, see docs/API.md.

Configuration

Edit config.yaml to customize ALICE behavior: server settings, model defaults, generation parameters, storage limits, and NSFW filtering.

For full configuration reference, see docs/CONFIGURATION.md.

Requirements

  • Python 3.10 or newer
  • RAM 16GB minimum (32GB recommended for SDXL/FLUX)
  • Disk 50GB+ for model storage
  • GPU 8GB+ VRAM recommended (4GB for smaller models)

Key dependencies: PyTorch 2.6.0, diffusers 0.35.2, FastAPI 0.104.1. See requirements.txt for the complete list.

Documentation

Document What You'll Find
macOS Deployment Full macOS setup and troubleshooting
AMD Deployment AMD/ROCm setup including Steam Deck
Architecture System design and internals
Implementation Guide Development guide
API Reference Complete API documentation
Configuration Full config reference
Website Online guides and updates

Part of the Ecosystem

ALICE is part of Synthetic Autonomic Mind - a family of open source AI tools:

  • SAM - Native macOS AI assistant. SAM connects to ALICE for image generation.
  • CLIO - Terminal AI coding assistant (macOS, Linux, Windows)
  • SAM-Web - Access SAM from iPad, iPhone, or any browser

License

GPL-3.0 - See LICENSE for details.

Created by Andrew Wyatt (Fewtarius) · syntheticautonomicmind.org · github.com/SyntheticAutonomicMind/ALICE

Built with open source: Stable Diffusion · diffusers · FastAPI · PyTorch

About

Artificial Latent Image Composition Engine

Topics

python macos linux api web image-generation webui text2image diffusion-models stable-diffusion stable-diffusion-webui sdxl

Resources

Readme

License

GPL-3.0 license
Activity
Custom properties

Stars

12 stars

Watchers

0 watching

Forks

2 forks
Report repository

Releases 5

v20260223.1 Latest
Feb 23, 2026
+ 4 releases

Sponsor this project

Packages

 
 
 

Contributors

Languages