I've been working on Flux - a compiled, general-purpose systems programming language - and wanted to write up what it looks like today. This isn't a roadmap post or a vision doc, just a walkthrough of the language as it exists right now. Source files use the .fx extension, the compiler targets LLVM, and the language is nearing bootstrap. First things first. Flux is not C, nor a C derivative / wrapper. Let's start simple and build up from there. #import "standard.fx"; using standard::io::console; def main() -> int { print("Hello, World!\n"); return 0; }; A few things to notice immediately: def is the function keyword, -> declares the return type, and the closing brace of a compound statement gets a semicolon - compound statements are terminated just like any other statement in Flux. It's consistent everywhere once you internalize it. #import is textual - it splices the file contents at the import site. Multiple imports are processed left to right: #import "standard.fx"; #import "mylib.fx", "foobar.fx"; The using declaration brings a namespace into scope. Namespaces use :: for access, and duplicate namespace definitions merge rather than conflict - a library can spread a namespace across multiple files and it behaves as one namespace at the use site. Flux has the types you'd expect for systems work: bool, byte, int, uint, long, ulong, float, double, char, void And one you might not: data. More on that shortly. Variables are stack-allocated by default. Heap allocation requires the heap keyword - there's no implicit dynamic allocation anywhere. int x = 5; uint y = 300u; float pi = 3.14159; bool flag = true; heap string s = "some data"; (void)s; // explicit cleanup Multiple declarations can be comma-chained: int x = 10, y = 20, z; void as a value equals 0 equals false. You can use it directly in expressions and comparisons, and it serves as the null value for pointers. Functions live at module, namespace, or object scope - no nested function definitions. def myAdd(int x, int y) -> int { return x + y; }; Overloading works on type signature: def myAdd(float x, float y) -> float { return x + y; }; Prototypes (forward declarations) don't require parameter names, only types: def myAdd(int, int) -> int, myAdd(float, float) -> float; def is fastcall by default. Other calling conventions are first-class keywords like stdcall, cdecl, vectorcall, and thiscall. Standard if/elif/else, for, while, do/while, and switch - all terminated with semicolons. switch only puts the semicolon on the default block. try/catch only puts it on the last catch. for (int i = 0; i { A first; B second; }; Template arguments are inferred at the call site. Objects are executable types with constructors, destructors, and methods. this is always implicit - never a parameter. object Counter { int val; def __init(int start) -> this { this.val = start; return this; }; def __exit() -> void {}; def increment() -> void { this.val++; }; }; Counter c = 0; // sugar for Counter c(0); c.increment(); print(c.val); Single-parameter __init allows the assignment-style instantiation shown above. defer runs cleanup in LIFO order, immediately before the function returns: Counter c = 0; defer c.__exit(); // ... c is cleaned up automatically at return Traits enforce structural contracts at compile time: trait Drawable { def draw() -> void; }; Drawable object Sprite { def draw() -> void { // must not be empty return void; }; }; If a Drawable object doesn't implement draw(), compilation fails. throw accepts any type. catch matches by type, with auto as the catch-all: def risky(int mode) -> void { if (mode == 1) { throw(ErrorA(100)); } elif (mode == 2) { throw(ErrorB("failed")); } else { throw("generic"); }; }; try { risky(2); } catch (ErrorA e) { print(f"code: {e.code}"); } catch (ErrorB e) { print(f"msg: {e.message}"); } catch (string s) { print(s); } catch (auto x) { print("unknown"); }; Heap allocation goes through fmalloc and ffree directly: u64 p = fmalloc(sz); if (!(@)p) { ok = false; break; }; total_bytes += (i64)sz; ffree(p); @ is address-of. (@) is an address cast - converts an integer value to a pointer. ! applied to a pointer emits a null check. There's also a postfix not-null operator !?: if (ptr!?) { /* ptr is non-null */ }; Pointer arithmetic, casting, and raw dereferencing all work as you'd expect: byte* bp = (byte*)@addr; int val = *some_ptr; data Type and Bit-Level Work data{N} declares N-bit raw storage, unsigned by default. You can apply signed and create type aliases with as: signed data{32} as fixed16_16; def to_fixed(float value) -> fixed16_16 { return (fixed16_16)(value * 65536.0); }; def fixed_mul(fixed16_16 a, fixed16_16 b) -> fixed16_16 { i64 temp = ((i64)a * (i64)b) >> 16; return (fixed16_16)temp; }; Flux also has endian-aware width types as first-class aliases: nybble, be16, be32, be64, le16, le32, and so on. Network and binary protocol structs look like this: struct IPHeader { nybble version, ihl; byte tos; be16 total_length, identification, flags_offset; byte ttl, protocol; be16 checksum; be32 src_addr, dst_addr; }; def parse_ip(byte* packet) -> IPHeader { IPHeader* header = (IPHeader*)packet; return *header; }; def format_ip(be32 addr) -> string { byte* bp = (byte*)@addr; return f"{bp[0]}.{bp[1]}.{bp[2]}.{bp[3]}"; }; Flux separates logical and bitwise operators syntactically. Logical: &, |, ^^ (XOR), !& (NAND), !| (NOR). Bitwise versions are prefixed with a backtick: `&, `|, `^^, `!. Shifts: >. a[x``y] Operator overloading is supported as long as at least one parameter is not a built-in primitive - struct and object types are always eligible: def operator+(xyzStruct a, xyzStruct b) -> xyzStruct { return xyzStruct {x = a.x + b.x, y = a.y + b.y, z = a.z + b.z}; }; Templates and contracts can be attached to operator definitions. The chain operator 0, "x must be greater than zero"); }; def sqrt_int(int x) -> int : positive { // x is guaranteed > 0 here }; Parameterized contracts match the arity of the function they're attached to. Macros are expression-only and expand at the call site: macro CLAMP(val, lo, hi) { (val, lo, hi) ((val) (hi) ? (hi) : (val)) }; int c = CLAMP(x, 0, 255); Macros and contracts can be mixed on the same function. Enums are typed: enum Color { Red, Green, Blue }; Color c = Color::Red; Unions share memory across members in the usual way, declared like structs. The preprocessor is minimal: #import, #dir, #def, #ifdef, #ifndef, #else, #warn, #stop. #dir adds a path to the search list. #stop hard-halts compilation with a message. #import "standard.fx"; using standard::io::console; struct myStru { T a, b; }; def foo(T a, U b) -> U { return a.a * b; }; def bar(myStru a, int b) -> int { return foo(a, 3); }; macro macNZ(x) { x != 0 }; contract ctNonZero(a,b) { assert(macNZ(a), "a must be nonzero"); assert(macNZ(b), "b must be nonzero"); }; contract ctGreaterThanZero(a,b) { assert(a > 0, "a must be greater than zero"); assert(b > 0, "b must be greater than zero"); }; operator (T t, K k)[+] -> int : ctNonZero( c, d), // works on arity and position, not identifier name. ctGreaterThanZero(e, f) { return t + k; }; def main() -> int { myStru ms = {10,20}; int x = foo(ms, 3); i32 y = bar(ms, 3); println(x + y); return 0; }; The standard library is actively growing - JSON, UUIDs, networking, hashing, and encryption are all in progress. Bootstrapping - rewriting the compiler in Flux - is the next major milestone. There's a GitHub repository, Discord server, and website if you want to follow along or get involved. Repo: https://github.com/kvthweatt/Flux discord.gg/wVAm2E6ymf