Senzall's BASIC

The Green Screen

When you open Senzall's BASIC, you see a classic green-on-black terminal — the same look that greeted millions of home computer users in the late 1970s and early 1980s. A blinking cursor waits at the bottom for you to type.

Everything happens through text. You type commands and programs. The computer responds with text. There are no buttons to click, no menus to navigate — just you and the machine, communicating through a language called BASIC.

The Keyboard

Below the terminal screen you'll find a custom keyboard designed for BASIC programming:

• Top navigation row — arrow keys (Left, Right, Up, Down), Tab, and Delete. These control cursor movement and editing.
• Symbol row — numbers 0-9 and common symbols like quotes, parentheses, equals, semicolons, commas, and math operators. Everything you need for BASIC expressions.
• QWERTY letter rows — standard letter keys. BASIC commands are typed in uppercase, but the interpreter isn't case-sensitive — it understands both.
• Bottom row — Space bar and Return key to enter your commands.

The Learn Button

In the top corner of the screen you'll find the Learn button. Tap it to open a quick-reference card with all the BASIC commands, their syntax, and short examples. It's your cheat sheet while you're learning.

Immediate Commands

Some things you type are executed immediately, without a line number:

• RUN — execute the program currently in memory, starting from the lowest line number
• LIST — display all the program lines in order so you can see your code
• NEW — erase the entire program from memory and start fresh
• SAMPLES — open the sample program browser with 10 built-in example programs

How Numbered Lines Work

In BASIC, every line of your program starts with a line number. The computer stores lines in numerical order and executes them that way. This is how you build a program:

The numbers don't have to be consecutive. By convention, you number lines by 10s (10, 20, 30...) so you can insert new lines between existing ones later:

To delete a line, type just its number and press Return. To replace a line, type the same number with new content — it overwrites the old version.

PRINT

Display text, numbers, and the values of variables on the screen. The most fundamental command in BASIC.

Print a string

Print a variable

Print an expression

Mix text and values

Semicolons suppress the newline

Normally each PRINT goes to a new line. A semicolon at the end keeps the cursor on the same line:

Output: HELLO WORLD (on one line)

INPUT

Ask the user to type a value. The program pauses and waits for input.

With a prompt

Numeric input

Use a regular variable name (like X, N, AGE) for numbers. Use a variable ending in $ (like N$, A$, NAME$) for text strings.

LET

Assign a value to a variable. The word LET is optional — both forms work identically.

Variables can hold numbers or strings. String variable names always end with a dollar sign ($). You can use any math expression on the right side: addition (+), subtraction (-), multiplication (*), division (/), and parentheses for grouping.

GOTO

Jump to a specific line number. Execution continues from that line. This is how you create loops in BASIC.

This creates an infinite loop — the program prints the message, jumps back to line 10, prints it again, and so on. To stop a running program, tap the Stop button.

IF...THEN

Make decisions. If the condition is true, the command after THEN executes. If false, the program skips to the next line.

Simple comparison

Comparison operators

Use = (equal), <> (not equal), < (less than), > (greater than), <= (less or equal), >= (greater or equal).

IF...THEN GOTO

FOR...NEXT

Repeat a block of code a specific number of times. The loop variable counts up (or down) automatically.

Basic loop

Output: 1, 2, 3, 4, 5 (each on its own line)

Using STEP

Output: 0, 5, 10, 15, 20. The STEP value controls how much the counter increases each time. Use a negative STEP to count down:

Nested loops

This prints a 3-by-4 grid of stars. The inner loop (COL) runs completely for each pass of the outer loop (ROW).

GOSUB / RETURN

Call a subroutine. GOSUB jumps to a line number (like GOTO), but RETURN jumps back to where you left off. This lets you reuse code.

Line 20 jumps to line 100. Lines 100-120 execute. RETURN on line 120 jumps back to line 30. The END on line 40 prevents the program from accidentally falling into the subroutine again.

REM

Add a comment. Everything after REM on that line is ignored by the interpreter. Use comments to explain your code.

END and CLS

END stops the program. Use it to prevent execution from falling through into subroutines or data sections at the bottom of your code.

CLS clears the screen. Useful at the beginning of a program or when you want a fresh display.

Built-in Functions

Functions take a value and return a result. Use them inside expressions.

• INT(x) — rounds down to the nearest whole number. INT(3.7) returns 3. INT(-2.3) returns -3.
• RND(x) — returns a random number from 0 to x-1. RND(10) gives 0 through 9. To get 1 through 10, use INT(RND(10)) + 1.
• ABS(x) — returns the absolute value (removes the negative sign). ABS(-5) returns 5. ABS(5) returns 5.
• LEN(x$) — returns the length of a string. LEN("HELLO") returns 5.

Random numbers in practice

String Variables and Concatenation

String variables hold text and always end with a $ sign. You can join strings together using the + operator.

Output:

Tutorial 1: Your First Program

Let's write the classic first program every programmer writes, then build on it.

Step 1 — Hello World

