svgm-core 0.3.8

About

SVG files exported from tools like Figma, Illustrator, and Inkscape often include metadata, redundant attributes, unnecessary wrapper structure, and verbose path data.

SVGO has been the standard SVG optimizer for years. SVGM takes a different approach: a native Rust optimizer designed around fixed-point convergence, safe defaults, and a modern CLI. Like oxlint for ESLint, SVGM targets the same problem with a different architecture.

Fixed-point convergence

In some optimizers, additional runs can still reduce output further because later passes create opportunities for earlier ones. SVGM is designed to converge in a single invocation by running optimization passes over the in-memory AST until the document stabilizes.

$ svgm icon.svg

  icon.svg
  13.5 KiB -> 6.6 KiB (51.1% smaller)  0ms  3 passes

No re-parsing between iterations. No manual multipass flag. One invocation, fixed-point optimization.

Install

From source (requires Rust)

cargo install svgm

Build from repo

git clone https://github.com/madebyfrmwrk/svgm.git
cd svgm
cargo build --release
# Binary at ./target/release/svgm

Usage

svgm icon.svg                    # Optimize in place (overwrites the file)
svgm icon.svg -o icon.min.svg    # Write to a different file
svgm icon.svg --stdout           # Print to stdout instead of overwriting
svgm icon.svg --dry-run          # Preview size reduction without writing
svgm icons/*.svg                 # Optimize multiple files in place
svgm -r ./icons                  # Recursively optimize all SVGs in a directory
svgm -r ./icons -o ./icons-min   # Recursive with output directory
svgm icon.svg --quiet            # Suppress all output except errors

When piped (e.g. svgm icon.svg | gzip), output goes to stdout automatically.

Presets

svgm icon.svg --preset safe       # Removal + normalization only (20 passes)
svgm icon.svg --preset default    # Full optimization (34 passes, default)
svgm icon.svg --precision 2       # Override numeric precision on any preset

Config file

Create an svgm.config.toml in your project root:

preset = "default"
precision = 3

[passes]
convertShapeToPath = false  # opt-out: disable a specific pass

SVGM auto-discovers the config by walking up from the input file's directory. Use --config path to specify explicitly, or --no-config to skip. See svgm.config.example.toml for a starter template.

Benchmarks

100 real-world SVG logos (Figma, Illustrator, Inkscape, svgrepo exports). 902.7 KiB total original size.

Full benchmark details at svgm.dev/docs/benchmarks.

SVGM compresses more than SVGO while being 33x faster.

How it works

Architecture

              parse              optimize              serialize
SVG string ---------> AST tree ---------> AST tree -----------> SVG string
             xmlparser         fixed-point            minified
                                  loop                 output

1. Parse — xmlparser tokenizes the SVG into an arena-based AST with parent pointers
2. Optimize — Run all passes in a loop until no pass reports a change (max 10 iterations)
3. Serialize — Write the AST back as a minified SVG string

Passes operate directly on the in-memory AST, avoiding repeated serialize/parse cycles between iterations.

Optimization passes

Removal — strip dead weight

• Comments, doctypes, XML processing instructions, deprecated attributes
• Editor metadata (Inkscape, Illustrator, Sketch, Figma) and editor-generated descriptions
• Empty containers, empty attributes, empty text elements, useless defs
• Unused namespace declarations, non-inheritable group attributes
• Attributes matching SVG spec defaults (opacity="1", stroke="none", version="1.1", etc.)
• Useless stroke/fill sub-properties when the primary is invisible

Normalization — tighten values

• Collapse whitespace in attributes, minify inline styles
• Round numeric values with smart precision (tries lower precision when error is acceptable)
• Shorten colors: rgb(255,0,0) -> red, #aabbcc -> #abc (including in style="")
• Promote common child attributes to parent group
• Sort <defs> children for better compression
• Clean up deprecated enable-background

Structural — simplify the tree

• Collapse useless <g> wrappers (no-attribute groups, single-child groups with transform merging)
• Distribute group transforms to children when safe
• Reference safety: groups with clip-path, mask, or filter are never collapsed

Transform — simplify and apply transforms

• Merge consecutive transforms into a single equivalent (translate(10,20) translate(5,5) -> translate(15,25))
• Decompose matrices to shorter forms (matrix(a,0,0,a,tx,ty) -> translate(tx,ty)scale(a))
• Remove identity transforms (scale(1), translate(0,0), rotate(0))
• Apply pure translates directly to element coordinates and path data (with length comparison)
• Push transforms from single-child groups to child, enabling group collapse
• Optimize gradientTransform and patternTransform

Geometry — compress path data

• Shape-to-path conversion (rect, circle, ellipse, line, polyline, polygon → shorter <path>)
• Ellipse-to-circle conversion when rx equals ry
• Path merging (adjacent non-overlapping paths with identical attributes, with geometric intersection safety)
• Cubic-to-quadratic Bezier conversion (C → Q when losslessly possible)
• Cubic-to-arc conversion (detects circular arc curves)
• Smart arc radius rounding (sagitta-based geometric validation)
• Absolute-to-relative coordinate conversion where shorter (precision-aware comparison)
• L to H/V shortcut commands, consecutive h/v merging
• C to S and Q to T shorthand curves (reflected control points, including after non-curve commands)
• Degenerate curve to line simplification (collinear control points)
• Redundant command removal (zero-length lines, lineto before closepath)
• Strip leading zeros (.5 instead of 0.5), no space after command letters
• Implicit command repetition, minimal separator insertion

IDs — clean up references

• Remove unused id attributes
• Shorten referenced IDs to minimal unique names

Safety

SVGM is conservative by default:

• <desc> and <title> are preserved (accessibility semantics)
• <symbol> and <defs> with id attributes are never removed (may be referenced)
• Animation elements (<animate>, <animateTransform>, etc.) are fully preserved
• <foreignObject> content is never touched
• fill="black" on <svg> is kept (inherited by children)
• Default attributes are only removed when safe to inherit — ancestor chain is checked first

Rust API

use svgm_core::optimize;

let result = optimize("<svg>...</svg>").unwrap();
println!("{}", result.data);       // optimized SVG string
println!("{}", result.iterations); // convergence iterations

With preset/precision control:

use svgm_core::{optimize_with_config, Config, Preset};

let config = Config {
    preset: Preset::Safe,
    precision: Some(2),
    ..Config::default()
};
let result = optimize_with_config("<svg>...</svg>", &config).unwrap();

Project structure

svgm/
├── crates/
│   ├── svgm-core/       # Parser, AST, optimizer, serializer, passes
│   ├── svgm-cli/        # CLI binary (clap + indicatif)
│   ├── svgm-wasm/       # WebAssembly build (npm: svgm-wasm)
│   └── svgm-napi/       # Node.js native addon (npm: svgm-node)
├── LICENSE-MIT
└── LICENSE-APACHE

Roadmap

• Transform merging, application, and push-down (all 3 phases)
• Shape-to-path conversion (rect, circle, ellipse → shorter <path>)
• Path merging (adjacent paths with identical attributes)
• ID cleanup (remove unused, shorten used)
• CSS <style> inlining and minification
• Recursive directory processing (-r)
• Safety presets and config file support
• WASM build for browser usage
• SVGO feature parity (34 passes, compression at par)
• Node.js bindings via napi-rs

Contributing

SVGM is early, but already usable. Contributions and real-world SVG edge cases are especially helpful.

git clone https://github.com/madebyfrmwrk/svgm.git
cd svgm
cargo test --workspace
cargo clippy --workspace  # must pass clean

If you find an SVG that SVGM corrupts or handles worse than expected, please open an issue with the SVG attached.

License

Dual-licensed under MIT and Apache 2.0.