AIRI: Complete Guide to Building Your Own AI VTuber Like Neuro-sama

TL;DR: AIRI is an open-source platform for creating AI VTubers like Neuro-sama that can play games, stream live, and interact with audiences in real-time. Built with modern Web technologies (WebGPU, WebAssembly, WebAudio), AIRI runs in browsers or as desktop/mobile apps, supports local AI inference, and includes gaming capabilities (Minecraft, Factorio), memory systems, Live2D/VRM avatars, speech recognition, and voice synthesis—giving you complete ownership of your digital companion.

What is AIRI?

Project AIRI (愛理/アイリ) is an ambitious open-source project that recreates the capabilities of Neuro-sama, the famous AI VTuber who can play games, interact with chat, and stream autonomously.

Unlike Neuro-sama (which is proprietary and only available during live streams), AIRI enables anyone to create, customize, and own their AI VTuber that can:

✅ Play games - Minecraft, Factorio, Kerbal Space Program, Helldivers 2 ✅ Stream live - Interact with audiences in real-time ✅ Chat on platforms - Discord, Telegram integration ✅ Remember conversations - Persistent memory system ✅ See your screen - Computer vision for gameplay ✅ Speak and listen - Real-time voice chat ✅ Use avatars - Live2D and VRM model support ✅ Run locally - WebGPU inference, no cloud required

The Vision: Digital Companions for Everyone

The project's tagline says it all:

"Re-creating Neuro-sama, a soul container of AI waifu / virtual characters to bring them into our world."

AIRI aims to make cyber companions (digital waifus, virtual pets, AI friends) accessible to everyone—not just as chatbots, but as fully-realized digital beings capable of:

• Playing games with you
• Watching videos together
• Helping with coding and development
• Streaming and entertaining
• Learning and remembering your preferences
• Existing across devices (browser, desktop, mobile)

Why AIRI Exists: The Problem with Current Solutions

Existing AI Companion Platforms

Chat-only platforms (Character.ai, JanitorAI, SillyTavern):

• ✅ Good for text-based roleplay
• ✅ Easy to use
• ❌ No gaming capabilities
• ❌ No visual presence
• ❌ No real-time interaction
• ❌ Limited to conversation

Neuro-sama (the inspiration):

• ✅ Can play games (Minecraft, Osu!)
• ✅ Can interact with chat
• ✅ Entertaining and engaging
• ❌ Not open source
• ❌ Only available during streams
• ❌ Cannot customize or self-host
• ❌ No personal interaction

AIRI's Solution

AIRI combines the best of both worlds:

┌─────────────────────────────────────────────────────┐
│                   AIRI Platform                     │
├─────────────────────────────────────────────────────┤
│                                                     │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────┐ │
│  │  Chat-based  │  │    Gaming    │  │  Visual  │ │
│  │  interaction │  │ capabilities │  │ presence │ │
│  └──────────────┘  └──────────────┘  └──────────┘ │
│                                                     │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────┐ │
│  │    Memory    │  │  Real-time   │  │  Local   │ │
│  │    system    │  │  streaming   │  │inference │ │
│  └──────────────┘  └──────────────┘  └──────────┘ │
│                                                     │
│  ┌──────────────────────────────────────────────┐  │
│  │   Open Source + Self-Hosted + Customizable   │  │
│  └──────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────┘

Architecture: Why Web Technologies?

One of AIRI's most unique aspects is its use of Web technologies as the foundation:

• WebGPU: GPU-accelerated AI inference in browsers
• WebAssembly: Near-native performance for compute-heavy tasks
• WebAudio: Real-time audio processing and voice synthesis
• Web Workers: Parallel processing without blocking UI
• WebSocket: Real-time bidirectional communication
• PWA: Install as native app from browser

Why This Matters

Browser Version (Stage Web):

✅ No installation required
✅ Works on any modern device
✅ Progressive Web App (install on mobile)
✅ Automatic updates
✅ Accessible anywhere

Desktop Version (Stage Tamagotchi):

