⌘+k ctrl+k
1.1.3 (stable)
Search Shortcut cmd + k | ctrl + k
Building Instructions

Prerequisites

DuckDB needs CMake and a C++11-compliant compiler (e.g., GCC, Apple-Clang, MSVC). Additionally, we recommend using the Ninja build system, which automatically parallelizes the build process.

UNIX-Like Systems

macOS Packages

Install Xcode and Homebrew. Then, install the required packages with:

brew install git cmake ninja

Linux Packages

Install the required packages with the package manager of your distribution.

Ubuntu and Debian 

sudo apt-get update && sudo apt-get install -y git g++ cmake ninja-build libssl-dev

Fedora, CentOS, and Red Hat 

sudo yum install -y git g++ cmake ninja-build openssl-devel

Alpine Linux 

apk add g++ git make cmake ninja

Note that Alpine Linux uses the musl libc as its C standard library. There are no official binaries distributed for musl libc but DuckDB can be build with it manually following the instructions on this page.

Cloning the Repository

Clone the DuckDB repository:

git clone https://github.com/duckdb/duckdb

We recommend creating a full clone of the repository. Note that the directory uses approximately 1.3 GB of disk space.

Building DuckDB

To build DuckDB, we use a Makefile which in turn calls into CMake. We also advise using Ninja as the generator for CMake.

GEN=ninja make

Bestpractice It is not advised to directly call CMake, as the Makefile sets certain variables that are crucial to properly building the package.

Once the build finishes successfully, you can find the duckdb binary in the build directory:

build/release/duckdb

Linking Extensions

For testing, it can be useful to build DuckDB with statically linked core extensions. To do so, run:

CORE_EXTENSIONS='autocomplete;httpfs;icu;json;tpch' GEN=ninja make

This option also accepts out-of-tree extensions:

CORE_EXTENSIONS='autocomplete;httpfs;icu;json;tpch;delta' GEN=ninja make

For more details, see the “Building Extensions” page.

Windows

On Windows, DuckDB requires the Microsoft Visual C++ Redistributable package both as a build-time and runtime dependency. Note that unlike the build process on UNIX-like systems, the Windows builds directly call CMake.

Visual Studio

To build DuckDB on Windows, we recommend using the Visual Studio compiler. To use it, follow the instructions in the CI workflow:

python scripts/windows_ci.py
cmake \
    -DCMAKE_BUILD_TYPE=Release \
    -DCMAKE_GENERATOR_PLATFORM=x64 \
    -DENABLE_EXTENSION_AUTOLOADING=1 \
    -DENABLE_EXTENSION_AUTOINSTALL=1 \
    -DDUCKDB_EXTENSION_CONFIGS="${GITHUB_WORKSPACE}/.github/config/bundled_extensions.cmake" \
    -DDISABLE_UNITY=1 \
    -DOVERRIDE_GIT_DESCRIBE="$OVERRIDE_GIT_DESCRIBE"
cmake --build . --config Release --parallel

MSYS2 and MinGW64

DuckDB on Windows can also be built with MSYS2 and MinGW64. Note that this build is only supported for compatibility reasons and should only be used if the Visual Studio build is not feasible on a given platform. To build DuckDB with MinGW64, install the required dependencies using Pacman. When prompted with Enter a selection (default=all), select the default option by pressing Enter.

pacman -Syu git mingw-w64-x86_64-toolchain mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja
git clone https://github.com/duckdb/duckdb
cd duckdb
cmake -G "Ninja" -DCMAKE_BUILD_TYPE=Release -DBUILD_EXTENSIONS="icu;parquet;json"
cmake --build . --config Release

Once the build finishes successfully, you can find the duckdb.exe binary in the repository's directory:

./duckdb.exe

Android

DuckDB has experimental support for Android. Please use the latest main branch of DuckDB instead of the stable versions.

Building the DuckDB Library Using the Android NDK

We provide build instructions for setups using macOS and Android Studio. For other setups, please adjust the steps accordingly.

  1. Open Android Studio. Select the Tools menu and pick SDK Manager. Select the SDK Tools tab and tick the NDK (Side by side) option. Click OK to install.

  2. Set the Android NDK's location. For example:

    ANDROID_NDK=~/Library/Android/sdk/ndk/28.0.12433566/

  3. Set the Android ABI. For example:

    ANDROID_ABI=arm64-v8a

    Or:

    ANDROID_ABI=x86_64

  4. If you would like to use the Ninja build system, make sure it is installed and available on the PATH.

  5. Set the list of DuckDB extensions to build. These will be statically linked in the binary. For example:

    DUCKDB_EXTENSIONS="icu;json;parquet"

  6. Navigate to DuckDB's directory and run the build as follows:

    PLATFORM_NAME="android_${ANDROID_ABI}"
BUILDDIR=./build/${PLATFORM_NAME}
mkdir -p ${BUILDDIR}
cd ${BUILDDIR}
cmake \
    -G "Ninja" \
    -DEXTENSION_STATIC_BUILD=1 \
    -DDUCKDB_EXTRA_LINK_FLAGS="-llog" \
    -DBUILD_EXTENSIONS=${DUCKDB_EXTENSIONS} \
    -DENABLE_EXTENSION_AUTOLOADING=1 \
    -DENABLE_EXTENSION_AUTOINSTALL=1 \
    -DCMAKE_VERBOSE_MAKEFILE=on \
    -DANDROID_PLATFORM=${ANDROID_PLATFORM} \
    -DLOCAL_EXTENSION_REPO="" \
    -DOVERRIDE_GIT_DESCRIBE="" \
    -DDUCKDB_EXPLICIT_PLATFORM=${PLATFORM_NAME} \
    -DBUILD_UNITTESTS=0 \
    -DBUILD_SHELL=1 \
    -DANDROID_ABI=${ANDROID_ABI} \
    -DCMAKE_TOOLCHAIN_FILE=${ANDROID_NDK}/build/cmake/android.toolchain.cmake \
    -DCMAKE_BUILD_TYPE=Release ../..
cmake \
    --build . \
    --config Release

  7. For the arm64-v8a ABI, the build will produce the build/android_arm64-v8a/duckdb and build/android_arm64-v8a/src/libduckdb.so binaries.

Building the CLI in Termux

To build the command line client in the Termux application, install the following packages:

pkg install -y git ninja clang cmake python3

Clone the DuckDB repository and build it as follows:

mkdir build
cd build
export LDFLAGS="-llog"
cmake \
    -G "Ninja" \
    -DBUILD_EXTENSIONS="" \
    -DDUCKDB_EXPLICIT_PLATFORM=linux_arm64_android \
    -DCMAKE_BUILD_TYPE=Release \
    ..
cmake --build . --config Release

Note that you can also use the Python client:

pip install --pre --upgrade duckdb

Raspberry Pi (32-bit)

On 32-bit Raspberry Pi boards, you need to add the -latomic link flag. As extensions are not distributed for this platform, it's recommended to also include them in the build. For example:

mkdir build
cd build
cmake .. \
    -DCORE_EXTENSIONS="httpfs;json;parquet" \
    -DDUCKDB_EXTRA_LINK_FLAGS="-latomic"
make -j4

Troubleshooting

The Build Runs Out of Memory

Ninja parallelizes the build, which can cause out-of-memory issues on systems with limited resources. These issues have also been reported to occur on Alpine Linux, especially on machines with limited resources. In these cases, avoid using Ninja by setting the Makefile generator to empty (GEN=):

GEN= make
About this page