View on
perlancar > IOD > IOD



Annotate this POD


View/Report Bugs
Module Version: 0.9.12   Source  


IOD - IOD (INI On Drugs) file format specification




This document describes version 0.9.12 of IOD (from Perl distribution IOD), released on 2017-08-17.


Specification is still rather in flux. Backwards compatibility is not guaranteed between 0.9.x releases.


IOD (short for INI On Drugs) is a configuration file format that is mostly backward-compatible with the popular INI format. It adds a few extensions to make configuration more powerful but still lets the configuration parseable by a regular INI parser (albeit the parse result might differ, sometimes significantly so, but it can be exactly the same for simple cases). An implementation can turn off some or all of these extensions to make the configuration closer to a regular INI file.

IOD is meant to be a general configuration format for applications.


The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119.


A general configuration file format needs to be simple for computers as well as users to read and write. Users mostly need to write configuration, while computers need to read but increasingly nowadays also write to configuration (for automation tasks). INI is chosen as the basis format for several reasons: popularity, simplicity, and ease of round-trip parsing. These features satisfy the aforementioned requirements.

Popularity: INI format is popular on Windows as well as Unix. This makes it easy for new users to get started with the configuration.

Simplicity: INI format is simple and very straightforward. It is essentially assignments of key names and values, with sections.

Round-trip parsing: Round-trip parsing means preserving everything in the file through the parsing process, including comments and formatting (indentations, whitespaces). Most serialization format do not have round-trip parsers: after a read and write process, original formatting and comments are lost. Round-trip parsing means that if one loads an INI file, modifies a key value, and saves it again, everything that is not modified will still be the same (including whitespaces and comments). If no keys are modified, the saved file will be identical with the original.

Round-trip parsing is desirable in a configuration because oftentimes valuable information is contained in the formatting/indentation (grouping of keys) as well as comments (user explaining why she sets a key to a certain value, dates, other notes). Software modifying a configuration should not destroy all these.

INI vs ...

YAML. Although YAML looks nice and has many features, it lacks round-trip parsers and has complex rules that can trip beginners or non-programmers, e.g. significant indentation, significant whitespace in some places (for example after colon in mapping), etc. YAML 1.2 (2009) improves on some parts of this aspect but at the time of this writing (2017) many implementations are still stuck at version 1.0/1.1 of the specification.

JSON. Although JSON is popular and simple, most parsers are not round-trip. And even if the parser were round-trip, the format itself lacks some things that are desirable in a configuration, e.g. comments. (Note: The documentation for JSON Perl module mentions the phrase "round-trip", but it uses the phrase to mean integrity of values, not preserving comments/whitespaces.)

Note that IOD uses JSON in places.

Apache-webserver-style lacks round-trip parsers.

XML. Most parsers are not round-trip. The format is not convenient for humans to read and write.

Why not plain INI?

First, the INI format is ill-defined. There is no single standard, thus various implementations behave differently and there are various variants of the format. This specification intends to describe the IOD format more precisely.

Second, INI lacks some features that I like/need, like: variable substitution/expression, inclusion of other files, and merging between sections. Most of these features make writing configuration less repetitive.


A configuration is a text file containing a sequence of lines. Encoding MUST be UTF-8. Each line is either a blank line, a comment line, a key line, a section line, or a directive line. Parsing is done line-by-line and in a single pass.

Blank line

A blank line is a line containing zero or more whitespaces only. It is ignored.

Comment line

A comment line begins with ; or # as it's first nonblank character (note that some INI parsers do not allow indented comment; some only recognizes ; as the comment starter character). The use of ; is preferred.

 <ws>* ";"|"#" <COMMENT>


 ; this is a comment
 # this is also a comment

Key line

This line sets key name and value:

 <ws>* <NAME> <ws>* "=" <ws>* <VALUE> [<ws>* ";"|"#" <COMMENT>]