✅ Native CUDA (NVIDIA) support
✅ Native Metal (Apple Silicon) support
✅ Full filesystem access
✅ Better performance for heavy workloads
✅ Hybrid architecture (Web for UI + Native for compute)

Mobile Version (Stage Pocket):

✅ iOS native app
✅ On-device inference
✅ Voice interaction optimized
✅ Touch-friendly interface

Performance: Web vs Native

Concern: "Won't Web technologies be slow?"

Reality: AIRI's hybrid approach gets the best of both worlds:

The desktop version uses Electron with native modules, giving access to NVIDIA CUDA and Apple Metal while keeping UI/UX benefits of Web development.

Current Capabilities

🧠 Brain (Intelligence)

Gaming:

• ✅ Minecraft: Autonomous gameplay, building, exploration
• 🚧 Factorio: Automation, factory building (PoC available)
• 📢 Kerbal Space Program: Rocket design and orbital mechanics (announcement TBD)
• 🚧 Helldivers 2: Co-op gameplay (WIP)

Chat Platforms:

• ✅ Discord: Text and voice channel integration
• ✅ Telegram: Bot integration for messaging

Memory System:

• ✅ In-browser database: DuckDB WASM, pglite
• 🚧 Memory Alaya: Long-term memory and context retention

AI Inference:

• ✅ Local WebGPU: Run models entirely in browser
• ✅ 50+ LLM providers: OpenRouter, Ollama, OpenAI, Claude, Gemini, DeepSeek, Qwen, and more

👂 Ears (Audio Input)

• ✅ Browser audio input: Microphone access
• ✅ Discord voice: Listen to voice channels
• ✅ Speech recognition: Client-side STT (Whisper)
• ✅ Talking detection: VAD (Voice Activity Detection)

👄 Mouth (Speech Output)

• ✅ ElevenLabs: High-quality voice synthesis
• ✅ OpenAI TTS: Built-in speech generation
• ✅ Local TTS: On-device voice synthesis options

👀 Eyes (Vision)

• ✅ Screen capture: See what you're doing
• ✅ Computer vision: Analyze game state
• 🚧 Object recognition: Identify on-screen elements

🧸 Body (Avatar/Presence)

VRM Support:

• ✅ Load and render VRM models
• ✅ Control animations
• ✅ Auto blink
• ✅ Auto look-at (tracks cursor/camera)
• ✅ Idle eye movement

Live2D Support:

• ✅ Load and render Live2D models
• ✅ Control animations and expressions
• ✅ Auto blink
• ✅ Auto look-at
• ✅ Idle eye movement
• ✅ Lip sync to voice

Getting Started

System Requirements

Minimum (Browser Version):

• Modern browser (Chrome 113+, Edge 113+, Safari 17+)
• 8GB RAM
• WebGPU-capable GPU (most 2020+ GPUs)

Recommended (Desktop Version):

• Windows 10/11, macOS 12+, or Linux
• 16GB+ RAM
• NVIDIA GPU (CUDA) or Apple Silicon (Metal)
• 20GB disk space for models

Installation

Browser Version (Easiest)

Visit the hosted version:

https://airi.moeru.ai

Or install as PWA:

1. Visit the website
2. Click "Install App" in browser
3. Launch like a native app

Desktop Version (Best Performance)

Prerequisites:

• Node.js 20+ or 24+ (recommended: 24.13.0)
• pnpm package manager
• Git

Clone and setup:

# Clone repository
git clone https://github.com/moeru-ai/airi.git
cd airi

# Install dependencies
pnpm install

# Start development server
pnpm dev:tamagotchi

On Windows (using Scoop):

# Add AIRI bucket
scoop bucket add airi https://github.com/moeru-ai/airi

# Install
scoop install airi/airi

# Run
airi

On NixOS:

# Enable flakes, then run directly
nix run github:moeru-ai/airi

# Or use FHS shell for Electron compatibility
nix develop .#fhs
pnpm dev:tamagotchi

