ERBSLAND CONFIG LANGUAGE

[main]
host: "host01.example.com"
port: 1234

This is a simple configuration file showing the basic structure: a section called main with two settings for host and port.

Here’s another example that uses a more descriptive style:

# Comments are allowed almost everywhere.
---[ Main Settings ] ------ # A section 
App Name : "ELCL Demo"      # Name-Value Pair with Text Value
Version  : 1                # Name-Value Pair with Integer Value

This version includes comments and formatting that make the file more readable. It shows how ELCL supports clear documentation directly within configuration files.

Key Features

Straightforward Syntax
ELCL uses a clear and intuitive syntax with built-in type safety, which helps avoid common mistakes during configuration.

Reliable and Secure
Strict parsing rules support robust and secure configurations, making ELCL suitable for both simple and safety-critical use cases.

Well-Documented
From a detailed specification to user and developer guides, ELCL is thoroughly documented to help you understand and adopt it with ease.

Reference Implementations
Ready-to-use implementations in Python and C++ make it easier to integrate ELCL or build your own parser by example.

Test Suite for Compliance
A complete compliance test suite helps verify that implementations follow the ELCL standard, supporting consistent and dependable behavior.

Flexible Implementation Options
Whether you’re building for embedded systems or full-featured environments, ELCL scales with you—offering support for both lightweight and advanced parser designs.

Built-in Metadata Support
Metadata lines allow you to declare language versions and feature requirements, helping maintain compatibility across versions and future changes.

[Type Safe Configurations]
Floating Point Value : -1.9e8
Integer Decimal      : 123'456
Integer Hex          : 0x4000'0006
Integer Binary       : 0b00110011'00110011
Byte Counts          : 100 mb
Boolean              : true
Text                 : "Hello! 😄"
Code                 : `var a = "\n";`
Regular Expressions  : /^\w+$/
Date                 : 2025-12-01
Time                 : 12:27:08.123
Date and Time        : 2025-01-02 08:20:14+02:00
Byte Data            : <ab cd 01 02>

ELCL supports a wide range of value types — and for good reason. When configuration formats are too limited, we often end up storing everything as plain text. That not only complicates validation in the application, but also makes it harder to keep things consistent across different tools and environments.

By supporting proper types directly, ELCL makes configurations clearer and safer, while also simplifying the work of writing reliable parsers.

[server.processor]
[.features]
text_decoder : disabled
filter       : enabled
[.filter]
match        : /^FAIL/

As applications grow in complexity, their configuration needs tend to grow with them. That’s why ELCL supports flexible configuration structures—while still keeping the syntax simple and easy to read.

In the example above, the configuration starts with a fully named section and then adds two relative sections that build on that base. This creates a clear hierarchy, which is translated into the following value tree:

● (root)                     Document
└── [server]                 IntermediateSection 
    └── [processor]              SectionWithNames 
        ├── [features]               SectionWithNames 
        │   ├── filter                   Boolean 
        │   └── text_decoder             Boolean 
        └── [filter]                 SectionWithNames 
            └── match                    RegEx 

There’s Even More to Discover

ELCL offers many thoughtful features that go beyond the basics. Here’s a short list of highlights that might be especially useful, depending on your needs:

• @version helps with forward-compatible language development.
• @feature checks allow safe use of optional features based on implementation tiers.
• @signature supports cryptographic signing of configuration documents.
• @include lets you split configurations across multiple files.
• Both : and = are accepted as value separators.
• Supports one- and two-dimensional value lists.
• All names are case-insensitive by default — for example, Example Value is treated as example_value.
• Strict indentation rules for multi-line text help avoid ambiguity.
• Supports text-based names like "text" = 123 or [main.keys."text"] for dictionary-like structures.
• Allows visually structured section headers, such as -----[ name ]-----.
• Section lists let you define multiple sections under a shared name.
• (…)

Implementations

There are currently two official implementations of the Erbsland Configuration Language in active development:

• Erbsland Config for C++
• Erbsland Config for Python

There is also a list of implementations in the documentation.

Documentation and License

The full language specification for the Erbsland Configuration Language is published under the Apache License, Version 2.0. This license gives you the freedom to use, modify, and include the specification in both open-source and commercial projects.