ZX Spectrum Next: What Do I Actually Code In?

If you’re one of the thousands of backers waiting for your shiny new ZX Spectrum Next Issue 3 to arrive, congratulations — you’re about to receive one of the most exciting retro-modern computers ever made. But before you even power it on, you’ve probably started asking yourself the same questions many of us did: which language should I use? Why are there so many options? And what’s the difference between NextBASIC, Boriel ZX Basic, and this thing everyone keeps calling NextBuild?

This article is a hands-on guide written from a newcomer’s perspective. It’s meant to help you understand the various development options available for the Next, how to use VS Code to write your programs, and how to get those programs onto your real hardware. Whether you want to type in listings from 1980s books or build a fast, modern game, this guide will help you navigate the ecosystem with confidence.

1. The Core Problem

The ZX Spectrum Next is both a retro and a modern machine. It can behave like a 1980s 48K Spectrum, faithfully running original games and BASIC listings, or it can act as a fully enhanced system with extra memory, graphics modes, sound channels, and file support. This dual nature is part of its charm — but also the root of confusion for new users.

Because of this, there isn’t just one “right” way to write software for the Next. You can write in old-school BASIC and load your code directly on the device, or you can use modern compilers and build environments to create standalone executables. The result is a toolchain landscape that can feel fragmented until you understand what each piece does.

  • The Next can boot in either 48K compatibility mode or Next mode.
  • Tools like NextBuild and Remy Sharp’s VS Code extension target different goals.
  • File extensions such as .tap and .nex don’t always mean the same thing.

2. The Four Languages You’ll Encounter

When people talk about “coding for the Next,” they’re often referring to one of four environments. Each has its own history, purpose, and output format. Knowing the difference helps you pick the right one for what you’re trying to achieve.

NextBASIC (ROM, interpreted)
This is the BASIC that actually ships with the Next. You can type it on the Next itself and run it right away. It’s interpreted, not compiled. Great for learning and small projects.

Sinclair BASIC (48K style)
This is the classic Spectrum BASIC from 48K books: line numbers, GO TO, POKE. The Next can run this too — if you boot it in 48K mode or load a 48K-style .tap.

Boriel ZX Basic
This is a modern BASIC dialect that compiles to Z80. By default it targets Spectrum-like machines (48K/128K). This is what a lot of people use because compiled code is fast.

Assembly / C / Other Toolchains
sjasmplus, z88dk, etc. These can also produce .nex files. Important point: .nex ≠ “made with NextBuild only.”

3. The Tools You Keep Hearing About

Once you understand the languages, the next piece of the puzzle is the tooling. Most modern developers use Visual Studio Code (VS Code) on their PC or Mac to write programs, then copy or export them to the Next. These three tools make up the current standard toolchain.

Boriel ZX Basic Compiler (zxbc)
This is the actual compiler that turns your Boriel BASIC source code into a Spectrum-readable file, usually a .tap. You can use it directly from the command line — for example, typing zxbc game.bas -o game.tap — or through a build system like NextBuild. By default, Boriel targets the classic Spectrum memory layout (48K), but you can easily configure it for Next-specific features.

NextBuild (VS Code)
NextBuild is a VS Code extension that wraps Boriel ZX Basic and automatically compiles projects for the Next. It adds convenience features: handling assembler steps, linking in Next hardware libraries, and outputting .nex files that run natively on the Next’s operating system. If you’ve seen modern homebrew games for the Next that launch instantly from the browser, chances are they were built with NextBuild.

NextBASIC VS Code Extension (Remy Sharp)
Created by developer Remy Sharp, this extension provides a full editing environment for writing NextBASIC programs inside VS Code. It includes syntax highlighting, automatic renumbering, and commands to export your text as .tap or .bas files that the Next can understand. It’s perfect for those who love the simplicity of BASIC but want a modern editor instead of typing directly on the Next’s keyboard.

  • NextBuild → Compiled → .nex → Runs in Next mode.
  • Remy’s Extension → Interpreted → .tap → Runs in BASIC mode.

4. Why People Prefer NextBuild Over NextBASIC

While NextBASIC is excellent for tinkering, most developers outgrow it once they want speed, structure, and flexibility. Compiled code through NextBuild and Boriel ZX Basic executes dramatically faster and allows for more advanced logic and graphical effects. It’s also easier to manage large projects because you can use modern software practices like version control, multiple source files, and automated builds.

  • NextBASIC → Easy to start but slower.
  • NextBuild → Requires setup but produces fast, standalone programs.
  • Community momentum → Most tutorials and libraries now assume NextBuild.

5. Writing in VS Code and Running on the Next

This is the part that confuses beginners. How do you write code on your PC and run it on real hardware? There are two main approaches depending on your goal — staying true to BASIC or embracing compiled builds.

Workflow A — Writing and Running BASIC Directly
If you want to write in real NextBASIC and be able to open and edit your code directly on the Next, use Remy Sharp’s extension. You’ll type your program in VS Code, save it, then use the extension’s “Export to TAP” command. This creates a tokenized file the Next can load immediately. Copy that file to your SD card, load it through the file browser, and type RUN. It’s quick, authentic, and keeps your programs readable on the device.

