Ignis v0.3.2

Fixes

• Fixed method overload handling across analyzer lowering and monomorphization, including correct codegen behavior.
• Fixed overloaded method resolution in pipe expressions by considering the pipe left-hand side type.
• Fixed manual drop checks to allow variable field accesses.
• Fixed manual drop checks to allow complex receivers inside drop methods.

Standard Library

• Refactored runtime I/O implementation to use direct LibC calls and removed the internal rt_io.c runtime file.

Documentation

• Clarified String/str overload behavior and improved standard-library method documentation.
• Normalized lambda examples in std docs to canonical syntax.

Installation

Download and install the Linux amd64 artifact:

wget https://github.com/Ignis-lang/ignis/releases/download/v0.3.2/ignis-linux-amd64.tar.gz
wget https://github.com/Ignis-lang/ignis/releases/download/v0.3.2/ignis-linux-amd64.tar.gz.sha256

sha256sum -c ignis-linux-amd64.tar.gz.sha256
tar -xzf ignis-linux-amd64.tar.gz
sudo ./scripts/install.sh

Notes

• install.sh installs a wrapper that auto-configures IGNIS_STD_PATH.
• You can install to user space with --prefix ~/.local.

Ignis v0.3.0

Ignis 0.3.0 - 2026-02-18

This release is a major language update focused on expressive control flow, stronger ownership guarantees, and richer functional syntax.

Breaking Changes

• Removed the string keyword from the language; str is now the string primitive.
• let name = value else { ... }; is now reserved for try-capable values (@lang(try)) and reports A0187 for non-try types.

Language Features

• Added full pattern matching support with match, variant/tuple/literal/or patterns, and guards.
• Added if let, while let, and let else control-flow forms.
• Added try propagation with postfix ! for enums marked with @lang(try).
• Added defer with correct execution on normal scope exit and early exits.
• Added pipe operator |> with placeholder _, method/builtin RHS support, and improved generic inference.
• Added lambda/closure expressions with capture analysis, capture overrides (@move, @ref, @refMut), and @noescape support.
• Added declaration attributes and lint controls (@allow, @warn, @deny) plus extension methods via @extension(...).

Type System and Ownership

• Added traits with @implements(...), including default methods and semantic checks.
• Added structural Copy derivation and stricter Drop/Copy validation for records and enums.
• Migrated ownership and borrow checking to post-monomorphization HIR for improved soundness.
• Strengthened move tracking through match/aggregate flows and added A0186 (cannot move out of borrowed value).
• Added @takes for extern parameters to model ownership transfer across FFI boundaries.

Builtins and Directives

• Unified compiler intrinsics under directive syntax (@name(...), @name<T>(...)).
• Added and stabilized builtins such as @panic, @typeName, @bitCast, pointer/integer cast helpers, @read, @write, @dropInPlace, and @dropGlue.

Standard Library

• Added std::rc enhancements including Weak<T>, downgrade/upgrade, strongCount, get, and getMut.
• Added std::ffi::CString for C interop.
• Added high-level filesystem APIs (std::fs::File, ReadDir, convenience helpers), std::path, and improved I/O error surface.

Tooling

• Improved LSP stability and completion quality across namespaces, member access, and standard-library files.
• Expanded diagnostics for type positions, pattern control flow, and ownership errors.

Installation

Download and install the Linux amd64 artifact:

wget https://github.com/Ignis-lang/ignis/releases/download/v0.3.0/ignis-linux-amd64.tar.gz
wget https://github.com/Ignis-lang/ignis/releases/download/v0.3.0/ignis-linux-amd64.tar.gz.sha256

sha256sum -c ignis-linux-amd64.tar.gz.sha256
tar -xzf ignis-linux-amd64.tar.gz
sudo ./scripts/install.sh

Notes

• install.sh installs a wrapper that auto-configures IGNIS_STD_PATH.
• You can install to user space with --prefix ~/.local.

v0.2.4

Ignis 0.2.4

This release introduces project-based compilation with ignis.toml configuration files, enabling multi-file projects with structured build settings.

Project Configuration

Ignis now supports project configuration via ignis.toml:

[package]
name = "myproject"
version = "0.1.0"

[ignis]
std = true
std_path = "../std"

[build]
bin = true
source_dir = "src"
entry = "main.ign"
out_dir = "build"
opt_level = 2
debug = true
cc = "gcc"
emit = ["c", "obj"]

CLI Changes

