Genero BDL

Genero BDL — the Genero Business Development Language — is a commercial, database-centric procedural fourth-generation language (4GL) developed by Four Js Development Tools. It is the language at the heart of the Genero product line and the direct descendant of Informix 4GL, the SQL-integrated business-application language introduced by Informix Software in the mid-1980s. Genero BDL 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 BDL is not a general-purpose programming language. It is a domain-specific tool for building database-driven business applications — forms over a relational database, batch jobs, reports — and almost every interesting program written in it is, at its core, a transaction against a SQL database wrapped in screens, validation, and workflow rules.

History & Origins

Genero BDL’s lineage 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 bound 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 IBM acquired Informix’s database business in 2001, the long-term roadmap for Informix 4GL became uncertain. A community of customers and former Informix engineers had strong commercial reasons to preserve the language, and Four Js Development Tools — reportedly active in this space since the late 1990s — set out to build a successor toolchain. The result, released in the early 2000s under the Genero brand, included a new compiler (fglcomp) and runtime (fglrun) for what was formally named the Genero Business Development Language, together with a graphical front end driven by an XML-based form language.

From the start, the design goal of Genero BDL was twofold: preserve the Informix 4GL source compatibility that customers depended on, and reframe the language as a modern multi-tier development environment.

Design Philosophy

Several principles distinguish Genero BDL 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 BDL 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 that binds input fields to database columns and validation rules. Procedural code drives the form using statements such as INPUT, DISPLAY, CONSTRUCT, and MENU.
• Backward compatibility with Informix 4GL. Genero BDL is designed so that legacy Informix 4GL source can be moved into Genero with minimal modification — 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, a desktop GUI, a web browser, or a mobile device, with form definitions and the 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 source-control integration — features that are not part of the language itself but are central to how customers actually develop in BDL.

Language Overview

A small Genero BDL 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 runs SQL and assigns the result to a BDL variable in a single statement. 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 BDL 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.

Reports

BDL retains the Informix 4GL REPORT construct — a declarative report definition with control breaks, headers, and trailers — that is fed by procedural code via OUTPUT TO REPORT. This is a typical example of a 4GL construct that has no direct equivalent in a general-purpose language without substantial library support.

Architecture

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

For web and mobile deployments, the Genero Application Server acts as the intermediary between the runtime and HTTP clients, managing sessions and routing UI events. The desktop GUI client renders the same forms natively, and 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 BDL 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 BDL; the product is licensed and distributed directly by Four Js to customers and partners.

Evolution

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

• Richer UI controls. Forms gained support for tabs, trees, grids, charts, image fields, and other widgets well beyond the character-mode vocabulary 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. BDL added libraries and language constructs for publishing and consuming SOAP and later REST services, letting 4GL business logic participate in 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 BDL releases with minimal change.

Relationship to Genero 4GL

In casual usage, “Genero 4GL” and “Genero BDL” are used interchangeably, and Four Js’s documentation refers to the language with both names. BDL is the more formal designation — the Business Development Language is the named programming language; Genero 4GL is the broader category label that emphasizes its lineage from Informix 4GL. Source code, file extensions, and the compiler and runtime binaries are the same regardless of which label is used.

Current Relevance

Genero BDL 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 BDL 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 BDL is not commonly chosen for greenfield development; teams building new database-driven business applications today typically reach for general-purpose languages and frameworks — Java/Spring, C#/.NET, Python/Django, Node.js — backed by ORMs rather than a procedural 4GL with embedded SQL. BDL’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 BDL 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. BDL 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.