Eu costumava pensar que o ROCm da AMD era um pesadelo para fazer funcionar. Eu estava errado. Consegui colocar o ROCm para rodar em menos de um dia com esforço mínimo, apenas pesquisando no Google. Assim como a NVIDIA, ele é agnóstico em relação à distribuição, mesmo que falte maturidade.

Então eu conheci a stack de IA da Intel. Minha definição de “pesadelo” foi oficialmente atualizada.

Levei quase uma semana para fazer o OpenVINO com llama.cpp funcionar no Gentoo. O software sofre de um caso grave de “Ubuntunitis” — a crença delirante de que o Ubuntu é a única distribuição existente no universo. Esse é o selo de empresas com zero estratégia real e séria de Linux; empresas que tratam o Linux como se fosse Windows, demonstrando uma total falta de disposição para aprender como o desenvolvimento de software para o Linux realmente funciona.

A experiência é um inferno. A Intel espalhou sua stack de software de IA por dezenas de repositórios diferentes. Para piorar, cada componente exige uma correspondência de versões perfeita e frágil para funcionar. Não consigo entender por que criaram essa bagunça. O fato de estarem trabalhando nisso há quase uma década e o software ainda parecer de qualidade beta é revoltante.

Eu tenho o hardware, então vou fazê-lo funcionar. No entanto, devido ao caos absoluto de incompatibilidade de versões, estas instruções podem estar obsoletas no momento em que você as ler. Use isto como um guia geral, não como uma garantia.

E sim, eles fornecem o OpenVINO via Docker. Se você valoriza sua sanidade, faça isso. Este guia é, essencialmente, um conto de advertência para futuros mantenedores de pacotes em outras distribuições, para que vejam quão medíocre é a experiência de instalação nativa.

1. Instale o toolkit oneAPI

Primeiro, baixe o toolkit Intel oneAPI. Você deve selecionar o instalador offline para Linux (offline installer for Linux).

Execute o instalador offline com o seguinte comando. Recomenda-se instalar todos os componentes, exceto o Intel VTune Profiler.

sh ./intel-oneapi-toolkit-2026.1.0.192_offline.sh

2. Configure o Compilador (GCC 13)

A stack da Intel é extremamente exigente com as versões do compilador. Atualmente, ela se recusa a compilar com qualquer versão superior ao GCC 13.

Instale o GCC 13 como um pacote oneshot:

emerge --oneshot sys-devel/gcc:13

Nota para CPUs Heterogêneas: Se você estiver usando uma CPU com núcleos de Performance (P) e de Eficiência (E), o GCC 13 pode falhar na compilação. Para evitar problemas, utilize as seguintes flags para mirar em uma arquitetura x86-64 genérica:

USE="-ada -sanitize -fortran" CFLAGS="-march=x86-64" CXXFLAGS="-march=x86-64" emerge --oneshot sys-devel/gcc:13

Após a instalação, defina o GCC 13 como o padrão do sistema usando o gcc-config. Encontre o número do índice para x86_64-pc-linux-gnu-13 e aplique-o:

gcc-config -l
# Exemplo: se o índice for 4
gcc-config 4
source /etc/profile

3. Configure o caminho do PKG_CONFIG

O Gentoo não inclui o caminho das bibliotecas locais no PKG_CONFIG_PATH por padrão. É necessário exportá-lo manualmente para garantir que o sistema de build encontre os componentes instalados:

export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/usr/local/lib64/pkgconfig/

4. Compile o Level-Zero

Clone a versão específica do carregador Level-Zero, configure-o com CMake e instale-o.

git clone --branch v1.27.0 --single-branch --depth 1 https://github.com/oneapi-src/level-zero.git
cd level-zero
cmake -B build -S . -DCMAKE_BUILD_TYPE=Release
cmake --build build --target install --parallel

5. Compile o IGCS (Intel Graphics Compiler Shim)

Clone e compile o componente IGCS.

git clone --branch V0.9.5 --single-branch --depth 1 https://github.com/intel/igsc.git
cmake -B build -S . -DCMAKE_BUILD_TYPE=Release
cmake --build build --target install --parallel

