Diff — AdaLogic BASIC

**AdaLogic BASIC** (**ALB**) is a complete programming language and SDK — a modern BASIC dialect built for learning and for building real software, from games to tools to full applications. It pairs a deliberately beginner-readable surface syntax with a strict static type system, an event-driven program model, and a native toolchain.

## History

### Origins

ALB's story starts with its author, **Rocky L. Oliver** (born June 10, 2000), and an early brush with computing gone wrong. As a very young child — kindergarten or thereabouts — he had a teacher who split the class into students she believed she could teach and students she simply stopped helping. The day the class first used a computer, Oliver had never touched one (his family had no computer at home) and got no instruction beyond "go type this." Fellow students tried to help; the teacher did not. He went home each day with stacks of homework instead. His mother eventually homeschooled him, and he thrived.

At thirteen he got his first computer — a cheap, unreliable laptop. Keeping it running was an education in itself: fixing things, cleaning off viruses and malware, learning the machine by rescuing it. Around then he got hold of three programming books — *Let Us C*, *Ada as a Second Language*, and *Beginning C++ Game Development* — famously unforgiving texts for a teenager teaching himself. By fifteen he was writing real software.

### RockyBASIC and the first compilers

His first language project was a small compiler/interpreter called **RockyBASIC**, named after himself. Around the same period he built **ASCII Zombies**, a game written in pure C++ — a project currently being redesigned in ALB under the name **Red Sector**.

Then, in **August 2014**, everything stopped: the family home burned down, and there was basically nothing left — including the machine and the work on it. He was fourteen. RockyBASIC’s development ended there.

### The lost years (2014–2017)

For roughly a year and a half there was nothing to build on. The family had lost nearly everything — living with little more than the clothes they had, eventually in a camper. Oliver kept going anyway: experimenting with **Commodore 64 and DOS** — mostly on emulators, sometimes real hardware — and studying history, science, math, and programming/cybersecurity on his own.

Recovery came one machine at a time. A cheap thrift-store laptop came first — not very good, but a start. Then family friends gave him a workstation with a literal name label on it: an **HP Z230** (16 GB RAM, Intel i5-4590), gifted so he could get back to schoolwork. It helped — he was far behind — but about three or four months later he drew up a roughly **$300 budget build**: a $15 case, a GTX 950, the workstation's parts, spare rigging — a real desktop with real power at last. (The Z230 was later reassembled and went back into service once he had more machines.)

The gap years produced small languages and tools of their own:

- **Graefait** — a Borland-style library providing a `graphics.h` header for 64-bit Windows, written to replace the DOS-era graphics lessons his school assignments assumed

- **nandlib** — a NAND-logic language built in NASM, usable from C

- **Keystone** — an experimental language made of clever FASM macros; he wrote a text adventure in it, which is about as far as it went

*Graefait and nandlib are planned to be hosted here for anyone who wants to download or use them.*

### The return (2017)

He had tried other BASIC-family languages before the fire — GLBasic, PureBasic — and liked them, but none met his exact requirements. In the rebuild years his C/C++ game engine — the one behind *ASCII Zombies*, *Riverine Commando*, *Bitland Wars*, *Fractal Lands* — evolved into an **Ada-based engine**, and it needed a quick way to script enemies and game logic. The small DSL he wrote for it was called **AdaLog**. That name — Ada plus logic — is where **AdaLogic** comes from.

By then he had squeezed everything he could out of SDL and Raylib. A solid engine API, more bindings, more wrappers — and in **2017** he came back to the language itself "with a fury," rewriting the entire compiler in **Ada 2012**.

### The modern toolchain

By that point Oliver had also mastered **FASM** (the flat assembler) after years of struggling with other assemblers — so the early ALB toolchain was built directly on FASM rather than on any existing infrastructure.

One deliberate constraint shaped everything: **no conventional intermediate representation**. No LLVM, no borrowed backend. The first three or so code-generation backends were written completely by hand. By the time they existed, AI-assisted development was on the rise, and development speed accelerated rapidly on top of that foundation.

