Paths represent the outline of a shape which can be filled, stroked, (see Filling, Stroking and Paint Servers) used as a clipping path (see Clipping, Masking and Compositing), or for any combination of the three.
A path is described using the concept of a current point. In an analogy with drawing on paper, the current point can be thought of as the location of the pen. The position of the pen can be changed, and the outline of a shape (open or closed) can be traced by dragging the pen in either straight lines or curves.
Paths represent an outline of an object which is defined in terms of moveto (set a new current point), lineto (draw a straight line), curveto (draw a curve using a cubic bezier), arc (elliptical or circular arc) and closepath (close the current shape by drawing a line to the last moveto) elements. Compound paths (i.e., a path with subpaths, each consisting of a single moveto followed by one or more line or curve operations) are possible to allow effects such as "donut holes" in objects.
A path is defined in SVG using the 'path' element.
<!ENTITY % pathExt "" > <!ELEMENT path (%descTitle;,(animatesetanimateMotionanimateColoranimateTransform %geExt;%pathExt;)*) > <!ATTLIST path %stdAttrs; %langSpaceAttrs; class %ClassList; #IMPLIED transform %TransformList; #IMPLIED %graphicsElementEvents; %testAttrs; externalResourcesRequired %Boolean; #IMPLIED d %PathData; #REQUIRED length %Number; #IMPLIED %StylableSVGStyleAttribute; %ExchangeSVGFillStrokeAttrs; %ExchangeSVGGraphicsAttrs; %ExchangeSVGMarkerAttrs; > 
Attribute definitions:
A path is defined by including a 'path' element which contains a d="(path data)" attribute, where the d attribute contains the moveto, line, curve (both cubic and quadratic beziers), arc and closepath instructions. The following example specifies a path in the shape of a triangle. (The M indicates a moveto, the L's indicate lineto's, and the z indicates a closepath:
<?xml version="1.0" standalone="yes"?> <svg width="4in" height="3in" xmlns = 'http://www.w3.org/2000/svg20000303stylable'> <path d="M 100 100 L 140 100 L 120 140 z"/> </svg>
Path data values can contain newline characters and thus can be broken up into multiple lines to improve readability. Because of line length limitations with certain related tools, it is recommended that SVG generators split long path data strings across multiple lines, with each line not exceeding 255 characters. Also note that newline characters are only allowed at certain places within a path data value.
The syntax of path data is very abbreviated in order to allow for minimal file size and efficient downloads, since many SVG files will be dominated by their path data. Some of the ways that SVG attempts to minimize the size of path data are as follows:
The path data syntax is a prefix notation (i.e., commands followed by parameters). The only allowable decimal point is a period (".") and no other delimiter characters are allowed. (For example, the following is an invalid numeric value in a path data stream: "13,000.56". Instead, say: "13000.56".)
In the tables below, the following notation is used:
The following sections list the commands.
The "moveto" commands (M or m) establish a new current point. The effect is as if the "pen" were lifted and moved to a new location. A path data segment must begin with either one of the "moveto" commands or one of the "arc" commands. Subsequent "moveto" commands (i.e., when the "moveto" is not the first command) represent the start of a new subpath:
Command  Name  Parameters  Description 

M (absolute) m (relative) 
moveto  (x y)+  Start a new subpath at the given (x,y) coordinate. M (uppercase) indicates that absolute coordinates will follow; m (lowercase) indicates that relative coordinates will follow. If a relative moveto (m) appears as the first element of the path, then it is treated as a pair of absolute coordinates. If a moveto is followed by multiple pairs of coordinates, the subsequent pairs are treated as implicit lineto commands. 
The "closepath" (Z or z) causes an automatic straight line to be drawn from the current point to the initial point of the current subpath. "Closepath" differs in behavior from what happens when "manually" closing a subpath via a "lineto" command in how 'strokelinejoin' and 'strokelinecap' are implemented. With "closepath", the end of the final segment of the subpath is "joined" with the start of the initial segment of the subpath using the current value of 'strokelinejoin' . If you instead "manually" close the subpath via a "lineto" command, the start of the first segment and the end of the last segment are not joined but instead are each capped using the current value of 'strokelinecap':
Command  Name  Parameters  Description 

Z or z 
closepath  (none)  Close the current subpath by drawing a straight line from the current point to current subpath's most recent starting point (usually, the most recent moveto point). 
The various "lineto" commands draw straight lines from the current point to a new point:
Command  Name  Parameters  Description 

L (absolute) l (relative) 
lineto  (x y)+  Draw a line from the current point to the given (x,y) coordinate which becomes the new current point. L (uppercase) indicates that absolute coordinates will follow; l (lowercase) indicates that relative coordinates will follow. A number of coordinates pairs may be specified to draw a polyline. At the end of the command, the new current point is set to the final set of coordinates provided. 
H (absolute) h (relative) 
horizontal lineto  x+  Draws a horizontal line from the current point (cpx, cpy) to (x, cpy). H (uppercase) indicates that absolute coordinates will follow; h (lowercase) indicates that relative coordinates will follow. Multiple x values can be provided (although usually this doesn't make sense). At the end of the command, the new current point becomes (x, cpy) for the final value of x. 
V (absolute) v (relative) 
vertical lineto  y+  Draws a vertical line from the current point (cpx, cpy) to (cpx, y). V (uppercase) indicates that absolute coordinates will follow; v (lowercase) indicates that relative coordinates will follow. Multiple y values can be provided (although usually this doesn't make sense). At the end of the command, the new current point becomes (cpx, y) for the final value of y. 
These three groups of commands that draw curves:
The cubic bezier commands are as follows:
Command  Name  Parameters  Description 

C (absolute) c (relative) 
curveto  (x1 y1 x2 y2 x y)+  Draws a cubic bezier curve from the current point to (x,y) using (x1,y1) as the control point at the beginning of the curve and (x2,y2) as the control point at the end of the curve. C (uppercase) indicates that absolute coordinates will follow; c (lowercase) indicates that relative coordinates will follow. Multiple sets of coordinates may be specified to draw a polybezier. At the end of the command, the new current point becomes the final (x,y) coordinate pair used in the polybezier. 
S (absolute) s (relative) 
shorthand/smooth curveto  (x2 y2 x y)+  Draws a cubic bezier curve from the current point to (x,y). The first control point is assumed to be the reflection of the second control point on the previous command relative to the current point. (If there is no previous command or if the previous command was not an C, c, S or s, assume the first control point is coincident with the current point.) (x2,y2) is the second control point (i.e., the control point at the end of the curve). S (uppercase) indicates that absolute coordinates will follow; s (lowercase) indicates that relative coordinates will follow. Multiple sets of coordinates may be specified to draw a polybezier. At the end of the command, the new current point becomes the final (x,y) coordinate pair used in the polybezier. 
The quadratic bezier commands are as follows:
Command  Name  Parameters  Description 

Q (absolute) q (relative) 
quadratic bezier curveto  (x1 y1 x y)+  Draws a quadratic bezier curve from the current point to (x,y) using (x1,y1) as the control point. Q (uppercase) indicates that absolute coordinates will follow; q (lowercase) indicates that relative coordinates will follow. Multiple sets of coordinates may be specified to draw a polybezier. At the end of the command, the new current point becomes the final (x,y) coordinate pair used in the polybezier. 
T (absolute) t (relative) 
Shorthand/smooth quadratic bezier curveto  (x y)+  Draws a quadratic bezier curve from the current point to (x,y). The control point is assumed to be the reflection of the control point on the previous command relative to the current point. (If there is no previous command or if the previous command was not an Q, q, T or t, assume the control point is coincident with the current point.) T (uppercase) indicates that absolute coordinates will follow; t (lowercase) indicates that relative coordinates will follow. At the end of the command, the new current point becomes the final (x,y) coordinate pair used in the polybezier. 
The elliptical arc commands are as follows:
Command  Name  Parameters  Description 

A (absolute) a (relative) 
elliptical arc  (rx ry xaxisrotation largearcflag sweepflag x y)+  Draws an elliptical arc from the current point to (x, y). The size and orientation of the ellipse is defined two radii (rx, ry) and an xaxisrotation, which indicates how the ellipse as a whole is rotated relative to the current coordinate system. The center (cx, cy) of the ellipse is calculated automatically to satisfy the constraints imposed by the other parameters. largearcflag and sweepflag contribute to the automatic calculations and help determine how the arc is drawn. 
The elliptical arc command draws a section of an ellipse which meets the following constraints:
(We need examples to illustrate all of this! Here is one for the
moment.
Suppose you have a circle with center (5,5) and radius 2 and you wish
to draw an arc from 0 degrees to 90 degrees.
Then one way to achieve this would be M 7,5 A 2,2 0 0 1 5,7
.
In this example, you move to the "0 degree" location on the circle,
which is (7,5), since the center is at (5,5) and the circle has radius
2.
Since we have circle, the two radii are the same, and in this example
both are equal to 2.
Since our sweep is 90 degrees, which is less than 180, we set largearcflag
to 0.
We want to draw the sweep in a positive angle direction, so we set
sweepflag to 1.
Since we want to draw the arc to the point which is at the 90 degree
location of the circle, we set (x,y) to (5,7).)
The following notation is used in the BNF description of the grammar for path data:
The following is the BNF for SVG paths.
svgpath: wsp* subpaths? wsp* subpaths: subpath  subpath subpaths subpath: moveto subpathelements? subpathelements: subpathelement  subpathelement wsp* subpathelements subpathelement: closepath  lineto  horizontallineto  verticallineto  curveto  smoothcurveto  quadraticbeziercurveto  smoothquadraticbeziercurveto  ellipticalarc moveto: ( "M"  "m" ) wsp* movetoargumentsequence movetoargumentsequence: coordinatepair  coordinatepair commawsp? linetoargumentsequence closepath: ("Z"  "z") lineto: ( "L"  "l" ) wsp* linetoargumentsequence linetoargumentsequence: coordinatepair  coordinatepair commawsp? linetoargumentsequence horizontallineto: ( "H"  "h" ) wsp* horizontallinetoargumentsequence horizontallinetoargumentsequence: coordinate  coordinate commawsp? horizontallinetoargumentsequence verticallineto: ( "V"  "v" ) wsp* verticallinetoargumentsequence verticallinetoargumentsequence: coordinate  coordinate commawsp? verticallinetoargumentsequence curveto: ( "C"  "c" ) wsp* curvetoargumentsequence curvetoargumentsequence: curvetoargument  curvetoargument commawsp? curvetoargumentsequence curvetoargument: coordinatepair commawsp? coordinatepair commawsp? coordinatepair smoothcurveto: ( "S"  "s" ) wsp* smoothcurvetoargumentsequence smoothcurvetoargumentsequence: smoothcurvetoargument  smoothcurvetoargument commawsp? smoothcurvetoargumentsequence smoothcurvetoargument: coordinatepair commawsp? coordinatepair quadraticbeziercurveto: ( "Q"  "q" ) wsp* quadraticbeziercurvetoargumentsequence quadraticbeziercurvetoargumentsequence: quadraticbeziercurvetoargument  quadraticbeziercurvetoargument commawsp? quadraticbeziercurvetoargumentsequence quadraticbeziercurvetoargument: coordinatepair commawsp? coordinatepair smoothquadraticbeziercurveto: ( "T"  "t" ) wsp* smoothquadraticbeziercurvetoargumentsequence smoothquadraticbeziercurvetoargumentsequence: coordinatepair  coordinatepair commawsp? smoothquadraticbeziercurvetoargumentsequence ellipticalarc: ( "A"  "a" ) wsp* ellipticalarcargumentsequence ellipticalarcargumentsequence: ellipticalarcargument  ellipticalarcargument commawsp? ellipticalarcargumentsequence ellipticalarcargument: nonnegativenumber commawsp? nonnegativenumber commawsp? number commawsp? flag commawsp? flag commawsp? coordinatepair coordinatepair: coordinate commawsp? coordinate coordinate: number nonnegativenumber: integerconstant  floatingpointconstant number: sign? integerconstant  sign? floatingpointconstant flag: "0"  "1" commawsp: (wsp+ comma? wsp*)  (comma wsp*) comma: "," integerconstant: digitsequence floatingpointconstant: fractionalconstant exponent?  digitsequence exponent fractionalconstant: digitsequence? "." digitsequence  digitsequence "." exponent: ( "e"  "E" ) sign? digitsequence sign: "+"  "" digitsequence: digit  digit digitsequence digit: "0"  "1"  "2"  "3"  "4"  "5"  "6"  "7"  "8"  "9" wsp: (#x20  #x9  #xD  #xA)
The processing of the BNF must consume as much of a given BNF production as possible, stopping at the point when a character is encountered which no longer satisfies the production. Thus, in the string "M 100200", the first coordinate for the "moveto" consumes the characters "100" and stops upon encountering the minus sign because the minus sign cannot follow a digit in the production of a "coordinate". The result is that the first coordinate will be "100" and the second coordinate will be "200".
Similarly, for the string "M 0.6.5", the first coordinate of the
"moveto" consumes the characters "0.6" and stops upon encountering
the second decimal point because the production of a "coordinate" only
allows one decimal point.
The result is that the first coordinate will be "0.6" and the second
coordinate will be ".5".
Various operations, including text on a path and motion animation and various stroke operations, require that the user agent compute the distance along the geometry of a graphics element, such as a 'path'.
Exact mathematics exist for computing distance along a path, but the formulas are highly complex and require substantial computation. It is recommended that authoring products and user agents employ algorithms that produce as precise results as possible; however, to accommodate implementation differences and to help distance calculations produce results that approximate author intent, the length attribute can be used to provide the author's computation of the total length of the path so that the user agent can scale distancealongapath computations by the ratio of length to the user agent's own computed value for total path length.
A "moveto" operation within a 'path'
element is defined to have zero length.
Only the various "lineto", "curveto" and "arcto" commands contribute
to path length calculations.
The following interfaces are defined below: SVGPathElement, SVGPathSeg.
The SVGPathElement interface corresponds to the 'path' element.
The SVGPathElement interface provides two lists to access and modify the contents of the d attribute:
The two lists are always kept synchronized. Modifications to one list will immediately cause the corresponding list to be modified. Modifications to normalizedPathSegList might cause entries in pathSegList to be broken into a set of normalized path segments.
interface SVGPathElement : SVGElement, SVGTransformable, SVGLangSpace, SVGTests, EventTarget { attribute DOMString className; attribute SVGNumber length; readonly attribute SVGList pathSegList; readonly attribute SVGList normalizedPathSegList; #ifdef STYLABLESVG // The following predefined attribute collections are only // available in the DOM for Stylable SVG. STYLABLESVGStyleAttribute; #endif STYLABLESVG #ifdef EXCHANGESVG // The following predefined attribute collections are only // available in the DOM for Exchange SVG. EXCHANGESVGFillStrokeAttrs; EXCHANGESVGGraphicsAttrs; #endif EXCHANGESVG float getTotalLength ( ); SVGPoint getPointAtLength ( in float distance ) raises( SVGException ); unsigned long getPathSegAtLength ( in float distance ) raises( SVGException ); SVGPathSeg createSVGPathSeg ( ); };
Provides access to the contents of the d attribute in a form which matches oneforone with SVG's syntax. Thus, if the d attribute has an "absolute moveto (M)" and an "absolute arcto (A)" command, then pathSegList will have two entries: a SVG_PATHSEG_MOVETO_ABS and a SVG_PATHSEG_ARC_ABS.
The various methods from SVGList, which are defined to accept parameters and return values of type Object, must receive parameters of type SVGPathSeg and return values of type SVGPathSeg.
Provides access to the contents of the d attribute in a form where all path data commands are expressed in terms of the following subset of SVGPathSeg types: SVG_PATHSEG_MOVETO_ABS (M), SVG_PATHSEG_LINETO_ABS (L), SVG_PATHSEG_CURVETO_CUBIC_ABS (C) and SVG_PATHSEG_CLOSEPATH (z). Thus, if the d attribute has an "absolute moveto (M)" and an "absolute arcto (A)" command, then pathSegList will have one SVG_PATHSEG_MOVETO_ABS entry followed by a series of SVG_PATHSEG_ARC_ABS entries which approximate the arc. This alternate representation is available to provide a simpler interface to developers who would benefit from a more limited set of commands.
The various methods from SVGList, which are defined to accept parameters and return values of type Object, must receive parameters of type SVGPathSeg and return values of type SVGPathSeg, and the only valid SVGPathSeg types are SVG_PATHSEG_MOVETO_ABS (M), SVG_PATHSEG_LINETO_ABS (L), SVG_PATHSEG_CURVETO_CUBIC_ABS (C) and SVG_PATHSEG_CLOSEPATH (z).
float  The total length of the path. 
distance
units along the path,
utilizing the user agent's distancealongapath algorithm.
in float distance  The distance along the path, relative to the start of the path, as a distance in the current user coordinate system. 
SVGPoint  The returned point in user space. 
SVGException 
SVG_WRONG_TYPE_ERR: Raised if the parameter is the wrong type of value.

distance
units along the path,
utilizing the user agent's distancealongapath algorithm.
in float distance  The distance along the path, relative to the start of the path, as a distance in the current user coordinate system. 
unsigned long  The index of the path segment. 
SVGException 
SVG_WRONG_TYPE_ERR: Raised if the parameter is the wrong type of value.

SVGPathSeg  An SVGPathSeg with a pathSegType of SVG_PATHSEG_UNKNOWN. 
The SVGPathSeg interface corresponds to a single command within a path data specification.
interface SVGPathSeg { // Path Segment Types constant unsigned short SVG_PATHSEG_UNKNOWN = 0; constant unsigned short SVG_PATHSEG_CLOSEPATH = 1; constant unsigned short SVG_PATHSEG_MOVETO_ABS = 2; constant unsigned short SVG_PATHSEG_MOVETO_REL = 3; constant unsigned short SVG_PATHSEG_LINETO_ABS = 4; constant unsigned short SVG_PATHSEG_LINETO_REL = 5; constant unsigned short SVG_PATHSEG_CURVETO_CUBIC_ABS = 6; constant unsigned short SVG_PATHSEG_CURVETO_CUBIC_REL = 7; constant unsigned short SVG_PATHSEG_CURVETO_QUADRATIC_ABS = 8; constant unsigned short SVG_PATHSEG_CURVETO_QUADRATIC_REL = 9; constant unsigned short SVG_PATHSEG_ARC_ABS = 10; constant unsigned short SVG_PATHSEG_ARC_REL = 11; constant unsigned short SVG_PATHSEG_LINETO_HORIZONTAL_ABS = 12; constant unsigned short SVG_PATHSEG_LINETO_HORIZONTAL_REL = 13; constant unsigned short SVG_PATHSEG_LINETO_VERTICAL_ABS = 14; constant unsigned short SVG_PATHSEG_LINETO_VERTICAL_REL = 15; constant unsigned short SVG_PATHSEG_CURVETO_CUBIC_SMOOTH_ABS = 16; constant unsigned short SVG_PATHSEG_CURVETO_CUBIC_SMOOTH_REL = 17; constant unsigned short SVG_PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS = 18; constant unsigned short SVG_PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL = 19; attribute unsigned short pathSegType; attribute DOMString pathSegTypeAsLetter; attribute float x; attribute float y; attribute float x1; attribute float y1; attribute float x2; attribute float y2; attribute float r1; attribute float r2; attribute float angle; attribute boolean largeArcFlag; attribute boolean sweepFlag; };
SVG_PATHSEG_UNKNOWN  The unit type is not one of predefined types. It is invalid to attempt to define a new value of this type or to attempt to switch an existing value to this type.  
SVG_PATHSEG_CLOSEPATH  Corresponds to a "closepath" (z) path data command.  
SVG_PATHSEG_MOVETO_ABS  Corresponds to an "absolute moveto" (M) path data command.  
SVG_PATHSEG_MOVETO_REL  Corresponds to a "relative moveto" (m) path data command.  
SVG_PATHSEG_LINETO_ABS  Corresponds to an "absolute lineto" (L) path data command.  
SVG_PATHSEG_LINETO_REL  Corresponds to a "relative lineto" (l) path data command.  
SVG_PATHSEG_CURVETO_CUBIC_ABS  Corresponds to an "absolute cubic bezier curveto" (C) path data command.  
SVG_PATHSEG_CURVETO_CUBIC_REL  Corresponds to a "relative cubic bezier curveto" (c) path data command.  
SVG_PATHSEG_CURVETO_QUADRATIC_ABS  Corresponds to an "absolute quadratic bezier curveto" (Q) path data command.  
SVG_PATHSEG_CURVETO_QUADRATIC_REL  Corresponds to a "relative quadratic bezier curveto" (q) path data command.  
SVG_PATHSEG_ARC_ABS  Corresponds to an "absolute arcto" (A) path data command.  
SVG_PATHSEG_ARC_REL  Corresponds to a "relative arcto" (a) path data command.  
SVG_PATHSEG_LINETO_HORIZONTAL_ABS  Corresponds to an "absolute horizontal lineto" (H) path data command.  
SVG_PATHSEG_LINETO_HORIZONTAL_REL  Corresponds to a "relative horizontal lineto" (h) path data command.  
SVG_PATHSEG_LINETO_VERTICAL_ABS  Corresponds to an "absolute vertical lineto" (V) path data command.  
SVG_PATHSEG_LINETO_VERTICAL_REL  Corresponds to a "relative vertical lineto" (v) path data command.  
SVG_PATHSEG_CURVETO_CUBIC_SMOOTH_ABS  Corresponds to an "absolute smooth cubic curveto" (S) path data command.  
SVG_PATHSEG_CURVETO_CUBIC_SMOOTH_REL  Corresponds to a "relative smooth cubic curveto" (s) path data command.  
SVG_PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS  Corresponds to an "absolute smooth quadratic curveto" (T) path data command.  
SVG_PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL  Corresponds to a "relative smooth quadratic curveto" (t) path data command. 