---
name: bazzbasic
description: "BazzBasic BASIC interpreter language reference. Use when writing, debugging, or explaining BazzBasic code (.bas files). Triggers on: BazzBasic syntax, $ and # variable suffixes, SDL2 graphics in BASIC, SCREEN/DRAWSHAPE/LOADIMAGE commands, DEF FN functions, BazzBasic file I/O, sound commands, or any question about BazzBasic features. Always use this skill before writing any BazzBasic code."
---

# BazzBasic Language Reference
**Version:** 1.3 | **Author:** Kristian Virtanen (EkBass) | **Platform:** Windows x64  
**GitHub:** https://github.com/EkBass/BazzBasic  
**Manual:** https://ekbass.github.io/BazzBasic/manual/#/  
**Examples:** https://github.com/EkBass/BazzBasic/tree/main/Examples  
**Rosetta Code:** https://rosettacode.org/wiki/Category:BazzBasic  


---

## ⚠️ Critical Rules — Read First

| Rule | Detail |
|------|--------|
| Variables end with `$` | `name$`, `score$`, `x$` |
| Constants end with `#` | `MAX#`, `PI#`, `TITLE#` |
| Arrays declared with `DIM`, end with `$` | `DIM items$` |
| First use of variable requires `LET` | `LET x$ = 0` — after that `x$ = x$ + 1` |
| FOR and INPUT auto-declare, no LET needed | `FOR i$ = 1 TO 10` |
| Functions defined **before** they are called | Put at top or INCLUDE |
| Function name ends with `$`, called with `FN` | `FN MyFunc$(a$, b$)` |
| Function return value **must** be used | `PRINT FN f$()` or `LET v$ = FN f$()` |
| Arrays **cannot** be passed to functions directly | Pass individual elements, or serialize to JSON string — see *Passing Arrays to Functions* section |
| Case-insensitive | `PRINT`, `print`, `Print` all work |
| `+` operator does both add and concatenate | `"Hi" + " " + name$` |
| Division always returns float | `10 / 3` → `3.333...` |

---


## ABOUT
BazzBasic is built around one simple idea: starting programming should feel nice and even fun.

Ease of learning, comfort of exploration and small but important moments of success.

Just like the classic BASICs of decades past, but with a fresh and modern feel.

## STORY
Although over the years, as my own skills have grown, I have moved on to more versatile and modern languages, BASIC has always been something that has been fun to try out many different things with.

Sometimes it's great to just make a simple adventure game again, a lottery machine, a quiz, or even just those balls bouncing on the screen.

BazzBasic was created with this in mind.

I wanted to create a language that makes it easy for you to give free rein to your curiosity and program something.

And when you finish your first little game, you may crave something bigger and better.

Maybe one day you will move on to another programming language, but then BazzBasic will have succeeded in doing what it was intended for.

To arouse your curiosity.

## Variables & Constants

```basic
LET a$                      ' Declare without value
LET name$ = "Alice"         ' String variable
LET score$ = 0              ' Numeric variable
LET x$, y$, z$ = 10        ' Multiple declaration
LET PI# = 3.14159           ' Constant (immutable)
LET TITLE# = "My Game"      ' String constant
```

**Compound assignment operators** (variables only — **not** allowed with `#` constants):

```basic
x$ += 5     ' add
x$ -= 3     ' subtract
x$ *= 2     ' multiply
x$ /= 4     ' divide
s$ += " World"  ' string concatenation
```

**Scope:** All main-code variables share one scope (even inside IF blocks).  
`DEF FN` functions are fully isolated — only global constants (`#`) accessible inside.

**Comparison:** `"123" = 123` is TRUE (cross-type), but keep types consistent for speed.

### Built-in Constants
- **Boolean:** `TRUE`, `FALSE`
- **Math:** `PI#`, `HPI#` (π/2 = 90°), `QPI#` (π/4 = 45°), `TAU#` (2π = 360°), `EULER#` (e) — `#` suffix required
- **System:** `PRG_ROOT#` (program base directory path)
- **Keyboard:** `KEY_ESC#`, `KEY_ENTER#`, `KEY_SPACE#`, `KEY_UP#`, `KEY_DOWN#`, `KEY_LEFT#`, `KEY_RIGHT#`, `KEY_F1#`…`KEY_F12#`, `KEY_A#`…`KEY_Z#`, `KEY_0#`…`KEY_9#`, `KEY_LSHIFT#`, `KEY_LCTRL#`, etc.

