本地构建 llama.cpp

本项目的主要产物是 llama 库。其 C 语言风格接口可以在 include/llama.h 文件中找到。

项目还包括大量示例程序和工具，这些示例均基于 llama 库开发，既有简单的代码片段，也有较为复杂的子项目，例如与 OpenAI 兼容的 HTTP 服务器等。

获取源码方法：

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp

下面将介绍如何在不同的后端和选项下进行构建。

CPU 版本构建

使用 CMake 构建 llama.cpp：

cmake -B build
cmake --build build --config Release

注意：
想提升编译速度，可以加上 -j 参数实现多线程并行编译，比如：cmake --build build --config Release -j 8 表示并发运行 8 个任务。或者直接使用默认并发的编译器（如 Ninja）。

推荐安装 ccache 工具，以加快重复编译速度。
如果需要调试版本（Debug），分两种情况：
单配置生成器（如默认的 Unix Makefiles，此类生成器会忽略 --config 参数）：
cmake -B build -DCMAKE_BUILD_TYPE=Debug
cmake --build build
多配置生成器（如使用 -G "Xcode" 或 Visual Studio）：
cmake -B build -G "Xcode"
cmake --build build --config Debug
更多生成器详情及受支持列表，请查阅 CMake 官方文档。
若需静态库版本，请添加参数 -DBUILD_SHARED_LIBS=OFF：
cmake -B build -DBUILD_SHARED_LIBS=OFF
cmake --build build --config Release
构建 Windows 版本（x86，x64 和 arm64，使用 MSVC 或 clang 编译器）：
请先安装 Visual Studio 2022，比如 Community Edition。安装时选择如下功能（这些也会自动安装相关必需工具，比如 CMake）：

工作负载：C++桌面开发

组件（搜索后快速选择）：C++ CMake 工具、Windows 版 Git、C++ Clang 编译器、MS-Build 对 LLVM 工具集的支持（clang）

请务必使用 VS2022 的“开发者命令行”或 PowerShell，方便执行 git、编译和测试相关操作。
在 Windows on ARM（arm64, WoA）上编译，请使用：
cmake --preset arm64-windows-llvm-release -D GGML_OPENMP=OFF
cmake --build build-arm64-windows-llvm-release
也可以用 MSVC 编译器（build-arm64-windows-MSVC preset）或标准 CMake 指令，但需注意 MSVC 不支持编译 ARM 的内联汇编（如 Q4_0_N_M CPU 加速核心）。
若使用 Ninja 作为生成器且默认使用 clang 编译器，需先设置环境变量，例如：
set LIB=C:\Program Files (x86)\Windows Kits\10\Lib\10.0.22621.0\um\x64;C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.41.34120\lib\x64\uwp;C:\Program Files (x86)\Windows Kits\10\Lib\10.0.22621.0\ucrt\x64
构建命令如下：
cmake --preset x64-windows-llvm-release
cmake --build build-x64-windows-llvm-release
默认启用了 Curl（libcurl 客户端库）功能，如不需要可通过 -DLLAMA_CURL=OFF 关闭。否则需自行安装 libcurl 开发库。

BLAS 构建

启用 BLAS（基础线性代数子程序库，Basic Linear Algebra Subprograms）可提升处理大型批次数据时的推理速度（如批量大于 32，推荐使用 512）。BLAS 不影响文本生成阶段的性能。目前支持多种 BLAS 实现：

Accelerate 框架

仅在 Mac 上可用，且默认启用。按照常规流程构建即可。

OpenBLAS

纯 CPU 的 BLAS 加速，需要在本机预先安装 OpenBLAS。

在 Linux 下用 CMake 构建：

cmake -B build -DGGML_BLAS=ON -DGGML_BLAS_VENDOR=OpenBLAS
cmake --build build --config Release

BLIS

关于 BLIS 请见 BLIS.md。

Intel oneMKL

使用 oneAPI 编译器编译，可让不支持 avx512 的英特尔处理器启用 avx_vnni 指令集。此构建配置不支持英特尔 GPU，如需支持请查阅 llama.cpp for SYCL。

