Genero 4GL

Genero 4GL — more formally the Genero Business Development Language (BDL) — is a commercial fourth-generation language and rapid application development (RAD) environment developed by Four Js Development Tools. It is the modern descendant of Informix 4GL, the procedural, SQL-integrated business-application language that Informix Software introduced in the mid-1980s. Genero compiles source that is, in the common case, syntactically and semantically compatible with Informix 4GL, while adding modern GUI, web, and mobile front ends, additional language features, and a full IDE.

Genero 4GL is not a general-purpose programming language. It is a domain-specific tool for building database-driven business applications — forms over a relational database, report writers, batch jobs — and almost every interesting program written in it is, at heart, a transaction against a SQL database wrapped in screens and validation rules.

History & Origins

The story of Genero 4GL begins with Informix 4GL, which Informix Software released in 1986 as a procedural language with first-class SQL embedded directly into the source. Programs combined procedural statements (LET, IF, FOR, WHILE, FUNCTION, …) with SQL statements (SELECT, INSERT, UPDATE, DELETE) and a screen system based on forms — text descriptions of character-mode screens with input fields tied to database columns. Through the late 1980s and 1990s, Informix 4GL became one of the standard languages for building back-office systems on Unix.

After Informix was acquired by IBM in 2001, the long-term roadmap for Informix 4GL was uncertain, and a community of customers and former Informix engineers had strong commercial reasons to preserve the language. Four Js Development Tools, founded in the late 1990s by engineers with deep Informix expertise, built a successor toolchain — the Genero product line — designed to compile existing Informix 4GL source and to give it a modern user interface.

The release of Genero in the early 2000s reframed Informix 4GL from a character-mode Unix tool into a multi-tier development environment. The same business logic could be deployed against a GUI client running on Windows, macOS, or Linux; against a web browser via the Genero Application Server; or, later, against a native mobile client on iOS and Android — without rewriting the procedural code.

Design Philosophy

Several principles distinguish Genero 4GL from general-purpose languages:

• Database-first. SQL is a first-class part of the language, not a library call. A statement like SELECT customer_name INTO l_name FROM customers WHERE id = p_id is a single 4GL statement; cursors, transactions, and result-set iteration are language constructs rather than API surface.
• Forms are declarative. The user interface for a typical Genero application is described in a separate form file, which binds input fields to database columns and validation rules. The procedural code drives the form using statements such as INPUT, DISPLAY, CONSTRUCT, and MENU.
• Backward compatibility with Informix 4GL. Genero is designed so that legacy Informix 4GL source can be moved into Genero with minimal modification; this is a deliberate commercial choice, because the customers Four Js serves typically have decades of existing code.
• One codebase, many front ends. The same compiled BDL program can be rendered through a character terminal (fglrun), a desktop GUI client, a web browser, or a mobile device, with the form definitions and runtime making the rendering decisions.
• Tooling matters. Genero Studio, the IDE built around the language, provides project management, a visual form designer, a debugger, and integration with version control — features that are not part of the language itself but are central to how customers actually develop in it.

Language Overview

A small Genero 4GL program reads recognizably like Informix 4GL:

MAIN
    DEFINE l_name CHAR(40)
    DATABASE stores

    SELECT customer_name
        INTO l_name
        FROM customers
        WHERE customer_id = 100

    DISPLAY "Customer: ", l_name CLIPPED
END MAIN

MAIN is the program entry point. DEFINE declares variables with explicit, statically known types. DATABASE selects the database to operate against. SELECT … INTO is a single statement that runs SQL and assigns the result to a 4GL variable. DISPLAY writes output through whatever front end is currently attached — a terminal, a GUI window, or a web client.

Forms

A form file describes a screen and its bindings:

LAYOUT
GRID
{
  Customer ID:   [f01           ]
  Customer Name: [f02                            ]
}
END
END

ATTRIBUTES
EDIT f01 = customers.customer_id;
EDIT f02 = customers.customer_name;
END

A 4GL program opens this form and drives input through INPUT and DISPLAY:

OPEN FORM f FROM "customer"
DISPLAY FORM f
INPUT BY NAME cust.* WITHOUT DEFAULTS

