Run Fruit AI locally for video generation
🤖 Researched and drafted automatically from the official docs, and reviewed before publishing. Commands are taken from the source projects — but always sanity-check before running anything on your own hardware.
Fruit AI is a local-first video generation tool designed to create fruit-themed content. Running it on bare metal gives you full control over inference, no cloud bills, and privacy for your video projects. This guide walks you through a production-ready setup on a Linux machine.
Prerequisites
You’ll need:
- A Linux machine with at least 8GB RAM (16GB+ recommended for faster inference)
- NVIDIA GPU strongly recommended (CUDA 11.8+); CPU inference is possible but slow
- 50GB free disk space for model weights
- Python 3.8 or later
- Git
Step 1: Clone the repository
git clone https://github.com/fruitai/fruit-ai.git
cd fruit-ai
Step 2: Create a Python virtual environment
python3 -m venv venv
source venv/bin/activate
Step 3: Install dependencies
pip install --upgrade pip
pip install -r requirements.txt
If you have an NVIDIA GPU, also install CUDA support:
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
Step 4: Download model weights
Fruit AI downloads models on first run. Expect 10–30GB depending on which models you use. Run a test generation to trigger the download:
python fruit_ai.py --help
Refer to the official docs at https://fruitai.io/docs for the latest model URLs and configuration options.
Step 5: Generate your first video
Create a simple prompt file or use the CLI directly. Check the repo README for exact command syntax, as it may vary by version. A typical workflow looks like:
python fruit_ai.py --prompt "apple falling in slow motion" --output video.mp4
Consult https://fruitai.io/docs for the exact parameters your version supports.
Step 6: Run as a background service (optional)
For continuous operation, create a systemd service file at /etc/systemd/system/fruit-ai.service:
[Unit]
Description=Fruit AI Video Generation Service
After=network.target
[Service]
Type=simple
User=fruitai
WorkingDirectory=/opt/fruit-ai
Environment="PATH=/opt/fruit-ai/venv/bin"
ExecStart=/opt/fruit-ai/venv/bin/python fruit_ai.py --server
Restart=on-failure
RestartSec=10
[Install]
WantedBy=multi-user.target
Enable and start it:
sudo systemctl daemon-reload
sudo systemctl enable fruit-ai
sudo systemctl start fruit-ai
Check logs with sudo journalctl -u fruit-ai -f.
Step 7: Secure your setup
Important: Fruit AI should never be exposed to the public internet. Keep it on your LAN or behind a VPN only. If you run a web interface, bind it to 127.0.0.1 or a private network address, not 0.0.0.0.
If you need remote access, use SSH tunneling or WireGuard instead of opening ports.
Monitoring and maintenance
- Watch GPU memory usage with
nvidia-smiduring video generation - Keep the repo updated:
git pullperiodically - Monitor disk space; old videos and temp files can fill your drive
- Check the official docs for new model releases and performance tips
Is it worth it?
Yes, if you’re generating fruit videos regularly and want to avoid cloud costs or API rate limits. The upfront hardware cost (especially a decent GPU) is real, but inference on your own iron is fast and free after that. If you only generate a handful of videos per month, a cloud API might be simpler. But for a homelab that doubles as a creative tool, this pays for itself quickly and keeps your work private.
Related video
New self-hosted AI & homelab shorts, daily.
Subscribe on YouTubeRelated guides
Run Claude Code and Codex Locally with OtoDock
Deploy OtoDock on your server to get local code generation without cloud API costs. Self-hosted alternative to Claude Code and GitHub Copilot.
Run Claude Code Locally with OtoDock
Deploy OtoDock on your own hardware to run Claude Code and Codex as local AI agents without paying per API call. Full self-hosted setup.
Self-host Claude Code agents with OtoDock
Run Claude's code execution engine on your own hardware. Replace the SaaS with OtoDock—a self-hosted agent framework that keeps your inference and execution local.