Font

Fonts are used for rendering text in Minecraft. Several fonts are used in the game; the primary font used is known as either Mojangles or Minecraft Seven.

Multiple fonts can be defined and referenced with resource packs.

Fonts available

Java Edition

By default, Java Edition includes 4 fonts.

default
Main article: Mojangles
alt
uniform
Main article: GNU Unifont
illageralt
Main article: illageralt

Bedrock Edition

In Bedrock Edition, there are 2 default fonts. Many other font resources are used regardless of the font setting. Unlike in Java Edition, the font can be swapped out with a built-in setting. The font can be changed in for touchscreens, or D-pad right for controllers, and then the gear icon.

Mojangles
Main article: Mojangles
Noto Sans
Main article: Noto Sans

Display modifications

Bold text

Bold text is rendered by drawing each character twice: once at its normal position and again one pixel to the right. This technique creates the appearance of thicker, bolder text without modifying the font itself.

Experience bar text

This section of the article is empty.
 
You can help by expanding it.

The text on the experience bar is bright green Mojangles with a black outline.

Shadow

In most places text is rendered, a shadow appears beneath every character. This shadow is a copy of the character's glyph, with the red, green, and blue values divided by 4 and positioned 12.5% south-east of the character, relative to its spacing. Regardless of the resolution of the character's texture, the shadow is always moved by 12.5%. In the default font (assets/minecraft/textures/font/ascii.png), the shadow position is moved 1 pixel down and to the right.

For pixels where the glyph overlaps with the shadow, the above glyph's channels have 1 subtracted from them. For example, in areas where a white (#FFFFFF) glyph's pixel overlaps a shadow's, the white pixel becomes #FEFEFE.

Glowing text

Comparison of all the dyed glowing texts.

Glow Ink Sac applied on a sign causes a character to create eight copies of itself in all eight directions. This results in the font appearing to have a thick outline. Glowing text always renders with an emissive texture, so it appears bright in darkness. The text takes priority over the outline; outlines appear below a character's pixels if they conflict. However, it is a rendering effect that does not actually emit any light. The player can use a black ink sac on the sign to remove the glow.

In a sign's block data, [NBT Compound / JSON Object] front_text or [NBT Compound / JSON Object] back_text's [Boolean] has_glowing_text controls whether the text glows.

Providers

This feature is exclusive to Java Edition.
 

A font is constructed from a list of providers, sources that provide characters to use. Different providers use different formats and methods of constructing characters. The default font uses all except for ttf.

A font file uses the following format:

  • [NBT Compound / JSON Object]: The root object.
    • [NBT List / JSON Array] providers: A list of providers.
      • [NBT Compound / JSON Object]: A provider. Each type of provider is elaborated below.
        • [String] type: The type of provider.
        • [NBT Compound / JSON Object] filter: Options in Language -> Font Settings that must be in the given state for the provider to be used. Right now, these buttons are hardcoded, preventing the extension of these font filtering capabilities beyond the preset options provided.
          • [Boolean] uniform: Optional. The value that the "Force Uniform" option must be for this font provider to be enabled.
          • [Boolean] jp: Optional. The value that the "Japanese Glyph Variants" option must be for this font provider to be enabled.

Bitmap provider

The bitmap provider defines simple bitmap glyphs – glyphs from textures.

  • [NBT Compound / JSON Object]: The provider.
    • [String] type: bitmap.
    • [Int] ascent: The amount of vertical shifting is applied to the glyph. In typography, the ascent is the distance above the baseline to the cap height (top of glyph). The baseline in a glyph is the line where the descender begins. For example, in the lowercase letter y, the bottom end of the y extends past the baseline. In Vanilla, when the height is 8, the ascent is most often 7, as the descender is 1.
    • [NBT List / JSON Array] chars: The characters associated with each glyph in the texture file. The characters inside each string entry inside this list are mapped to the corresponding positions in the referenced file. The texture is divided evenly according to the number of strings in the list, and the length of the longest string in that list.
      • [String]: One line of characters.
    • [String] file: The PNG file used for the characters of this provider. Textures may be any size, and glyphs may be any color. White glyphs can be colored any other color in-game. Other colors retain that tint when re-colored. Black glyphs always appear black. The glyphs' widths are automatically determined based on the last right-most column of pixels containing any alpha value above 0. Glyphs themselves must not be larger than 256×256 pixels.
    • [Int] height: The scale of the resulting glyph. This scale should generally match the glyph's individual height, or be a power of it. While heights outside of this recommended range are allowed and are valid, the resulting glyphs declared inside the provider appears warped when rendered in-game. The height field is optional. When not defined, it defaults to 8, regardless of the underlying texture resolution.

