YINI — Readable like INI. Structured like JSON. No indentation surprises.

📦 1,246 npm downloads last month ⭐ 12 GitHub stars across YINI repos

If you find YINI interesting, consider ⭐ starring it on GitHub ↗

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.

Get Started View on GitHub ↗

🌐 The YINI Ecosystem

A high-level overview of the main YINI specification, tooling, implementation, and adoption pieces.

🧠 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)
	✔ YINI Test Suite / Parser Compatibility Tests	◐ Example Projects
	◐ Python Parser (Alpha)

✔ Complete ◐ In progress ○ Planned

RC = Release Candidate

Who is YINI for?

YINI configuration files are a good fit for:

Human-edited configuration files and internal tooling where you control the stack.
Developers who want readable, structured configuration without relying on indentation-sensitive syntax.
Teams that want comments, useful data types, and nested sections without JSON workarounds or flat INI-style sections.
Projects that benefit from predictable parsing in tools, CI, and application configuration.

YINI is early-stage: tooling is growing, community is small — However the specification is in release-candidate state, and the official parsers, CLI, and test suite are suitable to try in projects where you control the stack.

Real YINI configuration used by this site

This site uses site-config.yini as a real YINI configuration file in the yini-homepage repository.

During the build workflow, yini-cli converts it to JSON:

npx yini-cli parse site-config.yini --output src/config/site-config.json

This generates src/config/site-config.json, which is read by config.ts and used by this Astro site.

Repository: github.com/YINI-lang/yini-homepage

📝 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

This is a high-level comparison focused on configuration-file use cases.

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 sections / structured data	✅	✅	➖	✅	✅	✅
Nested structure without dotted keys or indentation rules (*)	✅	✅	➖	✅	❌	➖
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

*) YINI keeps hierarchy visible through nested sections while remaining indentation-insensitive and predictable.

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