YINI — Simple to Read, Structured by Design

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

Why YINI?

INI, JSON, YAML, XML, and TOML all solve configuration in different ways. YINI focuses on a practical middle ground: readable files, explicit structure, useful data types, and predictable parsing.

No indentation traps. Structure is defined by section markers, not whitespace.
Readable as files grow. Nested sections help larger configurations stay easy to scan.
Human-friendly editing. Comments, simple key-value pairs, and familiar syntax keep files approachable.
Predictable behavior. Clear rules and a formal grammar help tools parse YINI consistently.

More info: What is YINI and Why?

How YINI is used in practice

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

🛠 Validate and convert YINI files from the command line with the YINI CLI tool.
It can export parsed data as JSON, YAML, XML, or JavaScript.
📦 Load YINI directly in TypeScript/JavaScript applications with the YINI Parser for TypeScript.
🐍 Load YINI directly in Python scripts, tools, and applications with the YINI Parser for Python.
🧩 Use YINI for configuration files, data files, tooling, and CI workflows.

⚡ TL;DR — Quick Start

Try YINI in three simple steps:

This quick start uses the Node.js-based YINI CLI.

1) Create a file
Save these two lines as config.yini: (No build step or project setup required.)
```
^ App
name = "Hello"
```
💡 Make sure you save the file with the .yini extension (not .txt).
2) Run this in your terminal

From your terminal (with Node.js installed), in the same folder where you saved the file, run this:
```
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 instead:
```
{
    App: {
        name: "Hello"
    }
}
```

Get Started View on GitHub ↗

🌐 The YINI Ecosystem

🧠 Core	🛠 Implementation	🌍 Adoption
✔ Language Specification (RC)
✔ Parsing Rules (Lenient & Strict) (RC)	✔ TypeScript Parser (Primary)
✔ Formal Grammar (ANTLR) (RC)	✔ CLI Tool (Parse & Convert YINI)	✔ Homepage & Docs
	✔ Editor Syntax Highlighting grammar (VS Code / TextMate)	✔ Cheat Sheet (Quick Syntax Guide)
	◐ Python Parser (Alpha)	◐ Example Projects

✔ Complete ◐ In progress ○ Planned

RC = Release Candidate

📝 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

⚖️ How YINI compares to other config formats

YINI supports both lenient and strict parsing modes, depending on how much enforcement you need. Lenient mode is the default.

Feature	YINI (lenient)	YINI (strict)	INI	JSON	YAML	TOML
Human readability by default	✅	✅	➖	➖	✅	➖
Readability at scale	✅	✅	❌	❌	➖	➖
Predictable parsing	✅	✅	❌	✅	❌	✅
Formal specification / grammar	✅	✅	❌	✅	❌	✅
Nested structure	✅	✅	➖	✅	✅	✅
Comments	✅	✅	✅	❌	✅	✅
Syntax overhead	✅	✅	✅	❌	➖	➖
Configuration-oriented design	✅	✅	✅	➖	✅	✅
Diagnostic clarity	✅	✅	➖	✅	❌	✅
Tolerance for incomplete or hand-edited input	✅	❌	➖	❌	➖	❌
Strength of structural validation	➖	✅	❌	✅	➖	✅
Suitability for larger configurations	✅	✅	❌	➖	➖	➖
Industry familiarity	Low	Low	Very strong	Very strong	Very strong	Moderate
Native tooling availability	Limited / growing	Limited / growing	Moderate	Very strong	Very strong	Strong
Ecosystem maturity	Limited / growing	Limited / growing	Mature but fragmented	Very strong	Very strong	Strong

Lenient = flexibility & convenience · Strict = safety & predictability

✅ Strong support · ➖ Partial / debated · ❌ Poor or not supported

The final three rows use text labels to describe ecosystem and adoption maturity.

About

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 starring 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