Zero C# Compiles C# to Native Code Without Runtime or GC
Zero C# is a fork of bflat that compiles C# straight into small native programs with no .NET runtime, no garbage collector and nothing to install on the target. It keeps C# syntax, type checking and generics while managing memory through arenas freed all at once, and the same source runs on Linux, macOS, Windows, WebAssembly and even DOS on a 386.
Related Entities
Full Report
Contents12 sections
C# with nothing underneath
A fork of bflat compiles C# straight to a small native program: no .NET runtime, no garbage collector, nothing to install where it runs.
You keep C#'s syntax, type checking and generics. Memory comes from arenas you free all at once, and a small library gives you strings, collections, input and output on those terms. The same source runs on Linux, macOS and Windows, on WebAssembly, and on DOS on a 386.
Get started Build the quiz tutorial Run it in your browser
// Read into a stack buffer: nothing allocated per answer.
Span<char> buffer = stackalloc char[32];
Out.Write($"Q{i}: {a} + {b} = ");
int length = In.ReadLine(buffer);
// Kept until the end, so it goes into an arena.
mistakes.Add(Str.Format(keep,
$"{a} + {b} = {a + b}, not {value}"));From the quiz the tutorial builds, step by step.
The language stays, the runtime goes
The compiler still checks everything it checks in .NET. What's missing is what a runtime would do while your program runs.
You keep
- C# 15Unions, extension members and the new memory safety rules.
- Real genericsA specialized copy for each type, and static abstract members.
- Interfaces and virtual methodsDefault interface methods, casts,
isandas. - Records, tuples, anonymous typesValue equality,
with, and the generatedToString. - Lambdas and queries
Where,SelectandGroupBy, from a small library instead of LINQ. - Threads
Parallel.Forruns a loop on every core.
You do without
- Garbage collectorArenas free their memory all at once, when you say.
- .NET runtimeHello world is 11 KB on Windows and 40 KB on Linux, with nothing to install.
- Catching exceptions
throwends the program. Return errors as unions. - Reflection and asyncA type can be compared, but it has no name.
One program, five machines
The hello-world sample, unchanged, built for each target. Each build is checked by the same test suite, which requires the same output everywhere.
$ ./build.sh Minimal
$ ./run.sh Minimal
Hello from zero-mode!
$ wc -c bin/Minimal
39848 bin/MinimalLinux, x64 or arm64
A native program that needs only the C library. On macOS it builds and runs in a container.
$ ./build.sh --mac Minimal
$ bin/mac/Minimal
Hello from zero-mode!
$ wc -c bin/mac/Minimal
64728 bin/mac/MinimalmacOS on Apple Silicon
A native Mac program: bflat compiles it, the Mac's own clang links it. No container to run it.
$ ./build.sh --win Minimal
$ ./run.sh --win Minimal
Hello from zero-mode!
$ wc -c bin/win/Minimal.exe
10752 bin/win/Minimal.exeWindows x64
A console program on Windows' own C library, built from Linux or macOS. Tested under Wine.
$ ./build.sh --wasm Minimal
$ ./run.sh --wasm Minimal
Hello from zero-mode!
$ wc -c bin/wasm/Minimal.wasm
15833 bin/wasm/Minimal.wasmWebAssembly
A WASI module, through NativeAOT-LLVM. Runs under wasmtime.
C:\>D:
D:\>PROGRAM
Hello from zero-mode!
D:\>DIR PROGRAM.EXE
PROGRAM EXE 16,384
D:\>DOS on a 386
The same bitcode compiled for a 386, run by the HX DOS extender. Tested on Bochs's i386 model.
What's different, and what you get
Without a runtime, a few things work differently. Each has a page that explains why and what to do instead.
-
Memory is yours to free
There is no garbage collector, so new is never freed. Arenas hand out memory and free it all at once, one per lifetime.
Memory without a garbage collector
-
Text without throwaway strings
Out.Line($"...") formats straight into the output buffer, and In.ReadLine reads into a span. Strings that must last go into an arena.
Strings without a garbage collector
-
Collections that live in arenas
List, Dict, and their versions for references and string keys, all handles into an arena.
-
C# 15, with the safety rules on
Every program compiles under the updated memory safety rules: creating a pointer is safe, reading through one is marked and explained.
Where to start
If you're new to it, these four pages take you from nothing to an interactive program.
The bflat fork and the prerequisites. 2. Your first program
Build it, run it, see how small it is. 3. Run it on DOS
The same program under FreeDOS, in an emulator. 4. The tutorial
A quiz: output, input, bad input, arenas.
Looking for something specific? The task guides answer one question each, and the reference lists every type in the library.