手动安装 oneAPI 后：默认 GGML_BLAS_VENDOR 参数为 Generic。如果你已经加载了 Intel 环境脚本并在 cmake 时设置了 -DGGML_BLAS=ON，则会自动选择 mkl 版 Blas。否则可按如下步骤：

source /opt/intel/oneapi/setvars.sh # 如已在 oneapi-basekit docker 镜像下可跳过，仅手动安装时需要
cmake -B build -DGGML_BLAS=ON -DGGML_BLAS_VENDOR=Intel10_64lp -DCMAKE_C_COMPILER=icx -DCMAKE_CXX_COMPILER=icpx -DGGML_NATIVE=ON
cmake --build build --config Release

使用 oneAPI docker 镜像：如果不想手动设置环境变量和安装 oneAPI，可以在 Intel 官方 docker 容器 oneAPI-basekit 里完成上述操作。

更多可参考：在英特尔CPU上优化和运行LLaMA2。

其他BLAS库

如需使用其他 BLAS 库，请通过 GGML_BLAS_VENDOR 指定。受支持库详见 CMake官方文档。

Metal 构建

在 macOS 上，Metal（苹果自研图形与计算 API）默认开启，利用 Metal 可将运算任务交由 GPU 执行。如果想在编译时关闭 Metal，可在 CMake 命令里加上 -DGGML_METAL=OFF。

如果已启用 Metal 支持（即默认情况），可通过启动参数 --n-gpu-layers 0 显式禁用 GPU 推理。

SYCL

SYCL 是一种高层次的异构计算编程模型，可以提升跨设备（如 CPU、GPU、FPGA 等）开发效率。

llama.cpp 基于 SYCL 的实现用于支持英特尔 GPU（如数据中心 Max 系列、Flex 系列、Arc 系列、集成显卡及 iGPU）。

详细使用说明见 llama.cpp for SYCL。

CUDA

利用 NVIDIA GPU 实现加速。请确保已经安装 CUDA 工具包。

官方下载

请访问 NVIDIA 开发者网站获取 CUDA 安装包。

在 Fedora Toolbox 容器中编译和运行

我们还提供了在 Fedora toolbox 工具箱环境下配置 CUDA 工具包的指南。

推荐场景：

必须用于 Fedora Atomic 桌面系统，如：Silverblue 和 Kinoite
- （这些系统官方不提供 CUDA 软件包）
必须用于主机不在 NVIDIA CUDA 官方支持平台列表的情况
- 例如主机为 Fedora 42 Beta
建议 Fedora Workstation、Fedora KDE Plasma Desktop 用户，希望保持主机系统干净时使用
可选：toolbox 包还可用于 Arch Linux、Red Hat Enterprise Linux >= 8.5、Ubuntu

编译命令

cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release
### 覆盖 CUDA 架构能力（Compute Capability）设置