Cursors and transactions

Cursors are language-level objects:

DECLARE c CURSOR FOR
    SELECT customer_id, customer_name
        FROM customers
        WHERE active = "Y"

FOREACH c INTO l_id, l_name
    DISPLAY l_id, " ", l_name
END FOREACH

Transactions use BEGIN WORK, COMMIT WORK, and ROLLBACK WORK, mapping directly to SQL transaction semantics.

Architecture

A Genero 4GL program is compiled by fglcomp to a portable p-code, and executed by the runtime fglrun. The runtime communicates with a front-end process — character terminal, desktop GUI, web, or mobile — through a defined protocol; this separation is what lets the same compiled program drive multiple kinds of clients.

For web and mobile deployments, the Genero Application Server (GAS) acts as the intermediary between the runtime and HTTP clients, managing sessions and routing UI events. The desktop GUI client (often called the Genero Desktop Client, GDC) renders the same forms natively on Windows, macOS, and Linux. The mobile clients render the same forms through native iOS and Android wrappers.

This architecture is the practical embodiment of the language’s design philosophy: business logic is written once in BDL, and the form definitions plus the runtime are responsible for adapting it to whichever client is in use.

Platform Support

Genero is a commercial product distributed by Four Js, and its supported platforms are listed in the vendor’s official documentation. Historically, the runtime and tooling have targeted modern enterprise platforms — major Linux distributions and Windows on the server side, with desktop and mobile client builds — though specific platform versions vary by release. For any deployment, the authoritative source is Four Js’s release notes and platform support matrix for the version in question.

There is no official Docker Hub image for Genero 4GL; the product is licensed and distributed directly by Four Js to customers and partners.

Evolution

Across two decades of releases, the Genero 4GL language has evolved in several directions while preserving its Informix-4GL roots:

• Modern UI controls. Forms gained support for richer widgets — tabs, trees, grids, charts, image fields — well beyond the character-mode foundations of Informix 4GL.
• Web and mobile deployment. Successive releases of the Genero Application Server and the mobile clients allowed the same business logic to drive new classes of front ends without source changes.
• Web Services and REST. Genero added libraries and language constructs for publishing and consuming SOAP and REST services, enabling 4GL business logic to participate in modern service-oriented architectures.
• IDE integration. Genero Studio matured into a full development environment with project organization, source control integration, a visual form designer, and debugger.
• Cloud and containerization. More recent releases focus on packaging Genero applications for cloud deployment alongside other modern enterprise workloads.

Through these changes, Four Js has emphasized backward compatibility: existing Informix-4GL or earlier-Genero source is expected to continue compiling against newer releases with minimal change.

Current Relevance

Genero 4GL is a niche but commercially active language. Its relevance comes from the very large installed base of Informix 4GL applications written between the mid-1980s and the early 2000s, many of which still run critical business operations and would be expensive to rewrite. For those customers, Genero offers a path that preserves the substantial investment in domain logic while giving the application a modern user interface and deployment story.

Outside that installed base, Genero 4GL is not commonly chosen for greenfield development; developers building new database-driven business applications today typically reach for general-purpose languages and frameworks (Java/Spring, C#/.NET, Python/Django, Node.js, and so on) backed by ORMs rather than a procedural 4GL with embedded SQL. Genero’s niche, then, is exactly what Four Js built it to be: a long-term home for the Informix 4GL ecosystem.

Why It Matters

Genero 4GL is a useful example of how a commercial fourth-generation language can survive long after the original 4GL boom of the 1980s and 1990s ended. Most 4GLs of that era — Progress 4GL/OpenEdge, Magic, Uniface, dBase variants — followed similar trajectories: a strong commercial niche, deep ties to a particular database or vendor ecosystem, and a long tail of installed-base customers for whom rewrite costs exceed migration costs.

The language is also a reminder that backward compatibility is itself a feature with measurable economic value. Genero is interesting less for any single language innovation than for the fact that Informix 4GL source from the late 1980s can, with care, still be compiled, run, and deployed against a modern web or mobile front end through Four Js’s toolchain. For organizations whose business logic is encoded in decades-old 4GL programs, that property is the entire point.