Claudia is a powerful desktop GUI application for Claude Code, built by Asterisk. It transforms the command-line Claude Code experience into a beautiful, intuitive visual interface with advanced features like custom agents, session management, usage analytics, and more.

Claudia serves as your command center for Claude Code, providing:

• 🗂️ Visual Project Management - Browse Claude Code projects with a GUI
• 🤖 Custom AI Agents - Create specialized agents with custom prompts
• 📊 Usage Analytics - Track API costs and token usage
• ⏰ Session Timeline - Create checkpoints and navigate session history
• 🔌 MCP Server Management - Manage Model Context Protocol servers
• 📝 CLAUDE.md Editor - Built-in markdown editor with live preview

• OS: Windows 10 version 2004+ or Windows 11
• RAM: 4GB (8GB recommended)
• Storage: 1GB free space
• Prerequisites: Claude Code CLI installed and working

• Rust (1.70.0 or later)
• Bun (latest version)
• Git
• Visual Studio Build Tools (C++ support)
• WebView2 (usually pre-installed on Windows 11)

First, ensure Claude Code is installed and working. Follow the Claude Code Windows Installation Guide.

# Verify Claude Code is installed
claude --version

# Install Rust via rustup
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
 
# Or on Windows, download from: https://rustup.rs/
# After installation, restart terminal and verify:
rustc --version
cargo --version

# Install Bun
curl -fsSL https://bun.sh/install | bash
 
# Or on Windows via PowerShell:
powershell -c "irm bun.sh/install.ps1 | iex"
 
# Verify installation
bun --version

Download and install Visual Studio Build Tools with C++ support:

• Go to https://visualstudio.microsoft.com/downloads/
• Download “Build Tools for Visual Studio”
• Install with “C++ build tools” workload

Download from https://git-scm.com/ or use winget:

winget install Git.Git

git clone https://github.com/getAsterisk/claudia.git
cd claudia

# Install frontend dependencies
bun install

# For development (with hot reload)
bun run tauri dev
 
# For production build
bun run tauri build

Problem: `error RC2175 : resource file icon.ico is not in 3.00 format`

Solution: Convert PNG to proper ICO format using ImageMagick:

# Install ImageMagick
winget install ImageMagick.ImageMagick
 
# Convert PNG to ICO
magick "src-tauri/icons/128x128.png" "src-tauri/icons/icon.ico"

Problem: `Couldn't find a .ico icon` during bundling

Solution: Add icon path to `src-tauri/tauri.conf.json`:

{
  "bundle": {
    "icon": [
      "icons/32x32.png",
      "icons/128x128.png",
      "icons/128x128@2x.png",
      "icons/icon.icns",
      "icons/icon.png",
      "icons/icon.ico"
    ]
  }
}

Alternative: Build without bundling:

# Build executable only (no installer)
bun run tauri build --no-bundle
 
# Or modify package.json
{
  "scripts": {
    "tauri": "tauri build --no-bundle"
  }
}

Problem: `MSVC not found` error during build

Solution:

1. Install Visual Studio Build Tools with C++ support
2. Restart terminal after installation
3. Verify with: `cl.exe` (should be found in PATH)

Problem: Build fails with memory errors

Solution:

# Build with fewer parallel jobs
cargo build -j 2
 
# Or set environment variable
set CARGO_BUILD_JOBS=2
bun run tauri build

Problem: WebView2 runtime not found

Solution:

1. Download from: https://developer.microsoft.com/en-us/microsoft-edge/webview2/
2. Install “Evergreen Standalone Installer”
3. Restart system

# Fast compilation, larger binary, debug symbols
bun run tauri dev

# Optimized build with installer
bun run tauri build
 
# Build without installer (executable only)
bun run tauri build --no-bundle
 
# Debug build (faster compilation)
bun run tauri build --debug

After successful build, find files in:

src-tauri/target/release/
├── claudia.exe              # Main executable
└── bundle/                  # Installers (if bundling enabled)
    ├── msi/                 # MSI installer
    └── nsis/                # NSIS installer

# Run the built executable
cd src-tauri/target/release
./claudia.exe
 
# Or from project root during development
bun run tauri dev

1. Welcome Screen: Choose between CC Agents or CC Projects 2. Auto-Detection: Claudia automatically finds your `~/.claude` directory 3. Project Import: Existing Claude Code projects are imported automatically

CC Projects → Select Project → View Sessions → Resume or Start New

• Browse all Claude Code projects visually
• View session history with timestamps
• Resume previous sessions or start new ones
• Search projects and sessions quickly

