Existe um NOVO Gerenciador de Pacotes!? (Alternativa ao Bun)

Portuguêsالعربية Deutsch English Español Français हिन्दी Bahasa Indonesia 日本語 한국어 Русский 中文

Computing/SoftwareInternet Technology

Transcript

00:00:00Este é o Nub, um conjunto completo de ferramentas para JavaScript que roda sobre o Node em vez de substituí-lo.

00:00:04Ele substitui todas estas ferramentas que você usa atualmente, desde o gerenciador de pacotes, que

00:00:08é cinco vezes mais rápido que o pnpm, até o executor de TypeScript que pode substituir o TSX,

00:00:13e até mesmo um gerenciador de versões do Node. Ele traz os melhores recursos do Bun, mas sobre o Node.js padrão,

00:00:17e essa provavelmente é a razão pela qual “Nub” é simplesmente “Bun” escrito ao contrário.

00:00:21E eu sei que devs JavaScript adoram reinventar a roda, mas este não é só um projeto aleatório

00:00:25de qualquer um. Foi feito pelo Colin, o criador do Zod, que criou a prova de

00:00:29conceito do tRPC e inclusive já trabalhou no Bun. Então vamos direto ao ponto e dar uma olhada.

00:00:38O Nub é um único binário em Rust e funciona no Mac, Windows e Linux. E como mostrei na introdução,

00:00:44estas são apenas algumas das ferramentas que ele pode substituir. É um executor de arquivos, de scripts,

00:00:47de pacotes, gerenciador de pacotes e gerenciador de versões do Node. Vamos passar por cada um deles.

00:00:52Primeiro, o executor de arquivos, e só ele já tem recursos demais. O executor de arquivos suporta TypeScript

00:00:56completo, não só a remoção de tipos como o Node faz, podendo substituir ferramentas como TSX ou ts-node.

00:01:02Podemos ver aqui que tenho um arquivo TypeScript com enums, namespaces e até propriedades

00:01:06de parâmetro, algo que o Node normalmente não consegue executar. Se eu simplesmente rodar o Nub com o

00:01:11arquivo que quero executar, veja que funciona perfeitamente, enquanto falharia no Node.

00:01:15Se eu substituir o Nub pelo Node aqui, vemos o erro de sintaxe TypeScript não suportada,

00:01:20pois ele não aceita o namespace nem o enum. O executor de arquivos também substitui ferramentas como o dotenv,

00:01:24importando as variáveis de ambiente automaticamente. Suporta arquivos .env, .env.local e os do

00:01:29NODE_ENV, além de ter expansão automática de variáveis. Aqui embaixo temos uma

00:01:33variável composta por outras variáveis de ambiente. Temos o usuário do banco de dados e o

00:01:37host do banco aqui. Se eu rodar esse arquivo com o Nub agora, veja que ele importa essas variáveis

00:01:41para mim e montou minha URL de health check usando os valores das outras variáveis de ambiente.

00:01:46Você também pode ver que minha chave de API não coincide com a que tenho no .env aqui.

00:01:50Isso acontece porque o .env.local sempre tem prioridade, e aqui defini a chave de API

00:01:54como “subscribe to better stack”. Algo que você definitivamente deveria fazer para se manter

00:01:58atualizado com notícias de IA e desenvolvimento. Inscreva-se, ajuda demais. Agora vou

00:02:02rodar `nub src/index.tsx`, e podemos ver que tudo está funcionando aqui. É a minha

00:02:07demonstração completa do Nub. No código desse arquivo, uso vários recursos que o executor do Nub oferece.

00:02:12Um dos primeiros é poder importar arquivos JSON, além de YAML,

00:02:15HTML e até arquivos de texto, além de substituir ferramentas como o tsconfig-paths. Os caminhos configurados

00:02:20com `@config` no meu tsconfig serão resolvidos corretamente pelo Node.

00:02:24Ele também suporta decorators, como `@service` e `@sealed` aqui. Possui

00:02:29suporte a JSX, transpilando com base nas configurações do tsconfig, e você pode usar

00:02:34palavras-chave modernas como `using` para gerenciamento explícito de recursos. Além de tudo isso,

00:02:38tem suporte a várias APIs modernas, como Web Workers, Temporal e muitas outras. Ele aplica polyfills

