Você provavelmente aprendeu que um computador roda um kernel por vez. Essa regra parece tão básica no ecossistema de sistemas operacionais quanto uma máquina ter processador e memória. O projeto Multikernel, no entanto, decidiu quebrar essa premissa e tornar possível que um único computador físico execute vários kernels independentes simultaneamente.
Lançada em 17 de novembro de 2026 pelo desenvolvedor Cong Wang, a versão mklinux v7.0-mk5 traz um marco importante para o projeto. O suporte, que antes focava na arquitetura x86_64, agora engloba oficialmente processadores ARM64 (AArch64), abrindo caminho para testes em infraestruturas modernas de servidores e edge computing.
A ideia central desafia o modelo mental tradicional. Não estamos falando de máquinas virtuais, nem de containers, nem de configurações de dual boot. São múltiplos kernels Linux executando de forma nativa e paralela sobre frações dedicadas do próprio hardware físico.
O que é Multikernel Linux?
O kernel é a parte central do sistema operacional responsável por controlar recursos como CPU, memória, armazenamento, rede e dispositivos. Normalmente, quando um sistema Linux é inicializado, existe apenas um kernel que gerencia absolutamente tudo na máquina.
O Multikernel muda essa arquitetura. O projeto permite que um kernel principal separe uma parte dos recursos físicos do computador, como núcleos específicos de processamento e blocos de memória RAM, e carregue outros kernels independentes dentro desses recursos isolados.
A nova versão 7.0-mk5 é baseada no Linux 7.0. A árvore do projeto contém atualmente 330 patches aplicados sobre o kernel base, sendo que 114 deles foram introduzidos especificamente nesta atualização em relação à versão mk4 anterior.
Entenda sem termos técnicos
Para visualizar o conceito, imagine um grande prédio. Em um Linux tradicional, existe uma única administração cuidando de todos os andares, apartamentos e corredores. Em uma máquina virtual comum, existe uma administradora maior que terceiriza fatias do prédio para várias administrações menores, monitorando tudo o que elas fazem.
No Multikernel, a ideia é diferente. O próprio prédio é dividido fisicamente entre várias administrações independentes, sem uma entidade supervisora invisível controlando as portas. Uma recebe determinados andares exclusivos, outra recebe outros. Cada administração possui seus próprios recursos e pode continuar funcionando normalmente mesmo se a equipe vizinha enfrentar problemas graves.
Como vários kernels conseguem dividir a mesma máquina?
O funcionamento depende de dois papéis. O primeiro kernel que a máquina carrega é chamado de host. O host tem a capacidade de fatiar o hardware e iniciar instâncias adicionais, chamadas pelo projeto de spawn kernels.
Para fazer isso sem reiniciar o computador, o projeto utiliza a chamada de sistema kexec_file_load(). A função kexec já existe no Linux e serve para carregar um kernel sobre o outro, ignorando o processo lento de verificação de firmware e BIOS. No Multikernel, esse mecanismo foi modificado. Em vez de substituir o sistema atual, o kexec modificado carrega um novo kernel para rodar lado a lado com o host. Cada spawn kernel executa nativamente nos recursos físicos que recebeu.
Então é uma máquina virtual?
Não no formato tradicional. Uma máquina virtual normalmente exige um hipervisor, como KVM ou VMware, atuando como uma camada intermediária entre o sistema operacional convidado e o hardware físico. O hipervisor simula componentes, intercepta instruções e distribui ciclos de processamento.
O projeto Multikernel define explicitamente que sua arquitetura funciona sem hipervisor. Os kernels executam instruções diretamente no hardware físico reservado a eles, sem emulação de processador ou intercepção contínua de rotinas. Essa diferença busca reduzir a latência e o custo computacional que a virtualização tradicional adiciona.
Isso é a mesma coisa que Docker?
Também não. Soluções de containerização, como Docker e Podman, isolam processos, redes e sistemas de arquivos, mas todos esses containers continuam compartilhando o exato mesmo kernel do host.
Se o kernel do Linux sofrer um pânico de sistema, todos os containers caem juntos. No Multikernel, o isolamento ocorre na própria fundação. Cada instância possui seu próprio kernel completo e independente.
O 7.0-mk5 leva Multikernel ao ARM64
A maior novidade técnica do mklinux 7.0-mk5 é a chegada à arquitetura ARM64. Enquanto a versão anterior validou o conceito em x86_64, a adoção do ARM64 aproxima o projeto de servidores de nuvem de alta eficiência e infraestruturas com altíssima contagem de núcleos.
A implementação precisou resolver problemas específicos dessa arquitetura. Para gerenciar o ciclo de vida das CPUs que são entregues aos kernels adicionais, o projeto adotou a interface PSCI (Power State Coordination Interface), um padrão usado no ecossistema ARM para controlar estados de energia e inicialização de processadores.
Além disso, os processadores ARM utilizam um controlador genérico de interrupções chamado GICv3. Como múltiplos kernels precisam dividir a mesma máquina física sem que um interfira nas interrupções do outro, a versão mk5 implementa os spawn kernels como locatários (tenants) do controlador. O host continua gerenciando as partes globais do GICv3, enquanto cada kernel adicional inicializa e controla apenas os componentes relacionados às CPUs que foram fisicamente alocadas para ele.
Cada kernel ganha CPUs, memória e dispositivos próprios
Dividir memória e processador é apenas parte do trabalho. Para que um kernel funcione de forma autônoma, ele também precisa acessar periféricos, como placas de rede e armazenamento físico.
O Multikernel gerencia isso através de um mecanismo chamado “device leases” (empréstimos de dispositivos). O kernel host entrega um dispositivo PCI fisicamente para um kernel spawn. Enquanto durar o empréstimo, o host não deve tentar acessar aquele hardware. Quando o spawn kernel é finalizado, o dispositivo é resetado pelo host e volta ao pool de recursos globais.
Por que a IOMMU é tão importante?
O grande risco de entregar placas físicas para kernels independentes é o DMA (Direct Memory Access). Dispositivos de rede e armazenamento podem ler e escrever dados diretamente na memória do computador para atingir alto desempenho. Sem controle, um dispositivo atribuído ao Kernel B poderia, teoricamente, acessar blocos de memória que pertencem ao Kernel A.
Para evitar vazamentos de dados e corrupção de memória entre instâncias, a nova versão melhora significativamente o isolamento de hardware através da IOMMU. O recurso utiliza as extensões VT-d em processadores x86 e SMMUv3 no ecossistema ARM64. Na prática, o hardware físico passa a confinar rigorosamente a área de atuação do dispositivo PCI, permitindo que ele acesse apenas o espaço de memória que foi originalmente mapeado para aquele kernel específico.
Um kernel pode assumir o lugar de outro sem reboot completo