Type this line and press Return:

Nothing visible happens yet — you've just stored line 10 in memory. Now type:

The screen shows HELLO WORLD. You've just written and executed your first program.

Step 2 — Add more lines

Don't type NEW. Your program is still in memory. Add to it:

Type RUN again. Now it prints all three lines in order.

Step 3 — Use a variable

Let's make it personal. Add these lines:

Line 5 runs before line 10 (because 5 < 10). Line 20 replaces the old line 20. Type LIST to see your updated program, then RUN it. It asks your name, then greets you.

What you learned

PRINT displays text. INPUT asks for a response. Lines execute in numerical order. You can insert and replace lines anytime.

Tutorial 2: Making Decisions — Number Guessing Game

Let's build a game step by step. Type NEW first to clear any old program.

Step 1 — Pick a secret number

Line 20 picks a random number from 1 to 100 and stores it in the variable SECRET.

Step 2 — Ask for a guess

Step 3 — Check the guess

If the guess matches, jump to the win message (line 100). Otherwise, give a hint and loop back to ask again.

Step 4 — The win message

Run it!

Type RUN. The game picks a secret number, asks you to guess, gives you hints (too high / too low), and congratulates you when you get it right. Type RUN again for a new number.

What you learned

IF...THEN makes decisions. GOTO creates loops. RND generates random numbers. Variables store data that changes as the program runs.

Tutorial 3: Loops and Patterns — Star Pattern Maker

Let's use FOR...NEXT loops to draw patterns on screen. Type NEW first.

Step 1 — A simple row of stars

RUN it. You see: * * * * * * * * * *. The semicolon keeps each star on the same line. Line 40's empty PRINT moves to a new line at the end.

Step 2 — A triangle

Type NEW, then enter this program:

RUN it. Output:

The outer loop counts rows (1 to 5). The inner loop prints that many stars. Row 1 gets 1 star. Row 2 gets 2 stars. And so on.

Step 3 — Make it interactive

Let the user choose the size. Change line 10:

Now RUN it and try different sizes. Try 3. Try 10. Try 20.

Step 4 — Experiment!

Try changing line 30 to print different characters. Try PRINT "# "; or PRINT ROW; " "; to print numbers instead of stars.

What you learned

FOR...NEXT loops repeat code a set number of times. Nested loops (a loop inside a loop) create 2D patterns. The loop variable changes each time through.

• Tab — Load a line for editing. Type a line number and press Tab. That line's contents appear in the editor so you can modify it without retyping the whole thing.
• Up / Down arrows — Command history. Press Up to recall previous commands you've typed. Press Down to move forward through the history. Great for re-running or modifying recent commands.
• Left / Right arrows — Cursor movement. Move the cursor within the current line to insert or fix characters at any position.
• Delete a line. Type just the line number with no content and press Return. That line is erased from the program. For example, typing 15 and pressing Return deletes line 15.
• LIST to review. After making edits, type LIST to see your complete program in order. This is the fastest way to verify your changes look right.

Type SAMPLES to open the sample browser. Each program demonstrates a different concept. Load one, RUN it, then LIST it to see how it works.

• 1. Hello World — the classic first program. Teaches PRINT and string output.
• 2. Ask My Name — uses INPUT to read a response and PRINT to echo it back. Teaches variables and string input.
• 3. Countdown — counts from 10 to 1 and prints "LIFTOFF!" Teaches FOR...NEXT with a negative STEP.
• 4. Guessing Game — the computer picks a random number and you guess. Teaches IF...THEN, GOTO, and RND.
• 5. Times Table — prints a multiplication table for any number you choose. Teaches FOR...NEXT with expressions.
• 6. Star Triangle — draws a triangle made of stars. Teaches nested FOR...NEXT loops.
• 7. Dice Roller — simulates rolling two dice 100 times and counts the results. Teaches arrays and random numbers.
• 8. Temperature Converter — converts between Fahrenheit and Celsius. Teaches math expressions and subroutines (GOSUB/RETURN).
• 9. Number Sorter — sorts a list of numbers from smallest to largest. Teaches the bubble sort algorithm with nested loops.
• 10. Mini Adventure — a tiny text adventure game. Teaches combining IF...THEN, INPUT, GOTO, and program structure for a larger project.

• Start with SAMPLES. Load an example program, run it, then LIST it to see how it works. Modify a line and run again.
• Learn by experimenting. Change numbers, swap strings, add lines. You can't break anything — type NEW to start fresh.
• Number your lines by 10s. Use 10, 20, 30... so you can insert lines (15, 25) between them later.
• Use REM for notes. Add comments to remind yourself what each section does.
• Build up gradually. Start with a PRINT statement, then add INPUT, then IF...THEN. Layer concepts one at a time.
• Read the error messages. If something goes wrong, the interpreter tells you which line has the problem. Go fix that line and RUN again.
• Keep programs short at first. A 10-line program you understand is worth more than a 50-line program you copied. Build complexity as your confidence grows.