Why Build a Pascal Compiler in Rust? | Por que um compilador Pascal em Rust?

Bilingual post · Post bilíngue

Jump to: English · Português

---

English {#english}

Why Build a Pascal Compiler in Rust?

Delphi and Free Pascal are battle-tested, but their toolchains can feel heavy for CI, teaching, or quick experiments. CrabPascal asks a different question: what if Pascal compilation were rebuilt from scratch on a modern foundation — without cutting corners?

Current version: v2.22.0. MIT licensed. Sprint-driven releases.

The mission

CrabPascal's philosophy is straightforward:

Create a modern alternative for compiling Delphi-style Pascal projects using Rust — with clean architecture, no shortcuts, and no "good enough" hacks.

That means a full compiler pipeline (lexer → parser → semantic analysis → codegen/runtime), not a toy interpreter glued to regex.

Why Rust?

Rust brings concrete advantages to compiler engineering:

• Memory safety — AST nodes, symbol tables, and runtime values live in owned structures; no dangling pointers in the semantic analyzer.
• Performance — check on a typical unit completes in milliseconds; suitable for editor integration.
• Error handling — Result-based flows propagate diagnostics cleanly instead of silent failures.
• Concurrency — future parallel compilation of units is feasible without data races.
• Ecosystem — serde for AST snapshots, clap for CLI, mature testing tools.

Compare this to extending a legacy C codebase: Rust lets the team move fast while keeping invariants enforced by the type system.

Why not just use FPC or Delphi?

You still can — CrabPascal targets Delphi/FPC syntax and ships RTL shims under rtl/. The value proposition is different:

Aspect	Traditional toolchain	CrabPascal
Install footprint	IDE + license or large FPC tree	Single binary or cargo build
Run without codegen	Usually no	crab-pascal run via internal runtime
CI integration	Scripts, paths, configs	check with VS Code-friendly diagnostics
HTTP examples	Requires setup	Horse framework in examples/

CrabPascal is not claiming 100% Delphi compatibility today. It is claiming an honest, sprint-by-sprint path toward useful parity for learning, prototyping, and curated real-world examples.

Architecture choices that matter

The project follows the classic five-phase compiler model documented in the architecture guides:

1. Lexical analysis
2. Parsing to AST
3. Semantic analysis
4. Code generation (C backend) or direct interpretation
5. Optional optimization

Dual-mode execution is a deliberate design: run uses the internal runtime (zero gcc dependency); build-exe emits C and delegates to gcc/clang when available.

Who is this for?

• Educators teaching compilers or Pascal without IDE lock-in.
• Developers migrating Delphi snippets to a scriptable CLI.
• Contributors who want a readable Rust codebase with clear module boundaries.
• Teams building CI gates with crab-pascal check on every push.

The honest caveat

Parser hardening, generics edge cases, and build-exe parity with run are active sprint goals. The project publishes status per release — transparency over marketing.

If you believe Pascal deserves a modern toolchain and you trust Rust for systems code, CrabPascal is worth a clone. Start with cargo build --release, run an example, and read the architecture docs. The claws are real. 🦀

---

Português {#portugus}

Por que construir um compilador Pascal em Rust?

Delphi e Free Pascal são maduros, mas suas toolchains podem ser pesadas para CI, ensino ou experimentos rápidos. O CrabPascal propõe outra pergunta: e se reescrevêssemos a compilação Pascal do zero, em uma base moderna — sem atalhos?

Versão atual: v2.22.0. Licença MIT. Releases orientados por sprints.

A missão

A filosofia do CrabPascal é direta:

Criar uma alternativa moderna para compilar projetos Pascal estilo Delphi usando Rust — com arquitetura limpa, sem gambiarra e sem atalhos "bons o suficiente".

Isso significa um pipeline completo (lexer → parser → análise semântica → codegen/runtime), não um interpretador de brinquedo colado com regex.

Por que Rust?

Rust traz vantagens concretas para engenharia de compiladores:

• Segurança de memória — nós da AST, tabelas de símbolos e valores do runtime vivem em estruturas owned; sem ponteiros pendurados no analisador semântico.
• Performance — check em uma unit típica termina em milissegundos; adequado para integração com editores.
• Tratamento de erros — fluxos baseados em Result propagam diagnósticos de forma limpa.
• Concorrência — compilação paralela de units no futuro, sem data races.
• Ecossistema — serde para snapshots de AST, clap para CLI, ferramentas maduras de teste.

Em contraste com estender um codebase legado em C, Rust permite evoluir rápido mantendo invariantes garantidas pelo type system.

Por que não usar só FPC ou Delphi?

Você ainda pode — o CrabPascal mira sintaxe Delphi/FPC e inclui shims RTL em rtl/. A proposta de valor é outra:

Aspecto	Toolchain tradicional	CrabPascal
Instalação	IDE + licença ou árvore FPC grande	Binário único ou cargo build
Executar sem codegen	Geralmente não	crab-pascal run via runtime interno
Integração CI	Scripts, paths, configs	check com diagnósticos estilo VS Code
Exemplos HTTP	Requer setup	Framework Horse em examples/

O CrabPascal não promete 100% de compatibilidade Delphi hoje. Promete um caminho honesto, sprint a sprint, rumo a paridade útil para aprendizado, prototipagem e exemplos reais curados.

Decisões de arquitetura que importam

O projeto segue o modelo clássico de cinco fases documentado nos guias de arquitetura:

1. Análise léxica
2. Parsing para AST
3. Análise semântica
4. Geração de código (backend C) ou interpretação direta
5. Otimização opcional

A execução dual-mode é design deliberado: run usa runtime interno (zero gcc); build-exe emite C e delega ao gcc/clang quando disponível.

Para quem é?

• Educadores que ensinam compiladores ou Pascal sem lock-in de IDE.
• Desenvolvedores migrando trechos Delphi para uma CLI scriptável.
• Contribuidores que querem codebase Rust legível com módulos bem definidos.
• Times que rodam crab-pascal check a cada push no CI.

A ressalva honesta

Endurecimento do parser, casos de borda em generics e paridade build-exe vs run são metas ativas de sprint. O projeto publica status por release — transparência acima de marketing.

Se você acredita que Pascal merece uma toolchain moderna e confia no Rust para código de sistemas, vale clonar o CrabPascal. Comece com cargo build --release, rode um exemplo e leia a documentação de arquitetura. As garras são reais. 🦀

---

Published on dev.to/@crabpascal · Código em CrabPascal