Pitch: Rustyll: um novo gerador de sites estáticos em Rust e por que eu decidi criá-lo

Olá, pessoal! Aqui é o Matheus Breguêz (matbrgz).
Hoje quero apresentar publicamente um projeto que venho desenvolvendo há algum tempo e que nasceu de uma necessidade muito prática do meu dia a dia como desenvolvedor: o Rustyll, um gerador de sites estáticos escrito em Rust, compatível com a maior parte do ecossistema Jekyll — mas com foco extremo em desempenho, escalabilidade e eficiência.

Este é um post extenso, porque meu objetivo é registrar toda a motivação, o processo, os problemas que enfrentei, o que me levou a construir essa ferramenta e o que espero dela daqui pra frente. Se você gosta de SSG, Rust, Jekyll ou trabalha com sites grandes, este texto é pra você.

🌱 De onde tudo começou

Durante muitos anos trabalhei com sites estáticos — especialmente Jekyll, que, pessoalmente, considero um dos projetos mais elegantes e acessíveis já criados nesse ecossistema.

Só que, conforme meus projetos foram crescendo, comecei a esbarrar em um problema específico: escala.

Estou falando de sites com:

• dezenas de milhares de includes
• templates complexos
• milhares de páginas
• coleções enormes
• builds rodando em CI/CD
• pipelines sensíveis ao tempo

Em determinado projeto que mantive, o site ultrapassou 50.000 páginas geradas, com mais de 30.000 includes processados dinamicamente. Jekyll, apesar de excelente, simplesmente não conseguia lidar com esse volume sem sofrer:

• travamentos ocasionais por uso excessivo de memória
• builds extremamente lentos
• pipelines que estouravam timeout
• dificuldade de debug em alguns limites internos

Tentei otimizar de todas as formas:

• incremental builds
• reduzir includes
• minimizar lógica Liquid
• aplicar pré-processamento
• quebrar coleções em blocos menores
• e até hacks… muitos hacks 😅

Mesmo assim, ficou claro:
o gargalo não era meu código — era a arquitetura do Ruby para esse tipo de carga.

E foi aí que a pergunta surgiu:

E se existisse um “Jekyll”, só que mais rápido, mais seguro e preparado para sites gigantescos?

⚡ Por que Rust?

Rust entrou na minha vida por curiosidade, mas ficou por razões técnicas: segurança, velocidade e paralelismo.

Eu queria:

• tempos de build extremamente rápidos
• 0 problemas de memória
• execução paralela real
• estabilidade para projetos enormes
• previsibilidade para pipelines de produção

Rust parecia obviamente o caminho certo.

Além disso, eu não queria criar “mais um SSG”.
Eu queria criar algo que aproveitasse o melhor de dois mundos:

✔ A simplicidade do Jekyll

✔ O poder e desempenho do Rust

Nascia, pelo menos como ideia, o Rustyll.

🚀 O que é o Rustyll

O Rustyll é um gerador de sites estáticos de alta performance, inspirado no Jekyll e compatível com a maior parte do seu ecossistema.

A proposta é simples:

Fornecer uma alternativa extremamente rápida para quem tem sites muito grandes ou precisa de builds previsíveis e estáveis.

Ou seja, não é uma “concorrência” ao Jekyll é uma evolução natural para casos extremos, mantendo a filosofia original.

✨ Objetivos principais

• Compatibilidade com a estrutura Jekyll (pastas, config, includes, layouts, Liquid)
• Desempenho altíssimo em sites grandes
• Paralelismo real para processamento
• Builds previsíveis e consistentes
• Código moderno e seguro graças ao Rust

📦 Para quem o Rustyll faz sentido?

• pessoas com sites muito grandes
• devs que usam Jekyll, mas sofrem com tempo de build
• projetos que precisam rodar em CI/CD sob restrições
• empresas que têm milhões de acessos, mas querem manter SSG
• entusiastas de Rust e geradores estáticos

🧪 Casos reais que motivaram o Rustyll

Vou abrir um pouco dos bastidores.

🚧 Caso 1: builds que demoravam mais de 30 minutos

Mesmo com incremental build ativado, um dos meus projetos simplesmente não terminava dentro do tempo limite do GitHub Actions. Eu precisava fazer alterações mínimas e esperava uma eternidade pra ver o resultado.

🔥 Caso 2: uso de memória insustentável

Jekyll chegou a consumir mais de 4 GB de RAM e, em alguns casos, crashava o ambiente.

🕸 Caso 3: includes demais

Literalmente milhares de includes aninhados, e cada passo custava caro.

Esses problemas não significam que “Jekyll é ruim” — ele funciona perfeitamente para a maioria das pessoas.

Mas eu precisava de algo que fosse além.

E quando você não encontra a ferramenta certa…
Você cria a ferramenta.

🛠️ Como o Rustyll funciona por dentro

Sem transformar isso em um paper técnico, algumas decisões foram essenciais:

🧵 Execução paralela

O Rustyll divide processamento de páginas, includes e coleções usando threads seguras.

📄 Cache inteligente

Detecção detalhada de mudanças para evitar recompilar o que não precisa.

🧩 Mapeamento rigoroso do comportamento do Jekyll

Para manter compatibilidade, precisei estudar profundamente:

• Liquid
• includes
• layouts
• collections
• front matter
• permalinks
• filtros
• e funcionamento interno do Jekyll

🪶 Desenho minimalista

Evitei dependências desnecessárias para manter tudo leve e rápido.

🌎 Filosofia do projeto

A visão é muito clara:

🔹 Não substituir o Jekyll

O Jekyll é histórico, estável e excelente.
O Rustyll existe para casos específicos onde desempenho extremo é necessário.

🔹 Ser acessível

Se você já conhece Jekyll, deve conseguir usar o Rustyll com mínimo esforço.

🔹 Ser rápido, previsível e confiável

O foco absoluto é escalabilidade.

📢 Convite para colaborar

O Rustyll ainda está caminhando em direção à versão 1.0, e essa é uma etapa importante.

Eu adoraria contar com:

• colaboradores
• pessoas testando builds reais
• devs curiosos em Rust
• mantenedores de grandes sites
• gente experiente no ecossistema Liquid/Jekyll
• feedback de quem usa SSG em produção

💡 Contribuições possíveis

• testes com sites reais
• sugestões de compatibilidade
• criação de plugins
• melhoria da documentação
• benchmarks
• issues e comentários
• revisão de código

Mesmo que você não programe em Rust, sua experiência com SSG já é valiosa.

🧭 Rumo ao Rustyll 1.0

A meta da versão 1.0 é:

• compatibilidade elevada com Jekyll
• estabilidade total
• build rápido mesmo em sites enormes
• ótima documentação
• CLI madura
• primeiros plugins externos
• primeiros benchmarks oficiais

Se você acredita no poder dos geradores estáticos (como eu), o Rustyll pode ser um passo à frente na evolução desse ecossistema.

💬 Obrigado por ler até aqui

O Rustyll nasceu de uma necessidade real, mas cresceu como um projeto que quero compartilhar com a comunidade. Estou animado com as possibilidades e espero que ele ajude muitas pessoas que lidam com sites grandes — assim como eu.

Se quiser conversar sobre o projeto, contribuir, testar ou dar ideias, será muito bem-vindo.

Vamos construir juntos.

Links Úteis:
GitHub
Website (criado em Rustyll)

— Matheus Breguêz (matbrgz)