UTF-16 codepoints encoded in UTF-8 sequences can be used by use of surrogate pairs. To convert a character into a surrogate pair, one can use the following equations, where C is the codepoint in decimal:

  • High Surrogate (first codepoint): ((C − 65536) − (C % 1024)) ÷ 1024 + 55296
  • Low Surrogate (second codepoint): (C % 1024) + 56320

When the length of either chars or its strings is not a divisor of the resource's dimensions, it can result in an unexpected division of glyphs. The Unicode escape \u0000 can be used to add padding in the list. Padding acts as a "dummy character", so that the glyph data at that corresponding position in the file is not assigned a character.

Space provider

The space provider defines the width of a character's glyph.

  • [NBT Compound / JSON Object]: The provider.
    • [String] type: space.
    • [NBT Compound / JSON Object] advances: Object that specifies the width of each character. The keys are the characters. The keys must be only 1 grapheme long (multi-byte character still count as one character, like U+1F525 🔥 FIRE, which is encoded as 0xF0 0x9F 0x94 0xA5). Although it is intended to be used for whitespace characters (characters that have "WSpace=Y" in Unicode), it can be used for any character, as long as there is no prior definition of that character's glyph.
      • [Int] <a codepoint>: The width of the character specified by the key. Values must be an integer whose absolute value is less than or equal to 256. Negative values are forced to 0 when typed in chat.

By default, the game has two widths defined:

  • U+0020 <SPACE> SPACE is 4
  • U+200C <ZWNJ> ZERO WIDTH NON-JOINER is 0

TTF provider

The ttf provider embeds already-compiled TrueType and OpenType fonts.[a]

  • [NBT Compound / JSON Object]: The provider.
    • [String] type: ttf.
    • [String] file: A resource location to a file ending in .ttf. Path is relative from /assets/minecraft/font/.
    • [Int] oversample: The resolution to render at. Values that don't match the glyph's native em sizing division or DPI cause it to be anti-aliased.
    • [NBT List / JSON Array] shift: An array of two integers. It defines how much each glyph contained in this TrueType font is to be moved horizontally and vertically.
      • [Int]: The horizontal shifting (positive is leftward, negative is rightward).
      • [Int]: The vertical shifting (positive is downward, negative is upward).
    • [Int] size: This field is similar to a bitmap provider's height field. This is a divisor by which the em-size of the font's glyphs are to be divided and then fitted into the bitmap grid. This value can vary greatly across different fonts.
    • [String][NBT List / JSON Array] skip: A list of strings or a string of the characters to which this font has no assignment. If it is a list of strings, the strings are concatenated together and then act as if it were originally a string. This allows the same input as a bitmap provider's chars.

Unihex provider

The unihex provider is a replacement for the Legacy Unicode provider. It uses the GNU Unifont .hex format. It references a ZIP archive that contains a number of .hex files.

  • [NBT Compound / JSON Object]: The provider.
    • [String] type: unihex.
    • [String] hex_file: A resource location to a .ZIP archive file. It must be openable by Java's ZipFile. Inside, there must be at least 1 .hex file at the root of the archive. Subdirectories are not walked through and filenames with an extension different from .hex are ignored. Filenames must follow normal file resource name rules.
      • [String]: Each .hex file in the .ZIP archive contains one or more glyph definitions. Each line has one glyph definition, and follows the format <codepoint>:<data>. <codepoint> is the Unicode codepoint, without the U+ or 0x. It must have four, five, or six digits. The <data> is a hexadecimal number that encodes the glyph data. Glyphs are always sixteen pixels high. Glyphs can be eight, sixteen, 24, or 32 pixels wide.[b]
    • [NBT List / JSON Array] size_overrides: Defines custom widths for a range of characters.
      • [NBT Compound / JSON Object]: One range.
        • [String] from: The starting character for the range at which this size override applies to.
        • [String] to: The ending character for this range. Both from and to must be one character.
        • [Int] left: The position of the left-most column of glyphs in range.
        • [Int] right: The position of the right-most column of glyphs in range. Both left and right must be between 0 and 32, inclusive.

