G-Lang
C evolved.

Installation

G 0.10.0 runs on Linux x86-64 and is tested on Arch and CachyOS, Ubuntu 24.04 and Debian 13. You need make and clang with LLVM 18 or newer and libclang. On Windows, use WSL2 with Ubuntu 24.04 (not tested separately).

Then build and install:

This installs g and guild into /usr/local/bin and the standard library into /usr/local/lib/g/std. G finds its standard library relative to its own location, so any prefix works. To try G without installing, add compiler/build to your PATH instead.

Your first program

guild new creates guild.toml, src/main.g, a test, and VSCodium debug settings. guild build -v prints every g command it runs, so any build can be repeated by hand. g also works on its own, like a C compiler:

Modules

G replaces #include and header files with #import. A file is a module named after the file, and its names are used through the module name. A module can span several files and live in its own folder.

#import Units                 // finds Units.g
#import player/Player         // a module in a folder
#import Physics as ph         // an alias

Units.hurt(&s);
ph.step(dt);

Everything in a module is visible to importers, except static names (module only) and static static names (this file only). Each module is compiled once, and modules may import each other.

C libraries

C reaches G through its header. Without an alias, a header's names are used exactly as in C; with one, they're qualified. Static and shared C libraries both work: link them as in C, or list them in guild.toml.

#import <zlib.h>              // compress(), uncompress()
#import <zlib.h> as z         // z.crc32(), z.Bytef

unsigned long crc = z.crc32(0, (const z.Bytef^)"hello", 5);

G libraries

A G module compiles to a static (.a) or shared (.so) library plus a .gi interface file. Importers use it exactly like source. With guild:

guild builds dependencies first, and a program with shared dependencies runs in place. By hand, it's the C workflow: g -c -o out/MathLib.o MathLib/ then ar rcs, or g -shared -fPIC -o libMathLib.so MathLib/.

G features

i32 kills;                     // zero by default
f32 buf[4096] = undefined;     // opt out where speed matters

i32^ p = &kills;               // ^ declares a pointer; *p dereferences

struct Health { i32 hp = 100; i32 max_hp = 100; };
struct Soldier {               // a type name, no typedef
    using Health health;       // s.hp reaches s.health.hp
    f32 speed = 2.5f;          // field default
};

void hurt(Soldier^ s, i32 amount = 10);   // default parameter
void hurt(Tank^ t, i32 amount = 10);      // overload on type

{
    defer printf("cleanup\n"); // runs when the block ends
}

tagged union Unit { Soldier soldier; Tank tank; };
match (u) {                    // cases end on their own
case soldier as s: ...
case tank as t:    ...
}

switch (n) {
case 3:
    printf("three, ");
    fallthrough;               // falling through must be said out loud
case 2:
    printf("streak\n");
    break;
}

fntype Callback = int(int hp, float armor);   // function pointer type

#import Global unqualified     // clamp(x) as well as Global.clamp(x)

void log(const char^ msg,      // the caller's file and line, no macro
         const char^ file = __CALLER_FILE__, int line = __CALLER_LINE__);

Also: all of C23 and the GNU extensions C headers rely on, and the fixed-width types i8–i64, u8–u64, f32, f64.

Error handling

i64! load_score(const char^ path)          // '!' = can fail
{
    GString text = try GFile.read_all(path);  // pass errors up
    defer GString.free(&text);
    return try GString.to_int(text);
}

i64 score = load_score("save.txt") else {     // or handle them here
    printf("no save: %s\n", err.msg);
    return 1;
};

An error is a plain value, {int code; const char^ msg;}, made with return error(code, msg). There are no exceptions and no hidden control flow. else {}; deliberately ignores an error.

In debug builds, every error also carries a return trace: where it was raised and each try that passed it up. GTrace.print(err) prints it, and main may return ! to print it when the program fails:

guild

Command	What it does
guild new name [--lib]	Create a project: guild.toml, src/, tests/, assets/, VSCodium settings
guild build [--release]	Build into guild/debug/ or guild/release/
guild run	Build, then run
guild test	Build and run every tests/*.g as its own program
guild clean	Remove guild/
-v	Print every g command, so any build can be repeated by hand

Standard library

Module	What it gives you
GString	Growable strings, or fixed ones on your own buffer. Always '\0'-terminated, so s.data goes straight to C. append, appendf, find, sub, to_int, to_float…
GArray	Growable arrays of any item size: push, get, pop, insert, remove, remove_swap, sort
GMap	Hash maps with text keys: set, get, has, remove, next
GFile	Read or write a whole file in one call, with errors you can handle
GTrace	Prints an error's return trace: where it was raised and each try that passed it up
GMath	Vec2/3/4, Mat4 and quaternions, column-major in the glm conventions, ready for OpenGL, Vulkan and SDL

Editor & debugger

The VSCodium extension (on the Download page) uses the compiler's own language server, g --lsp: highlighting, errors as you type, hover, completion with docs, and go-to-definition, including into compiled G libraries and the standard library. Debugging goes through gdb, with breakpoints and stepping on your .g lines and G names in the variables view. Tagged unions show only the member they hold. The Breakpoints panel has two error breakpoints: G errors: when raised (off by default) stops on every return error(...), and G errors: when main fails (on) stops before a failing program exits, with the error shown and the call stack below it.

Full specification

The complete language specification, with every rule, error message and design decision, lives in the repository: docs/spec/modules.md ↗ and docs/spec/guild.md ↗.