Today the compiler has **many backends** — including **FASM, FASM16, and C** — and the SDK ships with thick and thin bindings across its targets.

## Design philosophy

ALB's surface is BASIC-flavored, but its decisions are deliberate:

* **`--` comments**, borrowed from Ada — chosen simply because the author likes the clean style (classic `REM` is *not* ALB syntax).

* **Case-insensitive keywords** — `PRINT`, `print`, and `Print` are the same word, as in classic BASIC.

* **A real static type system** — sized integers (`U8`–`U64`, `I8`–`I64`, `S32`), floats (`F64`/`REAL`, `PURE`/`RATIONAL`), vector/matrix types (`FLOAT2`, `FLOAT4`, `MAT2`–`MAT4`), `BOOL`, `STRING`, `BINARY`, and hardware-sized `HW8`/`HW16`/`HW32` types.

* **1-based arrays** — index 0 is out of bounds, matching how newcomers count.

* **An event-shaped program model** — `ON TICK` holds update logic and `ON PAINT` holds drawing, so a beginner always knows exactly where code goes. No guessing which loop owns what.

* **Temporal variables** — `HISTORY` and `TEMPORAL` declarations record a variable's values over time, enabling runtime debugging where you can *reverse computation* and step back through a program's history.

* **`PARALLEL` blocks** — parallel arrays made ergonomic without losing speed.

* **Hand-written backends** — the no-IR constraint keeps the whole pipeline understandable and self-owned.

## Syntax tour

The tour below covers the shape of the language — the [official handbook](/handbook) is the verified syntax sheet (the cheat sheet), [Learn](/learn) has guided lessons, the [examples gallery](/examples) has runnable demos, and the [lexicon](/lexicon) explains the terms.

### Program skeleton

```

BEGIN

VERSION 0.0.0.1

CREATE_WINDOW "ALB APP", 960, 640

ON TICK

    -- update logic

END ON

ON PAINT

    -- draw logic

END ON

LISTEN

END

```

Every program starts with `BEGIN`. The optional `VERSION` tag stamps the source's own version. `LISTEN` starts the event loop; `ON TICK` and `ON PAINT` separate simulation from rendering.

### Declarations

```

#MAX_ENTITIES = 64

LET score = 0

LET hp AS U16 = 100

LET name AS STRING = "ALB"

TYPE SmallHealth IS U16 RANGE 1 .. 255 TEMPORAL

LET px AS I32 HISTORY 16 = 140

```

`LET` declares variables, optionally with explicit types. `TYPE` creates constrained types — `RANGE` bounds and `TEMPORAL`/`HISTORY` make a value replayable. `#NAME = value` defines a constant.

### Control flow

```

IF hp > 0 THEN

    LET alive = TRUE

ELSE

    LET alive = FALSE

END IF

WHILE hp > 0

    LET hp = hp - 1

END WHILE

FOR i = 1 TO 10 THEN

    PRINT i

END FOR

MATCH mode

    0 => state = 1

    ELSE => state = 99

END MATCH

```

Structured `IF/ELSE`, `WHILE`, `FOR`, and `MATCH` arms with `=>`. `SELECT` uses `CASE`. Keywords are case-insensitive throughout.

### Functions, modules, files

```

FUNCTION Twice(x AS U32) AS U32

    RETURN x + x

END FUNCTION

MODULE MathKit

BEGIN

    FUNCTION Add2(x AS U32) AS U32

        RETURN x + 2

    END FUNCTION

END MODULE

IMPORT MathKit

```

`.alb` is a main file; `.albi` is an include file. Modules and namespaces are the real organization mechanism, though — the extensions are a convention, and an include can live in any file name you like.

### Arrays and PARALLEL

```

STRICT cells[64] AS U16

LET cells[1] = 10

PARALLEL swarm[128]

    x  AS S32

    y  AS S32

    hp AS U16

END PARALLEL

```

Arrays are 1-based and statically typed; `PARALLEL` declares structure-of-arrays-style records with the ergonomics of a struct and the layout of parallel columns.

## Toolchain

