Skip to content
Klutch.sh Docs

Deploying Mumble

Introduction

Mumble is a free, open-source, low-latency, high-quality voice chat application designed primarily for gamers but suitable for any voice communication needs. Unlike proprietary alternatives, Mumble gives you complete control over your voice communication infrastructure with enterprise-grade encryption and exceptional audio quality.

Built with a client-server architecture, Mumble (Murmur is the server component) supports advanced features like positional audio for gaming, extensive access control lists for managing channels and users, and real-time audio processing for crystal-clear voice transmission even on limited bandwidth connections.

Key highlights of Mumble:

  • Ultra-Low Latency: Optimized for real-time voice communication with minimal delay, essential for gaming and live collaboration
  • High Audio Quality: Supports Opus codec with configurable bitrates up to 96 kbps per user
  • Strong Encryption: All communication is encrypted using TLS with AES-256
  • Positional Audio: 3D audio positioning for immersive gaming experiences
  • Access Control Lists: Granular permissions system for channels, groups, and individual users
  • Cross-Platform: Native clients available for Windows, macOS, Linux, iOS, and Android
  • Lightweight: Minimal server resource requirements compared to web-based alternatives
  • Self-Hosted: Complete privacy and control over your voice data

This guide walks through deploying Mumble server (Murmur) on Klutch.sh using Docker.

Why Deploy Mumble on Klutch.sh

Deploying Mumble on Klutch.sh provides several advantages for your voice communication needs:

Always-On Voice Server: Your Mumble server runs 24/7 without managing home servers or dealing with dynamic IP addresses. Friends and team members can connect anytime.

Simplified Deployment: Klutch.sh handles container orchestration, networking, and infrastructure management. Push your configuration to GitHub and deploy automatically.

Persistent Configuration: Store your server database, certificates, and configuration in persistent volumes that survive container restarts.

Secure Access: Klutch.sh provides automatic SSL certificates for the web admin interface while Mumble’s native protocol handles voice encryption separately.

Scalable Resources: Allocate CPU and memory based on expected concurrent users. Start small and scale as your community grows.

Geographic Flexibility: Deploy closer to your user base to minimize latency for the best voice quality.

Prerequisites

Before deploying Mumble on Klutch.sh, ensure you have:

  • A Klutch.sh account
  • A GitHub account with a repository for your Mumble configuration
  • A Mumble client installed on your device for testing
  • Basic familiarity with Docker and containerization concepts

Understanding Mumble Architecture

Mumble uses a client-server architecture with clear separation of concerns:

Murmur Server: The server component handles all voice routing, user authentication, channel management, and access control. It’s lightweight and can handle hundreds of concurrent users on modest hardware.

Voice Protocol: Mumble uses UDP for voice transmission with automatic fallback to TCP tunneling when UDP is blocked. The voice protocol operates on port 64738 by default.

Control Protocol: Administrative connections and text chat use TCP on the same port (64738).

SQLite Database: User registrations, channel configurations, and access control lists are stored in a SQLite database.

Certificate Authentication: Users can register with the server using client certificates for passwordless authentication.

Preparing Your Repository

Create a GitHub repository containing your Mumble server configuration.

Repository Structure

mumble-deploy/
├── Dockerfile
├── murmur.ini
└── .dockerignore

Creating the Dockerfile

FROM mumblevoip/mumble-server:latest


# Copy custom configuration
COPY murmur.ini /etc/murmur.ini


# Expose Mumble port (voice and control)
EXPOSE 64738/tcp
EXPOSE 64738/udp


# Data volume for persistence
VOLUME ["/data"]

Creating the Configuration File

Create a murmur.ini file:

; Mumble Server Configuration


; Database location
database=/data/murmur.sqlite


; Log to console for container logging
logfile=


; Welcome message shown to connecting users
welcometext="<br />Welcome to our Mumble server.<br />Please be respectful and have fun!<br />"


; Server port
port=64738


; Server password (leave blank for open server)
serverpassword=


; Maximum users (0 = unlimited based on bandwidth)
users=100


; Maximum bandwidth per user in bits/second
bandwidth=72000


; Allow HTML in messages
allowhtml=true


; Text message length limit
textmessagelength=5000


