File: README.md
Mumble - Open Source voice-chat software
Mumble is an Open Source, low-latency and high-quality voice-chat program
written on top of Qt and Opus.
There are two modules in Mumble; the client (mumble) and the server (mumble-server formerly known as murmur).
The client works on Windows, Linux, FreeBSD, OpenBSD, and macOS,
while the server should work on anything Qt can be installed on.
The documentation of the project can be found on the website.
Contributing
We always welcome contributions to the project. If you have some code that you would like to contribute, please go ahead and create a PR. While doing so,
please try to make sure that you follow our commit guidelines.
If you are new to the Mumble project, you may want to check out the general introduction to the Mumble source code.
Translating
Mumble supports various languages. We are always looking for qualified people to contribute translations.
We are using Weblate as a translation platform. Register on Weblate, and join our translation project.
Writing plugins
Mumble supports general-purpose plugins that can provide functionality that is not implemented in the main Mumble application. You can find more
information on how this works and how these have to be created in the plugin documentation.
Building
For information on how to build Mumble, check out the dedicated documentation.
Make sure to switch to the appropriate branch in this repository to get the correct build documentation. The current master branch contains
the unstable code for a future release of Mumble. If you want to build an already released stable version of Mumble, e.g. 1.5.735, select the
corresponding branch, e.g. 1.5.x, in the dropdown menu above. Alternatively, use the documentation in the respective release tarball.
Reporting issues
If you want to report a bug or create a feature request, you can open a new issue (after you have checked that there is none already) on
GitHub.
Code Signing
We graciously acknowledge that this program uses free code signing provided by
SignPath.io, and a free code signing certificate by the
SignPath Foundation.
Windows
Running Mumble
After installation, you should have a new Mumble folder in your
Start Menu, from which you can start Mumble.
Running Mumble-Server
Double-click the icon to start mumble-server. There will be a small icon on your
taskbar from which you can view the log.
To set the superuser password, run mumble-server with the parameters --set-su-pw .
MacOS
Running Mumble
To install Mumble, drag the application from the downloaded
disk image into your /Applications folder.
Running Mumble-Server
mumble-server is distributed separately from the Mumble client on MacOS.
It is called Static OS X Server and can be downloaded from the main webpage.
Once downloaded it can be run in the same way as on any other Unix-like system.
For more information please see the "Running mumble-server" in the Linux/Unix section below.
Linux/Unix
Running Mumble
If you have installed Mumble through your distribution package
repository, you should be able to find Mumble in your start menu. No
additional steps are necessary.
Running Mumble-Server
mumble-server should be run from the command line, so start a shell (command prompt)
and go to wherever you installed Mumble. Run mumble-server as
mumble-server [--set-su-pw ] [--ini ] [--foreground] [--verbose]
--set-su-pw Set a new password for the user SuperUser, which is hardcoded to
bypass ACLs. Keep this password safe. Until you set a password,
the SuperUser is disabled. If you use this option, mumble-server will
set the password in the database and then exit.
--ini Use an inifile other than mumble-server.ini, use this to run several instances
of mumble-server from the same directory. Make sure each instance is using
a separate database.
--foreground Run in the foreground, logging to standard output.
--verbose More verbose logging.Docker image
Our official Docker image along with instructions on how to use it can be found at https://github.com/mumble-voip/mumble-docker
Server configuration
You can find an up-to-date mumble-server configuration template in this repository.
Further server configuration documentation can be found on the project website.
OpenGL Overlay
The OpenGL overlay works by intercepting the call to switch buffers, and just
before the buffer switch, we draw our nice GUI.
To load a game with the overlay enabled, start the game like this:
LD_PRELOAD=/path/to/libmumble.so.1.1 gamenameIf you have Mumble installed through the binary packages, this can be done by
simply typing:
mumble-overlay gamenameSponsors
File: docs/dev/build-instructions/build_installer.md
Creating an installer
Currently, the installer creation has been tested on Windows only.
For creating the installer, WixSharp has to be present on your system.
- Download the latest WixSharp release
- Extract into a folder
- Add that folder to the PATH environment variable
When creating an installer, you have to specify a build number using e.g. -DBUILD_NUMBER=3 when invoking cmake. The build number is used to
differentiate multiple builds for the same Mumble version and makes sure that always the latest build will upgrade any previous builds. If you are
creating an installer for yourself, just use build number 0.
The cmake option packaging, off by default, specifies whether or not to build the installer. If being built it will be multi-lingual by default.
Use the cmake generate option -Dpackaging=ON to enable building the installer.
Use the additional cmake generate option -Dtranslations=OFF to build a single-language installer instead.
Note that the installers expect some components to be built. For example, the client installer expects the g15 component to be built too. Without it packaging will fail on the missing expected file.
File: docs/dev/build-instructions/build_linux.md
Building on Linux
These are instructions for performing a regular build using the libraries that are shipped with your distribution. For instructions to build a static
version of Mumble, checkout this file.
Dependencies
Ubuntu
In order to install the needed dependencies on Ubuntu, you have to run the following command (but see notes below the command):
sudo apt install \
build-essential \
cmake \
pkgconf \
qt6-base-dev \
qt6-tools-dev \
qt6-tools-dev-tools \
libqt6svg6-dev \
qt6-l10n-tools \
libgl-dev \
libboost-dev \
libssl-dev \
libprotobuf-dev \
protobuf-compiler \
libprotoc-dev \
libcap-dev \
libxi-dev \
libasound2-dev \
libogg-dev \
libsndfile1-dev \
libopus-dev \
libspeechd-dev \
libavahi-compat-libdnssd-dev \
libxcb-xinerama0 \
libzeroc-ice-dev \
libpoco-dev \
g++-multilibThe dependence on g++-multilib only applies if you are on a 64bit system and want to cross-compile overlay support for 32bit applications as well
(which is enabled by default). If you don't do this (-Doverlay-xcompile=OFF when invoking cmake), you also don't have to install g++-multilib.
You will need cmake v3.23 or later. If the version shipped by your distribution is not recent enough, you can install a recent one via the
official PPA or from the linked page.
Debian (Stable)
In order to install the needed dependencies on Debian, you may
run the following command.
sudo apt install \
build-essential \
cmake \
g++-multilib \
libasound2-dev \
libavahi-compat-libdnssd-dev \
libboost-dev \
libcap-dev \
libgl-dev \
libmsgsl-dev \
libogg-dev \
libpoco-dev \
libprotobuf-dev \
libprotoc-dev \
libqt6svg6-dev \
libsndfile1-dev \
libspeechd-dev \
libspeexdsp-dev \
libssl-dev \
libxcb-xinerama0 \
libxi-dev \
libzeroc-ice-dev \
nlohmann-json3-dev \
pkgconf \
protobuf-compiler \
qt6-base-dev \
qt6-base-dev-tools \
qt6-l10n-tools \
qt6-tools-dev \
qt6-tools-dev-tools \
qtchooser- There is a problem with Opus, causing crashes on some systems. Disabling the bundled opus version when running cmake might be necessary for now:
cmake -Dbundled-opus=OFF .. - Also, see Ubuntu notes, which explain some things relevant to Debian builds.
CentOS 9 Stream
In order to install the needed dependencies on Cent OS 9, you have to run the following command:
sudo dnf -y install epel-release
sudo dnf config-manager --set-enabled PowerTools
sudo dnf group install "Development Tools"
sudo dnf install https://zeroc.com/download/ice/3.7/el8/ice-repo-3.7.el8.noarch.rpm
sudo dnf install libice-c++-devel libice3.7-c++
sudo dnf install \
cmake \
qt6-devel \
qt6-qtsvg-devel \
openssl-devel \
protobuf-devel \
libsndfile-devel \
libXi-devel \
libXext-devel \
speech-dispatcher-devel \
avahi-compat-libdns_sd-devel \
alsa-lib-devel \
libICE-devel \
libogg-devel \
boost-devel \
libcap-devel \
poco-devel \
gcc-toolset-9-gcc-c++ OpenSUSE Tumbleweed
In order to install the needed dependencies on OpenSUSE Tumbleweed (not Leap),
you have to run the following commands:
sudo zypper install -t pattern devel_basis devel_qt6
sudo zypper install \
libopenssl-devel \
protobuf-devel \
poco-devel \
libsndfile-devel \
libXi-devel \
libspeechd-devel \
avahi-compat-mDNSResponder-devel \
alsa-devel \
libcap-devel \
gcc-c++-32bitThere is no official package for Ice on OpenSUSE Tumbleweed.
This means you need to generate the files like so:cmake -Dice=OFF ..
If you are using any other distribution that is not based on one of the distros listed above, you probably have to adapt the commands to your distro manually.
Running cmake
It is recommended to perform a so-called "out-of-source-build". In order to do so, navigate to the root of the Mumble directory and run cmake -B build
This will cause cmake to create the necessary build files for you. If you want to customize your build, you can pass special flags to cmake in step 3.
For all available build options, have a look here.
E.g. if you only want to build the server, use cmake -Dclient=OFF ...
Database backends
When compiling the Mumble server, backends for postgresql and mysql are enabled and compiled by default.
These require additional development headers to be installed on the system.
Alternatively, you can disable those backends using the respective CMake options.
Building
By default cmake will create Makefiles if run on Linux, so in order to build, you can simply run make in the build directory. If you want to
parallelize the build (to speed things up), you can use make -j $(nproc).
If you want to stay independent of the type of the generated build files, you should issue cmake --build . (from the build directory) in order to
start the compilation. If you want to parallelize the build, use cmake --build . -j <jobs> where <jobs> is the amount of parallel jobs to be run
concurrently. A good choice usually is <jobs> = $(nproc).
FAQ
See the general build-FAQ.
File: docs/dev/build-instructions/build_macos.md
Building on macOS
These instructions are for performing a regular build of Mumble that will only run on systems that have the necessary libraries installed on them. For
building a static version, checkout this file.
Dependencies
On macOS, you can use homebrew to install the needed packages. If you don't have it installed already, you can follow the
instruction on their official website to install homebrew itself.
Once homebrew is installed, you can run the following command to install all required packages:
brew update && brew install \
cmake \
pkg-config \
qt6 \
boost \
libogg \
libvorbis \
flac \
libsndfile \
protobuf \
openssl \
poco \
iceRunning cmake
It is recommended to perform a so-called "out-of-source-build". In order to do so, navigate to the root of the Mumble directory and the issue the
following commands:
mkdir build(Creates a build directory)cd build(Switches into the build directory)cmake ..(Actually runs cmake)
This will cause cmake to create the necessary build files for you. If you want to customize your build, you can pass special flags to cmake in step 3.
For all available build options, have a look here.
E.g. if you only want to build the server, use cmake -Dclient=OFF ...
Building
Once cmake has been run, you can issue cmake --build . from the build directory in order to actually start compiling the sources. If you want to
parallelize the build, use cmake --build . -j <jobs> where <jobs> is the amount of parallel jobs to be run concurrently.
FAQ
See the general build-FAQ.
CMake chooses Apple's SSL library
It can happen that cmake will find Apple's own SSL library that comes pre-installed on your system. This is usually incompatible with Mumble though
and you'll usually get errors about undefined OpenSSL symbols during link-time:
ld: symbol(s) not foundYou can circumvent this problem by pointing cmake to the OpenSSL version you installed following the instructions from above. For how to do this,
please refer to our build-FAQ.
File: docs/dev/build-instructions/build_static.md
Building static Mumble
These instructions are for creating a static build of Mumble. "Static" means that it bundles most (all) of its dependencies into the built library in
order to make it run on systems that don't have the necessary dependencies installed.
This will typically take 3 steps: installing dependencies, running the CMake generator, then building Mumble.
Dependencies
We are using vcpkg in order to manage the dependencies needed for the build. This package manager is available
on all major platforms (Windows, Linux, macOS, probably more), so the instructions here apply to all of these systems.
In order to ensure maximum reproducibility, we host our own fork of vcpkg at https://github.com/mumble-voip/vcpkg that contains vcpkg packages at the
exact state that have been used by us to build Mumble. There are also pre-built environments
available there.
The entire build environment will require between 30GB and 60GB of space on your hard-drive. If installed via script, it tends to converge towards the
lower bound whereas a manual installation usually tends towards the higher bound.
In addition to the dependencies installed via vcpkg, you'll also need cmake (v3.23 or later). On Linux you might have to install
cmake using a PPA and on macOS you can install it using homebrew.
Furthermore you need a C++ compiler. On Linux and MacOS that'd usually be gcc (g++) or clang. On Windows you probably want to use MSVC
(check out Setup Visual Studio on how to install it).
Installing via script
The recommended way of installing the dependencies on your system is to clone our vcpkg fork and run the installation script located in the
repository's root.
On Windows you'll have to run the script by opening a PowerShell window, executing Set-ExecutionPolicy -Scope CurrentUser RemoteSigned and then
running the mentioned script. On Linux and macOS no such preliminaries are necessary.
If you already have vcpkg installed on your system, you should probably prefer using the manual installation of dependencies in order to avoid a
second vcpkg installation.
Using pre-built environments
For common configurations, you can also use the pre-built vcpkg environments mentioned above instead of using the script.
- Download & unzip the appropriate environment from the releases page.
- When using the
cmakecommands below, use the unzipped folder as<vcpkg dir>in the-DCMAKE_TOOLCHAIN_FILEand-DIce_HOMEarguments. Use
the corresponding triplet for-DVCPKG_TARGET_TRIPLET. You'll also need to set-Dbundled-cli11=OFFand-Dbundled-spdlog=OFF
For example, on Windows, after extracting mumble_env.x64-windows-static-md.<hash>.7z to C:\mumble-env\, CMAKE_TOOLCHAIN_FILE would be C:\mumble-env\mumble_env.x64-windows-static-md.<hash>\scripts\buildsystems\vcpkg.cmake". (Replace <hash> with the commit hash in the filename, e.g. b1fe4a4257.)
Manual installation
Again, we advise you to use our vcpkg fork or pre-built environments. If you are using upstream vcpkg, you do not have access to a compatible version of ZeroC Ice, so you'll have
to disable that when building the server.
The current list of vcpkg packages required to build Mumble can be found at https://github.com/mumble-voip/vcpkg/blob/master/mumble_dependencies.txt.
On Windows, you'll also have to install the mdnsresponder package.
The command for installing a package is vcpkg install --triplet where is to be replaced with the name of the package you want to install and is the desired target triplet. We recommend using these triplets:
| OS | Triplet |
|---|---|
| Windows | x64-windows-static-md |
| Linux | x64-linux |
| macOS | x64-osx |
Therefore if you are on Windows, you'd install boost as vcpkg install boost --triplet x64-windows-static-md.
Additional dependencies on Linux
Additional dev packages will need to be installed for some components in vcpkg on GNU/Linux (package names match Ubuntu packages):
libxi(X11)libgl1-mesalibglu1-mesamesa-commonlibxrandrlibxxf86vmlibbluetoothlibx11-xcb
vcpkg will also require installation of:
python3python2python
Most GNU/Linux distros should have these or equivalent packages.
Additional dependencies on macOS
The following is required for macOS:
Xquartz
Additional dependencies on Windows
The following is required for Windows:
python(winget install --id=Python.Python.3.13 -e)
Building Mumble
After all dependencies are installed, you can follow these steps in order to actually build Mumble itself:
- Start a command line (on Windows see caveats listed below)
- Clone the Mumble repo https://github.com/mumble-voip/mumble.git (if not done already)
- Navigate into the cloned directory
- Create a directory named
buildand navigate into it (mkdir build && cd build) - Run the cmake generator with relative target path
..(more on that further down) - Run the cmake in build-mode:
cmake --build .or invoke your buildsystem of choice directly (e.g.make -j $(nproc))
cmake will generate a bunch of files so you should call it from a dedicated, empty directory ("out-of-source build"). In the list above we suggestbuild.
Windows caveats
On Windows you can't use the default command-prompt (as is) as it won't have the needed development tools in its PATH. See Setup Visual Studio for simple ways to access the development tools.
CMake Generator
Important configuration options
| Option | Value | Description |
|---|---|---|
VCPKG_TARGET_TRIPLET |
x64-windows-static-md, x64-linux, x64-osx or whatever the pre-built environment used |
The vcpkg triplet chosen when installing the dependencies via vcpkg |
CMAKE_TOOLCHAIN_FILE |
<vcpkg_root>/scripts/buildsystems/vcpkg.cmake |
|
Ice_HOME |
<vcpkg dir>/installed/x64-windows-static-md |
Required if you build with Ice (enabled by default) |
static |
ON |
|
bundled-cli11 andbundled-spdlog |
OFF |
Required when using pre-built environments from after 2026-02. Without these flags, linker errors for unresolved CLI11/spdlog/fmt symbols will occur. See common build errors |
<vcpkg dir> is a placeholder for your prepared build environment vcpkg setup (the path to the vcpkg directory created by the get_dependency script, or the path to your pre-built environment).
For Linux the cmake invokation may be (using the default generator make):
# From your build/ directory
cmake \
"-DVCPKG_TARGET_TRIPLET=x64-linux" \
"-Dstatic=ON" \
"-DCMAKE_TOOLCHAIN_FILE=<vcpkg dir>/scripts/buildsystems/vcpkg.cmake" \
"-DIce_HOME=<vcpkg dir>/installed/x64-linux" \
"-DCMAKE_BUILD_TYPE=Release" \
"-Dbundled-cli11=OFF" \
"-Dbundled-spdlog=OFF" \
..For macOS the command may be:
# From your build/ directory
cmake \
"-DVCPKG_TARGET_TRIPLET=x64-osx" \
"-Dstatic=ON" \
"-DCMAKE_TOOLCHAIN_FILE=<vcpkg dir>/scripts/buildsystems/vcpkg.cmake" \
"-DIce_HOME=<vcpkg dir>/installed/x64-osx" \
"-DCMAKE_BUILD_TYPE=Release" \
"-Dbundled-cli11=OFF" \
"-Dbundled-spdlog=OFF" \
..For Windows the command may be:
# From your build/ directory
# See note about using `-G "Ninja"` instead.
cmake -G "NMake Makefiles" `
"-DVCPKG_TARGET_TRIPLET=x64-windows-static-md" `
"-Dstatic=ON" `
"-DCMAKE_TOOLCHAIN_FILE=<vcpkg dir>/scripts/buildsystems/vcpkg.cmake" `
"-DIce_HOME=<vcpkg dir>/installed/x64-windows-static-md" `
"-DCMAKE_BUILD_TYPE=Release" `
-Dbundled-cli11=OFF `
-Dbundled-spdlog=OFF `
..Optionally you can use -G "Ninja" to use the Ninja buildsystem (which probably has to be installed separately).
Especially on Windows this is recommended as the default NMake Makefiles only compile using a single thread (which takes quite a while).
[!NOTE]
If you ran previous builds that failed with missing dependencies, you may need to delete and recreate yourbuild/directory before trying new approaches, or CMake will continue to struggle finding dependencies.
Customizing the build
There are various options that can be passed to cmake when performing step 6 from above. See here for details.
Building
Finally, you're ready to build. From your build/ directory:
# Or invoke your buildsystem of choice directly (e.g. `make -j $(nproc)`)
cmake --build .As you edit C++, you only need to rerun this one step to rebuild Mumble.
Troubleshooting
See also our general build FAQ if your problem is not listed below.
sndfile not found
This is an error that is often encountered on 64bit Windows systems. The problem is usually that you have used the wrong developer command prompt and
therefore cmake is trying to build a 32bit version of Mumble. The ./Get-MumbleDeps.ps1 script automatically detects your system's architecture and
only builds the 64bit version of the libraries (including sndfile). cmake then tries to locate a 32bit version of the library and fails as only the
64bit version is present.
The solution is to use a x64 developer command prompt. You can see what kind of build cmake is performing at the top of the cmake output. For 64 bit
it should say Architecture: 64bit.
NOTE: If you initially have run cmake from the wrong prompt (32bit), then you'll have to delete all files in your build directory before running
cmake again from the new prompt. Otherwise cmake will not check the architecture again and proceed with the cached 32bit variant.
CMake can't find library
If cmake doesn't find a library and you don't really know why this might be, you can use -Ddebug-dependency-search=ON when running cmake in order to
get a lot of debug information regarding the search for the needed dependencies. Chances are that this will shed some light on the topic.
Unable to download from https://repo.msys2.org
This can happen if you're using a system that doesn't support TLS 1.3 (which https://repo.msys2.org requires) such as Windows 7. In this case the only
possible workaround is either to download the respective files manually using a brower that does support TLS 1.3 (e.g. Firefox) or to replace all
occurrences of https://repo.msys2.org in the vcpkg dir with http://repo.msys2.org and thereby forxing vcpkg to use the HTTP mirror instead. Note
though that this is inherently unsafer than using HTTPS.
A common error message for this scenario could be
-- Acquiring MSYS2...
-- Downloading https://sourceforge.net/projects/msys2/files/Base/x86_64/msys2-base-x86_64-20190524.tar.xz/download...
-- Downloading https://repo.msys2.org/msys/x86_64/msys2-keyring-r21.b39fb11-1-any.pkg.tar.xz...
-- Downloading https://repo.msys2.org/msys/x86_64/msys2-keyring-r21.b39fb11-1-any.pkg.tar.xz... Failed. Status: 35;"SSL connect error"
CMake Error at scripts/cmake/vcpkg_download_distfile.cmake:173 (message):
Failed to download file.
If you use a proxy, please set the HTTPS_PROXY and HTTP_PROXY environment
variables to "https://user:password@your-proxy-ip-address:port/".
Otherwise, please submit an issue at https://github.com/Microsoft/vcpkg/issueRef: https://github.com/microsoft/vcpkg/issues/13217
`afxres.h` not found
When installing the dependency zlib via vcpkg, it may fail to locate the include file afxres.h (when building its mdnsresponder dependency).
dll.rc(10): fatal error RC1015: cannot open include file 'afxres.h'.To resolve this, ensure MFC has been installed in your Visual Studio installation.
File: docs/dev/build-instructions/build_windows.md
Building on Windows
On Windows we only support static builds. You will need to set up Visual Studio first.
File: docs/dev/build-instructions/cmake_options.md
CMake options
Using CMake the build can be customized in a number of ways. The most prominent examples for this is the usage of different
options (flags). These can be set by using -D<optionName>=<value> where <optionName> is the name of the respective option
as listed below and <value> is either ON or OFF depending on whether the option shall be activated or inactivated.
An example would be cmake -Dtests=ON ...
Available options
alsa
Build support for ALSA.
(Default: ON)
asio
Build support for ASIO audio input.
(Default: OFF)
benchmarks
Build benchmarks
(Default: OFF)
BUILD_OVERLAY_XCOMPILE
Build an x86 overlay
(Default: OFF)
bundle-qt-translations
Bundle Qt's translations as well
(Default: ${static})
bundled-cli11
Use the bundled CLI11 version instead of looking for one on the system
(Default: ON)
bundled-json
Build the included version of nlohmann_json instead of looking for one on the system
(Default: ON)
bundled-rnnoise
Build the included version of RNNoise instead of looking for one on the system.
(Default: ${rnnoise})
bundled-soci
Build the included version of SOCI instead of looking for one on the system
(Default: ON)
bundled-spdlog
Use the bundled spdlog version instead of looking for one on the system
(Default: ON)
bundled-speex
Build the included version of Speex instead of looking for one on the system.
(Default: ON)
bundled-utfcpp
Use the bundled utf8cpp version instead of looking for one on the system
(Default: ON)
client
Build the client (Mumble)
(Default: ON)
coreaudio
Build support for CoreAudio.
(Default: ON)
crash-report
Include support for reporting crashes to the Mumble developers.
(Default: ON)
database-mysql-tests
Whether to include the MySQL database tests (requires special setup)
(Default: OFF)
database-postgresql-tests
Whether to include the PostgreSQL database tests (requires special setup)
(Default: OFF)
database-sqlite-tests
Whether to include the SQLite database tests
(Default: ON)
dbus
Enable DBus support/interface
(Default: ON)
debug-dependency-search
Prints extended information during the search for the needed dependencies
(Default: OFF)
display-install-paths
Print out base install paths during project configuration
(Default: OFF)
elevation
Set "uiAccess=true", required for global shortcuts to work with privileged applications. Requires the client's executable to be signed with a trusted code signing certificate.
(Default: OFF)
enable-mysql
Whether or not to enable the MySQL database backend
(Default: ${server})
enable-postgresql
Whether or not to enable the PostgreSQL database backend
(Default: ${server})
enable-sqlite
Whether or not to enable the SQLite database backend
(Default: ON)
g15
Include support for the G15 keyboard (and compatible devices).
(Default: OFF)
g15-emulator
Build the g15helper executable in emulator mode. This will cause an emulated G15 window to appear on screen. Allows the use of Mumble's G15 support without owning the physical hardware.
(Default: OFF)
gkey
Build support for Logitech G-Keys. Note: This feature does not require any build-time dependencies, and requires Logitech Gaming Software to be installed to have any effect at runtime.
(Default: ON)
ice
Build support for Ice RPC.
(Default: ON)
jackaudio
Build support for JackAudio.
(Default: ON)
lto
Enables link-time optimizations for release builds
(Default: ${LTO_DEFAULT})
manual-plugin
Include the built-in "manual
(Default: positional audio plugin." ON)
online-tests
Whether or not tests that need a working internet connection should be included
(Default: OFF)
optimize
Build a heavily optimized version, specific to the machine it's being compiled on.
(Default: OFF)
oss
Build support for OSS.
(Default: ON)
overlay
Build overlay.
(Default: ${client})
overlay-xcompile
Build 32 bit overlay library, necessary for the overlay to work with 32 bit processes.
(Default: ${client})
packaging
Build package.
(Default: OFF)
pipewire
Build support for PipeWire.
(Default: ON)
plugin-callback-debug
Build Mumble with debug output for plugin callbacks inside of Mumble.
(Default: OFF)
plugin-debug
Build Mumble with debug output for plugin developers.
(Default: OFF)
plugins
Build plugins.
(Default: ON)
portaudio
Build support for PortAudio
(Default: ON)
pulseaudio
Build support for PulseAudio.
(Default: ON)
qssldiffiehellmanparameters
Build support for custom Diffie-Hellman parameters.
(Default: ON)
qtspeech
Use Qt's text-to-speech system (part of the Qt Speech module) instead of Mumble's own OS-specific text-to-speech implementations.
(Default: OFF)
retracted-plugins
Build redacted (outdated) plugins as well
(Default: OFF)
rnnoise
Use RNNoise for machine learning noise reduction.
(Default: ON)
server
Build the server (Murmur)
(Default: ON)
skip-msi-rebuild
Prevent rebuilding installer MSI files from source. Used to be able to include signed MSI files in the bundle.
(Default: OFF)
speechd
Build support for Speech Dispatcher.
(Default: ON)
static
Build static binaries.
(Default: OFF)
symbols
Build binaries in a way that allows easier debugging.
(Default: OFF)
test-lto
Whether to use LTO when building test cases
(Default: ${lto})
tests
Build tests.
(Default: ${packaging})
tracy
Enable the tracy profiler.
(Default: OFF)
translations
Include languages other than English.
(Default: ON)
update
Check for updates by default.
(Default: ON)
use-pkgconf-install-paths
Try to query install paths from pkgconf - this is incompatible to using CMAKE_INSTALL_PREFIX
(Default: OFF)
use-timestamps
Allow using compile-time timestamps
(Default: ON)
warnings-as-errors
All warnings are treated as errors.
(Default: ON)
wasapi
Build support for WASAPI.
(Default: ON)
xboxinput
Build support for global shortcuts from Xbox controllers via the XInput DLL.
(Default: ON)
xinput2
Build support for XI2.
(Default: ON)
zeroconf
Build support for zeroconf (mDNS/DNS-SD).
(Default: ON)
File: docs/dev/build-instructions/common_build_errors.md
Common build errors
This page is supposed to give a summary of the most common build errors that are encountered when building Mumble and how to fix them.
| Error message | Description and fix |
|---|---|
| inlining failed in call to always_inline ‘vdupq_n_f32’: target specific option mismatch | This error message occurs when attempting to build Opus. It seems to be an issue specific to the Raspberry Pi (4) (or maybe to ARM in general). This is a known problem in Opus.It can be fixed relatively easy by specifying -DOPUS_DISABLE_INTRINSICS=ON when invoking CMake. |
| CMake Error at cmake/qt-utils.cmake:6 (include): include could not find requested file: FindPythonInterpreterCall Stack (most recent call first): src/murmur/CMakeLists.txt:16 (include) | Submodules are outdated Run the command 'git submodule update --init' |
| CMake Error at cmake/qt-utils.cmake:6 (include): include could not find requested file: CompilerFlagsCall Stack (most recent call first): CMakeLists.txt:92 (include) | Same as above |
error LNK2001: unresolved external symbol for CLI11, spdlog, or fmt symbols (e.g. CLI::App, spdlog::logger, fmt::v12::vformat) when using a pre-built vcpkg environment |
The pre-built vcpkg environments (2026-02 and later) ship CLI11, spdlog, and fmt as compiled static libraries rather than header-only. Mumble's CMake defaults (bundled-cli11=ON, bundled-spdlog=ON) activate the vendored header-only versions, but the vcpkg include paths still leak in and reference compiled symbols that aren't linked.Fix: disable the bundled versions so CMake uses the vcpkg compiled targets instead:cmake ... -Dbundled-cli11=OFF -Dbundled-spdlog=OFF |
File: docs/dev/build-instructions/faq.md
Build FAQ
For common compilation errors, see common build errors.
How to speed up the compilation
Mumble supports being compiled as a unity build, if you are using cmake 3.16 or newer. To use this
feature, use -DCMAKE_UNITY_BUILD=ON option when invoking cmake.
Don't use this option when also using -DCMAKE_EXPORT_COMPILE_COMMANDS=ON though as the unity build will render the produced compilation database
useless.
How can I specify the build type
In order to set the build type (Debug vs Release), you have to use the CMAKE_BUILD_TYPE variable when invoking cmake like so: cmake -DCMAKE_BUILD_TYPE=Release. The supported types currently are: "Debug" and "Release".
Note that this only works for single-config generators. If you are using a multi-config generator (e.g. visual studio projects), the steps
mentioned above won't have any effect. Instead, you'll have to choose the config type when invoking the build itself. This works by using e.g. cmake --build . --config Release.
CMake selects wrong OpenSSL version
If the automatic search process of cmake doesn't result in the proper version of OpenSSL being selected (e.g. an older/incompatible system version
could be chosen over the manually installed one), you always have the option of explicitly telling cmake where to look for OpenSSL via theOPENSSL_ROOT_DIR option.
If for instance you have installed OpenSSL to /usr/local/opt/openssl, you can invoke cmake like this:
cmake -DOPENSSL_ROOT_DIR=/usr/local/opt/openssl ..Build a specific version or commit
Version
Use tags to build a specific release version of Mumble.
You can find the tag-list here or by using the command git tag inside a cloned repository.
Use:
git clone -b [tag] https://github.com/mumble-voip/mumble.gitFor example (for version 1.3.3):
git clone -b 1.3.3 https://github.com/mumble-voip/mumble.gitor inside an already cloned repository:
git checkout [tag]or (if you want to create a new branch):
git checkout -b [new-branch-name] [tag]Commit
Use commit hashes to build a specific development state of Mumble.
You can find the list of commits here (for master branch) or by using the command git log inside a cloned repository.
Go into the cloned repository and use:
git checkout [commit_sha]or (if you want to create a new branch):
git checkout -b [new-branch-name] [commit_sha]File: docs/dev/build-instructions/find_build_number.md
Finding the correct BUILD_NUMBER
When invoking CMake, you can specify a build number as e.g. -DBUILD_NUMBER=42. The build number will be used as the third component of the Mumble
version.
First off: This is only important if you are planning to distribute/package Mumble (it makes sure that Mumble can be upgraded properly). For
self-compiled versions this doesn't really matter and you can simply omit the build number.
The build number is automatically increased with every commit that is made to Mumble. All build numbers for all commits can be found on
https://mumble.info/build-number.json. Simply look up the current commit hash (topmost entry in the result of git log) in the list and use the
corresponding build number.
Instead of manually looking up the commit of interest yourself, you could instead use the script scripts/mumble-build-number.py. You have to
pass the commit hash and the Mumble version (as specified in the main CMakeLists.txt file) to it and it will fetch the corresponding build number
for you. For instance:
python3 mumble-build-number.py --commit 53ddee77364482a8385ce7244a233bf10412d76a --version 1.5Note that not all commits will have a build number associated with them (due to how our CI works). As a general rule of thumbs, only merge-commits will
yield a build number. However, if you did not explicitly switch to a specific commit, the current HEAD (can be obtained via git rev-parse HEAD) will
most likely have a build number associated with it.