如果 `nvcc` 不能检测到你的 GPU，可能会出现如下警告：
```text
nvcc warning : Cannot find valid GPU for '-arch=native', default arch is used

此时可以手动指定 CUDA 计算能力：

1. 确认你的 NVIDIA 设备的 `Compute Capability`（计算能力），查看 : “CUDA: 你的 GPU 计算能力”。

例如：

GeForce RTX 4090      8.9
GeForce RTX 3080 Ti   8.6
GeForce RTX 3070      8.6

2. 在 CMake 命令中手动列出需要支持的 `Compute Capability`，用分号 `;` 分隔。

cmake -B build -DGGML_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES="86;89"

CUDA 运行时环境变量

可在运行时设置 CUDA 环境变量。

# 用 CUDA_VISIBLE_DEVICES 隐藏第一个计算设备
CUDA_VISIBLE_DEVICES="-0" ./build/bin/llama-server --model /srv/models/llama.gguf

统一内存（Unified Memory）

在 Linux 下，设置环境变量 GGML_CUDA_ENABLE_UNIFIED_MEMORY=1 可启用 CUDA 统一内存，这意味着当显存耗尽时会自动用系统内存（而不会直接崩溃）。在 Windows 中，此设定可在 NVIDIA 控制面板中通过“系统内存回退”选项实现。

性能调优选项

还可通过以下编译参数进一步优化性能：

选项	可选值	默认值	说明
GGML_CUDA_FORCE_MMQ	布尔值（true/false）	false	强制为量化模型使用自定义矩阵乘法核心，即使没有 int8 张量核心。适用于 V100、CDNA 和 RDNA3+，有 int8 张量核心的 GPU 默认开启。启用后大批次速度下降，但显存占用更低。
GGML_CUDA_FORCE_CUBLAS	布尔值（true/false）	false	强制对量化模型使用 FP16 cuBLAS 库，不用自定义矩阵核心
GGML_CUDA_F16	布尔值（true/false）	false	启用后，CUDA 去量化与乘法、q4_1 和 q5_1 矩阵乘法核心均使用半精度浮点（FP16）运算，适合较新 GPU 提升性能
GGML_CUDA_PEER_MAX_BATCH_SIZE	正整数	128	多 GPU 下，启用 peer access（显存直连）时最大批大小。Peer access 仅限 Linux 或支持 NVLink，开启后能提升大批次下的速度
GGML_CUDA_FA_ALL_QUANTS	布尔值（true/false）	false	为 FlashAttention CUDA 核心编译所有 KV 缓存量化类型。可细粒度控制 KV 缓存，但编译需时更长

MUSA

MUSA 提供对摩尔线程（Moore Threads） GPU 的加速支持。请确保已安装 MUSA SDK。

官方下载

访问摩尔线程开发者中心下载 MUSA SDK。

编译命令

cmake -B build -DGGML_MUSA=ON
cmake --build build --config Release

覆盖计算能力规格

默认启用了全部受支持的 MUSA 计算能力。如需自定义，在 CMake 命令中设置 MUSA_ARCHITECTURES：

cmake -B build -DGGML_MUSA=ON -DMUSA_ARCHITECTURES="21"
cmake --build build --config Release

该配置在编译期间只启用计算能力为 2.1（MTT S80）的设备，可以有效缩短编译时间。

编译选项

大多数适用于 CUDA 的编译选项同样可用于 MUSA，尽管尚未经过全面测试。

如果需要编译为静态库，可以添加 -DBUILD_SHARED_LIBS=OFF 和 -DCMAKE_POSITION_INDEPENDENT_CODE=ON，示例命令如下：

cmake -B build -DGGML_MUSA=ON \
  -DBUILD_SHARED_LIBS=OFF -DCMAKE_POSITION_INDEPENDENT_CODE=ON
cmake --build build --config Release

运行时 MUSA 环境变量

你可以在程序运行时设置 MUSA 环境变量。

例如，以下命令用于屏蔽第一个计算设备（通常设备编号为0）：

MUSA_VISIBLE_DEVICES="-0" ./build/bin/llama-server --model /srv/models/llama.gguf
### 统一内存（Unified Memory）

通过设置环境变量 `GGML_CUDA_ENABLE_UNIFIED_MEMORY=1`，可以在 Linux 系统下启用统一内存。这意味着当 GPU 显存不足时，可以自动使用系统内存（RAM）进行数据交换，避免程序崩溃。

## HIP

HIP 提供基于 AMD GPU 的加速功能（仅支持安装了 ROCm 的设备）。

请先确保已在你的系统中安装 [ROCm 驱动](https://rocm.docs.amd.com/projects/install-on-linux/en/latest/tutorial/quick-start.html#rocm-install-quick)。

### 在 Linux 上使用 CMake（以支持 gfx1030 架构的 AMD GPU 为例）

```bash
HIPCXX="$(hipconfig -l)/clang" HIP_PATH="$(hipconfig -R)" \
    cmake -S . -B build -DGGML_HIP=ON -DAMDGPU_TARGETS=gfx1030 -DCMAKE_BUILD_TYPE=Release \
    && cmake --build build --config Release -- -j 16

如果你的硬件为 RDNA3+ 或 CDNA 架构，为了提升 Flash Attention（闪存注意力，提升推理速度）的性能，可以在编译时加入 -DGGML_HIP_ROCWMMA_FATTN=ON，需要确保系统已经安装了 rocWMMA 库。

