Main page · News · Recent changes · All pages · Categories · Random page · Suggestions · Help

Diff — AdaLogic BASIC

Comparing rev 2 → rev 3

	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, 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.
+	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.

	He tried other BASIC-family languages — GLBasic, PureBasic — and liked them, but none met his exact requirements. While building an Ada-based game engine he needed a quick way to script enemies and game logic, so he wrote a small DSL called AdaLog. That name — Ada plus logic — is where AdaLogic comes from.

-	RockyBASIC was eventually abandoned. Then, in 2017, nearly two years later, he came back to it "with a fury" and rewrote the entire compiler in Ada 2012.
+	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.
+
+	In 2017, three years after the fire, he came back to it "with a fury" and rewrote 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

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

	## Implementation

	The compiler is written by hand with no LLVM-style IR. Multiple backends exist — FASM, FASM16, and C among them — and ALB can build anything C, FASM, or TypeScript can build, through thick and thin bindings.

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

	## Editions

	* Web platform — free: the IDE, lessons, examples, and this wiki.
	* SDK / toolchain — proprietary, for personal and enterprise use.

	## Who it's for

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

	## See also

	- [[Main Page]]
	- [[Wiki Help]]
	- [[Red Sector]] — the in-development ALB remake of ASCII Zombies
	- [Official handbook](/handbook) — the verified syntax sheet
	- [Browser IDE](/alb-ide/) — write and run ALB in your browser
	- [Examples gallery](/examples)

	[[Category:Language]]
	[[Category:AdaLogic BASIC]]