Engineer in front of the PBXC64 compiler machine
Technical preview
PBXC64 1.0.0-rc50
Windows x64
Native PE32+
Parallel compiler pipeline
Parallel EXE + GPU

One toolchain. One native path to a Windows program.

PBXC64 is designed as a complete Windows x64 compiler platform. PowerBASIC-style source, inline ASMX64, and future language frontends share a modern intermediate representation on their way to native machine code. Assembly, resource processing, COFF objects, and PE32+ output belong to the same toolchain.

RC50 preview: the following parallelism, GPU and scientific sections explain architecture and development goals, not a currently fully qualified feature set.

The result is not a wrapper around another compiler. It is a controllable platform for native EXE, DLL, and OBJ output, precise diagnostics, and long-term language expansion.

V10 package with the RC50 previewUse profileExplore the architecture

Built for demanding native Windows projects

Take PowerBASIC forwardAs a compiler for the supported C17 subset, PBXC64 combines familiar, PowerBASIC-style syntax with a modern 64-bit architecture. Dedicated compiler profiles address PBWin and PBCC compatibility.
Control the toolchainCompiler, ASMX64, resource compiler, COFF writer, and PE linker are designed as one integrated platform.
Ready for more languagesEach frontend retains its own syntax and semantics, then uses the same optimization and x64 output path.

Modern compiler architecture, not direct syntax translation

PBXC64 first preserves program meaning in a high-level IR. MIR with SSA and Memory SSA then enables deeper analysis and optimization. LLIR and Machine IR provide a controlled path into the x64 backend. Language rules, optimization, and machine code therefore remain cleanly separated.

PowerBASIC / ASMX64 / future frontends -> HIR -> MIR + SSA + Memory SSA -> Optimizer -> LLIR -> Machine IR -> x64 code generation -> ASMX64 -> COFF / PE32+

This structure supports multi-stage optimization, whole-program analysis, safe parallelization, and additional frontends without rebuilding the backend for every language.

Parallelism at two levels

PBXC64 does not use parallelism only to compile faster. The compiler can also discover parallel work in the user's program and build it into the generated executable.

1. The compiler works in parallelFiles and includes, frontends, functions, HIR/MIR/SSA processing, optimization, x64 code generation, ASMX64, COFF production, resources, and linker work can be distributed across multiple workers. This reduces build time, especially for large projects.
2. The generated program works in parallelPBXC64 analyzes data dependencies, memory access, aliases, loops, and reductions. Independent work can be emitted as a task graph for a native work-stealing thread pool. Sequential execution remains selectable for debugging and reproducible behavior.

Automatically from a loop to CPU cores or the GPU

A loop over independent array regions can become a parallel FOR. Sums and other suitable operations can run as parallel reductions. Large string, vector, matrix, or UNL/UNF workloads can additionally be marked as GPU candidates.

Safe by defaultOnly provably independent work is parallelized by default. Dependencies, I/O ordering, and observable side effects remain intact.
Cost-based choiceSmall and latency-sensitive tasks stay on the CPU. For larger data sets, the planner considers compute cost, transfer overhead, and the available GPU type.
Direct3D 12 with CPU fallbackThe Windows-native GPU path targets Direct3D 12 Compute. If GPU offloading is unavailable or not worthwhile, a CPU execution path remains available.

The complete native Windows path

From source to PE imageLexer, parser, semantic analysis, IR system, optimizer, x64 backend, ASMX64, COFF object writer, resource compiler, import/export tables, and PE linker form one architecture.
No external backend chainThe product design lets PBXC64 complete compilation itself without depending on LLVM, GCC backends, MASM, NASM, or external linker processes.

PowerBASIC compatibility with room to grow

Three compiler profilesenhanced uses the extended PBXC64 feature set. pbwin and pbcc provide explicit compatibility paths for Windows and console projects.
Inline ASMX64 with a symbol bridge#ASM ... #ENDA connects the high-level language with x64 assembly. Symbols and type information can move between the frontend and assembler in a controlled form.

Technology for compute-intensive applications

UNL and UNFNative concepts for unlimited integers and precise floating-point, decimal, fixed-point, and rational numbers.
Vectors, matrices, and intervalsScientific data types are part of the architecture, allowing the compiler to analyze and optimize them directly.
CPU, parallelism, and GPUThe design combines CPU feature dispatch, safe automatic parallelization, and a Windows-native Direct3D 12 GPU planner with CPU fallback.

One executable for the complete build path

The expanded command interface below describes the architectural design and is not a verified RC50 usage contract. The current package README documents:

PBXC64.exe program.pb

Design of the expanded toolchain interface:

pbxc64 build source.bas -> compile, assemble, and link
pbxc64 compile source.bas -> produce OBJ, ASM, or IR output
pbxc64 asm source.asmx -> assemble with ASMX64
pbxc64 link file1.obj ... -> link with the internal linker
pbxc64 rc file.rc -> compile Windows resources
pbxc64 dump / verify -> inspect and verify artifacts

PBXC64 is currently a technical preview

RC50 remains a technical preview; its signed executable is available in the V10 package. No current full qualification run is claimed here.

Download PBX Compiler V10

Continue in the Compiler Workshop

RC50 is included as a technical preview in the shared PBX Compiler V10 package. The architecture overview below describes design and existing components, not full qualification of every listed path.

Who it is for: developers who want to try PowerBASIC-style source on a new Windows x64 platform. Requirements: Windows x64; RC50 is a technical preview. For production use, PBXB64 is the primary product. The reference help (CHM) is at the bottom of the page; see the license.

View PBXB64 V24View all compilersHelp with your project

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.

Download Activity

Daily activity for every offered download over the rolling last 28 days. Each downloadable file has its own persistent color.

Current download and release boundaries

PBX Compiler V10: about 355 MB. Includes PBXA32 V24, PBXA64 V10, PBXB64 V24, PBXC64 RC50, ScharffBasic and the PBX Editor with help, includes and examples.

The shipped executable has file version 1.0.0-rc50 and a valid signature. RC50 remains a preview but is already downloadable in the V10 package. Further parallelization, GPU and scientific architecture goals do not promise fully qualified language or runtime parity.

CHM DeutschCHM EnglishV10 package checksum