---

## Arrays

```basic
DIM scores$                         ' Declare (required before use)
DIM a$, b$, c$                      ' Multiple
scores$(0) = 95                     ' Numeric index (0-based)
scores$("name") = "Alice"           ' String key (associative)
matrix$(0, 1) = "A2"                ' Multi-dimensional
```

| Function/Command | Description |
|-----------------|-------------|
| `LEN(arr$())` | Total element count (note empty parens) |
| `ROWCOUNT(arr$())` | Count of first-dimension rows — use this for FOR loops over multi-dim arrays |
| `HASKEY(arr$(key))` | 1 if exists, 0 if not |
| `DELKEY arr$(key)` | Remove one element |
| `DELARRAY arr$` | Remove entire array (can re-DIM after) |
| `JOIN dest$, src1$, src2$` | Merge two arrays; `src2$` keys overwrite `src1$`. Use empty `src1$` as `COPYARRAY`. |

**Always check with `HASKEY` before reading uninitialized elements.**

---

## Control Flow

```basic
' Block IF
IF score$ >= 90 THEN
    PRINT "A"
ELSEIF score$ >= 80 THEN
    PRINT "B"
ELSE
    PRINT "F"
END IF                      ' ENDIF also works

' One-line IF (GOTO/GOSUB only)
IF lives$ = 0 THEN GOTO [game_over]
IF key$ = KEY_ESC# THEN GOTO [menu] ELSE GOTO [play]

' FOR (auto-declares variable)
FOR i$ = 1 TO 10 STEP 2 : PRINT i$ : NEXT
FOR i$ = 10 TO 1 STEP -1 : PRINT i$ : NEXT

' WHILE
WHILE x$ < 100 : x$ = x$ * 2 : WEND

' Labels, GOTO, GOSUB
[start]
    GOSUB [sub:init]
    GOTO [main]

[sub:init]
    LET x$ = 0
RETURN

' Dynamic jump (variable must contain "[label]" with brackets)
LET target$ = "[menu]"
GOTO target$

' Other
SLEEP 2000                  ' Pause ms
END                         ' Terminate program
```

---

## I/O

| Command | Description |
|---------|-------------|
| `PRINT expr; expr` | `;` = no space, `,` = tab |
| `PRINT "text";` | Trailing `;` suppresses newline |
| `INPUT "prompt", var$` | Splits on whitespace/comma |
| `INPUT "prompt", a$, b$` | Multiple values |
| `LINE INPUT "prompt", var$` | Read entire line with spaces |
| `CLS` | Clear screen |
| `LOCATE row, col` | Move cursor (1-based) |
| `CURPOS("row")` / `CURPOS("col")` | Read cursor row or col (1-based, matches LOCATE) |
| `CURPOS()` | Read cursor as `"row,col"` string |
| `COLOR fg, bg` | Text colors (0–15 palette) |
| `SHELL("cmd")` | Run shell command, returns output |
| `SHELL("cmd", ms)` | With timeout in ms (default 5000) |

**Escape sequences in strings:** `\"` `\n` `\t` `\\`

### Keyboard Input
| Function | Returns | Notes |
|----------|---------|-------|
| `INKEY` | Key value or 0 | Non-blocking |
| `KEYDOWN(key#)` | TRUE/FALSE | Held-key detection; **graphics mode only** |
| `WAITKEY(key#, ...)` | Key value | Blocks until key pressed; `WAITKEY()` = any key |

### Mouse (graphics mode only)
`MOUSEX`, `MOUSEY` — cursor position  
`MOUSELEFT`, `MOUSERIGHT`, `MOUSEMIDDLE` — 1 if pressed, 0 otherwise

### Console Read
`GETCONSOLE(row, col, type)` — type: 0=char (ASCII), 1=fg color, 2=bg color