• --project <dir>: Explicitly specify project directory
• Auto-detection: Running ignis build without arguments searches upward for ignis.toml
• Single-file mode: Still supported by passing a file path directly

Build Configuration Options

Option	Description	Default
bin	Produce executable	true
source_dir	Source directory	"src"
entry	Entry file (relative to source_dir)	"main.ign"
out_dir	Output directory	"build"
opt_level	Optimization level (0-3)	0
debug	Include debug info	false
cc	C compiler	"cc"
cflags	Extra compiler flags	[]
emit	Extra artifacts: "c", "obj"	[]

LSP Improvements

• Project-aware analysis: LSP now discovers and uses ignis.toml as the source of truth for std_path, entry point, and analysis settings
• Entry point validation: Binary projects emit a diagnostic when missing fn main
• Config file watching: File watchers detect ignis.toml changes and re-analyze
• In-memory overrides: Unsaved ignis.toml content is used for analysis
• TOML diagnostics: Parse errors in ignis.toml are reported in the editor

Bug Fixes

• Fixed monomorphized std functions being emitted in multiple user modules (now only emitted in the entry module to avoid duplicate definitions)
• Fixed build layout paths for absolute source paths in project mode

Internal

• Deduplicated toml and serde_json workspace dependencies
• Added ProjectManager with mtime-based caching for project configurations
• Added BuildLayout::with_project_root() for proper path relativization

Full Changelog: v0.2.3...v0.2.4

v0.2.3

Ignis 0.2.3

This release introduces important syntax changes, expands the standard library with memory management and C interoperability, and improves compiler stability.

Breaking Changes

• Parenthesized Conditions: Syntax now requires parentheses around conditions in if and while control structures.
  • Before: if x > 0 { ... }
  • After: if (x > 0) { ... }

Standard Library & Runtime

• New Intrinsics: Added alignOf, maxOf, and minOf intrinsics, and improved syntax for type intrinsics
• Memory Utilities: Added layout and alignment utilities to std/memory
• Libc Module: Introduced libc module providing raw POSIX bindings
• Unified Runtime: Refactored runtime to consolidate C modules into a single libignis_rt archive

Compiler & Interoperability

• C Headers: Compiler now emits proper struct and enum definitions in C headers
• UTF-8 Support: Fixed line and column calculation to handle UTF-8 character boundaries correctly
• Parser Stability: Added recursion limit to parser to prevent stack overflows and improved lexer handling

Documentation & Examples

• Updated dependencies and added documentation support for extern blocks and namespace
• Added bump allocator example with tests and block metadata

Full Changelog: v0.2.2...v0.2.3

v0.2.2

Ignis 0.2.2

This release focuses on LSP server stability and crash prevention.

Bug Fixes

• Panic Recovery: Added global panic hook and catch_unwind wrappers around analysis and completion to prevent panics from killing the LSP server
• Invalid ModuleId Crash: Fixed crash when a file fails to parse by cleaning up placeholder ModuleId entries from the lookup table
• UTF-8 Boundary Panics: Fixed panics when cursor offset lands in the middle of a multi-byte UTF-8 character by clamping to valid boundaries
• Empty Std Module Name: Added validation to reject "std::" imports without a module name
• Duplicate Import Prefix: Fixed import completion inserting std::io when user already typed std:: (now correctly inserts just io)

Improvements

• Fallback Import Detection: Added raw text-based import path detection for unclosed quotes where the lexer fails to produce a String token
• Dynamic Std Modules: Import path completion now reads available modules from the project manifest instead of a hardcoded list
• Version Mismatch Guard: Completion now checks document version to avoid race conditions between did_change and completion requests
• Cleaned up verbose debug logging throughout the completion system

Full Changelog: v0.2.1...v0.2.2

v0.2.1

Ignis 0.2.1

This release brings significant improvements to the Language Server Protocol (LSP) support and adds new language features for visibility control and mutable pointers.

Language Features

Visibility Control

Fields and methods in records are now private by default. Use the public keyword to make them accessible from outside the record:

record Person {
    public name: string;   // Accessible from anywhere
    age: i32;              // Private - only accessible within Person methods
    
    public getName(): string {
        return self.name;
    }
    
    getAge(): i32 {        // Private method
        return self.age;
    }
}

Private members can be accessed within the record's own methods via self.

Mutable Pointers

Added explicit mutable pointer syntax *mut T to distinguish from immutable pointers *T:

