How to svg precision tuner: technical faq and troubleshooting guide
- Step 1Start conservative at 2 — Begin at the default 2 decimal places and view the output at the sizes you actually ship. If it is identical, try 1 for a bigger saving. Only drop to 0 for simple geometric icons.
- Step 2Check curves for kinks — Zoom the preview on smooth curves and circular arcs. Over-rounding shows as faint angularity where a curve should be smooth. If you see it at 2x zoom, step the precision back up — the tuner rounds numbers but does not refit curves.
- Step 3Test at real display size — Most icons ship at 16–48px. A distortion that is obvious at 400% zoom is usually invisible at 24px. Judge at the size users see, not at the zoom level you debug at.
- Step 4Keep the original to re-tune — Rounding is one-way — once you save a tuned file, the discarded digits are gone. Always tune from the original source so you can re-run at a higher precision if you over-rounded. Do not tune an already-tuned file repeatedly.
- Step 5Confirm what changed — Open the source view in the result panel (or diff against the original). Only numbers in
dand the rounded attributes should differ. Colours, IDs, classes, viewBox, and transforms must be unchanged — if they are, the tuner worked correctly. - Step 6Chain to the right next tool — For fewer nodes, use the path simplifier. For whitespace/structure, the minifier. For editor signatures, the metadata scrubber. The tuner does the precision step and hands off the rest.
Safe precision by asset type
Recommended Decimal places slider value. The right value is the lowest one that still looks correct at your actual display size.
| Asset type | Recommended places | Why |
|---|---|---|
| Simple geometric icons (arrows, checks) | 0–1 | Coordinates snap to whole/near-whole units with no visible loss |
| Standard UI icons at 16–64px | 1 | ±0.05px error — imperceptible, strong byte saving |
| Brand logos | 2 (default) | Safe at any normal size; preserves subtle curves |
| Detailed illustrations | 2 | Keeps fine curve geometry while still trimming float noise |
| Large hero / zoomed artwork | 2–3 | Higher precision avoids visible kinks when shown large |
Rounded vs preserved (quick reference)
The tuner is numeric-only. This is the definitive list of what it edits and what it never touches.
| Item | Rounded? |
|---|---|
d path data (M/L/C/S/Q/T/A/H/V numbers, arc radii) | Yes |
cx cy x y r rx ry x1 y1 x2 y2 width height points | Yes |
stroke-width / data-x (caught by word boundary) | Yes (side effect) |
viewBox | No |
transform | No |
Gradient offset, stop-color, CSS in <style> | No |
fill/stroke colours, id, class, ARIA | No |
Scientific-notation exponent (e.g. e-5) | No (left attached) |
Cookbook
Troubleshooting recipes — symptom, cause, fix. All grounded in the tuner's actual behaviour.
Symptom: curve looks faceted after tuning
Cause: rounded too hard for the curve's scale, usually 0 places on Bézier/arc control points. Fix: re-tune the original at 1–2 places. The tuner does not refit curves, so prevention beats cure.
Bad: decimalPlaces = 0 on a logo with C curves
→ visible kinks at display size
Fix: re-run the ORIGINAL at decimalPlaces = 2
(a tuned file has already lost the digits)Symptom: viewBox still has long decimals
Cause: viewBox is intentionally out of scope. Fix: this is correct — leave it, or edit the viewBox by hand. Rounding it could rescale the artwork.
viewBox="0 0 23.999998 23.999998" → unchanged (by design) The tuner only rounds path data + listed shape attrs. Clean the viewBox manually if you must.
Symptom: stroke-width changed unexpectedly
Cause: the attribute match keys on a word boundary before 'width', so 'stroke-width' is caught. Fix: usually harmless; raise precision if you need a high-precision stroke.
stroke-width="1.500003" → (1 place) stroke-width="1.5" Expected. If 1.500003 truly mattered, use more places.
Symptom: 'Invalid SVG' on paste
Cause: pasted markup did not parse as valid SVG XML. Fix: ensure a real <svg> root and matched tags, or upload the .svg file instead of pasting.
Error: Invalid SVG — could not parse the pasted content
as valid SVG XML
Fix: paste complete, well-formed <svg>...</svg>
or drag the .svg file onto the drop zoneSymptom: file barely got smaller
Cause: most bytes were tags/colours/metadata, not coordinates. Fix: chain the other optimisers — precision tuning only shortens numbers.
Saved: 3% → coordinates were a small slice of the file
Next: svg-metadata-scrubber + svg-unused-defs-purger
+ svg-pro-minifier → attack the restEdge cases and what actually happens
Over-rounded and the digits are gone
IrreversibleRounding discards the extra digits permanently — a tuned 12 cannot become 12.0000390625 again. There is no 'restore precision' button because the information is gone. Always tune from a kept original so you can re-run at a higher precision if you went too far.
Tuning an already-tuned file
No further changeRunning the tuner again at the same or higher precision on an already-rounded file does nothing useful (0% saved) — the digits are already short. Running it at a lower precision rounds further but from the lossy intermediate, which can compound error on curves. Tune once, from the original.
Curve with C/S/Q/T/A commands at 0 places
Over-roundedBézier control points and arc parameters round like any other number, but they sit off the visible path, so coarse rounding can shift the curve enough to see. The tuner does not refit curves. Keep curve-heavy shapes at 1–2 places, and use the path simplifier if your goal is fewer nodes rather than shorter numbers.
Arc (A) flags and radii rounded
Watch on complex arcsAn arc command's rx, ry, and endpoint coordinates are rounded along with everything else; the large-arc and sweep flags are 0/1 and unaffected by rounding. On tight or complex arcs, aggressive rounding of rx/ry can subtly change the arc. Preview arcs after tuning at low precision.
No input provided
RejectedProcessing with no file and no pasted source returns Please upload an SVG file or paste SVG source code. The tuner transforms an input; it does not generate anything.
Pasted markup is not valid SVG
Invalid SVGPasted content that fails to parse as SVG XML is rejected with Invalid SVG — could not parse the pasted content as valid SVG XML before any rounding. Upload the original file or fix the markup.
File over the tier size limit
413-style blockInputs over 5 MB on free (50 MB on Pro) are blocked before processing with a message naming the limit and tier. SVGs rarely reach this; if one does, simplify or minify it first, or upgrade for the larger ceiling.
Expecting per-element precision control
Not availableThere is no UI to set different precision for specific elements — the single slider applies globally. For element-level control you would use SVGO's convertPathData in code. This tool intentionally trades that flexibility for a one-knob, predictable pass.
Expecting it to clean viewBox or transforms
Out of scopeviewBox and transform are never rounded. If those carry the bloat you care about, flatten transforms in your design tool or add an SVGO pass — the Precision Tuner deliberately limits itself to path data and the listed shape attributes.
Numbers in a CSS <style> block unchanged
PreservedThe tuner rewrites presentation attributes and the d string only. Values inside a <style> block (e.g. a stroke-width: 1.5px rule) are not rounded. Move presentation to attributes if you want them tuned, or accept they are out of scope.
Frequently asked questions
What is the minimum safe precision for smooth curves?
1 decimal place for icons displayed at 16–64px, where the error is about ±0.05px — invisible. For SVGs shown at 200px and up (hero illustrations, large logos), use 2 places to keep curves smooth. The tuner rounds without refitting, so go gentler on curve-heavy artwork.
Exactly which attributes get rounded?
The d path data and the numeric attributes cx cy x y r rx ry x1 y1 x2 y2 width height points. That covers path, circle, rect, ellipse, line, polyline, and polygon geometry. Because the match uses a word boundary, attributes ending in those names — like stroke-width or data-x — are also caught.
Are arcs (the A path command) affected?
Yes — an arc's rx, ry, and endpoint coordinates are rounded like any other number. The large-arc-flag and sweep-flag are 0 or 1 and are unaffected by rounding. On tight or complex arcs, rounding rx/ry aggressively can slightly change the arc, so preview at low precision.
Can I preserve precision for specific elements?
Not in this tool — the single slider applies globally. For element-level precision control you would use SVGO's convertPathData plugin in code. The Precision Tuner intentionally offers one predictable knob rather than per-element configuration.
What is the file-size limit?
5 MB per file on the free tier and 50 MB on Pro, with higher limits on Developer and above. The tuner processes text quickly, so even large illustration SVGs are handled fast — but a giant auto-traced file could exceed the free limit, in which case simplify or minify it first.
Does it touch viewBox or transforms?
No. viewBox and transform are deliberately excluded, because changing them can rescale or move the artwork. The tuner rounds only the path data and the listed shape attributes. Clean viewBox or transform values manually or with an SVGO pass if needed.
Why did stroke-width change when I only wanted path data rounded?
The attribute matcher keys on a word boundary before names like width and x, so stroke-width (ending in width) and data-x (ending in x) are also rounded. At sensible precision this is harmless — 1.500003 becoming 1.5 is fine. If a high-precision stroke-width matters, choose a higher decimal-places value.
Can I undo a precision reduction?
No — rounding permanently discards the extra digits, so a tuned file cannot regain them. Always keep the original and re-tune from it if you over-rounded. Never repeatedly tune the same output file.
Does it change colours, IDs, or classes?
No. Only numeric coordinate values are rewritten. fill, stroke, hex colours, id, class, ARIA attributes, and element order are preserved exactly. To recolour, use a colour tool; to rename IDs, use a different step entirely.
How is this different from path simplification?
Precision tuning rounds existing coordinates and removes no points — the shape is preserved. Path simplification (the path simplifier) deletes whole points to cut node count and can change geometry. Use the tuner for a clean, lossless-looking pass; use the simplifier when you specifically need fewer nodes.
Does it use SVGO?
No. It is a focused regex rewrite that rounds numbers in the d attribute and listed shape attributes — it never converts command types, merges segments, or restructures paths. For SVGO-style structural minification, run the minifier after tuning.
Is my file uploaded?
No. The Precision Tuner runs entirely in your browser (or your own paired runner on Pro+ tiers), and the result panel shows a '0 bytes uploaded' badge. Source SVGs never reach JAD servers.
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.