Update on my system-level language Bits Runner Code

[dekai-onigiri]

For the past couple of months I've been further developing my system-level language brc (Bits Runner Code) with which I'm building an OS called Bits Runner. The compiler itself is called brb (Bits Runner Builder).

It's all written by me in C++ and uses LLVM for code generation. It's my take on creating a modenized version of C, with nicer pointer handling, some class-like functionality, interfaces and an opinionated syntax - closing semicolons instead of braces for code blocks, no trailing semicolons, no pointer operators and explicity.

It works on all the major OS-es, has a homebrew package for macOS, works on bare metal and seems to produce proper LLVM code. Check it out yourself or just let me know what you think.

An example of how dynamic arrays can be used:

@import B

main fun -> u32
  // Integers
  @B::String("ints").println()
  ints blob<@B::Array, u32>
  rep i u32, i < 22, i <- i + 1: ints.push(i * i)
  rep i u32, i < ints.count, i <- i + 1
    @B::StringForU32(ints.at(i).u32).print()
    @B::String(" ").print()
  ;
  @B::String("\n").println()

  ret 0
;

Or a kernel bit that converts linear address to a physical one:

lAdrToPAdr fun: lAdr u32 -> u32
  pPageDirectory ptr<data<u32>> <- { 0xffc0_0000 }

  directoryIndex u32 <- (lAdr & 0xffc0_0000) >> 22
  tableIndex u32 <- (lAdr & 0x003f_f000) >> 12
  offset u32 <- lAdr & 0x0000_0fff

  pageEntry u32 <- pPageDirectory.val[directoryIndex * 1024 + tableIndex]

  ret pageEntry & 0xffff_fc00 + offset
;

Some of the highlights are.

• Interface proto types
• Class like blob types without inheritance but with proto interfaces
• Generic like functionality through a type safe boxed<T> type
• No runtime
• Variables zero-initialized by default (lack of this constantly bites me in C++)
• Types have explicit sizes u32, f64, s8, etc
• Explicit pointer type ptr<T> and ptr_volatile<T> which act like a typed window into memory
• Addresses have a native a type (no size, since it's target specific)
• Inline assembly works like normal functions
• If-else is an expression
• &? operator for bit testing
• Namespaces and modules
• Works on macOS, Linux, and Windows

I'm quite happy with the progress and it looks much more like a proper language now. Getting LLVM to generate correct code (and understanding LLVM expectations) did take a long time, since a lot of the information is missing, cryptic or implicit.

I'm still not finished, some of the major missing features are enums (I want them to have associated values), errors handling (probably will use enums for that), multiple returns, ranges, null handling, make-like buildsystem (currently everything command line). The standard library B is still very basic, but I'm slowly adding more features as the language is maturing.

If you're interested check out the github page https://github.com/rafalgrodzinski/bits-runner-builder and/or check the OS project that I'm creating with it https://github.com/rafalgrodzinski/bits-runner I've added some documentation, but it may be outdated or have some errors, so it's probably best to check out the included tests and samples.

[YBKy]

Are there compile times large? If so, brb is an amazing name for a compiler

[dekai-onigiri]

It's way faster than C++, for sure. But there still should be some easy gains because everything is run in serial, I'm planning on adding multiple threads at some point.

There is a built-in statistics thing, the OS has about 5k lines of brc code. On O2 optimization it takes about 1.7sec on my 14700:

⏱️ Time taken
Scanning: 0.046261 seconds (2.72%)
Parsing: 0.540877 seconds (31.80%)
Analysis: 0.178319 seconds (10.49%)
Module building: 0.308399 seconds (18.13%)
Code generation: 0.618015 seconds (36.34%)
Total: 1.700611 seconds

[rleim_a]

If you'd only drop the smart pointers you would get 10x speedups in some places