Zero Compiler

Zero is a compiler project for the Zero programming language and Zero Assembly (ZASM). ZASM is the working assembly language today: write x86 instructions, define data, share headers, and call Windows DLL functions to build an executable. The higher-level Zero language is under design; see Coming Soon.

Download Zero · Getting started · Language reference · Examples · Source code

What Zero Supports Today

The compiler’s host architecture and its output architecture are separate. The Windows x64 release runs on Windows x64 and generates Windows x86 programs. Windows APIs can create windows and controls, but the current output still uses the console subsystem. ELF, ARM code generation, and native x64 output are future work.

Download and Install

1. Open the latest release.
2. Under Assets, download zero-v<version>-win-x64.zip.
3. Extract the ZIP into a folder where you can save files.

4. Open PowerShell in that folder and run:

   .\zero.exe --help
   

Keep this layout when moving or installing the compiler:

zero.exe
zcc.exe
include/
  windows/
    console.zh
    windows.zh
    ...
  linux/                  # Drafts for future ELF support.
    libc/
    syscalls/
samples/
  hello-using.zasm
  ...

Both executable names run the same compiler. There is no installer, and the native release does not require .NET to be installed. Keep include beside the executables so shared headers can be found from any working directory.

Getting Started with ZASM

Save this as hello-zero.zasm in the extracted release folder. Make sure the extension is .zasm, rather than .txt.

; Print a greeting using the shipped console header.
using "windows/console.zh"

  jmp start               ; Skip the bytes stored below.

message db 'Hello Zero!', 0

start:
  push message            ; Pass the string's address.
  call [puts]             ; Print the string and a newline.
  add esp, 4              ; Remove the one 32-bit argument.

  push 0                  ; Return exit code 0.
  call [exit]

Compile and run it:

.\zero.exe run hello-zero.zasm

Output:

Hello Zero!

The compiler creates hello-zero.exe beside the source file. Run it again with .\hello-zero.exe, or omit run to compile without executing.

Read the Program

using inserts the header’s source. windows/console.zh declares the DLL imports for puts, printf, and exit. jmp start skips the inline string data. puts prints a zero-terminated string and adds a newline. Its cdecl calling convention requires the caller to remove the argument with add esp, 4.

Command-Line Guide

# Compile; output defaults to hello-zero.exe.
.\zero.exe hello-zero.zasm

# Choose an output file.
.\zero.exe hello-zero.zasm greeting.exe

# Compile and execute; wait for the program's exit code.
.\zero.exe run hello-zero.zasm

# Add header search directories in order.
.\zero.exe run hello-zero.zasm -I "headers" -I "C:\Libraries\Zero"

# zcc is another name for the same compiler.
.\zcc.exe run hello-zero.zasm

Use -h or --help for help. --include is an alternative to -I. A compilation failure prevents run from executing an older output file. See the reference for command options and error codes.

ZASM Language at a Glance

Use one instruction or directive per line. Operands are separated by commas; when an instruction has a destination, it comes first. Mnemonics, register names, and labels are case-insensitive. Preserve the spelling of DLL export names. Semicolons start comments outside quoted strings; they are not required terminators.

Mnemonics

Only the operand forms listed in the instruction reference are supported. For example, mov eax, 42 and mov eax, [value] work; register-to-register MOV and memory stores are Coming Soon.

Operands and Registers

The current instruction forms use the 32-bit registers EAX, EBX, ECX, EDX, ESI, EDI, EBP, and ESP. Other widths and SIMD registers are future work. See register roles and memory addressing.

Directives, Labels, and Statements

Use a colon for labels before DW and DD; only DB also supports the colon-free form shown above. Data currently lives alongside instructions in the read-only code section. Start with a jump when inline data appears before your code. The first emitted byte is the entry point; the name start has no special meaning.

Include search order is the current working directory, then each -I directory, then include beside the compiler. Nested headers use the same search order. See Using included files for nested headers, cycle detection, source locations, and library integration.

Read the full ZASM reference for strings, labels, instruction forms, imports, calling conventions, and current limitations.

Examples and Tutorials

Start with the complete basic examples: console text, integer addition with formatted output, and a Windows MessageBox. Each includes a command and expected behavior.

From the release folder, also try:

.\zero.exe run samples\hello-using.zasm
.\zero.exe run samples\hello-db-vars.zasm
.\zero.exe run samples\v002-integer-math.zasm
.\zero.exe run samples\hello-concat.zasm
.\zero.exe run samples\hello-win86-controls.zasm

• String concatenation tutorial: a short walkthrough with a mnemonic table.
• Sample guide: console, arithmetic, strings, MessageBox, and controls.
• Windows API headers: core Windows APIs, controls, dialogs, drawing, shell, networking, COM, and more.
• Linux headers and future ELF support: draft glibc interfaces and architecture-specific syscall references.
• Header catalog: all shipped .zh files and calling rules.
• Assembly overview and opcodes: a compact companion to the language reference.

Build and Contribute

Clone the repository and run .\build.bat from its root. This builds the compiler, validates every ZASM sample, and publishes zero.exe, zcc.exe, include, and samples into publish.

• Building Zero: prerequisites, AOT publishing, sample validation, and version settings.
• Automatic versioning and releases: GitHub Actions version increments, tags, and releases.
• Project background and original language ideas: history and proposed higher-level syntax.
• Future formats and architectures: shared parsing with separate target backends.
• ZSRC console proof of concept: a future high-level language example.
• Assembly syntax sandbox: experimental proposals, including directives that are not implemented.

The reference describes the current compiler. Historical examples and design proposals are labeled separately so they can evolve without implying support today.

Coming Soon

See the ZASM feature roadmap for implemented assembly features, proposed key features, and nice-to-have improvements.

These are documentation placeholders and development ideas, with no promised release date. They are not current compiler capabilities.

Contributors can replace these placeholders with tested syntax and examples as features become available. See the reference’s limitations before adapting assembly from another assembler.