let x: i32 = 42;
let p: *i32 = &x as *i32;         // Immutable pointer
let mut y: i32 = 10;
let mp: *mut i32 = &mut y as *mut i32;  // Mutable pointer

Mutable Self in Methods

Methods can now explicitly declare mutable self to indicate they modify the receiver:

record Counter {
    value: i32;
    
    public increment(&mut self): void {
        self.value = self.value + 1;
    }
    
    public get(&self): i32 {
        return self.value;
    }
}

Documentation Comments

Added support for documentation comments that appear in LSP hover:

/// Adds two numbers together.
/// Returns the sum of a and b.
function add(a: i32, b: i32): i32 {
    return a + b;
}

/**
 * A person with a name and age.
 * Use Person::new() to create instances.
 */
record Person {
    public name: string;
    public age: i32;
}

LSP Improvements

New Features

• Code Completion: Context-aware suggestions for identifiers, member access (.), static access (::), and import paths
• Document Symbols: Navigate to functions, records, enums, and namespaces in the current file
• Workspace Symbols: Search for symbols across all project files
• Find All References: Locate all usages of a symbol
• Go to Definition on Imports: Click on import path strings (e.g., "std::io") to jump to the module file
• File Watching: Automatically re-analyze when files change outside the editor

Enhanced Hover Information

• Doc comments now display with proper Markdown formatting
• Hover works on all identifier positions including:
  • Record fields (in definitions and initializers)
  • Enum variants
  • Type annotations
  • Path segments (e.g., each part of Outer::Inner::func)
  • Import items
  • Static access targets (e.g., Io in Io::println)

Inlay Hints

• Parameter name hints at call sites (e.g., foo(name: "Alice", age: 30))
• Hints skip obvious cases: single-char params, underscore prefixes, matching variable names

Performance

• Analysis results are cached per document
• Tokens are cached for completion context detection
• Last good analysis preserved during typing for better completion

Internal Improvements

• Added name_span to Definition for accurate declaration detection
• Added FileId::SYNTHETIC for internal definitions that shouldn't appear in user-facing features
• Added AnalysisStage enum to track how far analysis progressed
• Improved semantic token classification accuracy
• Fixed visibility enforcement for field and method access

Bug Fixes

• Fixed extern functions incorrectly consuming ownership of arguments
• Fixed NodeId collisions in multi-module analysis
• Improved diagnostic span accuracy for various error types

Full Changelog: v0.2.0...v0.2.1

v0.2.0

Ignis v0.2.0 Release Notes

Overview

Ignis v0.2.0 introduces generics, user-defined types, and namespaces. This release significantly expands the language's type system while maintaining the compile-to-C approach.

New Features

Generics

Type parameters for functions, records, enums, and type aliases:

function identity<T>(x: T): T {
    return x;
}

record Box<T> {
    value: T;
}

enum Option<T> {
    SOME(T),
    NONE,
}

type Alias<T> = Box<T>;

Generics are monomorphized at compile time, producing specialized code for each instantiation.

Records

User-defined struct types with fields and methods:

record Point {
    x: i32;
    y: i32;
    
    distance(): f64 {
        return Math::sqrt((self.x * self.x + self.y * self.y) as f64);
    }
    
    static origin(): Point {
        return Point { x: 0, y: 0 };
    }
}

Enums

Algebraic data types with unit and payload variants:

enum Result<T, E> {
    OK(T),
    ERROR(E),
}

enum Color {
    RED,
    GREEN,
    BLUE,
}

Enums compile to tagged unions in C.

Namespaces

Module-level organization with :: access:

namespace Math {
    function add(a: i32, b: i32): i32 {
        return a + b;
    }
}

let sum: i32 = Math::add(1, 2);

Extern Blocks

Group FFI declarations by library:

extern libc {
    function puts(s: string): i32;
    function printf(format: string, ...): i32;
}

Type Aliases with Generics

Type aliases now support type parameters:

type IntBox = Box<i32>;
type Identity<T> = T;
type BoxAlias<T> = Box<T>;

For-Of Loops

Iterate over arrays:

let arr: i32[3] = [1, 2, 3];
for (let x of arr) {
    // x is i32
}

Function Overloading

Multiple functions with the same name but different signatures:

function print(x: i32): void { ... }
function print(x: string): void { ... }

Other Additions

• Ternary expressions: condition ? then : else
• Null pointer type for explicit null handling
• Record and enum static fields and methods

Breaking Changes

