Mumble Voice Chat Server Installation

Mumble (powered by the Murmur server) is an open-source, low-latency voice chat application built for gaming and team communication, offering excellent voice quality, channel-based organization, fine-grained permission controls, and certificate-based authentication. This guide covers installing Murmur on Linux, configuring channels, setting ACL permissions, enabling certificate authentication, and tuning audio quality.

Prerequisites

  • Ubuntu 20.04+ / Debian 11+ or CentOS 8+ / Rocky Linux 8+
  • 256 MB RAM (Murmur is very lightweight)
  • 512 MB RAM for 100+ concurrent users
  • UDP port 64738 open (Murmur's default voice port)
  • TCP port 64738 for fallback connections
  • Root or sudo access

Installing Murmur

# Ubuntu/Debian
sudo apt-get update
sudo apt-get install -y mumble-server

# CentOS/Rocky Linux
sudo dnf install -y epel-release
sudo dnf install -y mumble-server

# Or install the official Mumble package (newer version)
# Download from https://www.mumble.info/downloads/
MURMUR_VERSION="1.5.634"
wget https://github.com/mumble-voip/mumble/releases/download/v${MURMUR_VERSION}/murmur-static_x86-${MURMUR_VERSION}.tar.bz2
tar xjf murmur-static_x86-${MURMUR_VERSION}.tar.bz2
sudo mv murmur-static_x86-${MURMUR_VERSION}/murmur.x86 /usr/local/bin/murmur
murmur --version

Configuring Murmur

The configuration file is at /etc/mumble-server.ini (Debian/Ubuntu) or /etc/murmur.ini (CentOS):

# /etc/mumble-server.ini

# Network settings
host=0.0.0.0       # Listen on all interfaces
port=64738         # Default Murmur port (TCP + UDP)
serverpassword=    # Leave empty for public server, or set a join password

# SSL/TLS certificate (recommended for security)
# Leave blank to use auto-generated certificate
sslCert=
sslKey=
# Or specify paths to Let's Encrypt cert:
# sslCert=/etc/letsencrypt/live/mumble.example.com/fullchain.pem
# sslKey=/etc/letsencrypt/live/mumble.example.com/privkey.pem

# Server name shown in the public server list
registerName=My Mumble Server
# Leave these blank to keep your server unlisted:
# registerUrl=
# registerHostname=
# registerPassword=

# Maximum users
users=100

# Bandwidth per user (bytes/second)
# 72000 = ~576 kbps maximum (reasonable for high quality)
bandwidth=72000

# Database (SQLite by default)
database=/var/lib/mumble-server/mumble-server.sqlite

# Log file
logfile=/var/log/mumble-server/mumble-server.log

# PID file
pidfile=/run/mumble-server/mumble-server.pid

# Timeout for idle connections (seconds, 0 = disable)
timeout=30

# Enable text messaging between users
allowping=true

# Default channel when users first connect
# defaultchannel=0  # 0 = root channel

# Require users to be in the database before connecting
# certrequired=False

# Allow client to use HTML in text messages
allowhtml=true

# Max length of text messages
textmessagelength=5000

# Allow recording
recordingallowed=true

# Opus codec settings (modern, recommended)
opusthreshold=100  # 100% = always use Opus if client supports it

# Bonjour - broadcast server on LAN
bonjour=false

Generate a TLS certificate with Let's Encrypt:

sudo certbot certonly --standalone -d mumble.example.com

# Set correct permissions for Murmur to read the cert
sudo chmod 640 /etc/letsencrypt/live/mumble.example.com/privkey.pem
sudo chown root:mumble-server /etc/letsencrypt/live/mumble.example.com/privkey.pem

Running as a Systemd Service

# For the apt-installed version:
sudo systemctl enable --now mumble-server

# For manually installed binary, create a service:
sudo useradd -r -s /sbin/nologin mumble-server
sudo mkdir -p /var/lib/mumble-server /var/log/mumble-server

sudo cat > /etc/systemd/system/mumble-server.service << 'EOF'
[Unit]
Description=Mumble Server (Murmur)
After=network.target

[Service]
User=mumble-server
Group=mumble-server
Type=forking
PIDFile=/run/mumble-server/mumble-server.pid
ExecStart=/usr/local/bin/murmur -ini /etc/mumble-server.ini -fg
RuntimeDirectory=mumble-server
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable --now mumble-server
sudo systemctl status mumble-server

Open the firewall:

sudo ufw allow 64738/tcp comment "Mumble TCP"
sudo ufw allow 64738/udp comment "Mumble UDP voice"

Initial Connection and SuperUser Setup

Set the SuperUser password before first connection:

# Set the SuperUser password
sudo murmurd -ini /etc/mumble-server.ini -supw YourSuperUserPassword
# Or for apt-installed version:
sudo mumble-server-user-wrapper murmurd -supw YourSuperUserPassword -fg

Connect with the Mumble client:

  1. Open Mumble → Server → Connect
  2. Add a new server:
    • Label: My Server
    • Address: your-server-ip or mumble.example.com
    • Port: 64738
    • Username: SuperUser
    • Password: (your SuperUser password)
  3. Click OK and connect

The SuperUser account has full administrative access. Create named admin accounts and disable SuperUser for daily use.

Channel Management

Channels organize users by team, topic, or activity. Create channels via the Mumble client while logged in as SuperUser or an admin:

From the Mumble client:

  1. Right-click on the root channel → Add → Channel
  2. Name the channel (e.g., "General", "Gaming", "Dev Team")
  3. Set channel description (optional)
  4. Configure Max Users (0 = unlimited)

Channel properties:

  • Temporary: auto-deleted when empty
  • Default channel: users join here on connect

Typical channel structure:

Root
├── Lobby (default, anyone can join)
├── General
│   ├── Break Room
│   └── AFK
├── Gaming
│   ├── Squad 1
│   └── Squad 2
└── Private Channels
    ├── Admin
    └── VIP

From command line using murmurctl:

# Install Python binding
pip3 install zeroc-ice

# Use Murmur's ICE interface for scripting
python3 << 'EOF'
import Ice
Ice.loadSlice('/usr/share/mumble-server/MumbleServer.ice')
import MumbleServer

props = Ice.createProperties()
props.setProperty('Ice.ImplicitContext', 'Shared')
data = Ice.InitializationData()
data.properties = props
ic = Ice.initialize(data)
ic.getImplicitContext().put("secret", "your_icesecretwrite")
base = ic.stringToProxy("Meta:tcp -h 127.0.0.1 -p 6502")
meta = MumbleServer.MetaPrx.checkedCast(base)
server = meta.getServer(1)
server.getConf("host")
EOF

ACL Permissions

ACLs (Access Control Lists) control who can speak, join, and administer channels.

ACL configuration in the Mumble client:

  1. Right-click a channel → Edit → ACL tab
  2. Toggle Inherit ACLs (inherit from parent channel)
  3. Add groups and assign permissions

Default groups:

  • @all - everyone connected to the server
  • @auth - authenticated (registered) users
  • @in - users currently in this channel
  • @out - users NOT in this channel
  • @sub(0) - users in sub-channels

Permission flags:

PermissionMeaning
TraverseCan see the channel exists
EnterCan join the channel
SpeakCan transmit voice
Mute/DeafenCan mute/deafen others
MoveCan move users between channels
Make ChannelCan create sub-channels
Text MessageCan send text messages
Kick/BanCan kick/ban users
RegisterCan register users
Register SelfCan self-register

Example: Private channel for a team

  1. Create channel "Dev Team"
  2. Right-click → Edit → ACL tab
  3. Uncheck "Inherit ACLs"
  4. Set @all: Allow Traverse, Deny Enter
  5. Create a group devteam with allowed users
  6. Set devteam group: Allow Enter, Speak, Text Message

Register users (required for group membership):

  • In Mumble client: right-click a connected user → Register
  • The user must have a certificate (auto-generated or imported)

Certificate Authentication

Certificates identify users uniquely and persist across reconnections. Mumble auto-generates certificates on first connect.

View your certificate in Mumble: Configure → Settings → Privacy → Certificate Management

Require certificates for joining:

# In /etc/mumble-server.ini
certrequired=true    # Block users without a certificate

Strong authentication with certificates:

# Users must have a certificate AND be registered
certrequired=true
# Then register users via the server (right-click → Register)
# Registered users can only connect from devices with their certificate

Export/import certificates for use on multiple devices:

  • Mumble → Configure → Settings → Privacy → Certificate Management
  • Click "Export Certificate" → save the .p12 file
  • On new device: Configure → Settings → Privacy → Import Certificate

Audio Quality Tuning

Mumble's audio quality is tunable in the client, but the server sets limits:

# /etc/mumble-server.ini

# Maximum bandwidth per user (bytes/second)
# 8000  = ~64 kbps  (low quality, low bandwidth)
# 16000 = ~128 kbps (standard quality)
# 40000 = ~320 kbps (high quality)
# 72000 = ~576 kbps (maximum quality - let client choose)
bandwidth=72000

# Opus codec threshold
# opusthreshold=100 means "use Opus if ALL clients support it"
# Lower values allow mixed Opus/CELT environments
opusthreshold=100

Client-side tuning (set each user's preferences):

  • Configure → Settings → Audio Output → Quality
  • Set quality to "Balanced" or "Quality"
  • Configure → Settings → Audio Input → Transmission
    • Use Voice Activation with noise gate, or
    • Use Push to Talk for cleaner audio

Noise suppression settings:

  • Configure → Settings → Audio Input → enable Noise Suppression
  • Enable Echo Cancellation for users on speakers (not headphones)

Troubleshooting

Server not reachable:

# Check if Murmur is listening
ss -tlnpu | grep 64738
sudo systemctl status mumble-server

# Test connectivity
nc -zvu your-server-ip 64738  # UDP test

Certificate warnings in client:

# Murmur generates a self-signed certificate
# Users will see a warning on first connect - click "Yes" to trust it
# For production, use a Let's Encrypt certificate in the config

Users hear echo:

# Echo is a client-side issue
# In Mumble client: Configure → Settings → Audio Input
# Enable "Echo Cancellation"
# Use headphones (eliminates echo completely)

Permission denied to join channel:

# Check ACL configuration for the channel
# Right-click channel → Edit → ACL tab
# Ensure the user's group has Enter permission
# Check "Inherit ACLs" - parent permissions may be blocking

High CPU usage:

# Each active voice stream uses CPU
# Check the number of active users
# Reduce bandwidth limit slightly (e.g., 40000 instead of 72000)

Viewing server logs:

sudo tail -f /var/log/mumble-server/mumble-server.log
sudo journalctl -u mumble-server -f

Conclusion

Murmur is an extremely resource-efficient voice server that delivers consistently low latency compared to VoIP solutions like Discord or TeamSpeak, making it ideal for gaming, remote teams, and latency-sensitive communication. The channel-based ACL system provides granular access control for complex organizational structures, and Opus codec support ensures excellent audio quality even at moderate bandwidth. For production use, configure TLS with a Let's Encrypt certificate, enable certrequired, and register users to prevent anonymous access to sensitive channels.