This page documents details on JOSM's ​MapCSS implementation. This is used for the following features in JOSM:

• Mappaint styles
• Validator rules (Tag checker)
• Search dialog

General Structure

A MapCSS style sheet has rules of the form

selector {
    prop: value;
    /* ... */
    prop: value;
    /* and/or */
    set: class;
    set: .class;
}

The algorithm to find the styles for a given object is like this:

 - for each rule:
     if the selector applies, set the properties from the { } block
 - analyze the final list of properties and generate styles from it

MapCSS uses the comment format of CSS (/* ... */). Note that when commenting out large parts of a MapCSS file, some constructs may cause an unexpected end of the comment, for instance:

/*
*[highway][name =~ /^R(\.|:)? .*/] { /* the end of the regular expression defines the unexpected end of the comment */
        throwWarning: tr("foo");
}
*/

Selectors

Selectors denote the filter expressions of a MapCSS rule. The rule is only applied to a map object, if its selectors match with the object.

Selectors in MapCSS are different from standard CSS for the web. MapCSS only supports a subset of the standard CSS selectors, but extends them with additional selectors required for OSM data.

Some basic examples:

/* applied to ways with a tag highway=residential */
way[highway=residential] {  /*  the styles */}

/* applied to new, closed ways on layer 1, provided they have the tag amenity=parking and access=public, and provided 
 * the zoom level is between 11 and 14 
 */
way|z11-14[amenity=parking][access=public]:closed:new::layer_1 {...}


area[amenity=parking][access=public], area[amenity=parking][!access] {...}
relation[type=route][route=foot] > way::relation_underlay {..}

The different elements (type-, zoom- , condition selector, pseudo classes, layer identifier, grouping and child combinator) are explained below.

Type selector