---

## User-Defined Functions

```basic
' Define BEFORE calling. Name must end with $.
DEF FN Clamp$(val$, lo$, hi$)
    IF val$ < lo$ THEN RETURN lo$
    IF val$ > hi$ THEN RETURN hi$
    RETURN val$
END DEF

PRINT FN Clamp$(5, 1, 10)          ' ✓ OK — return value used
LET v$ = FN Clamp$(15, 0, 10)     ' ✓ OK
FN Clamp$(5, 1, 10)                ' ✗ ERROR — return value unused
```

- Isolated scope: no access to global variables, only global constants (`#`)
- Parameters passed **by value**
- Labels inside functions are local — GOTO/GOSUB cannot jump outside
- Supports recursion
- Arrays as parameters not allowed. Use ASJSON to make array as JSON-string to pass it.
- Use `INCLUDE` to load functions from separate files if many

---

## String Functions

| Function | Description |
|----------|-------------|
| `ASC(s$)` | ASCII code of first char |
| `CHR(n)` | Character from ASCII code |
| `INSTR(s$, search$)` | Position (1-based), 0=not found; case-sensitive by default |
| `INSTR(s$, search$, mode)` | mode: 0=case-insensitive, 1=case-sensitive |
| `INSTR(start, s$, search$)` | Search from position (case-sensitive) |
| `INVERT(s$)` | Reverse string |
| `LCASE(s$)` / `UCASE(s$)` | Lower / upper case |
| `LEFT(s$, n)` / `RIGHT(s$, n)` | First/last n chars |
| `LEN(s$)` | String length |
| `LTRIM(s$)` / `RTRIM(s$)` / `TRIM(s$)` | Strip whitespace |
| `MID(s$, start)` | Substring from start (1-based) |
| `MID(s$, start, len)` | Substring with length |
| `REPEAT(s$, n)` | Repeat string n times |
| `REPLACE(s$, a$, b$)` | Replace a$ with b$ in s$ |
| `SPLIT(arr$, s$, sep$)` | Split into array, returns count |
| `SRAND(n)` | Random alphanumeric string of length n |
| `STR(n)` | Number to string |
| `VAL(s$)` | String to number |
| `SHA256(s$)` | SHA256 hash (64-char hex) |
| `BASE64ENCODE(s$)` / `BASE64DECODE(s$)` | Base64 encode/decode |

---

## Math Functions

| Function | Description |
|----------|-------------|
| `ABS(n)` | Absolute value |
| `ATAN(n)` | Arc tangent |
| `BETWEEN(n, min, max)` | TRUE if min ≤ n ≤ max |
| `CEIL(n)` / `FLOOR(n)` | Round up / down |
| `CINT(n)` | Round to nearest integer |
| `CLAMP(n, min, max)` | Constrain n to [min, max] |
| `COS(n)` / `SIN(n)` / `TAN(n)` | Trig (radians) |
| `DEG(rad)` / `RAD(deg)` | Radians ↔ degrees |
| `DISTANCE(x1,y1, x2,y2)` | 2D Euclidean distance |
| `DISTANCE(x1,y1,z1, x2,y2,z2)` | 3D Euclidean distance |
| `EXP(n)` | e^n |
| `INT(n)` | Truncate toward zero |
| `LERP(start, end, t)` | Linear interpolation (t: 0.0–1.0) |
| `LOG(n)` | Natural logarithm |
| `MAX(a, b)` / `MIN(a, b)` | Larger / smaller of two |
| `MOD(a, b)` | Remainder |
| `POW(base, exp)` | Power |
| `RND(n)` | Random integer 0 to n-1 |
| `ROUND(n)` | Standard rounding |
| `SGN(n)` | Sign: -1, 0, or 1 |
| `SQR(n)` | Square root |

**Math constants:** `PI#`, `HPI#` (PI/2), `QPI#` (PI/4), `TAU#` (PI*2), `EULER#`

---

## Graphics