6. Compile o Intel Graphics Compiler (IGC)

Este passo é complexo pois exige um ecossistema específico de dependências. É necessário clonar vários repositórios com revisões exatas para garantir a compatibilidade: LLVM, OpenCL-Clang, SPIRV-LLVM e diversas ferramentas/headers de SPIRV.

Após clonar os repositórios, compile o IGC:

# [Bloco massivo de comandos git clone para as dependências]
cmake -B build -S ../igc -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DCMAKE_BUILD_TYPE=Release -Wno-dev
cmake --build build --target install --parallel 20

7. Compile o GMMlib

Compile a biblioteca Intel Graphics Memory Management.

git clone --branch intel-gmmlib-22.9.0 --single-branch --depth 1 https://github.com/intel/gmmlib.git
cd gmmlib
cmake -B build -S . -DCMAKE_BUILD_TYPE=Release
cmake --build build --target install --parallel

8. Compile o OpenCV 4.13

O OpenCV deve ser compilado com flags específicas para suportar SYCL, TBB e oneDNN.

git clone --revision=4.13.0 --single-branch --depth 1 https://github.com/opencv/opencv.git
cd opencv
cmake -B build -S . -DWITH_SYCL=ON -DWITH_TBB=ON -DWITH_ONEDNN=ON -DWITH_IPP=ON
cmake --build build --target install --parallel 20

9. Compile o Compute Runtime (Neo)

Clone o runtime de computação Neo. Será necessário editar manualmente os arquivos CMake para corrigir os caminhos de diretório do IGC e GMMlib.

Edite neo/cmake/find_igc.cmake e neo/cmake/find_gmmlib.cmake. Nas linhas 23 e 24, modifique a lógica para tratar o diretório lib64:

if(IS_DIRECTORY "${IGC_DIR}/lib64/pkgconfig/")
set(__tmp_LIBDIR "lib64")

Em seguida, compile e instale:

git clone --branch 26.05.37020.3 --single-branch --depth 1 --recurse-submodules https://github.com/intel/compute-runtime neo
cmake -B build -S . -DCMAKE_BUILD_TYPE=Release -DNEO_SKIP_UNIT_TESTS=1 -DIGC_DIR="/usr/local/" -DGMM_DIR="/usr/local/"
cmake --build build --target install --parallel 20

10. Compile o OpenVINO

Clone o repositório do OpenVINO. É necessário mover manualmente os cabeçalhos OpenCL para o diretório do sistema para evitar erros de compilação.

git clone --branch 2026.2.1 --single-branch --depth 1 --recurse-submodules https://github.com/openvinotoolkit/openvino.git

# Migração manual de cabeçalhos
cp /home/fbugno/bin/local_installs/openvino/thirdparty/ocl/clhpp_headers/include/CL/cl2.hpp /usr/include/CL/
cp /home/fbugno/bin/local_installs/openvino/thirdparty/ocl/clhpp_headers/include/CL/opencl.hpp /usr/include/CL/

# Configuração e build
git config --global --add safe.directory /home/fbugno/bin/local_installs/intel_ai/openvino/thirdparty/level_zero/level-zero
cmake -B build -S . -DCMAKE_INSTALL_PREFIX=/opt/intel/openvino -DENABLE_INTEL_CPU=ON -DENABLE_INTEL_GPU=ON -DENABLE_INTEL_NPU=ON -DENABLE_WHEEL=OFF -DENABLE_PYTHON=OFF -DOpenCV_DIR=/usr/local/lib64/cmake/opencv4
cmake --build build --target install --parallel 20

11. Compile o oneTBB

Compile a biblioteca Threading Building Blocks com um prefixo de instalação personalizado.

git clone --depth 1 --branch v2022.3.0 https://github.com/oneapi-src/oneTBB
cd oneTBB
cmake -S . -B build -DCMAKE_INSTALL_PREFIX=/opt/intel/onetbb -DCMAKE_BUILD_TYPE=Release -DTBB_TEST=OFF -DTBB_STRICT=OFF
cmake --build build --target install --parallel 20
ldconfig