Selector	Description
*	Matches with any object
node, way, relation	Matches with the osm objects of the given type.
area	Matches with any area regardless of whether the area border is only modelled with a single way or with a set of ways glued together with a relation. area[natural=beach] {...} /* ... is equal to ... */ way[natural=beach], relation[type=multipolygon][natural=beach] {...} Note that area selects unclosed ways as well, so it may be useful to add the :closed pseudo class. The JOSM Validator will give a warning for unclosed ways that have an area style.
meta	The meta selector starts a special rule that should stand at the beginning of the file. It gives some general information on the style sheet. All software that supports MapCSS should be able to parse this sections without errors, so do not use exotic syntax extensions in this part. meta { title: "Parking lanes"; /* title shown in the menu */ icon: "logo_16x16x8.png"; /* small icon shown in the menu next to the title */ version: "1.2"; /* the version of the style */ description: "..."; /* one or two sentences of describing the style */ author: "..."; /* the author(s) of the style */ link: "https://..."; /* URL to the web page of the style */ min-josm-version: 6789; /* the minimum JOSM version where this style works */ }
canvas	Some style information not specific to nodes, ways or relations. canvas { fill-color: #ffffea; /* the former background-color is deprecated since r7110 */ default-points: false; default-lines: false; } Key Description Value Format Default Value fill-color Specifies the overall fill/background color (background-color is deprecated since r7110). Color black default-points Whether default point style should be added to nodes where no style applies. Boolean true default-lines Whether default line style should be added to ways where no style applies. Boolean true

Child selector

If a node is part of a way, we say that it is a child of this way. Similarly, if a node, a way, or a relation is a member of a relation, we say, that it is a child of this relation.

In MapCSS you can use a child selector which matches only if both the parent and the child object match.

Example:

/*
 * only matches for a way which is a child of a relation with tags 
 * type=route and route=foot
 */
relation[type=route][route=foot] > way {...}

Notes:

• Zoom selector and Layer identifier are only relevant for the part to the right of the > sign.
• The functions prop() and is_prop_set() are only supported on the right side of the > sign.
• The functions parent_tag and parent_tags (see below) can be used to access tags from the parent(s).
• For compatibility with the MapCSS 0.2 standard, relation[type=route][route=foot] way {/*...*/}, without the greather-than-sign > is supported, too. However, no #Linkselector may be specified in this case.

Parent selector

In addition to child selectors, JOSM supports the notion of a parent selector. Note, that parent selectors are a JOSM-specific extension of MapCSS not present in other MapCSS implementations.

Similar to a child selector, a parent selector only matches if both the parent and the child object match. In contrast to the child selector, the character < is used.

In contrast to the child selector, the parent object will be "selected". In other words, the properties in the {...}-Declaration Block apply to the object on the right hand side of the "<" sign.

Example:

/*
 * matches for a highway which has at least one node tagged as traffic_calming=*
 */
node[traffic_calming] < way[highway] {...}

Condition selector

Selectors can include a set of conditions. If any of these conditions evaluates to false, the selector doesn't match and the style rule isn't applied.

An attribute condition specifies a condition on a tag of an OSM object.

Operator	Description	Example
=	Exact match of the value.	way[highway=residential] /* is case sensitive, i.e. does NOT match e.g. highway=Residential or Highway=residential */ node[name="My name"] /* use quotes if key or value includes spaces */ node["name:ru"="Калининград"] /* use quotes if key or value includes special characters like colons or unicode characters */
!=	Value not equal	way[highway!=residential] node[name!="My name"] node["name:ru"!="Калининград"]
<, >, <=, >=	Comparision for numeric values.	node[population >= 50000] /* population greater than or equal to 50000 */ node[ele = 3000] /* elevation with exactly 3000 meters */
^=	Prefix match	node[name ^= "myprefix"] /* value starts with 'myprefix' */
$=	Postfix match	node[name $= "mypostfix"] /* value ends with 'mypostfix' */
*=	Substring match	node[name *= "my substring"] /* value contains the substring 'my substring' */
~=	List membership	*[vending~=stamps] /* the tag value for the tag 'vending' consists of a list of ;-separated values */ /* and one of these values is 'stamps' */
=~	​Regular expression match	*[name=~/^My_pattern.*/] /* the value of the tag 'name' matches with the regular expression '^My_pattern.*' */ /* Note, that reqular expressions have to be enclosed in /.../ */ Case-insensitive matching can be enabled via the embedded flag expression (?i) (see ​Pattern.CASE_INSENSITIVE). *[name =~ /^(?i)(parking)$/] /* matches parking, Parking, PARKING, PaRkInG,... */ *[name =~ /^(?U)(\p{Lower})+$/] /* name consists of only lower case unicode characters */
!~ (since r6455)	negated ​Regular expression match	*[surface!~/paved|unpaved/]
∈ (​U+2208, since r6609)	element of Matches when an object matches the right selector(s) contains at least one element which match the left selector(s).	*[amenity=parking] ∈ area[amenity=parking] { throwWarning: tr("{0} inside {1}", "amenity=parking", "amenity=parking"); } Finds areas with amenity=parking that contain at least one node or area with amenity=parking. Since r15064 this rule produces one warning for each element on the left when there are multiple matches.
⊆ (​U+2286, since r15102)	Subset of or Equal To Synonym for ∈.	*[amenity=parking] ⊆ area[amenity=parking] { throwWarning: tr("{0} inside {1}", "amenity=parking", "amenity=parking"); }
⊇ (​U+2287, since r15102)	Superset of or Equal To Matches when an object matches the right selector(s) and is contained in one or more elements which match the left selectors.	area[amenity=parking] ⊇ *amenity=parking] finds nodes or areas with amenity=parking inside areas with amenity=parking. Slower than ⊆ and thus not useful in validator rules, but can be useful in the search dialog.
⊈ (​U+2288, since r15102)	Neither a Subset of nor Equal To Matches when an object matches the right selector(s) and does not contain any element which matches the left selectors.	*[highway=street_lamp] ⊈ area:closed2[amenity=parking][lit=yes] finds areas amenity=parking that have lit=yes but don't contain a lamp. Always add :closed2 to avoid false positives as unclosed areas never contain something.
⊉ (​U+2289, since r15102)	Neither a Superset of nor Equal To Matches when an object matches the right selector(s) and is not contained in any area which matches the left selectors.	area[landuse=residential] ⊉ *[building] finds buildings which are not inside any landuse=residential area. Note that this operator is likely to produce false positives when you have landuse=residentialareas which don't match :closed2.
⧉ (​U+29C9, since r6613)	crossing	area:closed:areaStyle ⧉ area:closed:areaStyle { throwOther: tr("Overlapping Areas"); } takes layer tag into account if set (since r12986)

Since r6554, it is possible to prefix the "value" (i.e., expression after the operator) with a * in order to "de-reference" it (i.e., obtain consider it as another key and obtain its value). Thus, [key1 = *key2] or [key1=*key2] compares the value of key1 with the value of key2, and [key =~ */pattern/] considers the value of the key pattern as a regular expression and matches it against the value of key.

In addition, you can test whether a tag is present or not:

Condition	Example
Presence of tag	way[highway] /* matches any way with a tag 'highway' (is case sensitive) */ way["name:fr"] /* use quotes if the tag name includes special caracters (white space, colons, unicode characters, etc.) */
Absence of tag	way[!highway] /* matches any way which does not have a tag 'highway' (is case sensitive) */ way[!"name:fr"] /* use quotes if the tag name includes special caracters (white space, colons, unicode characters, etc.) */
Presence of tag by ​Regular expression match (since r6547)	way[/^addr:/] /* matches any `addr:*` key */
Absence of tag by Regular expression match	way[!/^addr:/] /* matches any way which does not have a tag 'addr:*' */

You can test whether the value of a tag is logical truth value. The value is evaluated to true, if it is either "yes", "true", or "1". All other values are evaluated to false.

Condition	Example
Testing for truth value	way[oneway?] /* matches any way with a truth value in the tag 'oneway' */
Testing for false value (since r6513)	way[oneway?!] /* matches any way with a false value in the tag 'oneway' */

Territory selector

