Vala

Vala is a statically typed, object-oriented programming language created for the GNOME desktop ecosystem. Its pitch is unusual and elegant: give programmers the syntax and conveniences of C# — classes, interfaces, properties, signals, generics, lambdas, async/await — but compile everything down to plain C code targeting GObject, the object system that underpins GTK and the rest of the GNOME platform. The result is a native binary with no virtual machine, no garbage-collected runtime, and no dependencies beyond the GLib libraries that GNOME software links against anyway. For nearly two decades Vala has been the pragmatic middle path for Linux desktop developers: far more expressive than GObject C, far lighter than Mono or the JVM.

History and Origins

Vala was conceived by Jürg Billeter and implemented by Billeter together with Raffaele Sandrini, two Swiss developers who wanted a modern, high-level language for writing GNOME applications. Writing GObject-based code in C was (and is) famously verbose — defining a single class involves pages of boilerplate macros, manual reference counting, and hand-wired signal machinery. The pair admired the syntax and semantics of C#, but adopting it would have meant depending on the Mono runtime, which was both a heavyweight addition to the desktop and, at the time, a source of patent anxiety in the free-software community.

Their answer was to keep the language and discard the runtime. The first Vala compiler was completed in May 2006, initially bootstrapped in C. By July 2007, with the release of version 0.1.0, the compiler had become self-hosting: valac has been written in Vala ever since — a strong early proof that the language was ready for real work.

In 2008 the same compiler infrastructure gained a second front end: Genie, a dialect with Python-like indentation-based syntax that compiles through the identical pipeline. Vala and Genie code can be mixed freely in one project, an early demonstration of how cleanly the compiler separates surface syntax from its GObject-centric core.

Design Philosophy

Vala’s design flows from one central decision: the compiler is a transpiler. valac translates Vala source into C code that uses the GObject type system directly, then hands that C to GCC or Clang. Everything else follows:

• No added runtime. A Vala program is, after compilation, indistinguishable from a hand-written GObject C program. It links against GLib and whatever libraries it uses — nothing more. There is no VM to start, no JIT to warm up, no tracing garbage collector.
• Perfect two-way C interoperability. Vala consumes C libraries through lightweight binding files (VAPI files), which describe an existing C API to the compiler. Hundreds of library bindings ship with the compiler, and writing new ones requires annotation, not wrapper code. In the other direction, a library written in Vala exposes an ordinary GObject C API (with a generated header) that C, Python, JavaScript, Rust, and other languages can call — often via GObject Introspection with no extra effort.
• Memory management without a collector. Vala uses GObject’s reference counting, automated by the compiler. Ownership annotations (owned, unowned, weak) let programmers control when references are counted, and the compiler inserts the ref/unref calls a C programmer would write by hand. Reference cycles are the programmer’s responsibility to break — a deliberate trade-off for deterministic, pause-free behavior.
• The platform is the standard library. Rather than inventing its own ecosystem, Vala embraces GLib and GIO as its standard library and GTK as its natural UI toolkit. The language is a better way to use the GNOME platform, not a replacement for it.

Because the generated code is ordinary GObject C, a Vala program’s runtime characteristics are essentially those of the equivalent hand-written C — the language adds abstraction at compile time, not execution time.

Key Features

Vala reads like C#, and most of the features a C# or Java programmer expects are present:

• Classes with single inheritance, interfaces (which may carry default implementations, giving mixin-like reuse), and abstract and virtual methods
• Properties with get/set blocks and automatic backing fields, mapped onto GObject properties
• Signals as first-class language members — the observer pattern that pervades GTK programming is a keyword, not a library convention
• Generics, type inference with var, nullable types (string?), and compile-time null checking
• Lambdas/closures and delegates
• async/await asynchronous methods built on GIO’s asynchronous I/O machinery — coroutine-style code without threads
• Exception-like error handling (throws, try/catch) mapped onto GLib’s GError convention
• String templates (@"Hello, $name!"), foreach, operator-accessible collections via the Gee library, and D-Bus client/server support generated directly from interface definitions

