| Field | Value | Copy |
|---|---|---|
| {{ row.label }} | {{ row.value }} |
{{ normalizedYaml }}{{ iniText }}{{ envText }}{{ propertiesText }}| Document | Path | Type | Preview | Copy |
|---|---|---|---|---|
| Doc {{ row.docIndex }} | {{ row.path || '(root)' }} | {{ formatTypeLabel(row.type) }} | {{ row.preview }} |
| Path | Types | Docs | Example |
|---|---|---|---|
| {{ row.path }} | {{ row.types }} | {{ row.docs }} | {{ row.example }} |
INI files store configuration as named sections and simple key-value lines. They are easy to scan in small doses, but they get harder to audit once settings spread across several sections, comments, and environment variants. This converter parses that text into a structured view and rewrites it into formats that are easier to compare and reuse.
Paste raw configuration or drop a file and the tool builds a normalized object, summary metrics, flattened paths, schema rows, and regenerated outputs for YAML, JSON, environment-style variables, properties files, and normalized INI text. That makes it useful for migration work, quick config reviews, or any situation where one source file has to feed several downstream formats.
A short server block may look obvious in plain text, but inherited configuration often hides duplicate keys, type changes, or naming collisions that only show up once you flatten the data. The summary, path preview, and schema view expose those issues faster than reading line by line, especially when you need to explain what a file contains to someone who does not normally work in INI.
The parser is intentionally opinionated. Whole-line comments beginning with ; or # are ignored, duplicate keys are replaced by the last assignment in the same section, repeated section headers merge into the same object, and only simple booleans and base-10 numbers become typed values. The result is consistent and useful, but it represents one concrete interpretation of the file rather than every convention used by every INI parser.
Configuration files often contain passwords, tokens, and internal hostnames. Even when the conversion itself is straightforward, you should still review sensitive files on a trusted machine and treat the generated text with the same care as the original configuration.
For a first pass, paste the raw file into INI content and leave the advanced controls at their defaults. Then look at Configuration Summary before copying anything. The document count should be 1, the key and scalar counts should feel plausible, and any warning badges deserve attention before you trust the generated formats.
Overview when you want a fast sanity check on top-level keys, sample keys, and sample values.Paths when you need flattened names for shell variables, CSV review, or mapping documents.Schema when you need to confirm whether a path resolves to strings, numbers, booleans, or mixed-looking content.Env or Properties only after you are comfortable with the chosen path style and prefix rules.A common misread is to assume that a clean YAML or JSON output means the original INI would behave the same way in every parser. It does not. The safer trust check is to compare the warnings, confirm the typed values in Overview or Schema, and inspect the flattened names that other tools will actually consume.
Another easy miss is the Preview trimmed badge. That badge limits only the visible Paths table. It does not mean path rows were dropped from export. If you are auditing a large file, raise Max preview paths for on-screen review, then export the full paths or schema table once the first slice looks right.
The parser reads one INI-style document as lines, normalizes line endings, and keeps a current section while it walks downward. A section header like [server] opens or reuses an object, while a key=value line writes a scalar under the current section. If no section header appears, values go into a temporary default section that is unwrapped so the final result is still a plain object.
Value typing is intentionally narrow. Double-quoted strings decode \n, \r, and \t; single-quoted strings keep their inner text as written; bare true and false become booleans; and only simple base-10 integers or decimals become numbers. Text such as 1e3, yes, or prod ; comment stays a string because it does not match the tool's numeric or boolean rules.
Warnings are equally specific. After trimming, lines that start with ; or # are treated as whole-line comments and skipped. Lines without an equals sign trigger Skipped line N: unable to parse., and a repeated key inside the same section replaces the earlier value with Duplicate key section.key replaced.. Repeated section headers do not create separate documents. They keep filling the same section object.
Once the object exists, the tool walks it again to compute documentCount, totalKeys, totalScalars, maxDepth, flattened paths, and schema rows. Path style changes whether those references look like server.port or server/port. Those flattened rows then feed every export format, which is why the path, schema, env, properties, and regenerated INI outputs stay synchronized.
| Stage | Tool behavior | Why it matters |
|---|---|---|
| Line scan | Normalize newlines, skip blank lines, and ignore trimmed whole-line comments. | Prepares a stable parse surface before any type or path decisions are made. |
| Section and key parse | Interpret [section] headers and key=value assignments in order. |
Determines where each value lands and which duplicate assignment wins. |
| Type inference | Convert only simple booleans and decimal numbers; keep everything else as strings. | Controls whether downstream JSON, YAML, env, and schema outputs show text or typed scalars. |
| Flatten and summarize | Walk the object tree into preview rows, full path rows, schema rows, and top-level metrics. | Creates the shared representation used by Overview, Paths, and Schema. |
| Emit formats | Render YAML, JSON, normalized INI, env lines, and properties lines from the parsed data. | Keeps every output tied to the same interpreted source instead of separate conversion paths. |
A compact example shows how the internal representation changes the exports. With this input:
[server]
port=8080
debug=true
The parser builds a server object with a numeric port and a boolean debug. In dot style the flattened rows include server.port and server.debug. JSON therefore emits 8080 and true without quotes, while the env output becomes SERVER_PORT=8080 and SERVER_DEBUG=true unless you add a prefix.
| Setting | Lower | Upper | Behavior at the boundary |
|---|---|---|---|
YAML indent |
1 | 8 | Values outside the range are clamped, with 2 as the fallback. |
Line width |
0 | 240 | 0 disables wrapping; other invalid values fall back to 80. |
Max preview paths |
50 | 2000 | The visible path table is clamped to this range, while full exports still include all discovered rows. |
JSON spacing |
0 | 4 | 0 means minified output in the UI; positive values add indentation. |
| Output surface | Meaning | Typical use |
|---|---|---|
Configuration Summary |
High-level counts plus warnings and top value types. | First trust check before copying generated formats. |
Overview |
Per-document sample fields such as top-level keys, scalar count, and max depth. | Quick sanity check for unexpected structure changes. |
Paths and Schema |
Flattened references and observed types for each discovered location. | Audit-friendly view for naming, type checking, and export mapping. |
YAML, JSON, INI, Env, Properties |
Rendered text outputs from the same parsed object. | Copy-ready targets for editors, scripts, and migration work. |
The cleanest workflow is parse first, trust-check second, and only then copy the target format you need.
INI content or drop a .ini, .cfg, or .txt file onto the editor. If you want a quick baseline, use Load sample first so you can see the expected shape.No INI data detected. means the input is blank or contains only content the parser ignored. Skipped line N: unable to parse. means a line is missing = or does not match the expected section format.Configuration Summary and any warning badges before moving to target formats. A duplicate-key warning or an unexpected scalar count is easier to fix here than after you have copied YAML or env text elsewhere.Advanced only for formatting or naming changes. That is where you control JSON spacing, YAML indent, Line width, Sort keys, Force quotes, Quote style, Expand anchors, Path style, Max preview paths, ENV prefix, and Uppercase env.Overview, Paths, and Schema to confirm that keys landed where you expect and that values have the types you expect. This is the point where you catch numeric text that stayed a string or an inline comment that remained part of the value.Apply to editor so the normalized YAML replaces the original input for another pass.The first output to trust is the warning state, not the prettiest format. If the page reports skipped lines or duplicate replacements, every downstream format already reflects those decisions. The converted text is therefore a normalized interpretation of the source, not a literal preservation of every comment, ordering choice, or parser quirk.
Preview trimmed means discovered path count is greater than the selected Max preview paths, which is clamped between 50 and 2000. It does not mean the CSV export was cut down.YAML and JSON show typed values. Bare true and false become booleans, simple decimals become numbers, and comments are not preserved in those formats.Env and Properties are flattening views, so path naming matters as much as value content. Verify a few critical keys in Paths before you assume the generated names are what another system expects.Do not overread a clean export as proof that every other INI parser will agree with this one. INI behavior varies across ecosystems. The corrective check is simple: inspect the critical rows in Schema or Paths, especially values with quotes, duplicates, inline comment-like text, or names that include dots and slashes.
Consider this input:
[server]
host=localhost
port=8080
[database]
user=appuser
pool=5
Configuration Summary shows 1 document, 4 keys, and 4 scalars. In Paths, you see server.host, server.port, database.user, and database.pool. If you add the prefix APP, the Env output becomes APP_SERVER_HOST=localhost and APP_SERVER_PORT=8080, while Schema confirms that server.port and database.pool are numbers rather than strings.
Now consider:
[app]
mode=prod ; keep for now
mode=stage
active=true
The first mode value stays a string because inline comment text is not stripped. The second assignment wins, so the page adds Duplicate key app.mode replaced. to the warnings and the final Schema row for app.mode is still string-typed. active becomes a boolean, so JSON emits true without quotes. This is a good example of why warnings matter more than the surface neatness of the output.
With this input:
[server]
host localhost
port=8080
The parser cannot read line 2 because it lacks =, so it adds Skipped line 2: unable to parse.. Paths therefore contains server.port but not server.host, and the regenerated outputs are missing the host entirely. Fix the line to host=localhost, rerun the parse, and the missing path appears immediately in both Paths and Schema.
Because the parser ignores only whole-line comments after trimming. A line like mode=prod ; note is treated as a value assignment whose text includes ; note.
A repeated key inside the same section replaces the earlier value. When that happens, the tool adds a warning such as Duplicate key section.key replaced. so you can see that only the last assignment survived.
No. The tool handles simple section headers and key=value lines, but it does not preserve comments, multiline value blocks, or every ecosystem-specific INI convention. Treat the output as a normalized representation, not a perfect archival copy.
The visible table is capped by Max preview paths, which is clamped to 50-2000. If you see Preview trimmed, raise the limit for review or export the CSV to inspect the complete path list.
It means the page could not produce any parsed assignments from the current input. Blank content, comment-only content, or lines that never match the expected patterns will all leave the outputs empty until you add at least one valid assignment.
[server] that collects related settings.server.port for a nested value.