How to reduce svg path complexity with the ramer–douglas–peucker algorithm
- Step 1Open the tool and add your SVG — Go to the SVG Path Simplifier. Drag an
.svgonto the drop zone or click to browse — you can also paste raw SVG source into the textarea. The simplifier is a Pro feature, so a free-tier session sees an upgrade overlay instead of the controls. - Step 2Check what kind of paths you have — Before setting anything, know that only pure-polyline (
M/L) paths are eligible. Auto-traced bitmaps, polygons drawn as line segments, GPS tracks, and flattened contours qualify. Pen-tool / Figma / Illustrator icons that use cubic Béziers (C) do not — they pass through untouched. If you need fewer curve control points, this tool is the wrong one; reach for an editor or a dedicated curve-fitter. - Step 3Set the tolerance slider — The slider goes
0.1–5.0in0.1steps, default1.0. Tolerance is the maximum distance (in the path's coordinate units) the simplified line may stray from the original. Start at1.0for a safe cleanup; nudge up to2–3for a real cut on rough traces. - Step 4Process and read the metrics — Click Process SVG. The metrics row reports
Tolerance,Polyline paths simplified,Curve paths preserved, the saved-% badge, and original vs output byte sizes. IfPolyline paths simplifiedis0, every path in your file had curves — nothing was eligible and the output equals the input. - Step 5Eyeball the rendered preview — The panel renders the simplified SVG directly (and offers a collapsible
View SVG source). There is no before/after diff overlay — compare against the original visually at your real display size. If straight runs look chunky where they should be smooth, the source was a polyline and you simply went too aggressive: lower the tolerance. - Step 6Download or copy, then chain a minifier — Download the
*-simplified.svgor copy the source. RDP removes nodes; it does not strip whitespace, comments, or shrink other numbers. Follow up with the Precision Tuner to round remaining coordinates and the Pro-Minifier for the final byte squeeze.
Tolerance slider — effect on polyline paths
tolerance is the only option. Schema range is 0.1–5.0, step 0.1, default 1.0. Node-reduction figures are typical for traced/polyline icon-scale paths and vary with the path — preview before committing.
| tolerance | What happens | Typical node reduction (polyline paths only) |
|---|---|---|
| 0.1 (minimum) | Removes only points essentially on the baseline; near-lossless | 5–15% |
| 0.5 | Barely perceptible cleanup of near-collinear runs | 10–25% |
| 1.0 (default) | Safe general cleanup; shape visually unchanged | 25–45% |
| 2.0 | Noticeable simplification, good for icons and thumbnails | 40–60% |
| 5.0 (maximum) | Aggressive — only dominant vertices survive; check the preview | 60–80% |
Which paths get simplified (the eligibility rule)
The tool tests each path's d against /^\s*[Mm][^CcSsQqTtAaHhVv]*$/. Only fully matching paths are simplified; the rest are returned byte-for-byte.
| Path `d` contains | Eligible? | Result |
|---|---|---|
M/L only (absolute lines) | Yes | RDP runs; nodes dropped; coords rewritten at 2 decimals |
A trailing Z/z close | Yes | Simplified, and the close command is re-appended as Z |
Cubic/smooth Bézier C / S | No | Passed through unchanged (counts as Curve paths preserved) |
Quadratic Q / T | No | Passed through unchanged |
Elliptical arc A | No | Passed through unchanged |
Horizontal/vertical H / V | No | Passed through unchanged — even though they are straight lines |
| Fewer than 3 points | Yes (no-op) | Returned unchanged — RDP needs ≥3 points to drop any |
Cookbook
Concrete before/after d strings. Each shows the eligibility rule and the tolerance effect — paste these into the tool to reproduce.
A traced polyline icon shrinks
An auto-traced shape exported as straight segments. Every command is M/L, so it is eligible. At tolerance 1.0 the near-collinear points collapse and coordinates are re-emitted at two decimals.
Before (12 points, all M/L): M10,10 L11,10.2 L12,10.1 L20,10 L21,15 L22,30 L22.1,31 L23,45 L40,46 L41,46 L42,46.2 L60,46 tolerance = 1.0 After (4 points kept): M10.00,10.00 L22.00,30.00 L23.00,45.00 L60.00,46.00 Result panel: Polyline paths simplified: 1 · Curve paths preserved: 0
An Illustrator Bézier icon is returned untouched
The most common surprise. A pen-tool icon uses cubic curves (C). It fails the polyline-only test, so RDP never runs and the path is preserved verbatim. Saved-% is 0 and the metric tells you why.
Before: M12,2 C6.48,2 2,6.48 2,12 C2,17.52 6.48,22 12,22 C17.52,22 22,17.52 22,12 C22,6.48 17.52,2 12,2 Z tolerance = 3.0 (anything) After (identical): M12,2 C6.48,2 2,6.48 2,12 C2,17.52 6.48,22 12,22 C17.52,22 22,17.52 22,12 C22,6.48 17.52,2 12,2 Z Result panel: Polyline paths simplified: 0 · Curve paths preserved: 1
A closed polygon keeps its Z
A polygon drawn as line segments with a closing Z. The path is eligible; the close is detected and re-appended after simplification so the shape stays closed.
Before: M0,0 L0.5,0.1 L10,0 L10,0.4 L10,10 L0,10 Z tolerance = 1.0 After: M0.00,0.00 L10.00,0.00 L10.00,10.00 L0.00,10.00 Z (the near-collinear L0.5,0.1 and L10,0.4 are dropped; Z preserved)
Mixed file: some paths simplify, some don't
A real icon set often mixes polyline outlines and curved accents in one SVG. The tool walks every d="…" independently — polylines simplify, curves pass through — and the counts add up in the metrics.
Input has two paths: <path d="M0,0 L1,0.1 L50,0 L50,50 L0,50 Z"/> (polyline) <path d="M5,5 C8,5 8,9 5,9 Z"/> (curve) tolerance = 1.0 Output: path 1 → simplified (collinear L1,0.1 dropped) path 2 → unchanged Result panel: Polyline paths simplified: 1 · Curve paths preserved: 1
Going too high facets a polyline
On a dense polyline that approximates a curve (e.g. a flattened arc), a high tolerance discards points that mattered and the smooth run becomes visibly angular. This is the only distortion mode for this tool — and it only affects polylines, never real curves.
A circle flattened to 60 line segments: tolerance = 0.5 → ~40 points, still round tolerance = 2.0 → ~16 points, slightly polygonal tolerance = 5.0 → ~8 points, an octagon Fix: lower the tolerance until the preview looks right at display size.
Edge cases and what actually happens
Path uses cubic/quadratic Bézier or arc commands
PreservedAny d containing C, S, Q, T, or A fails the polyline-only test and is returned byte-for-byte. The tool does NOT sample curves into polylines and does NOT refit curves — that earlier claim is wrong. It counts as Curve paths preserved in the metrics. If you need fewer Bézier control points, simplify in a vector editor; this tool is for M/L polylines.
Path uses H/V shorthand for straight lines
PreservedH (horizontal) and V (vertical) lines are straight, but the eligibility regex excludes them too. A path like M0,0 H10 V10 H0 Z is left untouched. Convert H/V to explicit L commands first (a minifier or editor can do this) if you want it to be simplifiable.
Lowercase relative move (`m …`) path
LimitedThe eligibility test allows a leading lowercase m, but the point-extraction step only reads absolute M/L coordinate pairs. A path written with relative l line-tos may pass the test yet yield too few extracted points to simplify, so it is returned unchanged. For reliable results, feed absolute-coordinate polylines.
Fewer than three points
No-opRDP needs at least three points to discard anything (it keeps the first and last). A 2-point line or a single move is returned unchanged. This is correct: there is nothing in the middle to drop.
Output equals input, saved-% is 0
ExpectedIf every path had curves, or no point was further than the tolerance from its baseline, nothing is removed. The saved-% badge stays at 0 and Polyline paths simplified may read 0. That means the tool did its job — RDP never adds error beyond the tolerance, and it never touches ineligible paths.
Coordinates are rounded to two decimals
By designSurviving points are re-emitted as x.xx,y.yy (two-decimal toFixed(2)). On a tiny viewBox this rounding is itself a (small) shape change independent of node removal. For sub-pixel-critical geometry, keep tolerance low and verify the preview; the rounding is not configurable here — use the Precision Tuner when you want explicit control over decimal places.
Tolerance is in coordinate units, not pixels
Scale-relativeThe same tolerance is far more aggressive on a 24-unit viewBox than on a 1024-unit one. If a value that looks gentle on a logo wrecks an icon, it is because the icon's coordinate space is smaller. Scale your tolerance to the path's coordinate range, not to its on-screen size.
File over the tier size limit
RejectedThe browser checks file size before processing. The SVG family limit is 5 MB on free, 50 MB on Pro, and 2 GB on Developer; an oversized file throws a per-job-limit error. Because the tool is Pro-minimum, free-tier users hit the upgrade overlay before they ever reach the size check.
Self-intersecting or spiky polyline
Watch closelyRDP optimises perpendicular distance, not topology. On a spiky or self-touching polyline, an aggressive tolerance can let a simplified segment cross another part of the path. Simplify gently and inspect the preview for these shapes.
Frequently asked questions
Does this tool simplify Bézier curves?
No. It only simplifies paths whose d is made entirely of M/L (move + line-to) commands. Any path containing C, S, Q, T, or A curve commands — or even H/V shorthand — is passed through completely unchanged. It does not sample curves into polylines and does not refit curves. An all-Bézier Illustrator icon comes out byte-identical. For fewer curve control points, use a vector editor.
What tolerance value should I use?
The slider runs 0.1–5.0 (default 1.0). Start at 1.0 for a safe cleanup that won't visibly change the shape, move to 2–3 for a real cut on rough traces, and only approach 5 for thumbnails or hit-test geometry. Tolerance is in the path's coordinate units, so account for the viewBox scale, and always check the rendered preview.
Why did nothing change after I ran it?
Almost certainly every path in your file used curves (or H/V), so none were eligible — the Polyline paths simplified metric will read 0 and Curve paths preserved will show the count. The other possibility is that the polyline was already minimal: no point lay further than your tolerance from its baseline, so RDP kept everything.
How much smaller will my SVG get?
For eligible polyline paths with redundant nodes, typically 30–60% fewer points at a moderate tolerance, plus an extra trim from rounding surviving coordinates to two decimals. Files with no eligible polylines see 0% from this tool. The result panel shows original vs output bytes and a saved-% badge so you can measure it directly.
Is there a before/after diff overlay?
No. The result panel renders the simplified SVG and offers a collapsible View SVG source, but there is no diff overlay or side-by-side comparison. Compare against the original visually at your real display size; the numeric metrics (paths simplified/preserved, byte sizes) give you the quantitative side.
Can I undo simplification?
Your original file is never modified — the tool emits a new *-simplified.svg and the upload stays in memory. If the result looks wrong, raise the tolerance back up (or down) and re-run, or click Reset to start over. There is no in-tool revert beyond re-processing.
Is this the same as SVGO's path plugins?
No. SVGO's convertPathData mostly shortens number representations and merges commands; it does not run RDP to remove vertices. This tool actually drops control points from polylines using Ramer–Douglas–Peucker — a different, more aggressive geometric optimisation. The two are complementary: simplify here, then minify with SVGO-style passes.
Does it keep my closed shapes closed?
Yes. If an eligible polyline ends in Z/z, the tool re-appends Z after simplification so the shape stays closed. The simplification itself runs on the open point list; the close command is restored verbatim.
What happens to coordinate precision?
Surviving points are re-emitted with two decimal places (x.xx,y.yy). That compounds the byte saving but is a small shape change on tiny viewBoxes. The decimal count is fixed in this tool; if you need explicit control, run the Precision Tuner which rounds path/numeric coordinates to a chosen 0–4 decimal places.
Which tier do I need and what's the size limit?
The Path Simplifier is a Pro feature — free users get an upgrade overlay. The SVG file-size limit is 5 MB on free, 50 MB on Pro, and 2 GB on Developer. Processing time scales with total node count, not raw file size: a small file with tens of thousands of polyline points takes longer than a large file of curves the tool skips.
Is my SVG uploaded anywhere?
No. Processing runs in your browser (or on your own paired runner). The SVG content never reaches a JAD server — the result panel shows a 0 bytes uploaded badge. Only an anonymous run counter increments for dashboard stats.
What's the best follow-up after simplifying?
Chain the byte-focused tools: the Precision Tuner to round remaining coordinates, the Pro-Minifier to strip whitespace/comments, and the Compression Estimator to see the real gzip/brotli transfer size. For the algorithm itself, read the RDP explainer.
Privacy first
Every JAD SVG tool runs entirely in your browser using the DOM API and Canvas. Your SVG files never leave your device — verified by zero outbound network requests during processing.