Spring Boot's application.yml and application.properties have been feuding for years: one is a cleanly nested tree, the other fifty lines of flattened keys. This bench moves both ways: nested keys flatten into server.port=8080, arrays pick between two styles, numbers and booleans get their types inferred, comments follow their keys, and a round-trip check verifies the whole job in one click.
Configs you paste are processed in this page's memory only - nothing is uploaded and no account is needed. Interface options such as array style and indent width live in this device's browser and are lost when you switch devices or clear site data. To remove them, use "Clear my data" in the footer. And never paste production secrets into any online tool.
comma outputs items=a,b,c (fewer lines); indexed outputs items.0=a line by line (Spring accepts both, and the indexed style lets each element carry its own comment).On the YAML side: mappings, sequences, indentation nesting, flow style ([a, b] and {k: v}), single- and double-quoted strings, numbers, booleans, null (~ or empty), comments, and block scalars | >. Block-scalar multi-line text is squeezed into a single line with \n escapes for Properties and restored on the way back.
On the Properties side: flattened keys (a.b.c=v rebuilt into three nesting levels), both = and : separators, backslash line continuations, \u4e2d Unicode escapes, and # / ! comments. Values get type inference: pure numbers become numbers, true/false becomes booleans, empty becomes null.
Anchors &, multi-document --- and tags !! are not supported - encountering one raises an error with the line number instead of silently dropping content. This is the same parser behavior as the site's JSON⇄YAML tool: one file parses identically in both tools.
The classic case is a Spring Boot config migration: the old project is all properties, the new teammate writes yml, and eyeballing key names across both is misery. Convert once, and matching key sets are visible immediately.
It also shines when writing docs or diffing environment differences - flattening configs into properties keys makes diffs far more readable than aligning YAML indentation by hand.
| Input | YAML (mappings/sequences/indentation/flow/quotes/comments/block scalars) or Java Properties (= and : separators, continuations, Unicode escapes) |
|---|---|
| Output | The opposite format; YAML→Properties flattens nested keys (a.b.c=v) with comma or indexed arrays; Properties→YAML rebuilds hierarchy plus type inference |
| Key parameters | Comma arrays and 2-space indent by default; ?arr=index&indent=4 deep-links; comments follow their nearest key |
| Processing | Browser-local parsing and conversion - no uploads, no collection, works offline; interface options in localStorage |
| Limits | 1MB per run (tens of thousands of config lines, milliseconds) |
| Known limits | No anchors or references (& *), multi-document (---) or tags (!!); block scalars escape to one line and back; dates kept as strings verbatim |
Two styles to pick from: comma-separated (items=a,b,c) or indexed (items.0=a, items.1=b, items.2=c). Spring Boot accepts both officially; the indexed style keeps per-element comment positions while the comma style saves lines. Switch in the options before converting.
Yes. A # comment in YAML moves into Properties attached to the nearest key below it; conversely, # comments in Properties ride back into YAML on their corresponding keys. The only exception is comments at the very top of the file before any key appears - those are placed at the head of the output.
No, types are inferred automatically: 8080 comes out as a number, true/false as booleans, empty values as null; only quoted values stay strings. To force a value to remain a string, wrap it in quotes in the Properties file.
No. Parsing and conversion run entirely in this device's browser - there is no upload endpoint and the page works offline. Only interface options like array style and indent width live in this browser's localStorage; they do not follow you to another device, and Clear my data in the footer removes them. And do not paste intranet configs into random online tools.
The key-value set matches exactly: every key and every value (numbers, booleans, null, arrays included) corresponds one to one after the round trip, and the page has a round-trip check button to verify on the spot. Ordering and layout may differ (Properties sorts keys more stably), and block-scalar multi-line text becomes an escaped single line and back.
Same YAML parser core (hand-written, errors carry line numbers), same behavior: one YAML file parses to an equivalent structure here and in json-format. The only difference is that this side talks to Properties instead of JSON.