Every keyword
All 85 of them, alphabetically, each with an example you can type straight in. The output printed under each one is what the machine prints.
By what it does
| Job | Keywords |
|---|---|
| Writing and running | RUN, LIST, NEW, CLR, REM, END, STOP, CONT |
| Values | LET, DIM, DEF, FN |
| Showing things | PRINT, TAB, SPC, POS, HEX |
| Asking | INPUT, INKEY, JOY |
| Deciding | IF, THEN, ELSE, AND, OR, NOT |
| Repeating | FOR, NEXT, TO, STEP |
| Jumping | GOTO, GOSUB, RETURN, ON |
| Built-in lists | DATA, READ, RESTORE |
| Arithmetic | SGN, INT, ABS, SQR, RND, LOG, EXP, SIN, COS, TAN, ATN, MIN, MAX |
| Text | LEN, LEFT$, RIGHT$, MID$, CHR$, ASC, STR$, VAL |
| Screen and sound | CLS, LOCATE, COLOR, SOUND, VOL |
| The memory card | DIR, LOAD, SAVE, DEL, DISK, FORMAT, BLOAD, BSAVE |
| Clock and lasting memory | TIME, DATE, SETTIME, SETDATE, NVRAM |
| The machine underneath | PEEK, POKE, SYS, BANK, MEM, FRE, WAIT, PAUSE, BRK |
Operator precedence
Highest first. Anything on the same row goes left to right, and parentheses beat all of it.
| Operators | |
|---|---|
| Power | ^ |
| Unary | -+ |
| Multiplicative | */ |
| Additive | +- |
| Relational | =<><><=>= |
| Logical NOT | NOT |
| Logical AND | AND |
| Logical OR | OR |
The keywords
ABS
ABS(x)
The size of a number, ignoring its sign.
PRINT ABS(-5); ABS(5) 5 5AND
a AND b
True when both sides are true — and, underneath, a bit-by-bit AND of two whole numbers.
PRINT (5 > 3) AND (2 > 1)
PRINT 12 AND 10-1
8ASC
ASC(s$)
The code of the first character of a string.
PRINT ASC("A") 65ATN
ATN(x)
Arctangent, in radians. `ATN(1) * 4` is a serviceable π.
PRINT ATN(1) * 4 3.14159265BANK
BANK n
Choose which bank of extra RAM appears in the window at 32768.
BANK 1
POKE 32768, 42
BANK 0
PRINT PEEK(32768)
BANK 1
PRINT PEEK(32768) 0
42BLOAD
BLOAD addr, "name"
Read a file of raw bytes straight back into memory.
POKE 2560, 42
BSAVE 2560, 1, "SCORE.DAT"
POKE 2560, 0
BLOAD 2560, "SCORE.DAT"
PRINT PEEK(2560) 42BRK
BRK
Drop into the machine-code Monitor. `X` at the Monitor's `.` prompt comes back to BASIC.
BRKThe Monitor starts and shows the registers.
BSAVE
BSAVE addr, len, "name"
Write raw bytes straight from memory to a file — a high score, a screen, a level.
POKE 2560, 42
BSAVE 2560, 1, "SCORE.DAT"
DIRSCORE .DAT 1CHR$
CHR$(n)
The character with code `n`.
PRINT CHR$(72); CHR$(73)HICLR
CLR
Clear the variables, arrays and strings but keep the program.
A = 5
CLR
PRINT A 0CLS
CLS
Clear the screen and put the cursor at the top left.
10 CLS
20 PRINT "A FRESH SCREEN"COLOR
COLOR fg, bg
Set the text and background colors, each 0 to 15, for everything printed from now on.
10 CLS
20 COLOR 1, 15
30 PRINT "DARK ON WHITE"CONT
CONT
Carry on from a `STOP` or a stopped program, at the line after the one it stopped on. Editing any line first makes it impossible.
10 PRINT "A"
20 STOP
30 PRINT "B"A
BREAK IN 20
BCOS
COS(x)
Cosine of an angle in radians.
PRINT COS(0) 1DATA
DATA item [, item ...]
A list of values baked into the program for `READ` to work through. Skipped when the program runs past it.
10 DATA 262, 294, 330
20 READ A, B, C
30 PRINT A; B; C 262 294 330DATE
DATE
Print today's date from the battery-backed clock.
SETDATE 20, 26, 8, 3
DATE2026-08-03DEF
DEF FN name(var) = expr
Define your own one-line function.
10 DEF FN F(C) = C * 9 / 5 + 32
20 PRINT FN F(100) 212DEL
DEL "name"
Delete a file from the current disk.
DEL "HELLO.TXT"
DIRDISK 0DIM
DIM var(size) [, var(size) ...]
Make an array. One dimension only, and you get elements `0` to `size` — so `DIM S(9)` is ten of them.
10 DIM S(3)
20 S(0) = 10
30 S(3) = 40
40 PRINT S(0); S(3) 10 40DIR
DIR
List the files on the current disk, with their sizes in bytes.
DIRDISK 0
HELLO .TXT 6DISK
DISK n
Choose which of the card's 256 one-megabyte disks to work with.
DISK 3
MEMDISK 3ELSE
IF expr THEN stmt ELSE stmt
What to do when the test does not hold.
10 IF 1 = 2 THEN PRINT "YES" ELSE PRINT "NO"NOEND
END
Stop the program and return to the prompt. Variables keep their values.
10 PRINT "DONE"
20 END
30 PRINT "NEVER"DONEEXP
EXP(x)
`e` raised to the power `x`.
PRINT EXP(1) 2.71828183FN
FN name(expr)
Call a function you defined with `DEF`.
10 DEF FN D(N) = N * 2
20 PRINT FN D(21) 42FOR
FOR var = start TO limit [STEP step]
Count from one number to another, running everything up to `NEXT` each time through.
10 FOR N = 1 TO 4
20 PRINT N; " SQUARED IS"; N * N
30 NEXT N 1 SQUARED IS 1
4 SQUARED IS 16FORMAT
FORMAT
Erase the current disk and start it fresh. Asks first.
FORMATIt asks before erasing anything.
FRE
FRE(x)
How many bytes are left for variables, arrays and strings. The argument is ignored.
NEW
PRINT FRE(0) 30718GOSUB
GOSUB linenum
Jump to a subroutine, remembering where you came from. `RETURN` comes back.
10 GOSUB 100
20 PRINT "BACK"
30 END
100 PRINT "IN THE SUBROUTINE"
110 RETURNIN THE SUBROUTINE
BACKGOTO
GOTO linenum
Jump to a line and carry on from there.
10 PRINT "HELLO"
20 GOTO 40
30 PRINT "SKIPPED"
40 PRINT "END"HELLO
ENDHEX
HEX(n)
A number written in hexadecimal, always four digits with a `$` in front. `n` is 0 to 65535.
PRINT HEX(255); " "; HEX(4096)$00FF $1000IF
IF expr THEN stmt|linenum [ELSE stmt|linenum]
Do something only when a test holds. `THEN 100` is short for `THEN GOTO 100`.
10 A = 7
20 IF A > 5 THEN PRINT "BIG" ELSE PRINT "SMALL"BIGINKEY
INKEY
The code of a key being pressed right now, or `0` if none. Does not wait — put it in a loop.
PRINT INKEY 0INPUT
INPUT ["prompt";] var [, var ...]
Stop and wait for the person at the keyboard to type something. Only works inside a program.
10 INPUT "HOW OLD ARE YOU"; A
20 PRINT "IN DOG YEARS:"; A * 7IN DOG YEARS: 63INT
INT(x)
Round down to a whole number — down towards minus infinity, so `INT(-3.7)` is `-4`.
PRINT INT(3.7); INT(-3.7) 3-4JOY
JOY(n)
Read joystick 1 or 2. The bits are **active low** — a bit that reads `0` is a direction being pushed, so test with `= 0`, not with `<> 0`.
PRINT JOY(1)255 with nothing being pushed: every bit high.
LEFT$
LEFT$(s$, n)
The first `n` characters of a string.
PRINT LEFT$("HELLO", 2)HELEN
LEN(s$)
How many characters are in a string.
PRINT LEN("HELLO") 5LET
[LET] var = expr
Give a variable a value. `LET` is optional and almost nobody types it.
LET P = 3
PRINT P * 100 300LIST
LIST
Show the program you have. It takes no line number — `LIST` lists the lot.
10 PRINT "HELLO"
20 GOTO 1010 PRINT "HELLO"
20 GOTO 10LOAD
LOAD "name" | LOAD
Read a program back off the card, replacing whatever is in memory. Bare `LOAD` receives one over the serial port by XModem.
10 PRINT "KEEP ME"
SAVE "KEEPER"
NEW
LOAD "KEEPER"
RUNKEEP MELOCATE
LOCATE row, col
Put the cursor somewhere. Rows are 0 to 23 down the screen, columns 0 to 39 across.
10 CLS
20 LOCATE 5, 10
30 PRINT "OVER HERE"LOG
LOG(x)
Natural logarithm.
PRINT LOG(1) 0MAX
MAX(a, b)
The larger of two numbers.
PRINT MAX(3, 7) 7MEM
MEM
Print free memory, which cards the machine found, and the current disk. A statement, not a function — `PRINT MEM` is a syntax error.
MEMFree bytes, the fitted-hardware byte, and the selected disk.
MID$
MID$(s$, start [, len])
Characters from the middle of a string, counting from 1. Leave `len` out to take the rest.
PRINT MID$("HELLO", 2, 3)
PRINT MID$("HELLO", 3)ELL
LLOMIN
MIN(a, b)
The smaller of two numbers.
PRINT MIN(3, 7) 3NEW
NEW
Throw the program away and clear the variables. There is no undo.
10 PRINT "HELLO"
NEW
PRINT FRE(0) 3071830718 bytes free — the same as a machine that has just been switched on, because the program is gone.
NEXT
NEXT [var]
End of a loop: add the step and go around again. One variable only — `NEXT J, I` is not accepted, so close each loop with its own `NEXT`.
10 FOR I = 1 TO 2
20 FOR J = 1 TO 2
30 PRINT I; J
40 NEXT J
50 NEXT I 1 1
2 2NOT
NOT expr
Flips every bit, which turns true (`-1`) into false (`0`) — but `NOT 1` is `-2`, not `0`, so use it on comparisons rather than on counts.
PRINT NOT (1 = 2)
PRINT NOT 1-1
-2NVRAM
NVRAM addr, value | NVRAM(addr)
256 bytes of memory on the clock card that survive a power cut. A statement to write one, a function to read one.
NVRAM 0, 123
PRINT NVRAM(0) 123ON
ON expr GOTO l1 [,l2 ...] | ON expr GOSUB l1 [,l2 ...]
Pick a destination by number: 1 takes the first line in the list, 2 the second. Out of range falls through to the next line.
10 N = 2
20 ON N GOSUB 100, 200
30 END
100 PRINT "FIRST"
110 RETURN
200 PRINT "SECOND"
210 RETURNSECONDOR
a OR b
True when either side is true — and, underneath, a bit-by-bit OR.
PRINT (1 > 2) OR (3 > 2)
PRINT 12 OR 10-1
14PAUSE
PAUSE n
Do nothing for `n` hundredths of a second.
10 PRINT "WAIT FOR IT"
20 PAUSE 50
30 PRINT "THERE"WAIT FOR IT
THEREPEEK
PEEK(addr)
Read one byte of memory, 0 to 255.
PRINT PEEK(781)The byte at address 781 — the machine's record of which cards are fitted.
POKE
POKE addr, value
Write one byte of memory. `value` is 0 to 255.
POKE 2560, 42
PRINT PEEK(2560) 42POS
POS(x)
Which column the cursor is on. The argument is ignored; give it `0`.
PRINT "AB"; POS(0)AB 2PRINT [item] [;|, item ...]
Show numbers and text. `;` joins items tightly, `,` moves to the next 14-column zone, and a trailing `;` or `,` holds the cursor on the line.
PRINT "TOTAL:"; 6 * 7TOTAL: 42READ
READ var [, var ...]
Take the next value from the `DATA` lists and put it in a variable.
10 DATA 10, 20
20 READ X
30 READ Y
40 PRINT X + Y 30REM
REM [text]
A remark. Everything after `REM` on the line is for people, not the machine.
10 REM SCORE KEEPER
20 S = 100
30 PRINT S 100RESTORE
RESTORE
Go back to the first `DATA` item, so you can read the list again.
10 DATA 5, 6
20 READ A
30 RESTORE
40 READ B
50 PRINT A; B 5 5RETURN
RETURN
Go back to the line after the `GOSUB` that called this subroutine.
10 GOSUB 100
20 END
100 PRINT "AND BACK"
110 RETURNAND BACKRIGHT$
RIGHT$(s$, n)
The last `n` characters of a string.
PRINT RIGHT$("HELLO", 3)LLORND
RND(x)
A random number from 0 up to (but not including) 1. A negative argument reseeds from that number, so the same seed replays the same sequence.
10 FOR N = 1 TO 3
20 PRINT INT(RND(1) * 6) + 1;
30 NEXT NThree dice rolls, each from 1 to 6.
RUN
RUN [linenum]
Run the program from the top, or from a line number if you give one. Clears the variables first.
10 PRINT "ONE"
20 PRINT "TWO"
30 PRINT "THREE"TWO
THREESAVE
SAVE "name" | SAVE
Write the program to the card. Bare `SAVE` sends it over the serial port instead, by XModem.
10 PRINT "KEEP ME"
SAVE "KEEPER"
DIRKEEPER . 18SETDATE
SETDATE cc, yy, mm, dd
Set the date: century, year within it, month, day. 2026 is `20, 26`.
SETDATE 20, 26, 12, 25
DATE2026-12-25SETTIME
SETTIME hh, mm, ss
Set the clock. It keeps running with the power off.
SETTIME 12, 30, 0
TIMEThe clock now reads half past twelve.
SGN
SGN(x)
`-1` for a negative number, `0` for zero, `1` for a positive one.
PRINT SGN(-4); SGN(0); SGN(9)-1 0 1SIN
SIN(x)
Sine of an angle in radians.
PRINT SIN(0) 0SOUND
SOUND voice, freq, dur
Play a note: `voice` 1 to 3, `freq` in hertz, `dur` in hundredths of a second. The program waits for the note to finish.
10 VOL 15
20 SOUND 1, 262, 20
30 SOUND 1, 330, 20
40 SOUND 1, 392, 20Three notes — the bottom of a C major chord.
SPC
SPC(n)
Inside `PRINT`, print `n` spaces from wherever the cursor is.
PRINT "A"; SPC(5); "B"A BSQR
SQR(x)
Square root.
PRINT SQR(144) 12STEP
FOR var = start TO limit STEP step
How much to add each time through. Negative counts down.
10 FOR N = 10 TO 1 STEP -3
20 PRINT N;
30 NEXT N 10 7 4 1STOP
STOP
Pause the program and say where it stopped. `CONT` picks it up again.
10 PRINT "FIRST"
20 STOP
30 PRINT "SECOND"FIRST
BREAK IN 20STR$
STR$(n)
A number turned into a string — keeping the leading space that `PRINT` puts where a minus sign would go.
PRINT "[" + STR$(42) + "]"[ 42]SYS
SYS addr
Call machine code at an address and come back when it returns.
POKE 2560, 96
SYS 2560
PRINT "BACK FROM MACHINE CODE"BACK FROM MACHINE CODETAB
TAB(n)
Inside `PRINT`, move to column `n` of the line.
PRINT "NAME"; TAB(12); "SCORE"NAME SCORETAN
TAN(x)
Tangent of an angle in radians.
PRINT TAN(0) 0THEN
IF expr THEN stmt|linenum
The part of `IF` that says what to do when the test holds.
10 IF 2 + 2 = 4 THEN PRINT "ARITHMETIC WORKS"ARITHMETIC WORKSTIME
TIME
Print the time of day from the battery-backed clock.
TIMEThe time, as `HH:MM:SS`.
TO
FOR var = start TO limit
The part of `FOR` that says where to count to.
10 FOR N = 3 TO 5
20 PRINT N;
30 NEXT N 3 4 5VAL
VAL(s$)
A string turned into a number. Reads as far as it can and gives `0` if that is nowhere.
PRINT VAL("3.5"); VAL("12ABC"); VAL("ABC") 3.5 12 0VOL
VOL n
Set the overall volume, 0 to 15.
10 VOL 8
20 SOUND 1, 440, 10
30 PRINT "THAT WAS A CONCERT A"THAT WAS A CONCERT AWAIT
WAIT addr, mask
Hold the program until reading `addr` and ANDing it with `mask` gives something other than zero. Nothing else happens while it waits.
POKE 2560, 1
WAIT 2560, 1
PRINT "BIT IS SET"BIT IS SET📄 BASIC Reference card — every keyword, the operator table and every error message, on three printable pages.