None. v0.2.0 is backwards compatible with v0.1 code.

ABI Changes

• Records compile to C structs with field_N naming
• Enums compile to tagged unions with discriminant tag
• Generic names use ____ separator (e.g., Box____i32)
• Namespace names use _ separator (e.g., Math_add)

See docs/ABI_v0.2.md for details.

Documentation

• Language Reference v0.2
• ABI Reference v0.2

Known Limitations

• No pattern matching (match expressions) yet
• No closures/lambdas
• No traits/interfaces
• No associated types

Upgrade Guide

No changes required. Existing v0.1 code compiles without modification.

# Rebuild the standard library
ignis build-std

# Recompile your project
ignis build

Full Changelog: v0.1.1...v0.2.0

v0.1.1

Ignis v0.1.1 Release Notes

New Features

Automatic Drop Insertion

Owned types (string, dynamic buffers) are now automatically cleaned up at scope exit, early returns, and break/continue statements.

function example(): void {
    let s: string = "hello";
    return;  // s is automatically dropped
}

Ownership Tracking

The compiler tracks ownership and detects use-after-move:

let s: string = "hello";
consume(s);    // ownership moved
println(s);    // ERROR: use of moved value 's'

Use-After-Free Detection

Dereferencing a pointer after deallocate() is a compile-time error:

let p: *mut i32 = allocate(16) as *mut i32;
deallocate(p);
let x: i32 = *p;  // ERROR: use of freed pointer 'p'

Literal Type Inference

Numeric literals coerce to the expected type when the value fits:

let x: u64 = 42;        // OK
let y: u8 = 300;        // ERROR: overflow
takeU32(100);           // coerced to u32

Memory Module

New std::memory module for raw allocation:

import allocate, deallocate from "std::memory";

let p: *mut i32 = allocate(64) as *mut i32;
deallocate(p);  // accepts any pointer type

Other Changes

• FFI leak warnings when passing owned values to extern functions
• Updated ABI and language reference documentation

Full Changelog: v0.1.0...v0.1.1

v0.1.0

Ignis v0.1.0 Release Notes

Release Date: January 2026

This is the first release of the Ignis compiler (ignisc.rs), a from-scratch rewrite in Rust that compiles Ignis source code to C, then to native executables via GCC.

Highlights

• Full compilation pipeline: Ignis → AST → HIR → LIR → C → executable
• Multi-module system with import/export support
• Static type system with inference and explicit annotations
• Borrow checker for reference safety

Language Features

Types

• Integers: i8, i16, i32, i64, u8, u16, u32, u64
• Floats: f32, f64
• boolean, char (Unicode code point, 4 bytes), string, void
• Arrays with compile-time bounds checking
• References (&T, &mut T) and pointers (*T, *mut T)

Expressions

• Arithmetic, comparison, logical, and bitwise operators
• Compound assignment (+=, -=, *=, /=, etc.)
• Shift operators (<<, >>)
• Type casts (expr as Type)
• Char literals with escape sequences and Unicode ('\u{XXXX}')

Control Flow

• if/else if/else
• while and for loops
• break and continue
• return

Declarations

• Functions with typed parameters and return types
• let / let mut variable bindings
• const compile-time constants
• extern declarations for FFI
• export for module-level visibility

Modules

• import x, y from "path" syntax
• Automatic dependency resolution and topological compilation
• Standard library with std::io, std::string, std::math

Compiler Features

• Semantic analysis: name resolution, type checking, borrow checking
• Bidirectional type inference: literals adapt to expected types
• Const evaluation: compile-time evaluation of constant expressions
• Diagnostics: detailed error messages with source locations
• Debug flags: --dump-ast, --dump-hir, --dump-lir, --dump-types, --dump-defs
• Optimizations: -O flag passes optimization to GCC

CLI

ignis build <file.ign>           # Compile to executable
ignis build <file.ign> --emit-c  # Output C code only
ignis build <file.ign> -O        # Enable optimizations
ignis build-std                  # Build standard library

Known Limitations

• Borrow checker does not track mutations through compound expressions (arr[i], *ptr, field access)
• No generics, traits, or enums yet
• No closures or first-class functions
• Runtime bounds checking is limited

Documentation

• docs/LANGUAGE_REFERENCE_v0.1.md - Complete language reference
• docs/ABI_v0.1.md - C ABI and type mappings

Full Changelog: https://github.com/Ignis-lang/ignis/commits/v0.1.0