00:02:43automaticamente para você em versões do Node sem suporte, e também ativa recursos experimentais

00:02:48do Node, como suporte ao localStorage. Isso é só a ponta do iceberg de todos os recursos

00:02:52que o executor de arquivos suporta, mas vale destacar que ele é 100% compatível com as flags

00:02:56do Node. Afinal, por rodar o Node no fim das contas, ele apenas repassa essas flags. Se o seu

00:03:01script não usa recursos incompatíveis com o Node, você pode trocar `nub` por `node` e obter o

00:03:06mesmo resultado. Tudo isso é feito com quase nenhum impacto na velocidade. Ele deve ser o mais

00:03:10próximo do Node possível e, segundo a documentação, leva exatamente o mesmo tempo

00:03:14para rodar um arquivo no Nub quanto no Node. Admito que não será mais rápido que o Bun, pois o Bun é

00:03:19um runtime nativo que substitui o Node, enquanto o Nub roda sobre o Node. Decidi rodar meu

00:03:24próprio benchmark no meu Mac para ver qual é mais rápido. Ajustando a visualização,

00:03:28vemos que o Node foi o mais rápido para mim. Não ficou exatamente na mesma velocidade

00:03:31do Nub. O Nub ficou um pouco atrás, mas o TSX foi mais lento que ambos. Deixando o executor

00:03:36de arquivos de lado, o recurso número dois é o gerenciador de versões do Node. Chega de precisar do NVM ou

00:03:41FNM. No Nub, se eu tiver um arquivo `.node-version` no projeto, ou definir no `.nvmrc` ou até

00:03:46no `package.json`, o Nub instalará automaticamente a versão necessária do Node.js para mim.

00:03:52No momento, este projeto usa a versão mais recente do Node 26. Se eu alterar este arquivo para algo

00:03:56como 24 e rodar novamente com o Nub, ele baixará essa versão do Node automaticamente. Ele também tem todos os

00:04:02comandos usuais de gerenciamento esperados: podemos instalar versões do Node, listar as instaladas,

00:04:06desinstalá-las e até fixar versões, o que cria o arquivo de versão do Node

00:04:10para você. É simples assim! Vamos para os próximos três recursos,

00:04:15onde o Nub pode substituir o pnpm e o Bun. O recurso número três é o

00:04:20gerenciador de pacotes. Promete ser cinco vezes mais rápido que o pnpm — e eu já achava o pnpm

00:04:25super rápido! Funciona como esperado: `nub install` instala os pacotes. Mas algo bem legal

00:04:31aqui é que ele pode adotar seus lockfiles existentes. Se você usou Bun ou pnpm em um projeto

00:04:36antes, o Nub apenas atualizará esses lockfiles em vez de criar um próprio. Isso facilita demais

00:04:41a transição entre eles se necessário, o mesmo valendo para a compatibilidade com o pnpm. Cada comando

00:04:46de gerenciamento de pacotes no Nub é idêntico ao pnpm, incluindo recursos avançados como

00:04:51os catálogos de workspace. As flags são as mesmas, então alternar entre pnpm e Nub deve funcionar direto. Se você

00:04:57usa npm, Bun ou Yarn, as opções de configuração desses gerenciadores também serão reconhecidas.

00:05:02Quanto à promessa de velocidade, os benchmarks colocam o Nub como o mais rápido em instalações

00:05:06com cache frio, levando 346 ms para instalar 1168 pacotes. Na minha máquina, fiz um

00:05:13teste com 14 dependências diretas que resultaram em 212 pacotes únicos, e o benchmark provou que o Nub é

00:05:19o mais rápido. O Nub instalou meus pacotes em 136 ms, o Bun ficou em segundo com 239 ms,

00:05:25e o pnpm e o npm levaram mais de um segundo. A alegação de velocidade se confirmou na minha máquina,

00:05:30com velocidades impressionantes. O gerenciador de pacotes também pega as melhores partes do pnpm quanto à

00:05:35segurança: tem um tempo mínimo de lançamento padrão de 24 horas e não roda scripts de build

00:05:40a menos que aprovados, protegendo contra a maioria dos ataques. A próxima grande parte de um gerenciador