12. Compile o Driver NPU

Para compilar o driver NPU, você deve primeiro carregar as variáveis de ambiente do OpenVINO e atualizar o PKG_CONFIG_PATH. Note que o git-lfs é obrigatório para esta etapa.

source /opt/intel/openvino/setupvars.sh
export PKG_CONFIG_PATH=/opt/intel/onetbb/lib64/pkgconfig:/usr/local/lib64/pkgconfig/:$PKG_CONFIG_PATH
git clone --branch v1.33.0 --single-branch --depth 1 --recurse-submodules https://github.com/intel/linux-npu-driver.git
cd linux-npu-driver
cmake -B build -S . -DENABLE_NPU_COMPILER_BUILD=ON -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DCMAKE_BUILD_TYPE=Release -DENABLE_OPENVINO_PACKAGE=OFF -Wno-dev
cmake --build build --target install --parallel 20

Validação: Você pode verificar a instalação executando os testes do NPU UMD:

cd validation
mkdir -p models/add_abc
curl -o models/add_abc/add_abc.xml https://raw.githubusercontent.com/openvinotoolkit/openvino/master/src/core/tests/models/ir/add_abc.xml
touch models/add_abc/add_abc.bin
npu-umd-test --config ./umd-test/configs/basic.yaml

13. Compile o llama.cpp

É possível compilar o llama.cpp utilizando o backend OpenVINO ou o backend SYCL.

Para suporte ao OpenVINO:

git clone --branch b9993 --single-branch --depth 1 https://github.com/ggml-org/llama.cpp.git
source /opt/intel/openvino/setupvars.sh
cmake -B build -S . -DCMAKE_INSTALL_PREFIX=/opt/intel/llama.cpp -DGGML_OPENVINO=ON -DCMAKE_BUILD_TYPE=Release -Wno-dev
cmake --build build --parallel 20

Para suporte ao SYCL:

source /opt/intel/oneapi/setvars.sh
cmake -B build -S . -DCMAKE_C_COMPILER=icx -DCMAKE_CXX_COMPILER=icpx -DGGML_SYCL=ON -DGGML_SYCL_F16=ON -DCMAKE_BUILD_TYPE=Release -Wno-dev
cmake --build build --parallel 20

14. Compile o OVMS (OpenVINO Model Server)

git clone https://github.com/openvinotoolkit/model_server.git
git checkout v2026.2.1

Resumo de Dependências

Para suporte a receitas futuras, certifique-se de que os seguintes pacotes do Gentoo estejam instalados: sys-devel/gcc, dev-util/cmake, dev-util/ninja, dev-util/pkgconf, dev-vcs/git, dev-vcs/git-lfs, dev-util/patchelf, dev-cpp/tbb, dev-libs/pugixml, app-arch/snappy, dev-libs/rapidjson, dev-libs/flatbuffers, dev-libs/nlohmann_json, dev-libs/ocl-icd, dev-util/opencl-headers, media-libs/libva, dev-lang/python, dev-python/pip, dev-python/pybind11, dev-libs/libffi.

Resultados de Testes

Ao executar modelos na GPU ou NPU, utilize as seguintes variáveis de ambiente:

export GPU_ENABLE_LARGE_ALLOCATIONS=1
export GGML_OPENVINO_STATEFUL_EXECUTION=1
export GGML_OPENVINO_DEVICE=NPU

Notas de Desempenho/Estabilidade:

  • A maioria dos modelos (Qwen, GLM, Gemma, etc.): Falhou.
  • DevQuasar/Goekdeniz-Guelmez_Josiefied-Qwen3-8B: Funcionou (11 tokens/s) com janela de contexto de 25k e execução stateful.
  • saidutta69/Mistral-7B-Instruct-v0.3: Funcionou na NPU com tamanho de contexto abaixo de 10k.

Conclusão

O OpenVINO Model Server via Docker continua sendo a escolha superior para CPUs Intel. Por uma margem enorme.