Convert OTF to TTF (Rebuilding Cubic Curves as Quadratic Ones)
The actual curve-fitting math that happens when a PostScript-flavored outline gets rebuilt for TrueType's simpler curve system.
- Add a file Choose or drop it here
- Pick the format Change it whenever needed
- Download the result After conversion completes
What Actually Has to Be Rebuilt When PostScript Curves Become TrueType Ones
A CFF-flavored OTF file, marked by the "OTTO" signature at the start of the file, stores every glyph's outline as a Type 2 charstring program describing cubic Bézier curves, the same two-control-point curve math Adobe built into PostScript Type 1 fonts back in 1984 and carried forward into OpenType's CFF table when Adobe joined Microsoft's font-format effort in 1996. A TTF file, by contrast, stores outlines as quadratic Bézier curves in a glyf table, a format Apple built in 1991 using one control point per curve segment rather than two. These are genuinely different mathematical curve families, not just different file syntax, which is the reason converting between them means real reconstruction rather than a simple repackaging step.
Every cubic Bézier curve in the original OTF charstring has to be individually approximated using one or more quadratic Bézier segments, since a single quadratic curve can't exactly reproduce most cubic curve shapes. This process, often called curve fitting or degree reduction, is where a font conversion tool does the bulk of its real work for this specific direction, running a mathematical subdivision algorithm on every curve segment in every glyph the font contains, rather than simply reading and rewriting existing coordinate values the way a WOFF or EOT unwrap does.
The Curve-Fitting Math Behind Turning Two Control Points Into One
In practice, a good curve-fitting algorithm subdivides a complex cubic curve into multiple shorter quadratic segments until the combined quadratic approximation stays within an acceptably small error tolerance of the original cubic shape, meaning a single sweeping cubic curve in the source font might become two, three, or more quadratic curve segments in the resulting glyf table. This subdivision is also why a CFF-flavored font, using cubic curves, can typically represent the same complex curve using fewer total control points than an equivalent quadratic-only outline, a real, measurable structural reason CFF-flavored fonts are frequently slightly smaller in raw outline data than a TrueType-flavored equivalent.
Beyond the outline curves themselves, this conversion also has to handle CFF's subroutine calls, reusable charstring fragments referenced by multiple glyphs to save file space, resolving each one into its final, flattened outline before that glyph's curve-fitting step can even run. And because CFF-flavored fonts never support TrueType's older 'kern' table for letter-pair spacing, relying exclusively on the newer GPOS table instead, a genuinely complete OTF-to-TTF conversion needs to either carry that GPOS data forward as-is or specifically build an equivalent 'kern' table, since simply converting outlines without addressing kerning data can leave a technically valid TTF file that types with visibly incorrect letter spacing.
The conversion tool also has to generate an entirely new loca table from scratch, since that table stores the byte offset of every glyph's point data within the glyf table, and those offsets depend entirely on how many quadratic curve points the newly fitted outlines actually end up using, a number that can only be known after the curve-fitting step for every single glyph has already finished running. Getting the loca table wrong produces a file where some glyphs read correctly and others render as garbage or blank shapes, since the operating system's font rasterizer is reading glyph data from the wrong byte position entirely.
The specific curve-fitting math most modern conversion tools rely on comes from an open-source library called cu2qu, developed jointly by engineers at Google Fonts and Adobe and released publicly around 2015, which implements the cubic-to-quadratic conversion algorithm now used inside both the fonttools library and the Glyphs font editor. Before cu2qu's public release, font teams needing this exact conversion often relied on less standardized in-house scripts, which is part of why curve-fitting quality across different older conversion tools could vary noticeably in how closely the quadratic approximation matched the original cubic shape.
What Survives the Rebuild and What Doesn't
- Gain — access to TrueType's detailed pixel-level hinting system: the resulting glyf-table font can carry precise per-glyph hint instructions, historically valuable for small-size legibility on lower-resolution displays.
- Lose — CFF's lighter, faster hinting model: the alignment-zone-based hinting CFF fonts use doesn't carry over; new TrueType-style hints have to be generated separately if fine small-size rendering matters.
- Risk — genuine curve approximation, not exact translation: every cubic curve segment gets fitted with one or more quadratic segments, and while modern algorithms keep visual differences minimal, sharp corners can occasionally soften slightly under close inspection.
- Gain — a typically simpler compatibility story: TrueType's glyf structure is the format some older or specialized software, including certain embroidery and engraving programs, was built to expect exclusively.
- Lose — file size efficiency in some cases: since cubic curves often need fewer control points than the quadratic segments approximating them, a converted TTF glyph outline can end up describing the same shape with more stored data.
- Risk — kerning data getting dropped if not explicitly handled: CFF-flavored fonts store kerning only in GPOS, never in the older 'kern' table, so a conversion tool has to specifically account for this rather than assuming kerning transfers automatically.
Where a Rebuilt TrueType-Flavored Font Gets Accepted That the Original Didn't
Certain embroidery machine design programs, some engraving and vinyl-cutting software, and a handful of older CAD packages were built specifically expecting TrueType's glyf outline structure, and can reject, partially misread, or silently drop advanced features from a CFF-flavored OTF file even though the exact same software handles a converted TrueType-flavored version of that same typeface without issue. This specific compatibility gap, not general design software use, is the primary real-world reason this particular conversion direction gets performed at all, since mainstream software including current Windows, macOS, Photoshop, and Illustrator already read CFF-flavored OTF just fine.
Standard document and browser software shows no meaningful difference between the two outline flavors once a font is properly installed, so this conversion is worth doing specifically when a known piece of specialized hardware-driving software is the actual target, rather than as a general precaution applied to every font a person owns.
Why Sharp Corners Sometimes Go Soft After This Specific Conversion
A specific, documented complaint around font conversion tools involves letters with sharp serif corners or crisp geometric points looking subtly rounded or softened after an OTF-to-TTF conversion, most noticeable at very large display sizes or under close print inspection rather than in ordinary body text. This is a direct, expected consequence of cubic-to-quadratic curve fitting, since a sharp corner formed by two cubic curve segments meeting at a precise angle can require the quadratic approximation to introduce a small amount of curvature at that junction to keep the overall shape within its error tolerance, rather than preserving an infinitely sharp point exactly.
The practical fix reported for cases where this visible softening actually matters, typically large display typography or logo work rather than body text, is using a conversion tool that allows a tighter error tolerance setting during the curve-fitting step, which produces more quadratic segments per original curve and a closer visual match, at the cost of a somewhat larger resulting file. For body text at normal reading sizes, this level of curve softening is reported as imperceptible in the overwhelming majority of real-world cases.
Two Outline Systems Compared on What They Actually Store
| Feature | OTF (CFF-flavored) | TTF |
|---|---|---|
| Curve type | Cubic Bézier (2 control points) | Quadratic Bézier (1 control point) |
| Outline storage | Type 2 charstring program | Explicit glyf table point data |
| Hinting model | Alignment zones, lighter effort | Pixel-level instructions, more labor-intensive |
| Kerning storage | GPOS table only | Can use 'kern' table or GPOS |
| Typical file size for same glyph count | Often smaller | Often slightly larger after conversion |
| Conversion involves approximation? | N/A (source) | Yes, curve fitting required |
Questions About Turning PostScript Outlines Into TrueType Ones
Does converting OTF to TTF actually change how letters look?
Slightly, in theory. Cubic curves get mathematically approximated with quadratic ones, and while the visual difference is usually imperceptible, sharp corners can occasionally soften a small amount, especially at very large sizes.
Why is my converted TTF file a different size than the original OTF?
Cubic curves often need fewer control points than the quadratic segments approximating them, so a converted glyph can end up storing more data points even though it draws the same visual shape.
Will the letter spacing (kerning) still work correctly after converting?
Only if the conversion tool specifically handles it. CFF-flavored fonts store kerning exclusively in the GPOS table, so a proper conversion needs to carry that data forward or build an equivalent 'kern' table.
Why would I need TTF if OTF already works on my computer?
Some older or specialized software, including certain embroidery and engraving machine programs, was built expecting TrueType's glyf structure specifically and can misread a CFF-flavored OTF file.
What software actually performs the cubic-to-quadratic curve math?
Most modern conversion tools rely on cu2qu, an open-source library released around 2015 by engineers from Google Fonts and Adobe specifically for this conversion, now used inside both the fonttools library and the Glyphs font editor.
Is quadratic curve fitting always a one-way loss of precision?
In practical terms, yes, though the visual impact is usually far smaller than the mathematical description suggests. Converting the resulting TTF back to a CFF-flavored OTF afterward doesn't restore the original cubic curves either, since the quadratic approximation is now the only outline data the file actually contains; round-tripping between the two formats isn't the same as reversing a compression wrapper.