CC Agents → Create Agent → Configure → Execute

1. Design Agent: Set name, icon, and system prompt 2. Configure Model: Choose Claude model (Sonnet, Opus, etc.) 3. Set Permissions: Configure file access and network permissions 4. Execute Tasks: Run agent on any project

Menu → Usage Dashboard → View Analytics

• Monitor API costs by model and project
• Track token usage over time
• Export data for accounting
• Visual charts and trends

Menu → MCP Manager → Add Server → Configure

• Add Model Context Protocol servers
• Import from Claude Desktop configuration
• Test server connections
• Manage server permissions

# Navigate to Claudia directory
cd claudia
 
# Pull latest changes
git pull origin main
 
# Update dependencies
bun install
 
# Rebuild application
bun run tauri build

#!/bin/bash
# Save as update-claudia.bat
 
echo "🔄 Updating Claudia..."
 
cd claudia
git pull origin main
 
echo "📦 Installing dependencies..."
bun install
 
echo "🔨 Building application..."
bun run tauri build --no-bundle
 
echo "✅ Update complete!"
echo "📍 Executable location: src-tauri/target/release/claudia.exe"

Create `.cargo/config.toml` in project root:

[build]
jobs = 2                    # Limit parallel jobs
target-dir = "target"       # Custom target directory
 
[target.x86_64-pc-windows-msvc]
rustflags = ["-C", "target-cpu=native"]  # Optimize for your CPU

# Set before building
set RUST_LOG=debug                    # Enable debug logging
set TAURI_DEBUG=true                  # Enable Tauri debug mode
set CARGO_BUILD_JOBS=2                # Limit build parallelism
set RUSTFLAGS="-C target-cpu=native"  # CPU optimization

Edit `src-tauri/tauri.conf.json` for custom settings:

{
  "build": {
    "beforeBuildCommand": "bun run build",
    "beforeDevCommand": "bun run dev",
    "devPath": "http://localhost:5173",
    "distDir": "../dist"
  },
  "bundle": {
    "active": false,  // Disable bundling for faster builds
    "targets": ["nsis"],  // Use NSIS instead of WiX
    "windows": {
      "certificateThumbprint": null,
      "digestAlgorithm": "sha256",
      "timestampUrl": ""
    }
  }
}

Slow Build Times:

# Use fewer CPU cores
set CARGO_BUILD_JOBS=2
 
# Use faster linker (install first)
cargo install -f cargo-binutils
rustup component add llvm-tools-preview

High Memory Usage:

# Increase virtual memory
# Control Panel → System → Advanced → Performance Settings → Virtual Memory
# Set to 8GB+ if you have sufficient disk space

Application Won't Start:

1. Verify WebView2 is installed
2. Check Windows Defender/antivirus exclusions
3. Run as Administrator (temporarily)
4. Check Windows Event Viewer for errors

Claude Code Not Found:

# Verify Claude Code installation
claude --version
 
# Check PATH
echo $PATH | grep -i claude
 
# Reinstall if necessary
npm install -g @anthropic-ai/claude-code

# Clone and setup development environment
git clone https://github.com/getAsterisk/claudia.git
cd claudia
 
# Install dependencies
bun install
 
# Start development server
bun run tauri dev
 
# Run tests
cd src-tauri && cargo test
 
# Format code
cd src-tauri && cargo fmt

claudia/
├── src/                   # React frontend
│   ├── components/        # UI components
│   ├── lib/               # API client & utilities
│   └── assets/            # Static assets
├── src-tauri/             # Rust backend
│   ├── src/
│   │   ├── commands/      # Tauri command handlers
│   │   ├── checkpoint/    # Timeline management
│   │   └── process/       # Process management
│   └── tests/             # Rust test suite
└── public/                # Public assets

Claudia prioritizes security:

• Process Isolation: Agents run in separate processes
• Permission Control: Granular file and network access
• Local Storage: All data stays on your machine
• No Telemetry: No data collection or tracking
• Open Source: Full code transparency

• Official Claudia Repository
• Claudia Website
• Claude Code Documentation
• Tauri Framework
• Bun Package Manager
• Rust Programming Language

A: Yes, Claudia is a GUI wrapper for Claude Code CLI. Install Claude Code first.

A: Pre-built releases will be available soon. Currently, building from source is required.

A: Rust compilation is thorough but slow. Use `–debug` flag for faster development builds.

A: Yes, Claudia is open source (AGPL-3.0 license). You still need Claude API access.

A: Absolutely! Check the GitHub repository for contribution guidelines.