```basic
SCREEN 12                           ' 640×480 VGA (recommended)
SCREEN 0, 800, 600                  ' Custom size
SCREEN 0, 1024, 768, "My Game"      ' Custom size + title
FULLSCREEN TRUE                     ' Borderless fullscreen (graphics only)
FULLSCREEN FALSE                    ' Windowed
```

| Mode | Resolution |
|------|-----------|
| 1 | 320×200 |
| 2 | 640×350 |
| 7 | 320×200 |
| 9 | 640×350 |
| 12 | 640×480 ← recommended |
| 13 | 320×200 |

### Drawing Primitives
```basic
PSET (x, y), color                          ' Pixel
LINE (x1,y1)-(x2,y2), color                ' Line
LINE (x1,y1)-(x2,y2), color, B             ' Box outline
LINE (x1,y1)-(x2,y2), color, BF            ' Box filled (FAST — use instead of CLS)
CIRCLE (cx,cy), radius, color              ' Circle outline
CIRCLE (cx,cy), radius, color, 1           ' Circle filled
PAINT (x, y), fillColor, borderColor       ' Flood fill
LET c$ = POINT(x, y)                       ' Read pixel color
LET col$ = RGB(r, g, b)                    ' Create color (0–255 each)
```

**Color palette (COLOR command, 0–15):** 0=Black, 1=Blue, 2=Green, 3=Cyan, 4=Red, 5=Magenta, 6=Brown, 7=Lt Gray, 8=Dk Gray, 9=Lt Blue, 10=Lt Green, 11=Lt Cyan, 12=Lt Red, 13=Lt Magenta, 14=Yellow, 15=White

### Screen Control
```basic
SCREENLOCK ON                       ' Buffer drawing (start frame)
SCREENLOCK OFF                      ' Present buffer (end frame)
VSYNC(TRUE)                         ' Enable VSync (default, ~60 FPS)
VSYNC(FALSE)                        ' Disable VSync (benchmarking)
CLS                                 ' Clear screen (slow — prefer LINE BF)
```

### Shapes & Images
```basic
' Create shape
' LOADSHAPE and LOADIMAGE return a stable integer handle — never reassigned.
' SDL2 owns the resource; your code only ever holds this one reference. Use constants.
LET RECT# = LOADSHAPE("RECTANGLE", w, h, color)  ' or "CIRCLE", "TRIANGLE"
LET IMG_PLAYER# = LOADIMAGE("player.png")         ' PNG (alpha) or BMP
LET IMG_REMOTE# = LOADIMAGE("https://example.com/a.png") ' Download + load

' Sprite sheet — sprites indexed 1-based
DIM sprites$
LOADSHEET sprites$, 128, 128, "sheet.png"        ' tileW, tileH, file
MOVESHAPE sprites$(1), x, y                      ' sprites$(1) = first sprite

' Transform
MOVESHAPE RECT#, x, y               ' Position by center point
ROTATESHAPE RECT#, angle            ' Degrees (absolute)
SCALESHAPE RECT#, scale             ' 1.0 = original size
DRAWSHAPE RECT#                     ' Render to buffer
SHOWSHAPE RECT# / HIDESHAPE RECT#   ' Toggle visibility
REMOVESHAPE RECT#                   ' Free memory (always clean up)
```


---

### Text Rendering (SDL2_ttf.dll required)
#### DRAWSTRING & LOADFONT


```basic
' Default font (Arial)
DRAWSTRING "Hello!", 100, 200, RGB(255, 255, 255)

' Load alternative font — becomes the new default
LOADFONT "comic.ttf", 24
DRAWSTRING "Hello!", 100, 200, RGB(255, 255, 255)

' Reset to Arial
LOADFONT
```

`DRAWSTRING x, y` positions the top-left of the text. Requires `SDL2_ttf.dll` in the same directory as the interpreter. Prefer this over PRINT, which makes graphic screen easily blinking.

---

## Sound

```basic
' LOADSOUND returns a stable integer handle — SDL2 manages the resource.
' The handle never changes; store it in a constant to protect it from accidental reassignment.
LET SND_JUMP# = LOADSOUND("jump.wav")   ' Load (WAV recommended)
SOUNDONCE(SND_JUMP#)                    ' Play once, non-blocking
SOUNDONCEWAIT(SND_JUMP#)               ' Play once, wait for finish
SOUNDREPEAT(SND_JUMP#)                 ' Loop continuously
SOUNDSTOP(SND_JUMP#)                   ' Stop specific sound
SOUNDSTOPALL                            ' Stop all sounds
```