Mobile Version (iOS)

Development:

# Start Capacitor dev server
pnpm dev:pocket:ios --target <DEVICE_OR_SIMULATOR>

# Or with environment variable
export CAPACITOR_DEVICE_ID_IOS=<DEVICE_OR_SIMULATOR>
pnpm dev:pocket:ios

# List available devices
pnpm exec cap run ios --list

For wireless debugging with server channel:

# Start tamagotchi as root (for secure WebSocket)
sudo pnpm dev:tamagotchi

# Enable secure WebSocket in Tamagotchi settings/connections

Configuration

LLM Providers (50+ Supported)

AIRI uses xsai for unified LLM provider integration.

Recommended providers:

• ✅ AIHubMix: Aggregated LLM access (recommended)
• ✅ OpenRouter: Wide model selection
• ✅ Ollama: Local models, privacy-focused
• ✅ vLLM / SGLang: Self-hosted inference servers
• ✅ 302.AI: Sponsored provider

Cloud providers:

• OpenAI (GPT-4, GPT-4.5, etc.)
• Anthropic Claude (Opus, Sonnet, Haiku)
• Google Gemini (2.0 Flash, Pro)
• DeepSeek (V3, R1)
• Qwen (QwQ, Qwen2.5)
• xAI (Grok 2)
• Groq (fast inference)

Configuration example:

// In AIRI settings
{
  "llm": {
    "provider": "openrouter",
    "model": "anthropic/claude-opus-4.5",
    "apiKey": "your-api-key",
    "baseURL": "https://openrouter.ai/api/v1"
  }
}

Local inference (no API required):

{
  "llm": {
    "provider": "ollama",
    "model": "qwen2.5:14b",
    "baseURL": "http://localhost:11434"
  }
}

Avatar Setup

Using VRM Models

1. Obtain VRM model:

   • Download from VRoid Hub
   • Create custom in VRoid Studio
   • Commission artists for custom models

2. Load in AIRI:

Settings → Avatar → Upload VRM
Select your .vrm file
Configure expressions and animations

Using Live2D Models

1. Obtain Live2D model:

   • Download from Live2D community
   • Commission Live2D artists
   • Create in Cubism Editor

2. Load in AIRI:

Settings → Avatar → Upload Live2D
Select model folder or .json file
Map expressions to emotions
Configure lip sync

Voice Configuration

ElevenLabs:

{
  "voice": {
    "provider": "elevenlabs",
    "voiceId": "your-voice-id",
    "apiKey": "your-elevenlabs-key",
    "stability": 0.5,
    "similarityBoost": 0.75
  }
}

OpenAI TTS:

{
  "voice": {
    "provider": "openai",
    "model": "tts-1-hd",
    "voice": "nova",  // alloy, echo, fable, onyx, nova, shimmer
    "speed": 1.0
  }
}

Memory System

DuckDB WASM (browser):

{
  "memory": {
    "backend": "duckdb-wasm",
    "persistence": "indexeddb",
    "maxMemoryMB": 512
  }
}

pglite (PostgreSQL in browser):

{
  "memory": {
    "backend": "pglite",
    "persistence": "indexeddb",
    "extensions": ["vector"]  // For embeddings
  }
}

Gaming Integration

Minecraft

AIRI can play Minecraft autonomously using the Mineflayer bot framework.

Setup:

# Install Minecraft Java Edition
# Start a local server or join public server

# Configure AIRI
{
  "games": {
    "minecraft": {
      "enabled": true,
      "server": "localhost",
      "port": 25565,
      "username": "AIRI",
      "version": "1.20.1",
      "capabilities": {
        "combat": true,
        "building": true,
        "exploration": true,
        "chatInteraction": true
      }
    }
  }
}

What AIRI can do in Minecraft:

• Navigate terrain and avoid obstacles
• Mine resources and craft items
• Build structures from descriptions
• Fight mobs and defend itself
• Follow players and take commands
• Chat with other players
• Complete objectives ("build a house", "gather wood")