You can test whether an object is located inside or outside of a specific territory. JOSM has an internal database for this. The territories file is an osm file and can be downloaded here and opened in JOSM to investigate it (screenshot preview)​. It contains borders of all countries of the world. Due to performance reasons the borders are simplified. They can be refined for special cases on request. The territories are "tagged" with their ​ISO_3166-1_alpha-2 codes. USA, Canada, China, India and Australia have additional boundaries for their subdivisions. See the following examples on how to use the territory selectors. Territory selectors are less useful in mappaint styles and can be very resource heavy there. However they are much more useful for mapcss based validator rules. To select territories with left-hand-traffic or right-hand-traffic, there is a simpler way, see #PseudoClasses. See #10387 for main implementation of this feature.

node[inside("FR")]                    /* matches any node located inside of France (this includes all the overseas territories)                                     */
node[inside("FX")]                    /* matches any node located inside of Metropolitan France (i.e. only the mainland part with its near islands including Corse) */
node[inside("EU")]                    /* matches any node located inside of the European Union                                                                      */
node[inside("FR,DE")]                 /* matches any node located inside of France __OR__ inside of Germany                                                         */
node[inside("US-FL")]                 /* matches any node located inside of the US state Florida                                                                    */

node[outside("FR")]                   /* matches any node located outside of France                                                                                 */
node[outside("FR,DE")]                /* matches any node located outside of France __AND__ outside of Germany                                                      */
node[inside("US")][outside("US-FL")]  /* matches any node located inside of the USA except the state Florida                                                        */

Link selector

In a child selector, you can formulate conditions on the link between a parent and a child object.

If the parent is a relation, you can formulate conditions for the role a member objects has in this relation.

relation[type=route] >[role="link"] way {  /* matches any way which is a member of route relation with role 'link' */ 
   color: blue;
}

Operator	Description	Example
=	Exact match of the role name. The name name role is compulsory in this context.	relation >[role=residential] way relation >[role="My name"] way /* use quotes if the role value includes spaces or other special characters */

The operators !=, ^=, $=, *=, and ~= are supported too. Please refer to condition selector operators.

Nodes in ways and members in relations are ordered. You can formulate conditions on the position of a node in a way or a member object in a relation. Positive numbers count from first to last element, negative numbers (since r8236) count from last to first element.

relation[type=route] >[index=1] way {  /* matches the first way which is a member of route relation  */ 
   color: blue;
}

way >[index=-1] node {  /* matches the last node of a way  */ 
   symbol-stroke-color: green;
}

way!:closed >[index=1] node!:connection,
way!:closed >[index=-1] node!:connection {  /* matches all single way end nodes */ 
   symbol-stroke-color: green;
}

Zoom selector

You can decorate a type selector with a zoom selector. The zoom selector restricts the range of zoom levels at which the respective MapCSS rule is applied.

Example	Description
way|z12 {...}	At zoom level 12
way|z13-15 {...}	From 13 to 15
way|z16- {...}	16 and above
way|z-12 {...}	12 and below
way {...}	any zoom level

The precise definition of scale ranges for each zoom level may change in the future. By rule of thumb you can expect to be approximately at zoom level n when imagery displays slippymap tiles of level n.

Pseudo Classes

See Javadoc for the up-to-date list of pseudo classes supported by JOSM's MapCSS implementation.

:closed	true for ways where the first node is the same as the last and for any (completely downloaded) multipolygon relation
:closed2	same as above, but this one ignores if a multipolygon is downloaded completely (since r9099)
:completely_downloaded	true for a relation whose members are all downloaded (since r9099)
:new	all new objects
:connection	true for nodes that are used by more than one way
:unconnected	true for nodes that are not used by any way (since r6687)
:tagged	What JOSM considers tagged, i.e. an object that with a tag key other than the following: source*, source_ref, note, comment, converted_by, created_by, watch*, fixme, FIXME, description, attribution (version r4008; in this list, * is a glob)
:righthandtraffic	true if there is right-hand traffic at the current location (since r7193); see left-right-hand-traffic for screenshot of areas
:clockwise	Whether the way is closed and oriented clockwise, or non-closed and the 1st, 2nd and last node are in clockwise order.
:anticlockwise	Whether the way is closed and oriented anticlockwise, or non-closed and the 1st, 2nd and last node are in anticlockwise order.
:unclosed_multipolygon	true for fully loaded unclosed multipolygon relations (since r8252)
:open_end	to select end nodes of unclosed multipolygon relations with relation:unclosed_multipolygon >:open_end node (since r8252)
:in-downloaded-area	true if an object is within source area and false if in the hatched area (since r8495).
:selected	true if an object is selected in the editor (since r9341).
:modified	changed objects (since r7193).

You can also negate pseudo classes. E.g. !:new for all old objects.

Layer Identifier

Layers can be used to create more than one style for a single object. Here is an example:

way[highway=secondary] {
    width: 3;
    color: yellow;
}

way[highway=tertiary] {
    width: 2;
    color: orange;
}

way[access][access!=public]::non_public_access_layer {
    width: +2; 
    color:red; 
    dashes: 2; 
    object-z-index:-1.0;
}

way[bridge]::bridge_layer {
    width: +3; 
    color:#000080;
    opacity:0.5;
    object-z-index:1.0; 
}