00:05:45de pacotes é a execução, o recurso número 4, cujo destaque é ser

00:05:4919 vezes mais rápido que o npx. O comando `nubx` aponta direto para a pasta de binários no node_modules,

00:05:54executando os binários em Rust diretamente. Não há um processo Node intermediário,

00:05:59o que significa que funciona com qualquer gerenciador de pacotes por ir direto

00:06:03ao node_modules. Como na maioria dos comandos do Nub, ele é totalmente compatível com as flags

00:06:07do `pnpm exec`, incluindo os comandos `dlx`. Rodando o benchmark no Mac, o Nub foi o

00:06:12mais rápido com 169 ms para rodar o esbuild, contra 423 ms do pnpm. Novamente, a promessa se confirmou.

00:06:20O recurso final necessário em um gerenciador de pacotes é o executor de scripts, supostamente

00:06:2424 vezes mais rápido que o `pnpm run`. Suporta hooks de ciclo de vida, variáveis de ambiente do npm

00:06:29e repasse de argumentos. Ao usar npm ou pnpm, programas Node.js são iniciados,

00:06:34carregando o JavaScript do gerenciador a cada vez, enquanto o Nub usa seu binário em Rust

00:06:38sem processos de inicialização. Meus benchmarks locais mostraram que o `nub run` foi o mais rápido,

00:06:43embora não por uma margem tão grande quanto na documentação. Vale notar —

00:06:47pela quarta vez neste vídeo — que esse comando é 100% compatível

00:06:51com o pnpm, suportando inclusive seus recursos de monorepo. Algo que quero destacar

00:06:56sobre esses últimos três recursos é que o Nub não reinventou a roda. Ele usa o

00:07:00Obe internamente, um gerenciador de pacotes escrito pelo JDX, criador do

00:07:04mise. Ele tornou o gerenciador integrável por outras bibliotecas, e o Colin trabalhou

00:07:08com ele para usá-lo no Nub, então não é trabalho plagiado. Esses são os destaques

00:07:13do Nub, mas há muito mais a explorar, como a GitHub Action pronta para usar,

00:07:17que substitui a oficial `setup-node`. Ele foi feito para facilitar tudo

00:07:21ao redor do Node. Mas aqui está a pergunta que me faço: eu realmente usaria

00:07:26isso? Minha resposta é sim em certos cenários. Sendo sincero, uso bastante

00:07:31o Bun e não tive problemas de compatibilidade no meu desenvolvimento. Talvez com a nova

00:07:35versão em Rust eu mude, mas ainda assim usaria o pnpm para o resto, e

00:07:40devo admitir que nunca achei o pnpm lento. Também uso o mise para gerenciar minha versão do

00:07:44Node, então não preciso dessa parte, mas me vejo querendo

00:07:48o executor de arquivos que substitui o TSX. O principal caso de uso para mim é quando

00:07:52uso máquinas virtuais temporárias. Às vezes crio uma rapidamente para fazer testes

00:07:57e, se quero apenas começar com o Node, o Nub é um dos pacotes mais completos

00:08:01e a forma mais rápida e fácil de fazer isso. Então é mais o meu costume

00:08:05que me impede de usar o Nub diariamente, mas quero saber o que você usa

00:08:08como gerenciador de pacotes, e se pensa em testar o Nub, talvez trocando o

00:08:12Bun agora que foi reescrito em Rust. Me conte nos comentários abaixo e, se já for

00:08:16inscrito, como sempre, nos vemos no próximo vídeo.

Key Takeaway

Criado por Colin (autor do Zod), o Nub é um binário em Rust que unifica gerenciamento de pacotes, execução de TypeScript e controle de versões do Node.js, oferecendo compatibilidade total com o ecossistema existente e desempenho superior em instalações e scripts.

Highlights

O Nub é um único binário escrito em Rust que roda diretamente sobre o Node.js em vez de tentar substituí-lo como faz o Bun.
O executor de arquivos do Nub aceita sintaxes avançadas de TypeScript, como enums e namespaces, além de recursos como JSX, decorators e suporte automático a arquivos .env.
Em testes de instalação de pacotes com cache frio, o Nub instalou 212 pacotes em apenas 136 ms, superando o Bun (239 ms) e o pnpm (mais de 1 segundo).
O executor de pacotes `nubx` roda binários em Rust apontando direto para o `node_modules`, tornando a execução 19 vezes mais rápida que o `npx` e alcançando 169 ms no esbuild.
O Nub gerencia automaticamente a versão do Node.js ao ler arquivos `.node-version`, `.nvmrc` ou `package.json`, baixando e alternando a versão sem necessidade de NVM ou FNM.

