Newshot

Show HN: Zero C#, Power of C# without any GC

Original text(via Hacker News)

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.


        // 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, is and as.
  • Records, tuples, anonymous typesValue equality, with, and the generated ToString.
  • Lambdas and queriesWhere, Select and GroupBy, from a small library instead of LINQ.
  • ThreadsParallel.For runs 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 exceptionsthrow ends 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/Minimal
      

Linux, 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/Minimal
      

macOS 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.exe
      

Windows 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.wasm
      

WebAssembly

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

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.

  • 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

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.

  • Collections that live in arenas List, Dict, and their versions for references and string keys, all handles into an arena. Choose a collection

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. The memory safety rules

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.

  • InstallThe bflat fork and the prerequisites.

The bflat fork and the prerequisites.

  • Your first programBuild it, run it, see how small it is.

Build it, run it, see how small it is.

  • Run it on DOSThe same program under FreeDOS, in an emulator.

The same program under FreeDOS, in an emulator.

  • The tutorialA quiz: output, input, bad input, arenas.

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.

The text above was extracted automatically from the source page and may miss images, tables or code blocks. The original is authoritative.

Published by Hacker News
This site only summarises and aggregates; copyright stays with the original author. Headlines and summaries follow the source — where they differ, the original wins.
Read the original ↗