How to svg fonts vs modern formats: how we got here
- Step 1Place the format on the timeline — SVG Fonts were specified in SVG 1.1 (2003) and never updated; WOFF was published 2010 and recommended 2012; WOFF2 reached W3C Recommendation in 2018. SVG Fonts were removed from SVG 2 and dropped by Chrome in 2015. Knowing the dates explains why so much old documentation still mentions them.
- Step 2Separate SVG Fonts from color-SVG OpenType — The deprecated SVG **Fonts** format is a standalone XML document with `<font>`/`<glyph>` elements. The modern `SVG ` table inside an OpenType font (used for color emoji and color icons) is a completely different thing that is alive and well. Don't migrate one expecting the other.
- Step 3Compare on compression — The decisive loss: SVG Fonts have no compression. WOFF wraps an sfnt in zlib; WOFF2 uses Brotli plus a font-aware transform. An SVG Font of the same typeface is often 4–8× the size of its WOFF2 equivalent. For the bandwidth-conscious web of the 2010s, that alone was fatal.
- Step 4Compare on shaping and features — WOFF/WOFF2 carry the full OpenType payload — GSUB ligatures, GPOS kerning, variable-font axes. SVG Fonts have only `<glyph>` outlines and optional `<hkern>`. JAD's converter doesn't even emit the `<hkern>`, so a converted file is outlines + advances only. For any text needing real shaping, modern formats win outright.
- Step 5Identify the surviving niches — Where SVG Fonts still appear in 2026: certain PDF generation paths, some e-reader rendering engines, museum/archival pipelines preserving 2010-era web assets, and bespoke vector tools that read `<glyph>` directly. All non-browser. If the target is a browser, the niche is empty.
- Step 6Convert only when the consumer demands it — If a downstream tool genuinely requires an SVG Font, use [Font-to-SVG-Font](/font-tools/font-to-svg-font) — but subset first with the [Font Subsetter](/font-tools/font-subsetter) so you stay under the 5,000-glyph cap and keep the verbose XML small. Otherwise convert to [WOFF2](/font-tools/ttf-to-woff2).
Web font format timeline
The succession that pushed SVG Fonts into legacy status. Browser-support notes reflect shipping engines, not specs.
| Format | Introduced | Status in 2026 | Why it mattered |
|---|---|---|---|
| SVG Fonts | SVG 1.1, 2003 | Deprecated; removed from all browsers | XML vector typography; iOS-only era; no compression |
| EOT | IE4 era / late 1990s | Dead (IE-only) | Microsoft's embedding format; required IE; obsolete with IE |
| WOFF 1.0 | 2010 (Rec 2012) | Supported everywhere; superseded by WOFF2 | zlib-compressed sfnt wrapper; first cross-browser standard |
| WOFF2 | W3C Rec 2018 | Universal — the default web format | Brotli + font-aware transform; ~30% smaller than WOFF |
| Raw TTF/OTF on the web | Always | Works but discouraged | Uncompressed; fine for tools, wasteful as a web font |
Capability comparison
What each format can actually carry. "SVG Font (JAD output)" is what this site's converter produces — a subset of even the SVG Fonts spec.
| Capability | SVG Font (JAD output) | WOFF / WOFF2 | TTF / OTF |
|---|---|---|---|
| Glyph outlines | Yes (up to 5,000) | Yes (all) | Yes (all) |
| Compression | None (plain XML) | zlib / Brotli | None |
| Kerning | No (<hkern> not emitted) | Yes (GPOS / kern) | Yes |
| Ligatures / GSUB | No | Yes | Yes |
| Variable axes | No | Yes | Yes |
| Browser rendering | No (removed) | Yes (universal) | Yes (works) |
| Typical relative size | 4–8× the WOFF2 | 1× (WOFF2 baseline) | ~1.3–2× WOFF2 |
Cookbook
Worked comparisons a font librarian or tooling author actually faces. Sizes are illustrative of the format characteristics, not benchmarks of a specific typeface.
Same typeface, four formats, four sizes
ExampleThe size story that ended SVG Fonts. WOFF2 is the baseline; the SVG Font is the outlier because XML plus uncompressed path strings have no entropy coding.
Typeface: a Latin sans, ~400 glyphs, UPM 1000 WOFF2 ........ ~30 KB (Brotli + transform) WOFF ........ ~40 KB (zlib) TTF ........ ~55 KB (uncompressed sfnt) SVG Font .... ~220 KB (plain XML, no compression) Verdict: identical glyphs, ~7× the bytes for SVG Font.
Inherited 2011 @font-face stack with an SVG src
ExampleThe classic 'bulletproof @font-face' of the early 2010s listed four formats including SVG for iOS. In 2026 only the WOFF2 line does anything; the SVG line is dead weight you can delete.
/* 2011-era stack */
src: url('f.eot'); /* IE — dead */
url('f.woff2') format('woff2'), /* the only live one */
url('f.woff') format('woff'), /* fallback, fine */
url('f.ttf') format('truetype'), /* fallback, fine */
url('f.svg#f') format('svg'); /* iOS-only era — dead */
/* 2026: keep woff2 (+ optional woff), delete eot and svg */Why iOS forced SVG Fonts on everyone for a while
ExampleEarly iOS Safari supported SVG Fonts but not WOFF, so cross-platform sites shipped both. Once iOS gained WOFF (and later WOFF2), the SVG line became pure legacy — but the muscle memory persisted in copy-pasted stacks for years.
Roughly: iOS < 5 → SVG Fonts only (no WOFF) iOS 5+ → WOFF supported → SVG line redundant iOS 10+ → WOFF2 supported → ship WOFF2 Lesson: the SVG src survived in templates long after it stopped doing anything, which is why you still see it.
Converting a legacy SVG Font for a PDF engine
ExampleThe legitimate 2026 use: a downstream PDF generator wants an SVG Font. Don't hand it the modern stack — produce the legacy format from your real source font, subsetting first to keep the XML small.
Pipeline:
Brand-Regular.ttf
→ Font Subsetter (keep only document charset)
→ small Brand-Regular.subset.ttf
→ Font-to-SVG-Font → Brand-Regular.svg (small, complete)
Result: an SVG Font under the 5,000-glyph cap, no wasted XML.Don't confuse SVG Fonts with color-SVG OpenType
ExampleA frequent mix-up. Color emoji/icon fonts embed an SVG table inside an OpenType file — that's a living feature. The deprecated SVG Fonts format is a separate XML document. JAD's converter produces the latter, not the former.
Two different things:
1) deprecated SVG Fonts: <svg><defs><font>…</font></defs></svg>
→ standalone XML, removed from browsers
2) color OpenType: an OTF/TTF with an internal 'SVG ' table
→ modern, renders color glyphs in browsers
JAD Font-to-SVG-Font emits (1). It does not create (2).Edge cases and what actually happens
Every row below was probed against the live API. Some documented requirements (alphabetical axis order, numerical tuple order) are not actually enforced in practice — useful to know if you've been blaming the wrong thing for a 400.
Treating SVG Fonts as a current web option
Won't render in browsersEvery shipping browser removed SVG Fonts — Chrome in 2015, others around the same era; only old iOS Safari ever rendered them inline. Listing an format('svg') src in 2026 does nothing useful. For the web, ship WOFF2 with an optional WOFF fallback and stop there.
Expecting kerning to survive the conversion
Not exportedThe SVG Fonts spec permits <hkern>, but JAD's converter does not emit kerning pairs — it writes outlines and advance widths only. A converted SVG Font renders glyphs at their default advances with no pair adjustments. If the downstream needs kerning, it won't get it from this format; audit the original with the Kerning Pair Auditor.
Assuming ligatures/features carry over
Not exportedWOFF2 carries GSUB/GPOS; the SVG Font output carries neither. No ligature substitution, no contextual alternates, no marks. Glyphs only export if they have a Unicode codepoint, so ligature-only glyphs disappear entirely. This is a hard limit of the legacy format as produced here, not a missing toggle.
Confusing SVG Fonts with the OpenType SVG table
Different formatsColor fonts embed an SVG table inside an sfnt and are fully modern. The deprecated SVG Fonts format is a separate standalone XML file. They share three letters and nothing else. Converting a font here gives you the legacy document, never a color-OpenType file.
Large historical font exceeds the glyph cap
Capped — silentWhen archiving a big multi-script typeface to SVG Font, the converter stops at 5,000 glyphs with no warning beyond the Glyphs-exported count. For faithful archival of a large repertoire, split the work into subsets by script with the Font Subsetter and convert each — or keep the original sfnt as the archival master.
EOT files in an inherited stack
ObsoleteEOT (Embedded OpenType) was Microsoft's IE-only format and died with IE. JAD does not produce or consume EOT, and there is no reason to generate one in 2026. If you find an .eot in a legacy @font-face, delete the line — no supported browser needs it.
Output is bigger than the source — is conversion broken?
By designNo. SVG Fonts are uncompressed XML; a converted file is routinely several times the size of the WOFF2/TTF it came from. That size penalty is exactly why the format lost. It's only acceptable when a non-browser consumer specifically requires the format and file size doesn't dominate.
Round-tripping SVG Font back to a web font
Lossy / unsupportedGoing SVG Font → TTF/WOFF2 would require rebuilding cmap, kerning, OpenType layout, and metrics that the SVG output never carried. JAD provides no SVG-Font import, and any such reconstruction elsewhere is lossy. Always treat the original TTF/OTF as the source of truth and keep it.
Frequently asked questions
Why were SVG Fonts removed from browsers?
Two reasons dominated: no compression (an SVG Font is several times the size of the equivalent WOFF2), and divergent, incomplete implementations across engines. Once WOFF/WOFF2 delivered compressed, consistent, OpenType-complete fonts, SVG Fonts had no advantage left. Chrome removed them in 2015 and SVG 2 dropped them.
When were SVG Fonts ever the right choice?
Briefly, in the early iOS era: older iOS Safari supported SVG Fonts but not WOFF, so cross-platform sites shipped an SVG src specifically for iPhones. Once iOS gained WOFF and then WOFF2, that justification evaporated, though the src line lingered in templates for years.
How much bigger is an SVG Font than a WOFF2?
Typically 4–8× larger for the same typeface. WOFF2 uses Brotli plus a font-aware transform; an SVG Font is plain XML with each glyph's path written out at 2-decimal precision and no entropy coding. That size gap is the headline reason the format lost.
Are SVG Fonts the same as color emoji fonts?
No. Color fonts embed an SVG table inside an OpenType file and are a current, browser-supported feature. The deprecated SVG Fonts format is a standalone XML document with <font>/<glyph> elements. They are unrelated despite the shared letters; JAD's converter produces the deprecated standalone format.
Where do SVG Fonts still get used in 2026?
Non-browser niches: some PDF generation paths, certain e-reader rendering engines, archival/preservation pipelines for 2010-era assets, and bespoke vector tools that parse <glyph> directly. If your target is any current browser, there's no remaining use case.
Does JAD's converter produce a spec-complete SVG Font?
It produces a valid but minimal one: <font>, <font-face>, <missing-glyph>, and <glyph> elements with outlines and advances. It omits optional spec features like <hkern> kerning and does not export OpenType ligatures or features. That matches what the surviving consumers actually read.
Should I add an SVG src to my @font-face for old devices?
No. No device or browser in active use needs an SVG src in 2026. Ship WOFF2 (with an optional WOFF fallback for very old engines) and delete any format('svg') and EOT lines from inherited stacks — they're dead weight.
What replaced SVG Fonts for vector/scalable typography on the web?
Nothing special was needed — all web fonts are already vector-scalable. WOFF2 carries the same outline data SVG Fonts did, just compressed and with full OpenType features. The 'vector' selling point of SVG Fonts was never unique; the formats that beat it are also vector.
Can I convert a deprecated SVG Font into WOFF2 here?
No — this site converts TTF/OTF/WOFF/WOFF2 into an SVG Font, not the reverse. To get a WOFF2, start from the original TrueType/OpenType source with TTF → WOFF2. SVG Font → WOFF2 would be lossy regardless of tool.
Why do old tutorials still mention SVG Fonts?
Because they were genuinely part of the 'bulletproof @font-face' advice from roughly 2009–2014, and that content was never updated. Treat any tutorial that lists an SVG src as pre-2015 and verify each format line against current browser support before copying it.
Is the SVG Fonts spec still maintained?
No. SVG Fonts were defined in SVG 1.1 (2003), never received a 2.0 revision, and were removed from SVG 2 entirely. There is no active maintenance and no new conformance work. Treat the format as frozen and legacy.
If I only have a legacy SVG Font, what should I do?
Find the original TTF/OTF if at all possible — it's the lossless source for any modern conversion. If the SVG Font is all you have, you can extract outlines, but kerning, features, and full metrics are gone. For going forward, target WOFF2 from a real source font.
Privacy first
Every JAD Font tool runs entirely in your browser using opentype.js and the wawoff2 WASM Brotli encoder. Your fonts never leave your device — verified by zero outbound network requests during processing.