Load all sounds at startup. Call `SOUNDSTOPALL` before `END`.

---

## File I/O

```basic
LET data$ = FileRead("file.txt")        ' Read as string
DIM cfg$ : LET cfg$ = FileRead("settings.txt")  ' Read as key=value array
FileWrite "save.txt", data$             ' Create/overwrite
FileAppend "log.txt", entry$            ' Append
LET ok$ = FileExists("file.txt")        ' 1=exists, 0=not
FileDelete "temp.dat"                   ' Delete file
```

**key=value parsing:** When `FileRead` assigns to a `DIM`'d array, lines `key=value` become `arr$("key")`. Lines starting with `#` are comments. Perfect for `.env` files.

```basic
DIM env$
LET env$ = FileRead(".env")
LET API_KEY# = env$("OPENAI_API_KEY")
```

**Paths:** Use `/` or `\\` — never single `\` (it's an escape char). Relative paths are from `PRG_ROOT#`.  
**FileWrite with array** saves in key=value format (round-trips with FileRead).

---

## Network

```basic
LET res$ = HTTPGET("https://api.example.com/data")
LET res$ = HTTPPOST("https://api.example.com/submit", "{""key"":""val""}")

' With headers (optional last parameter)
DIM headers$
headers$("Authorization") = "Bearer mytoken"
headers$("Content-Type") = "application/json"
LET res$ = HTTPGET("https://api.example.com/data", headers$)
LET res$ = HTTPPOST("https://api.example.com/data", body$, headers$)
```

---

## Arrays & JSON

Nested JSON maps to comma-separated keys: `data$("player,name")`, `data$("skills,0")`

```basic
' Array → JSON string
LET json$ = ASJSON(arr$)

' JSON string → array (returns element count)
DIM data$
LET count$ = ASARRAY(data$, json$)

' Load/save JSON files
LOADJSON arr$, "file.json"
SAVEJSON arr$, "file.json"
```

---

## Fast Trigonometry

~20× faster than `SIN(RAD(x))`, 1-degree precision. Uses ~5.6 KB memory.

```basic
FastTrig(TRUE)                      ' Enable lookup tables (must call first)
LET x$ = FastCos(45)               ' Degrees, auto-normalized 0–359
LET y$ = FastSin(90)
LET r$ = FastRad(180)              ' Deg→rad (no FastTrig needed)
FastTrig(FALSE)                     ' Free memory
```

Use for raycasting, sprite rotation, particle systems, any high-freq trig.

---

## Command-Line Arguments

```basic
' bazzbasic.exe myprog.bas arg1 arg2
PRINT ARGCOUNT         ' number of args (2 in this example)
PRINT ARGS(0)          ' first arg  → "arg1"
PRINT ARGS(1)          ' second arg → "arg2"
```

`ARGCOUNT` and `ARGS(n)` are 0-based; ARGS does not include the interpreter or script name.

---

## Libraries & INCLUDE

```basic
INCLUDE "helpers.bas"               ' Insert source at this point
INCLUDE "MathLib.bb"                ' Load compiled library

' Compile library (functions only — no loose code)
' bazzbasic.exe -lib MathLib.bas  →  MathLib.bb
' Function names auto-prefixed: MATHLIB_functionname$
PRINT FN MATHLIB_add$(5, 3)
```

Library functions can read main-program constants (`#`). `.bb` files are version-locked.

---

## Passing Arrays to Functions

Arrays cannot be passed directly to `DEF FN` functions, but a clean workaround exists using JSON serialization. Convert the array to a JSON string with `ASJSON`, pass the string as a parameter, then deserialize inside the function with `ASARRAY`. This is the accepted pattern in BazzBasic v1.2+.

