0.5.0

🇺🇸 English

Version 0.5.0 marks the largest and most important pivot in the history of SimpleScript. The core of the language was completely rethought to focus on what truly matters: portability, speed, and the Web ecosystem.

The Zig/LLVM backend was discontinued, and the entire compiler was rewritten from scratch in Go, integrating TinyGo as the primary engine for WebAssembly (Wasm) generation.

✨ What's New?

• WebAssembly as a First-Class Citizen: The integration with TinyGo and the adoption of the WebAssembly Component Model (via the .wit file) allows SimpleScript to run natively and extremely lightweight directly in the browser, without heavy runtimes.
• New Basic Types (AST): The language grammar was expanded, paving the way for more complex structures. The Lexer now natively supports the json, list, and map types.
• New Control Flow: The break, continue, func, and return keywords were added to the Abstract Syntax Tree (AST), preparing the compiler for full support of custom functions in upcoming releases.
• Refactored CLI: Compiler usage has become much simpler with the new commands: run (fast native execution), build (native binaries), and wasm (web modules).

🛠️ Refactoring and Internal Improvements

• Extreme Modularization: The Frontend (Lexer and Parser) was completely separated and modularized, making the code much cleaner, easier to maintain, and testable.
• Farewell LLVM: All LLVM dependencies were removed, permanently resolving historical issues with cross-compilation and library paths on Windows.
• Internationalized Documentation: The README.md was completely rewritten, reflecting the new architecture and including an official Portuguese (pt-BR) version.

⚙️ Upgrade Requirements

To build the compiler from source, Go 1.24 and TinyGo (for the wasm command) are now required.

---

🇧🇷 Português

A versão 0.5.0 marca o maior e mais importante pivô na história do SimpleScript. O núcleo da linguagem foi completamente repensado para focar naquilo que realmente importa: portabilidade, velocidade e ecossistema Web.

O backend em Zig/LLVM foi descontinuado e o compilador foi reescrito do zero em Go, integrando o TinyGo como o motor principal para geração de WebAssembly (Wasm).

✨ O que há de novo?

• WebAssembly como Cidadão de Primeira Classe: A integração com o TinyGo e a adoção do WebAssembly Component Model (via arquivo .wit) permite que o SimpleScript rode de forma nativa e super leve direto no navegador, sem runtimes pesados.
• Novos Tipos Básicos (AST): A gramática da linguagem foi expandida, preparando o terreno para estruturas mais complexas. O Lexer agora suporta nativamente os tipos json, list e map.
• Novo Fluxo de Controle: Foram adicionadas as palavras-chave break, continue, func e return à árvore sintática abstrata (AST), preparando o compilador para o suporte completo a funções customizadas nas próximas versões.
• CLI Refatorada: O uso do compilador ficou muito mais simples com os novos comandos: run (execução nativa rápida), build (binários nativos) e wasm (módulos para web).

🛠️ Refatorações e Melhorias Internas

• Modularização Extrema: O Frontend (Lexer e Parser) foi completamente separado e modularizado, tornando o código muito mais limpo, fácil de manter e testar.
• Adeus LLVM: Todas as dependências do LLVM foram removidas, resolvendo permanentemente os problemas históricos de compilação cruzada e caminhos de bibliotecas no Windows.
• Documentação Internacionalizada: O README.md foi totalmente reescrito, refletindo a nova arquitetura e incluindo uma versão oficial em Português (pt-BR).

⚙️ Requisitos de Atualização

Para a construção do compilador a partir do código-fonte, agora é necessário o uso do Go 1.24 e do TinyGo (para o comando wasm).

Full Changelog: v0.4.0...v0.5.0

0.4.0

This release transforms SimpleScript into a robust, strongly typed language. We’ve introduced explicit typing, powerful multi-assignment capabilities, and a significant upgrade to the developer experience with precise error diagnostics and variadic outputs.

🚀 What's New

• Strong Typing System: Introduced explicit types for increased safety. Supported types: int, float, str, and bool.
• Multi-Assignment (Swap): Support for atomic variable swapping without temporary variables (e.g., a, b = b, a).
• Variadic say() Function: The say function now accepts multiple arguments of different types in a single call, separated by commas.
• Variable-Range Loops: for loops now support variables for both start and end points, allowing for dynamic iteration ranges.
• Precise Error Diagnostics: Enhanced error reporting with specific column markers and helpful "hints" to guide the developer.

🛠️ Technical Updates

• LLVM IR Optimization: Refactored print functions to handle i64, double, and ptr types dynamically.
• Memory Safety: Migrated internal lists to ArrayListUnmanaged to prevent circular dependency resolution issues during compilation.
• Lexer Refinement: Improved comment handling and whitespace skipping to ensure robust single-pass parsing.

0.3.0

This release represents a complete rewrite and modernization of the SimpleScript compiler, focusing on performance, maintainability, and international collaboration.

✨ What's New

🌍 International Codebase

• Complete English migration - All code, comments, and documentation now in English
• Ready for global open-source collaboration
• Professional naming conventions throughout

🏗️ Optimized Architecture

• Reorganized project structure - Clear separation of concerns
• Integrated Lexer/Parser - Single-pass compilation for maximum performance
• Improved LLVM integration - Better IR generation and optimization
• Enhanced error handling - Specific error types with clear messages

⚡ Performance Improvements

• Optimized precedence climbing - More efficient expression parsing
• Inline functions - Reduced function call overhead
• Better memory management - Improved allocation patterns
• Const correctness - Allows more compiler optimizations

0.2.0

This release marks a major milestone for SimpleScript. We are moving from a simple calculator to a functional programming language. With the introduction of Variables, Constants, and For Loops, the engine is now capable of managing state and executing complex logic.

What's New

• Variable Support (var): Dynamic storage with register-based allocation.
• Constants (const): Immutable data protection enforced at the compiler level.
• Control Flow (for loops): High-performance iteration using for i in start..end syntax.

Technical Improvements

• Zig 0.15.2 Stability: Migrated the entire engine to the latest stable Zig version.

Code Example

const PI = 3
var radius = 10

say('Calculating 0 to 5:')
for i in 0..5 {
  say(i + PI)
}

0.1.0

This is the first stable release of the SimpleScript engine. This version establishes the core foundation of the language, focusing on raw performance and low execution latency.

✨ What's New?

• Register-based VM: Implementation of an efficient Virtual Machine architecture that significantly reduces memory overhead compared to traditional stack-based VMs.
• 32-bit Bytecode: Compact instruction design optimized for high-speed decoding.
• Arithmetic Compiler: Direct translation of chained arithmetic expressions into optimized bytecode.
• Robust Lexer: A high-performance lexical analyzer capable of identifying identifiers, numbers, strings, and operators.

🛠️ Supported Commands & Syntax

• say(value): Prints strings or integers to the standard output.
• Chained Arithmetic: Native support for complex math expressions, e.g., say(1 + 2 + 3 + 4).