🚀 Tiger v0.1.0: Initial Release

TL;DR

Tiger is a complete compiler infrastructure written entirely in Delphi. No LLVM. No GCC. No external toolchains. Just uses Tiger; and you're generating native x86-64 binaries for Windows and Linux — executables, DLLs, shared objects, and static libraries — entirely from code.

This release delivers a fully functional backend: SSA-based IR, multi-pass optimizer, x86-64 code generator, PE linker, ELF linker, and runtime system. All pure Object Pascal.

🏗️ The Architecture

Tiger provides everything needed to go from programmatic IR construction to native binary output:

Component	Purpose
Fluent API	Build programs using chainable Delphi method calls
SSA Optimizer	Constant folding, copy propagation, CSE, dead code elimination
x86-64 Backend	Native machine code generation for Win64 and Linux64
PE Linker	Windows executables, DLLs, static libraries, object files
ELF Linker	Linux executables, shared objects, static libraries, object files
Runtime	Exception handling, managed strings, heap management

The result: A single uses Tiger; clause gives you a complete compiler backend. No PATH configuration. No SDK installation. No external dependencies beyond the Delphi RTL.

✨ What You Can Build

Hello World

LTiger := TTiger.Create(tpWin64);
try
  LTiger.ImportDll('msvcrt.dll', 'printf', [vtPointer], vtInt32, True);

  LTiger.Func('main', vtVoid, True)
    .Call('printf', [LTiger.Str('Hello, World!'#10)])
    .Call('Tiger_Halt', [LTiger.Int64(0)])
  .EndFunc();

  LTiger.TargetExe('output\hello.exe', ssConsole);
  LTiger.Build(True, nil);
finally
  LTiger.Free();
end;

Cross-Platform Targeting

Target Windows or Linux from the same Delphi codebase:

// Target Windows
LTiger := TTiger.Create(tpWin64);

// Target Linux
LTiger := TTiger.Create(tpLinux64);

// Platform-specific imports
if LTiger.GetPlatform = tpWin64 then
  LTiger.ImportDll('msvcrt.dll', 'printf', [vtPointer], vtInt32, True)
else
  LTiger.ImportDll('libc.so.6', 'printf', [vtPointer], vtInt32, True);

Records with Inheritance

LTiger.DefineRecord('TPoint')
     .Field('X', vtInt32)
     .Field('Y', vtInt32)
   .EndRecord();

LTiger.DefineRecord('TPoint3D', 'TPoint')  // Inherits from TPoint
     .Field('Z', vtInt32)
   .EndRecord();

Exception Handling

LTiger.Func('RiskyOperation', vtVoid, True)
  .Try()
    .Call('DoSomethingDangerous', [])
  .Except()
    .Call('printf', [LTiger.Str('Exception caught!'#10)])
  .Finally()
    .Call('Cleanup', [])
  .EndTry()
.EndFunc();

Dynamic Arrays

LTiger.DefineArray('TIntArray', vtInt32, 0);  // Dynamic array

LTiger.Func('main', vtVoid, True)
  .Local('arr', 'TIntArray')
  .SetLength('arr', LTiger.Int64(10))
  .AssignIdx('arr', LTiger.Int64(0), LTiger.Int64(42))
  // ...
.EndFunc();

Variadic Functions

LTiger.Func('Sum', vtInt64, True, ccCdecl, True)  // Variadic
  .Local('total', vtInt64)
  .Local('i', vtInt32)
  .Assign('total', LTiger.Int64(0))
  .For('i', LTiger.Int64(0), LTiger.Sub(LTiger.VaCount(), LTiger.Int64(1)), False)
    .Assign('total', LTiger.Add(LTiger.Get('total'), LTiger.VaArg(LTiger.Get('i'), vtInt64)))
  .EndFor()
  .Return(LTiger.Get('total'))
.EndFunc();

📦 Output Formats

Target	Windows	Linux
Executable	.exe (PE)	ELF executable
Shared Library	.dll (PE)	.so (ELF)
Static Library	.lib (COFF archive)	.a (ar archive)
Object File	.obj (COFF)	.o (ELF)

🔧 Feature Summary

Type System:

• Records with C ABI alignment, packing, and inheritance
• Unions (named and anonymous) with record nesting
• Bit fields
• Fixed and dynamic arrays
• Enumerations with auto and explicit values
• Pascal-style set types with full operations
• Type aliases
• Typed and untyped pointers
• Function pointers with indirect calls

Functions and Linkage:

• Function overloading via name mangling
• Public/private function exports
• C and C++ linkage modes
• DLL/shared object imports (static and dynamic)
• Static library imports with ImportLib
• Variadic functions with VaCount/VaArg intrinsics

Runtime Features:

• Structured exception handling (try/except/finally)
• Hardware exception support (Windows SEH, Linux signals)
• Managed reference-counted strings
• Runtime heap management with leak detection
• Global variables with zero-initialization

Build Features:

• Compile-time intrinsics (SizeOf, AlignOf, High, Low, Len)
• Inc/Dec, Succ/Pred, Ord/Chr intrinsics
• Version info and icon embedding (Windows)
• Status callbacks for build progress
• Multi-level optimization (0, 1, 2)
• SSA dump for IR diagnostics

🚀 Getting Started

Requirements

• Delphi 11 (Alexandria) or later
• Windows 10/11 64-bit for development
• WSL2 with Ubuntu for Linux targeting (optional)

No external compilers. No linkers. No SDKs. Just Delphi.

Installation

1. Download the release or clone the repository
2. Add the src folder to your Delphi library path
3. Add uses Tiger; to your project
4. Start generating native binaries

Hello World

uses
  Tiger;

var
  LTiger: TTiger;
begin
  LTiger := TTiger.Create(tpWin64);
  try
    LTiger.ImportDll('msvcrt.dll', 'printf', [vtPointer], vtInt32, True);

    LTiger.Func('main', vtVoid, True)
      .Call('printf', [LTiger.Str('Hello from Tiger!'#10)])
      .Call('Tiger_Halt', [LTiger.Int64(0)])
    .EndFunc();

    LTiger.TargetExe('hello.exe', ssConsole);
    LTiger.Build(True, nil);
  finally
    LTiger.Free();
  end;
end.

🌐 Community

• GitHub: tinyBigGAMES/Tiger
• Discord: Join us
• Bluesky: @tinybiggames.com

🎯 The Bottom Line

Tiger v0.1.0 — Initial Release

A complete compiler infrastructure in pure Delphi:

✅ SSA-based IR with multi-pass optimizer
✅ Native x86-64 machine code generation
✅ Cross-platform: Windows (PE) and Linux (ELF)
✅ Zero external dependencies
✅ Rich type system (records, unions, arrays, sets, enums)
✅ Exception handling with platform-native mechanisms
✅ Managed strings with reference counting
✅ Function overloading and variadic functions
✅ Static and dynamic library support
✅ Fluent API for clean program construction

No LLVM. No GCC. No external toolchains. Just Delphi.

---

Tiger™ Compiler Infrastructure.

Copyright © 2025-present tinyBigGAMES™ LLC. All Rights Reserved.