<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Mr Marko Smithnen on Medium]]></title>
        <description><![CDATA[Stories by Mr Marko Smithnen on Medium]]></description>
        <link>https://medium.com/@marko.seppanen?source=rss-1778d0a86bf8------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Stories by Mr Marko Smithnen on Medium</title>
            <link>https://medium.com/@marko.seppanen?source=rss-1778d0a86bf8------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 12:30:41 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@marko.seppanen/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[YINI reaches RC6: A Configuration Format Built for Clarity and Predictability]]></title>
            <link>https://medium.com/@marko.seppanen/yini-reaches-rc6-a-configuration-format-built-for-clarity-and-predictability-4e4d3a7023c2?source=rss-1778d0a86bf8------2</link>
            <guid isPermaLink="false">https://medium.com/p/4e4d3a7023c2</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[configuration]]></category>
            <dc:creator><![CDATA[Mr Marko Smithnen]]></dc:creator>
            <pubDate>Fri, 19 Jun 2026 23:14:55 GMT</pubDate>
            <atom:updated>2026-06-19T23:14:55.296Z</atom:updated>
            <cc:license>https://creativecommons.org/publicdomain/mark/1.0/</cc:license>
            <content:encoded><![CDATA[<p>The YINI configuration format has now reached <strong>Specification Release Candidate 6</strong>.</p><p>This release is not about adding new flashy features. It is mostly about tightening the language, removing ambiguity, and making the format easier to implement consistently.</p><p>That may sound less exciting than a big feature release - but for a configuration format, this kind of work matters a lot.</p><p>Configuration files are supposed to be boring in the right way. Easy to read, hard to misread, and predictable for both humans and tools.</p><p>That is what YINI is built around.</p><h3>Why YINI exists</h3><p>YINI started from a fairly simple idea:</p><blockquote>What if a configuration format could stay readable as it grows, without relying on implicit behavior or heavy punctuation?</blockquote><p>Most existing formats make trade-offs that eventually get in the way:</p><ul><li>Classic INI files are easy to read, but tend to become limited when configuration grows more structured.</li><li>JSON is well-defined and widely supported, but can be noisy for hand-written configuration — double quotes everywhere, brackets for everything.</li><li>YAML is expressive and popular, but its reliance on indentation and automatic value interpretation can sometimes make files harder to understand at a glance.</li><li>TOML is a capable configuration format, but larger or deeply nested configurations can become harder to scan and maintain.</li><li>XML is precise and extensible, but closing tags, attributes, and nesting make even simple configuration files visually heavy and tedious to write by hand.</li></ul><p>YINI is an attempt to find a practical middle ground (for more detail, see <a href="https://yini-lang.org/start/what-is-yini-and-why/"><strong>Why YINI?</strong></a>):</p><ul><li>More structured than classic INI.</li><li>Less punctuation-heavy than JSON.</li><li>Indentation-insensitive unlike YAML.</li><li>Explicit about parsing rules and validation behavior.</li><li>Designed to stay readable as configuration files grow.</li></ul><p><strong>A small YINI file looks like this:</strong></p><pre>@yini<br><br>^ App<br>name = &quot;Example&quot;<br>version = &quot;1.0.0&quot;<br>debug = false<br><br>^^ Server<br>host = &quot;127.0.0.1&quot;<br>port = 8080<br><br>^^ Features<br>enabled = [<br>    &quot;auth&quot;,<br>    &quot;logging&quot;,<br>    &quot;metrics&quot;,<br>]</pre><p>The ^ section markers define structure. Repeated markers represent nested sections. The file remains readable without relying on indentation to define meaning.</p><h3>The problem RC 6 tries to address</h3><p>As YINI has developed, one of the main goals has been to avoid a common problem in configuration formats:</p><blockquote><em>The syntax looks simple at first, but edge cases become surprising later.</em></blockquote><p><strong>Some examples of this kind of problem are:</strong></p><ul><li>Is this character part of a value or the start of a comment?</li><li>Does this duplicate key override the earlier one?</li><li>Is this + operator string concatenation or numeric addition?</li><li>Are two sections with the same name merged, replaced, or rejected?</li><li>Does whitespace affect structure?</li><li>Does the parser guess what the user meant?</li></ul><p>RC 6 focuses on making those answers clearer.</p><p><strong>The main design principle remains:</strong></p><blockquote><em>Make the format clear for humans, but deterministic for parsers.</em></blockquote><p>This is the heart of this release.</p><h3>Clearer section structure</h3><p>YINI uses section markers instead of indentation to define hierarchy:</p><pre>^ App<br>name = &quot;MyApp&quot;<br><br>^^ Server<br>host = &quot;localhost&quot;<br><br>^^^ TLS<br>enabled = true</pre><p>The number of section markers defines the nesting level.</p><p>This is meant to keep hierarchy visible while avoiding indentation-sensitive structure. Indentation can still be used for readability, but it does not define the data model.</p><p>The primary section marker is:</p><pre>^</pre><p>YINI also supports alternative section markers, but ^ remains the recommended default for most examples and normal usage.</p><p>This is one of the central ideas of YINI: structure should be explicit and visible.</p><h3>Strict and lenient mode are more clearly defined</h3><p><strong>YINI has two parsing modes:</strong></p><ul><li><strong>Lenient mode</strong> — practical, forgiving, and intended as the default.</li><li><strong>Strict mode</strong> — validation-focused and intended for stricter tooling, CI checks, and production-sensitive configuration.</li></ul><p>A file can declare its intended mode:</p><pre>@yini strict</pre><p>or:</p><pre>@yini lenient</pre><p>RC 6 clarifies how these declarations should behave when the file is parsed in a different mode.</p><p>The reason is simple: mode declarations should not become decorative comments. If a file says it expects strict behavior, tooling should not quietly treat that as “close enough” in a looser context.</p><p>Strict mode is meant to help catch mistakes. Lenient mode is meant to be useful during editing and practical usage. Both modes have value, but the difference between them should be explicit.</p><h3>Comment syntax is more consistent</h3><p>YINI supports common comment styles:</p><pre>// A line comment</pre><pre># Another line comment</pre><pre>; A full-line comment</pre><pre>/*<br>    A block comment.<br>*/</pre><p>RC 6 clarifies that # is consistently treated as a comment marker outside strings.</p><p>This also means # is no longer used for hexadecimal numbers.</p><p>That may seem like a small syntax detail, but it removes a possible source of confusion. If # starts a comment in one context but means a number in another, both humans and parsers need more special-case logic.</p><p>RC 6 chooses the simpler rule:</p><blockquote><em>Outside strings, </em><em># starts a comment.</em></blockquote><h3>Hexadecimal numbers now use clearer prefixes</h3><p>Because # is reserved for comments, hexadecimal values use clearer forms such as:</p><pre>color = 0xffcc00<br>mask = hex:ffcc00</pre><p>This makes the syntax easier to scan and avoids conflict with comments.</p><p>Digit separators are also supported for readability:</p><pre>maxSize = 1_000_000<br>flags = 0b1111_0000<br>id = 0x_ab_cd_12_34</pre><p>The intention is to make larger numeric values easier to read without changing their meaning.</p><h3>String handling is more explicit</h3><p>String behavior is one of the places where configuration formats can easily become surprising.</p><p>RC 6 continues to refine YINI’s string rules so that the intent is visible in the syntax.</p><p>For example:</p><pre>name = &quot;Example&quot;<br>path = R&quot;C:\Users\marko\config&quot;<br>message = C&quot;Line one\nLine two&quot;</pre><p>The distinction matters:</p><ul><li>Raw strings preserve backslashes.</li><li>Classic strings interpret escape sequences.</li></ul><p>That makes Windows paths, regular expressions, and escaped text easier to represent without guessing how the parser will treat the value.</p><p>Triple-quoted strings are available for longer text:</p><pre>description = &quot;&quot;&quot;<br>This is a longer string.<br>It can span multiple lines.<br>&quot;&quot;&quot;</pre><p>The goal is not to have many string forms for the sake of it. The goal is to make each kind of string explicit enough that the reader can understand what will happen.</p><h3>String concatenation is more predictable</h3><p>YINI uses + for string concatenation, but RC 6 makes the rules more conservative and explicit.</p><p>In strict mode, all concatenation operands must be string literals:</p><pre>title = &quot;YINI &quot; + &quot;Config&quot;</pre><p>In lenient mode, scalar values may be allowed after the first string literal:</p><pre>message = &quot;Port: &quot; + 8080</pre><p>This produces:</p><pre>Port: 8080</pre><p>But this is still string concatenation only. It is not arithmetic.</p><pre>value = 1 + 2</pre><p>That should not be treated as numeric addition.</p><p>This is an intentional design choice. YINI should not make the reader wonder whether + means string concatenation, numeric addition, or something else depending on context.</p><p>For now, + means concatenation.</p><p>Predictability wins over cleverness here.</p><h3>Inline objects are more clearly specified</h3><p>YINI supports inline objects for compact structured values:</p><pre>database = {<br>    host: &quot;localhost&quot;,<br>    port: 5432,<br>    ssl: true,<br>}</pre><p>RC 6 clarifies that the canonical inline object member syntax is:</p><pre>key: value</pre><p>Lenient parsers may accept key = value inside inline objects, but strict mode should require :.</p><p>This gives users a more forgiving mode while still keeping strict mode suitable for validation and tooling.</p><p>The broader principle is the same: lenient mode can help with practical editing, but strict mode should provide a clean and predictable target.</p><h3>Lists remain explicit</h3><p>Lists use brackets:</p><pre>plugins = [<br>    &quot;auth&quot;,<br>    &quot;cache&quot;,<br>    &quot;metrics&quot;,<br>]</pre><p>Trailing commas are convenient in hand-edited files and may be accepted in lenient mode.</p><p>Strict mode can reject them when stronger validation is desired.</p><p>One important rule is that missing entries are not silently treated as null. YINI should not guess structure that was not written.</p><p>That is part of the format’s general bias toward explicitness.</p><h3>Duplicate keys and sections are safer</h3><p>Duplicate handling is another area where configuration formats can become dangerous.</p><p>If a value appears twice, should the second value replace the first? Should it merge? Should it be an error?</p><p>RC 6 keeps this conservative.</p><p>Duplicate keys in the same section and nesting level are not silently overwritten.</p><p>In lenient mode, the first definition wins and later duplicates should produce a warning.</p><p>In strict mode, duplicates are errors.</p><p>This avoids a common and frustrating problem: a value being accidentally overridden much later in a large file.</p><p>Duplicate sections are also not treated as implicit merges. YINI avoids hidden merge behavior because it can become difficult to reason about as files grow.</p><p>Again, the goal is not cleverness. The goal is to make the file’s meaning clear.</p><h3>Strict files can use a .strict.yini suffix</h3><p>RC 6 also documents a recommended naming convention for strict-mode YINI files:</p><pre>config.strict.yini</pre><p>This does not replace the parser mode. It is only a useful signal for humans and tools.</p><p>For example, an editor extension or CI workflow could warn if a file looks like it is intended for strict parsing but is being handled differently.</p><p>The suffix is a small convention, but it helps make intent visible.</p><h3>The ecosystem around YINI</h3><p>The specification is the central piece, but YINI is not only a document.</p><p>One important addition around this release is the newly public yini-test repository (<a href="https://github.com/YINI-lang/yini-test">here</a>). It provides shared test cases for YINI parser behavior, helping tools and parser implementations stay consistent with the specification instead of slowly drifting in different directions.</p><p>The ecosystem now includes several related tools and repositories:</p><ul><li>The YINI specification.</li><li>A TypeScript parser.</li><li>A Python parser.</li><li>A CLI tool for parsing and converting YINI.</li><li>Syntax highlighting support for editors using TextMate-style grammars.</li><li>A public yini-test test suite for parser behavior and compatibility checks.</li><li>The YINI homepage and documentation.</li></ul><p>The yini-test repository is especially important because it gives parser implementations a shared set of cases to validate against.</p><p>That matters for a format like YINI. If the specification says one thing, but each parser slowly develops different behavior, the format becomes harder to trust.</p><p>Shared tests help keep implementations aligned.</p><p>The CLI is also useful for quickly trying YINI from the terminal:</p><pre>npx yini-cli parse config.yini</pre><p>The TypeScript parser can be used directly in Node.js and TypeScript projects. The Python parser is being developed for Python-based tooling, scripts, and applications.</p><p>The goal is not just to define YINI, but to make it practical to test, parse, and use.</p><h3>Why RC 6 matters</h3><p>RC 6 is mostly about tightening the format.</p><p>That includes:</p><ul><li>Fewer ambiguous rules.</li><li>Clearer strict vs lenient behavior.</li><li>Safer duplicate handling.</li><li>More explicit string behavior.</li><li>Clearer number syntax.</li><li>Better parser consistency.</li><li>Stronger alignment between the specification and tooling.</li></ul><p>This is the kind of work a configuration format needs before it can become stable.</p><p>A configuration format should not surprise you. It should not make you wonder whether whitespace changed the structure, whether a duplicate value silently replaced another value, or whether a symbol means different things in different places.</p><p>The ideal configuration file is not impressive because it is clever.</p><p>It is useful because it is readable, predictable, and boring in the right places.</p><p>That is what YINI is aiming for.</p><p>The full specification can be found <a href="https://yini-lang.org/specification">here</a>.</p><h3>Try it</h3><p>A minimal YINI file looks like this:</p><pre>@yini<br><br>^ App<br>name = &quot;Hello YINI&quot;<br>debug = false<br><br>^^ Server<br>host = &quot;127.0.0.1&quot;<br>port = 8080</pre><p>Parse it with the CLI:</p><pre>npx yini-cli parse config.yini</pre><p>The result is structured data that can be exported as JSON or used by tools and applications.</p><h3>Links</h3><ul><li>YINI homepage: <a href="https://yini-lang.org/">https://yini-lang.org</a></li><li>YINI on GitHub: <a href="https://github.com/YINI-lang">https://github.com/YINI-lang</a></li><li>Specification: <a href="https://yini-lang.org/specification">https://yini-lang.org/specification</a></li><li>CLI tool: <a href="https://yini-lang.org/tools/yini-cli">https://yini-lang.org/tools/yini-cli</a></li><li>TypeScript parser: <a href="https://yini-lang.org/tools/yini-parser-ts">https://yini-lang.org/tools/yini-parser-ts</a></li><li>Python parser: <a href="https://yini-lang.org/tools/yini-parser-python">https://yini-lang.org/tools/yini-parser-python</a></li></ul><h3>Feedback is welcome</h3><p>RC 6 is still a release-candidate specification, so feedback is useful.</p><p>Especially useful feedback includes:</p><ul><li>Confusing syntax rules.</li><li>Parser edge cases.</li><li>Unclear examples.</li><li>Places where strict and lenient behavior should be clearer.</li><li>Documentation gaps.</li><li>Real-world configuration examples that would be useful to test against.</li></ul><p>If you try YINI, find a rough edge, or have opinions about configuration formats, I would be happy to hear them.</p><p>Thanks for reading.</p><p>— -</p><p>Originally published on dev.to:</p><p><a href="https://dev.to/marko_kseppnen_6250a7f/yini-config-format-specification-rc-6-released-clearer-strings-stricter-parsing-and-growing-2n6k">https://dev.to/marko_kseppnen_6250a7f/yini-config-format-specification-rc-6-released-clearer-strings-stricter-parsing-and-growing-2n6k</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4e4d3a7023c2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Use a YINI Config File in Your Node.js App (With Real Examples)]]></title>
            <link>https://medium.com/@marko.seppanen/how-to-use-a-yini-config-file-in-your-node-js-app-with-real-examples-b8d48d1cc7dc?source=rss-1778d0a86bf8------2</link>
            <guid isPermaLink="false">https://medium.com/p/b8d48d1cc7dc</guid>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[configuration]]></category>
            <dc:creator><![CDATA[Mr Marko Smithnen]]></dc:creator>
            <pubDate>Sat, 02 Aug 2025 23:06:53 GMT</pubDate>
            <atom:updated>2026-02-08T00:28:02.648Z</atom:updated>
            <content:encoded><![CDATA[<h3>🙋‍♂️ Why I Wrote This</h3><p>You know that moment when you’re knee-deep in a side project and you just want a clean config file?<br> Something easier on the eyes than JSON, but more structured than old-school INI?</p><p>That was me — and that’s how <strong>YINI</strong> started.</p><p>Not to reinvent configuration formats, but just to make one that I wouldn’t dread editing.</p><p>In short, YINI stands for “Yet another INI.” It’s an INI alternative, strongly inspired by INI and JSON, but with strong typing, simple nested sections, minimal syntax noise, support for comments, and an optional strict validation mode.</p><p>In this post, I’ll walk you through how to actually use YINI in a Node.js app, with real examples pulled straight from my own parser tests and tooling setup. It’s simple, flexible, and (hopefully) a bit fun.</p><h3>📦 Installing the Parser</h3><p>First, install the YINI parser from npm:</p><pre>npm install yini-parser</pre><h3>🧪 Parsing a Basic Config</h3><p>Let’s start with a simple YINI config:</p><pre>^ App<br>title = &#39;My App Title&#39;<br>items = 25<br>isDarkTheme = true</pre><p>Here’s how you load it in your app:</p><pre>import YINI from &#39;yini-parser&#39;;<br><br>const config = YINI.parse(`<br>    ^ App<br>    title = &#39;My App Title&#39;<br>    items = 25<br>    isDarkTheme = true<br>`);<br><br>console.log(config.App.title); // &#39;My App Title&#39;</pre><p>YINI forces you to quote strings for clarity. Numbers, booleans, and nulls are parsed correctly too — without weird surprises.</p><p>The above YINI (in the variable config) now corresponds to the following JS object:</p><pre>// JS object<br>{ <br>  App: {<br>    title: &#39;My App Title&#39;,<br>    items: 25,<br>    isDarkTheme: true <br>  } <br>}</pre><h3>📂 Loading from a File</h3><p>In most real projects, you’ll want to load your config from an actual file.<br> yini-parser provides a convenience method for this: YINI.parseFile(..).</p><pre>import YINI from &#39;yini-parser&#39;;<br><br>const config = YINI.parseFile(&#39;./config.yini&#39;);<br><br>console.log(config.App.title); // e.g., &#39;My App Title&#39;</pre><p>This works out of the box with both .yini files, and supports options like strict mode or metadata as additional arguments.</p><p>Under the hood, parseFile(..) just reads the file as UTF-8 and passes it to YINI.parse(..). It&#39;s a small helper, but it makes things cleaner in app code.</p><h3>💡 Structured Config with Nested Sections</h3><p>Sometimes your config grows — and when it does, structure helps. YINI supports <strong>nested sections</strong> that are easy to read <em>and</em> parse:</p><pre>@yini<br><br>^ App<br>name = &quot;Nested Example&quot;<br>version = &quot;1.0.0&quot;<br>debug = OFF<br><br>    ^^ Database<br>    host = &quot;db.example.com&quot;<br>    port = 3306<br>    user = &quot;appuser&quot;<br>    password = &quot;dbpassword&quot;<br><br>        ^^^ Pool<br>        min = 2<br>        max = 10<br>        idleTimeout = 300<br><br>    ^^ Logging<br>    level = &quot;info&quot;<br>    logToFile = ON<br>    filePath = &quot;./logs/app.log&quot;<br><br>/END</pre><p>You can parse this in <strong>strict mode</strong> like this:</p><pre>const config = YINI.parse(yiniString, true); // true = strict mode</pre><p>Now you’ve got a deeply nested, clean, type-aware config object.</p><p>The config JavaScript object will look like this now:</p><pre>// JS object<br>{<br>  App: {<br>    name: &#39;Nested Example&#39;,<br>    version: &#39;1.0.0&#39;,<br>    debug: false,<br>    Database: {<br>      host: &#39;db.example.com&#39;,<br>      port: 3306,<br>      user: &#39;appuser&#39;,<br>      password: &#39;dbpassword&#39;,<br>      Pool: { min: 2, max: 10, idleTimeout: 300 }<br>    },<br>    Logging: { level: &#39;info&#39;, logToFile: true, filePath: &#39;./logs/app.log&#39; }<br>  }<br>}</pre><h3>🛠 Optional Metadata</h3><p>Sometimes you want more than just values — you want some extra info, some stats, or structure metadata (e.g., for tooling or validation). Just pass the fourth argument:</p><pre>const configWithMeta = YINI.parse(yiniString, false, &#39;auto&#39;, true);</pre><p>Now you’ll get extra info in the parsed structure — including attached comments and position metadata.</p><h3>🗨️ Comments — Your Way</h3><p>Use the comment style you like. YINI supports them all:</p><pre>// This is a comment<br># So is this<br>-- And this<br><br>/*<br>Block comments<br>are supported too<br>*/</pre><h3>✅ Recap</h3><p>YINI isn’t trying to be better than JSON, TOML, or YAML. It just tries to be <strong>clear, consistent, and pleasant to use</strong> — especially when you want nesting without indentation sensitivity, or strict validation without a mess of brackets.</p><p>If you like working with structured configs in Node.js and want something that’s:</p><ul><li>Human-friendly</li><li>Easy to read</li><li>Tooling-ready</li><li>Just structured enough…</li></ul><h3>🔗 Links</h3><ul><li><strong>npm:</strong> <a href="https://www.npmjs.com/package/yini-parser">yini-parser</a></li><li><strong>GitHub:</strong> <a href="https://github.com/YINI-lang/yini-parser-typescript">YINI-lang/yini-parser-typescript</a></li><li><a href="https://yini-lang.org/?utm_source=medium&amp;utm_medium=article&amp;utm_campaign=yini_launch">YINI Homepage</a></li></ul><p>– Marko<br> (creator of YINI)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b8d48d1cc7dc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why I Created YINI — A Human-Friendly, Structured Configuration Format]]></title>
            <link>https://medium.com/@marko.seppanen/why-i-created-yini-a-human-friendly-structured-configuration-format-6e23ac5a1d44?source=rss-1778d0a86bf8------2</link>
            <guid isPermaLink="false">https://medium.com/p/6e23ac5a1d44</guid>
            <dc:creator><![CDATA[Mr Marko Smithnen]]></dc:creator>
            <pubDate>Wed, 28 May 2025 21:15:11 GMT</pubDate>
            <atom:updated>2026-02-08T00:26:41.518Z</atom:updated>
            <content:encoded><![CDATA[<h3>Why I Created YINI — A Human-Friendly, Structured Configuration Format</h3><p>During one of my hobby projects, I needed a configuration format. Naturally, I reached for INI — it’s familiar and straightforward. But then I hit a wall: <strong>INI doesn’t have a formal specification.</strong> That made consistency difficult across tools and implementations. I needed something predictable, structured, and formally defined.</p><p>So I explored the usual suspects: JSON, YAML, TOML…</p><p>Each had strengths, but <strong>none quite fit the practical gap</strong> I was trying to solve — especially when it came to human readability, editability, and structure without excess.</p><p>That’s when <em>Yet Another INI</em> was born:<br> <strong>Say hello to YINI.</strong></p><h3>🧩 What YINI Aims to Be</h3><p>YINI is built to be:</p><ul><li>✅ Simple and lightweight</li><li>✅ Human-friendly to read and write</li><li>✅ Structured and type-aware</li><li>✅ Fully specified — with clear rules and a formal grammar</li><li>✅ A balance between hand-written clarity and machine-readability</li></ul><h3>-Baah, do we really need another file format, this is clearly a case of <a href="https://xkcd.com/927/">https://xkcd.com/927/</a> — right? Or..</h3><h3>Why Not Just Use…?</h3><h4>INI?</h4><p>Too vague. No formal grammar. Type guessing. Comment styles differ. Nested sections? Undefined.</p><p><strong>YINI brings:</strong></p><ul><li>An actual specification.</li><li>Clear section headers using ^, ^^, ^^^... for nesting.</li><li>Quoted strings by default — no type ambiguity.</li><li>Booleans like true, on, yes, etc. — case-insensitive.</li><li>An optional document terminator (/END) to prevent trailing ambiguity.</li></ul><h4>JSON?</h4><p>Structured and strict — but verbose and noisy for humans.</p><pre>{<br>  &quot;User&quot;: {<br>    &quot;name&quot;: &quot;Alice&quot;,<br>    &quot;age&quot;: 28,<br>    &quot;active&quot;: true<br>  }<br>}</pre><p><strong>In YINI:</strong></p><pre>^ User<br>name = &quot;Alice&quot;<br>age = 28<br>active = true</pre><p>✅ Less punctuation. ✅ Easy to scan. ✅ Easy to write.</p><h4>YAML?</h4><p>Very flexible, but:</p><ul><li>Indentation-sensitive</li><li>Can behave inconsistently</li><li>Hard to visually parse in large files</li></ul><pre>Settings:<br>  theme: dark<br>  language: en<br>  Display:<br>    resolution: &quot;1920x1080&quot;<br>    fullscreen: true</pre><p>In YINI:</p><pre>^ Settings<br>theme = &quot;dark&quot;<br>language = &quot;en&quot;<br><br>    ^^ Display<br>    resolution = &quot;1920x1080&quot;<br>    fullscreen = true</pre><p>✅ Structure is explicit — not whitespace-dependent.</p><p>TOML?</p><p>Clean and modern. But YINI goes even further in simplicity:</p><ul><li>No dotted keys.</li></ul><p><strong>YINI keeps just the essentials</strong> — enough for config files.</p><pre>| Type                   | Quotes Used                |Multi-Line|Escapes|Trims Whitespace | Description                          | Similar To             |<br>|------------------------|----------------------------|----------|-------|------------------|-------------------------------------|------------------------|<br>| Raw String             | `&#39;...&#39;` or `&quot;...&quot;`         | ❌ No    | ❌ No | ❌ No           | Simple 1-line literal               | Raw literal strings    |<br>| Classic String (C)     | `C&#39;...&#39;` or `c&quot;...&quot;`       | ❌ No    | ✅ Yes| ❌ No             | 1-line with escapes               | C / JSON strings       |<br>| Hyper String (H)       | `H&#39;...&#39;` or `h&quot;...&quot;`       | ✅ Yes   | ❌ No | ✅ Yes            | Clean multi-line text, trimmed    | HTML text flow         |<br>| Triple-Quoted (Raw)    | `&quot;&quot;&quot;...&quot;&quot;&quot;`                | ✅ Yes   | ❌ No | ❌ No             | Multi-line raw text               | Python raw triple-quote|<br>| C-Triple-Quoted        |`C&quot;&quot;&quot;...&quot;&quot;&quot;` or `c&quot;&quot;&quot;...&quot;&quot;&quot;`| ✅ Yes   | ✅ Yes| ❌ No             | Multi-line with escapes           | Python triple-quote    |</pre><p>All of these are formally defined — including whitespace normalization and control character rules — so your parser and editor can be in sync.</p><h3>📄 Fully Structured</h3><ul><li>Explicit section nesting using ^, ^^, ^^^ markers</li><li>Keys are case-sensitive, identifiers can be quoted (`like-this`)</li><li>Comments with #, ;, //, or --</li><li>Strict and lenient parsing modes</li></ul><h3>🔚 /END?</h3><p>Yes. YINI supports a <strong>document terminator</strong> (/END) — optional but useful in precise validation.</p><h3>📘 Read the Full Specification</h3><p>You can explore the full spec here:<br> ➡️ <a href="https://github.com/YINI-lang/YINI-spec">github.com/YINI-lang/YINI-spec</a></p><p>There’s also a formal grammar in ANTLR4 — if you’re into building parsers, this gives you a solid head start.</p><p>YINI isn’t trying to replace JSON, YAML, TOML, or INI. It’s a pragmatic addition — something you can use when those formats feel a bit too much (or too little) for your use case.</p><p>Whether you’re writing a CLI config, embedded app settings, or a human-editable structured file — YINI might just be the middle ground you’ve been missing.</p><p>🛠️ Feedback is warmly welcome — ideas, criticism, questions, or weird edge cases.</p><p>Thanks for reading!</p><p>— M. Seppänen<br> (Creator of YINI — <a href="https://yini-lang.org/?utm_source=medium&amp;utm_medium=article&amp;utm_campaign=yini_launch">yini-lang.org</a>)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6e23ac5a1d44" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[YINI — A Simpler Config Format, When INI Falls Short]]></title>
            <link>https://medium.com/@marko.seppanen/yini-a-simpler-config-format-when-ini-falls-short-9ed9f5528237?source=rss-1778d0a86bf8------2</link>
            <guid isPermaLink="false">https://medium.com/p/9ed9f5528237</guid>
            <category><![CDATA[configuration-file]]></category>
            <category><![CDATA[ini]]></category>
            <category><![CDATA[json]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[syntax]]></category>
            <dc:creator><![CDATA[Mr Marko Smithnen]]></dc:creator>
            <pubDate>Mon, 05 May 2025 23:09:58 GMT</pubDate>
            <atom:updated>2026-02-08T00:29:10.524Z</atom:updated>
            <content:encoded><![CDATA[<h3>YINI — A Simpler Config Format, When INI Falls Short</h3><p>During one of my projects, I needed a configuration format. Naturally, I thought of INI — it’s simple and familiar. But as I dug deeper, I realized: INI doesn’t actually have a formal specification. That became a problem. I needed something consistent, structured, and formally defined.</p><p>So I explored the usual alternatives: JSON, YAML, TOML…</p><p>Each had strengths, but I found a small practical gap that none quite filled — especially for the needs of my project. I wanted something:</p><ul><li>Simple and lightweight</li><li>Human-friendly to read and write</li><li>Capable of handling structured data</li><li>But not overly complex or verbose</li></ul><p>That’s when <strong>yet another INI</strong> was born — say hello to YINI!</p><h3>But why? What exactly..??</h3><p>✅ <strong>I wanted something INI-like</strong>, but with a clear structure, built-in types, and an actual specification.</p><ul><li>No type ambiguity: strings must be quoted</li><li>Flexible boolean values: support True, ON, yes (case-insensitive)</li><li>An explicit document terminator (/END) — so the last section isn’t left dangling</li><li>Simple, non-verbose section nesting (no need to repeat section names, or dotting here and there)</li></ul><p>✅ JSON’s types were just right — but I needed something <strong>less noisy</strong> and more writable by hand, and <strong>without the need to quote all keys all the time</strong>.</p><p><strong>So this JSON:</strong></p><pre>{<br>  &quot;User&quot;: {<br>    &quot;name&quot;: &quot;Alice&quot;,<br>    &quot;age&quot;: 28,<br>    &quot;active&quot;: true<br>  }<br>}</pre><p><strong>Can be written in YINI like:</strong></p><pre>^ User<br>name = &quot;Alice&quot;<br>age = 28<br>active = true</pre><p>✅ YAML felt too complex, indentation-sensitive, and sometimes unpredictable in behavior.</p><p><strong>So YAML:</strong></p><pre>Settings:<br>  theme: dark<br>  language: en<br>  Display:<br>    resolution: &quot;1920x1080&quot;<br>    fullscreen: true</pre><p><strong>Becomes in YINI:</strong> (notice the section markers ##)</p><pre>^ Settings<br>theme = &quot;dark&quot;<br>language = &quot;en&quot;<br><br>  ^^ Display<br>  resolution = &quot;1920x1080&quot;<br>  fullscreen = true</pre><p>✅ TOML is great — clean and well-structured — but I still wanted something <strong>even more minimalist</strong><em> </em>—<strong> with fewer rules</strong>, <strong>no edge cases</strong>.</p><p>With just enough of the types that JSON offers — no more, no less — For clean 1-to-1 structure and data mapping between YINI and JSON.</p><p>—</p><p>I recently finalized the <strong>YINI specification</strong> into beta stage.</p><p>It’s meant to be a lightweight, structured, and human-first configuration file format that tries to strike a pragmatic balance between simplicity and structure.</p><p>That said, there are already many excellent configuration formats out there, and most are great at what they do. <strong>YINI isn’t trying to replace them</strong> — it’s intended as a complement to existing formats.</p><p>📖 You can read the full spec here:<br>➡️ <a href="https://github.com/YINI-lang/YINI-spec">https://github.com/YINI-lang/YINI-spec</a></p><p>The repository also includes a grammar, in ANTL4 if you are familial with it, that should follow the specification.</p><p>Feedback is warmly welcome — ideas, criticism, questions, or use cases. I’d love to hear your thoughts.</p><p>Thanks for reading!<br> — M. Seppänen (creator of YINI, Homepage: <a href="https://yini-lang.org/?utm_source=medium&amp;utm_medium=article&amp;utm_campaign=yini_launch">https://yini-lang.org</a>)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9ed9f5528237" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>