Properties Converter

.properties content:

Use key=value, key:value, or whitespace-separated lines; one PROPERTIES, CONF, or TXT file is accepted.

Drop PROPERTIES, CONF, or TXT onto the textarea.

JSON spacing:

Choose 2 or 4 spaces for review, or Minified for single-line JSON.

YAML indent:

Enter 1-8 spaces; 2 is the usual YAML style.

YAML line width:

Use 80 for readable diffs, 0 for no wrapping, or up to 240 columns.

Sort YAML keys:

Keep on for deterministic review output; off preserves parsed order where possible.

Quote YAML scalars:

Turn on when IDs such as 00127 or true must stay visibly string-like.

YAML quote style:

Double quotes handle escapes clearly; single quotes keep most text literal.

Avoid YAML anchors:

Keep on for handoff files that must paste cleanly into tools without anchor support.

Path style:

Dot keeps keys like server.port; slash writes server/port style audit paths.

Path preview limit:

Enter 50-2000 rows; CSV and DOCX still include every flattened path.

Env prefix:

Example: APP turns server.port into APP_SERVER_PORT.

Uppercase env keys:

Keep on for POSIX-style exports; turn off only when the target expects lowercase names.

Field	Value	Copy
{{ row.label }}	{{ row.value }}

Document overview appears after parsing.

{{ normalizedYaml }}

Normalized YAML appears after parsing.

{{ iniText }}

INI output appears when keys are present.

{{ envText }}

Environment output appears when scalar values exist.

{{ propertiesText }}

Properties output appears when scalar values exist.

Document	Path	Type	Preview	Copy
Doc {{ row.docIndex }}	{{ row.path \|\| '(root)' }}	{{ formatTypeLabel(row.type) }}	{{ row.preview }}

Flattened paths appear after parsing.

Path	Types	Docs	Example	Copy
{{ row.path }}	{{ row.types }}	{{ row.docs }}	{{ row.example }}

Schema details appear after parsing.

Embed:

Customize

Include current inputs

Size

Advanced

Width

Height

Aspect ratio

Max height

Collapsible embed

Allow fullscreen

Referrer policy

Sandbox tokens

Configuration text is often copied into places the original application never expected. A small Java .properties file may become a release-review note, a deployment checklist, an environment-variable set, or a YAML handoff for another team. The syntax change is the visible part. The harder question is whether the same setting names and string values still mean the same thing after conversion.

The properties format is compact because each logical line carries one key and one value. Separators can be =, :, or whitespace, comments start with # or ! after leading whitespace, and a trailing backslash can continue a long value onto the next physical line. That compact shape makes files easy to edit, but it also hides details that matter during handoff.

Properties conversion risks and review checks
Risk	Why It Happens	Review Check
Duplicate key	The same decoded key appears again later in the text.	Confirm which value should win before using converted output.
Unexpected type	Java properties are strings, while JSON and YAML can carry numbers and booleans.	Check numeric-looking IDs, `true`, `false`, and quoted values in Schema Map.
Changed path shape	Dotted names look hierarchical even when the original format treats them as one key.	Compare Path Preview before using INI, env, or normalized properties output.
Lost formatting	Comments, blank lines, separator style, and spacing are not part of the parsed value map.	Treat generated properties text as normalized review text, not a byte-for-byte round trip.

Names such as server.port and database.url look like paths, yet ordinary properties parsing treats them as flat keys. JSON, YAML, INI, and environment-variable naming all add their own ideas about nesting, sections, quoting, and separators. A converted result can be syntactically valid while still being a poor fit for the parser or application that will consume it.

A useful properties conversion therefore starts with inspection. Duplicates, escaped characters, inferred types, flattened paths, and generated names should be checked before the converted text replaces a working configuration. The final destination still gets the last word, because shells, YAML readers, INI parsers, and custom applications can each apply different rules.

How to Use This Tool:

Use the converter as a review step before handing Java-style properties text to JSON, YAML, INI, env, or another normalized properties file.

