Zero-config developer tools. One click to install. One click to run.

⚠️ Warning Most Code generated By AI.

Main Dashboard	Running Tool	Tool Settings	Dark Mode

• ForgeDesk icon: static/forgedesk-icon.svg (vector, dark steel desk with forge spark)

• 🚀 Zero Configuration - No YAML, no JSON, no .env to edit
• 🖱️ One Click Operations - Install, start, stop, remove - all one click
• ✨ Sensible Defaults - Everything works out of the box
• ⚙️ In-App Settings - Change ports, passwords via GUI (no config files!)
• 🌙 Dark/Light Theme - Toggle between themes
• 🐳 Docker Powered - All tools run in isolated containers

┌─────────────────────────────────────────────────────────────┐
│  🛠️ ForgeDesk                              [⚙️] [🌙]        │
├─────────────────────────────────────────────────────────────┤
│  [All] [📧 Email] [🔍 Search] [🗄️ Database] [📦 Storage]    │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐   │
│  │ 📧 Mailpit    │  │ 🗄️ MySQL      │  │ 🚀 Redis      │   │
│  │ ● Running     │  │ ○ Stopped     │  │ ● Running     │   │
│  │ Port: 8025    │  │ Port: 3306    │  │ Port: 6379    │   │
│  │ [Open] [Stop] │  │ [Start]       │  │ [Open] [Stop] │   │
│  └───────────────┘  └───────────────┘  └───────────────┘   │
│                                                             │
│  ┌───────────────┐  ┌───────────────┐                      │
│  │ 🐘 PostgreSQL │  │ 🦀 RustFS     │                      │
│  │ ○ Not Installed│ │ ○ Not Installed│                     │
│  │ Port: 5432    │  │ Port: 9000    │                      │
│  │ [Install]     │  │ [Install]     │                      │
│  └───────────────┘  └───────────────┘                      │
│                                                             │
├─────────────────────────────────────────────────────────────┤
│  🐳 Docker: Connected  │  2 running  │  v0.1.0             │
└─────────────────────────────────────────────────────────────┘

1. Install Docker Desktop - Download here
2. Download ForgeDesk - Get the latest release for your platform
3. Launch the app - Tools are ready to install with one click!

Once tools are running, use these connection strings in your applications:

# Mailpit SMTP
smtp://localhost:1025

# MailHog SMTP
smtp://localhost:1026

# Redis
redis://localhost:6379

# MySQL
mysql://root:root@localhost:3306/dev

# PostgreSQL
postgresql://postgres:postgres@localhost:5432/dev

# MongoDB
mongodb://localhost:27017

# RabbitMQ
amqp://guest:guest@localhost:5672

# Meilisearch
http://localhost:7700 (Master Key: masterKey)

# Elasticsearch
http://localhost:9200

# RustFS S3
http://rustfsadmin:rustfsadmin@localhost:9000

# MinIO S3
http://minioadmin:minioadmin@localhost:9000

# Kafka
localhost:9092

# LocalStack (AWS Services)
AWS_ENDPOINT_URL=http://localhost:4566
AWS_ACCESS_KEY_ID=test
AWS_SECRET_ACCESS_KEY=test

# Keycloak
http://localhost:8180 (admin / admin)

# Prometheus
http://localhost:9090

# Grafana
http://localhost:3000 (admin / admin)

If you plan to run RustFS and MinIO at the same time, change one of the host ports in Settings to avoid a 9000 clash.

• Docker mode (container ↔ container): Put your app and MySQL on the same Docker network and use the MySQL container name as host (e.g., mysql:3306). Attach with docker network connect devtools <your_app_container> or share the network in compose:

  networks:
    devtools:
      external: true
  services:
    app:
      networks: [devtools]

• Host mode (container ↔ host): Use host.docker.internal:3306 or your host IP when MySQL runs on the host. Ensure MySQL binds to 0.0.0.0 and your firewall allows the port.

• Proxy/tunnel (optional): Only needed when networks cannot be shared. Use HAProxy/SSH/WireGuard to bridge isolated networks; otherwise skip the proxy.

• Docker Desktop must be installed and running
• Rust (for development)
• Node.js (for development)

# Install dependencies
npm install

# Run in development mode
npm run tauri dev

# Run backend tests
cd src-tauri && cargo test

# Build for production
npm run tauri build

The project includes comprehensive tests for the Rust backend:

# Run all tests
cd src-tauri && cargo test

# Run tests with output
cd src-tauri && cargo test -- --nocapture

# Run specific test module
cd src-tauri && cargo test tools::tests
cd src-tauri && cargo test database_tests

• Tool Definitions: Tests for all 6 tools (Mailpit, MySQL, Redis, PostgreSQL, MinIO, RustFS)
• Tool Registry: Tests for tool lookup and listing
• Database Operations: Tests for installation tracking, port configuration, auto-start settings
• Serialization: Tests for JSON serialization/deserialization of all data types

• GUI Framework: Tauri 2.x + Svelte 5
• Backend: Rust with Bollard (Docker API)
• Styling: TailwindCSS v4
• Config Storage: SQLite

developer-tools/
├── src/                      # Svelte frontend
│   ├── routes/               # SvelteKit routes
│   └── lib/
│       ├── components/       # Svelte components
│       ├── stores/           # State management
│       └── types/            # TypeScript types
│
├── src-tauri/                # Rust backend
│   └── src/
│       ├── lib.rs            # Tauri commands
│       ├── docker.rs         # Docker integration
│       ├── database.rs       # SQLite storage
│       ├── error.rs          # Error types
│       └── tools/            # Tool definitions
│           ├── mod.rs        # Tool registry
│           ├── mailpit.rs    # Mailpit tool
│           ├── mysql.rs      # MySQL tool
│           ├── postgres.rs   # PostgreSQL tool
│           ├── redis.rs      # Redis tool
│           ├── minio.rs      # MinIO tool
│           └── tests.rs      # Tool tests
│
└── docs/
    └── screenshots/          # App screenshots

