PBXB64 V23 RELEASE Native 64-bit compiler for PowerBASIC-style BASIC
Write the BASIC you know, get a native Windows x64 EXE in about half a second. One compiler file, own assembler, own linker, no GCC, no LLVM, no Visual Studio.
PBXB64 V23 is a native Windows x64 compiler written in C17. It reads PowerBASIC-compatible BASIC and writes PE32+ programs; eight further frontends (C, B64, COBOL, FORTH, Logo, PILOT, Rust, SPR) and an inline x64 assembler share the same toolchain. The V9 package adds 218 C17 headers, H-Lib, reference help in German, English, Spanish and French, and HelpSamples.chm alongside the source examples.
What Distribution V9 Updates
PBXB64 23.0.0-V23 was successfully built from the current integration on 10 October 2026 and is included in the shared PBX-Compiler V9 package (PBX-Basic_09.zip). The main change is new integer types: INTEGER is now 2 bytes, plus SBYTE and SDWORD, INTn/UINTn up to 512 bits and Windows SDK aliases; out-of-range constants are compile errors. Existing code may be affected – the package includes MIGRATION_V23_INTEGER_TYPES.md. Also linker, C23 and runtime fixes and the latest available reference help in four languages (5 October artifacts, not regenerated for this build). The points below arrived with V21 or later and still apply in V23. The included sources span ten folders (BASIC, B64, C, ASM, COBOL, FORTH, Logo, PILOT, Rust, SPR); this does not imply complete parity between the frontends.
V9 editor and toolchain: Editor 0.3.0.27 preserves the compiler selection per tab and includes the evidenced search, dark-theme and debugger usability improvements. Source stepping in this executable is enabled only for PBXB64 and ScharffBASIC; later editor source features are not included. Other package versions are PBXA32 V25 / 1.9.0.0, PBXA64 0.74.0-V74 and PBXC64 1.0.0-rc50. PBXA32 includes Source62 fixes for C pointer addition/indexing and UNION aggregates; PBXC64 delivers the updated line-table build. ScharffBASIC remains byte-identical to V8.
New PBXB64 source integration: B64 escape/character diagnostics and i64 operations, clearer Logo type/binding boundaries, Forth KEY/COUNT and counted-string corrections, Rust Option/Result, zip, trait and recursion-depth work, COBOL call descriptors and NATIONAL/division limits, and PB RATIONAL scalar calls. Runtime payloads were freshly generated and embedded. --memory-budget-mib=N limits tracked compiler allocations (default 1024 MiB), not total Windows process memory or the generated program. SPR contains the frozen scope of 73 started additions: 13 A + 19 B + 41 C; SAP and SPR Browser are deferred.
Verification and help boundary: The regular build succeeded with unchanged inputs. Functional, native and regression follow-up tests were omitted under explicit user instruction; fresh full qualification and proven effects of all SPR commands are not asserted. Each compiler includes its latest already available CHM; the four PBXB64 CHMs date from 5 October 2026. Other compiler help artifacts are older too; PBXA32 has no distinct V25 CHM. Editor Help is newer than executable .27. The dated V8 sample outputs below remain historical evidence. Exact PBXB64/SPR restart handoffs are included in the ZIP.
PBXB64.exe; no extra header folder is needed. The 218 current headers are also shipped under include/c17; the existing c17_headers reference folder is retained.stdarg.h: va_start and va_arg use the canonical compiler builtins instead of a null pointer.PBXB64.exe. Compiling and linking require no external toolchain.Examples contains over 6,400 files in ten folders, 863 of them BASIC programs. HelpSamples.chm complements these sources as a separate reference book.PBXB64_Help_DE.chm, PBXB64_Help_EN.chm, PBXB64_Help_ES.chm and PBXB64_Help_FR.chm are included in the V9 package.PBX-Compiler V9 package with PBXA32, PBXA64, PBXB64 V23, PBXC64, ScharffBasic and PBX Editor; four PBXB64 reference helps, sample CHM, over 6,400 example files and 218 C17 headers.
All six EXEs have valid signatures and timestamps; SHA-256 checksums are included. ScharffBASIC and its help remain unchanged from V8.
Release package prepared for native Windows x64 development
At a glance
Measured on one Windows 11 PC, 2026-10-05 (19 compiles, 0.36-0.46 s each).
Why PBXB64?
True native x64 code
No GCC, no LLVM, no Visual Studio. One command, one tool: PBXB64 turns source into a PE32+ EXE in about 0.4 s (measured). There is no extra runtime DLL to ship: generated EXEs use only Windows system DLLs such as ucrtbase.dll and kernel32.dll.
Nine frontends, one toolchain
PowerBASIC-compatible BASIC is the flagship and the C17 frontend is ready to use. B64, PILOT, COBOL, FORTH, Logo, Rust and SPR are included as experimental frontends. Inline assembler and X-Code are part of the BASIC frontend.
Own x64 backend
Instruction selection, register allocation, peephole optimization, assembler and PE32+ image generation are part of the compiler itself, which is written in C17.
Own PE32+ linker
The built-in linker processes COFF objects, import tables, relocations, TLS and exception data. Generated programs target Windows 10 x64 or newer (documented requirement).
What it is - and what it is not
PBXB64 is a compiler. It reads PowerBASIC-compatible BASIC source and writes a native Windows x64 executable (or DLL). It is not an interpreter and not a virtual machine. It is not a 100 % clone of PowerBASIC: LONG is 64-bit and INTEGER is 16-bit (see the migration table).
| Frontend | V23 maturity | Key supported scope | Limits / not supported |
|---|---|---|---|
| PowerBASIC | production | Flagship native Windows x64 compilation; functions, types, arrays, strings, control flow and custom compile-time directives/forms. | Full PB11 compatibility is not claimed; compile-time extensions have a limited surface and V9 has no fresh aggregate qualification. |
| C | bounded | Reference frontend for native Windows x64 EXE/DLLs; documented C89–C2y modes, preprocessing, Windows ABI and selected GCC/MSVC extensions. | Full standards conformance is not claimed; long double is 64-bit, _BitInt reaches 128 bits, and some language/assembler/linker forms are unsupported. |
| B64 | experimental | Functions, prototypes, pointers, structures, fixed arrays, loops and numeric expressions. | Integer spellings still use signed 64-bit values; self-referential structure pointers are unsupported. |
| PILOT | experimental | Text, input, calculations, matching, jumps and subroutines with numeric QUAD binding. | PBXB64 PILOT dialect with bounded input, expression and stack capacities; shared return stack is not thread-safe. |
| COBOL | experimental | Numeric processing, CALL/LINKAGE and sequential files; selected JSON/XML, allocation and NATIONAL operations. | Not full ISO COBOL; SQL/CICS/MQ unsupported, dynamic CALL is module-known only, and JSON/XML shapes are limited. |
| Forth | experimental | Stack operations, integer arithmetic, words, loops, byte I/O, strings and numeric PB embedding. | Not full Forth 2012; BASE/HEX and other words are absent, and stack misuse is not fully guarded. |
| Logo | experimental | Procedures, recursion, loops, words and lists; console output and bitmap turtle operations. | Binary64 numbers and bounded primitives/capacities; READLIST/MAP unsupported, with mixed-list/host limits remaining. |
| Rust | experimental | Modules, structures, enums, generics, traits, closures, selected macros, Vec/Box/Option/Result and C FFI. | No complete borrow/lifetime checker, Cargo, full standard library, procedural macros or unwinding. |
| SPR / MiniRobot | experimental | Existing commands plus 73 selected new roots; selected bitmap, queue, process, registry and Windows helpers. | 60 roots remain unfinished; no MiniRobot comparison qualification. SAP and SPR Browser are deferred, with many selectors/providers open. |
Maturity states come from pipeline_frontend_registry.c and the current restart handoff. A successful build is not native qualification; functional tests were not run.
Get started in 3 minutes
The complete hello-world source, command line, output and historical timing note are preserved on the detail page.
See DetailsComing from PowerBASIC - 64-bit migration
The complete documentation-backed checklist now lives on its own detail page. It covers integer widths, pointers, APIs, memory, includes and concrete migration patterns.
See Details DeutschThe detail page preserves the previous V23 section and labels historical examples; no new compiler or functional tests were run for this publication.
Verified examples and measured outputs
The machine-room examples, command lines, output logs and historical measurement notes are preserved on this detail page.
See DetailsX-Code, #OVERRIDE & Preprocessor
X-Code
Separate typed assembler dialect: virtual registers, X. commands, register allocation and APX modes. #XCODE … #ENDX accesses BASIC variables and bridge-imported storage. Additional to the nine frontends and the inline assembler; not another standalone file frontend.
View examples and details#OVERRIDE
Replace registered BASIC runtime functions with typed custom implementations. ABS(2)=42 example verified with V23. Distinct from the OVERRIDE method keyword and macro text substitution.
View syntax and exampleBASIC preprocessor
#INCLUDE, #DEFINE, conditional #IF branches and #REPEAT before compilation. A small example checks their combined effect against result 42 (verified with V23).
View checked exampleThe X-Code, #OVERRIDE and preprocessor examples were compiled and run with V23 on 2026-10-05. APX: with APX=AUTO or APX=EMULATE, X-Code translates APX instructions into ordinary x64 instructions, so the APX example runs on any x64 CPU (checked on a processor without APX). Only APX=NATIVE emits real APX encoding and needs an APX-capable processor. The detail page shows both modes.
Frontend quick examples
The complete sum-to-five examples for all nine frontends remain on the detail page, including source snippets and the documented maturity boundary.
See DetailsCross-frontend bridge examples
The full BRIDGE EXPORT/IMPORT source pairs and historical output remain on a dedicated bridge detail page.
See Details9 Highlights of 22 Feature Pages
Explore the details with code samples and explanations. The code blocks on the feature pages are compiled with V23.
Architecture
Nine frontends, shared intermediate representation, own x64 backend, built-in assembler, COFF writer, and PE32+ linker.
Explore →Data Types
Standard PowerBASIC types, SBYTE/SDWORD, INT8..INT512 and UINT8..UINT512, the UN family, native H-Lib types, and COM types.
Explore →Containers
H-Lib native containers: hash tables, growable arrays, sorting with a code pointer and FOR EACH.
Explore →Science & Math
Number theory, special functions, probability, polynomials, exact decimals, and complex numbers.
Explore →Graphics & GUI
GRAPHIC windows and DDT dialogs (DIALOG, CONTROL). DDT is documented as partially implemented.
Explore →Inline Assembly
x64 assembly directly in BASIC: #ASM and #ACODE blocks with variable bindings.
B64 dialect
C-like syntax with types, structs, arrays and pointers (experimental frontend).
Explore →Tooling, help and examples
| Item | What you get |
|---|---|
| PBX-Editor | Shipped in the V9 package (see the README in PBX-Editor\). |
| Help | Four CHM references (DE, EN, ES, FR, about 52 MB each) plus HelpSamples.chm. |
| Examples | Over 6,400 files, 863 of them BASIC programs. |
| Debug info | PDB output via -g --pdb file.pdb (the file is written; debugger use not tested). |
| Resources | Built-in .rc compiler (STRINGTABLE, VERSIONINFO; sample 18). |
| DLLs | #COMPILE DLL with EXPORT (sample 17). |
| Other products in the package | PBXA32, PBXA64, PBXC64 (C17) and ScharffBasic. |
Know before you build
- DDT and GUI. More than 20 control types are available through
CONTROL ADD, from BUTTON, TEXTBOX and LISTBOX to LISTVIEW, TREEVIEW, TAB, TOOLBAR, STATUSBAR and GRAPHIC, plus the DIALOG, MENU and GRAPHIC commands (tested with V23). Tip:DIALOG SHOW MODALdoes not lock the owner window automatically; useDIALOG DISABLEandDIALOG ENABLEwhere needed. - Frontends. BASIC and C17 are ready to use; all 221 shipped C examples run with V23. B64, PILOT, COBOL, FORTH, Logo, Rust and SPR are experimental.
- Signed. The compiler
PBXB64.exeis digitally signed. - Windows API. Include
windows_core.pbi(tested with V23). The large umbrella includesWindows.pbiandWIN32API.pbiare still being completed. - Small rules. The
THREAD CREATEtarget must be a FUNCTION; do not put another statement after a statement macro on the same line with:. - APX. X-Code emulates APX instructions on any x64 CPU (
APX=AUTOorAPX=EMULATE). OnlyAPX=NATIVEneeds an APX-capable processor. - Measurements. Timings come from one fast Windows 11 PC; the parallel speed-up depends on your core count.
Free for private use, cleanly licensed for business
Private, non-commercial use is free. Business, team, and commercial usage goes through Smart Package Robot or by email to info@it-berater.org.
Redistribution of the original, unmodified package is allowed (LICENSE.txt). Download: see the V9 package panel at the top of this page (PBXB64 V23 in the V9 package).
Download Activity
Daily activity for every offered download over the rolling last 28 days. Each downloadable file has its own persistent color.
Command atlas and test vocabulary
The full command-family atlas and its historical vocabulary remain on a dedicated reference page.
See Details