Paste text into .properties content, choose one supported .properties, .conf, or .txt file with Browse file, drop a file on the editor, or use Sample.
Check the summary before copying a converted format. Parsed key count, scalar count, path style, available formats, and warning badges show whether the input produced usable review data.
Open Advanced when the destination needs different JSON spacing, YAML indentation, YAML line width, sorted YAML keys, scalar quoting, YAML anchor handling, path style, preview size, env prefix, or env key casing.
Use Conversion Ledger to review top-level keys, nested key count, scalar count, sample keys, sample values, and maximum depth.
Compare Path Preview and Schema Map when dotted keys, bracketed paths, duplicate keys, or inferred types could affect the handoff.
Copy or download the specific format that matches the destination. Use table exports for the ledger, path preview, or schema map when reviewers need the audit data alongside the converted text.

If the result reports No properties detected or warns about an empty key, fix the first non-comment line, separator, or escape sequence before using the output tabs.

Interpreting Results:

The review data is usually more important than the prettiest converted text. JSON or YAML can look valid while a duplicate key has replaced an earlier value, a quoted string has become unquoted, or an environment-variable name has collapsed punctuation into a broader name.

Duplicate key warnings mean the same decoded key appeared more than once. The later value is used in the final converted views.
Path Preview shows flattened paths for review and export. Dot style uses bracket notation when a key is not a simple identifier.
Schema Map groups each observed path with inferred type, document count, and an example value. Use it to find unexpected numbers, booleans, strings, nulls, arrays, or objects.
Preview trimmed means the on-page path table stopped at the selected preview limit. Copy and export actions still use the full flattened path set.
Properties Config is normalized from parsed paths. It does not restore comments, spacing, original separator choice, or every original key-spelling choice.

A clean result means the text parsed and serialized under the selected settings. It does not prove that the converted form will be accepted by a shell, YAML reader, INI parser, or custom application without its own validation.

Technical Details:

Java properties parsing is line oriented. A natural line is one physical line from the text stream, while a logical line can span several natural lines when an odd number of trailing backslashes escapes the line break. Blank lines are ignored, and a comment starts when the first non-whitespace character is # or !.

Key parsing stops at the first unescaped =, :, space, tab, or form-feed character. Whitespace around the separator is skipped, and the remaining text becomes the value. Escapes are decoded for keys and values, including tab, newline, carriage return, form feed, escaped separators, escaped spaces, and valid four-hex-digit Unicode escapes.

Transformation Core:

The parsed document starts as one flat key-value map. Review paths and destination formats then present that map in different shapes, but the original properties file did not create nested objects merely because a key contained dots.

Properties parsing and conversion rules
Rule	How It Works	Review Cue
Line continuation	An odd number of trailing backslashes joins the next physical line after leading whitespace is removed.	A long value should appear as one value, not as separate keys.
Separator detection	The first unescaped equals sign, colon, or whitespace separator divides key and value.	Keys that contain spaces, colons, or equals signs need escaping in the original text.
Escape decoding	Common Java-style escapes and valid `\uXXXX` sequences are decoded before converted output is built.	Unicode and whitespace escapes should be checked in path and preview rows.
Type inference	Quoted values stay strings, unquoted `true` and `false` become booleans, and simple decimal numbers become numbers.	Codes such as `00127` should be quoted if leading zeroes must remain visible.
Duplicate keys	A later decoded key replaces an earlier value for the same key.	Treat every duplicate-key badge as a merge-review item.

Output Semantics:

Each output format answers a different handoff question. JSON and YAML keep typed scalar values, INI groups normalized paths into sections where possible, env output creates shell-style names, and review tables expose the parsed shape without requiring the reader to scan a large text block.

Properties output views and interpretation limits
View	Basis	Main Limit
JSON	Serializes the parsed map with the selected spacing.	Inferred numbers and booleans are no longer string values.
YAML Config	Serializes the parsed map with selected indentation, wrapping, sorting, quoting, and anchor options.	Plain scalars may be interpreted by YAML readers, so quoting can be safer for string-like codes.
INI Config	Uses the first normalized path segment as a section when a path has multiple segments.	Deep or unusual keys may be flattened more than a hand-written INI file would be.
ENV Variables	Turns scalar paths into environment-style names with optional prefix and casing control.	Punctuation collapses to underscores, so similar paths can become similar names.
Path Preview and Schema Map	List flattened paths, inferred types, examples, and document counts for review.	They describe the parsed view, not a runtime-specific configuration model.

