.properties

.properties is a file extension for files mainly used in Java-related technologies to store the configurable parameters of an application. They can also be used for storing strings for Internationalization and localization; these are known as Property Resource Bundles.

Each parameter is stored as a pair of strings, one storing the name of the parameter (called the key), and the other storing the value.

Unlike many popular file formats, there is no RFC for .properties files and specification documents are not always clear, most likely due to the simplicity of the format.

Format
Each line in a .properties file normally stores a single property.  Several formats are possible for each line, including key=value, key = value, key:value, and key value. Single-quotes or double-quotes are considered part of the string.  Trailing space is significant and presumed to be trimmed as required by the consumer.

Comment lines in .properties files are denoted by the number sign (#) or the exclamation mark (!) as the first non blank character, in which all remaining text on that line is ignored.  The backwards slash is used to escape a character. An example of a properties file is provided below.

# You are reading a comment in ".properties" file.
! The exclamation mark can also be used for comments.
# Lines with "properties" contain a key and a value separated by a delimiting character.
# There are 3 delimiting characters: '=' (equal), ':' (colon) and whitespace (space, \t and \f).
website = https://en.wikipedia.org/
language : English
topic .properties files
# A word on a line will just create a key with no value.
empty
# White space that appears between the key, the value and the delimiter is ignored.
# This means that the following are equivalent (other than for readability).
hello=hello
hello = hello
# Keys with the same name will be overwritten by the key that is the furthest in a file.
# For example the final value for "duplicateKey" will be "second".
duplicateKey = first
duplicateKey = second
# To use the delimiter characters inside a key, you need to escape them with a \.
# However, there is no need to do this in the value.
delimiterCharacters\:\=\ = This is the value for the key "delimiterCharacters\:\=\ "
# Adding a \ at the end of a line means that the value continues to the next line.
multiline = This line \
continues
# If you want your value to include a \, it should be escaped by another \.
path = c:\\wiki\\templates
# This means that if the number of \ at the end of the line is even, the next line is not included in the value. 
# In the following example, the value for "evenKey" is "This is on one line\".
evenKey = This is on one line\\
# This line is a normal comment and is not included in the value for "evenKey"
# If the number of \ is odd, then the next line is included in the value.
# In the following example, the value for "oddKey" is "This is line one and\#This is line two".
oddKey = This is line one and\\\
# This is line two
# White space characters are removed before each line.
# Make sure to add your spaces before your \ if you need them on the next line.
# In the following example, the value for "welcome" is "Welcome to Wikipedia!".
welcome = Welcome to \
          Wikipedia!
# If you need to add newlines and carriage returns, they need to be escaped using \n and \r respectively.
# You can also optionally escape tabs with \t for readability purposes.
valueWithEscapes = This is a newline\n and a carriage return\r and a tab\t.
# You can also use Unicode escape characters (maximum of four hexadecimal digits).
# In the following example, the value for "encodedHelloInJapanese" is "こんにちは".
encodedHelloInJapanese = \u3053\u3093\u306b\u3061\u306f
# But with more modern file encodings like UTF-8, you can directly use supported characters.
helloInJapanese = こんにちは

In the example above,  (line 5) would be a key, and its corresponding value would be . While the number sign (#) and the exclamation mark (!) marks text as comments, it has no effect when it is part of a property. Thus, the key  (line 37) has the value  and not ! All of the whitespace in front of line 38 is excluded.

Before Java 9, the encoding of a .properties file is ISO-8859-1, also known as Latin-1. All non-ASCII characters must be entered by using Unicode escape characters, e.g. \uHHHH where HHHH is a hexadecimal index of the character in the Unicode character set. This allows for using .properties files as resource bundles for localization. A non-Latin-1 text file can be converted to a correct .properties file by using the native2ascii tool that is shipped with the JDK or by using a tool, such as po2prop, that manages the transformation from a bilingual localization format into .properties escaping.

An alternative to using unicode escape characters for non-Latin-1 character in ISO 8859-1 character encoded Java *.properties files is to use the JDK's XML Properties file format which by default is UTF-8 encoded, introduced starting with Java 1.5.

Another alternative is to create custom control that provides custom encoding.

In Java 9 and newer, the default encoding specifically for property resource bundles is UTF-8, and if an invalid UTF-8 byte sequence is encountered it falls back to ISO-8859-1.

Editing

Editing .properties files is done using any text editor such as those typically installed on various Operating Systems including Notepad on Windows or Emacs, Vim, etc. on Linux systems.

Third-party tools are also available with additional functionality specific to editing .properties files such as:
 Data Validation
 Creating new keys
 Synchronization of key names
 Automatic bi-directional conversion of non-ASCII symbols to support non-Latin languages
 Integration with Eclipse

Non-Java uses and exceptions 
Apache Flex uses .properties files as well, but here they are UTF-8 encoded.

In Apache mod_jk's uriworkermap.properties format, an exclamation mark ("!") denotes a Negation operator when used as the first non blank character in a line.

Perl CPAN contains Config::Properties to interface to a .properties file.

SAP uses .properties files for localization within their framework SAPUI5 and its open-source variant OpenUI5

There are many Node.js (JavaScript/TypeScript) options available on Npm's package manager.

PHP also has many package options available.

See also
 XML, JSON and YAML are used by some for more complex configuration formats.

References

External links
 - gives the precise semantics of well-formed Java property files
 - describes property resource bundles
 - explains Java properties in a simple XML format.
MultiProperties - It is an Eclipse plugin for editing multiple key-value based files with similar content. This kind of file format can be Properties for example in Java programming language, which is frequently used for backing a ResourceBundle.
Bracket Properties - a refresh of the Properties concept while keeping the ubiquitous .properties file format intact.
Java Properties Editor (Application + Eclipse plugin) - useful utility to view and to edit properties files in a whole project.
DOKSoft Properties Editor Eclipse plugin  - i18n tool for installing into Eclipse IDE.
Message Editor - it manages i18n for Java application. It generates XML property files. It includes two stylesheets for .properties and .xml property generation at compile time (Ant based.)
JLokalize - open source Java properties editor with reversal function and spell check
Config::Properties - Perl CPAN.
Jackson Properties module is a library that allows mapping Properties file contents into Java Objects and back, similar to how XML and JSON is commonly mapped
SAPUI5 - Use of Localized Texts in Applications

Properties
Configuration files
Java (programming language)
PROPERTIES