Reference provider

The reference provider serves one purpose: to include another provider only once. It can be used to include providers from other fonts in other resource packs.

Referenced providers are guaranteed to be loaded only once, no matter how many times they are included.

  • [NBT Compound / JSON Object]: The provider.

Legacy Unicode provider

BlockSprite rose.png: Sprite image for rose in Minecraft
This section describes content that has been removed from the game.
 
This feature was present in earlier versions of Minecraft, but has since been removed.

The legacy_unicode provider is similar to the bitmap provider in that it loads glyphs from only textures. This format is deprecated, and is prioritized only when the "Force Unicode Font" option is turned on. It acts as a "fallback" for glyphs that no other provider has defined a texture for.

  • [NBT Compound / JSON Object]: The provider.
    • [String] type: legacy_unicode.
    • [String] template: A reference to a set of files. The string %s must be included in this field. %s is replaced with every valid page number, in hexadecimal.
    • [String] sizes: A reference to a binary resource that contains the widths of each glyph. Most often, this file is called glyph_sizes.bin; this is its default name.

Templates, specified by the template field, are name-based, and are all PNG files. Each template file must have equal width and height. The template numbering scheme works based off of the Unicode BMP. The number used is equal to a BMP codepoint's high byte.[c][d] These template textures are called "pages". Template page "22" must cover characters U+2200 to U+22FF. Page numbers go from 00 to FF. Characters beyond U+FFFF cannot be changed through this provider. By default, each glyph is 16×16 pixels wide, so each individual template page is 256×256 pixels (16 glyphs on each line, 16 lines). Its default textures are an outdated version of GNU Unifont.[1]

The file referenced by the sizes field must have the following format. Each character width is one byte large. The high nibble[e] records the starting position, while the lower nibble records the ending position in the 16×16 glyph grid. For this reason, the file must be 0xFFFF bytes long (65535 in decimal).

A specific character's width is determined by finding its codepoints byte. The character 'A' has a codepoint of U+0041, so byte offset 0x41 (65 in decimal) would be addressed. A square character occupying the entire grid (pixel width #1 [0, 0x0] through #16 [15, 0xF]) would have a value of 0x0F (15 in decimal).

Widths cannot extend past 16 pixels, and characters whose codepoints are greater than U+FFFF are not handled. Some codepoints are invalid on their own. These are the surrogate pairs; they are used to encode codepoints higher than U+FFFF in UTF-16. This means that the template pages D8, D9, DA, DB, DC, DD, DE, and DF are invalid and cannot be used.

Emoji support

Minecraft has included textures for a number of emojis. The earliest emoji textures were for ☺☻. Since 1.15, this support has expanded. Emojis are monochromatic and behave just as any other character. The game does not support modifiers, such as skin tone, joining, or emoji presentation. The skin tone modifiers U+1F3FB..U+1F3FF 🏻 🏼 🏽 🏾 🏿 do not apply colored skin tones to their applicable emojis, and instead show tones as their Unifont glyphs. Joining multiple emojis via U+200D ‍ ZERO WIDTH JOINER to create 1 single emoji is not supported; multi-sequence emoji such as 👨‍👩‍👧 instead show as 👨‌👩‌👧 with dotted boxes showing ZWJ between them. Variation selectors, which control presentation, are displayed as dotted boxes with VSnumber.

For characters supported in the default font, as opposed to the fallback fonts, see Mojangles#Emoji.

