YINI — Modern Configuration Without the Noise

YINI is a modern, human-friendly configuration format that bridges the simplicity of INI with the expressive features of YAML. It offers a clear, structured syntax with nested sections, rich data types, and both line and block comments — making config files easy to read, write, and maintain.

Get Started Quick tutorial

💡 Why YINI?

INI is simple and familiar, but it lacks structure for complex data.
YAML offers rich features, though it can be harder to read and lint consistently.
JSON is precise and universal, but less concise for human editing.
YINI aims to balance these aspects — keeping readability while providing clear nesting and predictable behavior.

Familiar — learn it in minutes if you know INI
Structured — sections, arrays, objects, clear nesting
Predictable — fewer gotchas; strict/lenient modes available

⚡ TL;DR — Quick Start

Try YINI in three quick steps:

1) Create a file
Save the two lines below as config.yini:
```
^ App
name = 'Hello'
```
⚠️ Make sure you save the file with the .yini extension (not .txt).
2) Run this in your terminal

From the same folder where you saved the file:
```
npx yini-cli parse config.yini
```
3) See the result

This prints the following JavaScript object:
```
{ App: { name: 'Hello' } }
```
Bonus: Pretty-printed JSON output

Use the --pretty flag, and run this line:
```
npx yini-cli parse config.yini --pretty
```
Which gives the following (JSON):
```
{
    "App": {
        "name": "Hello"
    }
}
```

📝 Example

YINI code:

^ App
  name = "My App"
  version = "1.2.3"
  pageSize = 25
  darkTheme = off

Parsed output (JS):

{
    "App": {
        "name": "My App",
        "version": "1.2.3",
        "pageSize": 25,
        "darkTheme": false
    }
}

🧩 Key Features

Readable & familiar
Plain-text config files built from simple key–value pairs (e.g. key = value) line by line, taking a lot of inspiration from classic INI.
Structured hierarchy
Uses section markers like ^ for nesting sections to create a clear hierarchy, without indentation sensitivity. For example: ^ App, ^^ Server, and ^^^ Logging.
Rich data types
Supports more than just strings: integers, floating-point numbers, booleans, arrays, and objects — including nested inline structures — making it more robust and versatile for different kinds of data.
Comments
Allows both inline comments (using // or #) and block comments (using /* ... */), which improves readability and makes it easy to explain settings directly in the file.
Reduced syntax noise
Aims for a cleaner look compared to many other formats by reducing “noise” like excessive brackets and quotes, and by avoiding long dotted key chains (such as server.database.advanced.timeout).
Formally specified
A formal, versioned specification and ANTLR grammar help keep implementations aligned and predictable.
Free & open source
YINI is free, open-source software that you can use and study.

ℹ️ About

YINI is a new configuration format, formalized in 2025. It's a structured configuration format designed for clarity, easy nesting, and strict validation.

The format's syntax and behavior are defined in the YINI Specification, currently at Version 1.0 — Candidate Release.

YINI was created and is maintained by Marko K. Seppänen as an open-source project under the YINI-lang organization.

The specification, tooling, and ecosystem are actively evolving toward the first stable release.

🛠️ Contribute & Get Involved

YINI is open-source and evolving. You can help by trying it, reporting issues, contributing code, or just ⭐ the project on GitHub.

GitHub Org ↗ Read the Spec

🔭 Next steps

Get Started

Learn how to install and use YINI from CLI.
Quick Tutorial

5-minute guided walkthrough of YINI — the basics of the YINI format and how to validate it.
Specification

Official YINI format rules — Full technical details of the YINI format.
FAQ

Common questions answered.

Build & Release Status

Parser (Node.js) library: yini-parser

CLI tool: yini-cli