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.

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.

Use profile Explore the architecture

Built for demanding native Windows projects

Take PowerBASIC forwardAn extended PBXC64 dialect combines familiar syntax with a modern 64-bit architecture. Dedicated modes 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 language profilesenhanced uses the extended PBXC64 language. 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 command interface exposes each capability directly and keeps intermediate results accessible:

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

This page presents the product profile and target architecture. A public download will follow when a coherent preview is ready for user testing. Until then, PBXB64 remains the released primary download product.

RC50Preview of the new platform generation

Continue in the Compiler Workshop

PBXB64 is the current primary download product, with a released package, help, and older versions.

Download PBXB64 V14 View all compilers