Repeat comparisons are most reliable when the same settings stay fixed: JSON spacing, YAML indent and line width, YAML sorting, YAML quoting, anchor handling, path style, env prefix, env casing, and preview limit. If those settings change between runs, a visible diff may come from formatting rather than a real configuration change.

Limitations and Privacy Notes:

This conversion is meant for inspection, cleanup, and handoff. It is not a complete compatibility test for every shell, JSON parser, YAML parser, INI parser, or application-specific configuration loader.

Java's native properties API treats keys and values as strings; typed JSON and YAML output is a conversion choice for review and downstream formats.
Comments, blank lines, original separator style, original order assumptions, and most formatting choices do not survive normalized output.
Only one selected text file is read at a time, and empty or comment-only input produces No properties detected.
Pasted text and selected files are parsed in the browser. Secrets still need care while they are visible, copied, downloaded, or shared.
Test the copied output in the destination parser before replacing a working configuration file.

Worked Examples:

Service settings for release review

With server.port=8443, logging.level=INFO, and feature.alpha=true, the ledger should show three keys and three scalar values. JSON and YAML output will treat 8443 as a number and true as a boolean, while env output can create names such as SERVER_PORT and FEATURE_ALPHA.

Duplicate value after a merge

If timeout=30 appears near the top and timeout=60 appears later, the duplicate-key warning is the important result. The final output views use 60. Review the original lines before deciding whether the replacement was intentional.

A key that contains punctuation

A key such as path.with\ spaces=/srv/example app decodes the escaped space before path output is built. In dot path style, punctuation may produce bracketed notation; in env output, punctuation collapses toward underscores. Check the path row before using the generated name in a deployment environment.

A numeric-looking identifier

build.code=00127 is inferred as a number unless it is quoted for conversion review. If leading zeroes matter, use quotes in the properties text and check Schema Map before copying JSON or YAML.

A file with only comments

Blank lines and lines that start with # or ! after whitespace are ignored. A file made only from those lines produces No properties detected; add a real key-value line before expecting output tabs to fill.

FAQ:

Does server.port become nested JSON?

No. The properties text is parsed as a flat key-value map, so server.port remains one key. Path Preview and env output may display a flattened review name, but that does not mean the original key was nested.

Why did a value become a number or boolean?

Unquoted true, false, and simple decimal numbers are inferred as typed values for converted output. Quote values that must remain string-like, especially identifiers with leading zeroes.

What does a duplicate-key warning mean?

The same decoded key appeared more than once. The later value replaced the earlier value in the final JSON, YAML, INI, env, properties, path, and schema output.

Why is the visible path table shorter than my file?

The on-page table respects Path preview limit so large inputs stay readable. Increase the limit up to the allowed maximum when you need more rows on screen, or use table export for the full path set.

Can I replace my original file with Properties Config?

Treat it as normalized review text, not a guaranteed round trip. It can change comments, spacing, separators, and path spelling, so test it in the destination application before replacing a working file.

Is pasted configuration sent to a server?

The parsing and conversion run in the browser for pasted text and selected files. Secrets still need care because they may remain visible on screen, in the clipboard, or in downloaded files.

Glossary:

Natural line: One physical line in the text stream.
Logical line: The complete key-value line after any continued lines have been joined.
Scalar value: A single non-object value such as text, a number, a boolean, null, or an empty string.
Path Preview: The flattened list of paths, inferred types, and shortened value previews.
Schema Map: A grouped view of paths, observed types, document counts, and example values.
Env prefix: Optional text added before generated environment-style names.

References:

Properties, Oracle, Java SE 26 API.
RFC 8259: The JavaScript Object Notation (JSON) Data Interchange Format, RFC Editor, December 2017.
YAML Ain't Markup Language (YAML) Version 1.2.2, YAML Language Development Team, October 1, 2021.