Which Languages Influenced Lua Design?
Lua was created in 1993 at the Pontifical Catholic University of Rio de Janeiro (PUC-Rio) to solve software customization and data configuration challenges. Rather than emerging from traditional general-purpose languages, Lua’s foundational architecture was directly shaped by two earlier, in-house data description languages: SOL (Simple Object Language) and DEL (Data Entry Language). Understanding these predecessors explains why Lua emphasizes data description, lightweight syntax, and extensible associative tables as core design principles.
The Industrial Needs at Telegroas and Petrobras
Between 1992 and 1993, the Computer Graphics Technology Group (Tecgraf) at PUC-Rio developed software tools for Brazilian engineering clients, notably the state oil company Petrobras. The engineers required flexible graphical user interfaces and customized data entry systems. At the time, Brazil’s restrictive trade policies made importing commercial software prohibitively expensive, compelling Tecgraf to design customized tools from scratch.
The development team, led by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, and Waldemar Celes, discovered that hardcoding configuration parameters in compiled C code slowed down development cycles. They needed declarative, user-friendly ways for non-programmers to define engineering data and interface layouts.
DEL: The Data Entry Language
The first language developed to meet this demand was DEL (Data Entry Language). DEL was a declarative language designed specifically for describing data entry forms and validating user input for engineering simulations.
DEL allowed users to specify entity attributes, form controls, and validation rules declaratively. However, it had noticeable limitations:
- It lacked procedural control flow, meaning conditional logic or complex validation required external C routines.
- It was tightly coupled to specific engineering applications, making it difficult to adapt for broader configuration needs.
- The syntax became cumbersome as the data models grew in complexity.
As Tecgraf began developing larger graphical applications, the team recognized that DEL was not versatile enough to serve as a universal configuration tool.
SOL: The Simple Object Language
To overcome the rigid nature of DEL, the team developed SOL (Simple Object Language) around 1992. SOL was heavily inspired by the syntax of declarative data formats like BibTeX and the procedural language Modula.
SOL introduced several structural concepts that later formed the identity of Lua:
- Object Constructors: SOL allowed nested, record-like data definitions using clear declarative syntax, which removed the need for custom parsers for every new data type.
- Type Definition Support: Users could define structured records and lists cleanly, separating data declaration from business logic.
- Lightweight Footprint: The parser was small, fast, and easily embeddable into host C programs.
Despite these improvements, SOL revealed another critical constraint. While it excelled at defining static configurations and data hierarchies, it lacked procedural programming capabilities such as loops, conditionals, and user-defined functions. Whenever an application required dynamic behavior, developers had to write custom glue code in C.
Unifying Declarative and Procedural Features into Lua
Faced with the dilemma of either adding control structures to SOL or grafting data description capabilities onto an existing procedural language like Tcl, the designers chose to create a unified solution.
In 1993, they synthesized the strengths of DEL and SOL into a single language named Lua (meaning "Moon" in Portuguese, serving as a play on SOL, which means "Sun"). Lua incorporated:
- Declarative constructors from SOL: The table syntax in Lua directly evolved from SOL’s object definition format, allowing data structures to be represented naturally without separate serialization formats.
- Validation and custom behavior from DEL: Procedural features, first-class functions, and meta-mechanisms were introduced so that data validation and event handling could run directly within the script rather than requiring recompilation of C modules.
- A unified data construct: Instead of separate representations for records, arrays, and objects, Lua introduced the associative table, a single versatile primitive capable of handling all data storage paradigms.
By fusing the declarative clarity of SOL and DEL with a small, efficient procedural runtime, Lua solved the configuration and scripting challenges of its creators and evolved into an embeddable language widely adopted across software engineering and game development.