Gambas

Gambas is a free software object-oriented dialect of BASIC together with a complete integrated development environment, designed primarily for building graphical desktop applications on Linux. Created by French developer Benoît Minisini and distributed under the GNU General Public License, Gambas occupies a distinctive niche: it provides much of the rapid application development experience that Visual Basic offered on Windows in the 1990s, but on free software platforms and with a modern object-oriented language design. The name is a recursive acronym — Gambas Almost Means BASic — and is also the Spanish word for “shrimps,” reflected in the project’s prawn mascot.

History & Origins

Motivation

Benoît Minisini grew up programming in BASIC and wanted to bring the productivity of Visual Basic-style graphical development to Linux without compromising on free software principles. In the late 1990s, GUI development on Linux required mastering C with Motif, Xt, or the then-young GTK+ and Qt toolkits — a substantially higher barrier than dragging controls onto a form in Visual Basic. Minisini began work on Gambas in roughly 1999 with the explicit goal of offering a BASIC-derived language, a visual form designer, and a runtime library that would make Linux a viable platform for the kind of small desktop applications that dominated the Windows shareware and in-house tooling worlds.

From 0.x to 1.0

Gambas spent several years in 0.x development before reaching its first stable release. Version 1.0 was released on January 4, 2005, with an IDE composed of several floating windows for the form designer, code editor, and project tools — a layout reminiscent of older versions of the GIMP. The 1.x series established the language’s core syntax, the component-based runtime, and the dual GUI back-end design that would let the same Gambas program target either Qt or GTK+.

Gambas 2 and 3

Version 2.0, released on January 2, 2008, introduced a unified single-window IDE and refined the language and component system. Version 3.0, released on December 31, 2011, brought another generation of IDE improvements, new language features, and a broader standard component set. The 3.x line has now been under continuous development for well over a decade, reaching version 3.21.5 in March 2026 and remaining the actively maintained major series. Subsequent 3.x releases added JIT compilation through LLVM, an integrated profiler, Wayland support, and parity between the Qt 5 and GTK 3 components.

Design Philosophy

Gambas is built around several deliberate design choices:

• BASIC syntax with modern semantics. The surface syntax is recognizably BASIC — Dim, If ... Then ... End If, For ... Next, Print — but the underlying language is fully object-oriented, with classes, inheritance, interfaces, properties, events, and exceptions.
• Component-based runtime. Gambas applications are assembled from components that are loaded on demand. There is a separate component for Qt-based GUIs, another for GTK+, and many more for databases, networking, OpenGL, image processing, and so on. A program only pays the memory cost for the components it actually uses.
• Two GUI back-ends, one API. A well-written Gambas program can be retargeted between Qt and GTK+ by changing a single component reference, because both back-ends present nearly the same gb.qt / gb.gtk API surface.
• Visual form design. The IDE includes a form designer with property and event editors that closely resemble the Visual Basic 6 workflow, lowering the barrier for developers coming from that environment.
• Self-hosting tooling. The Gambas IDE itself is written in Gambas, which acts as both a demonstration of the language’s capabilities and a permanent test of its breadth.

The project documentation summarizes the goal as making it easy to develop graphical applications on Linux — not a clone of Visual Basic, but a language that takes the parts of the VB experience that worked well and reimplements them on a free software foundation.

Key Language Features

Object Orientation

Gambas is genuinely object-oriented: every Gambas file defines either a class or a module, and most runtime entities — controls, files, database connections, even primitives like strings — are objects with properties and methods.

' A simple class
Public Sub Form_Open()
    Dim hShape As New Circle(50, 50, 25)
    hShape.Draw()
End Sub

Class Circle
    Public X As Integer
    Public Y As Integer
    Public Radius As Integer

    Public Sub _new(aX As Integer, aY As Integer, aRadius As Integer)
        X = aX
        Y = aY
        Radius = aRadius
    End

    Public Sub Draw()
        Print "Circle at "; X; ","; Y; " r="; Radius
    End
End Class

Classes support inheritance with Inherits, virtual methods, interfaces (Implements), and a Me reference equivalent to this in other object-oriented languages.

Data Types

Gambas provides a fixed set of primitive types and a rich object class library:

Strings are UTF-8 by default, which simplifies internationalization compared with VB6-era BASIC dialects.

Events and Properties

Gambas inherits VB’s event-driven control model. UI controls fire events that are handled by Public Sub routines named with a fixed Object_Event convention:

Public Sub Button1_Click()
    Message.Info("Hello from Gambas!")
End

Public Sub TextBox1_KeyPress()
    If Key.Code = Key.Enter Then
        Button1_Click()
    Endif
End

Properties can be declared with explicit getters and setters or using the shorthand Property syntax, allowing classes to expose state with the same uniform syntax as built-in controls.

Database Support

The gb.db component family provides a uniform API across SQLite, MySQL/MariaDB, PostgreSQL, ODBC, and Firebird. Result sets are accessed as enumerable collections of records:

Dim hConn As New Connection
hConn.Type = "sqlite"
hConn.Name = "data.db"
hConn.Open()

