Humusprivate beta

Build from source

Humus builds on macOS, Linux and Windows from one tree. The source lives at github.com/phobos-instruments/humus, and a source zip travels with every release. The compiled app is the whole application: nothing is gated behind a code, so the download on the website only saves you the build, and for most people that is the easier door.

What you need

Everywhere: git, CMake 3.22 or newer, Python 3, and a network for the first configure. It fetches the GUI framework and the audio sync library, and downloads and converts the hand and pose tracking models, so it takes a few minutes. Nothing after it needs a network.

  • macOS (the primary target, Apple Silicon first): the Xcode command line tools and Ninja. Big Sur is the oldest system a build runs on.

  • Linux: a C++ compiler and the development packages for ALSA, FreeType, fontconfig, X11 with Xrandr, Xinerama and Xcursor, OpenGL, curl and GTK 3. On a Debian-family system that is one line:

    sudo apt install build-essential ninja-build cmake git pkg-config python3 \
  libasound2-dev libfreetype-dev libfontconfig1-dev libx11-dev \
  libxrandr-dev libxinerama-dev libxcursor-dev libxext-dev \
  libgl1-mesa-dev libcurl4-openssl-dev libgtk-3-dev

    Optional: libavcodec-dev libavformat-dev libavutil-dev libswscale-dev. With them VideoPlayer plays ordinary video files; without them it plays HAP videos only, and the configure says so.

  • Windows: Visual Studio with the "Desktop development with C++" workload, which brings CMake with it, plus git and Python 3. Work from a Developer Command Prompt, not a plain one: the compiler has to be on the PATH.

Build and run

The Makefile at the root is a small wrapper around CMake. make alone lists its targets. On Windows there is no make, so make.cmd beside it answers to the same names.

make run             # build and launch the app in this terminal
make build           # build the app, the command-line tool and the plugin
make configure       # only configure (make build and make run do it for you)
make clean           # delete the build directory

make run ARGS="--first-boot" replays the first-launch tour. BUILD_TYPE=Debug in front of any target gives a debug build.

The built app sits in engine/build/hum_gui_artefacts/Release/. Launching it from make run attributes the microphone and camera permission to the terminal; open the app bundle directly when Humus should own its own.

First launch scans your plugins, a few minutes for large plugin shells and cached afterwards.

The command-line tool and the plugin

make build also builds hum, which reads a patch and renders one offline with no display:

engine/build/hum info   patch.hum                         # macOS and Linux
engine/build/hum render patch.hum out.wav --seconds 10
engine\build\Release\hum.exe info patch.hum               # Windows

The Humus plugin lands in engine/build/Humus_artefacts/Release/: VST3 everywhere, and AU as well on macOS.

Packs

make pack                        # every pack as a .humpack bundle
make install-pack PACK=sample    # install one for the app, here the tutorial pack

make pack leaves the bundles in engine/build/humpacks/, and make install-pack with no PACK lists what was built. Restart the app to see an installed pack.

Without make

The wrapper does nothing CMake cannot do by hand:

cmake -S engine -B engine/build -G Ninja -DCMAKE_BUILD_TYPE=Release
cmake --build engine/build

On Windows, make.cmd uses the Visual Studio generator, which ignores CMAKE_BUILD_TYPE, so the configuration is named when building:

cmake -S engine -B engine\build -A x64
cmake --build engine\build --config Release

Intel Macs

ARCH=x86_64 appended to any target builds for Intel on an Apple Silicon Mac, in its own tree (engine/build-x86_64), and Rosetta runs the result.

Where it goes from here