Hubbry Logo
TrueTypeTrueTypeMain
Open search
TrueType
Community hub
TrueType
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
TrueType
TrueType
TrueType
View on Wikipedia
from Wikipedia
TrueType
Filename extension.ttf & .tte (for EUDC usage) for Microsoft Windows, .dfont for macOS
Internet media type
  • font/ttf
  • font/sfnt
  • application/x-font-ttf
  • application/font-sfnt (deprecated)
[1]
Type codeTFIL
Uniform Type Identifier (UTI)public.truetype-ttf-font
Developed byApple
Type of formatoutline font
Extended fromSFNT
Extended toOpenType

TrueType is an outline font standard developed by Apple in the late 1980s as a competitor to Adobe's Type 1 fonts used in PostScript. It has become the most common format for fonts on the classic Mac OS, macOS, and Microsoft Windows operating systems.

The primary strength of TrueType was originally that it offered font developers a high degree of control over precisely how their fonts are displayed, right down to particular pixels, at various font sizes. With widely varying rendering technologies in use today, pixel-level control is no longer certain in a TrueType font.

History

[edit]

During its development, TrueType was first known by the codename Bass and later by Royal.[2] The system was developed and eventually released as TrueType with the launch of Mac System 7 in May 1991. The initial TrueType outline fonts, four-weight families of Times Roman, Helvetica, Courier,[3] and the pi font "Symbol" replicated the original PostScript fonts of the Apple LaserWriter. Apple also replaced some of their bitmap fonts used by the graphical user-interface of previous Macintosh System versions (including Geneva, Monaco and New York) with scalable TrueType outline-fonts. For compatibility with older systems, Apple shipped these fonts, a TrueType Extension and a TrueType-aware version of Font/DA Mover for System 6. For compatibility with the Laserwriter II, Apple developed fonts like ITC Bookman and ITC Chancery in TrueType format.

All of these fonts could now scale to all sizes on screen and printer, making the Macintosh System 7 the first OS to work without any bitmap fonts. The early TrueType systems — being still part of Apple's QuickDraw graphics subsystem — did not render Type 1 fonts on-screen as they do today. At the time, many users had already invested considerable money in Adobe's still proprietary Type 1 fonts. As part of Apple's tactic of opening the font format versus Adobe's desire to keep it closed to all but Adobe licensees, Apple licensed TrueType to Microsoft. When TrueType and the license to Microsoft was announced, John Warnock, co-founder and then CEO of Adobe, gave an impassioned speech in which he claimed Apple and Microsoft were selling snake oil, and then announced that the Type 1 format was open for anyone to use.

Meanwhile, in exchange for TrueType, Apple got a license for TrueImage, a PostScript-compatible page-description language owned by Microsoft that Apple could use in laser printing. This was never actually included in any Apple products when a later deal was struck between Apple and Adobe, where Adobe promised to put a TrueType interpreter in their PostScript printer boards. Apple renewed its agreements with Adobe for the use of PostScript in its printers, resulting in lower royalty payments to Adobe, who was beginning to license printer controllers capable of competing directly with Apple's LaserWriter printers.

Part of Adobe's response to learning that TrueType was being developed was to create the Adobe Type Manager software to scale Type 1 fonts for anti-aliased output on-screen. Although ATM initially cost money, rather than coming free with the operating system, it became a de facto standard for anyone involved in desktop publishing. Anti-aliased rendering, combined with Adobe applications' ability to zoom in to read small type, and further combined with the now open PostScript Type 1 font format, provided the impetus for an explosion in font design and in desktop publishing of newspapers and magazines.

Apple extended TrueType with the launch of TrueType GX in 1994, with additional tables in the sfnt which formed part of QuickDraw GX. This offered powerful extensions in two main areas. First was font axes (today known as variations), for example allowing fonts to be smoothly adjusted from light to bold or from narrow to extended — competition for Adobe's "multiple master" technology. Second was Line Layout Manager, where particular sequences of characters can be coded to flip to different designs in certain circumstances, useful for example to offer ligatures for "fi", "ffi", "ct", etc. while maintaining the backing store of characters necessary for spell checkers and text searching. However, the lack of user-friendly tools for making TrueType GX fonts meant there were no more than a handful of GX fonts.

Much of the technology in TrueType GX, including variations and substitution, lives on as AAT (Apple Advanced Typography) in macOS. Few font-developers outside Apple attempt to make AAT fonts; instead, OpenType has become the dominant sfnt format, and all of the font variation technology is the de facto standard today in OpenType Variations.

Adoption by Microsoft

[edit]

To ensure its wide adoption, Apple licensed TrueType to Microsoft for free.[4] Microsoft added TrueType into the Windows 3.1 operating environment. In partnership with their contractors, Monotype Imaging, Microsoft put a lot of effort into creating a set of high quality TrueType fonts that were compatible with the core fonts being bundled with PostScript equipment at the time. This included the fonts that are standard with Windows to this day: Times New Roman (compatible with Times Roman), Arial (compatible with Helvetica) and Courier New (compatible with Courier). In this context, "compatible" means two things. On an aesthetic level, it means that the fonts are similar in appearance. On a functional level, it means that the fonts have the same character widths. This allows documents which have been typeset in one font to be changed to the other, without reflow.

Microsoft and Monotype technicians used TrueType's hinting technology to ensure that these fonts did not suffer from the problem of illegibility at low resolutions, which had previously forced the use of bitmapped fonts for screen display. Subsequent advances in technology have introduced first anti-aliasing, which smooths the edges of fonts at the expense of a slight blurring, and more recently subpixel rendering (the Microsoft implementation goes by the name ClearType), which exploits the pixel structure of LCD based displays to increase the apparent resolution of text. Microsoft has heavily marketed ClearType, and sub-pixel rendering techniques for text are now widely used on all platforms.

Microsoft also developed a "smart font" technology, named TrueType Open in 1994, later renamed to OpenType in 1996 when it merged support of the Adobe Type 1 glyph outlines. Opentype now contains all of the same functionality of Apple TrueType and Apple TrueType GX.

Platform support

[edit]

Macintosh and Microsoft Windows

[edit]

TrueType has long been the most common format for fonts on classic Mac OS, Mac OS X, and Microsoft Windows, although Mac OS X and Microsoft Windows also include native support for Adobe's Type 1 format and the OpenType extension to TrueType (since Mac OS X 10.0 and Windows 2000). While some fonts provided with the new operating systems are now in the OpenType format, most free or inexpensive third-party fonts use plain TrueType.

