This is an old revision of the document!
SD-8516 Stellar Basic V1.0
Dennis Allison’s 1975 article in Dr. Dobb’s Journal was a key moment in the history of Computer Science. It contained a formal specification of Tiny BASIC, a BASIC that could be implemented in less than 4 KB.
Stellar BASIC is very much in the same vein as Tiny BASIC, and is intended to evolve over time.
Core features
- Line-numbered programs
- `LET` (often optional)
- `PRINT`
- `INPUT`
- `IF … THEN`
- `GOTO`
- `GOSUB` / `RETURN`
- `FOR` / `NEXT`
- Integer arithmetic only (usually 16-bit)
- Single-letter variables (`A`–`Z`)
- What’s usually removed
- No floating-point math
- No strings (or very limited strings)
- No arrays (or extremely small ones)
- No file I/O
- Minimal error messages
- Very limited editing commands
Some versions didn’t even store source code text—only tokenized forms.
—
- # Size
Typical Tiny BASIC interpreters:
- 1–4 KB total
- Some famous versions were under 2 KB
- A few extreme versions fit in less than 1 KB
This was achieved through:
- Hand-written assembly
- Tokenization
- Shared code paths
- Aggressive simplification of syntax
—
- # Example: Tiny BASIC program
```basic 10 LET A = 1 20 PRINT A 30 A = A + 1 40 IF A ⇐ 10 THEN GOTO 20 50 END ```
Many Tiny BASICs would allow this even shorter form:
```basic 10 A=1 20 ?A 30 A=A+1 40 IF A⇐10 GOTO 20 ```
(`?` was often shorthand for `PRINT`.)
—
- # Notable Tiny BASIC implementations
- Palo Alto Tiny BASIC (Dennis Allison)
- Li-Chen Wang’s Tiny BASIC
- 6800 Tiny BASIC
- NASCOM Tiny BASIC
- Apple I BASIC (inspired by Tiny BASIC ideas)
- Micro-Soft 8080 BASIC (larger, but influenced by Tiny BASIC work)
Each one differed slightly, but all followed the “tiny, usable, interactive” idea.
—
- # Why Tiny BASIC matters
Tiny BASIC is important because it:
- Made programming accessible on the *cheapest possible hardware*
- Helped bootstrap the early microcomputer software ecosystem
- Demonstrated how interpreters could be designed under extreme constraints
- Influenced later minimal languages and embedded scripting systems
It’s often cited as an early example of open, shared language design, since many implementations were published openly in magazines.
—
- # In one sentence
Tiny BASIC is a deliberately minimal BASIC interpreter, typically fitting in a few kilobytes, designed to make interactive programming possible on the earliest and most constrained microcomputers.
If you’d like, I can:
- Show a formal Tiny BASIC grammar
- Compare Tiny BASIC vs Microsoft BASIC
- Explain how a Tiny BASIC interpreter works internally
- Show how to write your own Tiny BASIC in C or assembly