Dim hResult As Result
hResult = hConn.Exec("SELECT name, score FROM players ORDER BY score DESC")
For Each hResult
    Print hResult!name; ": "; hResult!score
Next

JIT Compilation

Since the Gambas 3.2 timeframe, the project has supported just-in-time compilation of hot bytecode paths through an LLVM-based component. The default execution model remains an interpreter that runs the compact Gambas bytecode generated by the compiler, but performance-sensitive numeric routines can benefit from JIT acceleration. Specific speed-ups vary substantially depending on workload, and the project documentation is careful not to promise particular performance ratios — JIT is presented as a tool to be benchmarked per use case rather than a guaranteed win.

Platform Support

According to the official documentation, Gambas runs natively on Linux and FreeBSD. Experimental or community-maintained ports exist for other Unix-like systems and Haiku, and Windows usage is generally documented as proceeding through Cygwin or the Windows Subsystem for Linux rather than as a first-class native port. Verify the current platform matrix on the official Gambas wiki before targeting anything other than mainstream Linux distributions.

Gambas is packaged in the standard repositories of major Linux distributions including Debian, Ubuntu, Fedora, openSUSE, Arch Linux, and Mageia, which is typically the easiest way to install it. The runtime depends on the chosen GUI back-end (Qt or GTK+) along with any component-specific libraries (database drivers, OpenGL, etc.).

Architecture

A Gambas project compiles to a compact bytecode executable that contains:

1. Class files — one binary class per .class source file, containing bytecode and metadata.
2. Component references — declarations of which Gambas components (e.g. gb.qt5, gb.db.sqlite3) the program needs at runtime.
3. Resources — embedded images, translations, and data files.

When the executable is launched, the Gambas interpreter (gbx3) loads the required components dynamically and begins executing the program’s startup class. This architecture keeps deployed applications small — a typical Gambas program is often a few hundred kilobytes — and allows the same binary to run unchanged on any system with a compatible Gambas runtime installed.

Tooling and IDE

The Gambas IDE is one of the project’s most distinctive features. It provides:

• A form designer with toolbox, property editor, and event editor in the Visual Basic 6 idiom.
• A code editor with syntax highlighting, code completion, and inline help.
• An integrated debugger with breakpoints, watches, and step execution.
• A profiler (added in the 3.x series) for measuring per-line execution counts and timings.
• A package builder that can produce .deb, .rpm, Pacman, and source packages directly from a project.
• A translation manager for managing .po files used to localize an application.
• A farm client that connects to the Gambas Software Farm, where community members publish open-source Gambas applications.

Because the IDE is itself written in Gambas, every feature added to the language is immediately exercised by the IDE on the next build — a feedback loop that has tended to keep the language honest.

Community and Ecosystem

Gambas has a small but persistent international community concentrated in Europe and Latin America. The project’s primary resources include:

• The official wiki at gambaswiki.org, which hosts documentation, tutorials, and reference material.
• A mailing list and forum, where Benoît Minisini and other long-time contributors are active participants.
• The Gambas Software Farm, a curated repository of community-contributed Gambas applications that can be browsed and installed directly from the IDE.
• A long-running French-language community presence, reflecting the project’s origins.

Compared with mainstream languages, Gambas’s ecosystem is modest, but it covers the typical needs of desktop development — GUI, database access, networking, image processing, OpenGL, scripting — through its component library rather than through third-party packages.

Current Relevance

Gambas in 2026 occupies a genuine niche rather than a mass market. The dominant approaches to Linux desktop development today are C/C++ with Qt, Python with PyQt or GTK bindings, Vala, Electron, and various web-stack solutions. Yet Gambas retains an audience of developers who value:

• A Visual Basic-like development experience that other Linux tooling does not replicate as faithfully.
• A single-vendor, integrated stack — language, IDE, GUI library, and database access — that does not require assembling a toolchain from independent projects.
• BASIC syntax familiarity, particularly among developers and educators with backgrounds in QuickBASIC, Visual Basic, or QBasic.
• Free software guarantees under the GPL, in contrast to the proprietary Visual Basic lineage.

The continued release cadence — multiple 3.x point releases per year over more than a decade — suggests that the project is sustainable at its current scale, even if it never reaches the popularity of larger languages.

Why It Matters

Gambas matters as a case study in what happens when a single, dedicated maintainer applies decades of effort to a tool that fills a real but narrow gap. Visual Basic 6 was retired by Microsoft in the mid-2000s, and no successor language — VB.NET included — quite replicated its low-friction approach to building small desktop applications. On Linux, the equivalent gap is even wider, because the dominant GUI toolkits assume substantial C/C++ or Python proficiency. Gambas’s existence demonstrates that a thoughtful BASIC dialect, paired with a serious IDE and a rigorously designed object model, can deliver real productivity to non-specialist developers without sacrificing the open-source ethos of its host platform.

For the history of programming languages, Gambas is a useful reminder that BASIC did not end with the home computer era. The line of descent from Dartmouth BASIC through QuickBASIC, Visual Basic, and now Gambas spans more than sixty years, and it continues to power working software on modern operating systems — a testament to the durability of an idea that prioritizes accessibility above all else.