Increasing resolutions and new approaches to screen rendering have reduced the requirement of extensive TrueType hinting. Apple's rendering approach on macOS ignores almost all the hints in a TrueType font, while Microsoft's ClearType ignores many hints, and according to Microsoft, works best with "lightly hinted" fonts.

Linux and other platforms

[edit]

The FreeType project of David Turner has created an independent implementation of the TrueType standard (as well as other font standards in FreeType 2). FreeType is included in many Linux distributions.

Until May 2010, there were potential patent infringements in FreeType 1 because parts of the TrueType hinting virtual machine were patented by Apple, a fact not mentioned in the TrueType standards. (Patent holders who contribute to standards published by a major standards body such as ISO are required to disclose the scope of their patents, but TrueType was not such a standard.)[5] FreeType 2 included an optional automatic hinter to avoid the patented technology, but these patents have now expired so FreeType 2.4 now enables these features by default.[6]

Outlines

[edit]
A quadratic Bézier curve segment is defined by two end points and one control point. This circle is eight contiguous segments. The squares are end points and the circles are control points.

The outlines of the characters (or glyphs) in TrueType fonts are made of straight line segments and quadratic Bézier curves. These curves are mathematically simpler and faster to process than cubic Bézier curves, which are used both in the PostScript-centered world of graphic design and in Type 1 fonts. However, most shapes require more points to describe with quadratic curves than cubics. This difference also means that it is not possible to convert Type 1 losslessly to the TrueType format, although in practice it is often possible to do a lossless conversion from TrueType to Type 1.[7][8]

Hinting language

[edit]

TrueType systems include a virtual machine that executes programs inside the font, processing the "hints" of the glyphs, in TrueType called “instructions”. These distort the control points which define the outline, with the intention that the rasterizer produce fewer undesirable features on the glyph. Each glyph's instruction set takes account of the size (in pixels) at which the glyph is to be displayed, as well as other less important factors of the display environment.

Although incapable of receiving input and producing output as normally understood in programming, the TrueType instruction language does offer the other prerequisites of programming languages: conditional branching (IF statements), looping an arbitrary number of times (FOR- and WHILE-type statements), variables (although these are simply numbered slots in an area of memory reserved by the font), and encapsulation of code into functions. Special instructions called delta instructions are the lowest level control, moving a control point at just one pixel size.

