C++

The same interfaces as C, with classes. Good for organising game logic into objects.

How to run it on your phone

vml run examples/cpp/test/sysinfo.cpp

Compiling takes a while (one to two minutes for C, a few seconds for scripting languages). Once the program is running, the gamepad is at the bottom of the screen - the D-pad and the four action buttons are all there. Tap the back arrow in the top-right corner to return to the Shell.

What to know before you write

• Include vml_ui.h just like C
• Classes and some templates are supported; do not rely on the full STL (the standard library is VML's own implementation)
• Global object construction order may not match the C++ standard: to keep it simple, keep state inside main

Examples

Also in this folder: app/1945.cpp, app/gorilla.cpp, app/minesweeper.cpp, bgi/demo_bgi.cpp, bgi/test_bgi.cpp, demo/demo_std.cpp, test/libs.cpp, tty/demo_tty.cpp, ui/demo_ui.cpp

The rest of this page is taken straight from the VML source (third_party/vml/VMLPrepares/CppCompiler/): the README covers what this front end supports and how to compile it, and the language reference covers the syntax itself. When upstream changes, regenerating this page brings it up to date.

Language reference

C++ language compiler specification

Version: v1.1 | Date: 2026-07-06 | Revised by: Shenzhen Tanso Intelligent Technology Co., Ltd.

Specification standard

Keywords

All C subset keywords plus the C++ extensions: class new delete this virtual override public private protected namespace using template typename try catch throw typeid dynamic_cast static_cast const_cast reinterpret_cast bool true false nullptr friend operator explicit mutable inline constexpr

Supported features (C++11 subset)

Basic features

• [x] Basic types: int/char/float/double/bool/void/pointers/references/const
• [x] Control flow: if/else/while/for/do-while/switch/case/break/continue/goto
• [x] Functions: definition / overloading / default arguments / by value / by reference / recursion
• [x] Operators: all arithmetic / comparison / logical / bitwise / ternary / increment and decrement / sizeof

Object-oriented

• [x] Classes: members / methods / access control (public/private/protected)
• [x] Inheritance: single / multiple / virtual inheritance
• [x] Polymorphism: virtual functions / vtable / dynamic binding
• [x] Constructors / destructors: default / parameterized / copy / initializer list
• [x] new/delete: dynamic memory allocation and release

Advanced features

• [x] Templates: function templates / class templates
• [x] Exceptions: try/catch/throw (mapped to VML THROW/CATCH)
• [x] Namespaces: namespace/using
• [x] const member functions
• [ ] RTTI: typeid/dynamic_cast (skipped on MCU)

Standard library

• [x] new/delete
• [x] iostream (basic)
• [ ] Full STL (partially supported)

Floating-point and 64-bit compile modes

The VML toolchain controls how floating-point values and 64-bit integers are handled through three compile options:

32-bit floating point (float32)

The 32-bit single-precision floating-point type float in this language is compiled in one of the following modes:

• hard mode (default): uses the VML native floating-point instructions MOVEF/ADDF/SUBF/MULF/DIVF/CMPF/NEGF, computing directly through the sixteen floating-point registers F0-F15. Best performance; suited to target platforms that have floating-point hardware.
• soft mode: uses the Q15.16 fixed-point software simulation library softfloat.c, simulating floating-point math through functions such as __vml_float_add/sub/mul/div/neg/abs/cmp. Suited to MCU platforms that have no floating-point hardware.
• none mode: disables all 32-bit floating-point types; a float declaration is reported as a compile error.

64-bit floating point (double)

The 64-bit double-precision floating-point type double in this language is compiled in one of the following modes:

• soft mode (default): uses the IEEE 754 double-precision software simulation library softdouble.c, simulating through functions such as __vml_double_add/sub/mul/div/neg/abs/cmp, __vml_int2double/double2int and __vml_float2double/double2float. Compatible with every platform, MCU included.
• hard mode: uses the VML double-precision instructions MOVED/ADDD/SUBD/MULD/DIVD/CMPD/NEGD, computing through the eight double-precision registers D0-D7. Requires the target platform to support 64-bit arithmetic.
• none mode: disables all 64-bit floating-point types; a double declaration is reported as a compile error.

64-bit integers (int64)

The 64-bit integer type long long in this language is compiled in one of the following modes:

• soft mode (default): uses the double-register software simulation library softint64.c, simulating 64-bit integer arithmetic through functions such as __vml_i64_add/sub/neg/and/or/xor/not/shl/shr.
• hard mode: uses the VML native 64-bit integer instructions MOVEL/ADDL/SUBL/MULL/DIVL/MODL/NEGL/CMPL/ANDL/ORL/XORL/NOTL/SHLL/SHRL, computing through the eight long-integer registers L0-L7. Available from v1.65.197+.
• none mode: disables the 64-bit integer type; a long long declaration is reported as a compile error.

Software simulation libraries

The software simulation libraries above all live in the Lib/shared/ directory. They are written in C and compiled to VML by the C compiler, and every language shares them:

Precision notes

• The VML target platform is an MCU; the full STL and RTTI are not supported
• The keyword table includes C++11 features (nullptr/constexpr/override/friend), but template/STL are only parsed and skipped, with no code generated

🆕 String type (v1.65.19)

This language compiler stores strings internally as .wstring (UTF-16LE) by default.

Predefined macro: VML_WSTRING — defined automatically in OS mode, undefined in MCU mode Output function: OS mode automatically uses shared_print_wstr (converts UTF-16LE to UTF-8 automatically)

// user code can test the encoding with the macro
#ifdef VML_WSTRING
  // the default string is wstring (UTF-16LE)
#else
  // the default string is UTF-8
#endif

🆕 Preprocessor directives (v1.65.19)

The C++ compiler inherits every preprocessor feature of the C compiler:

Together with the -D VML_PREFIX=xxx command-line option, the same C/C++ source can generate libraries with different prefixes for different languages. See C_LANGUAGE_SPEC.md for details.

Compiler README

C++11 compiler

Path: VMLPrepares/CppCompiler/ Completeness: ~95% | 🟢 production ready Standard library: Lib/cpp/

Features

• ✅ Parsing + code generation (Lexer/Parser/CodeGenerator)
• ✅ Control flow (if/while/for/switch)
• ✅ Functions / operator overloading / friend
• ✅ Classes / inheritance / virtual functions / vtable
• ⚠️ Templates — parsed and skipped, no code generated
• ⚠️ Lambda — basic support
• ✅ POKE/PEEK memory access (MMIO)
• ✅ Namespaces / casts
• ✅ Shared built-in function library (builtins.vml)

Compile modes

MCU mode (default, --mode mcu)

MCU mode is tuned for microcontroller and bare-metal environments (Arduino/STM32/8051 and the like) and automatically skips features that need an operating system.

Skipped (no code is generated when these appear):

• throw/catch, typeid, dynamic_cast

Kept (the low-level parts are provided by the BIOS):

• new/delete (heap), iostream, STL containers
• POKE/PEEK memory-mapped I/O (MMIO)
• Basic type arithmetic, control flow, function calls
• printf/puts mapped to UART
• Raw pointers (with restrictions)

OS mode (--mode os, reserved)

OS mode targets environments that have an operating system (embedded Linux, RTOS and so on). It will then support the full set of language features (file system, threads, async, exceptions, reflection and so on).

RAM level

• --ram k: kilobyte range (2KB~64KB, such as 8051/PIC/AVR)
• --ram m: megabyte range (64KB~1MB, such as ARM Cortex-M, default)
• --ram g: gigabyte range (such as x86/DDR systems)
• --stack-size <bytes>: set the stack size by hand (by default it is allocated automatically from --ram)

MCU safe-coding tips

• Limited stack space (256-4096 bytes is typical), avoid deep recursion
• No deep recursion (anything deeper than 10 levels needs a stack assessment)
• No dynamic loading (import/dofile/eval)
• Floating-point math may need a software floating-point library

Usage

dotnet run --project VMLPrepares/CppCompiler input.Cp -o output.vml

Tests

Test/Cp/ — 0 test files (the test directory is yet to be created)