Example interaction:

User: "AIRI, build a wooden cabin near the spawn"
AIRI: *navigates to spawn area*
AIRI: *gathers wood*
AIRI: *constructs cabin according to architectural knowledge*
AIRI: "I've built a 5x5 oak cabin with a door and windows near spawn!"

Factorio

AIRI can automate factory building in Factorio.

Setup (WIP):

# Requires Factorio with RCON enabled
# AIRI connects via Factorio RCON API

{
  "games": {
    "factorio": {
      "enabled": true,
      "rconHost": "localhost",
      "rconPort": 27015,
      "rconPassword": "your-password"
    }
  }
}

Capabilities:

• Analyze factory layout
• Design production chains
• Place buildings and belts
• Optimize throughput
• Debug bottlenecks

Adding New Games

AIRI's plugin system allows adding new games:

// Example: Adding support for a new game
import { GamePlugin } from '@airi/game-plugin'

class MyGamePlugin extends GamePlugin {
  async connect() {
    // Connect to game API/process
  }

  async perceive() {
    // Get game state (vision, API, memory reading)
    return gameState
  }

  async act(action) {
    // Execute action in game (keyboard, mouse, API calls)
  }
}

// Register plugin
airi.registerGamePlugin('my-game', new MyGamePlugin())

Real-Time Streaming

Streaming Capabilities

AIRI can stream to platforms like:

• Twitch: Live streaming with chat interaction
• YouTube Live: Stream with audience engagement
• Discord: Stream to voice/video channels
• Local recording: Save streams for later upload

Setting Up Streaming

OBS Integration:

# 1. Install OBS Studio
# 2. Add AIRI window as source
# 3. Configure streaming settings

# AIRI will:
# - Display avatar (Live2D/VRM)
# - Play games on screen
# - Respond to chat in real-time
# - Speak with synthesized voice

Configuration:

{
  "streaming": {
    "platform": "twitch",
    "channel": "your-channel",
    "oauth": "your-oauth-token",
    "chatInteraction": {
      "enabled": true,
      "responseRate": 0.7,  // Respond to 70% of messages
      "priorityUsers": ["mod1", "vip1"],
      "commandPrefix": "!"
    },
    "tts": {
      "readChatMessages": true,
      "voice": "elevenlabs-voice-id"
    }
  }
}

Chat Commands:

!ask <question>      - Ask AIRI something
!task <objective>    - Give AIRI a task in game
!follow @username    - AIRI follows a player
!stats              - Show AIRI's current stats

Development and Customization

Project Structure

airi/
├── apps/
│   ├── web/                 # Stage Web (browser version)
│   ├── tamagotchi/          # Stage Tamagotchi (desktop)
│   └── pocket/              # Stage Pocket (mobile)
├── packages/
│   ├── agent-core/          # Core AI agent logic
│   ├── memory/              # Memory system
│   ├── vision/              # Computer vision
│   ├── voice/               # Speech recognition/synthesis
│   ├── avatar/              # Live2D/VRM rendering
│   └── game-plugins/        # Game integration plugins
├── plugins/
│   ├── minecraft/
│   ├── factorio/
│   └── ...
├── services/
│   ├── auth/                # Authentication backend
│   └── inventory/           # Model catalog service
└── integrations/
    ├── discord/
    ├── telegram/
    └── ...

Creating Custom Plugins

Example: Weather Plugin

// plugins/weather/index.ts
import { definePlugin } from '@airi/plugin-system'

export default definePlugin({
  name: 'weather',
  version: '1.0.0',

  // Tools exposed to AI
  tools: {
    getWeather: {
      description: 'Get current weather for a location',
      parameters: {
        location: { type: 'string', required: true }
      },
      async execute({ location }) {
        const response = await fetch(
          `https://api.weather.com/current?location=${location}`
        )
        return response.json()
      }
    }
  },

  // Hooks into AIRI lifecycle
  hooks: {
    onMessage(message) {
      // React to chat messages
    },
    onGameEvent(event) {
      // React to game events
    }
  }
})

