A modern C++ implementation of Microsoft BASIC-80 version 5.21.

Repository: https://github.com/avwohl/mbasicc

Debian/Ubuntu:

# Download the latest .deb from releases
sudo dpkg -i mbasicc_X.Y.Z_amd64.deb
sudo apt-get install -f  # Install dependencies if needed

Fedora/RHEL/CentOS:

# Download the latest .rpm from releases
sudo rpm -i mbasicc-X.Y.Z-1.*.rpm

# Download and extract the binary tarball
tar xzf mbasicc-X.Y.Z-linux-amd64.tar.gz
sudo cp mbasicc-X.Y.Z-linux-amd64/mbasicc /usr/local/bin/

Requirements:

• C++17 compiler (g++ 7+ or clang++ 5+)
• libedit development files
• make

Debian/Ubuntu:

sudo apt-get install build-essential libedit-dev
git clone https://github.com/avwohl/mbasicc.git
cd mbasicc
make
sudo cp mbasicc /usr/local/bin/

Fedora/RHEL:

sudo dnf install gcc-c++ make libedit-devel
git clone https://github.com/avwohl/mbasicc.git
cd mbasicc
make
sudo cp mbasicc /usr/local/bin/

macOS:

# libedit is included in macOS
git clone https://github.com/avwohl/mbasicc.git
cd mbasicc
make
sudo cp mbasicc /usr/local/bin/

If libedit is not available on your system, build with -DMBASIC_NO_EDITLINE and drop -ledit from the link line. For example:

make CXXFLAGS="-std=c++17 -O2 -DMBASIC_NO_EDITLINE" LDFLAGS=

This provides basic line input without history or line editing features.

Makefile.djgpp cross-compiles a 32-bit DJGPP mbasicc.exe that runs on FreeDOS, MS-DOS, and DOSBox. The build automatically uses the editline-free fallback (no extra dependencies).

Cross-compile from Linux/macOS:

# Install the DJGPP cross-compiler toolchain (one-time):
#   Linux: download from https://github.com/andrewwutw/build-djgpp/releases
#          and prepend its bin/ directory to PATH
#   macOS: brew install andrewwutw/extras/djgpp
make -f Makefile.djgpp
# Output: mbasicc.exe

Native build under FreeDOS (with DJGPP installed):

make -f Makefile.djgpp CROSS_PREFIX=

The CI builds this target on every push and uploads mbasicc.exe as an artifact. To run the resulting binary, copy mbasicc.exe (and cwsdpmi.exe, shipped with DJGPP, if needed) to your FreeDOS system.

# Run a BASIC program
mbasicc program.bas

# Interactive REPL
mbasicc

# Parse only (show AST)
mbasicc --parse program.bas

# Tokenize only
mbasicc --tokenize program.bas

10 REM Hello World in MBASIC
20 PRINT "Hello, World!"
30 FOR I = 1 TO 5
40   PRINT "Count: "; I
50 NEXT I
60 END

Save as hello.bas and run:

mbasicc hello.bas

This implementation covers the vast majority of MBASIC 5.21 features:

• All program flow control (FOR/NEXT, WHILE/WEND, GOSUB/RETURN, GOTO, IF/THEN/ELSE)
• All data types (INTEGER %, SINGLE !, DOUBLE #, STRING $)
• All arithmetic and logical operators including MOD, , EQV, IMP
• All standard math functions (SIN, COS, TAN, ATN, LOG, EXP, SQR, etc.)
• All string functions (LEFT$, RIGHT$, MID$, INSTR, CHR$, ASC, etc.)
• Array handling (DIM, ERASE, multi-dimensional arrays, OPTION BASE)
• User-defined functions (DEF FN)
• File I/O (sequential and random access)
• Error handling (ON ERROR GOTO, RESUME, ERR, ERL)
• PRINT USING formatted output
• DATA/READ/RESTORE
• CHAIN and COMMON for program chaining
• Interactive REPL with line editing and history

• Direct memory access (PEEK, POKE, VARPTR)
• Port I/O (INP, OUT, WAIT)
• Machine code calls (USR, CALL, DEF USR)
• Cassette tape I/O (CLOAD, CSAVE)

These hardware-specific features are implemented as stubs that return 0 or do nothing.

mbasicc/
├── include/mbasic/      # Header files
│   ├── ast.hpp          # Abstract Syntax Tree definitions
│   ├── error.hpp        # Error codes and messages
│   ├── file_handler.hpp # File I/O abstraction (for WASM portability)
│   ├── interpreter.hpp  # Interpreter class
│   ├── io_handler.hpp   # Console I/O abstraction (for WASM portability)
│   ├── lexer.hpp        # Lexical analyzer
│   ├── parser.hpp       # Parser
│   ├── readline.hpp     # Line editing wrapper
│   ├── runtime.hpp      # Runtime state
│   ├── tokens.hpp       # Token definitions
│   └── value.hpp        # Value types
├── src/                 # Implementation files
│   ├── ast.cpp
│   ├── console_io.cpp   # Console I/O implementation (std::cin/std::cout)
│   ├── error.cpp
│   ├── file_handler.cpp # File I/O implementation (std::fstream)
│   ├── interpreter.cpp
│   ├── lexer.cpp
│   ├── main.cpp
│   ├── parser.cpp
│   ├── readline.cpp     # editline wrapper (portable)
│   ├── runtime.cpp
│   ├── tokens.cpp
│   └── value.cpp
├── man/                 # Documentation
│   └── mbasicc.1        # Man page
├── tests/               # Test files
├── .github/workflows/   # CI/CD configuration
│   ├── ci.yml           # Continuous integration
│   └── release.yml      # Release builds
├── Makefile
├── README.md
├── CHANGELOG.md
└── LICENSE

For WebAssembly or embedding in other projects, you can build just the portable core:

make lib          # Creates libmbasic.a

This includes the lexer, parser, AST, runtime, and interpreter - but not the I/O implementations. Provide your own IOHandler implementation for custom platforms.

The test suite from the Python reference implementation can be used:

# Run all tests
for f in ~/src/mbasic/basic/dev/tests_with_results/test_*.bas; do
    echo "=== $(basename $f) ==="
    mbasicc "$f"
done

Or run individual tests:

mbasicc ~/src/mbasic/basic/dev/tests_with_results/test_simple.bas
mbasicc ~/src/mbasic/basic/dev/tests_with_results/test_math_functions.bas
mbasicc ~/src/mbasic/basic/dev/tests_with_results/test_string_functions.bas

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Run the test suite
5. Submit a pull request

This project is licensed under the GNU General Public License v3.0 - see the LICENSE file for details.

• BASIC-80 Reference Manual v5.21 (AA-P226A-TV)
• MBASIC Wikipedia

• 80un - Unpacker for CP/M compression and archive formats (LBR, ARC, squeeze, crunch, CrLZH)
• cpmdroid - Z80/CP/M emulator for Android with RomWBW HBIOS compatibility and VT100 terminal
• cpmemu - CP/M 2.2 emulator with Z80/8080 CPU emulation and BDOS/BIOS translation to Unix filesystem
• ioscpm - Z80/CP/M emulator for iOS and macOS with RomWBW HBIOS compatibility
• learn-ada-z80 - Ada programming examples for the uada80 compiler targeting Z80/CP/M
• mbasic - Modern MBASIC 5.21 Interpreter & Compilers
• mbasic2025 - MBASIC 5.21 source code reconstruction - byte-for-byte match with original binary
• mbasicc_web - WebAssembly MBASIC 5.21
• mpm2 - MP/M II multi-user CP/M emulator with SSH terminal access and SFTP file transfer
• romwbw_emu - Hardware-level Z80 emulator for RomWBW with 512KB ROM + 512KB RAM banking and HBIOS support
• scelbal - SCELBAL BASIC interpreter - 8008 to 8080 translation
• uada80 - Ada compiler targeting Z80 processor and CP/M 2.2 operating system
• uc80 - ANSI C compiler targeting Z80 processor and CP/M 2.2 operating system
• ucow - Unix/Linux Cowgol to Z80 compiler
• um80_and_friends - Microsoft MACRO-80 compatible toolchain for Linux: assembler, linker, librarian, disassembler
• upeepz80 - Universal peephole optimizer for Z80 compilers
• uplm80 - PL/M-80 compiler targeting Intel 8080 and Zilog Z80 assembly language
• z80cpmw - Z80 CP/M emulator for Windows (RomWBW)