go-basic: Turbo BASIC and QBasic, compiled to Go

What is go-basic?

go-basic is a real compiler pipeline: a hand-written lexer, a recursive-descent/Pratt parser, a semantic analyzer that infers types from BASIC's variable suffixes, and a code generator that emits idiomatic Go. Point it at a .bas file and it either prints the equivalent Go source or builds it straight into a standalone executable.

What sets it apart from a toy transpiler is the runtime: SCREEN graphics modes, sprites (GET/PUT), CIRCLE/LINE/PAINT/DRAW, and SOUND/PLAY audio are all reimplemented in pure Go on top of Ebiten and Oto. That's enough to run real DOS-era software, not just PRINT demos.

• Open source
• MIT licensed
• Go 1.24+
• 65 example programs
• Bytecode VM
• Free

Features

In action: QBasic Gorillas

The classic QBasic Gorillas game, compiled straight from its original .bas source and running as a native Go binary through go-basic's graphics runtime:

./go-basic compile examples/gorilla.bas
./gorilla

What the transpiler produces

A BASIC program becomes readable, idiomatic Go — loops become for, typed variables keep their BASIC-inferred type, and PRINT maps to fmt.

10 PRINT "HELLO WORLD"
20 FOR I = 1 TO 5
30   PRINT "COUNT:"; I
40 NEXT I
50 END

package main

import "fmt"

func main() {
    fmt.Println("HELLO WORLD")
    var I float32
    for I = float32(1); I <= float32(5); I += float32(1) {
        fmt.Print("COUNT:", I)
        fmt.Println()
    }
}

Language support

Screen modes

Quick start

Requires Go 1.24+. The graphics/audio runtime uses Ebiten and Oto — macOS and Windows need nothing extra; Linux (Debian/Ubuntu) needs a handful of system packages for OpenGL, X11, and ALSA.

git clone https://github.com/andrewloable/go-basic.git
cd go-basic
go build -o go-basic .

Compile a .bas file straight to a binary

./go-basic compile examples/gorilla.bas
./go-basic compile examples/gorilla.bas -o mygame
./gorilla

Or just transpile to Go source

./go-basic transpile examples/gorilla.bas -o gorilla.go

Useful for inspecting the generated code, hand-editing it, or wiring it into a larger Go project.

How it works

A classical multi-stage compiler pipeline, each stage in its own internal/ package:

1. Lexer. A hand-written scanner turns source text into a stream of typed tokens — keywords, type suffixes (% & ! # $), string and numeric literals (decimal, hex &H, octal &O), and line structure.
2. Parser. Recursive descent for statements, Pratt (TDOP) parsing for expressions, resolving BASIC's ambiguity between function calls, array access, and plain variable references into a typed AST.
3. Semantic analysis. Builds a symbol table with types inferred from variable suffixes, DIM declarations, and assignment context.
4. Code generation. A tree-walking transpiler maps BASIC constructs to Go equivalents, calling into a runtime library for BASIC-specific behavior.
5. Runtime. Pure Go implementations of BASIC builtins — math, strings, formatted output, file I/O, graphics, and sound.

A second backend, the bytecode VM, skips Go codegen entirely: it compiles the AST straight to stack-based bytecode and interprets it.

Status

The examples/ directory ranges from hello-world to the full Gorillas game — try circle_draw.bas or fibonacci.bas for smaller demos.