How to svg minifiers compared: jad, svgomg, svgo, and manual cleanup
- Step 1Decide your risk tolerance — If the asset is hand-curated and you want guaranteed-identical rendering with zero config, use the JAD minifier. If you're optimising bulk machine-generated icons and can spot-check the result, SVGO's aggressive plugins squeeze more out.
- Step 2Run the JAD minifier first — Drop or paste your SVG into the tool above. It strips comments, whitespace, the XML prolog, editor namespaces, and empty elements in one pass — the same safe removals SVGO does, with none of the geometry-altering ones. Note the percent reduction.
- Step 3Add precision rounding if you need more — SVGO's biggest win is usually
convertPathData/cleanupNumericValuesrounding. JAD exposes that as svg-precision-tuner — pick 0–4 decimals. Two decimals is the common sweet spot for icons. - Step 4Simplify polylines if the path has redundant nodes — For traced or hand-drawn polyline paths, svg-path-simplifier applies Ramer–Douglas–Peucker node reduction — analogous to SVGO removing redundant points. It skips any path containing curve commands, so curves are never faceted.
- Step 5Prune dead defs and metadata explicitly — Match SVGO's
removeUnusedNS/removeUselessDefswith svg-unused-defs-purger, and itsremoveMetadata/removeTitlebehaviour with svg-metadata-scrubber — each as a deliberate, reviewable step. - Step 6Verify the wire size — Reduction percent on raw bytes isn't the whole story — servers gzip/brotli SVG. Compare your optimised output across tools using svg-compression-estimator to see the real transferred size.
JAD minifier vs SVGOMG / SVGO / manual
Feature-by-feature. "Safe" means the transform cannot change rendering. SVGO/SVGOMG figures reflect their default-plus-common plugin sets as of 2026; exact behaviour depends on which plugins you enable.
| Capability | JAD minifier | SVGOMG / SVGO | Manual edit |
|---|---|---|---|
| Strip comments | Yes (safe) | Yes (removeComments) | Tedious |
| Collapse inter-tag whitespace | Yes (safe) | Yes (cleanupListOfValues / pretty off) | Tedious |
| Remove XML prolog | Yes (safe) | Yes (removeXMLProcInst) | Easy |
| Strip editor namespaces | Yes (safe, fixed list) | Yes (removeEditorsNSData) | Hard to be exhaustive |
| Round coordinate precision | No — use svg-precision-tuner | Yes (cleanupNumericValues) | Error-prone |
| Collapse/merge path data | No — use svg-path-simplifier (polylines only) | Yes (convertPathData, mergePaths) | Impractical |
| Remove unused defs | No — use svg-unused-defs-purger | Yes (removeUselessDefs) | Risky by hand |
| Remove viewBox | Never | Optional (removeViewBox — breaks scaling!) | Don't |
| Configurable plugins | None (one fixed pass) | Dozens of toggles | n/a |
| Reproducible / idempotent | Yes | Depends on config | No |
| Runs locally (no upload) | Yes | Yes (SVGOMG is client-side) | Yes |
SVGO plugin → JAD tool mapping
If you're replacing an SVGO config, here's which JAD tool covers each common plugin. Run the minifier first, then add only the steps you actually need.
| SVGO plugin | What it does | JAD equivalent |
|---|---|---|
| removeComments | Drop <!-- --> | Built into the minifier |
| removeXMLProcInst | Drop <?xml?> | Built into the minifier |
| removeEditorsNSData | Drop inkscape/sodipodi/dc/cc/rdf NS | Built into the minifier |
| removeEmptyAttrs / removeEmptyContainers | Drop attr="" and empty <g> | Built into the minifier |
| cleanupNumericValues / convertPathData (rounding) | Round coordinates | svg-precision-tuner |
| convertPathData (point removal) | Remove redundant path points | svg-path-simplifier (polylines only) |
| removeUselessDefs | Drop unreferenced defs | svg-unused-defs-purger |
| removeMetadata / removeTitle / removeDesc | Drop metadata + a11y text | svg-metadata-scrubber |
Cookbook
Side-by-side outcomes on the same input, so you can see exactly where the tools diverge in behaviour (not just headline percentages).
The viewBox footgun JAD avoids
SVGO's removeViewBox plugin (and SVGOMG's matching toggle) strips the viewBox when width/height are present — which silently breaks responsive scaling. The JAD minifier never removes the viewBox.
Input: <svg width="24" height="24" viewBox="0 0 24 24"><path d="M3 12h18"/></svg> SVGO with removeViewBox enabled: <svg width="24" height="24"><path d="M3 12h18"/></svg> → no longer scales in a flexible container. JAD minifier: <svg width="24" height="24" viewBox="0 0 24 24"><path d="M3 12h18"/></svg> → viewBox preserved; responsive scaling intact.
Same safe removals, identical render
On the safe transforms, JAD and SVGO converge. Comments, prolog, editor namespaces, and whitespace all go.
Input (Inkscape, 360 B): <?xml version="1.0"?> <svg xmlns="http://www.w3.org/2000/svg" xmlns:inkscape="..." viewBox="0 0 16 16"> <!-- created with inkscape --> <rect width="16" height="16"/> </svg> JAD minifier output: <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><rect width="16" height="16"/></svg> → matches SVGO's safe-plugin output here.
Where SVGO wins: precision rounding
SVGO rounds long coordinate strings by default. JAD's minifier doesn't — but svg-precision-tuner does, and you choose the decimals.
Input path: <path d="M12.347826 4.913043 L 19.082608 11.5"/> JAD minifier alone (unchanged numbers): <path d="M12.347826 4.913043 L 19.082608 11.5"/> Then svg-precision-tuner @ 2 decimals: <path d="M12.35 4.91 L19.08 11.5"/> → this is the SVGO-equivalent step, done explicitly.
Where SVGO wins: aggressive path conversion
SVGO can convert shapes to paths and merge subpaths. JAD's path simplifier only reduces points on pure polyline paths and skips anything with curves — narrower, but it never faceted a curve by accident.
Input (a traced polyline with redundant nodes): <path d="M0 0 L1 0.02 L2 0 L3 0.01 L10 0"/> JAD svg-path-simplifier @ tolerance 1.0: <path d="M0.00,0.00 L10.00,0.00"/> A path with C/Q/A curve commands is left untouched by JAD (use SVGO if you must crunch curve data, then spot-check).
CI reproducibility difference
JAD's fixed pass is idempotent — re-running yields identical bytes, so it never churns diffs. An SVGO config can produce different output across versions or plugin updates.
JAD minifier, run twice: pass 1 → logo-minified.svg (1,204 bytes) pass 2 → logo-minified.svg (1,204 bytes) ← identical SVGO across a version bump can re-order or re-round: svgo 3.0 → 1,210 bytes svgo 3.2 → 1,198 bytes ← diff churn in git
Edge cases and what actually happens
SVGOMG's removeViewBox toggle
Risk avoidedEnabling removeViewBox in SVGOMG/SVGO strips the viewBox when width/height exist, which breaks flexible scaling — a very common regression. The JAD minifier has no such transform; the viewBox is always preserved.
You need SVGO-level path crunching
Out of scopeJAD does not collapse Bézier path data or merge subpaths. For heavy reduction of generated/auto-traced curve data, SVGO's convertPathData/mergePaths go further — use SVGO for that specific case and visually verify, since those plugins can alter rendering.
Matching an existing svgo.config.js
SupportedYou can reproduce most of an SVGO config by chaining JAD tools: minifier (comments/whitespace/NS/empties) → svg-precision-tuner (numbers) → svg-path-simplifier (points) → svg-unused-defs-purger. The geometry-altering plugins have no JAD analogue by design.
Title/desc removal differs
By designSVGO can strip <title>/<desc> via removeTitle/removeDesc. The JAD minifier keeps them for accessibility. If you want them gone, that's svg-metadata-scrubber — a separate, explicit choice rather than a hidden default.
Inline `<style>` minification
Out of scopeSVGO has minifyStyles (powered by csso). The JAD minifier does not minify CSS inside <style> blocks — selectors and declarations are preserved verbatim. For CSS-heavy SVGs this is a small size difference but guarantees styling is untouched.
Privacy of in-browser tools
ParitySVGOMG runs SVGO compiled to client-side JS; the JAD minifier also runs in-browser. Neither uploads your file. JAD additionally stores no file content server-side — only an anonymous run counter for dashboard stats.
Bulk/batch optimisation
DiffersThe SVGO CLI shines at batch optimising a whole folder in one command. The JAD web minifier processes one file per run; for automation, pair the @jadapps/runner and script GET /api/v1/tools/svg-pro-minifier plus the runner's /v1/tools endpoint so files never leave your machine.
Configurability expectation
By designIf you expect plugin toggles, the JAD minifier will feel sparse — that's intentional. The value is a guaranteed-safe, zero-config pass. Configurable behaviour lives in the dedicated sibling tools where each option's effect is explicit.
Frequently asked questions
Is the JAD minifier just SVGO under the hood?
No. It's a focused set of safe text transforms (comments, whitespace, XML prolog, editor namespaces, empty elements, empty attributes), not the SVGO plugin engine. It intentionally omits SVGO's geometry-altering plugins. The rounding and path-reduction that SVGO is known for live in separate JAD tools you opt into explicitly.
Which gets my files smaller — JAD or SVGOMG?
On raw bytes, SVGO/SVGOMG can go further because they also round numbers and crunch path data. But you can close most of the gap by chaining JAD's minifier with svg-precision-tuner and svg-path-simplifier. The remaining difference is mostly SVGO's aggressive curve-data conversion, which carries rendering risk.
Why doesn't JAD remove the viewBox like SVGO can?
Because removing the viewBox breaks responsive scaling — it's one of the most common SVGO regressions. JAD never touches the viewBox, so an optimised icon always keeps the ability to scale fluidly in a flexible container.
Can I reproduce my svgo.config.js with JAD tools?
Most of it. Map the safe plugins to the built-in minify pass, cleanupNumericValues to svg-precision-tuner, redundant-point removal to svg-path-simplifier, and removeUselessDefs to svg-unused-defs-purger. The geometry-rewriting plugins (convertShapeToPath, mergePaths) have no JAD equivalent by design.
Is SVGOMG safe to use? Why pick JAD instead?
SVGOMG is excellent and runs locally. JAD's pitch is different: a single guaranteed-safe pass with no toggles to misconfigure, reproducible output for CI, and modular follow-up tools where each riskier transform is an explicit, reviewable step rather than a hidden default.
Does the JAD minifier round numbers like SVGO?
No. Coordinate precision is untouched by minify. Use svg-precision-tuner and choose 0–4 decimals — that's the JAD equivalent of SVGO's number cleanup, and it's usually the single biggest path-data saving.
Which tool is better for path simplification?
For curve-heavy data, SVGO's convertPathData is more powerful (and riskier). JAD's svg-path-simplifier is narrower and safer: it only reduces nodes on pure polyline (M/L) paths and skips anything containing curve commands, so it can never accidentally facet a smooth curve.
Do both tools keep my SVG private?
Yes. SVGOMG runs SVGO as in-browser JavaScript; JAD's minifier also processes entirely client-side. Neither uploads your file. JAD stores no file content — only an anonymous "tool ran" counter for signed-in dashboards.
What about minifying CSS inside `<style>` tags?
SVGO has a minifyStyles plugin; JAD's minifier doesn't minify embedded CSS. For most icons this is negligible, and keeping the CSS verbatim guarantees styled SVGs render identically. If CSS size matters, minify the stylesheet separately.
Can I automate JAD minification like the SVGO CLI?
Yes, via the runner. Pair the @jadapps/runner, fetch the tool schema with GET /api/v1/tools/svg-pro-minifier, and POST jobs to the runner's /v1/tools endpoint on 127.0.0.1:9789. The transform runs in-process locally, so files never reach JAD's servers — see the GitHub Actions guide for a full pipeline.
Why is JAD's output identical every time?
The minify pass is a fixed sequence of deterministic transforms with no configurable options, so the same input always yields the same output. That idempotence is ideal for CI — re-running never churns your git diff, unlike an SVGO config that can shift across versions or plugin updates.
Is manual editing ever worth it?
Rarely for whole-file optimisation — it's slow and error-prone. Manual edits make sense for surgical changes (renaming an id, fixing one attribute). For bulk cleanup, the JAD minifier plus its sibling tools, or the SVGO CLI, will always be faster and more consistent.
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.