The hallmark of effective TrueType glyph programming techniques is that it does as much as possible using variables defined just once in the whole font (e.g., stem widths, cap height, x-height). This means avoiding delta instructions as much as possible. This helps the font developer to make major changes (e.g., the point at which the entire font's main stems jump from 1 to 2 pixels wide) most of the way through development.

Creating a very well-instructed TrueType font remains a significant amount of work, despite the increased user-friendliness of programs for adding instructions to fonts. Many TrueType fonts therefore have only rudimentary instructions, or have them automatically applied by the font editor, with results of various quality.

Embedding protection

[edit]

The TrueType format allows for the most basic type of digital rights management – an embeddable flag field that specifies whether the author allows embedding of the font file into things like PDF files and websites. Anyone with access to the font file can directly modify this field, and simple tools exist to facilitate modifying it (obviously, modifying this field does not modify the font license and does not give extra legal rights).[9][10] These tools have been the subject of controversy over potential copyright issues.[11][12]

Emoji

[edit]

Apple has implemented a proprietary extension to allow color .ttf files for its emoji font Apple Color Emoji.

File formats

[edit]

Basic

[edit]

A basic font is composed of multiple tables specified in its header. A table name can have up to 4 letters.

A .ttf extension indicates a regular TrueType font or an OpenType font with TrueType outlines. Windows end user defined character editor (EUDCEDIT.EXE) creates TrueType font with name EUDC.TTE.[13] An OpenType font with PostScript outlines must have an .otf extension. In principle, an OpenType font with TrueType outlines may have an .otf extension, but this has rarely been done in practice.

In classic Mac OS and macOS, OpenType is one of several formats referred to as data-fork fonts, as they lack the classic Mac resource fork.

Collection

[edit]

TrueType Collection (TTC) is an extension of TrueType format that allows combining multiple fonts into a single file, creating substantial space savings for a collection of fonts with many glyphs in common. They were first available in Chinese, Japanese, and Korean versions of Windows, and supported for all regions in Windows 2000 and later. Classic Mac OS included support of TTC starting with Mac OS 8.5.

A TrueType Collection file begins with a ttcf table that allows access to the fonts within the collection by pointing to individual headers for each included font. The fonts within a collection share the same glyph-outline table, though each font can refer to subsets within those outlines in its own manner, through its cmap, name and loca tables. Collection files bear a .ttc filename extension. In classic Mac OS and macOS, TTC has file type ttcf.

Suitcase

[edit]

The suitcase format for TrueType is used on classic Mac OS and macOS. It adds additional Apple-specific information.

Like TTC, it can handle multiple fonts within a single file. But unlike TTC, those fonts need not be within the same family.

Suitcases come in resource-fork and data-fork formats. The resource-fork version was the original suitcase format. Data-fork-only suitcases, which place the resource fork contents into the data fork, were first supported in macOS. A suitcase packed into the data-fork-only format has the extension dfont.

PostScript

[edit]

In the PostScript language, TrueType outlines are handled with a PostScript wrapper as Type 42 for name-keyed or Type 11 for CID-keyed fonts.

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

TrueType

View on Grokipedia
from Grokipedia
TrueType is an outline font standard and digital font technology for representing scalable typefaces, originally developed by Apple Computer in the late 1980s as an alternative to Adobe's Type 1 fonts to avoid per-font royalty payments and enable efficient rendering on screens and printers. It uses vector-based outlines combined with hinting instructions to ensure high-quality display at low resolutions, and its file format consists of a series of tables storing font data such as metrics, character mappings, and shapes. The format was licensed to , which adopted and extended it for cross-platform use in operating systems like macOS and Windows. Apple first integrated TrueType into its operating system with the release of in May 1991, providing a core set of fonts including Times Roman, , and to support scalable without reliance on external font vendors. followed suit by incorporating TrueType into in April 1992, collaborating with font foundries like Monotype to expand the font library and improve rasterization for better on-screen legibility. This joint adoption made TrueType a de facto standard for digital fonts, enabling device-independent rendering and widespread use in personal computing. Key features of TrueType include its modular table structure, where essential tables like 'glyf' (for glyph outlines), 'cmap' (for character-to-glyph mapping), 'hmtx' (for horizontal metrics), and 'head' (for font header information) define the font's visual and typographic properties. Advanced hinting via bytecode instructions in tables such as 'fpgm' (font program) and 'cvt' (control value table) allows fonts to adapt to pixel grids, enhancing clarity on digital displays. Over time, extensions like TrueType GX (by Apple for advanced ) and TrueType Open (by , later version 2 in collaboration with ) added support for multilingual text, variations, and compatibility, evolving the format into modern standards like .

History

Development by Apple

In the early 1980s, Apple sought to advance on the Macintosh beyond fonts, which were limited to fixed resolutions and required separate designs for each size, to support emerging high-resolution devices like the printer introduced in 1985. The company initially licensed fonts from but recognized the need for a device-independent, scalable outline format to enable smooth rendering across varying output devices without per-font royalties to third-party scalable technologies such as Bitstream's Font Fusion. This motivation stemmed from the Macintosh's design philosophy, influenced by ' emphasis on elegant during the system's launch, though development of TrueType occurred after his 1985 departure from Apple. TrueType's core technical goals centered on using quadratic Bézier curves to define outlines, allowing efficient mathematical scaling to any size while maintaining legibility without the need for multiple master fonts or complex cubic curves as in 's Type 1 format. Apple began internal development in the late 1980s, publicly announcing the format at the 1989 Seybold Desktop Publishing Conference after divesting its stake in , with the project focusing on integrated hinting mechanisms to align curves to pixel grids for low-resolution displays. Key contributors included Apple's font engineering team, who designed the system to be and embeddable in operating systems, addressing limitations in existing PostScript-based fonts. Apple filed patents for foundational TrueType elements, including scalable outline descriptions and grid-fitting hinting, in the late 1980s to protect the technology's innovations in rasterization and curve approximation. The format debuted with Macintosh System 7.0 on May 13, 1991, replacing bitmap versions of system fonts and introducing scalable outlines for broader use in desktop publishing. Initial TrueType fonts included conversions of classics like Chicago (the menu and interface font) and Geneva (used for icons and small text), alongside licensed staples such as Times Roman, Helvetica, and Courier, enabling seamless scaling in applications like PageMaker.

Adoption by Microsoft

In September , Apple and entered into a licensing agreement, allowing to license Apple's TrueType technology for use on non-Apple platforms, including a cross-licensing arrangement that granted mutual access to related patents and ensured broad compatibility without legal entanglements. This pact primarily aimed to circumvent ongoing disputes and reduce reliance on Adobe's proprietary system, which required per-font royalties. Microsoft's adoption of TrueType was driven by the need for a cost-effective, scalable font solution to enhance ' graphical capabilities, replacing the expensive Type Manager integration in earlier versions. Although launched in 1990 with initial font support, TrueType's full rasterizer was integrated into , released in April 1992, enabling device-independent scaling and on-screen rendering without additional licensing fees. This implementation included core fonts such as Arial and Times New Roman, developed in collaboration with Monotype , which became staples for Windows applications and improved text legibility across various output devices. To bolster TrueType's functionality in Windows, introduced enhancements like advanced hinting tools through Visual TrueType (VTT), a graphical editor for optimizing rendering at low resolutions, and expanded the 'name' table to store richer metadata such as multilingual font names and licensing details. These additions facilitated better developer integration and cross-platform portability, solidifying TrueType's role as a foundational element of Microsoft's operating system ecosystem.

Standardization and later developments

In the early 1990s, Apple and collaborated to establish TrueType as an open specification, with announcing its integration into Windows and in March 1990 following a licensing agreement with Apple. The detailed technical documentation for TrueType 1.0 was subsequently released, enabling broader adoption and development by third parties. Apple's patents on TrueType, particularly those covering hinting for font rendering, expired worldwide by May 2010, removing previous legal barriers and allowing unrestricted implementation in open-source projects like . This expiration facilitated wider innovation without licensing restrictions. Key advancements in the 1990s included the introduction of TrueType GX by Apple in 1994, which added support for font variations through additional tables in the SFNT structure, enabling dynamic adjustments along design axes such as weight and width. This model influenced later technologies by providing a foundation for interpolating outlines. TrueType also integrated with during this period, with Microsoft's 1992 specification incorporating Unicode encoding (initially termed "Apple Unicode") to support multilingual text rendering. In modern contexts, TrueType remains foundational for web fonts via the (WOFF), a compressed wrapper for TrueType and files standardized by the W3C as a Recommendation in December 2012, and its successor WOFF2, released as a Recommendation in 2018, which offers up to 30% better compression for TrueType outlines. It continues to be supported in mobile operating systems, including and Android, where TrueType files (.ttf) are used for system and app fonts due to their and compatibility. While the core TrueType outline format has seen no major changes since 2000, extensions like the COLR and CPAL tables—introduced in specifications around 2016—enable layered color glyphs by composing monochrome outlines with color palettes, enhancing support for and multicolor in TrueType-based fonts. These developments build on TrueType's outline representation to extend its relevance in technologies, standardized in in 2016, which revive GX-style variations for efficient delivery of font families.

Core technology

Outline representation

TrueType employs a vector-based outline format to represent shapes, utilizing quadratic Bézier curves rather than the fixed grids of fonts. This approach defines the boundaries of characters through mathematical curves and lines, allowing for precise and compact storage of typographic forms. In contrast to fonts, which are resolution-dependent and prone to when scaled, TrueType's outlines maintain sharpness across varying sizes by mathematically reconstructing the . The core structure resides in the 'glyf' table, which stores glyph data as one or more closed contours—each a sequence of points that form the outline of a character or its components. Contours are defined by an of endpoint indices, with the shape closing implicitly by connecting the final point back to the initial one of the contour; the interior is determined using the non-zero winding rule based on point ordering. Points within contours are categorized as on-curve or off-curve: on-curve points serve as endpoints or vertices for straight lines (when two consecutive on-curve points appear), while off-curve points act as control handles to shape the quadratic curves between on-curve anchors. These points are encoded with flags specifying attributes like coordinate precision (e.g., 1-byte delta or full 2-byte values) and curve status, enabling efficient storage of relative coordinates. Mathematically, each curve segment in a TrueType glyph is a quadratic Bézier spline defined by three points: start point P0\mathbf{P_0}, control point P1\mathbf{P_1}, and end point P2\mathbf{P_2}. The parametric equation for the curve is: B(t)=(1−t)2P0+2(1−t)tP1+t2P2,t∈[0,1]\mathbf{B}(t) = (1-t)^2 \mathbf{P_0} + 2(1-t)t \mathbf{P_1} + t^2 \mathbf{P_2}, \quad t \in [0,1] This quadratic form produces parabolic arcs, differing from the cubic Bézier curves (requiring four points) used in PostScript Type 1 fonts, which allow greater flexibility but demand more computational resources for rendering. Sequences of such segments approximate smooth contours, with a minimum of three points required for any curved element. The 'glyf' table further supports composite glyphs, where complex shapes are constructed by referencing and combining simpler component s, potentially with affine transformations such as scaling, , or applied via fixed-point arguments. Each composite includes a glyph index for the referenced component, along with flags and optional offset or metric adjustment data, forming an acyclic graph that terminates at simple leaf s; this hierarchical composition significantly reduces redundancy and file size for characters built from shared elements, like accented letters. This outline representation provides infinite , as glyphs can be rendered at any resolution without introducing artifacts at the font's intended design , forming the essential prerequisite for all subsequent scaling and rasterization operations.

Scalability and rasterization

TrueType's stems from its use of vector-based outlines, which allow glyphs to be scaled to any or resolution without inherent quality degradation, in contrast to fonts that require separate files for each and resolution, leading to storage inefficiencies and inconsistent rendering. This resolution is achieved by scaling the master outline from font units (typically 1024 or 2048 per em square) to device coordinates using a factor derived from the point , device resolution, and units per em, such as \text{scale} = \frac{\text{pointSize} \times \text{resolution}}{72 \times \text{units_per_em}}, enabling precise placement at 26.6 fixed-point precision (1/64th of a ). Historically, TrueType addressed the proliferation of fonts on early Macintosh systems, where fixed-resolution bitmaps caused issues like dropouts and poor ; by providing a single scalable outline per font, it facilitated What You See Is What You Get () printing and display across varied devices, reducing the need for multiple variants. The rasterization process in TrueType converts these scaled outlines into pixel bitmaps via a scan-line that fills closed contours. It begins by digitizing the outline into edges, then processes horizontal scan lines from top to bottom, computing intersections with edges to determine pixel coverage using the non-zero rule, where a pixel's center is filled if the winding number—the net count of contour edges crossing a ray from the pixel center (positive for one direction, negative for the other)—is non-zero. This method identifies interior regions and handles edge cases like dropouts—gaps in thin features—through optional control rules that activate additional pixels along scan-line transitions to ensure feature preservation at low resolutions. The resulting adheres to simple on/off rules, such as turning on pixels whose centers lie inside or on the outline boundary. To enhance smoothness beyond binary bitmaps, TrueType supports and techniques. , a widely used open-source library for rendering TrueType fonts, generates anti-aliased pixmaps with 256 levels of gray, blending partial coverage along edges for reduced jaggedness and improved legibility on displays. Microsoft's extends this by exploiting LCD subpixel structure, treating red, green, and blue components separately to triple horizontal resolution (e.g., an 800x600 display yields 2400x600 effective subpixels), allowing finer anti-aliasing that sharpens text without excessive blurring, particularly beneficial for TrueType outlines on color screens. Performance in TrueType rasterization involves trade-offs, especially at low resolutions like 72 dpi printers or screens, where an 18-point spans only 18 pixels per em, amplifying artifacts unless mitigated by grid-fitting. Modern implementations leverage optimized scaling—faster when units per em is a power of 2, such as 2048—and can benefit from in GPUs for broader graphics pipelines, though core scan conversion remains primarily software-based to maintain precision. These aspects ensure efficient rendering on resource-constrained devices while prioritizing quality at higher resolutions.

Hinting and rendering

Hinting language

The hinting language in TrueType fonts consists of a set of instructions embedded within the 'glyf' table of each glyph, designed to dynamically adjust the positions of outline points for improved and consistency when rendering on low-resolution devices like screens. These instructions enable grid-fitting, where curves and stems are aligned to the grid to avoid distortions at small point sizes, such as 9–12 pixels per em (ppem). The language operates via a stack-based virtual machine interpreter, which processes opcodes in a bytecode format to manipulate glyph coordinates. Common opcodes include PUSHB, which pushes byte values onto the stack for subsequent operations, and DELTAP1, which applies delta adjustments to specific points during rasterization. The execution occurs in up to four distinct passes per glyph: a first pass for general setup, followed by three delta exception passes for fine-tuned shifts based on pixel resolution. This structure allows precise control over point movements while the outline serves as the foundational shape being modified. Key instructions encompass a range of functions for point and curve manipulation. For instance, IUP (Interpolate Unset Points) linearly interpolates the positions of points that remain unadjusted after primary operations, preserving relative relationships. SHPIX shifts points by a specified amount to align stems uniformly. Additionally, the twilight zone refers to a special low-resolution regime (typically below 1 per unit) where instructions permit fractional movements less than a full , facilitating smoother transitions in undersampled glyphs without full grid snaps. TrueType's hinting language originated with Apple's development of an initial integrated into their font tools during the format's creation in the late 1980s, providing the bytecode generation for glyph instructions. Microsoft later advanced designer accessibility through Visual TrueType (VTT), a graphical tool released in the that allows visual editing of hints and automatic compilation to , supporting both standard and variable fonts. Despite its power, the language's complexity—requiring detailed knowledge of the virtual machine and opcode interactions—makes manual hand-hinting labor-intensive and error-prone for font designers. As a result, contemporary workflows increasingly rely on automated tools such as for basic instruction generation and ttfautohint for script-agnostic bytecode creation. Post-2000 open-source efforts have further democratized hinting through libraries like , which executes TrueType instructions during rasterization, often integrated with text-shaping engines such as for comprehensive rendering pipelines.

Rendering techniques

TrueType rendering employs specialized engines to apply hinting instructions during rasterization, ensuring optimal glyph appearance across devices and resolutions. On Apple systems, legacy engines such as and the Advanced Type Services for Unicode Imaging (ATSUI) handled TrueType font rendering by executing hinting code to adjust outlines for screen display, prioritizing pixel-perfect alignment on early Macintosh hardware. Modern Apple rendering shifted to Core Text, introduced in macOS 10.5, which integrates TrueType support with advanced layout and capabilities for high-fidelity text on displays and beyond. Microsoft's DirectWrite API, available since , utilizes technology to render TrueType fonts with subpixel antialiasing, leveraging LCD display structures for sharper text edges and improved readability at small sizes. Key techniques in TrueType rendering focus on stem alignment through hinting to achieve uniform stroke widths, where instructions move points to grid boundaries, ensuring consistent vertical and horizontal stems across characters like 'H' and 'I' for balanced text blocks. This alignment prevents irregular widths that arise from scaling alone, maintaining by snapping stems to even counts (e.g., 1, 2, or 3 pixels thick) based on point size. Instruction execution during rendering involves sequential processing of hinting , with built-in prioritizing later instructions to override earlier ones, avoiding contradictory movements and ensuring stable shapes. The hinting language serves as the control mechanism, executed by the rasterizer to apply these adjustments dynamically. Advancements in TrueType rendering include subpixel positioning, originally rooted in TrueType's grid-fitting model and extended in fonts for fractional advances (e.g., 1/64 pixel increments), allowing precise without full-pixel shifts. Anti-aliasing modes enhance smoothness; for instance, grayscale techniques using 4x4 oversampling blend pixel edges to reduce jaggedness in unhinted or lightly hinted glyphs, while applies RGB for horizontal color fringing that simulates higher resolution. Quality metrics in TrueType rendering address print and screen disparities, such as stem darkening, which artificially boldens thin strokes at small sizes to compensate for spread on , ensuring even tonal comparable to screen previews. hints, though limited in base TrueType to global adjustments via the Control Value Table, enable subtle variations in stroke thickness and spacing up to 2048 pixels per em, approximating multiple master designs for better proportionality at different scales. Rendering TrueType fonts presents challenges in balancing fidelity to the designer's intent with computational speed, as complex hinting instructions can increase processing time on resource-constrained devices, while (e.g., 26.6 format) introduces rounding errors that accumulate during scaling and projection. Open-source implementations like FreeType's autohinter provide a fallback by generating lightweight hints on-the-fly for fonts lacking manual instructions, using script-aware algorithms to approximate stem alignment and darkening without execution, though at the cost of slightly reduced precision compared to native rasterizers.

File formats

TrueType Font (.ttf)

The TrueType Font (.ttf) file format is a single-font container based on the SFNT (Scalable Font) wrapper, which organizes the font data into a series of tables accessed via offsets for efficient parsing. The file begins with a header containing the SFNT version (typically 0x00010000 for TrueType), followed by a table directory that lists the number of tables, search parameters for binary lookup, and records for each table including a four-character tag, checksum, offset from the file start, and length. Essential tables include 'head' for overall font metrics, 'hhea' for horizontal header information, 'maxp' for maximum profile limits on glyphs and instructions, 'name' for naming strings like family and style, 'OS/2' for platform-specific metrics such as character range and typographic data, 'cmap' for character-to-glyph index mapping, 'glyf' for glyph outline descriptions, 'loca' for offsets to individual glyph data in the 'glyf' table, and 'hmtx' for horizontal advance widths and left side bearings. This offset-based indexing allows random access to tables without sequential reading, supporting scalable rendering across resolutions. Among these, the 'cmap' table is critical for text processing, using subtables in formats like 4 (for basic up to 65,535 code points) or 12 (for extended with 32-bit code points) to map input character codes to indices, enabling cross-platform compatibility with Unicode text. The 'head' table provides foundational metrics, including unitsPerEm (commonly set to 2048, defining the em square's resolution in font units) and a checksumAdjustment field that ensures file integrity by compensating for the font's total (calculated as the sum of 32-bit words across all tables, adjusted to 0xB1B0AFBA). TrueType fonts optimize file size through compact glyph outline storage in the 'glyf' table, using quadratic Bézier curves and relative coordinates to represent scalable vector paths without built-in color support, which was introduced later in OpenType extensions. Validation of .ttf files involves verifying table checksums against the 'head' adjustment and using tools like ttx from the FontTools library to convert the binary format to editable XML for inspection or modification, facilitating debugging and compliance checks. However, the format's table-parsing mechanisms have been susceptible to security vulnerabilities, such as buffer overflows in malformed 'cmap' or 'glyf' data, leading to remote code execution exploits in the 2010s on Windows systems. As the primary distribution format for TrueType fonts, .ttf files are widely used on desktop operating systems for application and , while for web deployment, they are often converted to WOFF () to enable compressed, licensed delivery via CSS @font-face rules, improving load times without altering the underlying outline data.

TrueType Collection (.ttc)

The TrueType Collection (TTC) format bundles multiple TrueType fonts into a single file, primarily to reduce redundancy by allowing shared glyph data and other common tables across font variants such as regular, bold, and italic styles within a family. This approach is particularly useful in systems requiring font families, including Android and embedded devices where storage efficiency is critical. The TTC file structure begins with a TTC Header at offset 0, which specifies the version and provides offsets to the table directories of each constituent font. Version 1.0 of the header includes the tag 'ttcf', major and minor version numbers (1.0), the number of fonts (uint32 numFonts), and an array of Offset32 values pointing to each font's Offset Table from the file start. Version 2.0 extends this by adding fields for digital signatures, including a DSIG tag, length, and offset, to support enhanced security features. Following the header, the file contains one or more Offset Tables (each with a Table Directory) for the individual fonts, and the actual font tables, where common ones like 'glyf' (glyph outlines), 'loca' (location), 'hmtx' (horizontal metrics), and 'cvt ' (control value table) can be shared to avoid duplication, while font-specific tables such as 'cmap' (character-to-glyph mapping) and 'name' (naming) remain unique per sub-font. Introduced in the alongside TrueType's development for improved efficiency, the TTC format enables to individual fonts via their offsets, resulting in smaller overall file sizes compared to separate .ttf files. For instance, sharing data across variants can yield substantial space savings, especially for complex scripts. However, TTC has limitations: not all font tools or renderers fully support shared tables, potentially requiring fallback to non-shared implementations, and validation must verify each sub-font independently for compliance. Additionally, shared tables demand compatible TrueType hinting instructions, and index renumbering may complicate processing if indices differ across fonts. TTC adoption is widespread in mobile operating systems like Android, where it optimizes storage for large font sets; a prominent example is the Noto Sans CJK TTC files, which bundle multiple weights and styles for East Asian scripts to support comprehensive text rendering in resource-constrained environments.

Legacy and wrapper formats

In the era, TrueType fonts were often distributed in files, which served as containers bundling multiple font resources—such as outline data, bitmaps, and metrics—within the system's . This format, typically identified by a .suit extension, allowed for efficient management of font families on pre-OS X Macintosh systems, where the resource fork stored all font components without separate data forks. files were particularly common for TrueType implementations on Mac, enabling the inclusion of screen-optimized bitmaps alongside scalable outlines, though they relied on legacy Macintosh resource structures that became incompatible with later file systems. To bridge compatibility between TrueType and -based printing environments, developed the Type 42 format as a wrapper that embeds TrueType outline data within a font dictionary and stream. Specified in Adobe Technical Note #5012, Type 42 fonts convert the binary TrueType structure into a -readable form, allowing TrueType glyphs to be processed by interpreters in printers without native TrueType support. This wrapper was commonly generated by printer drivers during output, particularly in the for workflows, and was included in the PostScript 3 core font set to ensure high-quality rendering of 19 common TrueType-derived fonts on compatible devices. Early Windows systems employed resource-based storage for fonts via .fon files, which could encapsulate TrueType outlines as standalone rather than independent files, facilitating integration into executables or system libraries. Introduced alongside TrueType in , this approach allowed .fon files to hold scalable TrueType for both rasterization and vector rendering, though it was primarily used for variants and phased out in favor of direct .ttf files as TrueType adoption grew. In the early 2000s, Apple introduced the .dfont format as a transitional wrapper for Mac OS X, shifting suitcase-style bundling from resource s to the fork while retaining SFNT-based TrueType structures for multiple fonts in a single file. This format supported legacy Mac font management during the shift to Unix-based systems but was short-lived, as individual .ttf files became standard by the mid-2000s. As Unicode standardization advanced and SFNT containers dominated font ecosystems, these legacy wrappers largely became obsolete, with tools like enabling conversion of suitcase, .dfont, .fon, and Type 42 formats to modern Unicode-compliant .ttf files. parses resource forks and wrappers to extract TrueType outlines, re-encoding glyphs to Unicode mappings and generating standalone SFNT files, which preserves while addressing encoding limitations in pre-Unicode systems. This migration was driven by the need for cross-platform compatibility and broader character support, rendering resource-dependent formats impractical on modern file systems without extended attributes.

Platform support

Apple systems

TrueType was integrated into the classic Macintosh operating system with the release of in 1991, providing scalable outline fonts as an alternative to fonts and Type 1 formats. In this era, TrueType fonts were rendered primarily through , Apple's 2D graphics library, which handled rasterization for on-screen display and printing. For advanced , Apple Type Services (ATS) extended TrueType capabilities, enabling features like font smoothing and ligature support in later classic Mac versions such as and beyond. With the transition to OS X in the early 2000s, Apple shifted font management and rendering to more modern frameworks, culminating in the introduction of the Core Text framework in Mac OS X 10.5 Leopard in 2007. Core Text provides low-level APIs for text layout, glyph shaping, and font handling, fully supporting TrueType (.ttf) and OpenType (.otf) formats through integration with the Quartz 2D graphics engine. In OS X and subsequent macOS versions, Font Book serves as the central tool for installing and managing TrueType fonts, automatically validating files for errors during import and supporting formats like .ttf, .ttc (TrueType Collections), and variable TrueType fonts. Quartz enabled subpixel antialiasing for TrueType rendering on LCD displays until macOS Mojave in 2018, after which Apple favored grayscale antialiasing on high-resolution Retina screens for reduced color fringing. As of 2025, TrueType remains a core component of font support across Apple's ecosystem, including macOS, , , and , where system fonts are rendered using Core Text for consistent typography in user interfaces and environments. Apple's (SF Pro) system font family, introduced in 2014 and expanded in subsequent years, relies on TrueType outlines within its structure to ensure scalable, high-fidelity rendering optimized for processors in devices like M-series Macs and iPhones. Tools such as Font Book's built-in validator continue to check TrueType files for compliance, flagging issues like malformed tables or invalid instructions before installation. Legacy .dfont formats, used in early OS X for bundling TrueType and data, were deprecated starting with (10.15) in 2019, with modern systems prioritizing standard .ttf and .otf files to enhance security and compatibility.

Microsoft Windows

TrueType was first integrated into with the release of in April 1992, establishing it as the default outline font technology and replacing earlier raster-based fonts for scalable rendering across applications. The operating system's (GDI) included a built-in TrueType rasterizer, enabling on-the-fly generation of font bitmaps at various sizes and resolutions without requiring printer-specific outlines. This rollout standardized a core suite of 14 TrueType fonts, including , , and Courier New, provided by Monotype Typography, which became foundational for Windows typography and ensured consistent cross-application rendering. Over the 1990s, Windows evolved to handle more complex text layouts through Uniscribe, a set of APIs introduced with 5.0 in 1999 and fully integrated into , supporting and scripts like and Hebrew that require glyph reordering and shaping. By the late 2000s, Microsoft advanced rendering with DirectWrite, launched in 2009 alongside , which provided hardware-accelerated text layout and glyph rendering via integration, improving performance for TrueType fonts in modern graphics pipelines while maintaining compatibility with GDI legacy paths. A key innovation for TrueType in Windows was , a subpixel technique introduced with in 2001, which leverages the red-green-blue subpixel structure of LCD displays to increase horizontal resolution by up to 300%, thereby enhancing on-screen readability compared to traditional grayscale rendering. ClearType tuning, including adjustments for hinting to align stems precisely on subpixels, could be customized via registry settings under HKEY_CURRENT_USER\Control Panel\Desktop\FontSmoothing, allowing users to optimize contrast and gamma for specific monitors. As of 2025, TrueType remains universally employed in Windows user interfaces, particularly within WinUI frameworks and the , where variable TrueType fonts like Segoe UI Variable enable smooth weight and width interpolation for responsive across devices. Support for variable TrueType, allowing a single font file to encompass multiple styles, has been native since via DirectWrite, facilitating efficient rendering in high-DPI environments. Font management occurs through the C:\Windows\Fonts folder for installation and preview, with registry entries in HKEY_LOCAL_MACHINE\SOFTWARE[Microsoft](/page/Microsoft)\Windows NT\CurrentVersion\Fonts tracking mappings; since version 21H2 in 2021, enhanced font isolation blocks loading of untrusted fonts outside the system directory to mitigate security vulnerabilities like remote code execution in parsing.

Linux and other systems

TrueType font support on Linux primarily relies on the library, a portable and efficient font rendering engine initiated in that rasterizes TrueType outlines into bitmaps or vectors for display. FreeType serves as the core renderer in major distributions, handling loading, scaling, and while integrating seamlessly with system font management tools. For fonts lacking native hinting instructions, FreeType's autohinter module applies algorithmic adjustments to optimize stem alignment and , enhancing legibility at small sizes without proprietary execution. This integration extends to display protocols like X11 and Wayland through , which configures font matching, substitution, and rendering properties to ensure consistent TrueType output across applications and desktops. In other Unix-like systems such as and Solaris, provides analogous TrueType rendering capabilities, enabling cross-platform compatibility for font display in graphical environments. Complementing , the library—developed starting in 2006—performs advanced text shaping for TrueType and fonts, particularly in complex scripts like or Indic languages, by arranging glyphs according to linguistic rules and positional variants. processes to generate positioned glyph runs, which then rasterizes, forming a robust pipeline for multilingual text in these systems. Beyond traditional desktops, TrueType support appears in mobile and embedded contexts; on Android, the leverages to load and render TrueType fonts, supporting system-wide in applications and the UI framework. Embedded platforms like the , running variants, utilize for efficient TrueType rendering in resource-constrained environments, such as GUI toolkits or consoles. In web browsers, rendering engines including Blink (powering Chromium-based browsers) and (in ) incorporate via Skia or direct bindings to handle TrueType fonts on backends, ensuring displays correctly across diverse hardware. Historical challenges for open-source TrueType implementations on stemmed from patents on bytecode hinting, enforced by Apple and until their global expiration in May 2010, after which could fully enable instruction-based rendering without legal restrictions. More recently, performance-oriented alternatives have emerged, such as the crate—a pure-Rust from the early that introspects TrueType fonts, shapes text, and generates images for high-speed applications in constrained or cross-platform scenarios. For system tweaks, earlier customizations like the Infinality patches, which modified for akin to , have been deprecated since the mid-2010s in favor of upstream enhancements in standard versions, reducing maintenance overhead while maintaining quality.

Special features

Embedding and protection

TrueType fonts include embedding permissions specified in the 'OS/2' table's fsType field, a 16-bit value that controls how the font can be incorporated into documents. The fsType bits 0–3 define mutually exclusive usage levels: a value of 0 allows installable , where the font can be installed and used on the target system; 2 indicates a restricted prohibiting embedding without owner permission; 4 permits preview and print embedding for read-only viewing and printing; and 8 enables editable embedding for documents that allow font modification. Additional bits include 8 (0x0100), which prohibits subsetting before embedding to preserve the full font, and 9 (0x0200), which restricts embedding to representations only, excluding outline data. These permissions are honored by applications like Adobe PDF and , which embed TrueType fonts (.ttf) into files such as PDFs and .docx documents, ensuring consistent rendering across systems while respecting licensing restrictions. For protection, fsType settings like restricted (bit 1, value 2) or preview/print-only (bit 2, value 4) aim to prevent unauthorized distribution by blocking full or installation, often paired with end-user agreements (EULAs) that legally enforce non-extraction clauses. However, these technical flags are largely ineffective against extraction tools, as users can bypass them using font utilities to copy embedded fonts from documents. Introduced in the early alongside TrueType's development by Apple and to address font concerns, the fsType mechanism provided foundries with a standardized way to signal licensing intent, though enforcement relied on software compliance rather than robust security. has historically guided developers to set fsType to 0 for broadly embeddable fonts or higher values for protected ones, emphasizing alignment with EULAs to balance accessibility and rights. In modern practice, web embedding favors the wrapper around or fonts, which applies compression for faster loading but includes no (DRM) or , allowing easy conversion back to original formats. Embedding practices shifted toward more open licensing in the , with many foundries defaulting to installable permissions to encourage web use, though EULAs remain the primary legal safeguard. Tools like ttx from the FontTools Python library enable modification of fsType flags by converting fonts to editable XML and back, facilitating testing or compliance adjustments but also highlighting the ease of circumventing protections. Despite these mechanisms, embedding fonts carries risks, as maliciously crafted tables (e.g., in hinting instructions) can exploit parsing vulnerabilities in rendering engines, potentially leading to execution; has issued advisories on such threats in shared documents.

Emoji and extended glyph support

TrueType fonts originally supported outline for scalable rendering, but extensions introduced in the 2010s enabled color and layered representations for and extended , building on base shapes to accommodate modern requirements. Apple pioneered bitmap-based support through the 'sbix' table, introduced in the 2010s for embedding scalable bitmap graphics in formats like , , or TIFF, allowing direct rendering of color in and macOS systems. This table stores multiple bitmap strikes at varying sizes for a single , ensuring crisp display across resolutions without vector scaling. In parallel, proposed the 'CBDT' (Color Bitmap Data Table) and 'CBLC' (Color Bitmap Location Table) extensions around 2014, standardized in for embedding color bitmap data, including raw RGBA pixels or images, to support multi-color raster in Android and Chromium-based browsers. These tables pair with TrueType outlines for fallback rendering when color is unavailable. For vector-based layered glyphs, the 'COLR' (Color Table) and 'CPAL' (Color Palette Table) extensions, adopted by and integrated into since 2016, enable paint-ordered layering of monochrome outlines with colors from predefined palettes, facilitating complex compositions like multi-layer flags or textured icons. This format references base TrueType outlines as layers, applying colors sequentially for scalable, resolution-independent rendering without bloat. TrueType's emoji evolution incorporates Unicode features like variation selectors for presentation (e.g., text vs. style) and skin tone modifiers, using sequences such as U+1F3FB ( tone) after base glyphs to generate diverse representations, as defined in #51 since 2015. Flags are constructed via regional indicator symbols (e.g., U+1F1FA U+1F1F8 for the flag), layered or bitmap-rendered through these extensions to form composite color glyphs. Google's Color Emoji font, distributed as a .ttc collection for Android, exemplifies platform-specific rendering with CBDT/CBLC support, covering over 3,900 s compatible with 17.0 as of 2025. Despite these advances, color emoji support in TrueType introduces limitations, including significant file size increases—Noto Color Emoji exceeds 10 MB due to embedded bitmaps—potentially impacting load times on resource-constrained devices. On unsupported platforms, such as older Windows versions or non-OpenType renderers, glyphs fallback to black-and-white outlines, losing color fidelity and sometimes altering composition for modifiers like skin tones.

References

  1. https://learn.microsoft.com/en-us/typography/truetype/history
  2. https://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=iws-chapter08
  3. https://learn.microsoft.com/en-us/typography/truetype/
  4. https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6.html
  5. https://www.historyofinformation.com/detail.php?id=1030
  6. https://developer.apple.com/fonts/TrueType-Reference-Manual/RM01/Chap1.html
  7. https://simoncozens.github.io/fonts-and-layout/history.html
  8. https://www.truetype-typography.com/tthist.htm
  9. https://lowendmac.com/2000/macintosh-system-fonts/
  10. https://www.upi.com/Archives/1989/09/19/Apple-Microsoft-sign-software-agreement/3607622180800/
  11. https://www.cringely.com/2013/03/14/accidental-empires-chapter-11-font-wars/
  12. https://www.nytimes.com/1991/05/20/business/a-software-alliance-is-expected.html
  13. https://learn.microsoft.com/en-us/typography/font-list/times-new-roman
  14. https://learn.microsoft.com/en-us/typography/tools/vtt/
  15. https://learn.microsoft.com/en-us/typography/opentype/spec/name
  16. https://learn.microsoft.com/en-us/shows/history/history-of-microsoft-1990
  17. https://freetype.org/patents.html
  18. https://vintageapple.org/inside_r/pdf/QD_GX_Typography_1994.pdf
  19. https://www.unicode.org/history/versionone.html
  20. https://www.w3.org/TR/WOFF/
  21. https://www.w3.org/TR/WOFF2/
  22. https://learn.microsoft.com/en-us/typography/opentype/spec/colr
  23. https://learn.microsoft.com/en-us/typography/opentype/spec/ttch01
  24. https://learn.microsoft.com/en-us/typography/opentype/spec/glyf
  25. https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6glyf.html#COMPOUNDGLYPHS
  26. https://learn.microsoft.com/en-us/typography/truetype/hinting
  27. https://developer.apple.com/fonts/TrueType-Reference-Manual/RM05/Chap5.html
  28. https://learn.microsoft.com/en-us/typography/truetype/hinting-tutorial/
  29. https://learn.microsoft.com/en-us/typography/opentype/spec/tt_instructions
  30. https://developer.apple.com/fonts/TrueType-Reference-Manual/RM03/Chap3.html
  31. https://freetype.org/ttfautohint/
  32. https://harfbuzz.github.io/integration-freetype.html
  33. https://developer.apple.com/fonts/
  34. https://developer.apple.com/documentation/coretext/
  35. https://learn.microsoft.com/en-us/windows/win32/directwrite/direct-write-portal
  36. https://freetype.org/freetype2/docs/hinting/text-rendering-general.html
  37. http://rastertragedy.com/RTRCh4.htm
  38. https://freetype.org/freetype2/docs/reference/ft2-auto_hinter.html
  39. https://learn.microsoft.com/en-us/typography/opentype/spec/otff
  40. https://fonttools.readthedocs.io/en/latest/ttx.html
  41. https://learn.microsoft.com/en-us/security-updates/securitybulletins/2012/ms12-039
  42. https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_fonts/WOFF
  43. https://learn.microsoft.com/en-us/typography/opentype/spec/otff#ttc-header
  44. https://learn.microsoft.com/en-us/typography/opentype/spec/otff#font-collections
  45. https://www.hollandlitho.com/font_files_and_formats.html
  46. https://fontforge.org/docs/techref/macformats.html
  47. https://www.adobe.com/content/dam/acom/en/devnet/font/pdfs/TN5609.PS3_Fonts.pdf
  48. https://helpx.adobe.com/acrobat/kb/font-handling-in-acrobat-distiller.html
  49. https://learn.microsoft.com/en-us/windows/win32/gdi/raster--vector--truetype--and-opentype-fonts
  50. https://fontforge.org/docs/faq.html
  51. https://fontforge.org/docs/ui/menus/filemenu.html
  52. https://appleinsider.com/articles/23/11/08/postscript-is-gone-long-live-truetype-and-opentype
  53. https://developer.apple.com/library/archive/documentation/mac/pdf/ImagingWithQuickDraw.pdf
  54. https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6AATIntro.html
  55. https://developer.apple.com/library/archive/documentation/StringsTextFonts/Conceptual/CoreText_Programming/Introduction/Introduction.html
  56. https://developer.apple.com/library/archive/documentation/StringsTextFonts/Conceptual/CoreText_Programming/Overview/Overview.html
  57. https://support.apple.com/guide/font-book/install-and-validate-fonts-fntbk1000/mac
  58. https://uxdesign.cc/why-fonts-look-better-on-macos-than-on-windows-51a2b7c57975
  59. https://developer.apple.com/fonts/system-fonts/
  60. https://eclecticlight.co/2025/05/03/a-brief-history-of-fonts-in-mac-os/
  61. https://www.betaarchive.com/wiki/index.php/Microsoft_KB_Archive/83247
  62. http://jeffpar.github.io/kbarchive/kb/089/Q89652/
  63. https://learn.microsoft.com/en-us/windows/win32/intl/uniscribe
  64. https://learn.microsoft.com/en-us/typography/cleartype/truetypecleartype
  65. https://learn.microsoft.com/en-us/typography/cleartype/
  66. https://fluent2.microsoft.design/typography
  67. https://learn.microsoft.com/en-us/windows/win32/directwrite/opentype-variable-fonts
  68. https://support.microsoft.com/en-us/windows/manage-fonts-in-windows-f12d0657-2fc8-7613-c76f-88d043b334b8
  69. https://learn.microsoft.com/en-us/windows/security/operating-system-security/device-management/block-untrusted-fonts-in-enterprise
  70. http://freetype.org/
  71. https://www.linuxfromscratch.org/blfs/view/cvs/general/freetype2.html
  72. https://harfbuzz.github.io/
  73. https://medium.com/kotlin-android-chronicle/understanding-freetype-font-rasterization-and-glyph-rendering-in-android-a8c10aa74de3
  74. https://skia.org/docs/user/tips/
  75. https://askubuntu.com/questions/897/how-can-i-make-fonts-look-like-they-do-in-windows
  76. https://crates.io/crates/swash
  77. https://github.com/pdeljanov/infinality-remix
  78. https://learn.microsoft.com/en-us/typography/opentype/spec/os2
  79. https://adobe-type-tools.github.io/font-tech-notes/pdfs/AcrobatDC_FontPolicies.pdf
  80. https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6OS2.html
  81. https://learn.microsoft.com/en-us/typography/fonts/font-faq
  82. https://github.com/fonttools/fonttools
  83. https://learn.microsoft.com/en-us/security-updates/securitybulletins/2013/ms13-053
  84. https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6sbix.html
  85. https://learn.microsoft.com/en-us/typography/opentype/spec/sbix
  86. https://learn.microsoft.com/en-us/typography/opentype/spec/cbdt
  87. https://github.com/googlefonts/noto-emoji
  88. https://learn.microsoft.com/en-us/typography/opentype/spec/cpal
  89. https://learn.microsoft.com/en-us/windows/win32/directwrite/color-fonts
  90. https://source.android.com/docs/core/fonts/custom-font-fallback
Add your contribution
Related Hubs
User Avatar
No comments yet.