YINI — Clean, Calm Configuration for Complex Systems

YINI is a human-friendly, INI-inspired text-based configuration format for software projects: readable like INI, structured like JSON, without YAML's surprises. It offers clear nesting, comments, and predictable parsing, so your configuration stays easy to read and reason about as it grows. Suitable for configuration files, application settings, and general data storage.

Looks like INI, handles structure like JSON — without YAML's indentation pitfalls.

Get Started Quick tutorial

Example of YINI code:

Source file: config.yini

✨ The big idea

YINI is configuration that looks familiar — but stays clean even as it grows.

Simple at first.
Structured when needed.
Easy to maintain.
Readable all the way.

💡 Why YINI?

INI, YAML, and JSON all approach configuration differently, each with tradeoffs:
INI favors simplicity, YAML offers expressive structure, and JSON prioritizes precision.
YINI focuses on keeping configuration readable while providing clear nesting and predictable behavior.

No indentation traps. Clear structure without YAML-style surprises.
Readable as files grow. Nest sections without losing clarity.
Designed for humans. Easy to edit, comment, and maintain.
Predictable behavior. Clear rules. Fewer edge cases.
The right balance. More structure than INI, less noise than JSON.

More info: What is YINI and Why?

💡 How can YINI be used?

Use YINI wherever you need structured configuration — without the usual complexity.

🛠 Convert YINI → JSON with a simple CLI.
📦 Load YINI directly into your app as native objects.
🧩 Use it for configs, data files, pipelines, and tooling.

⚡ TL;DR — Quick Start

Try YINI in three simple steps:

1) Create a file
Save the two lines below as config.yini: (no build step, no dependencies required)
```
^ 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
```
JSON is the default output format.
3) See the result

You should now see the following (JSON):
```
{
    "App": {
        "name": "Hello"
    }
}
```

Nice — you just parsed your first YINI file.

Bonus: JavaScript output
```
npx yini-cli parse config.yini --js
```
Use --js to output a JavaScript-style object:
```
{ App: { name: 'Hello' } }
```

Get Started View on GitHub ↗

📝 Example

YINI code:

Source file: settings.yini

Parsed output (JSON):

{
    "Settings": {
        "serviceId": "NebulaService",
        "release": "3.2.1",
        "debugMode": false,
        "tagline": ""Nebula" is a cloud of gas and dust in outer space.",
        "Network": {
            "bindAddress": "127.0.0.1",
            "bindPort": 8080,
            "allowedOrigins": [
                "https://myapp.com",
                "http://localhost:3000"
            ]
        },
        "Capabilities": {
            "enableSearch": true,
            "experimental": [
                "new-ui",
                "streaming-api"
            ],
            "pools": {
                "min_units": 2,
                "max_units": 5,
                "size_mb": 128,
                "timeout_sec": 90
            }
        },
        "DB Config": {
            "host": "db.internal",
            "ssl": true,
            "Security": {
                "username": "service_user",
                "password": "****"
            }
        }
    }
}

New to YINI? Read a short learn the YINI format.

🧩 Key Features

Clear section markers
Sections start with ^ by default:
```
^ App
title = "MyApp"
```
Nested sections use repeated ^ markers to indicate section levels — similar concept like Markdown's heading levels: ^ App, ^^ Server, ^^^ Logging. This creates a clear section hierarchy without relying on indentation.

YINI also supports alternative section markers such as <.
Predictable and well-defined
Defined by a formal, versioned specification and grammar (ANTLR4) to ensure consistent behavior across tools.
Simple key–value pairs
Inside a section, configuration is written as:
```
key = value
```
This keeps files readable and familiar, inspired by classic INI.
Structured like YAML, readable like INI
Useful data types (similar to JSON):
- Nested sections
- Lists (arrays)
- Objects (JavaScript objects)
- Strings and numbers
- Booleans and nulls
Comments where you expect them
Supports both line comments (#, //, ; and block/multi-line comments /* ... */), making it easy to document configuration directly in the file.
Reduced syntax noise
Keeps files readable by avoiding excessive brackets, quotes, and long dotted key paths such as server.database.advanced.param.
Free and open source
YINI is open-source software, free to use, inspect, and build upon.

💡 For syntax & quick reference: See YINI Cheat Sheet

ℹ️ About

YINI is an INI-inspired configuration format designed for clarity, simple nesting, and predictable parsing.

The format is defined by a formal, versioned specification and maintained as an open-source project under the YINI-lang organization on GitHub.

🛠️ Contribute & Get Involved

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

⬇️ Get YINI Tools ↗ GitHub Org ↗

🔭 Next steps

Get Started

Learn how to install and parse your first config in minutes.
Quick Tutorial

5-minute guided walkthrough of the YINI format and validation basics.
Code Examples

Real-world YINI examples showing common configuration patterns.
FAQ

Common questions about using YINI in real projects.
Specification

Official YINI format rules with full technical details of the YINI format.

Project status

CLI tool: yini-cli

Parser (Node.js) library: yini-parser