Npunlock roda kernels C customizados nas NPUs Intel Core Ultra

O que a Intel não abriu

As NPUs dos Intel Core Ultra (Meteor Lake) carregam núcleos programáveis chamados ACT-SHAVE, mas a pilha de software oficial da Intel só aceita operações compostas a partir de um conjunto fechado de blocos suportados pelo compilador de grafos. Não existe um fluxo público para o desenvolvedor entregar sua própria implementação em C para rodar nesses núcleos. É essa lacuna que o npunlock, projeto do desenvolvedor hsfzxjy, reconstrói via engenharia reversa: o caminho que vai de código C escrito à mão até um kernel executável na NPU.

Segundo o README do repositório, o projeto mantém o compilador e o driver da Intel para o grafo e a execução no hardware ao redor, mas abre uma porta lateral só para as operações customizadas compatíveis. Não é um driver alternativo nem um substituto do OpenVINO: o npunlock emite IR em formato OpenVINO para o driver Intel instalado normalmente, só que injeta nele um kernel escrito pelo próprio desenvolvedor.

Como o kernel chega na NPU

O fluxo documentado combina Python↳Python56 conteúdosVSCode + Python + Alexa: Desenvolva e teste skills para alexa localmente com pythonDev (Back & Front) · out 2025Dominando decoradores em Python: um guia completo com exemplosDev (Back & Front) · jan 2025Desenvolvimento de software: diferenças entre Python, JavaScript e JavaGestão Dev & TI · nov 2024Ver tudo em Dev (Back & Front) →, C e uma tensor ABI própria. Um exemplo completo do repositório implementa a função de ativação GELU em FP32 embutindo o kernel C direto como string dentro do script Python:

import numpy as np
import npunlock as npu

npu.configure(movi_dll_dir=r"C:\path\to\MVC_DEPEND")

gelu_c: bytes = b"""
#define MLIBM_DEFINE_LINK_COMPAT 1
#include <npunlock/npu3720_kernel.h>

void controlled_act(unsigned layerParams) {
    act_abi_invocation invocation;
    ACT_ABI_LOAD_INVOCATION32_OR_RETURN(layerParams, invocation);
    const float *in = ACT_ABI_INPUT_PTR32(const float, invocation, 0u);
    float *out = ACT_ABI_OUTPUT_PTR32(float, invocation, 1u);
    const float SQRT_2_DIV_PI = 0.7978845608028654f;
    for (unsigned i = 0; i < invocation.element_count; ++i) {
        float x = in[i];
        float w = x + 0.044715f * x * x * x;
        w = tanhf(w * SQRT_2_DIV_PI);
        out[i] = 0.5f * x * (1.0f + w);
    }
}
"""

x = npu.input("x", shape=(1, 2048), dtype="f32")
y = npu.custom(x, source=gelu_c, carrier="Abs", _name="y")
program = npu.compile(npu.Graph(inputs=[x], outputs=[y], name="gelu_f32_example"))

O header npunlock/npu3720_kernel.h, incluído no projeto, fornece as macros de invocação e os helpers de endereço de tensor específicos da NPU3720. Segundo a documentação, o toolchain MoviTools testado disponibiliza boa parte das funções convencionais da libm para os kernels sem precisar incluir , o que permite chamar tanhf diretamente dentro do C compilado para o acelerador.

A peça que falta: o toolchain MoviTools

Aqui está o ponto mais delicado do projeto para quem quiser reproduzir o setup no Brasil. A compilação do C customizado depende do MoviTools MVC_DEPEND, toolchain da Intel/Movidius que o npunlock não redistribui nem baixa automaticamente. O README indica que uma cópia funcional foi encontrada dentro de um pacote de driver legado da Lenovo (versão 31.0.100.1688) e orienta extrair só o payload MVC_DEPEND desse pacote, com um aviso explícito: não instalar nem fazer downgrade para esse driver, apenas aproveitar o MoviTools embutido nele. O passo a passo com hash de verificação e comando de extração fica documentado na página Getting MoviTools do próprio repositório.

É um detalhe que muda a complexidade prática de adotar a ferramenta: não basta pip install, é preciso caçar um instalador de driver antigo, extrair um diretório específico dele e apontar o npunlock para lá via variável de ambiente (NPUNLOCK_MOVITOOLS_DIR) antes de rodar qualquer exemplo.

O que já roda e o que ainda não

O próprio autor lista, no README, o escopo verificado até 23 de setembro de 2026:

• compilar C escrito pelo usuário para código de máquina ACT-SHAVE;
• rodar kernels customizados dentro de grafos de NPU Intel;
• kernels unários e binários densos estáticos em FP16, e um caminho unário verificado em FP32;
• um mesmo grafo executando ramos independentes FP32-unário e FP16-binário simultaneamente (o "latest breakthrough" datado de hoje no repositório, que exigiu tratar manualmente a reordenação de branches feita pelo compilador da Intel via um preflight de grupos ACT);
• funções matemáticas não lineares como GELU e tanhf;
• buffers de entrada e saída compartilhados entre host e NPU, compatíveis com NumPy;
• APIs em Python, linha de comando e C nativo.

Do lado das limitações, o suporte é experimental e restrito a Windows x64, hardware Meteor Lake / NPU3720, formas estáticas, carriers ACT compatíveis e layouts de tensor conhecidos. Grupos de conversão mista conectados ainda não são descobertos automaticamente via patch: o exemplo misto verificado usa ramos independentes, não uma cadeia de conversão. Nenhuma outra geração de NPU Intel foi validada até o momento.

Chamado aberto: Linux e NPUs mais novas

O repositório pede explicitamente ajuda de quem tiver hardware fora do escopo testado. Duas hipóteses aparecem descritas como promissoras, mas não validadas: um grafo NPU3720 já compilado no Windows poderia rodar em Linux↳Linux34 conteúdosKali Linux em um Servidor VPS: como, quando e por que usar?DevSecOps · dez 2024Construindo um Windows Service ou Linux Daemon com Worker Service & .NET Core – Parte 2Dev (Back & Front) · jul 2020Criando uma WebApi utilizando .NET, Linux e VSCodeDev (Back & Front) · ago 2019Ver tudo em DevSecOps →, já que é o firmware da NPU que executa o código de máquina customizado (o obstáculo seria carregar as DLLs Windows do MoviTools em Linux); e NPUs mais novas da Intel poderiam executar a mesma imagem SHAVE 3720xx, ou ter um pacote de driver OEM antigo equivalente com componentes MoviTools compatíveis. Ambas as rotas exigem validação em hardware real, registro de versões de driver/firmware e comparação de saída contra um oráculo rodando no host, conforme o guia Porting to Linux and newer NPUs do projeto.

Por que isso importa para quem programa no Brasil

Notebooks com Intel Core Ultra e NPU já circulam no mercado brasileiro, mas até aqui essa unidade ficava reservada a cargas de inferência que passavam pelo compilador de grafos da Intel via OpenVINO, sem espaço para lógica customizada. O npunlock, sob licença Apache 2.0, é uma via alternativa para quem quer aproveitar esse acelerador dedicado para operações fora do catálogo suportado oficialmente, seja em pipelines de inferência de modelos, seja em processamento de sinal ou qualquer carga que se beneficie de kernels sob medida. O próprio autor deixa claro no README que o trabalho de engenharia reversa, os experimentos e as conclusões técnicas vieram de trabalho manual: "I did use AI↳Inteligência artificial440 conteúdosUX e IA: Transformando Experiências Digitais com Inteligência ArtificialProduto & UX · jan 2025MCP: O que é e por que você vai ouvir falar disso em breve?AI · jul 2025IA generativa e a urgência de reconstruir nossa relação com a verdadeAI · jun 2025Ver tudo em AI → while building this project [...] for scaffolding, repetitive implementation work, converting my reverse-engineered results into organized documentation, and fixing my English. The reverse engineering, experiments, debugging, and technical conclusions came from hands-on work."

Para quem quiser reproduzir, o caminho realista hoje é: máquina Windows x64 com Meteor Lake e NPU3720, Python 3.10 ou superior, CMake 3.24+ com MSVC para build a partir do código-fonte, e o trabalho manual de extrair o MoviTools de um pacote de driver Lenovo legado sem instalá-lo. É experimental, restrito a uma única geração de NPU e a formas estáticas de tensor, mas é o primeiro caminho documentado publicamente para colocar C compilado dentro do acelerador de hardware que, até então, só recebia grafos prontos.

Fonte: Hacker News