; Register name shown in server browser
registerName=My Mumble Server


; SSL Certificate and Key (auto-generated if not specified)
; sslCert=/data/cert.pem
; sslKey=/data/key.pem


; Ice interface disabled for security
ice=


; Disable bonjour/zeroconf
bonjour=false

Creating the .dockerignore File

.git
.github
*.md
LICENSE
.gitignore
.DS_Store

Deploying Mumble on Klutch.sh

    Push Your Repository to GitHub

    Initialize your repository and push to GitHub with your Dockerfile and configuration files.

    Create a New Project on Klutch.sh

    Navigate to the Klutch.sh dashboard and create a new project named “mumble” or “voice-server”.

    Create a New App

    Within your project, create a new app and connect your GitHub repository containing the Mumble configuration.

    Configure TCP Traffic

    Mumble uses TCP port 64738 for its primary protocol:

    • Select TCP as the traffic type
    • Set the internal port to 64738

    Note: Voice traffic ideally uses UDP, but TCP tunneling provides acceptable quality for most use cases.

    Set Environment Variables

    Configure optional environment variables:

    VariableValue
    MUMBLE_SUPERUSER_PASSWORDStrong password for the SuperUser admin account

    Attach Persistent Volumes

    Add persistent storage for server data:

    Mount PathRecommended SizePurpose
    /data1 GBDatabase, certificates, and server configuration

    Deploy Your Application

    Click Deploy to start the build process. Klutch.sh will build and start your Mumble server.

    Connect with Mumble Client

    Once deployed, connect using your Mumble client:

    • Server: your-app-name.klutch.sh
    • Port: The assigned TCP port from your Klutch.sh dashboard
    • Username: Your desired display name

Initial Configuration

Setting Up SuperUser

After first deployment, set the SuperUser password:

  1. Check deployment logs for any auto-generated password
  2. Connect to the server with any username
  3. Use the SuperUser account to configure channels and permissions

Creating Channels

Using a client connected as SuperUser:

  1. Right-click on the root channel
  2. Select “Add” to create new channels
  3. Configure channel properties like description and position
  4. Set up nested channels for organization

Configuring Access Control

Mumble’s ACL system provides granular control:

  1. Right-click a channel and select “Edit”
  2. Navigate to the ACL tab
  3. Add groups and permissions as needed
  4. Common permissions include Speak, Mute, Deafen, Move, and Enter

User Registration

Certificate-Based Registration

Mumble supports passwordless authentication via certificates:

  1. Users generate a certificate in their client
  2. They connect and register with the server
  3. Future connections authenticate automatically

Password Registration

For simpler setups:

  1. Enable password registration in configuration
  2. Users register through the client interface
  3. Credentials are stored in the server database

Production Best Practices

Security Recommendations

  • Set a strong SuperUser password immediately after deployment
  • Use server passwords for private servers
  • Configure ACLs to limit who can create channels or modify settings
  • Regularly backup your database volume

Audio Quality Optimization

  • Set appropriate bandwidth limits based on your user count
  • Configure Opus codec settings for optimal quality
  • Monitor server resources during peak usage

Scaling Considerations

  • Each connected user consumes approximately 60-100 kbps bandwidth
  • CPU usage scales with concurrent speakers
  • Plan persistent storage for user growth

Troubleshooting

Cannot Connect to Server

  • Verify the deployment is running in Klutch.sh dashboard
  • Confirm you’re using the correct port from your deployment
  • Check if your client supports TCP tunneling (required for Klutch.sh)

Audio Quality Issues

  • Check user bandwidth settings in client
  • Verify server bandwidth limits in configuration
  • Ensure users have stable network connections

Permission Denied Errors

  • Verify your user is registered
  • Check channel ACLs for proper permissions
  • Connect as SuperUser to modify access controls

Additional Resources

Conclusion

Deploying Mumble on Klutch.sh gives you a professional-grade voice communication server with minimal infrastructure management. The combination of Mumble’s low-latency audio, strong encryption, and granular access controls with Klutch.sh’s reliable hosting creates a voice server that’s always available for your gaming sessions, team meetings, or community gatherings.

Whether you’re running a small private server for friends or a larger community voice platform, Mumble on Klutch.sh provides the reliability and control you need for quality voice communication.