默认情况下，如果通过 ROCm 的 rocm 元包（meta package）安装，系统会自动包含 rocWMMA 库。否则，也可以通过包管理器安装 rocwmma-dev 或 rocwmma-devel。

另外，还可以从官方 GitHub 仓库手动克隆源码，并检出相应版本（如 rocm-6.2.4），然后在 CMake 配置中加入 -DCMAKE_CXX_FLAGS="-I<path/to/rocwmma>/library/include/"，即便在 Windows 上这种方式也可用，但 AMD 官方并未对此做支持声明。

注意：

如果编译时出现以下错误提示：
clang: error: cannot find ROCm device library; provide its path via '--rocm-path' or '--rocm-device-lib-path', or pass '-nogpulib' to build without ROCm device library
你可以在 HIP_PATH 路径下，查找包含 oclc_abi_version_400.bc 文件的目录，并将此目录通过 HIP_DEVICE_LIB_PATH 变量加入编译命令开头。例如：
HIPCXX="$(hipconfig -l)/clang" HIP_PATH="$(hipconfig -p)" \
HIP_DEVICE_LIB_PATH=<你的目录路径> \
    cmake -S . -B build -DGGML_HIP=ON -DAMDGPU_TARGETS=gfx1030 -DCMAKE_BUILD_TYPE=Release \
    && cmake --build build -- -j 16

在 Windows 上使用 CMake （需要使用VS的x64原生命令行工具，并假设 GPU 支持 gfx1100）