Screenshots can be captured in two ways:

1. Run the app: npm run tauri dev
2. Use your OS screenshot tool:
   • macOS: Cmd + Shift + 4 then select window
   • Windows: Win + Shift + S
   • Linux: gnome-screenshot -w or scrot
3. Save to docs/screenshots/ with these names:
   • main-dashboard.png - Main app window
   • installing-tool.png - During installation
   • running-tool.png - Tool with connection info
   • tool-settings.png - Settings modal
   • dark-mode.png - Dark theme

# Run the screenshot helper (interactive prompts)
./scripts/screenshots.sh

# Or show manual instructions only
./scripts/screenshots.sh manual

The script will guide you through capturing each required screenshot.

Note: tauri-driver only works on Linux. On macOS/Windows, the script uses native screenshot tools with interactive prompts.

Recommended dimensions: 1200x800 pixels

1. Tool Definitions: Each tool is defined in Rust with its Docker image, ports, and configuration
2. Docker Management: The app communicates with Docker via the Bollard library
3. State Storage: Tool installation status and settings are stored in SQLite
4. Real-time Updates: The frontend polls for status changes and receives progress events

┌─────────────────┐     IPC      ┌─────────────────┐
│  Svelte Frontend │ ◄──────────► │  Rust Backend   │
└─────────────────┘              └─────────────────┘
                                         │
                                         ▼
                        ┌────────────────────────────┐
                        │         Docker API         │
                        │  (via Bollard library)     │
                        └────────────────────────────┘
                                         │
                                         ▼
                        ┌────────────────────────────┐
                        │    Docker Containers       │
                        │  (MySQL, Redis, etc.)      │
                        └────────────────────────────┘

• Ensure Docker Desktop is installed and running
• On macOS, grant Docker access in System Preferences > Security & Privacy

• Use the Settings dialog to change the port
• Or stop the service using the conflicting port

• Check Docker Desktop for container logs
• Ensure you have enough disk space for Docker images

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Run tests: cd src-tauri && cargo test
5. Submit a pull request

Want to add a new tool like MongoDB, RabbitMQ, or Meilisearch? Follow these steps:

Create a new file src-tauri/src/tools/mongodb.rs:

use super::{Tool, ToolCategory, ToolPort, ToolEnvVar};

pub fn definition() -> Tool {
    Tool {
        id: "mongodb".to_string(),
        name: "MongoDB".to_string(),
        description: "Document database for modern applications".to_string(),
        category: ToolCategory::Database,
        icon: "🍃".to_string(),
        image: "mongo:7".to_string(),
        
        // Define ports
        ports: vec![
            ToolPort {
                name: "MongoDB".to_string(),
                host_port: 27017,
                container_port: 27017,
                protocol: "tcp".to_string(),
            },
        ],
        
        // Environment variables (optional)
        env_vars: vec![
            // Add if authentication is needed:
            // ToolEnvVar {
            //     name: "MONGO_INITDB_ROOT_USERNAME".to_string(),
            //     value: "root".to_string(),
            // },
            // ToolEnvVar {
            //     name: "MONGO_INITDB_ROOT_PASSWORD".to_string(),
            //     value: "root".to_string(),
            // },
        ],
        
        // Volume for data persistence
        volumes: vec![
            ("mongodb-data".to_string(), "/data/db".to_string()),
        ],
        
        // Custom command (optional, use None for default)
        command: None,
        
        // Web UI URL (None if no web interface)
        web_url: None,
        
        // Connection string template
        connection_string: Some("mongodb://localhost:27017".to_string()),
        
        // Default credentials (for display in UI)
        default_credentials: None, // or Some(("username", "password"))
    }
}

Edit src-tauri/src/tools/mod.rs:

// Add the module
mod mongodb;

// In the get_all_tools() function, add:
pub fn get_all_tools() -> Vec<Tool> {
    vec![
        mailpit::definition(),
        mysql::definition(),
        postgres::definition(),
        redis::definition(),
        minio::definition(),
        mongodb::definition(),  // Add this line
    ]
}

Add to src-tauri/src/tools/tests.rs:

#[test]
fn test_mongodb_definition() {
    let tool = super::mongodb::definition();
    assert_eq!(tool.id, "mongodb");
    assert_eq!(tool.category, ToolCategory::Database);
    assert!(!tool.ports.is_empty());
}

# Run tests
cd src-tauri && cargo test

# Run the app to see your new tool
npm run tauri dev

Here are some popular tools you might want to add:

// RabbitMQ (Message Queue)
Tool {
    id: "rabbitmq",
    image: "rabbitmq:3-management",
    ports: [(5672, "AMQP"), (15672, "Web UI")],
    web_url: Some("http://localhost:15672"),
    default_credentials: Some(("guest", "guest")),
}

// Meilisearch (Search Engine)
Tool {
    id: "meilisearch",
    image: "getmeili/meilisearch:latest",
    ports: [(7700, "HTTP API")],
    web_url: Some("http://localhost:7700"),
    env_vars: [("MEILI_ENV", "development")],
}

// Elasticsearch
Tool {
    id: "elasticsearch",
    image: "elasticsearch:8.11.0",
    ports: [(9200, "HTTP"), (9300, "Transport")],
    env_vars: [
        ("discovery.type", "single-node"),
        ("xpack.security.enabled", "false"),
    ],
}

// Adminer (Database Web UI)
Tool {
    id: "adminer",
    image: "adminer:latest",
    ports: [(8080, "Web UI")],
    web_url: Some("http://localhost:8080"),
}

MIT