ALB compiles through a **master driver**, `alb.exe` (currently 0.2.0), which routes a program to one of many managed backend compilers. The compiler was written by hand with **no LLVM-style IR**, and ALB can build anything C, FASM, or TypeScript can build — through thick and thin bindings.

```

alb native game.alb -t fasm --build --outdir build/game

alb web game.alb --build --target es2020

alb c64 demo.alb --build --outdir build/c64

```

### Backends

Every backend has short aliases (`ts`, `rs`, `hs`, `py`, `6502`…); `alb list` shows them all.

| Command | Executable | What it targets |

| --- | --- | --- |

| `native` | `albt.exe` | Universal compiler: FASM, FASM16, C, Ada and more |

| `web` | `albw.exe` | TypeScript, browser, and Node |

| `c64` | `alb_65.exe` | Commodore 64 / 6502 |

| `brainfuck` | `albf.exe` | Brainfuck (ALBB) native emitter |

| `java` | `albj.exe` | Java / FlatJVM |

| `dotnet` | `albn.exe` | .NET / C# |

| `ada` | `alba.exe` | Native Ada |

| `python` | `albp.exe` | Python |

| `lua` | `albl.exe` | Lua (SDL3 graphics) |

| `moon` | `albm.exe` | MoonScript (SDL3 graphics) |

| `rust` | `albr.exe` | Rust (rustc) |

| `haskell` | `albh.exe` | Haskell / GHC (SDL3) |

| `odin` | `albo.exe` | Odin (SDL3 graphics) |

| `nasm` | `albnasm.exe` | NASM assembly (win64) |

| `godot` | `albgd.exe` | Godot |

| `player` | `alb_player.exe` | ALB program player |

| `agent` | `veronica_main.exe` | Veronica coding agent |

| `prompt` | `alb_prompt.exe` | Prompt and model utility |

### Polyglot blocks

ALB programs can embed foreign-language modules inline — ENABLE blocks for C, Ada, ASM, Python, Java, C#, and TypeScript/JavaScript — in the entry file or in INCLUDE files. `alb polyglot inspect|build|run` compiles the modules and the ALB host together into one all-language program.

### Packages, tools, doctoring

- `alb pkg` — the package manager (`alb-pkg.exe`); `alb pkg install core` pulls lean, version-locked toolchain packs

- `alb tool <name>` — run a bundled dependency directly (GCC, dotnet, Node) — offline-friendly

- `alb doctor` / `alb deps` — verify compilers and the version-locked dependency bundle

- `alb compile --backend <name>`, `--verbose`, `--dry-run` — routing control and inspection

### Graphics RHI

`--gfx=<backend>` selects the **alb_gfx** rendering backend DLL at compile time: **OpenGL, Vulkan, or Direct3D 6 through 12**.

### Includes

`INCLUDE "local.albi"` pulls a source-local file; `INCLUDE <alb_gfx.albi>` pulls a system/stdlib include from the SDK's `stdlib/vendor/` directories.

### The web IDE

The **browser IDE** ([alb-lang.org/alb-ide](/alb-ide/)) is half ALB, half JavaScript — written to solve the need for a web-based editor, and not a reflection of what a desktop IDE would be. The full proprietary SDK/toolchain is distributed separately at [alb-lang.com](https://alb-lang.com).

## Who it's for

Scientists, kids, teachers, hobbyists, game jams, and professionals — anything another language can build, ALB aims to build too.

## See also

### On this wiki

- [[Main Page]]

- [[Wiki Help]]

- [[Red Sector]] — the in-development ALB remake of ASCII Zombies

### On this site

- [Handbook](/handbook) — the verified syntax sheet; the cheat sheet

- [Browser IDE](/alb-ide/) — write and run ALB in your browser

- [Learn](/learn) — guided lessons

- [Examples](/examples) — runnable demos

- [Lexicon](/lexicon) — ALB terms and vocabulary

- [ALB SCAN](/scan) — static analysis for ALB programs

- [Toolkit](/alb-toolkit) — utilities built in ALB

- [Help](/help) — getting unstuck

- [Forum](/forum) — the community

[[Category:Language]]

[[Category:AdaLogic BASIC]]