How to svg path simplifier: tolerance, quality, and troubleshooting
- Step 1Identify whether your path is even eligible — Open the
dof the path you care about. PureM/L? Eligible. ContainsC/S/Q/T/AorH/V? It will be returned unchanged — no tolerance value will alter it. The result panel'sPolyline paths simplifiedvsCurve paths preservedconfirms this after a run. - Step 2Pick a tolerance from the type recipe — Use the per-type table below as a starting point: traced bitmap polylines tolerate the most; large on-screen polylines the least. Set the slider, process, and read the metrics.
- Step 3Account for coordinate scale — Tolerance is in coordinate units, not pixels. On a small viewBox (e.g. 24), a value of 1.0 is already strong; on a 1000-unit illustration it's gentle. If results feel too aggressive or too weak, it's usually the coordinate scale — adjust the value to the path's range.
- Step 4Inspect the rendered preview for faceting — Zoom the preview on what should be a smooth run. If a polyline that approximated a curve now shows straight chords, lower the tolerance by roughly half and re-run. There's no diff overlay, so compare against the original at your target size.
- Step 5Don't fight curves with this tool — If a circle-as-path or a Bézier illustration isn't shrinking, that's expected — it's not a polyline. Stop adjusting tolerance; switch tools (an editor for curve simplification) or use the Precision Tuner to at least round coordinates.
- Step 6Finish with the byte-focused tools — RDP removes nodes but leaves whitespace, comments, and other numbers alone. After simplifying, run the Pro-Minifier and confirm the real saving with the Compression Estimator.
Tolerance starting points by SVG type
All values fit the 0.1–5.0 slider. These assume the path is an eligible M/L polyline at the stated coordinate scale; curve paths are never affected regardless of value. Preview before committing.
| SVG type (polyline paths) | Suggested tolerance | Notes |
|---|---|---|
| Large logo / illustration polyline (shown 100–300px+) | 0.3–0.5 | Low tolerance preserves on-screen smoothness at size |
| UI icon polyline (16–64px) | 1.0–2.0 | Default 1.0 is safe; 2.0 for a real node cut |
| Auto-traced bitmap (straight-segment output) | 1.5–3.0 | Traces carry many redundant points; tolerate more |
| Thumbnail / loading decoration | 3.0–5.0 | Shape fidelity is non-critical; maximise reduction |
| Flattened curve approximated as a polyline | 0.3–1.0 | Higher values facet the 'curve' visibly — go gentle |
What this tool cannot do (use the right tool)
Common requests that fall outside the simplifier's scope, with the accurate alternative.
| You want to… | Does this tool do it? | Use instead |
|---|---|---|
| Reduce control points on Bézier curves | No — curves are preserved unchanged | A vector editor (Illustrator/Inkscape simplify) |
| Apply a different tolerance per path | No — tolerance is global | Split paths into separate files and run each, or edit in code |
| Round coordinates to N decimal places | Fixed at 2 decimals; not configurable | Precision Tuner (0–4 places) |
| Strip whitespace / comments / metadata | No — only node removal | Pro-Minifier, Metadata Scrubber |
| Remove unused defs/gradients | No | Unused Defs Purger |
| Simplify H/V straight-line paths | No — H/V makes a path ineligible | Convert H/V to explicit L first, then simplify |
Cookbook
Per-type quality recipes and troubleshooting walk-throughs. The tool changes only M/L polylines; curve paths return identical.
An auto-traced icon: find the highest safe tolerance
A bitmap traced to straight segments has hundreds of redundant points. Step the tolerance up until the preview just starts to degrade, then back off one notch.
tolerance 0.5 → 30% fewer points, indistinguishable tolerance 1.5 → 55% fewer points, still clean tolerance 3.0 → 70% fewer, slight corner rounding begins Choose 1.5 (the last value before visible change).
A logo shown large: stay conservative
A polyline logo displayed at 240px reveals faceting that a 24px icon would hide. Keep tolerance low and verify at the real display size.
Displayed at 240px, viewBox 0 0 240 240: tolerance 0.3 → smooth, ~20% fewer points tolerance 1.0 → faint flat spots on curves-as-polylines Use 0.3–0.5 for large display; check at 100% zoom.
A 'circle' that won't simplify
A circle drawn with arc (A) or Bézier (C) commands is not a polyline, so no tolerance changes it. This is correct behaviour — recognise it and switch approach.
<path d="M12,2 A10,10 0 1,0 12,22 A10,10 0 1,0 12,2 Z"/> tolerance = anything → identical output Result: Curve paths preserved: 1 → A real <circle> or curve-simplify in an editor; not here.
Diagnosing 'too aggressive' — it's the scale
The same tolerance wrecks a 24-unit icon but barely touches a 1000-unit drawing. The fix is matching tolerance to coordinate range, not lowering it blindly.
Icon viewBox 0 0 24 24, tolerance 1.0 → heavy loss (1/24 of width!) Drawing viewBox 0 0 1000 1000, tolerance 1.0 → negligible Rule of thumb: scale tolerance with the viewBox's coordinate span.
Quality then size: the correct chain
Simplification handles geometry; other tools handle bytes. Run them in order for the best result without over-simplifying.
1) Path Simplifier tolerance 1.0 → fewer polyline nodes 2) Precision Tuner 2 decimals → shorter coordinate numbers 3) Pro-Minifier → strip whitespace/comments 4) Compression Estimator → verify gzip/brotli transfer size
Edge cases and what actually happens
Curve-based SVGs show no quality change at any tolerance
PreservedPaths with C/S/Q/T/A are returned unchanged for every tolerance value — they're never simplified, so they can't be degraded. If a logo or illustration won't shrink, it's curves, not a tolerance problem. The tool will not facet a real Bézier; the only thing it faceted in old descriptions doesn't happen.
Over-simplified polyline goes angular
Over-simplifiedThe one genuine quality failure: too high a tolerance drops points that defined a polyline's shape, so smooth runs become straight chords and corners round off. Lower the tolerance (try halving it) and re-run. The right value is the largest one that still looks correct at your display size.
Tolerance feels far too strong for an icon
Scale-relativeTolerance is in coordinate units. On a 24-unit icon viewBox, 1.0 is 1/24 of the width — large. On a 1000-unit drawing it's negligible. Match the value to the coordinate range, not to the on-screen pixel size, to get consistent results across files.
Want per-path tolerance — not available
UnsupportedThe slider applies one global tolerance to every eligible path in the file; there's no per-path control in the UI. To vary it, separate the paths into different files and run each at its own tolerance, or edit the geometry in code. (And no, you can't set per-path RDP through the tool's options — there's only tolerance.)
Need a specific decimal precision
FixedSurviving points are written at two decimals (toFixed(2)); this isn't configurable in the simplifier. For explicit precision control (0–4 places) across all coordinates — including curve paths — use the Precision Tuner instead or afterward.
QR codes, technical diagrams, maps, CNC/embroidery
Don't simplifyThese need exact coordinates — a dropped vertex breaks a QR module, a dimension, or a toolpath. Don't run them through any geometric simplifier. (Most of these are polylines, so the tool *would* act on them — which is exactly why you must avoid it here.)
Nothing changed and the saved-% is 0
ExpectedEither every path had curves/H/V (ineligible), or no point on an eligible polyline lay further than the tolerance from its baseline. Both are correct outcomes — RDP never introduces error beyond the tolerance and never touches ineligible paths. Check the Polyline paths simplified count to see which case you hit.
Pro tier required; file over the size cap
RejectedThe simplifier is Pro-minimum, so free-tier users get an upgrade overlay rather than the slider. SVG file limits are 5 MB (free), 50 MB (Pro), 2 GB (Developer); oversized files throw a per-job-limit error before any processing happens.
Frequently asked questions
What settings does the Path Simplifier actually have?
Exactly one: a tolerance slider from 0.1 to 5.0 (step 0.1, default 1.0). There is no per-path control, no curve-fitting mode, no decimal-precision setting, and no preset buttons. Tolerance is the maximum distance, in the path's coordinate units, that the simplified line may deviate from the original.
What SVG types should NOT be simplified?
QR codes, technical diagrams, maps, data visualisations, and CNC/embroidery patterns — anything where exact coordinates matter, since a dropped vertex corrupts the result. Many of these are polylines the tool *would* act on, so the responsibility to avoid it is yours. Use this tool for icons, traces, and decorative polylines instead.
Why won't my logo or illustration shrink at any tolerance?
Because it's built from curves. Paths containing C/S/Q/T/A are returned unchanged regardless of tolerance — the tool only simplifies M/L polylines and does not sample or refit curves. To reduce curve control points, simplify in a vector editor; here, the Precision Tuner can at least shorten coordinate numbers.
Can I apply different tolerances to different paths in one SVG?
Not in the UI — the slider applies one global tolerance to every eligible path. For per-path control, split the paths into separate files and run each at its own value, or edit the geometry directly in code. The tool exposes only the single tolerance option.
How do I troubleshoot angular distortion after simplifying?
If straight chords appear where a polyline approximated a curve, the tolerance was too high — halve it and re-run, checking the preview at your target display size. Remember tolerance is in coordinate units, so on small viewBoxes even modest values are aggressive. Distortion can only happen on polylines; curves are never touched.
What tolerance should I use for icons vs illustrations?
For UI icons (16–64px) start at 1.0 and try up to 2.0; for large illustrations/logos shown at 100–300px+, use 0.3–0.5 to preserve on-screen smoothness; for auto-traced bitmaps use 1.5–3.0. Always scale these to the path's coordinate range, and preview before committing.
How many nodes should a good icon have?
A well-built 24px icon typically lands around 10–50 total nodes across its paths. Auto-traced icons with hundreds of polyline points benefit most from simplification — but only the M/L portions; any curved accents are left as the editor drew them.
Does it change coordinate precision?
Yes — surviving points are re-emitted at two decimal places, which trims a few bytes but is a small shape change on tiny viewBoxes. The decimal count is fixed in this tool. For explicit 0–4-place control across the whole file, run the Precision Tuner.
Is this the same optimisation as SVGO?
No. SVGO's path passes mainly shorten and merge number/command representations; they don't run RDP to remove vertices. This tool removes polyline nodes geometrically. Use both: simplify here, then minify with SVGO-style passes (or the Pro-Minifier) for the byte stripping RDP doesn't do.
What's the maximum file size and tier?
The tool is Pro-minimum, so free-tier users see an upgrade overlay. SVG file limits are 5 MB on free, 50 MB on Pro, and 2 GB on Developer. Processing time scales with total polyline node count, not raw file size — a small file dense with M/L points can take longer than a large file of curves the tool skips.
Is there a before/after comparison view?
The result panel renders the simplified SVG and lets you expand View SVG source, plus numeric metrics (paths simplified vs preserved, byte sizes, saved-%). There's no diff overlay or side-by-side, so compare against your original visually at the real display size.
What's the recommended end-to-end optimisation order?
Simplify polyline geometry here, round coordinates with the Precision Tuner, strip whitespace/comments/metadata with the Pro-Minifier and Metadata Scrubber, drop dead defs with the Unused Defs Purger, then verify transfer size with the Compression Estimator.
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.