A small example showing classes, properties, signals, string templates, and type inference:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

public class Greeter : Object {
    public string name { get; set; default = "World"; }

    public signal void greeted (string message);

    public void greet () {
        var message = @"Hello, $name!";
        print ("%s\n", message);
        greeted (message);
    }
}

void main () {
    var greeter = new Greeter ();
    greeter.greeted.connect ((msg) => {
        print ("(signal received: %s)\n", msg);
    });
    greeter.greet ();
}

Compiled with valac greeter.vala, this produces a native executable. Behind the scenes, Greeter becomes a full GObject class — with a registered type, a real GObject property, and a real GObject signal — that any other GNOME-platform language could instantiate and connect to.

Genie

The Genie dialect deserves its own mention: it targets the same compiler and object model but swaps the curly-brace syntax for an indentation-based one reminiscent of Python, with def for methods and init as the entry point. Genie never approached Vala’s adoption, but it remains part of the compiler to this day and stands as one of the few production examples of two syntaxes sharing one language core.

Evolution

Vala’s development has tracked the GNOME platform it serves. After the self-hosting milestone in 2007, the 0.x series advanced steadily — 0.10 in September 2010, 0.20 in March 2013, 0.30 in September 2015 — adding language polish (chained relational expressions, improved async support, better generics) and, release after release, refreshed bindings for the ever-moving GNOME library stack.

From 0.40 (March 2018) onward the project adopted a cadence of long-term support series aligned with GNOME releases, with 0.48 (March 2020) and 0.56 (March 2022, released alongside GNOME 42) following. The 0.56 series brought support for declaring main as an async method and bindings for newer platform libraries such as libsoup 3 and the GTK4-era WebKit. It has remained the current stable series for an unusually long stretch — patch releases continued through 0.56.19 in March 2026 — reflecting a mature language whose changes are now mostly refinement, tooling, and bindings rather than redesign.

Around the compiler, the ecosystem grew practical amenities: first-class support in the Meson build system (the GNOME standard), a community Vala Language Server for IDE integration, the Gee collections library, and the online Vala Playground. Development moved with the rest of GNOME to GitLab (gitlab.gnome.org), where the project is maintained today.

Vala and Its Alternatives

Vala occupies a distinctive point in the design space, best seen by comparison:

For developers committed to the GNOME platform who want static typing and native compilation without C’s ceremony, Vala remains the most direct route.

Current Relevance

Vala is a niche language by industry measures, but an unusually productive niche. Its center of gravity is the elementary OS project, which has built an entire desktop — the Pantheon shell, the Granite framework, AppCenter, and dozens of first-party apps — in Vala, and whose developer documentation teaches Vala as the platform language. Within GNOME proper, applications including Shotwell, Geary, GNOME Boxes, and GNOME Calculator are Vala codebases, and many third-party GTK applications on Flathub are as well. Because Vala apps compile against GLib, they run wherever GLib does; the project has long documented use on Linux, other Unix-like systems, Windows, and macOS, though the desktop-Linux ecosystem is where the language genuinely lives.

Development is active but calm: the compiler sees regular maintenance releases, bindings track new GNOME platform libraries, and the documentation reportedly saw a significant refresh in 2026, the language’s twentieth-anniversary year. The honest caveats are the flip side of its focus — a small contributor base, competition from Rust and GJS for new GNOME code, and limited applicability outside the GObject world.

Why It Matters

Vala matters for two reasons. Practically, it lowered the barrier to native GNOME development for a generation of Linux desktop programmers: whole ecosystems of polished applications — most visibly elementary OS — exist because writing a GObject class stopped requiring a hundred lines of C. Conceptually, it is one of the most successful demonstrations of a transpiled systems language: proof that a language can offer modern, garbage-collection-free ergonomics by compiling onto an existing C object system rather than shipping a runtime. That idea — meet an established ABI where it lives, and let the compiler absorb the boilerplate — prefigured a design conversation that languages keep having. Twenty years on, Vala still does exactly what it promised in 2006: C# comfort, C footprint, GNOME fluency.