Configuration Languages
Configuration languages are the “small, readable languages” software uses to describe settings and behavior, not to run full programs.
Configuration languages are a family of domain-specific languages used to define software, system, or infrastructure settings in a form that is meant to be human-readable and machine-parseable.
[1]
[2]
[3]
They matter because they sit between rigid data formats and general-purpose programming languages: they are expressive enough to describe structure, values, and sometimes limited logic, but constrained enough to keep configuration deterministic and safer to consume.
[4]
[3]
Defining and Describing Configuration Languages
Configuration languages are typically invoked when developers need to specify application preferences, deployment settings, infrastructure, build metadata, or policy-like parameters in text files.
[1]
[2]
[3]
In that usage, the term emphasizes a language whose primary job is to configure another system, rather than to compute arbitrary results.
[4]
[3]
A concise way to frame the idea is that these languages are “designed to define and manage the settings, parameters, and operational behavior” of software or infrastructure.
[1]
Uses in Context
- They are used as a DSL niche for cases where “enough expressiveness to avoid repetition” is needed, but “no infinite loops, no side effects, deterministic output” are still desired. [4]
History of Use
Origins
Configuration languages emerged from the broader tradition of domain-specific languages, especially as software systems needed text-based ways to describe settings apart from source code.
[1]
[4]
One early practical lineage is the INI-style configuration file, which a later review describes as emerging in the early 1980s with MS-DOS and early Windows as a flat, human-editable key-value format with sections.
[9]
Another important origin story is Lua: a historical account describes Lua as being born in 1993 at PUC-Rio’s Tecgraf laboratory to replace earlier configuration prototypes, and explicitly says, “Lua was not born as a scripting language. It was born as a configuration language.”
[10]
A second origin stream comes from the formalization of modern configuration-focused DSLs. HCL is described as a toolkit for “creating structured configuration languages” that are “human- and machine-friendly,” and its purpose is contrasted with general data serialization formats like JSON and YAML.
[11]
[6]
TOML was introduced by Tom Preston-Werner in 2013 as a configuration file format, with sources emphasizing that it was designed to be obvious, minimal, and unambiguous for humans and machines alike.
[7]
[8]
[12]
Evolution
- Early 1980s: INI-style files established the baseline pattern for simple configuration: sections, key-value pairs, comments, and direct human editing. [9]
- 1993: Lua was created at PUC-Rio’s Tecgraf laboratory as a configuration-oriented language for practical software deployment needs, later expanding beyond configuration into a general scripting language. [10]
Best Real-World Examples
Case Studies
Lua is a strong case study because it shows a configuration language evolving into a broader programming language without losing its original design intuition.
[10]
In 1993, engineers at PUC-Rio’s Tecgraf lab were dealing with configuration files for software used across diverse machines, and they combined earlier prototypes into Lua to handle that need.
[10]
The later scripting ecosystem around Lua demonstrates what happens when a configuration language becomes powerful enough to absorb application logic, not just settings.
[10]
That history shows the conceptual border between “configuration language” and “programming language” is real but porous.
[10]
TOML illustrates the opposite move: it narrowed the problem back down to a cleaner, more disciplined configuration format.
[7]
[8]
[12]
Tom Preston-Werner introduced it in 2013 as a human-readable alternative that aimed for obvious syntax, explicit types, and fewer semantic surprises than YAML-like formats.
[7]
[8]
[12]
The case shows that configuration languages often arise as reactions to complexity in earlier formats, and that one of their main design goals is reducing ambiguity for people who edit files by hand.
[9]
[8]
HCL shows how configuration languages can be specialized for infrastructure tooling rather than general software settings.
[11]
[2]
[5]
HashiCorp describes HCL as a toolkit for building structured configuration languages, and commentary around it emphasizes blocks, attributes, and predictable structure for declarative infrastructure definitions.
[11]
[6]
Terraform then popularized HCL in the infrastructure-as-code workflow, making configuration language design a central part of cloud operations practice.
[2]
[5]
This case shows that the most successful configuration languages are often shaped by the specific domain they serve, not by a desire to replace programming languages wholesale.
[4]
[5]
Images
Source: https://itnext.io/can-configuration-languages-dsls-solve-configuration-complexity-eee8f124e13a