Timeline

Apresentação e arquitetura do Nub

O Nub é um conjunto de ferramentas para JavaScript escrito em Rust que roda sobre o Node.js padrão.
A ferramenta substitui o gerenciador de pacotes, o executor de TypeScript e o gerenciador de versões do Node.js em um único binário.
O projeto foi criado por Colin, autor do Zod, criador da prova de conceito do tRPC e ex-desenvolvedor do Bun.

Diferente de alternativas como o Bun, que tentam substituir o runtime do Node.js por completo, o Nub atua como uma camada superior para otimizar fluxos de trabalho existentes. A ferramenta funciona em macOS, Windows e Linux. Seu nome é literalmente a palavra 'Bun' escrita ao contrário.

Recursos do executor de arquivos e compatibilidade

O executor de arquivos aceita TypeScript completo, resolvendo estruturas como namespaces, enums e parâmetro-propriedades que falham no Node.js puro.
Há suporte nativo e automático para arquivos .env, .env.local, expansão de variáveis, caminhos do tsconfig e importação direta de arquivos JSON, YAML, HTML e texto.
O Nub repassa todas as flags do Node.js e apresenta tempo de execução equivalente ao Node original, superando o TSX em velocidade.

O executor substitui ferramentas como TSX, ts-node, dotenv e tsconfig-paths. Ele também aplica polyfills automáticos para APIs modernas como Web Workers e Temporal, além de ativar recursos experimentais do Node como o localStorage. Em testes de benchmark locais, o tempo de execução do Nub ficou extremamente próximo ao do Node.js padrão e foi superior ao do TSX.

Gerenciamento automático de versões do Node.js

O Nub lê os arquivos .node-version, .nvmrc ou package.json para baixar e alternar a versão do Node.js automaticamente.
Comandos nativos permitem instalar, listar, desinstalar e fixar versões do runtime sem depender de NVM ou FNM.

Ao detectar uma mudança na declaração da versão do Node.js no arquivo de configuração do projeto, o Nub baixa a versão correspondente no mesmo instante. Essa funcionalidade elimina a necessidade de instalar gerenciadores de versão externos para manter os ambientes sincronizados.

Desempenho e segurança no gerenciamento de pacotes

O Nub adota os arquivos de lockfile existentes de ferramentas como pnpm e Bun sem criar formatos proprietários.
Em benchmarks locais com 212 pacotes, o Nub completou a instalação em 136 ms, enquanto o Bun levou 239 ms e o pnpm ultrapassou 1 segundo.
Medidas de segurança padrão incluem um tempo mínimo de lançamento de pacotes de 24 horas e o bloqueio de scripts de build não autorizados.

A sintaxe de comandos e a compatibilidade do Nub são idênticas às do pnpm, incluindo o suporte a catálogos de workspace e configurações do npm e Yarn. O motor interno de gerenciamento reaproveita o Obe, um gerenciador de pacotes integrável desenvolvido pelo criador do mise. Para proteger o projeto contra ataques na cadeia de suprimentos, scripts de build exigem aprovação prévia para execução.

Execução ultrarrápida de binários e scripts

O comando `nubx` executa binários em Rust diretamente da pasta node_modules sem inicializar um processo Node intermediário.
A execução do esbuild via `nubx` levou 169 ms no Mac, em comparação aos 423 ms do pnpm.
O comando `nub run` elimina o tempo de carregamento de JavaScript do gerenciador de pacotes durante a inicialização de scripts.

Ao pular a camada de inicialização do Node.js tradicional na execução de binários e scripts, o Nub atinge tempos de resposta muito mais baixos. O utilitário inclui ainda uma GitHub Action oficial destinada a substituir o `setup-node` em ambientes de CI/CD. Sua aplicação principal se destaca na configuração rápida de máquinas virtuais e ambientes temporários de desenvolvimento.

Community Posts

Write about this video