This draws all secondary and tertiary roads in yellow and orange respectively. Any road with an access tag other than public will get an extra line style below (object-z-index:-1.0;) the main line. If that part of the street happens to be a bridge, it will also get a half transparent blue overlay. The relative width value (width: +2;) refers to the width on the default layer (2 or 3 in this case).

The name for the layer can be any identifier.

If you omit the layer in the selector, this is the same as using ::default.

One more example:

node[amenity=parking] {
    icon-image: "presets/vehicle/parking/parking.svg";    /* displays the josm internal parking icon in the default layer */
    text: ref;                                            /* displays the value of the key ref as text in the default layer */
}

node[amenity=parking][fee=yes]::fee {
    icon-image: "presets/money/exchange.svg";             /* displays the josm internal exchange icon in the fee layer */
    icon-offset-x: 14;                                    /* shift the icon */
    icon-offset-y: -12;                                   /* shift the icon */
    text: charge;                                         /* displays the value of the key charge as text in the fee layer */
    text-offset-x: 16;                                    /* shift the text */
    text-offset-y: 17;                                    /* shift the text */
}

The result looks this way:

In addition, you can use the * layer to override and initialize all layers.
It overrides all existing subparts, so

way::A { a; } 
way::B { b; } 
way::* { c; } 

is equivalent to

way::A { a; } 
way::B { b; } 
way::A { c; } 
way::B { c; }

And it initializes new subparts. In other words:

way::* { a; } 
way::A { b; } 

is equivalent to

way::A {} 
way::* { a; } 
way::A { b; } 

which is in turn the same as

way::A { a; } 
way::A { b; } 

or

way::A { a; b; }

Grouping

Rules with common declaration block can be grouped into one:

area[landuse=forest] { color: green;   width: 2; }
area[natural=wood] { color: green;   width: 2; }

is the same as

area[landuse=forest], area[natural=wood] { color: green;   width: 2; }

Classes

You may assign classes to matched elements, and define other selectors using those classes:

/* assigning classes */
selector {
  set class;
  /* or equivalently */
  set .class;
}

/* matching classes */
way.class, node[foo=bar].class {
  /* ... */
}

Example for assigning/matching a class named path:

way[highway=footway] { set path; color: #FF6644; width: 2; }
way[highway=path]    { set path; color: brown; width: 2; }
way.path { text:auto; text-color: green; text-position: line; text-offset: 5; }

You can also negate classes. E.g. way!.path for all ways, which are not part of the class .path.

@supports rule for conditional processing [since 8087]

@supports rules are used to skip a section of the style under certain conditions. Typically you want to use a feature which is introduced in a newer version of JOSM, but like to have a fall back style for users of older JOSM clients. Example:

@supports (min-josm-version: 9789) {
    way[highway] {
        width: 4;
        color: orange;
    }
    /* fancy new stuff */
    /* ... */
}

@supports (max-josm-version: 9788) {
    way[highway] {
        width: 4;
        color: blue;
    }
    /* fall back mode, using more simple features */
    /* ... */
}

@supports (icon-offset-x) {
    /* only if icon-offset-x property is supported */
    node[amenity] {
        icon-offset-x: 5;
    }
}

The syntax closely matches the official ​css syntax. The following conditions are supported:

Condition	Description
(<mapcsskey>)	Check if a certain mapcss key is supported, e.g. repeat-image or icon-offset-x.
(min-josm-version: <number>)	Only include @supports section when the current version of JOSM is greater than or equal to the specified number.
(max-josm-version: <number>)	Only include @supports section when the current version of JOSM is lower than or equal to the specified number.
(user-agent: <string>)	Only include @supports section when the name of the editor / renderer matches the given string. In JOSM, the only accepted value is josm.

Conditions can be combined with and:

@supports (min-josm-version: 8087) and (max-josm-version: 8200) {
 /* only for JOSM versions 8087 to 8200 */
}

Other logical operators like or and not can also be used. Parentheses are needed if you want to combine different logical operators:

@supports ((min-josm-version: 8087) and (max-josm-version: 8200)) or (user-agent: myEditor) {
  /* for JOSM version 8087 to 8200 and for the editor called "myEditor" */
}

Since @supports rules are only supported in JOSM 8087 and later, you should also specify this as minimum JOSM version in the meta selector:

meta {
    min-josm-version: "8087"; /* This style uses @supports rules */
    /* ... */
}

Style settings

Styles settings are used to provide the user settings to customize a mappaint style. The user can use them in the MapPaint dialog. Style settings are availible since r7450. The internal style provides style settings since r7454. Note that there are plans to extend the implementation of style settings (currently there are only boolean values supported), so the mapcss syntax for style settings could change in the future (see #10435).

create a setting:

setting::highway_casing {
  type: boolean;
  label: tr("Draw highway casing");
  default: true;
}

use a setting:

way[highway][setting("highway_casing")] {
  casing-width: 2;
  casing-color: white;
}

Properties

General properties

Key	Description	Value Format	Default Value
z-index	Specify the order the objects are drawn: The objects with higher z-index are drawn on top of objects with lower z-index	Number (can be negative)	0
major-z-index	Similar to z-index, but it has higher priority than z-index. So if one object has a higher major-z-index than the other, it is drawn on top. If the major-z-index is the same, z-index decides.	Number (can be negative)	Depends on style element: area: 1, casing: 2, left-/right-casing: 2.1, line-pattern: 2.9, line: 3, point: 4, default-point: 4.1, line-text: 4.9, point-text: 5
object-z-index	Similar to z-index, but has lower priority. Controls the painting order for overlapping objects. E.g. for two crossing ways with text: Use z-index or major-z-index if you first want to draw the two lines and then the two captions. Use object-z-index if one of the ways should be completely on top of the other.	Number (can be negative)	0
modifier	Better control, whether a default line / node symbol is generated by JOSM. This happens when there is no proper style (modifier=false) found on any layer.	false or true	false for the default layer and true for any other layer

Note that due to performance reasons the values for the three z-indexes are limited to 24 bit float values with max. 5 decimal digits. Currently the internal mappaint style uses values with max. 2 digits before and after the decimal separator. To avoid problems use values of z-indexes between -99.999 and +99.999. (See also #14485)

Icon and symbol styles

Key	Description	Value Format	Default Value
icon-image	The icon at node position. See also Images.	Image	-
icon-opacity	Opacity of the icon image	Opacity	1.0
icon-width	Width of the icon. If only one of the properties icon-width and icon-height is given, the image will be scaled proportionally. The icon will keep the original size, if neither icon-width nor icon-height is set.	Number	-
icon-height	Height of the icon. (See icon-width)	Number	-
icon-offset-x	Shift the icon in horizontal direction (positive values to the right) (since r8085)	Number	0
icon-offset-y	Shift the icon in vertical direction (positive values downwards) (since r8085)	Number	0
icon-rotation	Rotate the icon clockwise or anti clockwise (negative value)(since r8260)	[rad], [rad]rad, [deg]°, [deg]deg, [grad]grad, [turn]turn (​definition) or a cardinal direction (e.g. northeast or sw); See also the functions degree_to_radians, cardinal_to_radians.	-
icon-position	Define the position of the icon for areas. Same as text-position (since r11730).	center, inside, line	center
symbol-shape	Display a symbol at the position of the node	square, circle, triangle, pentagon, hexagon, heptagon, octagon, nonagon, decagon	-
symbol-size	Size of the symbol	Number, can be relative ("+4")	10
symbol-stroke-width	outline stroke width	Width	1.0 if symbol-stroke-color is set
symbol-stroke-color	line color	Color	#FFC800 if symbol-stroke-width is set
symbol-stroke-opacity	line opacity	Opacity	1.0
symbol-fill-color	fill color for the shape	Color	blue, unless either symbol-stroke-width or symbol-stroke-color is set
symbol-fill-opacity	fill opacity	Opacity	1.0
text-..., font-...	general text & font properties
text-anchor-horizontal	horizontal text label placement	left, center, right	right
text-anchor-vertical	vertical text label placement	above, top, center, bottom, below	bottom

Do not rely on the default values for symbol-... properties (except for opacity). They are intended for "quick & dirty" style sheets and should be set to an explicit value.

Line styles

Key	Description	Value Format	Default Value
width	Line width	Width	-
color	Line color	Color	value of fill-color or (if unset) JOSM's default untagged color (#808080)
opacity	How transparent the line is.	Opacity	1.0
dashes	An array of alternating on/off lengths	list of numbers, e.g. > 15, 5 may be written as expression: > list(3, 4, 5, 6) or the keyword none to turn dashes off	-
dashes-offset	shift the dash pattern by a certain amount	Number (>= 0)	0
dashes-background-color	The color to use in between the dashes (optional)	Color	-
dashes-background-opacity	Opacity value for the dashes background	Opacity	value of opacity
linecap	Shape at the end of the line (see ​here)	none, round, square	none
linejoin	Shape at the line corners	round, miter, bevel	round
miterlimit	Applies for linejoin: miter. Sets the maximum overshoot when line segments meet at a very small angle	Number (>= 1.0)	10.0
offset	Move line to the left or right (when looking in way direction). This could be used to draw multiple lanes for one way or mark left and right side of a way differently.	Number (positive value moves line to the left, negative to the right)	0
text-position	set to line, if text should be drawn along the line	line, center	-
text-..., font-...	general text & font properties
repeat-image	repeated image along a line [since 5801]	Image	-
repeat-image-width	Width of the image (optional, see icon-width) [since 5811]	Number	-
repeat-image-height	Height of the image (optional) [since 5811]	Number	-
repeat-image-align	Alignment of the image. Top-, bottom edge or the (horizontal) center line of the image will be along the line [since 5801]	top, center, bottom	center
repeat-image-offset	Offset from the line [since 5801]	Number	0
repeat-image-spacing	Spacing between repeated images [since 5801]	Number	0
repeat-image-phase	Initial spacing at the beginning of the line [since 5812]	Number	0

All these properties (except for text-... and font-...) exist also with the casing- prefix. The casing is a second independent line element, that is drawn below the normal line and can be used to draw a thin frame around the line in another color.

Key	Description	Value Format	Default Value
casing-width	Width of the border on both sides of the main line. In JOSM < 5214: Total width of the casing	Width (revers to width if relative width is specified)	-
casing-color	Casing color	Color	value of fill-color or (if unset) JOSM's default untagged color (#808080)
casing-opacity	How transparent the casing is.	Opacity	1.0
casing-...	...	...	...

Similar to casing-, there is also the left-casing- and right-casing- prefix. It draws additional lines to the left and to the right of the main line.

Area styles

Key	Description	Value Format	Default Value
fill-color	Color in which to fill the area. Until 11700, the alpha component was set to 50 to create a transparency effect.	Color	-
fill-image	Image pattern	Image	-
fill-extent	Set this property, to draw only the outline of the area. The number specifies, how far to fill from the border of the area towards the center. (If unset, the area will be filled completely) [since 9008]	Number	-
fill-opacity	How transparent the fill is; applies to both color and image	Opacity	0.2 [since 11700, 1.0 before that] (can be changed with the mappaint.fillalpha and mappaint.fill-image-alpha preferences)
text-position	set to center, if text should be drawn in the center of the area. Set to inside to place the text completely inside the area (since r11722).	line, center, inside	-
text-..., font-...	general text & font properties

Required properties to create an Area style: fill-color or fill-image

Text & Font properties

Key	Description	Value Format	Default Value
text	How to find the label text. No label is displayed, unless this instruction is present.	auto Derive the text automatically. The default name tags are: "name:"+<LANG>, "name", "int_name", "ref", "operator", "brand" and "addr:housenumber". Configure a list of tag names in the preference "mappaint.nameOrder" in order to change this list. (After changing the list, a restart of JOSM is required.) String Denotes the key of the tag whose value is used as text. Expressions You can enter an expression to compute the text to be displayed. Examples: eval("this is a static text") - renderes a static text eval(concat(tag("first"), "-", tag("second"))) - displays the concatenated tags "first" and "second" "" To delete a previous set text.	-
text-color	the text color	Color	white for lines and nodes, #c0c0c0 for areas (JOSM "text" and "areatext" color preferences)
text-opacity	how transparent the text is	Opacity	1.0
text-offset-x	shift the text horizontally, (not supported for text along line)	Number	0
text-offset-y (can also be written as text-offset)	shift the text vertically, positive values shift the text in upwards direction	Number	0
text-halo-radius	size of text background border (to make text visible on background with a similar color)	Number	-
text-halo-color	color of the text halo	Color	complement of the text color
text-halo-opacity	transparency for the text halo	Opacity	1.0
font-family	font family	String	"Helvetica" (JOSM preference "mappaint.font")
font-size	font size	Number	8 (JOSM preference "mappaint.fontsize")
font-weight	bold or not	bold, normal	normal
font-style	italic or not	italic, normal	normal

User defined properties

• In Mappaint styles you can define any custom propety, e.g.: crc: CRC32_checksum(tag(name))/429496.7296;
• In Validator rules they must be prefixed by a -, e.g.: -osmoseItemClassLevel: "1210/1/1";

Property values explanations

Width

• 14.0 (any positive number)
• default (use JOSM's default line width, which is 2, but can be configured)
• thinnest (draws the line as thin as possible)
• +3 (with plus sign in front) adds the amount to the width on the default layer. This applies only for styles that are not on the default layer, e.g. highlights. Another way to write this would be prop("width","default")+3. For casing-width, this refers to the width value on the same layer.

Image

See Help/Styles/Images.

Color

• named color as found in ​this list
• html style: #RRGGBB, #RGB, #RRGGBBAA
• rgb(/*r*/, /*g*/, /*b*/) - rgb value with arguments from 0.0 to 1.0
• rgba(/*r*/, /*g*/, /*b*/, /*alpha*/) - rgb value with alpha
• hsb_color(/*hue*/, /*saturation*/, /*brightness*/) - color from HSB color space

Opacity

• from 0.0 (transparent) to 1.0 (opaque)

String

• any character sequence, in quotes, e.g. "images/fill.png". If the string is an identifier, quotes are optional. (Quote and backslash sign can be escaped.)

Number

• integer or floating point (in simple form e.g. 0.3). In general can be negative, but most properties do not support negative numbers
• has a special meaning if you put a "+" sign in front (relative width)

Eval expressions

See Javadoc of Functions for the up-to-date list of functions supported by JOSM's MapCSS implementation.

+, -, *, /

arithmetic operations

||, &&, !

boolean operations

<, >, <=, >=, ==

comparison operators

asin, atan, atan2, ceil, cos, cosh, exp, floor, log, max, min, random, round, signum, sin, sinh, sqrt, tan, tanh

the usual meaning, ​details

cond(b, fst, snd)

b ? fst : snd

if (b) then fst else snd

list(a, b, ...)

create list of values, e.g. for the dashes property

get(lst, n)

get the nth element of the list lst (counting starts at 0) [since 5699]

split(sep, str)

splits string str at occurrences of the separator string sep, returns a list [since 5699]

prop(p_name)

value of the property p_name of the current layer, e.g. prop("width")

prop(p_name, layer_name)

property from the layer layer_name

is_prop_set(p_name)

true, if property p_name is set for the current layer

is_prop_set(p_name, layer_name)

true, if property p_name is set for the layer layer_name

tag(key_name)

get the value of the key key_name from the object in question

parent_tag(key_name)

get the value of the key key_name from the object's parent

parent_tags(key_name)

returns all parent's values for the key key_name as a list ordered by a natural ordering [since 8775]

has_tag_key(key_name)

true, if the object has a tag with the given key

rgb(r, g, b)

create color value (arguments from 0.0 to 1.0)

hsb_color(h, s, b)

create color from hue, saturation and brightness (arguments from 0.0 to 1.0) [since 6899]

red(clr), green(clr), blue(clr)

get value of color channels in rgb color model

alpha(clr)

get the alpha value of the given color [since 6749]

length(str)

length of a string

count(lst)

length of a list, i.e., counts its elements [since 7162]

length(lst)

length of a list [since 5699] – deprecated since 7162

any(obj1, obj2, ...)

returns the first object which is not null (formerly coalesce, [since 7164])

concat(str1, str2, ...)

assemble the strings to one

join(sep, str1, str2, ...)

join strings, whith sep as separator [since 6737]

join_list(sep, list_name)

joins the elements of the list list_name to one string separated by the separator sep [since 8775]

upper(str)

converts string to upper case [since 11756]

lower(str)

converts string to lower case [since 11756]

trim(str)

remove leading and trailing whitespace from string [since 11756]

JOSM_search("...")

true, if JOSM search applies to the object

tr(str, arg0, arg1, ...)

translate from English to the current language (only for strings in the JOSM user interface) [since 6506]

regexp_test(regexp, string)

test if string matches pattern regexp [since 5699]

regexp_test(regexp, string, flags)

test if string matches pattern regexp; flags is a string that may contain "i" (case insensitive), "m" (multiline) and "s" ("dot all") [since 5699]

regexp_match(regexp, string)

Tries to match string against pattern regexp. Returns a list of capture groups in case of success. The first element (index 0) is the complete match (i.e. string). Further elements correspond to the bracketed parts of the regular expression. [since 5701]

regexp_match(regexp, string, flags)

Tries to match string against pattern regexp. Returns a list of capture groups in case of success. The first element (index 0) is the complete match (i.e. string). Further elements correspond to the bracketed parts of the regular expression. Flags is a string that may contain "i" (case insensitive), "m" (multiline) and "s" ("dot all") [since 5701]

substring(str, idx)

return the substring of str, starting at index idx (0-indexed) [since 6534]

substring(str, start, end)

return the substring of str, starting at index start (inclusive) up to end (exclusive) (0-indexed) [since 6534]

replace(string, old, new)

Replaces any occurrence of the substring old within the string string with the text new

osm_id()

returns the OSM id of the current object [since 5699]

osm_user_name()

returns the OSM user name who last touched the current object [since 15246]

osm_user_id()

returns the OSM user id who last touched the current object [since 15246]

osm_version()

returns the OSM version number of the current object [since 15246]

osm_changeset_id()

returns the id of the changeset the current object was last uploaded to [since 15246]

osm_timestamp()

returns the time of last modification to the current object, as timestamp [since 15246]

parent_osm_id()

returns the OSM id of the object's parent (matched by child selector) [since 13094]

URL_encode(str)

​percent-encode a string. May be useful for data URLs [since 6805]

URL_decode(str)

​percent-decode a string. [since 11756]

XML_encode(str)

escape special characters in xml. E.g. < becomes <, other special characters: >, ", ', &, \n, \t and \r [since 6809]

CRC32_checksum(str)

calculate the CRC32 checksum of a string (result is an integer from 0 to 2³²-1) [since 6908]

is_right_hand_traffic()

Check if there is left-hand or right-hand traffic at the current location. [since 7193]

number_of_tags()

returns the number of tags for the current OSM object [since 7237]

print(o)

prints a string representation of o to the command line (for debugging) [since 7237]

println(o)

prints a string representation of o to the command line, followed by a new line (for debugging) [since 7237]

JOSM_pref(key, default)

Get value from the JOSM advanced preferences. This way you can offer certain options to the user and make the style customizable. It works with strings, numbers, colors and boolean values.
[This function exists since version 3856, but with some restrictions. JOSM_pref always returns a string, but in version 7237 and earlier, the automatic conversion of string to boolean and color was not working. You can use the following workarounds for boolean values and color in version 7237 and earlier: cond(JOSM_pref("myprefkey", "true")="true", "X", "O") and html2color(JOSM_pref("mycolor", "#FF345611")). These explicit conversions should be no longer necessary in version 7238 and later. Automatic conversion to a number works in any version.]

setting()

to use a style setting [since 7450]

degree_to_radians()

returns a in degree given direction in radians [since 8260]

cardinal_to_radians()

returns a cardinal direction in radians [since 8260]

waylength()

returns the length of the way in metres [since 8253]

areasize()

returns the area of a closed way in square meters [since 8253]

at(lat,lon)

returns true if the object centroid lies at given lat/lon coordinates, e.g. to check for nodes at "null island" node[at(0.0,0.0)] [since 12514]

is_similar(str1, str2)

returns true if the two strings are similar, but not identical, i.e., have a Levenshtein distance of 1 or 2. Example: way[highway][name][is_similar(tag(name), "Main Street")] checks for streets with a possible typo in the name (e.g. Main Streeg). [since 14371]

gpx_distance()

returns the lowest distance between the OSM object and a GPX point [since 14802]

Examples

• circle symbol for house number with size depending of the number of digits

  node[addr:housenumber] { 
      symbol-shape: circle; 
      symbol-size: eval((min(length(tag("addr:housenumber")), 3) * 5) + 3); 
      symbol-fill-color: #B0E0E6; 
  
      text: "addr:housenumber"; 
      text-anchor-horizontal: center; 
      text-anchor-vertical: center; 
      text-offset-x: -1; 
      text-offset-y: -1; }
      
  node[addr:housenumber]::hn_casing { 
      z-index: -100; 
      symbol-shape: circle; 
      symbol-size: +2; 
      symbol-fill-color: blue; 
  }
  

• invert colors

  *::* {
      color: eval(rgb(1 - red(prop(color)), 1 - green(prop(color)), 1 - blue(prop(color))));
      fill-color: eval(rgb(1 - red(prop(fill-color)), 1 - green(prop(fill-color)), 1 - blue(prop(fill-color))));
  }
  

• random stuff

  way {
      width: eval(random() * 20);
      color: eval(rgb(random(), random(), random()));
  }
  

• regexp matching example: change "nameXXXsubname" to "name::subname"

  *[name=~/.+XXX.+/] 
  {
      _match: regexp_match("(.+?)XXX(.+)", tag("name"));
      text: concat(get(prop("_match"),1), "::", get(prop("_match"),2));
  }
  

• paint buildings in different colors according to street in the address tags

  area[building][addr:street] {
      fill-color: hsb_color(CRC32_checksum(tag("addr:street"))/4294967296.0, 0.9, 0.7);
      fill-opacity: 0.8;
  }
  

Compatibility notes

MapCSS 0.2

Grammar

• way[oneway=yes] does not have any magic, you can use way[oneway?] instead
• no @import
• JOSM does not require eval(...) to be wrapped around expressions, but for compatibility with other MapCSS implementations you should write it out.

Properties

At the moment, JOSM does not support the following properties:

line:

image

label:

font-variant, text-decoration, text-transform, max-width

shield:

not supported

Halcyon (Potlatch 2)

• Text label is placed in the center of the icon. For compatibility with Halcyon put

  node { text-anchor-vertical: center; text-anchor-horizontal: center; }
  

  at the beginning of your style sheet.
• standard z-index in Halcyon is 5, but it is 0 in JOSM
• image: circle; corresponds to symbol-shape: circle;

Kothic

• Kothic has support for eval, which probably differs from JOSM's eval.
• Kothic understands units, whereas JOSM always calculates in pixel.
• The extrusion features are not available in JOSM

Ceyx

• seems to have [tunnel=1] instead of [tunnel=yes] (Halcyon) or [tunnel?] (JOSM)

Media queries [since 6970] (deprecated)

Note: media queries are deprecated. You should use @supports rules instead (see above).

Media queries are used to skip a section of the style under certain conditions. Typically you want to use a feature which is introduced in a newer version of JOSM, but like to have a fall back style for users of older JOSM clients. Example:

@media (min-josm-version: 9789) {
    way[highway] {
        width: 4;
        color: orange;
    }
    /* fancy new stuff */
    /* ... */
}

@media (max-josm-version: 9788) {
    way[highway] {
        width: 4;
        color: blue;
    }
    /* fall back mode, using more simple features */
    /* ... */
}

The syntax closely matches the official ​css syntax. The following conditions are supported:

Media condition	Description
(min-josm-version: <number>)	Only include @media section when the current version of JOSM is greater than or equal to the specified number.
(max-josm-version: <number>)	Only include @media section when the current version of JOSM is lower than or equal to the specified number.
(user-agent: <string>)	Only include @media section when the name of the editor / renderer matches the given string. In JOSM, the only accepted value is josm.

Conditions can be combined with and:

@media (min-josm-version: 6970) and (max-josm-version: 7014) {
 /* only for JOSM versions 6970 to 7014 */
}

Multiple combined conditions can be chained with a comma (logical or):

@media (min-josm-version: 6970) and (max-josm-version: 7014), (user-agent: myEditor) {
  /* for JOSM version 6970 to 7014 and for the editor called "myEditor" */
}

Since media queries are only supported in JOSM 6970 and later, you should also specify this as minimum JOSM version in the meta selector:

meta {
    min-josm-version: "6970"; /* This style uses media queries */
    /* ... */
}