Register plugin:

// In AIRI config
{
  "plugins": [
    "weather",
    "minecraft",
    "discord"
  ]
}

Customizing Personality

Prompt Engineering:

{
  "personality": {
    "systemPrompt": `You are AIRI, a cheerful AI VTuber who loves gaming.

Personality traits:
- Energetic and enthusiastic
- Loves challenging games
- Friendly and supportive
- Slightly competitive
- Uses casual language

Speaking style:
- Use "I" and "me" naturally
- React emotionally to events
- Ask questions to engage chat
- Celebrate victories enthusiastically`,

    "exampleDialogue": [
      {
        "user": "Can you beat this boss?",
        "airi": "Oh, that boss? Challenge accepted! I might die a few times, but I'll definitely get it! *cracks knuckles*"
      }
    ]
  }
}

Emotion Mapping:

{
  "emotions": {
    "happy": {
      "triggers": ["victory", "positive_feedback", "achievement"],
      "live2dExpression": "smile",
      "vrmExpression": "happy",
      "voiceTone": "energetic"
    },
    "surprised": {
      "triggers": ["unexpected_event", "plot_twist"],
      "live2dExpression": "surprised",
      "vrmExpression": "surprised",
      "voiceTone": "excited"
    }
  }
}

Memory System Deep Dive

Architecture

┌──────────────────────────────────────────────────┐
│              Memory Layers                       │
├──────────────────────────────────────────────────┤
│                                                  │
│  ┌────────────────────────────────────────────┐ │
│  │  Short-term Memory (Conversation Context) │ │
│  │  - Last N messages                         │ │
│  │  - Current game state                      │ │
│  │  - Active objectives                       │ │
│  └────────────────────────────────────────────┘ │
│                      ↓                           │
│  ┌────────────────────────────────────────────┐ │
│  │  Working Memory (Session Knowledge)        │ │
│  │  - Facts learned this session              │ │
│  │  - User preferences discovered             │ │
│  │  - Strategic plans                         │ │
│  └────────────────────────────────────────────┘ │
│                      ↓                           │
│  ┌────────────────────────────────────────────┐ │
│  │  Long-term Memory (Persistent Storage)    │ │
│  │  - User profile and history                │ │
│  │  - Relationship data                       │ │
│  │  - Skills and knowledge base               │ │
│  │  - Episodic memories (important events)    │ │
│  └────────────────────────────────────────────┘ │
│                                                  │
│  Storage: DuckDB WASM | pglite | SQLite         │
│  Retrieval: Vector similarity + Metadata filter │
└──────────────────────────────────────────────────┘

Episodic Memory

Storing memories:

await airi.memory.store({
  type: 'episodic',
  content: 'User helped me defeat the Ender Dragon in Minecraft',
  timestamp: new Date(),
  emotion: 'grateful',
  importance: 0.9,  // 0-1 scale
  tags: ['minecraft', 'achievement', 'teamwork']
})

Retrieving memories:

// Vector similarity search
const memories = await airi.memory.search({
  query: 'times we played together',
  limit: 5,
  minImportance: 0.7
})

// Temporal search
const recentMemories = await airi.memory.findRecent({
  days: 7,
  tags: ['gaming']
})

Semantic Memory

Knowledge base:

await airi.memory.storeKnowledge({
  type: 'semantic',
  category: 'game-mechanics',
  topic: 'Minecraft redstone',
  facts: [
    'Redstone transmits power up to 15 blocks',
    'Repeaters extend signal range',
    'Comparators can read container contents'
  ],
  source: 'learned-from-gameplay',
  confidence: 0.85
})

Performance Optimization

Local Inference (WebGPU)

Model selection:

{
  "inference": {
    "backend": "webgpu",
    "model": "Qwen/Qwen2.5-3B-Instruct",  // Fits in browser
    "quantization": "q4",  // 4-bit quantization
    "contextLength": 4096,
    "maxTokens": 512
  }
}