```basic
DEF FN ProcessPlayer$(data$)
    DIM arr$
    LET count$ = ASARRAY(arr$, data$)
    RETURN arr$("name") + " score:" + arr$("score")
END DEF

[inits]
    DIM player$
    player$("name") = "Alice"
    player$("score") = 9999
    player$("address,city") = "New York"

[main]
    LET json$ = ASJSON(player$)
    PRINT FN ProcessPlayer$(json$)
END
```

**Notes:**
- The function receives a full independent copy — changes inside do not affect the original array
- Nested keys work normally: `arr$("address,city")` etc.
- Overhead is similar to copying an array manually; acceptable for most use cases

---

## Program Structure

```basic
' ---- 1. FUNCTIONS (or INCLUDE "functions.bas") ----
DEF FN Clamp$(v$, lo$, hi$)
    IF v$ < lo$ THEN RETURN lo$
    IF v$ > hi$ THEN RETURN hi$
    RETURN v$
END DEF

' ---- 2. INIT (declare ALL constants & variables here, not inside loops) ----
' Performance: variables declared outside loops avoid repeated existence checks.
[inits]
	LET SCREEN_W# = 640
	LET SCREEN_H# = 480
	LET MAX_SPEED# = 5

    SCREEN 0, SCREEN_W#, SCREEN_H#, "My Game"

    LET x$ = 320
    LET y$ = 240
    LET running$ = TRUE

' ---- 3. MAIN LOOP ----
[main]
    WHILE running$
        IF INKEY = KEY_ESC# THEN running$ = FALSE
        GOSUB [sub:update]
        GOSUB [sub:draw]
        SLEEP 16
    WEND
    SOUNDSTOPALL
END

' ---- 4. SUBROUTINES (or INCLUDE "subs.bas") ----
[sub:update]
    IF KEYDOWN(KEY_LEFT#)  THEN x$ = x$ - MAX_SPEED#
    IF KEYDOWN(KEY_RIGHT#) THEN x$ = x$ + MAX_SPEED#
RETURN

[sub:draw]
    SCREENLOCK ON
    LINE (0,0)-(SCREEN_W#, SCREEN_H#), 0, BF
    CIRCLE (x$, y$), 10, RGB(0, 255, 0), 1
    SCREENLOCK OFF
RETURN
```

**Key conventions:**
- Variables: `camelCase$` | Constants: `UPPER_SNAKE_CASE#` | Functions: `PascalCase$`
- Labels: `[gameLoop]` for jump targets, `[sub:name]` for subroutines
- Image/sound/shape IDs are stable integer handles — **always** store as constants: `LET MY_IMG# = LOADIMAGE("x.png")` — never use `$` variables for these
- Group many IDs → use arrays: `DIM sprites$` / `sprites$("player") = LOADIMAGE(...)` — but prefer named constants when count is small

---

## Performance Tips

- `LINE (0,0)-(W,H), 0, BF` to clear — much faster than `CLS`
- Always wrap draw code in `SCREENLOCK ON` / `SCREENLOCK OFF`
- Store `RGB()` results in constants/variables — don't call RGB in hot loops
- Declare all variables in `[inits]`, not inside loops or subroutines
- Use `FastTrig` for any loop calling trig hundreds of times per frame
- `SLEEP 16` in game loop → ~60 FPS

---

## IDE Features (v1.3)

### New File Template
When the IDE opens with no file (or a new file), this template is auto-inserted:
```basic
' BazzBasic version 1.3
' https://ekbass.github.io/BazzBasic/
```

### Beginner's Guide
- **IDE:** Menu → **Help** → **Beginner's Guide** — opens `https://github.com/EkBass/BazzBasic-Beginners-Guide/releases` in default browser
- **CLI:** `bazzbasic.exe -guide` or `bazzbasic.exe -help` — prints URL to terminal

### Check for Updates
- **IDE:** Menu → **Help** → **Check for updated...** — IDE reports if a newer version is available
- **CLI:** `bazzbasic.exe -checkupdate`

### Compile via IDE
- **Menu → Run → Compile as Exe** — compiles open file to standalone `.exe` (auto-saves first)
- **Menu → Run → Compile as Library (.bb)** — compiles open file as reusable `.bb` library (auto-saves first)