Workflow B — Compiling for Performance
If your goal is to make fast games or utilities, switch to Boriel ZX Basic and NextBuild. This setup compiles your BASIC into machine code and outputs a .nex executable. You can’t edit it directly on the Next, but it launches instantly and runs as fast as native software. This workflow feels closer to how professional Spectrum Next developers work.

6. Using Listings from Old 48K Spectrum Books

One of the joys of the Spectrum Next is being able to revisit those vintage programming books from the 1980s. You can absolutely type those listings into VS Code — but there’s one extra step. The Next (and the original Spectrum) don’t read plain text BASIC; they expect a tokenized format stored inside a .tap file. Think of it as a “virtual cassette.”

Tools like zmakebas can convert your text file into this format, but if you’re using Remy’s extension, it can handle that automatically when you export. Once you have your .tap, copy it to your SD card, boot your Next into 48K mode, and type LOAD "". You’ll see your retro masterpiece spring to life exactly as it would have in 1984.

  • Type your listing in VS Code.
  • Export to .tap using the extension or zmakebas.
  • Boot the Next in 48K mode and load it.

7. If Both Exports Make .TAP Files

Beginners often wonder why both 48K BASIC and NextBASIC programs use .tap files. The truth is, the file format is just a container — what matters is what’s inside. A 48K .tap contains Sinclair BASIC code and memory layout, while a NextBASIC .tap uses the extended instruction set and features. The Next’s operating system is smart enough to tell the difference when you load the file, but you must run it in the correct mode. If you try to load a NextBASIC .tap in 48K mode, it’ll fail, and vice versa.

  • The file format doesn’t define the target — the content and mode do.
  • 48K BASIC → Boot in 48K mode.
  • NextBASIC → Use Next mode.

8. Can I Use NextBuild to Compile for 48K?

You can, technically, but it’s not the best tool for that job. NextBuild is pre-configured for the Next and its extended memory map. If your goal is to build something purely 48K compatible, just run Boriel’s compiler directly from the command line. For example:

zxbc mygame.bas -o mygame.tap

This will generate a classic 48K Spectrum file. You can load it into any emulator or real hardware in 48K mode. It’s the simplest way to keep things authentic.

  • NextBuild → Optimized for Next.
  • Boriel compiler alone → Best for 48K targets.

9. Are All .nex Files Made with NextBuild?

Not at all. The .nex extension is the Next’s native executable format — think of it like .exe on Windows or .app on macOS. It tells the Next how to load and run a binary file, including metadata like where to start execution and how much memory to reserve. While NextBuild is the most popular way to produce these files, any toolchain that generates Z80 machine code can build a .nex: hand-written assembly, C projects using z88dk, or even direct output from sjasmplus scripts.

The extension simply tells you the file is a Next executable — not which compiler made it.

  • NextBuild → Commonly used, VS Code-friendly.
  • Z88DK or sjasmplus → Alternative compilers that also produce .nex.

10. Quick Decision Guide

Here’s a simple way to decide which setup to use:

  • You want to see and edit the program on the Next: Write in NextBASIC with Remy’s extension, export as .tap, load in BASIC mode.
  • You want maximum speed and compiled code: Write in Boriel BASIC, build with NextBuild, run as .nex.
  • You want to type listings from vintage books: Write in VS Code, export as .tap, boot the Next in 48K mode, and LOAD "".

11. Common Blockers

When you start experimenting, you’ll probably hit a few snags. Here are the usual suspects and how to fix them:

  • “My Next won’t load the file.” → You probably copied the raw .bas text file instead of exporting a tokenized .tap or .nex.
  • “It runs in the emulator but not in 48K mode.” → Make sure you haven’t used any Next-specific commands in your BASIC code.
  • “I can’t find zxbc.” → If NextBuild works, the compiler is installed — it just needs to be added to your system PATH or run from its directory.
  • “My BASIC program is too slow.” → That’s normal for interpreted code. Move to Boriel/NextBuild for a compiled version.

12. What to Do Next

Now that you understand the ecosystem, you can start experimenting. Install both Remy Sharp’s NextBASIC extension and the NextBuild system in VS Code. Create two folders — one for BASIC projects and one for compiled Next projects — and try exporting each to your SD card. The difference in performance will teach you more than any tutorial.

  • Set up simple VS Code build tasks for zxbc or zmakebas.
  • Keep example folders like:
    • nextbasic-demo/ (for simple interpreted programs)
    • boriel-nextbuild-demo/ (for compiled projects)
  • Note which mode you used — 48K or Next — and test in both.

The Spectrum Next is a bridge between eras — old enough to feel nostalgic, powerful enough to feel new. Once you grasp the two basic workflows (interpreted vs. compiled) and two machine modes (48K vs. Next), everything clicks. Suddenly, all those cryptic file extensions make sense — and you’ll be writing and running your own Next programs in no time.