O projeto já permitia que um kernel assumisse o controle da máquina a partir de seu host original. A versão mk5 avança nesse conceito introduzindo o mecanismo de “chained takeover” (assunção em cadeia).
Agora, um kernel que assumiu a máquina pode preparar e carregar outro kernel sucessor. Esse sucessor, por sua vez, pode passar o controle para um terceiro, e assim por diante. Essa capacidade atende a cenários onde a infraestrutura precisa aplicar atualizações no nível de sistema operacional, ou transferir cargas de trabalho críticas para um ambiente limpo, sem obrigar a máquina a passar pelo ciclo completo de reinicialização.
Dentro desse ecossistema, o projeto também mantém o Kmorph, uma ferramenta focada em usar essas capacidades para transformar ou trocar kernels dinamicamente mantendo uma instância substituta sempre pronta para assumir os recursos.
O que acontece quando um dos kernels trava?
Em um Linux tradicional, um erro irreversível no núcleo causa o famoso “kernel panic”, travando o computador inteiro instantaneamente. No Multikernel, a intenção do design é limitar a área de impacto. Se um spawn kernel entrar em colapso, os outros kernels na mesma máquina devem continuar executando normalmente.
A atualização 7.0-mk5 melhora essa resiliência alterando como os kernels se comunicam. Agora, cada par pai e filho possui anéis de comunicação isolados na memória. Se um kernel falhar durante uma operação de envio de mensagens, o erro bloqueia apenas o seu próprio link de comunicação, não prejudicando a estabilidade da rede interna dos demais.
Vale ressaltar que a máquina física continua sendo um ponto único de falha. Se a placa-mãe, o processador central, ou os barramentos compartilhados apresentarem falhas físicas, todos os kernels residentes cairão juntos.
Isso já faz parte do Linux oficial?
Não. O Multikernel Linux é mantido fora da árvore principal (out-of-tree). O código fonte, disponibilizado pela empresa Multikernel Technologies, é open source, mas os 330 patches não fazem parte do repositório oficial mantido por Linus Torvalds no mainline.
Isso significa que a funcionalidade deve ser tratada como um projeto experimental e de pesquisa ativa, não como um recurso presente nas distribuições comerciais estáveis.
Para que alguém precisaria de vários kernels?
O foco atual não está em usuários domésticos ou computadores de mesa. Os casos de uso avaliados pela equipe de desenvolvimento miram cenários complexos de infraestrutura:
- Tempo real: Dedicar um kernel e núcleos específicos apenas para tarefas de latência ultrabaixa, totalmente isolado das interrupções de hardware comuns do restante do sistema.
- Isolamento de cargas: Executar aplicações críticas em um ambiente onde falhas de drivers de outros setores não possam derrubar o serviço principal.
- Alta disponibilidade local: Manter um kernel pronto para assumir os dispositivos e a rede caso a instância primária enfrente problemas, reduzindo o tempo de inatividade.
- Manutenção contínua: Testar atualizações de sistema operacional em uma fração da máquina de produção, migrando as cargas de trabalho sem reiniciar o hardware físico.
Quais são as limitações atuais?
A arquitetura continua em pleno desenvolvimento e possui limitações técnicas documentadas nesta versão. No caso específico do ARM64, os spawn kernels podem receber apenas dispositivos PCI. O repasse de “platform devices” ainda não está suportado. Além disso, quando o recurso SDEI não está disponível no processador ARM, as instâncias precisam ser iniciadas usando pseudo-NMIs.
Para gerenciar tudo isso, o projeto atualizou o Kerf, sua ferramenta de configuração, para a versão 0.5.0. Como a nova versão do kernel modificou a ABI (Interface Binária de Aplicação) ligada ao kexec, ferramentas e carregadores mais antigos precisam obrigatoriamente ser recompilados.
O Multikernel disponibiliza pacotes pré-compilados (.deb e .rpm) tanto para x86_64 quanto para ARM64. Esses arquivos foram construídos utilizando as configurações genéricas baseadas no Ubuntu 26.04. No entanto, é vital esclarecer que o sistema operacional da Canonical não suporta a tecnologia oficialmente, servindo apenas como base de construção para os pacotes do projeto independente.
Por fim, quem for testar a novidade precisará configurar sua inicialização. Os pacotes distribuídos não possuem assinatura para o Secure Boot, exigindo ajustes na máquina, e também não incluem informações de depuração (debug info) ou BTF, limitando o uso de certas ferramentas avançadas de análise baseadas em BPF.