NAME can contain anything but newline or the equal sign (=). VALUE is either: 1) zero or more non-newline characters with optional encoding prefix, or a JSON string with double quotes, or a JSON array started with "[", or a JSON hash (object) started with "{". Encoding prefix is ! followed by encoding name, followed by at least one space. Known encodings are: j or json, h or hex, base64, e or expr, path, paths, and none. See "Encoding" for more details about encoding.


 foo bar=baz
 foo = bar baz ; whitespace around the equal sign will be removed
 foo=!base64 YmFyIGJheg== ; bar baz
 foo=!hex 00ff00 ; 3-byte binary data
 foo="a JSON string\nwith newline" ; comment
 foo=!j "a JSON string\nwith newline"
 foo=["a json array", "because it's started", "with ["]
 foo=!json [1,2,3]
 foo={"a json hash":1, "because it's started":2, "with {":3}
 foo=!json {"a":1,"b":2}
 foo=~/logs              ; will become e.g. /home/ujang/logs
 foo=~budi/Pictures      ; will become e.g. /home/budi/Pictures
 foo="~/logs"            ; a JSON-encoded string with value "~/logs"
 foo=!none [             ; a single open brace character

Specifying several keys with the same name will create an array value. Example:


will result in (in JSON):

 {"a": [1,2]}

To specify expression, use the !e or !expr encoding. Example:

 z=!e $x+$y ; 8

See "Expression" for more details on expressions.

Normally a key line should occur below section line, so that key belongs to the section. But a key line is also allowed before section line, in which it will belong to section called GLOBAL (configurable via the parser's default_section attribute).

Section line

A section line introduces a section:

 <ws>* "[" <ws>* <NAME> <ws>* "]" [<ws>* ";"|"#" <COMMENT>]

NAME is one or more non-newline characters that are not ].


 [Section Name]
 []  ; a comment

Non-contiguous sections are allowed, they will be assumed to be set/add keys as if the section were written contiguously, e.g.:




will result in sect1 containing a as [1, 2] and b as 3. However, note:


 ;!merge sect1



sect2 will contain {"a":1, "d":4} since at the point of parsing sect2, sect1 only contains {"a":1}. However, sect3 will contain {"a":1, "b":2, "c":3} since at the point of parsing sect3, sect1 already becomes {"a":1, "b":2}.

Directive line

A directive line is an unindented comment line using the ; comment character. The comment starts with an exclamation mark (!), a directive name (a word matching regular expression /\w+/, and zero or more arguments separated by whitespaces. Since it is a common error to write ! instead of :!, the parser can have a configuration to allow ; to become optional (though note that this will result in an invalid INI file).

 (";")? <ws>* "!" <ws>* <NAME> <ws>+ [ARGUMENTS]

An invalid directive will cause parsing to fail.

Examples of valid directives:

 ;!include somefile.iod

This directive is invalid because it uses # instead of ;:

 #!include blah

This directive is invalid because it is indented:

 ;start of line
   ;!include foo

This directive is invalid because of invalid directive name:

 ;!include! somefile.iod

This directive is invalid because it is unknown:


This directive is invalid because of unbalanced quotes:

 ;!include "somefile.ini

This directive is invalid because of missing required argument:


Argument. An argument is a sequence of one or more non-whitespace, non-newline characters, or a JSON string. Examples:

 "argument as JSON string"

Below is the list of known directives (<foo> signifies required arguments, [foo] signifies optional arguments):

!include <PATH>

Include another file, as if the content of the included file is the next lines in the current file. An included file might contain another !include directive. If PATH is not absolute, it is assumed to be relative to the current file. A circular include will cause the parser to die with an error. Example:

File dir1/a.ini:

 ;!include ../dir2/b.ini
 ;!include ../dir2/b3.ini

File dir2/b.ini:

 ;!include b2.ini

File dir2/b2.ini:

 c = 3
 ;!include b3.ini

File dir2/b3.ini:


When dir1/a.ini is parsed, the result will be (in JSON):

   "sectionA": {
     "sub1": {
       "a": 1,
       "b": 2,
       "c": [3, 4]
   "sectionB": {
     "c": 1

!merge [SECTION] ...

Specify that from now on (meaning, from the current section, not the next session), section will merge the specified section(s), in order. The specified sections to be merged must be predeclared. To stop merging, specify the directive without any argument.




 !merge defaults s1



will result in (in pseudo-JSON):

   "defaults": {"d":4},
   "s1"      : {"a":1,  "b":2},
   "s2"      : {"a":10, "b":2, "c":30, "d":4},
   "s3"      : {"a":1,  "b":2,         "d":4},
   "s4"      : {"a":20}, // no more merging

!noop ...

Directive that does nothing and will be ignored. For testing.



Currently expression is not fully defined and left to the implementation. The goal is to have a simple syntax that allows variable substitution using the $ syntax and some arithmetics/string operations.

Unsupported features

Some INI implementations support other features, and listed below are those unsupported by IOD, usually because the features are not popular or too incompatible with regular INI syntax:


Implementation can provide options to turn off some features. In general, to make an IOD configuration file not context-dependent, a turned off feature should cause parsing to fail to notify users that certain features are not available. A turned off feature should not just silently makes parsing behave differently. For example, if file inclusion is turned off, this line:

 !include somefile.ini

should make parsing fail instead of continuing (without including the file).

An exception is when an implementation provides explicit option to ignore certain features. For example, an implementation might provide an option to forbid expressions, or turn off expression parsing and parse it as literal.

Below are guidelines on what parsing options an implementation can provide:


Summary of differencess between INI and IOD?

IOD has more features:

Why are blank lines allowed in IOD?

They aid reading by human. This is in line with the goal of making it easy for human to read. Note that many INI parsers also allow blank lines.

What are the downsides of IOD format?


Please visit the project's homepage at


Source repository is at


Please report any bugs or feature requests on the bugtracker website

When submitting a bug or request, please include a test-file or a patch to an existing test-file that illustrates the bug or desired feature.


INI format specification,

TOML, a minimal configuration file format that looks like INI, but diverges more, This is similar in goal and principles to IOD, with a few differences: more types and literals (boolean, datetime), array and strings can span lines, section can be nested using indentation. There are already implementations in multiple languages, and a few of them are already round-tripping.


perlancar <>


This software is copyright (c) 2017, 2016, 2015, 2014, 2012 by

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.

syntax highlighting: