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).