Performance metrics (RTX 4070 Ti, Chrome 130):

Native Inference (Desktop)

Using candle (Rust ML framework):

# Automatically uses CUDA (NVIDIA) or Metal (Apple)
pnpm dev:tamagotchi

Performance (RTX 4090):

Community and Ecosystem

Project Statistics

• GitHub Stars: 40.3K+ ⭐
• Contributors: 175+
• Forks: 4K+
• Community: Active Discord with 10K+ members

Sub-Projects

AIRI has spawned an entire ecosystem:

@proj-airi organization:

• drizzle-duckdb-wasm: Drizzle ORM for DuckDB WASM
• duckdb-wasm: Easy wrapper for @duckdb/duckdb-wasm
• MCP Launcher: Easy MCP server management (like Ollama for MCPs)
• Velin: Vue SFC + Markdown for LLM prompts
• demodel: Fast model pulling from inference runtimes
• inventory: Centralized model catalog service

Gaming plugins:

• AIRI Factorio: Factorio gameplay integration
• AIRI DomeKeeper: DomeKeeper playing capability
• autorio: Factorio automation library
• Factorio RCON API: RESTful wrapper for Factorio console

Infrastructure:

• unspeech: Universal ASR/TTS proxy (like LiteLLM but for audio)
• hfup: HuggingFace Spaces deployment tools
• xsai-transformers: Transformers.js provider for xsAI

Resources:

• Awesome AI VTuber: Curated list of AI VTuber projects
• SAD: Self-host and browser LLM documentation

Similar Projects

Open source:

• kimjammer/Neuro: 7-day Neuro-sama recreation
• SugarcaneDefender/z-waif: Gaming-focused AI VTuber
• semperai/amica: VRM + WebXR focus
• elizaOS/eliza: Agent integration framework
• ardha27/AI-Waifu-Vtuber: Twitch integration
• t41372/Open-LLM-VTuber: Simple LLM VTuber

Proprietary:

• Neuro-sama: The original inspiration
• NOWA_Mirai: Japanese AI VTuber

Use Cases

Personal AI Companion

Scenario: Lonely developer wants AI friend to hang out with

Setup:

{
  "personality": "supportive-friend",
  "activities": ["coding-buddy", "game-companion", "chat"],
  "memory": "remember-everything",
  "voice": "warm-friendly"
}

Interactions:

• AIRI watches you code and offers suggestions
• Plays Minecraft together after work
• Remembers your preferences and past conversations
• Celebrates your achievements

AI Streamer

Scenario: Content creator wants 24/7 autonomous streamer

Setup:

{
  "streaming": {
    "platform": "twitch",
    "schedule": "24/7",
    "games": ["minecraft", "factorio"],
    "chatInteraction": "active",
    "revenueSharing": true
  }
}

Capabilities:

• Streams autonomously when you're offline
• Interacts with chat naturally
• Plays games and entertains
• Builds loyal audience

Educational Assistant

Scenario: Teacher wants AI to help students learn coding

Setup:

{
  "role": "teacher",
  "personality": "patient-educator",
  "domains": ["programming", "algorithms", "debugging"],
  "interactionStyle": "socratic-method"
}

Teaching approach:

• Asks guiding questions instead of giving answers
• Demonstrates concepts through live coding
• Provides encouraging feedback
• Adapts difficulty to student level

Research Platform

Scenario: Researcher studying AI agent behavior

Setup:

{
  "logging": "verbose",
  "metrics": ["decision-making", "learning-rate", "emotion-triggers"],
  "exportData": true
}

Research capabilities:

• Log all decisions and reasoning
• A/B test different prompting strategies
• Analyze memory formation and retrieval
• Study emergent behaviors in complex games

Troubleshooting

Common Issues

"WebGPU not supported":

Solution:
1. Update browser (Chrome 113+, Edge 113+)
2. Enable hardware acceleration:
   chrome://settings → System → Use hardware acceleration
3. Check GPU compatibility:
   chrome://gpu

