9314JIUsi
Developer tools · browser-local conversion

YAML ⇄ Properties Workbench

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.

InputYAML or Properties
OutputResult

Direction
Array style

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.

How to use it

  1. Paste YAML or Properties into the left input slot (leave direction on auto-detect if unsure), or hit a sample button to see it work first.
  2. Pick an array style: 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).
  3. Hit "Round-trip check" to verify on the spot: convert, move the result back, convert again - the key-value set must match before it reports green.
  4. Take the result from the right: copy it or download it as .yml / .properties.

What syntax is handled correctly

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.

When it earns its keep

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.

InputYAML (mappings/sequences/indentation/flow/quotes/comments/block scalars) or Java Properties (= and : separators, continuations, Unicode escapes)
OutputThe opposite format; YAML→Properties flattens nested keys (a.b.c=v) with comma or indexed arrays; Properties→YAML rebuilds hierarchy plus type inference
Key parametersComma arrays and 2-space indent by default; ?arr=index&indent=4 deep-links; comments follow their nearest key
ProcessingBrowser-local parsing and conversion - no uploads, no collection, works offline; interface options in localStorage
Limits1MB per run (tens of thousands of config lines, milliseconds)
Known limitsNo anchors or references (& *), multi-document (---) or tags (!!); block scalars escape to one line and back; dates kept as strings verbatim

FAQ

How do arrays look after converting YAML to Properties?

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.

Do comments survive the conversion?

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.

Going Properties back to YAML, do numbers and booleans become strings?

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.

Does my configuration get uploaded to a server?

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.

Does a round trip (YAML→Properties→YAML) match the original?

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.

How does this relate to the site's JSON⇄YAML tool?

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.

Related tools