Introdução

O Intel® Linux NPU Driver vem se consolidando como a base de software para explorar o potencial das NPUs embarcadas nos Intel Core Ultra (Meteor Lake, Arrow Lake, Lunar Lake e afins). A versão 1.24.0 marcou um ponto importante dessa evolução: além de atualizar firmware e componentes internos, trouxe melhorias de desempenho, estabilidade e segurança que começaram a aparecer em tutoriais e notícias da comunidade Linux. Nessa release, a Intel atualizou o Level Zero, o compilador e o firmware, além de fazer ajustes no próprio utilitário de testes da UMD, sempre mantendo a compatibilidade com o driver de kernel “intel_vpu” (que ainda carrega o nome histórico de VPU, apesar do hardware ser uma NPU).

A versão 1.26.0, lançada em 26 novembro de 2025, chega como continuidade desse trabalho, mas já com um ecossistema bem mais maduro em torno do conceito de “AI PC”. Segundo o LinuxCompatible, o 1.26.0 foi validado em várias combinações de Intel Core Ultra + Ubuntu (22.04/24.04/24.10/25.04) com kernels recentes e firmwares específicos, mantendo o alinhamento com Level Zero 1.24.2, OpenVINO 2025.3 e um compilador NPU atualizado (npu_ud_2025_44_rc1). Isso significa que, ao instalar o linux-npu-driver a partir do código-fonte ou via pacotes, você está plugando sua máquina em uma stack validada para workloads de IA eficientes em energia, pensada para executar redes neurais diretamente na NPU sem sobrecarregar CPU ou GPU.

Stack de software do Intel® NPU Driver

O repositório intel/linux-npu-driver hospeda o driver de espaço de usuário para o dispositivo Intel® NPU, um acelerador de inferência embarcado nos Intel Core Ultra. No Linux, a pilha é dividida em duas grandes camadas:

1. Driver de kernel – o módulo intel_vpu (IVPU) já está integrado ao kernel e é responsável por expor o dispositivo como /dev/accel/accel0 (ou similar), gerenciar o firmware e integrar com a infraestrutura de DRM/accel.
2. Stack de user-space – é o foco deste projeto: bibliotecas de user mode driver (UMD), implementações de oneAPI Level Zero para a NPU, compilador de modelos (NPU compiler) e ferramentas de validação, como o npu-umd-test.

Do ponto de vista das aplicações, você normalmente não conversa diretamente com o driver: quem faz isso é o framework de IA. Ferramentas como o OpenVINO usam o plugin “NPU” e, por baixo dos panos, dependem dessa stack para compilar o modelo (via compilador NPU) e enviar comandos ao hardware usando Level Zero. É aqui que o driver entra como peça crítica: se a combinação driver + firmware + compilador + Level Zero não estiver correta, a aplicação não enxerga a NPU ou sofre quedas de desempenho. Releases como 1.24.0 e 1.26.0 alinham todas essas versões, garantindo que quando você compilar um modelo para NPU, o binário gerado seja compatível com o firmware embarcado e com a versão do driver instalada no sistema.

Compilando e instalando o linux-npu-driver a partir do código-fonte

Abaixo está o fluxo básico para compilar e instalar o driver a partir do repositório oficial:

git clone https://github.com/intel/linux-npu-driver
cd linux-npu-driver
git submodule update --init --recursive

cmake -B build -S . \
  -DENABLE_NPU_COMPILER_BUILD=ON \
  -DCMAKE_CXX_FLAGS="-fcf-protection=none" \
  -DCMAKE_C_FLAGS="-fcf-protection=none"

cmake --build build --parallel $(nproc)
sudo cmake --install build

Comentando passo a passo:

1. git clone
   Baixa o código-fonte da versão atual do driver, incluindo UMD, compilador, firmware e ferramentas.
2. git submodule update --init --recursive
   O projeto depende de vários submódulos (por exemplo, componentes como vpux_elf e partes do compilador). Esse comando garante que todo o código necessário seja trazido junto, o que é essencial para builds offline e para empacotamento em distribuições.
3. Comando cmake -B build -S . ...
   • Cria um diretório de build fora da árvore de fontes (build).
   • Ativa a construção do compilador NPU (ENABLE_NPU_COMPILER_BUILD=ON).
   • Desabilita o -fcf-protection nas flags C/C++, o que é útil em toolchains que não reconhecem essa opção (como alguns GCC empacotados em distros específicas).
   • Nessa etapa, o CMake verifica dependências, configura caminhos, escolhe opções de compilação e gera os arquivos de projeto/Makefiles.
4. cmake --build build --parallel $(nproc)
   Compila o projeto usando todos os núcleos disponíveis. Isso gera as bibliotecas de UMD, o compilador, os binários de teste e demais artefatos necessários.
5. sudo cmake --install build
   Instala os artefatos gerados nos prefixos configurados (tipicamente /usr ou /usr/local), registrando as libs, o compilador e as ferramentas como npu-umd-test no sistema.

Em ambientes de produção (ou empacotamento para distro), é comum encapsular esse fluxo em um spec de RPM, .deb ou snap, como fez a Canonical no intel-npu-driver snap.

Validando o driver com o comando npu-umd-test

Depois de instalar o driver, é fundamental validar se a NPU está realmente funcional. Para isso existe a aplicação de teste do user mode driver, hoje chamada npu-umd-test (o prefixo antigo era vpu-umd-test, renomeado nas versões mais recentes do driver).GitHub+1

Nos pacotes em snap (intel-npu-driver), a Canonical documenta um fluxo bem claro que vale como referência também para instalações manuais:GitHub

Garantir permissões de acesso ao dispositivo
A NPU costuma aparecer como /dev/accel/accel0 associado ao módulo intel_vpu. Antes de rodar o teste sem ser root, o usuário precisa estar no grupo render e o nó de dispositivo precisa ter permissões adequadas:

sudo usermod -a -G render $USER   # depois faça logout/login
sudo chown root:render /dev/accel/accel0
sudo chmod g+rw /dev/accel/accel0

Ver o help e opções disponíveis

Em instalações via snap, o binário é exposto como app do snap:

intel-npu-driver.npu-umd-test --help

Em uma instalação “pura” a partir do código-fonte, o binário normalmente estará em um diretório padrão de executáveis (por exemplo /usr/bin/npu-umd-test), então:

npu-umd-test --help

Executar a bateria de testes
O npu-umd-test roda um conjunto de testes que exercitam o Level Zero da NPU, o compilador e o fluxo de envio de comandos ao hardware. Na própria documentação do snap, eles mostram resultados típicos como “200/209 testes passando” em diversas combinações de kernel/Ubuntu, com alguns testes marcados como “skipped” por dependências opcionais (GPU, DMA heap, métricas de uso, etc.).

Entender o papel do npu-umd-test no seu fluxo

• Se todos (ou quase todos) os testes passam, significa que driver de kernel, firmware, UMD, Level Zero e compilador estão conversando corretamente.
• Se vários testes falham, é um indicativo de versão incompatível de firmware, kernel sem suporte ou configuração incorreta de permissões/dispositivos.
• Em ambientes de empacotamento (RPM, DEB, snap, flatpak), é comum usar o npu-umd-test como smoke test automatizado de pós-instalação.

Em resumo, o npu-umd-test é o seu “check-up” oficial da NPU: se ele está feliz, as chances de seu pipeline OpenVINO ou outro framework de IA rodar liso na NPU são muito maiores.