set PATH=%HIP_PATH%\bin;%PATH%
cmake -S . -B build -G Ninja -DAMDGPU_TARGETS=gfx1100 -DGGML_HIP=ON -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_BUILD_TYPE=Release
cmake --build build
请确保 `AMDGPU_TARGETS` 设置为你希望支持的 GPU 架构。例如上面例子使用的 `gfx1100` 适用于 Radeon RX 7900XTX/XT/GRE。你可以在 [官方文档](https://llvm.org/docs/AMDGPUUsage.html#processors) 查找支持的目标名称。也可通过运行如下命令查询本机 GPU 型号：

```bash
rocminfo | grep gfx | head -1 | awk '{print $2}'

例如，gfx1035 会映射到 gfx1030。

你还可以使用环境变量 HIP_VISIBLE_DEVICES 指定需要使用的 GPU。如果你的 GPU 没有得到官方支持，也可通过设置 HSA_OVERRIDE_GFX_VERSION（如改为 RDNA2 的 gfx1030, gfx1031, 或 gfx1035，或者 RDNA3 的 11.0.0）来兼容。

统一内存

在 Linux 系统下，可以通过设置环境变量 GGML_CUDA_ENABLE_UNIFIED_MEMORY=1 启用统一内存架构（UMA），使 CPU 与集成 GPU 共享主内存。对于非集成型 GPU，启用 UMA 可能会影响性能，仅建议用于集成 GPU 场景。

Vulkan

Windows 平台

w64devkit

下载并解压 w64devkit。

下载并按照默认配置安装 Vulkan SDK。

打开 w64devkit.exe，运行以下命令复制 Vulkan 依赖文件：

SDK_VERSION=1.3.283.0
cp /VulkanSDK/$SDK_VERSION/Bin/glslc.exe $W64DEVKIT_HOME/bin/
cp /VulkanSDK/$SDK_VERSION/Lib/vulkan-1.lib $W64DEVKIT_HOME/x86_64-w64-mingw32/lib/
cp -r /VulkanSDK/$SDK_VERSION/Include/* $W64DEVKIT_HOME/x86_64-w64-mingw32/include/
cat > $W64DEVKIT_HOME/x86_64-w64-mingw32/lib/pkgconfig/vulkan.pc <<EOF
Name: Vulkan-Loader
Description: Vulkan Loader
Version: $SDK_VERSION
Libs: -lvulkan-1
EOF

切换到 llama.cpp 项目目录，使用 CMake 构建：

cmake -B build -DGGML_VULKAN=ON
cmake --build build --config Release

Git Bash MINGW64

下载安装 Git-SCM 并使用默认设置。

下载安装 Visual Studio Community Edition，确保选择了 C++ 相关组件。

下载安装 CMake，保持默认。

下载安装 Vulkan SDK，使用默认设置。

进入 llama.cpp 目录，右键点击选择“Open Git Bash Here”（在此处打开Git Bash），然后执行：

cmake -B build -DGGML_VULKAN=ON
cmake --build build --config Release

此时可以使用 Vulkan 后端加载模型，例如：

build/bin/Release/llama-cli -m "[模型路径]" -ngl 100 -c 16384 -t 10 -n -2 -cnv

MSYS2

安装 MSYS2，然后在 UCRT 终端下执行以下命令安装依赖：

pacman -S git \
    mingw-w64-ucrt-x86_64-gcc \
    mingw-w64-ucrt-x86_64-cmake \
    mingw-w64-ucrt-x86_64-vulkan-devel \
    mingw-w64-ucrt-x86_64-shaderc

切换到 llama.cpp 目录，使用 CMake 构建：

cmake -B build -DGGML_VULKAN=ON
cmake --build build --config Release

使用 Docker

无需单独安装 Vulkan SDK，容器内会自动安装。

# 构建镜像
docker build -t llama-cpp-vulkan --target light -f .devops/vulkan.Dockerfile .

# 运行
docker run -it --rm -v "$(pwd):/app:Z" --device /dev/dri/renderD128:/dev/dri/renderD128 --device /dev/dri/card1:/dev/dri/card1 llama-cpp-vulkan -m "/app/models/YOUR_MODEL_FILE" -p "Building a website can be done in 10 simple steps:" -n 400 -e -ngl 33

非 Docker 环境

请先确保已正确安装 Vulkan SDK。

以 Ubuntu 22.04（jammy）为例，可执行：

wget -qO - https://packages.lunarg.com/lunarg-signing-key-pub.asc | apt-key add -
wget -qO /etc/apt/sources.list.d/lunarg-vulkan-jammy.list https://packages.lunarg.com/vulkan/lunarg-vulkan-jammy.list
apt update -y
apt-get install -y vulkan-sdk
# 校验是否安装成功：
vulkaninfo

部分发行版也可通过包管理器直接安装。例如，Ubuntu 22.04 可安装 libvulkan-dev，Fedora 40 可安装 vulkan-devel、glslc 和 glslang。

随后，使用如下命令构建项目：

cmake -B build -DGGML_VULKAN=1
cmake --build build --config Release
# 测试命令（带 "-ngl 33" 参数以将所有计算层卸载到GPU）
./bin/llama-cli -m "PATH_TO_MODEL" -p "Hi you how are you" -n 50 -e -ngl 33 -t 4

# 你应该能在输出中看到如下一行（表明已检测到GPU）：
# ggml_vulkan: Using Intel(R) Graphics (ADL GT2) | uma: 1 | fp16: 1 | warp size: 32

CANN

CANN 支持利用华为昇腾（Ascend NPU）AI 核进行加速，CANN 是分层 API，可帮助开发者基于 Ascend NPU 快速构建 AI 应用和服务。

如需了解更多 Ascend NPU 相关信息，请访问 Ascend 社区。

请确保已经安装 CANN 工具包。可前往 CANN Toolkit 下载。

在 llama.cpp 目录下使用如下命令进行编译：

cmake -B build -DGGML_CANN=on -DCMAKE_BUILD_TYPE=release
cmake --build build --config release

可通过如下命令测试：

./build/bin/llama-cli -m PATH_TO_MODEL -p "Building a website can be done in 10 steps:" -ngl 32

如果屏幕输出如下信息，则说明已成功使用 CANN 后端：

llm_load_tensors:       CANN model buffer size = 13313.00 MiB
llama_new_context_with_model:       CANN compute buffer size =  1260.81 MiB

更多关于模型/设备支持、CANN 安装等细节，请参阅 llama.cpp for CANN。

Arm® KleidiAI™

KleidiAI 是专门为 Arm CPU 优化的 AI 微内核库。它可以通过微内核提升 ARM 架构下的 AI 工作负载性能，可在 llama.cpp 的 CPU 后端中启用。

在 llama.cpp 目录下，通过 CMake 启用 KleidiAI：

cmake -B build -DGGML_CPU_KLEIDIAI=ON
cmake --build build --config Release

通过如下命令验证 KleidiAI 是否启用：

./build/bin/llama-cli -m PATH_TO_MODEL -p "What is a car?"

如果启用 KleidiAI，输出内容将类似：

load_tensors: CPU_KLEIDIAI model buffer size = 3474.00 MiB KleidiAI 的微内核会利用 Arm CPU 的特性（如 dotprod、int8mm、SME）进行高效张量运算。llama.cpp 会根据 CPU 的实时特征自动选择最优微内核。但如果你的平台支持 SME，需要手动设置环境变量 GGML_KLEIDIAI_SME=1 以启用相应功能。

注意：

某些编译目标下，其他高优先级后端（如 GPU 后端）可能会默认启用。若需要强制使用 CPU 后端，请在编译时关闭高优先级后端（如 -DGGML_METAL=OFF），或运行时使用 --device none。

OpenCL

OpenCL 后端可通过近代 Adreno GPU（高通芯片）实现 GPU 加速。更多详细信息可见OPENCL.md。

Android 平台

假设你已经将 NDK 路径设置为 $ANDROID_NDK。首先，安装 OpenCL 头文件和ICD loader库（如果尚未安装）：

mkdir -p ~/dev/llm
cd ~/dev/llm

git clone https://github.com/KhronosGroup/OpenCL-Headers && \
cd OpenCL-Headers && \
cp -r CL $ANDROID_NDK/toolchains/llvm/prebuilt/linux-x86_64/sysroot/usr/include

cd ~/dev/llm

git clone https://github.com/KhronosGroup/OpenCL-ICD-Loader && \
cd OpenCL-ICD-Loader && \
mkdir build_ndk && cd build_ndk && \
cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK/build/cmake/android.toolchain.cmake \
  -DOPENCL_ICD_LOADER_HEADERS_DIR=$ANDROID_NDK/toolchains/llvm/prebuilt/linux-x86_64/sysroot/usr/include \
  -DANDROID_ABI=arm64-v8a \
  -DANDROID_PLATFORM=24 \
  -DANDROID_STL=c++_shared && \
ninja && \
cp libOpenCL.so $ANDROID_NDK/toolchains/llvm/prebuilt/linux-x86_64/sysroot/usr/lib/aarch64-linux-android

然后启用 OpenCL 构建 llama.cpp：

cd ~/dev/llm

git clone https://github.com/ggml-org/llama.cpp && \
cd llama.cpp && \
mkdir build-android && cd build-android

cmake .. -G Ninja \
  -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK/build/cmake/android.toolchain.cmake \
  -DANDROID_ABI=arm64-v8a \
  -DANDROID_PLATFORM=android-28 \
  -DBUILD_SHARED_LIBS=OFF \
  -DGGML_OPENCL=ON

ninja

Windows Arm64

首先，安装 OpenCL 头文件与 ICD loader 库（如果尚未安装）：

mkdir -p ~/dev/llm

cd ~/dev/llm
git clone https://github.com/KhronosGroup/OpenCL-Headers && cd OpenCL-Headers
mkdir build && cd build
cmake .. -G Ninja `
  -DBUILD_TESTING=OFF `
  -DOPENCL_HEADERS_BUILD_TESTING=OFF `
  -DOPENCL_HEADERS_BUILD_CXX_TESTS=OFF `
  -DCMAKE_INSTALL_PREFIX="$HOME/dev/llm/opencl"
cmake --build . --target install

cd ~/dev/llm
git clone https://github.com/KhronosGroup/OpenCL-ICD-Loader && cd OpenCL-ICD-Loader
mkdir build && cd build
cmake .. -G Ninja `
  -DCMAKE_BUILD_TYPE=Release `
  -DCMAKE_PREFIX_PATH="$HOME/dev/llm/opencl" `
  -DCMAKE_INSTALL_PREFIX="$HOME/dev/llm/opencl"
cmake --build . --target install

接下来，启用 OpenCL（开放计算语言）支持并编译 llama.cpp：

cmake .. -G Ninja `
  -DCMAKE_TOOLCHAIN_FILE="$HOME/dev/llm/llama.cpp/cmake/arm64-windows-llvm.cmake" `
  -DCMAKE_BUILD_TYPE=Release `
  -DCMAKE_PREFIX_PATH="$HOME/dev/llm/opencl" `
  -DBUILD_SHARED_LIBS=OFF `
  -DGGML_OPENCL=ON
ninja

安卓平台（Android）

如需了解如何在安卓平台构建，请点击这里查看详细文档。

关于GPU加速后端的说明

即使使用 -ngl 0 选项，某些计算过程仍可能使用GPU（图形处理器）加速。如果你希望完全禁用GPU加速，请添加参数 --device none。

在大多数情况下，您可以同时编译并使用多个后端（例如，CUDA 和 Vulkan）。只需在配置CMake时增加参数 -DGGML_CUDA=ON -DGGML_VULKAN=ON 即可。例如：

代码示例：

cmake .. -DGGML_CUDA=ON -DGGML_VULKAN=ON

运行时可以通过 --device 参数指定使用的后端设备。要查看所有可用设备，请使用 --list-devices 选项：

代码示例：
./main --list-devices

后端也可以构建为动态库（动态链接库），实现运行时按需加载。这意味着同一个 llama.cpp 可执行文件可以在不同 GPU 设备的机器上运行，自动适配相应环境。要启用该功能，请在构建时使用 GGML_BACKEND_DL 选项。

注意：

构建和运行时选择适合自己硬件的后端，可大幅提升推理速度和运行效率。对于初学者，建议先尝试单一后端，确认环境配置无误后再尝试多后端或动态库加载等高级功能。

CPU 版本构建​

BLAS 构建​

Accelerate 框架​

OpenBLAS​

BLIS​

Intel oneMKL​

其他BLAS库​

Metal 构建​

SYCL​

CUDA​

官方下载​

在 Fedora Toolbox 容器中编译和运行​

编译命令​

1. 确认你的 NVIDIA 设备的 Compute Capability（计算能力），查看 : “CUDA: 你的 GPU 计算能力”。​

2. 在 CMake 命令中手动列出需要支持的 Compute Capability，用分号 ; 分隔。​

CUDA 运行时环境变量​

统一内存（Unified Memory）​

性能调优选项​

MUSA​

官方下载​

编译命令​

覆盖计算能力规格​

编译选项​

运行时 MUSA 环境变量​

在 Windows 上使用 CMake （需要使用VS的x64原生命令行工具，并假设 GPU 支持 gfx1100）​

统一内存​

Vulkan​

w64devkit​

Git Bash MINGW64​

MSYS2​

使用 Docker​

非 Docker 环境​

CANN​

Arm® KleidiAI™​

OpenCL​

Android 平台​

Windows Arm64​

安卓平台（Android）​

关于GPU加速后端的说明​

CPU 版本构建

BLAS 构建

Accelerate 框架

OpenBLAS

BLIS

Intel oneMKL

其他BLAS库

Metal 构建

SYCL

CUDA

官方下载

在 Fedora Toolbox 容器中编译和运行

编译命令

1. 确认你的 NVIDIA 设备的 `Compute Capability`（计算能力），查看 : “CUDA: 你的 GPU 计算能力”。

2. 在 CMake 命令中手动列出需要支持的 `Compute Capability`，用分号 `;` 分隔。

CUDA 运行时环境变量

统一内存（Unified Memory）

性能调优选项

MUSA

官方下载

编译命令

覆盖计算能力规格

编译选项

运行时 MUSA 环境变量

在 Windows 上使用 CMake （需要使用VS的x64原生命令行工具，并假设 GPU 支持 gfx1100）

统一内存

Vulkan

w64devkit

Git Bash MINGW64

MSYS2

使用 Docker

非 Docker 环境

CANN

Arm® KleidiAI™

OpenCL

Android 平台

Windows Arm64

安卓平台（Android）

关于GPU加速后端的说明