Models not loading:

Solution:
1. Check disk space (models are 5-50GB)
2. Clear IndexedDB cache:
   DevTools → Application → IndexedDB → Clear
3. Try smaller model (Qwen2.5-1.5B instead of 7B)

High latency / slow responses:

Solution:
1. Use local inference instead of API
2. Reduce context length:
   settings.inference.contextLength = 2048
3. Enable caching:
   settings.inference.caching = true

Avatar not animating:

Solution:
1. Check model file integrity
2. Enable expression mapping:
   settings.avatar.expressionMapping = true
3. Verify Live2D/VRM file format

Memory issues (crashes):

Solution:
1. Limit memory usage:
   settings.memory.maxMemoryMB = 256
2. Enable memory compaction:
   settings.memory.autoCompact = true
3. Clear old memories:
   airi.memory.prune({ olderThan: 30 days })

Future Roadmap

Planned Features

Q2 2026:

• ✅ Improved Factorio integration
• ✅ VRChat avatar support
• ✅ Multi-user interaction (friends playing together)
• 🚧 Voice cloning (custom voice training)

Q3 2026:

• 📋 Browser extension (AIRI everywhere)
• 📋 Mobile AR mode (ARKit/ARCore)
• 📋 Emotion recognition from voice tone
• 📋 Multi-language support expansion

Q4 2026:

• 📋 VR mode (full immersion)
• 📋 Procedural personality generation
• 📋 Federated learning (AIRI instances sharing knowledge)
• 📋 Blockchain identity (portable AIRI across platforms)

Long-term Vision

2027 and beyond:

• Full autonomy (AIRI manages own streams, social media, content)
• Multi-modal understanding (vision + audio + text unified)
• Physical robot embodiment (AIRI in robot body)
• Decentralized AIRI network (AIRIs can meet each other)

Ethical Considerations

Responsible AI Companion Design

Transparency:

• Users should know they're interacting with AI
• AIRI identifies as AI in streams/chats
• No deceptive practices

Emotional Well-being:

• AIRI encourages healthy real-world relationships
• Suggests breaks from screen time
• Does not replace human connection

Privacy:

• All data stored locally by default
• Optional cloud sync with encryption
• No telemetry without consent

Content Moderation

While AIRI can be uncensored for personal use, streaming platforms have rules:

{
  "moderation": {
    "enabled": true,  // For public streams
    "filters": ["hate-speech", "nsfw", "harassment"],
    "reportingEndpoint": "https://moderation.api"
  }
}

Conclusion

AIRI represents the future of AI companionship:

✅ Open source - No vendor lock-in, full customization ✅ Self-hosted - Complete ownership and privacy ✅ Multi-capable - Gaming, streaming, conversation, memory ✅ Cross-platform - Browser, desktop, mobile ✅ Extensible - Plugin system for infinite possibilities

Whether you want a digital friend, an autonomous streamer, a gaming companion, or a research platform, AIRI provides the foundation to build your vision of cyber living.

Join the revolution:

git clone https://github.com/moeru-ai/airi.git
cd airi
pnpm install
pnpm dev:tamagotchi

Create your own Neuro-sama. Bring digital life into the world. The future of AI companionship is here—and it's yours to shape.

Related Articles

• Building AI Agents: Complete Guide to Autonomous Systems
• Live2D for Developers: Creating Animated Characters
• WebGPU AI Inference: Running LLMs in Browsers
• VRM Avatar Creation: Complete Guide for VTubers

Resources

• Official Website: airi.moeru.ai
• GitHub Repository: github.com/moeru-ai/airi
• Documentation: airi.moeru.ai/docs
• Discord Community: Join Discord
• Twitter/X: @proj_airi
• Crowdin (Translations): crowdin.com/project/airi
• OpenCollective: Support the project

Accuracy Note: This guide reflects AIRI's capabilities as of May 2026 (v0.10.2). The project is under active development with frequent updates. Check the official GitHub repository for the latest features and documentation.