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

Diff — AdaLogic BASIC

Comparing rev 4 → rev 5

	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:

-	- a Borland-style `graphics.h` for 64-bit Windows, written to replace the DOS-era graphics lessons his school assignments assumed
+	- 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

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

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