Bedrock Edition does not support any character above U+FFFF, which includes many modern emoji. It does not include any textures for emojis below that either; only those provided by GNU Unifont below U+FFFF are included and visible.

Special characters

In Java Edition, there are 2 characters that are accessible only through technical means:

  • The first is U+FFFD � REPLACEMENT CHARACTER, which appears when either the U+FFFD character is typed, or there is an invalid UTF-8 multi-byte sequence.
  • The second is the "notdef" character,[f] seen when a character that has no texture in the currently-used font is typed. It is hardcoded and cannot be modified through resource packs. It is sometimes called "tofu" in the typographical community because of it resembles a block of tofu. More information on this character can be found at Missing textures and models#Missing font character.

In Bedrock Edition, a character with no texture data appears as a blank space. The U+FFFD � REPLACEMENT CHARACTER shown belongs to GNU Unifont.

History

This section is missing information about: Console Edition font info.
 
Please expand the section to include this information. Further details may exist on the talk page.
Java Edition Classic
0.0.2aAdded text to the game, and the default font as a result.
Java Edition
1.111w49aAdded GNU Unifont to fully support multi-languages.
1.513w09aThe font texture is now able to be changed in a resource pack.
Added support for glyph resolutions above 16×16.
1.6.2reuploadFixed distorted font when HD font is used.[2]
1.13pre6Fonts are now saved as TrueType font files.
pre7Reverted TrueType font.
Retroactively removed TrueType font file from pre-6.
1.1620w17aRaw JSON text format now has a font key, which defines the font to use for that component. Default is minecraft:default.
Added the unihex provider.
The full range of Unicode is now supported in font definitions.
Pre-release 7The chars field of the bitmap provider can now specify UTF-16 codepoints.
1.1922w11aAdded the space provider.
Rendering of the space glyph is no longer hardcoded; it needs to be declared manually in the font.
1.2023w17aRemoved the legacy_unicode provider.
Added the unihex provider.
Added the reference provider.
1.20.524w06aAdded font variant filters to font providers.
1.21.4Pre-Release 1GNU Unifont updated to version 16.0.01.
1.21.625w18aGNU Unifont updated to version 16.0.03.
Added previously omitted Unifont glyphs for Private Use Areas.
Unihex Font Provider: Field size_overrides is now optional (defaults to empty list).
Pocket Edition Alpha
v0.1.0Added the default ASCII font called default.png.
v0.11.0build 1Added GNU Unifont to fully support multi-languages.
Legacy Console Edition
Xbox 360Xbox OnePS3PS4PS VitaWii USwitch
TU0CU11.001.001.00Patch 11.0.1Added text to the game, and the default font as a result.
TU1Updated the font with a clearer version.

Issues

Issues relating to "Font" are maintained on the bug tracker. Issues should be reported and viewed there.

Trivia

  • Although not in the changelog or specification, the default copy of the unihex provider also includes a [NBT List / JSON Array] __ranges field in the [NBT Compound / JSON Object] entries of [NBT List / JSON Array] size_overrides. It is a list of strings, being the Unicode block names of the applying range.
  • The New Nintendo 3DS Edition's font is a combination of the pre-1.12 JE font and some select characters from GNU Unifont. In addition, the ® sign was changed.

Gallery

See also

Notes

  1. Despite its name, the TTF provider accepts OpenType ("otf") fonts.
  2. Because the height is always 16, the width can be calculated. It is always equal to len(data) // 4.
  3. "High byte" refers to the first byte in a multi-byte sequence. For example, the high byte of 0xABCD is 0xAB.
  4. For codepoints with digits less than 4, they are padded with 0. For example, 0xF3 would be padded to 0x00F3: page 00. Likewise, 0xFAE is 0x0FAE: page 0F.
  5. A nibble is "half" of a byte. For example, in the byte 0xAB, A is the high nibble and B is the low nibble.
  6. Is not an actual Unicode character. "notdef" refers to the name given to it in font formats.

References

  1. MC-197772 — Missing textures in minecraft:uniform font — resolved as "Fixed".
  2. MC-17673 — Distorted fonts when using a converted texturepack on startup — resolved as "Fixed".

External links

Navigation