diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
new file mode 100644
index 00000000..e5fe3642
--- /dev/null
+++ b/.github/workflows/docs.yml
@@ -0,0 +1,48 @@
+name: Build & Deploy Docs
+
+on:
+  push:
+    branches: [main]
+    paths: ["sphinx-docs/**"]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "pages"
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install dependencies
+        run: pip install -r sphinx-docs/requirements.txt
+
+      - name: Build HTML
+        run: sphinx-build -b html sphinx-docs sphinx-docs/_build/html
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: sphinx-docs/_build/html
+
+  deploy:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
diff --git a/.gitignore b/.gitignore
index bf87b75d..c04defa6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,5 +4,6 @@ __pycache__
 .release
 dist
 **/generated/timestamp.asm
+sphinx-docs/_build/
 **/generated/version.asm
 uv.lock
diff --git a/sphinx-docs/Makefile b/sphinx-docs/Makefile
new file mode 100644
index 00000000..0d4f9c25
--- /dev/null
+++ b/sphinx-docs/Makefile
@@ -0,0 +1,18 @@
+.PHONY: html pdf livehtml clean
+
+# Mermaid CLI needs a Chrome headless shell; point it at whatever is cached.
+CHROME_HS := $(firstword $(wildcard $(HOME)/.cache/puppeteer/chrome-headless-shell/*/chrome-headless-shell-*/chrome-headless-shell))
+export PUPPETEER_EXECUTABLE_PATH := $(CHROME_HS)
+
+html:
+	uv run sphinx-build -b html . _build/html
+
+pdf:
+	uv run sphinx-build -b latex . _build/latex
+	cd _build/latex && xelatex f256-superbasic.tex && xelatex f256-superbasic.tex
+
+livehtml:
+	uv run sphinx-autobuild . _build/html --port 8000
+
+clean:
+	rm -rf _build
diff --git a/sphinx-docs/_static/custom.css b/sphinx-docs/_static/custom.css
new file mode 100644
index 00000000..889fe673
--- /dev/null
+++ b/sphinx-docs/_static/custom.css
@@ -0,0 +1,133 @@
+/* Wildbits brand colors */
+:root {
+    --wb-navy: #272662;
+    --wb-red: #EE4025;
+    --wb-orange: #F1632B;
+    --wb-gold: #FDBB3A;
+    --wb-green: #44A348;
+    --wb-teal: #6BA7BB;
+}
+
+/* Consistent table widths */
+table.docutils {
+    width: 100%;
+}
+
+/* Mermaid diagram sizing */
+.mermaid {
+    margin: 0.75em 0;
+}
+
+.mermaid svg {
+    max-height: 180px;
+}
+
+/* Admonition styling — note */
+.admonition.note {
+    border-left: 4px solid var(--wb-navy);
+    background: color-mix(in srgb, var(--wb-navy) 8%, transparent);
+}
+.admonition.note > .admonition-title {
+    background: color-mix(in srgb, var(--wb-navy) 15%, transparent);
+    color: var(--wb-navy);
+}
+
+/* Admonition styling — warning */
+.admonition.warning {
+    border-left: 4px solid var(--wb-orange);
+    background: color-mix(in srgb, var(--wb-orange) 8%, transparent);
+}
+.admonition.warning > .admonition-title {
+    background: color-mix(in srgb, var(--wb-orange) 15%, transparent);
+    color: var(--wb-orange);
+}
+
+/* Admonition styling — tip / hint */
+.admonition.tip, .admonition.hint {
+    border-left: 4px solid var(--wb-green);
+    background: color-mix(in srgb, var(--wb-green) 8%, transparent);
+}
+.admonition.tip > .admonition-title,
+.admonition.hint > .admonition-title {
+    background: color-mix(in srgb, var(--wb-green) 15%, transparent);
+    color: var(--wb-green);
+}
+
+/* Admonition styling — danger / error */
+.admonition.danger, .admonition.error {
+    border-left: 4px solid var(--wb-red);
+    background: color-mix(in srgb, var(--wb-red) 8%, transparent);
+}
+.admonition.danger > .admonition-title,
+.admonition.error > .admonition-title {
+    background: color-mix(in srgb, var(--wb-red) 15%, transparent);
+    color: var(--wb-red);
+}
+
+/* Admonition styling — important */
+.admonition.important {
+    border-left: 4px solid var(--wb-gold);
+    background: color-mix(in srgb, var(--wb-gold) 8%, transparent);
+}
+.admonition.important > .admonition-title {
+    background: color-mix(in srgb, var(--wb-gold) 15%, transparent);
+    color: #8a6d00;
+}
+
+/* Generic admonitions (custom title) */
+.admonition:not(.note):not(.warning):not(.tip):not(.hint):not(.danger):not(.error):not(.important) {
+    border-left: 4px solid var(--wb-teal);
+    background: color-mix(in srgb, var(--wb-teal) 8%, transparent);
+}
+.admonition:not(.note):not(.warning):not(.tip):not(.hint):not(.danger):not(.error):not(.important) > .admonition-title {
+    background: color-mix(in srgb, var(--wb-teal) 15%, transparent);
+    color: var(--wb-navy);
+}
+
+/* Dark mode overrides */
+body[data-theme="dark"] .admonition.note {
+    background: color-mix(in srgb, var(--wb-navy) 15%, transparent);
+}
+body[data-theme="dark"] .admonition.note > .admonition-title {
+    background: color-mix(in srgb, var(--wb-navy) 25%, transparent);
+    color: var(--wb-teal);
+}
+body[data-theme="dark"] .admonition.warning {
+    background: color-mix(in srgb, var(--wb-orange) 12%, transparent);
+}
+body[data-theme="dark"] .admonition.warning > .admonition-title {
+    background: color-mix(in srgb, var(--wb-orange) 20%, transparent);
+    color: var(--wb-orange);
+}
+body[data-theme="dark"] .admonition.tip,
+body[data-theme="dark"] .admonition.hint {
+    background: color-mix(in srgb, var(--wb-green) 12%, transparent);
+}
+body[data-theme="dark"] .admonition.tip > .admonition-title,
+body[data-theme="dark"] .admonition.hint > .admonition-title {
+    background: color-mix(in srgb, var(--wb-green) 20%, transparent);
+    color: var(--wb-green);
+}
+body[data-theme="dark"] .admonition.danger,
+body[data-theme="dark"] .admonition.error {
+    background: color-mix(in srgb, var(--wb-red) 12%, transparent);
+}
+body[data-theme="dark"] .admonition.danger > .admonition-title,
+body[data-theme="dark"] .admonition.error > .admonition-title {
+    background: color-mix(in srgb, var(--wb-red) 20%, transparent);
+    color: var(--wb-red);
+}
+body[data-theme="dark"] .admonition.important {
+    background: color-mix(in srgb, var(--wb-gold) 12%, transparent);
+}
+body[data-theme="dark"] .admonition.important > .admonition-title {
+    background: color-mix(in srgb, var(--wb-gold) 20%, transparent);
+    color: var(--wb-gold);
+}
+body[data-theme="dark"] .admonition:not(.note):not(.warning):not(.tip):not(.hint):not(.danger):not(.error):not(.important) {
+    background: color-mix(in srgb, var(--wb-teal) 12%, transparent);
+}
+body[data-theme="dark"] .admonition:not(.note):not(.warning):not(.tip):not(.hint):not(.danger):not(.error):not(.important) > .admonition-title {
+    background: color-mix(in srgb, var(--wb-teal) 20%, transparent);
+    color: var(--wb-teal);
+}
diff --git a/sphinx-docs/conf.py b/sphinx-docs/conf.py
new file mode 100644
index 00000000..678cb51e
--- /dev/null
+++ b/sphinx-docs/conf.py
@@ -0,0 +1,155 @@
+# Configuration file for the Sphinx documentation builder.
+
+import sys
+import os
+sys.path.insert(0, os.path.abspath("."))
+
+from superbasic_lexer import SuperBASICLexer
+from sphinx.highlighting import lexers
+
+_lexer = SuperBASICLexer()
+lexers["basic"] = _lexer
+lexers["superbasic"] = _lexer
+
+project = "Wildbits SuperBASIC"
+copyright = "2023-2026, Paul Robson & Wildbits Computing Company"
+author = "Paul Robson & Wildbits Computing Company"
+release = "1.1"
+
+extensions = [
+    "myst_parser",
+    "sphinxcontrib.mermaid",
+    "sphinx_copybutton",
+    "sphinx_design",
+]
+
+myst_enable_extensions = [
+    "colon_fence",
+    "deflist",
+    "fieldlist",
+    "tasklist",
+]
+
+templates_path = ["_templates"]
+exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
+
+# -- Options for HTML output -------------------------------------------------
+
+html_theme = "furo"
+html_static_path = ["_static"]
+html_css_files = ["custom.css"]
+html_title = "Wildbits SuperBASIC"
+
+html_theme_options = {
+    "navigation_with_keys": True,
+}
+
+# -- Options for LaTeX output ------------------------------------------------
+
+latex_documents = [
+    (
+        "index",
+        "f256-superbasic.tex",
+        "Wildbits SuperBASIC Reference Manual",
+        "Paul Robson",
+        "manual",
+    ),
+]
+
+latex_elements = {
+    "papersize": "letterpaper",
+    "pointsize": "11pt",
+    "fncychap": r"\usepackage[Bjornstrup]{fncychap}",
+    "fontpkg": r"""
+\usepackage{fontspec}
+\setmainfont{NotoSerif}[
+  Extension=.ttf,
+  UprightFont=*-Regular,
+  BoldFont=*-Bold,
+  ItalicFont=*-Italic,
+  BoldItalicFont=*-BoldItalic,
+]
+\setsansfont{NotoSans}[
+  Extension=.ttf,
+  UprightFont=*-Regular,
+  BoldFont=*-Bold,
+  ItalicFont=*-Italic,
+  BoldItalicFont=*-BoldItalic,
+]
+\setmonofont{NotoSansMono}[
+  Extension=.ttf,
+  UprightFont=*-Regular,
+  BoldFont=*-Bold,
+]
+""",
+    "geometry": r"\usepackage[letterpaper,inner=1.5in,outer=1.0in,top=0.75in,bottom=0.75in]{geometry}",
+    "preamble": r"""
+% Match original reference manual styling
+\definecolor{darkblue}{rgb}{0.1, 0.0, 0.6}
+\definecolor{silver}{rgb}{0.85, 0.85, 0.85}
+\ChNumVar{\color{darkblue}\fontsize{76}{80}\usefont{OT1}{pzc}{m}{n}\selectfont}
+\ChTitleVar{\color{darkblue}\raggedleft\Huge\sffamily\bfseries}
+
+% Dark blue section headings
+\usepackage{sectsty}
+\allsectionsfont{\color{darkblue}\bfseries\sffamily}
+
+% Tighter TOC spacing
+\usepackage{tocloft}
+\setlength{\cftbeforechapskip}{6pt}
+\setlength{\cftbeforesecskip}{2pt}
+\renewcommand{\cftchapleader}{\cftdotfill{\cftdotsep}}
+
+% Reduce float spacing
+\setlength{\floatsep}{8pt plus 2pt minus 2pt}
+\setlength{\textfloatsep}{10pt plus 2pt minus 2pt}
+\setlength{\intextsep}{8pt plus 2pt minus 2pt}
+
+% Black hyperlinks like the original
+\hypersetup{colorlinks=true,linkcolor=black,urlcolor=darkblue}
+
+% Plain code blocks — no frame, no background (like the original verbatim style)
+\sphinxsetup{
+  VerbatimColor={rgb}{1,1,1},
+  VerbatimBorderColor={rgb}{1,1,1},
+  verbatimborder=0pt,
+}
+\fvset{fontsize=\small}
+""",
+    "maketitle": r"""
+\begin{titlepage}
+    \colorbox{silver}{\makebox[\textwidth][r]{
+    \shortstack{
+        \vspace{3cm} \\
+        \color{darkblue}\bfseries\sffamily\Huge Wildbits SuperBASIC Reference Manual}} \\
+    }
+    \vfill
+    \hfill\mbox{\color{darkblue}\bfseries\sffamily\Large Paul Robson}
+    \hfill\mbox{\color{darkblue}\bfseries\sffamily\large \today}
+\end{titlepage}
+""",
+    "tableofcontents": r"\sphinxtableofcontents",
+}
+
+# -- Mermaid options ---------------------------------------------------------
+
+mermaid_init_js = """mermaid.initialize({
+  startOnLoad: true,
+  theme: 'base',
+  themeVariables: {
+    primaryColor: '#272662',
+    primaryTextColor: '#fff',
+    primaryBorderColor: '#1a1a4a',
+    secondaryColor: '#F1632B',
+    secondaryTextColor: '#fff',
+    secondaryBorderColor: '#d14a1a',
+    tertiaryColor: '#44A348',
+    tertiaryTextColor: '#fff',
+    tertiaryBorderColor: '#358a38',
+    lineColor: '#272662',
+    textColor: '#272662',
+    nodeBorder: '#272662',
+  },
+  themeCSS: '.node .label { color: #fff !important; } .edgeLabel { color: #272662 !important; }'
+});"""
+mermaid_pdfcrop = "pdfcrop"
diff --git a/sphinx-docs/guide/assembler.md b/sphinx-docs/guide/assembler.md
new file mode 100644
index 00000000..65779524
--- /dev/null
+++ b/sphinx-docs/guide/assembler.md
@@ -0,0 +1,45 @@
+# Inline Assembly
+
+SuperBASIC has a built-in inline assembler, closely modelled on that of BASIC in the British Acorn machines (Atom, BBC Micro, Archimedes). Assembled routines can be called via the `call` statement.
+
+## How It Works
+
+The instructions, named after their 65C02 opcode equivalents, generate code — so as a simple example the instruction `txa` generates the machine code `$8A` in memory. If the instruction has an operand (say) `lda #size*2` the expression is evaluated and the appropriate 2 bytes are stored in memory.
+
+Labels are specified using `.<label name>`, e.g. `.loop`; this is equivalent to setting the variable `loop` to the current write address, which can then be used in expressions — such as `jmp loop`.
+
+## The Assemble Command
+
+Assembly is controlled by the `assemble` command. This has two parameters — the first indicates where the code is to be assembled in memory, and the second is a control byte.
+
+This has 2 bits. Bit 0 indicates the pass, and if zero will not flag errors such as branches being out of range. Bit 1, when set, causes the code generated by instructions like `txa` to be listed.
+
+```basic
+100   assemble $6000,2:lda #42:sta count:rts
+```
+
+This very short example will assemble the 5 (or 4 depending on the value of `count`) bytes starting from `$6000` — and it also outputs those bytes to the screen.
+
+## Two-Pass Assembly
+
+Assemblers often require multiple passes through the source, and this one is no exception. As the inline assembler is not an assembler per se, this is done in code, by running through the assembler code with different values in the second parameter of the `assemble` command.
+
+Normally these are wrapped in a loop for the two passes. This illustrates the need — the first time through the assembler doesn't know where `forward` is — the second time round it has been set by line 140, so the branch can be correctly calculated:
+
+```basic
+100   for pass = 0 to 1
+110     assemble $6000,pass
+120     bra forward
+130     jsr $FFE2
+140     .forward:rts
+150   next
+```
+
+Note that unlike the Acorn machines there are no square brackets to delimit the assembler code — assembler commands can be put in at any time.
+
+## Limitations
+
+There is a minor syntactic limitation, in that instructions that target the accumulator (`inc`, `dec`, `lsr`, `ror`, `asl` and `rol`) must not use the `A` postfix — so it is `inc` rather than `inc a`.
+
+More generally, this assembler should be used for writing supporting code for BASIC programs — to speed up a part that is too slow in an interpreted language. It could be used for writing much larger programs (I believe "Elite" was written with this sort of system), but you would be better off using an assembler like `64tass` or `acme`, and loading the generated code into memory with the `bload` command.
+
diff --git a/sphinx-docs/guide/crossdev.md b/sphinx-docs/guide/crossdev.md
new file mode 100644
index 00000000..75a598b4
--- /dev/null
+++ b/sphinx-docs/guide/crossdev.md
@@ -0,0 +1,58 @@
+# Cross Development of BASIC Programs
+
+Cross development is an alternative to the classic way of programming a Home Computer, where the programmer types code directly into the machine. Cross development allows you to write the code on a Personal Computer, and upload it through the USB debug port. It is also possible to do this with machine code and graphic and other data.
+
+## Assistance
+
+In the SuperBASIC git, <https://github.com/wildbitscomputing/superbasic>, each release contains a file `howto-crossdev-basic.zip` which gives everything you need to cross develop in BASIC and some example programs.
+
+## Connection
+
+To connect your Wildbits/K2 to a PC (Windows, Linux, Mac) you need a USB data cable — Micro USB for the Wildbits/Jr or Wildbits/K, or USB-C for the Wildbits/Jr2 or Wildbits/K2. Some cables only provide power; make sure yours supports data. The USB plug connects to the board, and the other end to the PC.
+
+## Software
+
+There are two ways of programming the board. I prefer FnxMgr (<https://github.com/pweingar/FoenixMgr>) which is a Python script which runs on all platforms, and can easily automate uploading. It can also be uploaded through the Foenix IDE on Windows.
+
+Besides Python version 3, the FnxMgr script requires `pyserial`.
+
+## BASIC
+
+The input to the program is standard ASCII files, with line numbers. Line numbers are required for editing only. (The `number.py` script on the SuperBASIC GitHub adds line numbers and the end-of-file marker automatically.) However, you do not need to use line numbers in programming, though `GOTO` and `GOSUB` are implemented if you wish, or want to port old software.
+
+I would start with something simple though:
+
+```basic
+10    print "Hello, world !"
+20    zap
+```
+
+Each file should end in a character with an ASCII code greater than 127, which marks the end of the file. You can copy one from the software in GitHub.
+
+## Uploading and Running
+
+This is written for boards which automatically start up into BASIC.
+
+Uploading works by loading the ASCII text into memory. It is then effectively "typed in" by either the `xload` command or the `xgo` command. The first loads the program in (and it can then be listed or edited or run in the normal way). The second loads and runs it.
+
+To load the program into memory to be "loaded" you need something like the below.
+
+### Linux Upload
+
+```bash
+python ../bin/fnxmgr.zip --port /dev/ttyUSB0 --binary load.bas --address 28000
+```
+
+### Windows Upload
+
+```text
+python ..\bin\fnxmgr.zip --port COM1 --binary load.bas --address 28000
+```
+
+## Memory Use
+
+Program text is uploaded to physical address `$28000` onwards. The `xload` and `xgo` commands
+read from this address until they encounter the end-of-file marker, so the upload area grows
+with the size of your source file. Be aware that very large files may overlap with sprite memory
+at `$30000`. For the full memory map including program pages, graphics regions, and the `LOMEM`
+command, see {doc}`memory`.
diff --git a/sphinx-docs/guide/getting_started.md b/sphinx-docs/guide/getting_started.md
new file mode 100644
index 00000000..5d0d1ead
--- /dev/null
+++ b/sphinx-docs/guide/getting_started.md
@@ -0,0 +1,70 @@
+# Getting Started
+
+## Writing Programs
+
+Programs in SuperBASIC are written in the classic style, using line numbers. A line number on its
+own deletes that line.
+
+```basic
+100   print "Hello, world!"
+110   zap
+```
+
+`list` operates as in most other systems, except you can also list a single procedure by name
+with `list <procedure>()`. Use commas, not dashes, to specify a range, e.g. `list 100,300`.
+
+It is easy to cross-develop in SuperBASIC (see Chapter 9), writing a program on your favourite text
+editor, and transfering it to the Wildbits over USB using the FnxMgr or the Foenix IDE. It is also possible to
+develop without line numbers and have them added as the last stage before uploading.
+
+Upper and lower case are treated as the same, so `myName`, `MYNAME`, and `MyName` all refer to the
+same variable. The only place where case matters is inside string constants.
+
+Programs can be loaded from or saved to an SD Card or an IEC-type drive (the 6-pin DIN serial port)
+using the `save` and `load` commands.
+
+The documentsdirectory in the SuperBASIC GitHub repository has a simple syntax highlighter for the
+Sublime Text editor.
+
+## Screen Editor
+
+The built-in screen editor lets you type, edit, and navigate program lines directly on the machine.
+
+### Editing
+
+| Key                 | Action                                      |
+|---------------------|---------------------------------------------|
+| Enter               | Submit the current line                     |
+| Shift+Enter         | Move to next line without submitting        |
+| DEL/Backspace       | Delete character before cursor              |
+| Ctrl+D              | Delete character at cursor                  |
+| Shift+DEL/Backspace | Insert a blank line                         |
+
+### Navigation
+
+| Key               | Action                                      |
+|-------------------|---------------------------------------------|
+| Arrow keys        | Move cursor up / down / left / right        |
+| Ctrl+Left         | Jump to previous word                       |
+| Ctrl+Right        | Jump to next word                           |
+| Ctrl+Up           | Jump to beginning of line                   |
+| Ctrl+Down         | Jump to end of line                         |
+
+### Scrolling
+
+| Key               | Action                                      |
+|-------------------|---------------------------------------------|
+| Fnx+Up            | Scroll screen up (show previous lines)      |
+| Fnx+Down          | Scroll screen down (show later lines)       |
+
+### Other
+
+| Key               | Action                                      |
+|-------------------|---------------------------------------------|
+| Shift+Home        | Clear screen                                |
+| Ctrl+C            | Break execution                             |
+
+Lines that are longer than the screen width automatically wrap to the next row. The editor
+handles wrapped lines seamlessly — cursor movement, deletion, and insertion all work correctly
+across wrapped rows.
+
diff --git a/sphinx-docs/guide/graphics.md b/sphinx-docs/guide/graphics.md
new file mode 100644
index 00000000..c839a90c
--- /dev/null
+++ b/sphinx-docs/guide/graphics.md
@@ -0,0 +1,88 @@
+# Graphics
+
+## Introduction
+
+The graphics subsystem consists of three components, which is a subset of the full capabilities of the Wildbits machines.
+
+| Layer | Description |
+|---|---|
+| Tile Map | 8×8 pixel tile grid, up to 256×256 tiles, scrollable |
+| Bitmap | 320×240 pixel screen drawn on top of the tile layer |
+| Sprites | Hardware sprites drawn on top of the bitmap |
+
+The graphics are much more complex than this; the system allows up to three tile maps for example. Those can be done in BASIC if you wish, by directly accessing the system registers, as covered in the hardware reference guide.
+
+## Bitmap Graphics
+
+Bitmap graphics can be done in one of three ways.
+
+- Firstly, they can be done using BASIC commands like `line`, `plot` and `text` — these are the easiest.
+- Secondly, they can be done by directly accessing the graphics library via the `gfx` command.
+- Thirdly, you can "hit the hardware" directly using `poke` and `pokw` or the indirection operators.
+
+The latter is the most flexible. BASIC simplifies the graphics system to some extent to make it easier to use; for example, the Wildbits/K2 can have up to three bitmaps, but only one is supported using BASIC commands.
+
+## Graphics Modifiers and Actions
+
+Following drawing commands `plot`, `line`, `rect`, `circle`, `sprite`, `char` and `image` there are actions and modifiers which either change or cause the command to be done (e.g. draw the line, draw the string, etc.). Changes persist, so if you set `color 3` or `solid` it will apply to all subsequent draws until you change it.
+
+Not all things work or make sense for all commands; you can't change the dimensions of a line, or the color of a hardware sprite.
+
+| Modifier | Description |
+|---|---|
+| `to 100,100` | Draws the object from the current point to the new point, or at the new point |
+| `from 10,10` | Sets the current point but doesn't draw. The `from` is optional but must be used where a number precedes the coordinates |
+| `here` | Same as `to` but done at the current point |
+| `by 4,5` | Same as `to` but offset from the current point by 4 horizontal, 5 vertical |
+| `solid` | Causes shapes to be filled in |
+| `outline` | Causes shapes to be drawn in outline |
+| `dim 3` | Sets the size of scalable objects (`char`, `image`) from 1 to 8 |
+| `color 4` / `color 5` | Synonyms (due to American misspelling); sets the drawing color from LUT 0, which is set up as `RRRGGGBB` |
+
+## Some Useful Examples
+
+All these examples begin `bitmap on:cls:bitmap clear 3` — display and clear the bitmap, then fill it with color 3. This is `0000 0011` — and the color by default is `RRRG GGBB` in binary — so this is blue.
+
+### Some Lines
+
+```basic
+100   bitmap on:cls:bitmap clear 3
+110   line color $1E from 10,10 to 100,200 to 200,50 to 10,10 by 0,20
+```
+
+Note how you can chain commands and also the use of the relative position `by` which means "from here".
+
+### Some Circles
+
+```basic
+100   bitmap on:cls:bitmap clear 3
+110   circle solid color $1E outline 10,10 to 200,200 solid 10,10 to 30,30
+```
+
+Rectangles are the same. Currently we cannot draw ellipses.
+
+### Some Text
+
+```basic
+100   bitmap on:cls:bitmap clear 3
+110   text "Hello there" dim 1 color $FC to 10,10 dim 3 to 10,40
+```
+
+Drawing text from the font library in Vicky. These characters can be redefined.
+
+### Some Pixels
+
+```basic
+100   bitmap on:cls:bitmap clear 3
+110   repeat
+120     plot color random(256) to random(320),random(230)
+130   until false
+```
+
+Press Break to stop this one. Note you have to write `PLOT TO` here.
+
+## Ranges
+
+The range of values for draw commands is 0–319 and normally 0–239, though there is a VGA mode which is 320×200 (in which case it would be 0–199).
+
+Colors are values from 0–255 — initially this can be viewed as a binary number `RRRGGGBB`.
diff --git a/sphinx-docs/guide/introduction.md b/sphinx-docs/guide/introduction.md
new file mode 100644
index 00000000..4ca62219
--- /dev/null
+++ b/sphinx-docs/guide/introduction.md
@@ -0,0 +1,15 @@
+# Introduction
+
+This manual provides a reference for SuperBASIC, a beginner-friendly programming language for the
+Foenix F256 series of personal computers. It is not a tutorial and assumes the reader has some prior
+knowledge of programming in general and of BASIC in particular.
+
+SuperBASIC builds upon the heritage of classic BASIC dialects while introducing a wide range of en-
+hancements that make programming even more fun and accessible. It is tightly integrated with the
+advanced hardware capabilities of the Wildbits platform, offering first-class access to graphics, sprites,
+game controllers, sound, and more. Notable language additions include structured control flow, named
+subroutines, inline assembly, and an enriched standard library.
+
+We’ve worked hard to make SuperBASIC a powerful and approachable language for curious minds of
+all ages. We hope you enjoy using it as much as we enjoyed creating it!
+
diff --git a/sphinx-docs/guide/memory.md b/sphinx-docs/guide/memory.md
new file mode 100644
index 00000000..5a906452
--- /dev/null
+++ b/sphinx-docs/guide/memory.md
@@ -0,0 +1,128 @@
+# Memory
+
+## CPU Address Space
+
+The 65C02 can only address 64KB directly. The Wildbits/K2 hardware uses an MMU (Memory
+Management Unit) to map 8KB pages from the full 512KB physical address space into the CPU's
+64KB window.
+
+On startup, SuperBASIC configures the CPU address space as follows:
+
+| Slot | CPU Address       | Size | Contents                          |
+|------|-------------------|------|-----------------------------------|
+| 0    | `$0000`–`$1FFF`  |  8KB | System workspace and variables    |
+| 1    | `$2000`–`$3FFF`  |  8KB | BASIC program page (banked)       |
+| 2–3  | `$4000`–`$7FFF`  | 16KB | Array and `alloc()` storage       |
+| 4–5  | `$8000`–`$BFFF`  | 16KB | SuperBASIC ROM                    |
+| 6    | `$C000`–`$DFFF`  |  8KB | Kernel / I/O registers            |
+| 7    | `$E000`–`$FFFF`  |  8KB | Kernel ROM                        |
+
+```{note}
+The `$C000`–`$DFFF` slot contains I/O registers and is used by the kernel. You can read and
+write I/O registers here, and SuperBASIC itself uses this slot to access text screen and colour
+RAM by temporarily mapping in different I/O pages. If you remap this slot, be sure to restore
+it before returning control to the system.
+```
+
+### Slot 0 detail (`$0000`–`$1FFF`)
+
+Slot 0 is identity-mapped to physical page 0 and holds all of the interpreter's runtime state:
+
+| Address           | Size   | Contents                                               |
+|-------------------|--------|--------------------------------------------------------|
+| `$0000`–`$002F`  |  48 B  | Kernel zero page                                       |
+| `$0030`–`$003F`  |  16 B  | SuperBASIC zero page (code pointer, temps, stack ptr)  |
+| `$0050`–`$00AF`  |  96 B  | Number stack (status, mantissa, exponent — 16 entries) |
+| `$0100`–`$01FF`  | 256 B  | 6502 hardware stack                                    |
+| `$0200`–`$03FF`  | 512 B  | Argument storage (pexec command line)                  |
+| `$0400`–`$041F`  |  32 B  | Control storage (`option` values)                      |
+| `$0420`–`$0BFF`  |  ~2 KB | General storage (token buffer, line buffer, assembler state, listing state) |
+| `$0C00`–`$0FFF`  | 512 B  | BASIC stack (FOR/NEXT, GOSUB, PROC frames — grows downward) |
+| `$1000`–`$1FFF`  |   4 KB | Variable space (identifiers and values; strings grow downward from `$1FFF`) |
+
+### Slot 1 — Program page (`$2000`–`$3FFF`)
+
+Slot 1 holds the currently active page of the BASIC program. The interpreter banks different
+physical pages into this slot via the MMU register at `$0009` as the program grows beyond a
+single 8KB page.
+
+### Slots 2–3 — Arrays (`$4000`–`$7FFF`)
+
+The 16KB array area holds data created by `dim` and memory allocated by `alloc()`. Allocation
+grows upward from `$4000`.
+
+## Physical Memory Map (512KB)
+
+The full 512KB of RAM is divided into 64 pages of 8KB each. SuperBASIC uses them as follows:
+
+| Pages | Physical Address    | Usage                                  |
+|-------|---------------------|----------------------------------------|
+| 0     | `$00000`–`$01FFF`  | System workspace and variables (see above) |
+| 1     | `$02000`–`$03FFF`  | Program page (banked into slot 1)      |
+| 2–3   | `$04000`–`$07FFF`  | Array and `alloc()` storage            |
+| 4–5   | `$08000`–`$0BFFF`  | SuperBASIC ROM                         |
+| 6     | `$0C000`–`$0DFFF`  | I/O space (kernel reserved)            |
+| 7     | `$0E000`–`$0FFFF`  | Kernel ROM                             |
+| 8–15  | `$10000`–`$1FFFF`  | Bitmap graphics (64KB)                 |
+| 16–17 | `$20000`–`$23FFF`  | Tile image data                        |
+| 18–19 | `$24000`–`$27FFF`  | Tile map data                          |
+| 20+   | `$28000`–           | Cross-development upload area (grows with source file size) |
+| 24–29 | `$30000`–`$3BFFF`  | Sprite data                            |
+| 30–47 | `$3C000`–`$5FFFF`  | Free                                   |
+| 48–63 | `$60000`–`$7FFFF`  | BASIC program pages (default)          |
+
+### Screen and colour RAM
+
+The text screen and colour attribute memory are not in the main RAM region. They live on
+I/O pages `$02` (text) and `$03` (colour) and are accessed by temporarily mapping them into the
+`$C000`–`$DFFF` slot.
+
+## Program Paging
+
+BASIC programs are stored in banked memory pages. When the program needs more space than
+a single 8KB page, SuperBASIC automatically allocates additional pages. The interpreter pages them
+in and out of the CPU address space (slot 1, `$2000`–`$3FFF`) transparently as the program runs.
+
+By default, program pages are allocated starting at page 48 (`$60000`). Up to 16 pages (128KB) are
+available for BASIC programs in the default configuration.
+
+## The `lomem` Command
+
+The `lomem` command lets you change the first page used for BASIC program storage. This is useful
+when you need to free up higher memory for graphics data, or when you want to make more pages
+available for larger programs.
+
+```basic
+100   lomem $50000
+```
+
+The argument is a physical memory address. SuperBASIC converts it to a page number internally.
+Valid values range from page 8 (`$10000`) up to page 63 (`$7E000`). The page number is calculated
+by dividing the address by 8192 (the size of one page).
+
+```{note}
+Setting `lomem` to a low address may overlap with graphics or sprite memory. Make sure
+the pages you allocate for BASIC programs do not conflict with other hardware resources you
+are using.
+```
+
+The `lomem` setting persists across `new` and `load` — once set, it stays in effect until you
+change it again or reset the machine.
+
+## The `fre` Function
+
+The `fre` function reports how much memory is available in each of the three storage areas:
+
+| Call       | Returns                                              |
+|------------|------------------------------------------------------|
+| `fre(0)`   | Free program memory (bytes remaining across all unallocated pages) |
+| `fre(-1)`  | Free variable and string space (bytes remaining in `$1000`–`$1FFF`) |
+| `fre(-2)`  | Free array and `alloc()` space (bytes remaining in `$4000`–`$7FFF`) |
+
+## Cross-Development Upload Area
+
+When cross-developing, program text is uploaded to physical address `$28000` onwards (starting
+at page 20). The `xload` and `xgo` commands read sequentially from this address until they
+encounter an end-of-file marker (any byte with bit 7 set), so the upload area grows with the
+size of the source file. A typical BASIC program fits in pages 20–21, but large files may extend
+further. See {doc}`crossdev` for details.
diff --git a/sphinx-docs/guide/sound.md b/sphinx-docs/guide/sound.md
new file mode 100644
index 00000000..660d7cc6
--- /dev/null
+++ b/sphinx-docs/guide/sound.md
@@ -0,0 +1,34 @@
+# Sound
+
+## Introduction
+
+Depending on the hardware model and generation, a Wildbits machine includes a stereo SN76489 sound chip, and may also feature additional audio hardware such as SID, OPL3, and MIDI chips.
+
+In SuperBASIC these are simplified, so the same tones are played on left or right channels simultaneously.
+
+## Channels
+
+There are four sound channels, numbered 0 to 3. Channels 0–2 are simple square wave channels; channel 3 is a noise channel.
+
+```{mermaid}
+flowchart TD
+    classDef primary fill:#272662,color:#fff,stroke:#1a1a4a
+    classDef secondary fill:#F1632B,color:#fff,stroke:#d14a1a
+    classDef accent fill:#44A348,color:#fff,stroke:#358a38
+
+    CH0["Channel 0 — Square"]:::primary --> MIX["Mixer"]:::accent
+    CH1["Channel 1 — Square"]:::primary --> MIX
+    CH2["Channel 2 — Square"]:::primary --> MIX
+    CH3["Channel 3 — Noise"]:::secondary --> MIX
+    MIX --> SPK["Speaker"]:::primary
+```
+
+Sounds have a queue of sounds to play. So you could queue up a series of notes to play and they will carry on playing one after the other (if they are on the same channel).
+
+SuperBASIC does not stop to play the sounds; it is processed in the background. Everything can be silenced with `sound off`.
+
+It is possible to set a parameter to automatically change the pitch of the channel as it plays to allow easy creation of simple warpy sound effects.
+
+## Easy Commands
+
+Four commands `zap`, `shoot`, `ping` and `explode` exist which play a simple sound effect.
diff --git a/sphinx-docs/guide/sprites.md b/sphinx-docs/guide/sprites.md
new file mode 100644
index 00000000..862406f3
--- /dev/null
+++ b/sphinx-docs/guide/sprites.md
@@ -0,0 +1,83 @@
+# Sprites
+
+## Introduction
+
+Sprites are graphic images of differing sizes (8×8, 16×16, 24×24 or 32×32) which can appear on top of a bitmap but which don't affect that bitmap. It is a bit like a cartoon where you have a background and animated characters are placed on it.
+
+The sprite command adopts the same syntax as the graphics commands in the previous section. An example is:
+
+```basic
+sprite 3 image 5 to 20,20
+```
+
+This manipulates sprite number 3 (there are 64, numbered 0–63), using image number 5, centred on screen position 20,20. The image number comes from the data set — in the example set below it would be `enemy.png` rotated by 90° — the sixth entry as we count from 0. You can change the location and image independently.
+
+Most of the theoretical graphics options do not work; you cannot colour, scale, flip etc. a sprite — the graphic is what it is. However, they are very fast compared with drawing an image on the screen using the `image` command.
+
+## Creating Sprites
+
+SuperBASIC by default loads sprite data to memory location `$30000`. This chapter explains how to create that data file. This can be done by the developer, or via a Python script.
+
+## Getting Images
+
+Sprite data is built from PNG images up to 32×32. There are some examples in the Solarfox directory in the GitHub: <https://github.com/wildbitscomputing/superbasic>.
+
+They can be created individually, or ripped from sprite sheets — this is what `ripgfx.py` is doing in the Makefile in `solarfox/graphics`; starting with the PNG file `source.png` it is informed where graphics are, and it tries to work out a bounding box for that graphic, and exports it to the various files.
+
+## Building a Sprite Data Set
+
+Sprite data sets are built using the `spritebuild.py` Python script (in the utilities subdirectory). Again there is an example of this in the Solarfox directory.
+
+Sprite set building takes a file of sprite definitions — a simple text list of files, which can be either PNG files as-is, or postfixed by a rotate angle (only 0, 90, 180 and 270) or `v` or `h` for vertical and horizontal mirroring:
+
+```text
+graphics/ship.png
+graphics/ship.png 90
+graphics/ship.png 180
+graphics/ship.png 270
+graphics/enemy.png
+graphics/enemy.png 90
+graphics/enemy.png 180
+graphics/enemy.png 270
+graphics/collect1.png
+graphics/collect2.png
+graphics/life.png h
+```
+
+Sprite images are numbered in the order they appear in the file, from zero, and should be loaded at `$30000`.
+
+When building the sprite it strips it as much as possible and centres it in the smallest sprite size it fits in. When using BASIC commands to position a sprite, that position is relative to the centre of the sprite.
+
+## Build Pipeline
+
+```{mermaid}
+flowchart LR
+    classDef primary fill:#272662,color:#fff,stroke:#1a1a4a
+    classDef secondary fill:#F1632B,color:#fff,stroke:#d14a1a
+    classDef accent fill:#44A348,color:#fff,stroke:#358a38
+    classDef alert fill:#EE4025,color:#fff,stroke:#c4301c
+
+    PNG["PNG images<br/>(up to 32×32)"]:::primary --> BUILD["spritebuild.py"]:::secondary
+    BUILD --> BIN["Binary sprite set"]:::accent
+    BIN --> MEM["$30000+<br/>Sprite Memory"]:::primary
+    MEM --> HW["64 Hardware<br/>Sprites"]:::alert
+```
+
+## Collision Detection
+
+Collision detection between sprites is done using `hit(sprite1, sprite2)`. This uses a box test based on the size of the sprite. The value returned is zero for no collision, or the lower of the two coordinate differences from the centre, approximately.
+
+This only works if sprites are positioned via the graphics system; there is no way of reading sprite memory to ascertain where the physical sprites are.
+
+## Data Format
+
+At present there is a very simple data format:
+
+```text
++00 is the format code ($11)
++01 is the sprite size  (0-3, representing 8,16,24 and 32 pixel size)
++02 the LUT to use (normally zero)
++03 the first byte of sprite data
+```
+
+The size, LUT and data are then repeated for every sprite in the sprite set. The file should end with a sprite size of `$80` (128) to indicate the end of the set.
diff --git a/sphinx-docs/guide/structured_programming.md b/sphinx-docs/guide/structured_programming.md
new file mode 100644
index 00000000..f39a9985
--- /dev/null
+++ b/sphinx-docs/guide/structured_programming.md
@@ -0,0 +1,446 @@
+# Structured Programming
+
+SuperBASIC is built to help you write programs that are easy to read and easy to change later. If you’ve
+used BASIC on another computer, you might be used to steering your program with commands like
+`goto`, `gosub`, and `return`. These work fine in small programs, but once your code grows, they can
+make things messy and hard to follow.
+
+SuperBASIC still lets you use those commands if you want, but it also offers tools you’ll probably prefer
+as your programs get bigger. With loops, procedures, functions, and multi-step conditionals, your code
+can flow more naturally—making it simpler to read, easier to fix, and more fun to work with.
+
+## Named Procedures
+
+A _named procedure_ is simply a block of code that has a name. Once you’ve defined a procedure, you can
+run it—also called _calling it_—anywhere in your program just by using its name. This often makes your
+code easier to follow (assuming you choose clear, descriptive names), and saves you from writing the
+same steps over and over again.
+
+```{mermaid}
+flowchart LR
+    classDef primary fill:#272662,color:#fff,stroke:#1a1a4a
+    classDef accent fill:#44A348,color:#fff,stroke:#358a38
+
+    CALL["myfunc(args)"]:::accent --> PROC["PROC myfunc(params)"]:::primary
+    PROC --> BODY["Procedure body<br/>(params are local)"]:::primary
+    BODY --> ENDP["ENDPROC"]:::accent
+    ENDP --> RET["Return to caller"]:::primary
+```
+
+A procedure is defined using the `proc` keyword, followed by the procedure’s name and a pair of
+parentheses, followed by the code to be executed when the procedure is called. The definition is closed
+with the `endproc` keyword:
+
+```basic
+200   proc greet()
+210     print "Hello!"
+220     print "How are you?"
+230   endproc
+```
+
+The code inside a procedure—in this case, lines 210–220—is called the _body_ of the procedure. This is
+the part that actually runs when the procedure is called. Note that the body does not execute until you
+explicitly call the procedure.
+
+Procedure definitions are automatically skipped during normal execution, so they can appear anywhere
+in your program—before or after the code that calls them, or even in the middle. You can call a
+procedure from anywhere in your code, including from within other procedures.
+
+A procedure is called by writing its name followed by parentheses:
+
+```basic
+100   greet()                         ' prints "Hello!" and "How are you?"
+110   print "Bye-bye!"                ' prints "Bye−bye!"
+120   end                             ' end of program
+200   proc greet()
+210     print "Hello!"
+220     print "How are you?"
+230   endproc
+```
+
+Here, lines 200–230 define the procedure, and line 100 calls it. When the program encounters the
+`greet()` call in line 100, it jumps to the first line of the procedure’s body (line 210, `print "Hello!"`),
+executes the entire body, and then returns to line 110 to continue with the rest of the program.
+
+### Procedures with parameters
+
+Procedures become even more useful when they can accept _parameters_. A parameter is simply a
+placeholder for a value that we’ll pass to the procedure when we call it.
+
+Let’s tweak our `greet` procedure to greet someone by name:
+
+```basic
+100   greet("Alice")                  ' prints "Hello, Alice!"
+110   greet("Bob")                    ' prints "Hello, Bob!"
+120   print "Bye-bye!"                ' prints "Bye−bye!"
+130   end                             ' end of program
+200   proc greet(name$)
+210     print "Hello, " + name$ + "!"
+220   endproc
+```
+
+Here, we’ve added a parameter called `$name`, indicating that the procedure expects to receive a
+string value that is a person’s name. 
+
+
+When the procedure is called on line 100 with the argument `"Alice"` , `name$` is assigned that value,
+and line 210 prints `Hello, Alice!` . When control returns to line 110 and the procedure is called with
+`"Bob"` , `name$` becomes `"Bob"` , and line 210 prints `Hello, Bob!`.
+
+### Multiple parameters
+
+To define a procedure that takes more than one parameter, simply separate the parameter names with
+commas, and do the same when providing arguments in the procedure call:
+
+```basic
+100   greet("Alice", "morning")       ' prints "Good morning, Alice! "
+110   greet("Charlie", "evening")     ' prints "Good evening, Charlie! "
+120   print "Bye-bye!"                ' prints "Bye−bye!"
+130   end                             ' end of program
+200   proc greet(name$, time_of_day$)
+210     print"Good "; time_of_day$; ", "; name$; "!"
+220   endproc
+```
+
+A procedure can accept up to 13 parameters.
+
+```{admonition} Summary
+:class: seealso
+- A named procedure is a snippet of code that has a name.
+- When you call a procedure, you give it values (called arguments), which get assigned to the parameters. A parameter is like a local variable that lives inside a procedure.
+- A procedure can have no parameters, one parameter, or as many as you need.
+- Procedures make your code more flexible—you can reuse the same procedure for lots of
+different inputs.
+```
+
+## User-Defined Functions
+
+A _user-defined function_ is like a procedure, but it returns a value. This means you can use it
+inside expressions—anywhere you'd normally write a number or a string.
+
+### Single-line functions
+
+The simplest form defines a function in a single line using `fn`:
+
+```basic
+400   fn square(x) = x * x
+```
+
+You can then call it by name, just like a built-in function:
+
+```basic
+100   print square(5)                    ' prints 25
+110   print square(3) + square(4)        ' prints 25
+```
+
+A function can take multiple parameters, or none at all:
+
+```basic
+410   fn add(a, b) = a + b
+420   fn pi() = 3.14159
+```
+
+```{mermaid}
+flowchart LR
+    classDef primary fill:#272662,color:#fff,stroke:#1a1a4a
+    classDef accent fill:#44A348,color:#fff,stroke:#358a38
+
+    CALL["square(5)"]:::accent --> DEF["FN square(x) = x * x"]:::primary
+    DEF --> EVAL["Evaluate x * x<br/>(x = 5)"]:::primary
+    EVAL --> RET["Return 25"]:::accent
+```
+
+### Multi-line functions
+
+When a function's logic is too complex for a single expression, you can write a multi-line function
+using `fn` ... `endfn`. Use `return expr` inside the body to return a value:
+
+```basic
+100   print absval(-7)                   ' prints 7
+110   end
+200   fn absval(x)
+210     if x < 0
+220       return -x
+230     else
+240       return x
+250     endif
+260   endfn
+```
+
+The `endfn` keyword closes the function body. If execution reaches `endfn` without hitting a
+`return`, the function returns zero.
+
+A simple multi-line function can use `return` on its own line:
+
+```basic
+300   fn double(x)
+310     return x * 2
+320   endfn
+```
+
+Like procedures, function definitions are automatically skipped during normal execution, so they
+can appear anywhere in your program. Parameters are local to the function—they don't affect
+variables of the same name elsewhere in your program.
+
+### Nested and recursive function calls
+
+Functions can be nested—you can pass the result of one function as an argument to another:
+
+```basic
+100   print add(square(2), square(3))    ' prints 13  (4 + 9)
+110   print square(add(1, 2))            ' prints 9   (3 squared)
+```
+
+Functions can also call themselves recursively:
+
+```basic
+100   fn fact(n)
+110     if n <= 1
+120       return 1
+130     endif
+140     return n * fact(n - 1)
+150   endfn
+160   print fact(5)                      ' prints 120
+```
+
+Functions can also be used inside control structures, results assigned to variables, or combined with any
+other expression.
+
+```{admonition} Functions vs. Procedures
+:class: seealso
+- A **procedure** (`proc`/`endproc`) performs an action but does not return a value. You call it as
+  a standalone statement.
+- A **function** (`fn`/`endfn`) computes and returns a value. You call it inside an expression.
+- Both support parameters, and both localise their parameters automatically.
+```
+
+## `for` loops
+
+A `for` loop repeats a block of code a fixed number of times. When you know in advance how many
+times you want something to run, a `for` loop is usually the clearest and most concise option.
+The loop definition starts with the `for` keyword, followed by a loop variable, an equals sign, and a
+range of values to count over:
+
+```basic
+100   for i = 1 to 10
+110     print "Hello, World!"
+120   next
+```
+
+The loop is closed with the `next` keyword. The code inside the loop—in this case, line 110—is called
+the _body_ of the loop. The body executes once for each value in the loop variable’s range. In the example
+above, the loop runs ten times, with `i` taking on the values 1 through 10, so the program prints `"Hello,
+World!"` ten times.
+Because the loop variable changes each time, you can use it inside the body to produce different results
+on each pass. For example, this program prints the numbers 1 through 10:
+
+```basic
+100   for i = 1 to 10
+110     print i
+120   next
+```
+
+```{mermaid}
+flowchart LR
+    classDef primary fill:#272662,color:#fff,stroke:#1a1a4a
+    classDef secondary fill:#F1632B,color:#fff,stroke:#d14a1a
+    classDef highlight fill:#FDBB3A,color:#272662,stroke:#d4a030
+
+    FOR["FOR i = start TO end"]:::secondary --> BODY["Loop body"]:::primary
+    BODY --> NEXT["NEXT"]:::primary
+    NEXT --> CHECK{"i past end?"}:::highlight
+    CHECK -->|no| BODY
+    CHECK -->|yes| DONE["Done"]:::primary
+```
+
+
+### Nested loops
+
+A loop can contain another loop inside its body. This is called a _nested loop_. Nested loops are especially
+useful when you need to repeat an action across two or more dimensions—for example, filling rows
+and columns of a table.
+
+For instance, to display a multiplication table, you could write:
+
+```basic
+10   cls                            ' clear the screen
+20   for i=1 to 9                   ' outer loop, cycle through rows 1 to 9
+30     for j=1 to 9                 ' inner loop, cycle through columns 1 to 9
+40       print i;"x";j;"=";i*j,     ' print one multiplication fact (i x j)
+50     next                         ' go to the next column
+60     print                        ' move the cursor to the next line
+70     print                        ' insert a blank line for spacing
+80   next                           ' go to the next row
+```
+
+As indicated by indentation, lines 30–70 form the body of the _outer loop_, while line 40 is the body of the
+_inner loop_.
+Let’s break down how this program executes, step by step:
+
+- When the program first enters the outer loop (`i=1`), the inner loop in lines 30-50 runs through all
+values of `j` from 1 to 9, printing the results of `1 × j`.
+- After the inner loop finishes, execution returns to the outer loop’s body. Lines 60 and 70 add row
+spacing, and then the `next` statement in line 80 increases `i` by one, and the process repeats
+with `i=2`.
+- This continues until the outer loop has cycled through all its values, producing the full table.
+
+Notice that the inner loop restarts for each new row, allowing the program to cover every combination
+of two ranges of values, creating 81 multiplication facts in total:
+
+```text
+1x1=1   1x2=2   1x3=3   1x4=4   1x5=5   1x6=6   1x7=7   1x8=8   1x9=9
+2x1=2   2x2=4   2x3=6   2x4=8   2x5=10  2x6=12  2x7=14  2x8=16  2x9=18
+3x1=3   3x2=6   3x3=9   3x4=12  3x5=15  3x6=18  3x7=21  3x8=24  3x9=27
+...
+9x1=9   9x2=18  9x3=27  9x4=36  9x5=45  9x6=54  9x7=63  9x8=72  9x9=81
+```
+
+Nested loops aren’t limited to two levels—you can nest three or more if the problem naturally has more
+dimensions. Be aware, though, that readability drops quickly as nesting grows. In such cases, it is often
+clearer to move the inner logic into a _named procedure_. This allows the outer loop to function as a
+high-level outline, while the steps of the inner loops are contained in a separate, well-labeled block of
+code.
+
+For example, our multiplication-table program can be rewritten to move the inner loop into its own
+procedure:
+
+```basic
+10     cls                          ' clear the screen
+20     for i=1 to 9                 ' loop through rows 1 to 9
+30       print_row(i)               ' print multiplication facts for the row
+40       print                      ' insert a blank line for spacing
+50     next                         ' go to the next row
+60     end
+100    proc print_row(i)            ' print one row of the table
+110      for j=1 to 9               ' loop through columns 1 to 9
+120        print i;"x";j;"=";i*j,   ' print the multiplication fact
+130      next                       ' go to the next column
+140      print                      ' move the cursor to the next line
+150    endproc
+```
+
+This version produces the same results as before, but the outer loop now reads like a high-level outline:
+“for each row, print the row, then add spacing.” Meanwhile, the detailed logic for printing a row is
+encapsulated in a self-contained named procedure.
+
+### Counting backwards
+You can also make a loop count backwards by using the `downto` keyword instead of `to`. This version
+prints the numbers from 10 down to 1:
+
+```basic
+100   for i = 10 downto 1
+110     print i
+120   next
+```
+
+```{admonition} Compatibility with other BASICs
+:class: seealso
+In some BASIC dialects, the loop variable must be written again after the `next` keyword
+(for example, `next i`), and intricate behaviors are triggered if a loop is closed out of order.
+SuperBASIC simplifies this by requiring only a plain `next`, with no variable name, and it
+does not support or allow those peculiar behaviors.
+```
+
+## `while` and `repeat` loops
+
+`while` and `repeat` are a structured way of doing something repeatedly, until a condition becomes either true or false.
+
+A `while` loop checks its condition before entering the loop. For example:
+
+```basic
+100   lives = 3
+110   while lives > 0
+120     playgame()
+130   wend
+```
+
+Here, the program keeps calling `playgame()` while the variable `lives` is greater than zero. If the test
+on line 110 fails immediately, the loop body will never run. Notice how indentation, shown when the
+program is listed, helps to make the repeated block visually clear.
+
+```{mermaid}
+flowchart LR
+    classDef primary fill:#272662,color:#fff,stroke:#1a1a4a
+    classDef secondary fill:#F1632B,color:#fff,stroke:#d14a1a
+    classDef highlight fill:#FDBB3A,color:#272662,stroke:#d4a030
+
+    WHILE["WHILE condition"]:::secondary --> TEST{"true?"}:::highlight
+    TEST -->|yes| BODY["Loop body"]:::primary --> WHILE
+    TEST -->|no| WEND["WEND"]:::primary
+```
+
+
+A `repeat` loop, on the other hand, always runs its body at least once, because the test is checked only
+at the end:
+
+```basic
+100   lives = 3
+110   repeat
+120     playgame()
+130   until lives = 0
+```
+
+This example produces the same behaviour as the `while` loop above, but with a different control flow:
+The loop executes `playgame()` once before checking whether `lives  = 0`.
+
+```{mermaid}
+flowchart LR
+    classDef primary fill:#272662,color:#fff,stroke:#1a1a4a
+    classDef secondary fill:#F1632B,color:#fff,stroke:#d14a1a
+    classDef highlight fill:#FDBB3A,color:#272662,stroke:#d4a030
+
+    REPEAT["REPEAT"]:::secondary --> BODY["Loop body"]:::primary --> TEST{"UNTIL condition"}:::highlight
+    TEST -->|false| REPEAT
+    TEST -->|true| DONE["Done"]:::primary
+```
+
+## `if` ... `else` ... `endif`
+
+`if` is a conditional test, allowing code to be run if some test is satisfied, e.g.:
+
+```basic
+100   if count = 0 then explode
+110   if name$ = "Paul Robson" then print "You are very clever and modest."
+```
+
+(the built-in instruction `explode` plays a simple explosion effect).
+
+This is standard BASIC — `if` the test 'passes' the code following the `then` is executed.
+
+However, there is an alternate form, more in tune with modern programming: `if ... else ... endif`:
+
+```basic
+100   for n = 1 to 10
+110     if n % 2 = 0
+120       print n;" is even"
+130     else
+140       print n;" is odd"
+150     endif
+160   next
+```
+
+This prints whether a number is even or odd, based on the value of `n`. You can include multiple lines
+of code in either the `if` or `else` clause.
+
+The `else` part is optional.
+
+This can all be written on one line (or pretty much any way you like), e.g.
+
+```basic
+100   for n = 1 to 10
+110     if n % 2 = 0:print n;" is even":else:print n;" is odd":endif
+120   next
+```
+
+You cannot write, as you can in some BASIC interpreters, the following:
+
+```basic
+100   if a = 2 then print "A is two" else print "A is not two"
+```
+
+Once you have a `then` you are locked into the simple form; no `else` or `endif`.
+
+Generally when programming you use the `then` short version for simple tests, and the `if..else..endif` for more complicated ones.
+
+Here endeth the lesson.
+
diff --git a/sphinx-docs/guide/tiles.md b/sphinx-docs/guide/tiles.md
new file mode 100644
index 00000000..5cd65b11
--- /dev/null
+++ b/sphinx-docs/guide/tiles.md
@@ -0,0 +1,46 @@
+# Tiles and Tile Maps
+
+## Introduction
+
+SuperBASIC supports a single tile map, made up of 8×8 pixel images. A tile map can be up to 255×255 tiles in size. The default size is 64×32.
+
+## Setting Up a Tile Map
+
+The `tiles` command sets up a tile map. For example, the following command sets up a 48×48 tile map at the default locations (see below), and turns it on:
+
+```basic
+100   tiles dim 48,48 on
+```
+
+## Manipulating a Tile Map
+
+The `tile` command is used to manipulate a tile map, by either scrolling its position, or by writing to it. These commands can be chained in a similar manner to the graphics drawing ones.
+
+This example sets the draw pointer at tile 4 across, 5 down and draws the following tiles, writing horizontally: tile 10, 3 tile 11s, and another tile 10. So it is not difficult to create maps programmatically.
+
+`tile to` scrolls the tile map on the screen — this is in pixels, not whole tiles.
+
+The `tile()` function reads the tile at the current map position (which following the code at line 100, should be 11).
+
+```basic
+100   tile at 4,5 draw 10,11 line 3,10
+110   tile to 14,12
+120   t = tile(5,5)
+```
+
+## Data Formats
+
+There are two data files required for a tile map:
+
+```{mermaid}
+flowchart LR
+    classDef primary fill:#272662,color:#fff,stroke:#1a1a4a
+    classDef secondary fill:#F1632B,color:#fff,stroke:#d14a1a
+    classDef accent fill:#44A348,color:#fff,stroke:#358a38
+
+    MAP["$24000<br/>Map Data<br/>(w × h × 2 bytes)"]:::primary -- index into --> IMG["$26000<br/>Image Data<br/>(64 bytes/tile)"]:::secondary -- 8×8 pixels --> SCR["Screen<br/>320×240"]:::accent
+```
+
+The **images file** is a sequence of 64 bytes, representing an 8×8 tile. These are indexed from zero. This images file is held at `$26000` by default (though it can be placed anywhere).
+
+The **map file** is a word sequence, which is (map width × map height × 2) bytes in size, as specified in the Hardware Reference Manual. This map is held at `$24000` by default (it too can be placed anywhere).
diff --git a/sphinx-docs/guide/variables.md b/sphinx-docs/guide/variables.md
new file mode 100644
index 00000000..0089156b
--- /dev/null
+++ b/sphinx-docs/guide/variables.md
@@ -0,0 +1,90 @@
+# Identifiers, Variables and Typing
+
+## Procedure and Variable Naming
+
+SuperBASIC lets you give long, descriptive names to both variables and procedures (also known as
+subroutines). Using clear names makes your programs easier to read and understand.
+
+A name must start with a letter or an underscore (`_`), and it can continue with any combination of
+letters, numbers, or underscores. A name may also end with a type character (`$` or `#`), which shows
+the kind of data stored in the variable (see the next section for more details).
+Here are some examples of valid names:
+
+
+```text
+n
+count17
+number_of_lives
+str2num
+name$
+average#
+```
+
+Here are some examples of _invalid_ names:
+
+```text
+2string      ' can not start with a number
+$name        ' $ character must be at the end
+total#sum    ' # character must be at the end
+```
+
+
+```{note}
+
+When a program is stored in memory, each identifier name is stored only once, regardless
+of how many times it appears in the program. Thus, aside from that single instance, using
+shorter identifier names provides no additional space savings.
+```
+
+## Types
+
+SuperBASIC supports three variable types: integers, floating-point numbers, and strings.
+By default, a variable is an integer. Integers are whole numbers, such as −5, 0, or 4200. In SuperBASIC,
+they can go up to about 2 billion or down to−2 billion.
+
+A variable name ending with `#` represents a floating-point number (a decimal). Floating-point numbers
+let you use very large, very small, or fractional values (like 178.2). They are more flexible than integers,
+but sometimes less exact and a little slower to calculate.
+
+A variable name ending with `$` represents a string. A string is simply arbitrary text, up to 253 characters
+long. In program code, string values—called string literals—are written inside quotation marks. For
+example, `"Arthur Dent"` is a string literal.
+
+Here are some examples:
+
+```basic
+100   count = 19
+110   height# = 178.2
+120   name$ = "Arthur Dent"
+```
+
+## Arrays
+
+An array is a collection of related variables that share the same name and are stored together. Arrays
+are created using the `dim` statement, followed by the array name and the number of elements. Each
+individual element is accessed by giving its index inside parentheses. Array indexes always begin at
+zero:
+
+```basic
+100   dim fruits$(3)
+110   fruits$(0) = "apple"
+120   fruits$(1) = "orange"
+130   fruits$(2) = "banana"
+140   print fruits$(0)                   ' prints "apple"
+150   print fruits$(2)                   ' prints "banana"
+```
+
+SuperBASIC supports both one-dimensional and two-dimensional arrays, with up to 254 elements in
+each dimension.
+
+When first created, string array elements are empty strings, and number array elements are set to zero.
+
+Here is a two-dimensional array of numbers, which you can think of like a grid with rows and columns:
+
+```basic
+100   dim grid(8,8)                      ' 8 by 8 grid of numbers
+110   grid(4,3) = 17
+120   print grid(4,3)                    ' prints 17
+130   print grid(7,7)                    ' prints 0
+```
+
diff --git a/sphinx-docs/index.md b/sphinx-docs/index.md
new file mode 100644
index 00000000..bd0c3178
--- /dev/null
+++ b/sphinx-docs/index.md
@@ -0,0 +1,110 @@
+# F256 SuperBASIC Reference Manual
+
+```{only} html
+*By Paul Robson*
+
+A modernised BASIC interpreter for the 65C02-based Wildbits/K2 retro computers.
+```
+
+````{only} html
+::::{grid} 2
+:gutter: 3
+
+:::{grid-item-card} Introduction
+:link: guide/introduction
+:link-type: doc
+Overview, memory layout, and storage format.
+:::
+
+:::{grid-item-card} Getting started
+:link: guide/getting_started
+:link-type: doc
+Line-number editing, screen editor keys, and cross-development.
+:::
+
+:::{grid-item-card} Variables & Types
+:link: guide/variables
+:link-type: doc
+Integers, floats, strings, and arrays.
+:::
+
+:::{grid-item-card} Structured Programming
+:link: guide/structured_programming
+:link-type: doc
+Procedures, functions, WHILE, REPEAT, FOR, and IF/ELSE/ENDIF.
+:::
+
+:::{grid-item-card} Graphics
+:link: guide/graphics
+:link-type: doc
+Bitmap drawing, modifiers, colours, and the graphics pipeline.
+:::
+
+:::{grid-item-card} Tiles & Tile Maps
+:link: guide/tiles
+:link-type: doc
+8×8 tile maps, scrolling, and data formats.
+:::
+
+:::{grid-item-card} Sprites
+:link: guide/sprites
+:link-type: doc
+Hardware sprites, building sprite sets, and collision detection.
+:::
+
+:::{grid-item-card} Sound
+:link: guide/sound
+:link-type: doc
+SN76489 channels, sound queuing, and easy sound effects.
+:::
+
+:::{grid-item-card} Inline Assembly
+:link: guide/assembler
+:link-type: doc
+65C02 inline assembler modelled on the BBC Micro.
+:::
+
+:::{grid-item-card} Memory
+:link: guide/memory
+:link-type: doc
+Physical memory map, program paging, and the LOMEM command.
+:::
+
+:::{grid-item-card} Cross Development
+:link: guide/crossdev
+:link-type: doc
+USB uploading and FnxMgr.
+:::
+
+:::{grid-item-card} Keyword Reference
+:link: reference/keywords
+:link-type: doc
+Complete A–Z reference for every SuperBASIC keyword.
+:::
+
+::::
+````
+
+```{toctree}
+:hidden:
+:caption: User Guide
+
+guide/introduction
+guide/getting_started
+guide/variables
+guide/structured_programming
+guide/graphics
+guide/tiles
+guide/sprites
+guide/sound
+guide/assembler
+guide/memory
+guide/crossdev
+```
+
+```{toctree}
+:hidden:
+:caption: Reference
+
+reference/keywords
+```
diff --git a/sphinx-docs/reference/keywords.md b/sphinx-docs/reference/keywords.md
new file mode 100644
index 00000000..0c713ab1
--- /dev/null
+++ b/sphinx-docs/reference/keywords.md
@@ -0,0 +1,1024 @@
+# Keyword Reference
+
+This describes the keywords in SuperBASIC. Some that are naturally grouped together, such as graphics, have their own section.
+
+## !
+
+`!` is an indirection operator that does a similar job to `DEEK` and `DOKE`, i.e. accesses memory. It can be used either in unary fashion (`!47` reads the word at location 47) or binary (`a!4` reads the word at the value in address `a+4`). It can also appear on the left-hand side of an assignment statement when it functions as a `DOKE`, writing a 16-bit value in low/high order. It reads or writes a 16-bit address in the 6502 memory map.
+
+```basic
+10    !a = 42
+20    print !a
+30    print a!b
+40    a!b=12
+```
+
+## ' and REM
+
+Comment. `'` and `REM` are synonyms. The rest of the line is ignored. The only difference between the two is when listing, `'` comments show up in reverse to highlight them. Remarks should be in quotes for syntactic consistency.
+
+```basic
+10    ' "This is a title comment"
+20    REM
+30    REM "Another comment"
+```
+
+## abs()
+
+Returns the absolute value of the parameter.
+
+```basic
+10    print abs(-4)
+```
+
+## alloc()
+
+Allocate the given number of bytes of memory and return the address. Can be used for data structures or program memory for the assembler.
+
+Note: `alloc()` uses a bump allocator. There is no corresponding deallocation function — allocated memory is only freed when the program is cleared (`NEW` or `RUN`).
+
+```basic
+10    myAssemblerCode = alloc(128)
+```
+
+## asc()
+
+Returns the ASCII value of the first character in the string, or zero if the string is empty.
+
+```basic
+10    print asc("*")
+```
+
+## # and $
+
+`#` and `$` are used to type variables. `#` is a floating point value, `$` is a string. The default type is integer. Variables are not stored internally by name but by reference. This means they are quick to access but means they are always in existence from the start of a program if used in it. Integers are 32-bit signed; floats have a 32-bit signed mantissa and 8-bit exponent, giving approximately 9 decimal digits of precision.
+
+```basic
+100   an_integer  = 42
+110   a_float#  = 3.14159
+120   a_string$ = "hello world"
+```
+
+## ?
+
+`?` is an indirection operator that does a similar job to `PEEK` and `POKE`, i.e. accesses memory. It is the same as `!` except it operates on a byte level.
+
+```basic
+100   ?a = 42
+110   print ?a
+120   print a?b
+130   a?b=12
+```
+
+## $
+
+Hexadecimal constant prefix. `$2A` is the same as the decimal constant 42.
+
+```basic
+100   print $2a
+110   !$7ffe = 31702
+```
+
+## *
+
+Multiply.
+
+```basic
+100   print 4*2
+```
+
+## +
+
+Add or string concatenation.
+
+```basic
+100   sum = 4+2
+110   prompt$ = "hello "+"world !"
+```
+
+## -
+
+Subtract.
+
+```basic
+100   print 44 - 2
+```
+
+## %
+
+Binary modulus operator. Returns the non-negative remainder. The second value must be non-zero.
+
+```basic
+100   print 42 % 5 : rem prints 2
+110   print -17 % 5 : rem prints 2
+```
+
+## .
+
+Sets the following label to the current assembler address. So the example below sets the label `mylabel` at the current address and you can write things like `bra mylabel`. Note also that this is an integer variable.
+
+```basic
+100   .mylabel
+```
+
+## / and \\
+
+Signed division. An error occurs if the divisor is zero. Backslash is integer division, forward slash returns a floating point value.
+
+```basic
+100   print 22/7
+110   print 22\7
+```
+
+## < <= <> = > >=
+
+Comparison binary operators, which return 0 for false and −1 for true. They can be used to compare two numbers or two strings.
+
+```basic
+100   if a<42 then "a is not the answer to life the universe and everything"
+110   if name$="" then input name$
+```
+
+## @
+
+Returns the address of an l-expr, normally this is a variable of some sort, but it can be an array element or even an indirection.
+
+```basic
+100   print @fred, @a(4)
+```
+
+## &
+
+Binary AND operator. This is a binary operator not a logical one, so it can return values other than true and false.
+
+```basic
+100   print count & 7
+```
+
+## ^
+
+Binary exclusive OR operator. This is a binary operator not a logical one, so it can return values other than true and false.
+
+```basic
+100   print a^$0E
+```
+
+## |
+
+Binary OR operator. This is a binary operator not a logical one, so it can return values other than true and false.
+
+```basic
+100   print read.value | 4
+```
+
+## << >>
+
+Binary operators which shift an integer left or right a certain number of times logically. Much quicker than multiplication.
+
+```basic
+100   print a << 2,32 >> 2
+```
+
+## assemble
+
+Initialises an assembler pass. Apart from the simplest bits of code, the assembler is two-pass. It has two parameters. The first is the location in memory the assembled code should be stored, the second is the mode. At present there are two mode bits; bit 0 indicates the pass (0 = first pass, 1 = second pass) and bit 1 specifies whether the code is listed as it goes. Normally these values will be 0 and 1, as the listing is a bit slow. 6502 mnemonics are typed as-is.
+
+```basic
+100   assemble $6000,1:lda #42:sta count:rts
+```
+
+Normally these are wrapped in a loop for the two passes for forward references:
+
+```basic
+100   for pass = 0 to 1
+110     assemble $6000,pass
+120     bra forward
+130     <some code>
+140     .forward:rts
+150   next
+```
+
+This is almost identical to the BBC Microcomputer's inline assembler.
+
+## assert
+
+Every good programming language should have `assert`. It verifies contracts and detects error conditions. If the expression following is zero, an error is produced.
+
+```basic
+100   assert myage = 42
+```
+
+## bitmap
+
+Turns the bitmap on or off, or clears it, or sets its address (the default address is `$10000`). Only one bitmap is used in BASIC, but you can use others by accessing I/O. Keywords are `ON`, `OFF`, `CLEAR <colour>`, `AT <address>` and can be chained. On or Off without an `AT` will reset the address.
+
+```basic
+100   bitmap at $18000 on clear $03
+110   bitmap at $18000 on:bitmap clear $03
+```
+
+## bload
+
+Loads a file into memory. The 2nd parameter is the address in full memory space, *not* the 6502 CPU address. In the default setup, for the RAM area (`0000`–`7FFF`) this will however be the same.
+
+```basic
+100   bitmap on:bitmap clear 1
+110   bload "mypic.bin",$10000
+```
+
+## bsave
+
+Saves a chunk of memory into a file. The 2nd parameter is the address in full memory space, *not* the 6502 CPU address. The 3rd parameter is the number of bytes to save.
+
+```basic
+100   bsave "memory.space",$0800,$7800
+```
+
+## call
+
+Calls an assembly subroutine at the specified address. You may provide up to three arguments, which will be loaded into the A, X, and Y registers respectively. The address can be specified in decimal or hex.
+
+```basic
+100   call $4000
+110   call $4000,65,0,0
+```
+
+## chr$()
+
+Convert an ASCII integer to a single character string.
+
+```basic
+100   print chr$(42)
+```
+
+## circle
+
+Draws a circle, using the standard syntax. The vertical height defines the radius of the circle. See the section on graphics for drawing options.
+
+```basic
+100   circle here solid to 200,200
+```
+
+## cls
+
+Clears the text screen.
+
+```basic
+100   cls
+```
+
+## cprint
+
+Operates the same as the `print` command, but control characters (e.g. `00`–`1F`, `80`–`FF`) are printed using the characters from the FONT memory, not as control characters. The example below prints a horizontal upper bar character, not a new line.
+
+```basic
+100   cprint chr$(13);
+```
+
+## cursor
+
+Turns the flashing cursor on or off.
+
+```basic
+100   cursor on
+```
+
+## dir
+
+Shows all the files in the current drive.
+
+```basic
+100   dir
+```
+
+## fn endfn
+
+Define a user function. Single-line functions use `= expr`; multi-line functions use `endfn` to close the body. Use `return expr` inside a multi-line function to return a value explicitly; a bare `endfn` returns zero.
+
+```basic
+100   print square(5)
+110   print absval(-3)
+120   end
+200   fn square(x) = x * x
+210   fn absval(x)
+220     if x < 0
+230       return -x
+240     else
+250       return x
+260     endif
+270   endfn
+```
+
+## dim
+
+Dimension number or string arrays with up to two dimensions, with a maximum of 254 elements in each dimension.
+
+```basic
+100   dim a$(10),a_sine#(10)
+110   dim name$(10,2)
+```
+
+## drive
+
+Sets the current drive for load/save. The default drive is zero.
+
+```basic
+100   drive 1
+```
+
+## end
+
+Ends the current program and returns to the command line.
+
+```basic
+100   end
+```
+
+## event()
+
+`event()` tracks time. It is normally used to activate object movement or events in a game, and generates true at predictable rates. It takes two parameters: a variable and an elapsed time.
+
+If that variable is zero, then this function doesn't return true until after that many tenths of seconds has elapsed. If it is non-zero, it tracks repeated events, so `event(evt1,70)` will return true every second — the clock operates at the timer rate, 70Hz.
+
+Note that if a game pauses the event times will continue. One way out is to zero the event variables when leaving pause — this will cause it to fire after another delay period. If the event variable is set to −1 it will never fire, so this can be used to create one-shots.
+
+```basic
+100   repeat
+110     if event(myevent1,70) then print "Hello"
+120   until false
+```
+
+## false
+
+Returns the constant zero.
+
+```basic
+100   print false
+```
+
+## for next
+
+A loop which repeats code a fixed number of times, which must be executed at least once. The default step is 1 for `to` and −1 for `downto`; use `STEP` to set a different increment. The variable name on `NEXT` is not supported.
+
+```basic
+100   for i = 1 to 10:print i:next
+110   for i = 10 downto 1:print i:next
+120   for i = 0 to 100 step 10:print i:next
+```
+
+## frac()
+
+Return the fractional part of a number.
+
+```basic
+100   print frac(3.14159)
+```
+
+## fre()
+
+Returns information about free memory. The parameter selects which region:
+
+- `fre(0)` — free program memory (banked pages)
+- `fre(-1)` — free variable/string space
+- `fre(-2)` — free array space
+
+```basic
+100   print fre(0)
+110   print fre(-1)
+120   print fre(-2)
+```
+
+## get() and get$()
+
+Wait for the next key press then return either the character as a string, or as the ASCII character code.
+
+```basic
+100   print "Letter ";get$()
+```
+
+## getdate$(n)
+
+Reads the current date from the clock returning a string in the format `dd:mm:yy`. The parameter is ignored.
+
+```basic
+100   print "Today is ";getdate$(0)
+```
+
+## gettime$(n)
+
+Reads the current time from the clock returning a string in the format `hh:mm:ss`. The parameter is ignored.
+
+```basic
+100   print "It is now ";gettime$(0)
+```
+
+## gfx
+
+Sends a three-parameter command directly to the graphics subsystem. Often the last two parameters are coordinates (not always). It is not advised to use this for general use as programs would be somewhat unreadable.
+
+```basic
+100   gfx 22,130,100
+```
+
+## gosub
+
+Call a routine at a given line number. Provided for compatibility with older programs; use named procedures instead for new code.
+
+```basic
+100   gosub 1000
+```
+
+## goto
+
+Transfer execution to given line number. Provided for compatibility with older programs; use structured control flow instead for new code.
+
+```basic
+100   goto 200
+```
+
+## hit()
+
+Tests if two sprites overlap. This is done using a box test based on the size of the sprite (e.g. 8×8, 16×16, 24×24, 32×32). The value returned is zero for no collision, or the lower of the two coordinate differences from the centre, approximately. This only works if sprites are positioned via the graphics system.
+
+```basic
+100   print hit(1,2)
+```
+
+## if then and if else endif
+
+`IF` has two forms. The first is classic BASIC: `if <condition> then <do something>`. All the code is on one line. The `THEN` is mandatory.
+
+```basic
+100   if name="benny" then my_iq = 70
+```
+
+The second form allows multi-line conditional execution, with an optional `else` clause. Note the `endif` is mandatory; you cannot use a single line `if then else`:
+
+```basic
+100   if age < 18:print "child":else:print "adult":endif
+```
+
+## image
+
+Draws a possibly scaled or flipped sprite image on the bitmap, using the standard syntax. Flipping is done using bits 7 and 6 of the mode (e.g. `$80` and `$40`) in the colour option. This requires both sprites and bitmap to be on.
+
+```basic
+100   image 4 dim 3 colour 0,$80 to 100,100
+```
+
+## inkey() and inkey$()
+
+If a character key has been pressed, return either the character as a string, or as the ASCII character code. If no key is available return `""` or `0`. This uses key presses — if you want to check whether a key is up or down, use `keydown()`.
+
+```basic
+100   print inkey(),inkey$()
+```
+
+## input
+
+Inputs numbers or strings from the keyboard. This version uses the same syntax as `print`, except that where there is a variable a value is entered into that variable.
+
+```basic
+100   input "Your name is ?";a$
+```
+
+## int()
+
+Returns the integer part of a number.
+
+```basic
+100   print int(3.14159)
+```
+
+## isval()
+
+This is a support for `val()` and takes the same parameter (a string). This deals with the problem that `val()` errors if you give it a non-numeric value. This checks to see if the string is a valid number and returns −1 if so, 0 if it is not.
+
+```basic
+100   print isval("42")
+110   print isval("i like chips in gravy")
+```
+
+## itemcount()
+
+Together, `itemcount` and `itemget` provide a way of encoding multiple data items in strings. A multiple-element string has a separating character, which can be any ASCII character, often a comma. `itemcount()` takes a string and a separator and returns the number of items.
+
+```basic
+100   print itemcount("hello,world",",")
+```
+
+## itemget$()
+
+Takes three parameters: the string, the index of the substring required (starting at 1), and the separator. A bad index will generate a range error.
+
+```basic
+100   print itemget$("paul,jane,lizzie,jack",3,",")
+```
+
+## joyb()
+
+Returns a value indicating the status of the fire buttons on a gamepad, with the main fire button being bit 0. Takes a single parameter, the number of the gamepad. The keyboard keys Z X K M L (left/right/up/down/fire) are also mapped onto this controller.
+
+```basic
+100   if joyb(0) & 1 then fire()
+```
+
+## joyx() joyy()
+
+Returns the directional value of a gamepad in the x and y axes respectively as −1, 0 or 1, with 1 being right and down. Each takes a single parameter which is the number of the pad. Keyboard keys are also mapped.
+
+```basic
+100   x = x + joyx(0)
+```
+
+## keydown()
+
+Checks to see if a key is currently pressed or not — the parameter passed is the kernel raw key code. The demo below is also a simple program for identifying those raw key codes.
+
+```basic
+100   repeat
+110     for i = 0 to 255
+120       if keydown(i) then print "Key pressed ";i
+130     next
+140   until false
+```
+
+## load
+
+Loads a BASIC program from the current drive.
+
+```basic
+load "game.bas"
+```
+
+## left$()
+
+Returns several characters from a string counting from the left.
+
+```basic
+100   print left$("mystring",4)
+```
+
+## len()
+
+Returns the length of the string as an integer.
+
+```basic
+100   print len("hello, world")
+```
+
+## let
+
+Assignment statement. The `LET` is optional. You can also use `@a` where `a` is a reference.
+
+```basic
+100   let a = 42
+110   a$="hello"
+120   a#=22.7
+```
+
+## line
+
+Draws a line, using the standard syntax which is explained in the graphics section.
+
+```basic
+100   line 100,100 colour $e0 to 200,200
+```
+
+## list
+
+Lists the program. It is possible to list any part of the program using the line numbers, or list a procedure by name.
+
+```basic
+100   list
+110   list 1000
+120   list 100,200
+130   list ,400
+140   list myfunction()
+```
+
+## local
+
+Defines the list of variables (no arrays allowed) as local to the current procedure. The locals are initialised to an empty string or zero depending on their type.
+
+```basic
+100   local test$,count
+```
+
+## max() min()
+
+Returns the largest or smallest of the parameters. There can be any number of these (at least one). You can't mix strings and integers.
+
+```basic
+100   print max(3,42,5)
+```
+
+## mdelta
+
+Gets the current delta status of the PS/2 mouse. 6 reference parameters (normally integer variables) are provided: cumulative mouse changes in the x, y, z axes, and the number of times the left, middle and right buttons have been pressed.
+
+```basic
+100   mdelta dx,dy,dz,lmb,mmb,rmb
+```
+
+## memcopy
+
+This command is an interface to the Wildbits/K2's DMA hardware. `MEMCOPY` has several formats:
+
+```basic
+100   memcopy $10000,$4000 to $18000
+110   memcopy $10000,$4000 poke $F7
+120   memcopy $10000 rect 64,48 by 320 to $18000
+130   memcopy $10000 rect 64,48 by 320 poke $18
+140   memcopy at 32,32 rect 64,48 by 320 to at 128,128
+```
+
+Line 100 is a straight linear copy. Line 110 is a linear fill. Line 120 is a rectangular area copy. Line 130 is a rectangular area fill. Line 140 shows an alternate way using pixel coordinates.
+
+## mid$()
+
+Returns a subsegment of a string, given the start position (first character is 1) and the length, so `mid$("abcdef",3,2)` returns `"cd"`.
+
+```basic
+100   print mid$("hello",2,3)
+110   print mid$("another word",2,99)
+```
+
+## mouse
+
+Gets the current status of the PS/2 mouse. 6 reference parameters (normally integer variables) are provided: current mouse position in the x, y, z axes, and the status of the left, middle and right buttons.
+
+```basic
+100   mouse x,y,z,isx,isy,isz
+```
+
+## new
+
+Erases the current program.
+
+```basic
+100   new
+```
+
+## not()
+
+Unary operator returning the logical NOT of its parameter, i.e. 0 if non-zero, −1 otherwise.
+
+```basic
+100   print not(42)
+```
+
+## option
+
+`option` is used for general control functions which are not common enough to justify their own keyword. Option 0–7 set highlighting colours for Comment Foreground, Comment Background, Line Number, Token, Constant, Identifier, Punctuation, Data respectively. The lower 4 bits set the colour; setting bit 7 will disable the background change.
+
+```basic
+100   for i = 0 to 7:option i,128+15:next
+```
+
+## palette
+
+Sets the graphics palette. The parameters are the colour id and the red, green and blue components. On start up, the palette is `RRRGGGBB`.
+
+```basic
+100   palette 1,255,128,0
+```
+
+## peek() peekw() peekl() peekd()
+
+The `peek`, `peekw`, `peekl` and `peekd` functions retrieve 1–4 bytes from the 6502 memory space.
+
+```basic
+100   print peekd(42),peek(1)
+```
+
+## playing()
+
+Returns true if a channel is currently playing a sound.
+
+```basic
+100   print playing(0)
+```
+
+## plot
+
+Plot a point in the current colour using the standard syntax described in the graphics section.
+
+```basic
+100   plot to 100,200
+```
+
+## poke pokew pokel poked
+
+The `poke`, `pokew`, `pokel` and `poked` functions write one to four bytes to the 6502 memory space.
+
+```basic
+100   poke 4096,1: pokew $c004,$a705
+```
+
+## print
+
+Prints to the current output device, either strings or numbers (which are preceded by a space). `print` with `,` goes to the next tab stop. A return is printed unless the command ends in `;` or `,`.
+
+The `at row, column` modifier positions the cursor before printing (zero-based, top-left is 0,0).
+
+```basic
+100   print 42,"hello"
+110   print at 10,5;"positioned text"
+```
+
+## proc endproc
+
+Named procedures. These should be used rather than `GOSUB`. Or else. The empty brackets are mandatory even if there aren't any parameters. Definitions are skipped during normal execution, so they can appear anywhere in your program.
+
+```basic
+100   proc printmessage(msg$,n)
+110     print msg$+"world  x "+str$(n)
+120   endproc
+130   printmessage("hello",42)
+```
+
+## rnd() random()
+
+Generates random numbers. `rnd()` behaves like Microsoft BASIC: negative numbers set the seed, 0 repeats the last value, and positive numbers return a float 0 <= n < 1. `random(n)` returns a number from 0 to n−1.
+
+```basic
+100   print rnd(1),random(6)
+```
+
+## read / data
+
+Reads from `DATA` statements. The types must match. For syntactic consistency, string data must be in quote marks.
+
+```basic
+100   read a$,b
+110   data "hello world"
+120   data 59
+```
+
+## rect
+
+Draws a rectangle, using the standard syntax described in the graphics section.
+
+```basic
+100   rect 100,100 colour $ff to 200,200
+```
+
+## restore
+
+Resets the data pointer to the start of the program.
+
+```basic
+100   restore
+```
+
+## repeat until
+
+Conditional loop, which is tested at the bottom.
+
+```basic
+100   count = 0
+110   repeat
+120     count = count + 1:print count
+130   until count = 10
+```
+
+## return
+
+Outside a function, returns from a `GOSUB` call. Inside a multi-line function body (`fn` ... `endfn`), `return expr` evaluates the expression and returns its value; a bare `return` returns zero.
+
+```basic
+100   return
+110   return x * 2
+```
+
+## right$()
+
+Returns several characters from a string counting from the right.
+
+```basic
+100   print right$("last four characters",4)
+```
+
+## run
+
+Runs the current program after clearing variables as for `CLEAR`. Can also have a parameter which does a `LOAD` and then `RUN`.
+
+```basic
+100   run
+110   run "demo.bas"
+```
+
+## save
+
+Saves a BASIC program to the current drive.
+
+```basic
+save "game.bas"
+```
+
+## screen()
+
+Returns the character code at the given screen position (row, column).
+
+```basic
+100   print screen(0,0)
+```
+
+## screen$()
+
+Returns the character at the given screen position (row, column) as a single-character string.
+
+```basic
+100   print screen$(0,0)
+```
+
+## setdate
+
+Sets the RTC to the given date; the parameters are the day, month and year (00–99).
+
+```basic
+100   setdate 23,1,3
+```
+
+## settime
+
+Sets the RTC to the given time; the parameters are hours, minutes, seconds.
+
+```basic
+100   settime 9,44,25
+```
+
+## sgn()
+
+Returns the sign of a number, which is −1, 0 or 1 depending on the value.
+
+```basic
+100   print sgn(42)
+```
+
+## sound
+
+Generates a sound on one of the channels. There are four channels. Channel 3 is a noise channel; channels 0–2 are simple square wave channels. Sound has two forms:
+
+```basic
+100   sound 1,500,10
+```
+
+This generates a sound of pitch 500 which runs for about 10 timer ticks. The actual frequency is 111,563 / \<pitch value\>. The pitch value can be from 1 to 1023.
+
+Sounds can be queued up:
+
+```basic
+100   sound 1,1000,20:sound 1,500,10:sound 1,250,20
+```
+
+An adjuster value can be added which adds a constant to the pitch every tick:
+
+```basic
+100   sound 1,500,10,10
+```
+
+`sound off` turns off all sound and empties the queues.
+
+## spc()
+
+Return a string consisting of a given number of spaces.
+
+```basic
+100   a$ = spc(32)
+```
+
+## sprite
+
+Manipulate one of the 64 hardware sprites using the standard modifiers. Also supported are `sprite image <n>` which turns a sprite on and selects image \<n\>, and `sprite off` which turns a sprite off. For `sprite .. to` the sprite is centred on those coordinates.
+
+```basic
+100   sprite 4 image 2 to 50,200
+```
+
+## sprites
+
+Enables and disables all sprites, optionally setting the location of the sprite data in memory (default `$30000`). When turned on, all the sprites are erased and their control values set to zero.
+
+```basic
+100   sprites at $18000 on
+```
+
+## stop
+
+Stops program with an error.
+
+```basic
+100   stop
+```
+
+## str$()
+
+Converts a number to a string, in signed decimal form.
+
+```basic
+100   print str$(42),str$(412.16)
+```
+
+## text
+
+Draws a possibly scaled or flipped string from the standard font on the bitmap, using the standard syntax. Flipping is done using bits 7 and 6 of the mode in the colour option.
+
+```basic
+100   text "hello" dim 2 colour 3 to 100,100
+```
+
+## tile
+
+Manipulates the tile map. This allows you to set the scroll offset (with `TO xscroll,yscroll`) and draw on the tile map using `AT x,y` to set the position and `DRAW` followed by a list of tiles, with a repeat option using `LINE`.
+
+```basic
+100   tile to 12,0
+110   tile at 4,5 draw 10,11,11,11,10
+120   tile at 4,5 draw 10,11 line 3,10
+```
+
+## tile()
+
+Returns the tile at the given tile map position (not screen position).
+
+```basic
+100   print tile(2,3)
+```
+
+## tiles
+
+Sets up the tile map. Allows the setting of the size with `DIM <width>,<height>` and the location of the data with `AT <map address>,<image address>`. All addresses must be at the start of an 8KB page. Currently only 8×8 tiles are supported.
+
+```basic
+100   tiles on
+110   tiles off
+120   tiles dim 42,32 at $24000,$26000 on
+```
+
+## timer()
+
+Returns the current value of the 70Hz frame timer, which will wrap round in a couple of days.
+
+```basic
+100   print timer()
+```
+
+## true
+
+Returns the constant −1.
+
+```basic
+100   print true
+```
+
+## try
+
+Tries to execute a command, usually involving the Kernel, returning an error code if it fails or 0 if successful. Currently supports `BLOAD` and `BSAVE`.
+
+```basic
+100   try bload "myfile",$10000 to ec
+110   print ec
+```
+
+## val()
+
+Converts a string to a number. There must be some number there, e.g. `"-42xxx"` works and returns −42 but `"xxx"` returns an error. To make it usable, use `isval()` which checks validity first.
+
+```basic
+100   print val("42")
+110   print val("413.22")
+```
+
+## verify
+
+Compares the current BASIC program to a program stored on the current drive. This command is a defensive measure against potential bugs in either the kernel, the kernel drivers, or BASIC itself.
+
+```basic
+verify "game.bas"
+```
+
+## while wend
+
+Conditional loop with test at the top.
+
+```basic
+100   islow = 0
+110   while islow < 10
+120     print islow
+130     islow = islow + 1
+140   wend
+```
+
+## xload xgo
+
+These commands are for cross development in BASIC. If you store an ASCII BASIC program, terminated with a character code >= 128, then these commands will Load or Load-and-Run that program.
+
+## zap ping shoot and explode
+
+Simple commands that generate a simple sound effect.
+
+```basic
+100   ping:zap:explode
+```
diff --git a/sphinx-docs/requirements.txt b/sphinx-docs/requirements.txt
new file mode 100644
index 00000000..4fb10d48
--- /dev/null
+++ b/sphinx-docs/requirements.txt
@@ -0,0 +1,6 @@
+sphinx>=7.0
+myst-parser>=2.0
+furo>=2024.0
+sphinxcontrib-mermaid>=0.9
+sphinx-copybutton>=0.5
+sphinx-design>=0.5
diff --git a/sphinx-docs/superbasic_lexer.py b/sphinx-docs/superbasic_lexer.py
new file mode 100644
index 00000000..d815fbbc
--- /dev/null
+++ b/sphinx-docs/superbasic_lexer.py
@@ -0,0 +1,242 @@
+"""Pygments lexer for F256 SuperBASIC."""
+
+from pygments.lexer import RegexLexer, bygroups, words
+from pygments.token import (
+    Comment,
+    Keyword,
+    Name,
+    Number,
+    Operator,
+    Punctuation,
+    String,
+    Text,
+)
+
+
+class SuperBASICLexer(RegexLexer):
+    name = "SuperBASIC"
+    aliases = ["superbasic", "basic"]
+    filenames = ["*.bas"]
+
+    tokens = {
+        "root": [
+            # Line numbers at start of line
+            (r"^\s*\d+", Name.Label),
+            # REM comments (keyword form)
+            (r"(?i)\brem\b.*$", Comment.Single),
+            # Apostrophe comments
+            (r"'.*$", Comment.Single),
+            # Strings
+            (r'"[^"]*"', String.Double),
+            # Hex numbers
+            (r"\$[0-9A-Fa-f]+", Number.Hex),
+            # Decimal numbers (float)
+            (r"\b\d+\.\d*", Number.Float),
+            # Decimal numbers (integer)
+            (r"\b\d+\b", Number.Integer),
+            # Structure keywords (control flow)
+            (
+                words(
+                    (
+                        "while",
+                        "if",
+                        "repeat",
+                        "for",
+                        "proc",
+                        "fn",
+                        "endfn",
+                        "wend",
+                        "endif",
+                        "then",
+                        "until",
+                        "next",
+                        "endproc",
+                        "end",
+                        "goto",
+                        "gosub",
+                        "return",
+                        "else",
+                        "to",
+                        "downto",
+                        "step",
+                        "stop",
+                        "on",
+                        "off",
+                    ),
+                    prefix=r"(?i)\b",
+                    suffix=r"\b",
+                ),
+                Keyword,
+            ),
+            # Commands
+            (
+                words(
+                    (
+                        "print",
+                        "cprint",
+                        "input",
+                        "let",
+                        "dim",
+                        "data",
+                        "read",
+                        "restore",
+                        "call",
+                        "local",
+                        "new",
+                        "list",
+                        "run",
+                        "clear",
+                        "cls",
+                        "load",
+                        "save",
+                        "verify",
+                        "bload",
+                        "bsave",
+                        "dir",
+                        "drive",
+                        "poke",
+                        "pokew",
+                        "pokel",
+                        "poked",
+                        "memcopy",
+                        "lomem",
+                        "assert",
+                        "assemble",
+                        "option",
+                        "try",
+                        "cursor",
+                        "mouse",
+                        "mdelta",
+                        "setdate",
+                        "settime",
+                        "xload",
+                        "xgo",
+                    ),
+                    prefix=r"(?i)\b",
+                    suffix=r"\b",
+                ),
+                Keyword.Reserved,
+            ),
+            # Graphics / sound commands
+            (
+                words(
+                    (
+                        "bitmap",
+                        "line",
+                        "plot",
+                        "rect",
+                        "circle",
+                        "text",
+                        "image",
+                        "sprite",
+                        "sprites",
+                        "tile",
+                        "tiles",
+                        "gfx",
+                        "sound",
+                        "zap",
+                        "shoot",
+                        "ping",
+                        "explode",
+                        "palette",
+                        "colour",
+                        "color",
+                        "solid",
+                        "outline",
+                        "here",
+                        "from",
+                        "by",
+                        "at",
+                    ),
+                    prefix=r"(?i)\b",
+                    suffix=r"\b",
+                ),
+                Name.Builtin,
+            ),
+            # Built-in functions
+            (
+                words(
+                    (
+                        "abs",
+                        "alloc",
+                        "asc",
+                        "chr\\$",
+                        "event",
+                        "frac",
+                        "fre",
+                        "get\\$",
+                        "get",
+                        "getdate\\$",
+                        "gettime\\$",
+                        "hit",
+                        "inkey\\$",
+                        "inkey",
+                        "int",
+                        "isval",
+                        "itemcount",
+                        "itemget\\$",
+                        "joyb",
+                        "joyx",
+                        "joyy",
+                        "keydown",
+                        "left\\$",
+                        "len",
+                        "max",
+                        "mid\\$",
+                        "min",
+                        "not",
+                        "peek",
+                        "peekd",
+                        "peekl",
+                        "peekw",
+                        "playing",
+                        "random",
+                        "right\\$",
+                        "rnd",
+                        "screen\\$",
+                        "screen",
+                        "sgn",
+                        "spc",
+                        "str\\$",
+                        "tile",
+                        "timer",
+                        "val",
+                    ),
+                    prefix=r"(?i)\b",
+                    suffix=r"(?=\()",
+                ),
+                Name.Function,
+            ),
+            # Boolean constants
+            (r"(?i)\b(true|false)\b", Keyword.Constant),
+            # 65C02 assembly mnemonics
+            (
+                words(
+                    (
+                        "adc", "and", "asl", "bcc", "bcs", "beq", "bit", "bmi",
+                        "bne", "bpl", "bra", "brk", "bvc", "bvs", "clc", "cld",
+                        "cli", "clv", "cmp", "cpx", "cpy", "dec", "dex", "dey",
+                        "eor", "inc", "inx", "iny", "jmp", "jsr", "lda", "ldx",
+                        "ldy", "lsr", "nop", "ora", "pha", "php", "phx", "phy",
+                        "pla", "plp", "plx", "ply", "rol", "ror", "rti", "rts",
+                        "sbc", "sec", "sed", "sei", "sta", "stx", "sty", "stz",
+                        "tax", "tay", "trb", "tsb", "tsx", "txa", "txs", "tya",
+                        "stp",
+                    ),
+                    prefix=r"(?i)\b",
+                    suffix=r"\b",
+                ),
+                Keyword.Type,
+            ),
+            # Operators (multi-char before single-char to avoid partial matches)
+            (r"<>|<=|>=|<<|>>", Operator),
+            (r"[+\-*/\\<>=]", Operator),
+            (r"%", Operator),
+            # Punctuation
+            (r"[(),;:.]", Punctuation),
+            # Identifiers (with optional $ or # suffix)
+            (r"[a-zA-Z_][a-zA-Z0-9_]*[#$]?", Name.Variable),
+            # Whitespace
+            (r"\s+", Text.Whitespace),
+        ],
+    }