Download SKILL.md from EkBass/BazzBasic_AI_Guide: direct link, hf CLI and curl.
- Browser
- Download file 46.5 kB
-
https://huggingface.co/datasets/EkBass/BazzBasic_AI_Guide/resolve/main/SKILL.md
- Command line
-
hf download hf://datasets/EkBass/BazzBasic_AI_Guide/SKILL.md
-
curl -L -o SKILL.md https://huggingface.co/datasets/EkBass/BazzBasic_AI_Guide/resolve/main/SKILL.md
name: bazzbasic-code
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. For changing the interpreter or IDE source code use
bazzbasic-interpreter-dev or bazzbasic-ide-dev.
BazzBasic Language Reference
Version: 1.7 | Author: Kristian Virtanen (EkBass) | Platform: Windows x64 only (SDL2 via P/Invoke — no Linux, macOS, browser or Android)
Homepage: https://ekbass.github.io/BazzBasic/
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
Rosetta Code solutions: https://github.com/EkBass/BazzBasic/tree/main/Examples/rosetta-code
BazzBasic-AI-Guide: https://huggingface.co/datasets/EkBass/BazzBasic_AI_Guide
BazzBasic Beginner's Guide: https://github.com/EkBass/BazzBasic-Beginners-Guide/releases
BazzBasic is a BASIC meant for beginners and for small, fun experiments (simple games, quizzes, bouncing balls). It is not a high-performance game engine — keep generated code simple and readable rather than clever.
⚠️ Critical Rules — Read First
| Rule | Detail |
|---|---|
Variables end with $ |
name$, score$, x$ — the suffix does NOT mean string type |
Constants end with # |
MAX#, PI#, TITLE# — # only means immutable |
| Built-in constants cannot be redefined | LET PI# = 3.14 is an error (Cannot redefine constant 'PI#') — use your own name: LET MY_PI# = 3.14 |
Arrays declared with DIM, end with $ |
DIM items$. A non-$ name (DIM MAX#) is an error. DIM ends at :, so DIM a$ : a$(0) = 1 works |
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 |
| Case-insensitive | Keywords, variables, constants, labels and array names. For text values see the next row |
| Case rules differ for text | = <> < > <= >= ignore case: "abc" = "ABC" → 1. Array string keys are case-sensitive (arr$("name") and arr$("NAME") are different elements), and so is INSTR by default. JSON object keys are too, in both directions: ASJSON/SAVEJSON write them verbatim, ASARRAY/LOADJSON read them verbatim. Exact (case-sensitive) compare: IF SAME(pass$, input$) THEN. Before 1.7 (no SAME): LEN(a$) = LEN(b$) AND INSTR(a$ + "~", b$ + "~") = 1 — the + "~" makes two empty strings match |
| Functions defined before they are called | Put at top or INCLUDE — forward references don't resolve |
Function name ends with $, called with FN |
FN MyFunc$(a$, b$) |
Parameters end with $; pass exactly as many arguments as defined |
DEF FN F$(a$, B#) is an error (# = constant). FN Add$(1) for Add$(a$, b$) stops with FN ADD$: expected 2 arguments, got 1 |
| Function return value must be used | PRINT FN f$() or LET v$ = FN f$() |
DEF FN scope is fully isolated |
Only global # constants are visible. No $ variables, no global arrays. Arrays cannot be passed as parameters — see Passing Arrays to Functions |
+ does both add and concatenate |
If either side is a string, the other is auto-converted: "Score: " + 5 → "Score: 5", no STR() needed |
| Division always returns float | 10 / 3 → 3.333... |
Division by zero returns 0 silently |
Same for /, /=, % and MOD(a, 0). Guard with IF b$ = 0 THEN ... if correctness matters |
No \ or ^ operator |
Both are an error before the program runs (Unexpected character '\'). Integer division: INT(a / b), FLOOR(a / b) or CINT(a / b); power: POW(a, b) |
| Errors halt the program | No TRY/CATCH or ON ERROR — line-numbered message printed. Exception: a failed HTTPGET/HTTPPOST returns "" and sets HTTPERROR (see Network) |
| No line-continuation char | Leave an operator at line end or open a ( — see Line Continuation |
| No line numbers | Never supported. Use [labels] |
: separates statements on one line |
FOR i$ = 1 TO 3 : PRINT i$ : NEXT. A : inside a label like [sub:init] is part of the label name, not a separator |
NOT binds tighter than comparisons |
NOT a$ = b$ means (NOT a$) = b$. Parenthesize: IF NOT (a$ = b$) THEN, or use <> |
Comments: ' or REM |
' comment anywhere on a line; REM as a statement, also after : (PRINT x$ : REM note) |
🚫 Common AI Mistakes (avoid these)
These are the patterns LLMs most often produce when extrapolating from QBASIC, FreeBASIC, or VB. None of them are valid BazzBasic.
' ❌ WRONG ' ✓ CORRECT
LET x = 5 LET x$ = 5
LET MAX = 10 LET MAX# = 10
score$ = 0 ' first use LET score$ = 0
DEF FN doStuff(a, b) DEF FN DoStuff$(a$, b$)
FN MyFunc$(5) ' return ignored LET v$ = FN MyFunc$(5)
LET handle$ = LOADIMAGE("x.png") LET HANDLE# = LOADIMAGE("x.png")
CLS ' in graphics mode LINE (0,0)-(W,H), 0, BF
PRINT "x:", x$ ' in graphics mode DRAWSTRING "x:" + x$, 10, 10, WHITE#
FSTRING("Hi {{name$}}") ' Python-style FSTRING("Hi {{-name$-}}") ' triple-char markers
ISSET(arr$(0)) ' expecting error ' returns 0 silently — ISSET only sees scalars
LET x$ = a$ + _ ' VBA continuation LET x$ = a$ + ' just leave the operator
LET x$ = a$ + \ ' Python continuation LET x$ = a$ + ' or open a paren
IF NOT a$ = b$ THEN ' QBASIC habit IF NOT (a$ = b$) THEN
IF done$ THEN BREAK ' C/Python habit IF done$ THEN EXIT WHILE ' or EXIT FOR
IF done$ THEN GOTO [after] ' out of loop IF done$ THEN EXIT FOR ' GOTO leaks loop state
When Generating BazzBasic Code
- Prefer
FSTRINGover long+concatenation chains for multi-variable strings - Place
DEF FNdefinitions at the top of the file or viaINCLUDE - Store every
LOADIMAGE/LOADSOUND/LOADSHAPEhandle as a#constant. They return string handles that never change while the program runs — images/shapes (also eachLOADSHEETcell)"SHAPE1","SHAPE2"…, sounds a GUID-style string like"57212810-1166-4bcf-8ccd-bdfc6607046f". Treat them as opaque IDs, not numbers. For many handles, an array is fine:sprites$("player") = LOADIMAGE(...) - Declare all variables and constants in
[inits], not inside loops — this avoids repeated existence checks - Precompute colors:
LET WHITE# = RGB(255, 255, 255)in[inits], neverRGB()inside a game loop - In graphics mode: clear with
LINE (0,0)-(W,H), 0, BF(much faster thanCLS), draw text withDRAWSTRING(PRINTflickers), and wrap each frame inSCREENLOCK ON/SCREENLOCK OFF - If a feature isn't documented in this guide, say so rather than inventing one — BazzBasic does not silently inherit QBASIC, FreeBASIC, or VB conventions
Minimal Valid Program
[inits] ' [name] is a plain jump label, not a keyword
LET name$ = "World"
[main]
PRINT "Hello, " + name$
END
' subroutines go after END
[sub:drawScreen]
' draw
RETURN
Programs flow top to bottom. [inits] and [main] are organizational labels, not required syntax. END halts execution; place it at the end of the main flow so control doesn't fall through into subroutines.
Line Continuation
The lexer figures out continuation automatically using two rules. Never emit _, \, & or any other continuation marker.
Rule 1 — operator at end of line. If a line ends in a token that cannot legally end an expression, the next line continues it:
LET total$ = price$ * count$ -
discount$
IF score$ >= 0 AND
score$ <= 100 THEN
PRINT "Valid"
END IF
LET counter$ +=
step$
Tokens that trigger this: + - * / % = <> < <= > >= AND OR += -= *= /= ,
%is a real binary modulo operator and triggers continuation.MOD(a, b)is a function, so it does not (a)at line end never continues).
Rule 2 — open paren. Anything inside an unmatched ( keeps reading until the matching ):
LET dist$ = DISTANCE(
x1$, y1$,
x2$, y2$
)
Variables & Constants
Variables are dynamically typed, like in JavaScript.
LET a$ ' Declare without value
LET b$, c$, d$ ' Multiple declarations without value
LET e$, f$ = "foo", g$ = 10 ' e$ stays empty, f$ and g$ get values
LET name$ = "Alice" ' String
LET score$ = 0 ' Number
LET MAX_LIVES# = 3 ' Constant (immutable)
LET TITLE# = "My Game" ' String constant
Compound assignment (variables only — not allowed with # constants):
LET x$ = 1
x$ += 5
x$ -= 3
x$ *= 2
x$ /= 4
LET s$ = "Hello"
s$ += " World" ' concatenation
Scope: All main-code variables share one scope — IF, FOR, and WHILE do NOT create a new scope.
Comparison: "123" = 123 is TRUE (cross-type), but keep types consistent for speed.
Built-in Constants
- Boolean:
TRUE&ON(1),FALSE&OFF(0) — plain numbers.IF x$ = 1andIF x$ = TRUEare identical. - Math:
PI#,HPI#(π/2 = 90°),QPI#(π/4 = 45°),TAU#(2π = 360°),EULER#(e) - Astronomy:
AU#= 149597870700 — astronomical unit in metres (exact, IAU 2012) - System:
PRG_ROOT#(program base directory path, ends with a separator) - Version:
BBVER#(current BazzBasic version as a string, e.g."1.7"),BBBUILD#(interpreter build time as a string"dd-mm-yyyy hh:mm:ss", e.g."06-11-2026 20:47:16"; an-exeprogram reports the build time of the interpreter it was made with, since 1.7) - 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_NUMPAD0#…KEY_NUMPAD9#,KEY_NUMPAD_PLUS#,_MINUS#,_MUL#,_DIV#,_DOT#,KEY_LSHIFT#,KEY_LCTRL#,KEY_RSHIFT#,KEY_RCTRL#,KEY_LALT#,KEY_RALT#,KEY_LWIN#/KEY_RWIN#,KEY_TAB#,KEY_BACKSPACE#,KEY_INSERT#,KEY_DELETE#,KEY_HOME#,KEY_END#,KEY_PGUP#,KEY_PGDN#, punctuation (layout-dependent)KEY_COMMA#KEY_DOT#KEY_MINUS#KEY_EQUALS#KEY_SLASH#KEY_BACKSLASH#KEY_SEP#(;)KEY_GRAVE#KEY_LBRACKET#KEY_RBRACKET#— see Keyboard Input - Gamepad: see Gamepad
Arrays
Arrays are fully dynamic and support numeric, string, or mixed indexing.
DIM scores$ ' Declare (required before use)
DIM a$, b$, c$ ' Multiple
scores$(0) = 95 ' Numeric indices are 0-based
scores$("name") = "Alice" ' String keys: associative, insertion-ordered
PRINT HASKEY(scores$("NAME")) ' 0 - string keys are case-sensitive; use UCASE(key$) to normalize
matrix$(0, 1) = "A2" ' Multi-dimensional
DIM sounds$
sounds$("guns", "shotgun_shoot") = "shoot_shotgun.wav"
sounds$("guns", "ak47_shoot") = "shoot_ak47.wav"
sounds$("food", "ham_eat") = "eat_ham.wav"
PRINT LEN(sounds$()) ' 3 - total elements across all groups
PRINT ROWCOUNT(sounds$()) ' 2 - "guns" & "food"
DIM car$
car$("manufacturer") = "Ford"
car$("engine") = "1.6 Eco"
FOR i$ = 0 TO LEN(car$()) - 1 ' No FOREACH — LEN + ARRKEY is the idiom
LET key$ = ARRKEY(car$(), i$)
PRINT key$; " = "; car$(key$)
NEXT i$
| Function/Command | Description |
|---|---|
LEN(arr$()) |
Total element count across all dimensions |
ROWCOUNT(arr$()) |
Count of first-dimension rows — use this for FOR loops over multi-dim arrays |
ARRKEY(arr$(), i) |
Key at 0-based index i, in insertion order. Errors on out-of-range index |
HASKEY(arr$(key)) |
1 if exists, 0 if not — always check before reading possibly uninitialized elements |
DELKEY arr$(key) |
Remove one element |
DELARRAY arr$ |
Remove entire array (can re-DIM after) |
JOIN dest$, src1$, src2$ |
Merge two arrays; matching src2$ keys overwrite src1$ at the same level. Use an empty src1$ to copy an array |
Re-DIM of an existing global array is a no-op (contents kept) — only
DELARRAYremoves it. InsideDEF FN,DIMalways creates a fresh local array.
DIM arr$ = valuestores the value atarr$(0)— NOT as a scalar. If a scalar is what you want, useLET.
DIM arr$(10)is accepted but the size is ignored — it declares the same empty dynamic array asDIM arr$; nothing inside the parentheses is read. Write plainDIM arr$. Size and value cannot be combined:DIM arr$(10) = 5is an error.
Control Flow
' 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
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
' End value of counter Comparison. Wont pass ending point like in MS-BASIC style dialects
FOR i$ = 1 TO 10 : NEXT : PRINT i$ ' 10
FOR i$ = 1 TO 10 STEP 4 : NEXT : PRINT i$ ' 9
' EXIT FOR — leave innermost FOR, continue after its NEXT (loop var keeps its value)
FOR i$ = 1 TO 100
IF i$ * i$ > 50 THEN EXIT FOR
NEXT
PRINT "First square over 50: "; i$ ' 8
' WHILE
WHILE x$ < 100
x$ = x$ * 2
WEND
' EXIT WHILE — leave innermost WHILE, continue after its WEND
LET key$
WHILE 1
key$ = INKEY
IF key$ = KEY_ESC# THEN EXIT WHILE
' Game logic here
WEND
PRINT "Goodbye"
' Labels, GOTO, GOSUB
[start]
GOSUB [sub:init]
GOTO [start] ' Avoid jumping into the middle of IF/WHILE blocks
[sub:init]
LET x$ = 0
RETURN
' Dynamic jump (variable must contain "[label]" with brackets)
LET target$ = "[menu]"
GOTO target$
SLEEP 2000 ' Pause for milliseconds
END ' Terminate program
Labels may contain almost any printable character. Whitespace is trimmed; everything between [ and ] is the label name.
EXIT FOR / EXIT WHILE (since 1.5)
- Work anywhere inside the loop: one-line IF, inside an
IF...END IFblock, or inside an inner loop of the other kind.EXIT WHILEinside a FOR that sits in a WHILE leaves both loops. - Only the innermost loop of the named kind is left. To leave several nested loops of the same kind at once, use a flag variable.
- Inside
DEF FN, EXIT can only leave loops that are inside the function. EXITwithout a loop of that kind is an error:EXIT WHILE without WHILE.- Prefer EXIT over
GOTOout of a loop. A GOTO leaves the loop's bookkeeping behind; doing it repeatedly (e.g. once per frame) slowly fills memory and can confuse laterNEXTstatements.
I/O
| Command | Description |
|---|---|
PRINT expr; expr |
; = no space, , = tab, can be mixed |
PRINT "text"; |
Trailing ; suppresses newline |
INPUT "prompt", var$ |
Splits on whitespace/comma; quoted strings are single values |
INPUT "prompt", a$, b$ |
Multiple values |
LINE INPUT "prompt", var$ |
Read entire line with spaces |
CLS |
Clear screen (console) |
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, palette 0–15 only (RGB() does not work here) |
GETCONSOLE(row, col, type) |
Read console cell. type: 0=char (ASCII), 1=fg color, 2=bg color |
SHELL("cmd") |
Run shell command, returns output |
SHELL("cmd", ms) |
With timeout in ms (default 5000) |
Escape sequences in strings: \" \n \t \\ ""
SHELL + SQLite. The sqlite3 CLI is the recommended way to add a database — see the SQLite Database page in the manual. When wrapping SQL in SHELL:
- Always append
2>&1, or SQL errors disappear silently. - Wrap the SQL with
\":SHELL("sqlite3 db.sqlite \"SELECT * FROM users\" 2>&1"). - In paths use
/or\\— never a single\.
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 |
- Layout-safe keys: letters, digits, arrows, Space/Enter/Esc, F-keys, numpad and modifiers are the same on every layout — use these for controls. Main-keyboard punctuation (
+ - = , . /) depends on the layout: never bind controls toASC("+")orASC("-"); use letters orKEY_NUMPAD_PLUS#/KEY_NUMPAD_MINUS#. - Letters always return uppercase codes (
"a"and"A"→KEY_A#), in both graphics and console mode. KEYDOWNfollows the key label on the current layout, same asINKEY. If no key types a punctuation character without modifiers (e.g.=on a Finnish keyboard),KEYDOWNof that constant is always FALSE.- Numpad Enter =
KEY_ENTER#. INKEYconsumes the key: read it once per loop pass (LET k$ = INKEY) and compare the variable. A secondINKEYin the same pass returns 0.- Console mode:
INKEY/WAITKEYreturn the typed character (except letters and special keys); numpad returns the typed digit, notKEY_NUMPAD*#. - No real console (redirected stdin/stdout): console
INKEY/WAITKEY/SLEEP/CLS/CURPOSstop with a line-numberedError at line N: ...and exit code 1; pipedINPUT/LINE INPUTstill works.
Mouse (graphics mode only)
MOUSEX, MOUSEY — cursor positionMOUSELEFT, MOUSERIGHT, MOUSEMIDDLE — 1 if pressed, 0 otherwiseMOUSEHIDE / MOUSESHOW — hide / restore the cursor
Gamepad (console AND graphics mode)
| Function | Returns | Notes |
|---|---|---|
GAMEPADS() |
Number of connected pads | Parentheses optional |
PADBUTTON(pad, button) |
TRUE/FALSE | TRUE while held (like KEYDOWN) |
PADAXIS(pad, axis) |
Number | Sticks -1.0…1.0, triggers 0.0…1.0, built-in dead zone |
PADNAME(pad) |
String | e.g. "PS4 Controller", "" if not connected |
PADRUMBLE pad, strength, ms |
— (statement) | strength 0.0…1.0, non-blocking, parentheses optional |
- Pad index is 0-based, max 8 pads. Slots are stable while connected (not re-packed on disconnect). Hot-plug works.
- No
SCREENneeded — works in console programs too. - Disconnected pad = no input, never an error:
PADBUTTON→ FALSE,PADAXIS→ 0,PADNAME→"". Don't guard every read withIF GAMEPADS() > 0; useGAMEPADS()only to show a "connect a pad" message. - Buttons (Xbox naming):
PAD_A#PAD_B#PAD_X#PAD_Y#,PAD_UP#PAD_DOWN#PAD_LEFT#PAD_RIGHT#,PAD_LB#PAD_RB#,PAD_LSTICK#PAD_RSTICK#,PAD_BACK#PAD_START#PAD_GUIDE#,PAD_MISC#,PAD_TOUCHPAD#. PlayStation: A=Cross, B=Circle, X=Square, Y=Triangle. Raw 0–20 valid (16–19 = Elite paddles); outside → error. - Axes:
PAD_LX#PAD_LY#PAD_RX#PAD_RY#PAD_LT#PAD_RT#. Raw 0–5; outside → error. - Y axis: negative = up, same as screen Y.
y$ = y$ + PADAXIS(0, PAD_LY#) * SPEED#is correct — do not invert. - L2/R2 are triggers, not buttons: read with
PADAXIS(pad, PAD_LT#). Never pass an axis constant toPADBUTTON—PADBUTTON(0, PAD_LT#)silently reads button 4 (PAD_BACK#). - For one action per press, keep previous state:
IF now$ = TRUE AND was$ = FALSE THEN ...thenwas$ = now$. - Stick as digital direction:
IF PADAXIS(0, PAD_LX#) < -0.5 THEN ... - Pad OR keyboard:
IF PADBUTTON(0, PAD_LEFT#) OR KEYDOWN(KEY_LEFT#) THEN dx$ = -1 - Many third-party pads identify as PS4/Xbox controllers — normal, mapping is still correct.
User-Defined Functions
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) ' ✓ return value used
LET v$ = FN Clamp$(15, 0, 10) ' ✓
FN Clamp$(5, 1, 10) ' ✗ ERROR — return value unused
- Scope is isolated (see Critical Rules). Touching a global array gives:
Global array G$ is not visible inside DEF FN - pass it as a parameter with ASJSON() and rebuild it with ASARRAY() DIMinside a function creates a fresh, empty, local array on every call and every recursion level:
DEF FN Count$(x$)
DIM t$
t$(x$) = 1
RETURN LEN(t$())
END DEF
PRINT FN Count$(1) ' 1
PRINT FN Count$(2) ' 1 (not 2)
- Parameters are passed by value
- Labels inside functions are local — GOTO/GOSUB cannot jump outside
- Recursion uses the real call stack, so thousands of levels can overflow it. GOSUB/RETURN uses a separate heap-based stack with no such limit.
String Functions
| Function | Description |
|---|---|
ASC(s$) |
ASCII code of first char |
ASC(s$, pos) |
ASCII code of char at 1-based pos; out of range (pos < 1 or pos > LEN(s$)) → 0. Prefer over ASC(MID(s$, pos, 1)) in loops (no temp substring, ~35 % faster) |
CHR(n) |
Character from ASCII code |
INSTR(s$, search$) |
Position (1-based), 0=not found; case-sensitive. Start form INSTR(start, s$, search$): start < 1 or > LEN(s$) → 0 |
INSTR(s$, search$, mode) |
mode: 0=case-insensitive, 1=case-sensitive |
INVERT(s$) |
Reverse string |
LCASE(s$) / UCASE(s$) |
Lower / upper case |
LEFT(s$, n) / RIGHT(s$, n) |
First/last n chars; n <= 0 → "", n >= LEN(s$) → whole string |
LEN(s$) |
String length |
LTRIM(s$) / RTRIM(s$) / TRIM(s$) |
Strip whitespace |
MID(s$, start) |
Substring from start (1-based); start < 1 or > LEN(s$) → "" |
MID(s$, start, len) |
Substring with length; len < 0 → runtime error (MID: length must be 0 or more, got -1); len past the end clamps to the tail |
REPEAT(s$, n) |
Repeat n times; n <= 0 or empty string → ""; result > 2147483647 chars → runtime error (REPEAT: result too large (N characters)) |
REPLACE(s$, a$, b$) |
Replace a$ with b$ in s$ |
SAME(a$, b$) |
1 if identical, case-sensitive (SAME("A", "a") → 0); numbers compare as text (SAME("1.0", 1) → 0) — use = for numbers. Since 1.7 |
SPLIT(arr$, s$, sep$) |
Split into array (keys 0..count-1), returns count. Array is emptied first. arr$() also accepted |
SRAND(n) |
Random alphanumeric string of length n (decimals dropped). n = 0 → ""; a negative n is a runtime error (SRAND: length must be 0 or more, got -1) |
STR(n) |
Number to string |
VAL(s$) |
String to number |
SHA256(s$) |
SHA256 hash (64-char hex) |
BASE64ENCODE(s$) / BASE64DECODE(s$) |
Base64 encode/decode |
FSTRING — String Interpolation
FSTRING(template$) substitutes {{-name-}} placeholders with the value of variables, constants, or array elements.
LET name$ = "Krisu"
LET LEVEL# = 5
PRINT FSTRING("Hello {{-name$-}}, level {{-LEVEL#-}}")
' Output: Hello Krisu, level 5
The triple-character markers {{- and -}} are deliberately unusual. There is no escape syntax — literal {{-...-}} is always parsed as a placeholder.
| Form | Resolves to |
|---|---|
{{-var$-}} |
Variable var$ |
{{-CONST#-}} |
Constant CONST# (built-ins like {{-PI#-}} work too) |
{{-arr$(0)-}} |
Element at numeric index 0 |
{{-arr$(i$)-}} |
Element at index from variable i$ |
{{-arr$(KEY#)-}} |
Element at index from constant KEY# |
{{-arr$(name)-}} |
Element at literal string key "name" (no quotes inside FSTRING) |
{{-arr$(0, i$)-}} |
Multidimensional, mixed literal and variable indices |
Index resolution — for each comma-separated index, FSTRING checks:
- Ends with
$or#→ variable / constant lookup. Halts if undefined. - Parses as a number → numeric index.
arr$(01)andarr$(1.0)both resolve to key1. - Otherwise → literal string key.
So {{-name-}} (no suffix) is a literal array key, not variable name$. Always include the suffix.
Notes: Whitespace inside placeholders is trimmed. Numbers auto-stringify. FSTRING returns a value and must be used — a bare FSTRING(...) statement is an error. Undefined names, missing -}}, empty {{--}}, malformed or uninitialized array access all halt with a line-numbered message.
Not supported: arithmetic, function calls, nested lookups, or quoted literals inside placeholders. Pre-compute into a variable:
' ❌ WRONG
PRINT FSTRING("Total: {{-a$ + 5-}}")
PRINT FSTRING("Name: {{-UCASE(name$)-}}")
PRINT FSTRING("{{-arr$(arr2$(0))-}}")
' ✓ RIGHT
LET total$ = a$ + 5
LET upper$ = UCASE(name$)
LET k$ = arr2$(0)
PRINT FSTRING("Total: {{-total$-}}, Name: {{-upper$-}}, Item: {{-arr$(k$)-}}")
Full example:
DIM player$
player$("name") = "Krisu"
player$("class") = "Bass"
player$("level") = 99
DIM grid$
grid$(1, 0) = "."
grid$(1, 1) = "X"
LET row$ = 1
PRINT FSTRING("{{-player$(name)-}} the {{-player$(class)-}}, lvl {{-player$(level)-}}")
PRINT FSTRING("Row {{-row$-}}: [{{-grid$(row$, 0)-}}{{-grid$(row$, 1)-}}]")
END
' Output:
' Krisu the Bass, lvl 99
' Row 1: [.X]
Math Functions
| Function | Description |
|---|---|
ABS(n) |
Absolute value |
ATAN(n) |
Arc tangent |
ATAN2(y, x) |
Angle in radians from the positive x-axis to point (x, y) |
BETWEEN(n, min, max) |
TRUE if min ≤ n ≤ max |
INBETWEEN(n, min, max) |
TRUE if min < n < max (strict) |
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) / a % b |
Remainder (function and operator forms are equivalent). b = 0 → 0 |
POW(base, exp) |
Power |
RND(n) |
Random integer 0 to n-1 (n > 0) |
RND(0) |
Random float 0.0–1.0 |
ROUND(n) |
Nearest integer, half away from zero (0.5→1, -0.5→-1) — NOT banker's rounding |
SGN(n) |
Sign: -1, 0, or 1 |
SQR(n) |
Square root |
Fast Trigonometry
About 20× faster than SIN(RAD(x)), 1-degree precision, ~5.6 KB memory. Use for raycasting, sprite rotation, particle systems — anything calling trig hundreds of times per frame.
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
ISSET
ISSET(name) returns 1 if the named variable ($) or constant (#) is declared, 0 otherwise. The argument is not evaluated, so ISSET(undef$) safely returns 0.
- Scalars only.
ISSET(arr$)andISSET(arr$(0))always return0, never an error. - Bare name only. Expressions, string literals, numbers or an empty argument (
ISSET(a$ + b$),ISSET("a$"),ISSET(42),ISSET()) error with "invalid parameter". - Suffix is part of the name:
a$andA#are different names. LET name$without a value still counts as set. ISSET reports declaration, not "has a meaningful value".
IF ISSET(playerName$) = FALSE THEN
LET playerName$ = "Anonymous"
END IF
Graphics
SCREEN 12 ' 640×480 VGA
SCREEN 0, 800, 600 ' Custom size
SCREEN 0, 1024, 768, "My Game" ' Custom size + title
FULLSCREEN TRUE ' Borderless fullscreen (graphics only)
FULLSCREEN FALSE ' Windowed
Classic modes: 1, 7, 13 = 320×200 · 2, 9 = 640×350 · 12 = 640×480.
Drawing Primitives
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
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
SAVESCREEN "shot.png" ' Save screen as PNG (only .png; relative to program folder)
LET COL# = RGB(r, g, b) ' Create color (0–255 each)
Color values: All drawing primitives (PSET, LINE, CIRCLE, PAINT, DRAWSTRING, LOADSHAPE) accept a palette index 0–15 or an RGB(r, g, b) value. Never hand-construct packed integers (e.g. 16711680) — RGB() tags its value internally, and a raw integer is misread as a palette index.
Palette (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
SCREENLOCK ON ' Start frame (buffer drawing)
SCREENLOCK OFF ' Present buffer
VSYNC(TRUE) ' Enable VSync (default) — loop runs at monitor refresh rate
VSYNC(FALSE) ' Disable VSync (benchmarking)
Shapes & Images
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 0-based
DIM sprites$
LOADSHEET sprites$, 128, 128, "sheet.png" ' tileW, tileH, file
MOVESHAPE sprites$(0), x, y
MOVESHAPE RECT#, x, y ' Position
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)
Anchor point: LOADSHAPE primitives are center-anchored; LOADIMAGE images are top-left-anchored.
Text Rendering (requires SDL2_ttf.dll next to the interpreter)
DRAWSTRING "Hello!", 100, 200, WHITE# ' Default font: Arial, 16px
LOADFONT "comic.ttf", 24 ' Becomes the new default
LOADFONT ' Reset to Arial 16px
DRAWSTRING text, x, y, color positions the top-left of the text.
Sound
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
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 (array → key=value format)
FILEAPPEND "log.txt", entry$ ' Append
LET ok$ = FILEEXISTS("file.txt") ' 1=exists, 0=not
FILEDELETE "temp.dat" ' Delete file
DIM files$
LET n$ = FILELIST(files$, "levels", "*.txt") ' Names into files$(0..n-1), returns n
key=value parsing: When FILEREAD assigns to a DIM'd array, lines key=value become arr$("key"); lines starting with # are comments. Round-trips with FILEWRITE. Good for .env files:
DIM env$
LET env$ = FILEREAD(".env")
LET API_KEY# = env$("OPENAI_API_KEY")
FILELIST: files only (no folders, not recursive), names only (no paths), sorted alphabetically ignoring case, hidden/system files skipped. The array is cleared first. Pattern supports * and ?, default all files. Missing folder → returns 0. To open a listed file, prepend the folder: FILEREAD("levels/" + files$(i$)).
Paths: Use / or \\ — never a single \ (escape char). Relative paths are from PRG_ROOT#, which already ends with a separator: PRG_ROOT# + "data.txt". This also covers asset loads: LOADIMAGE, LOADSHEET, LOADSOUND, LOADFONT and SAVESCREEN resolve relative paths from the program folder too.
Network
LET res$ = HTTPGET("https://api.example.com/data")
LET res$ = HTTPPOST("https://api.example.com/submit", "{""key"":""val""}")
' Optional headers
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$)
' Optional timeout in seconds, AFTER headers (default 30, 0 = no limit)
LET res$ = HTTPPOST("http://localhost:11434/v1/chat/completions", body$, headers$, 120)
Failed requests do not stop the program. On connection error, unknown host or timeout, HTTPGET/HTTPPOST return "" and HTTPERROR holds the reason ("" after a successful call; parentheses optional). Check it right after the call:
LET res$ = HTTPGET(url$)
IF HTTPERROR <> "" THEN
PRINT "Source is down: "; HTTPERROR
ELSE
' use res$
END IF
HTTPERRORhas no$— it is a built-in function likeTICKS, not a variable.- An invalid URL (not
http:///https://) is still a program-stopping error. - HTTP error statuses (404, 500…) are not errors: the body (often an HTML error page) is returned and
HTTPERRORis"". ""alone does not prove failure — a server may answer with an empty body. UseHTTPERRORwhen it matters.
Local HTTP server (LISTEN)
Small HTTP server, typically glue between a static HTML page and a BazzBasic script on the same machine.
STARTLISTEN 8080 ' Bind 127.0.0.1:8080, no admin needed
STARTLISTEN 8080, 5000 ' Optional timeout in ms (0 = wait forever)
STARTLISTEN 8080, 0, "*" ' Optional host: "*" = all network interfaces
LET body$ = GETREQUEST() ' POST/PUT/PATCH body or GET query string ("" on timeout)
SENDRESPONSE "{""status"":""ok""}" ' Must be called or the browser hangs
STOPLISTEN
- Always pair
GETREQUEST()withSENDRESPONSE. - Default is
127.0.0.1. Use a host ("*"or an address) only when the user wants other computers to connect. Then tell them: Windows needs a one-timenetsh http add urlacl url=http://+:PORT/ user=Everyoneas administrator (STARTLISTEN's error prints the exact command), the firewall must allow the port, and the server is plain HTTP with no authentication or body size limit. - Host is positional: it is the third argument, so pass a timeout first (
0for none). - Body or query string only (no
?). Headers, method and URL path are not exposed. Parse JSON bodies withASARRAY. - OPTIONS preflight and CORS are automatic. Don't handle
OPTIONS; every response carriesAccess-Control-Allow-Origin: *. - One listener at a time. Call
STOPLISTENbefore anotherSTARTLISTEN. - Always 200 OK, always
text/plain. To return JSON, put JSON text in the body — browser-sideresponse.json()still works.
STARTLISTEN 8080
PRINT "Waiting for browser..."
LET json$ = GETREQUEST()
DIM data$
LET count$ = ASARRAY(data$, json$)
PRINT "Got name: " + data$("name")
SENDRESPONSE "{""status"":""ok""}"
STOPLISTEN
END
Arrays & JSON (and XML)
Nested JSON maps to comma-separated keys: data$("player,name"), data$("skills,0").
LET json$ = ASJSON(arr$) ' Array → JSON string
DIM data$
LET count$ = ASARRAY(data$, json$) ' JSON string → array, returns element count
LOADJSON arr$, "file.json" ' Load JSON file
SAVEJSON arr$, "file.json" ' Save JSON file
ASARRAY on an empty string is an error. A failed HTTPGET/HTTPPOST returns "", so check HTTPERROR before passing the response to ASARRAY.
ASJSON/SAVEJSON emit a JSON array at a level only when all its keys are canonical non-negative ints ("0", "1", ... — no sign, leading zeros or spaces) and the max index is <= 1,000,000 or the level is dense (max < 4*count+64); otherwise a JSON object with the original keys. A huge key (arr$("2147483647")) returns instantly as an object instead of freezing (before 1.7); "-5"/"007" keys are kept as properties, not dropped. ASARRAY/LOADJSON read both shapes back to the same keys (arrays → "0".."n-1", objects → verbatim names; null holes skipped).
Keys keep their case in both directions (D12): arr$("key") and arr$("KEY") stay two keys — ASJSON gives {"key":"lower","KEY":"upper"}, at every nesting level. Before 1.7 the write path collapsed case-differing keys and lost a value.
XML (light model)
ASARRAY also reads XML. It picks the format from the first character: { or [ = JSON, < = XML (BOM and whitespace skipped). Prefer JSON. Use XML only when the task requires it — an RSS/Atom feed, or an API or file that only offers XML. JSON keys are shorter, numbers stay numbers, and it maps to arrays cleanly.
LET n$ = ASARRAY(feed$, xml$) ' XML string → array
LET xml$ = ASXML(arr$) ' Array → XML string
LOADXML arr$, "file.xml" ' Load XML file
SAVEXML arr$, "file.xml" ' Save XML file (indented, with <?xml ...?>)
- Every element below the root is indexed, even a single one. Never drop the
,0:feed$("rss,channel,0,item,0,title,0"), notfeed$("rss,channel,item,title"). - Attributes:
...,guid,0,@isPermaLink. Text of an element that also has attributes or children:...,guid,0,#text. - Prefixes kept as written:
...,dc:creator,0. CDATA is plain text. Comments and DTDs are ignored. - All values are strings — use
VAL()for numbers. Mixed text-and-element order is lost. ASXML: a single top-level key becomes the root element, otherwise<root>. Keys must be valid XML names (no spaces).- XML is not HTML: a web page does not parse as XML.
' RSS reader
LET xml$ = HTTPGET("https://www.example.com/rss.xml")
IF HTTPERROR <> "" THEN
PRINT "Feed is down: "; HTTPERROR
END
END IF
DIM feed$
LET n$ = ASARRAY(feed$, xml$)
PRINT feed$("rss,channel,0,title,0")
LET i$ = 0
WHILE HASKEY(feed$("rss,channel,0,item," + i$ + ",title,0"))
PRINT "- "; feed$("rss,channel,0,item," + i$ + ",title,0")
i$ += 1
WEND
END
Passing Arrays to Functions
Serialize with ASJSON, pass the string, rebuild inside with ASARRAY. The function gets an independent copy — changes inside do not affect the original. Nested keys work normally.
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
Date & Time
LET t$ = TIME() ' Default "HH:mm:ss" -> "15:21:22"
LET t2$ = TIME("dd.MM.yyyy") ' .NET DateTime format -> "04.09.2026"
LET t3$ = TIME("dddd") ' -> "Friday"
LET start$ = TICKS ' Milliseconds since program start
Timing — SLEEP and TICKS do different jobs:
- Frame pacing: in graphics mode, VSync (on by default) waits at
SCREENLOCK OFF, limiting the loop to the monitor's refresh rate — usually 60 FPS, but 144 FPS on a 144 Hz monitor. Do NOT addSLEEP 16to a graphics loop — together they halve the frame rate. - SLEEP ms: use for deliberate pauses (title screens, "Game Over" delays) and to keep console loops from using 100% CPU (
SLEEP 10in anINKEYpolling loop). - TICKS: use for measuring time — timers, cooldowns, animation speed, and movement that should stay the same speed on every monitor.
[inits]
LET running$ = TRUE
LET lastTick$ = TICKS
LET delta$
LET x$ = 0, speed$ = 2 ' several variables in one LET
[main]
WHILE running$
delta$ = TICKS - lastTick$
lastTick$ = TICKS
x$ = x$ + speed$ * delta$ / 16 ' same speed regardless of frame rate
GOSUB [sub:draw]
WEND
END
Command-Line Arguments
' bazzbasic.exe myprog.bas arg1 arg2
PRINT ARGCOUNT ' 2
PRINT ARGS(0) ' "arg1"
PRINT ARGS(1) ' "arg2"
0-based; does not include the interpreter or script name.
Packaged -exe programs receive arguments identically (prog.exe arg1 arg2); inside a packaged exe, flags like -v are not special — they arrive as ordinary ARGS() strings.
Libraries & INCLUDE
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 (
#). .bbfiles are version-locked to the build that produced them — recompile after upgrading.- No extension fallback:
INCLUDE "helpers"does NOT tryhelpers.bas. - Path resolution: relative to the including file's directory first, then the program's base path.
- Circular includes halt with
Circular INCLUDE detected: <file>. - A .bb library is never embedded into an -exe package - ship it next to the exe (only .bas INCLUDEs are embedded).
Program Structure
' ---- 1. FUNCTIONS (or INCLUDE) ----
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 ----
[inits]
LET SCREEN_W# = 640
LET SCREEN_H# = 480
LET MAX_SPEED# = 5
LET PLAYER_COLOR# = RGB(0, 255, 0)
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] ' SCREENLOCK OFF + VSync paces the loop to the monitor refresh rate
WEND
SOUNDSTOPALL
END
' ---- 4. SUBROUTINES (or INCLUDE) ----
[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, PLAYER_COLOR#, 1
SCREENLOCK OFF
RETURN
Naming conventions: variables camelCase$, constants UPPER_SNAKE_CASE#, functions PascalCase$, labels [gameLoop] for jump targets and [sub:name] for subroutines.
IDE
From version 1.6, the IDE (BazzBasic-IDE.exe) and interpreter (BazzBasic.exe) are separate programs in the same release .zip. Launching the interpreter without arguments tries to open the IDE; if that fails, it prints a message to the console.
| Menu | Items |
|---|---|
| File | New, Open, Save, Save As, Save All, Close Tab, Close All, Restore Session on Startup¹, Print, Exit |
| Edit | Undo, Redo, Cut, Copy, Paste, Select All, Comment Selection, Uncomment Selection |
| Search | Find, Replace |
| View | Tree View¹ (DEF FN functions and labels on the left), Open Console², Open File Browser², Light Mode¹, Dark Mode (experimental)¹, Syntax Coloring¹ (off = monochrome), Take a Screenshot to Clipboard (IDE window only), Zoom In, Zoom Out |
| Run | Run Program (F5), Compile as Exe, Compile as Library (.bb), Path to BazzBasic.exe³ |
| Help | About, Homepage, Online Manual, Beginner's Guide, Rosetta Code, Check for Updates |
¹ Saved to %AppData%\BazzBasic\ide.json
² Opens in the current file's folder
³ Used if set; otherwise the IDE's own folder, then PATH
- Compile commands auto-save the file first.
- Help-menu links open the URLs listed at the top of this guide.
- CLI equivalents:
bazzbasic.exe -guide/-helpprints the Beginner's Guide URL,bazzbasic.exe -checkupdateschecks for a newer version. - New files get this template:
' BazzBasic version {ver_num}
' https://ekbass.github.io/BazzBasic/