from mass_driver import io
Supported Languages
Accessible Ligatures
True Italics
Disambiguated Forms
Functional Ink Traps
Unlike readability, which is a general measure of how comfortable a typeface is to read, legibility refers to how quickly and easily individual characters can be identified.
While most typefaces sacrifice legibility in order to improve overall reading comfort, MD IO prioritises shape recognition above all else.
The digit 1, lowercase l and capital I are all visually distinct from each other.
The number 0 has either a dot or a slash, to distinguish it from the capital letter O.
The number 8 is narrower at the top, and the eszett uses a blackletter form to avoid confusion with the capital B.
The comma and period (and glyphs derived from them) are clearly distinct, even at small sizes.
Legacy single-character ligatures are drawn single-width, so you can spot them in text.
Glyph constructions are optimised for better clarity and performance at small text sizes.
The differences between brackets, parentheses & braces are emphasised.
90° stroke endings help improve rendering on digital screens, regardless of size.
200 Thin
300 Light
400 Regular
500 Medium
600 Semibold
700 Bold
800 Black
900 Ultra
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
## Design Information
MD IO isn’t exclusively a programming font, but it
was designed from the beginning to be ideal for
writing code.
Alongside a tall x-height and balanced proportions,
IO’s relatively large ink traps help to maintain
clarity at smaller pixel sizes. *In the italic
styles, glyphs use a cursive-inspired construction
for greater emphasis.*
[image: ligatures](./assets/ligatures.svg)
A suite of subtle, accessibility-focused ‘ligatures’
help to improve the spacing of glyphs, and therefore
visual flow. In reality, these are actually *dynamic
repositioning rules* — unlike ligatures, they’re
compatible with both syntax highlighting and manual
tracking (letter-spacing).
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>MD IO · Typeface Family by Mass-Driver™</title>
<meta name="viewport" content="width=device-width, initial-scale=1" />
<link rel="stylesheet" href="static/site.css" />
<!-- Metadata // Link preview image -->
<meta property="og:image" content="https://io.mass-driver.com/opengraph.png">
</head>
<body>
<!-- Loading/Splash Screen -->
<div class="loading" id="loading_screen">
<p class="detail">
<i>from</i> mass_driver <i>import</i> io
</p>
</div>
function manhattan(x1, y1, x2, y2) {
return Math.abs(x1 - x2) + Math.abs(y1 - y2);
}
function aStar (board, startx, starty, goalx, goaly,
open = Array(8 * 8).fill(null),
closed = Array(8 * 8).fill(null),
current = {
"coord": [startx, starty],
"distance": 0,
"heuristic": manhattan(startx, starty, goalx, goaly),
"previous": null
}) {
const [x, y] = [...current.coord];
if (x === goalx && y === goaly) {
closed[x + y * 8] = current;
return (lambda = (closed, x, y, startx, starty) => {
if (x === startx && y === starty) {
return [[x, y]];
# findIndexBinary :: (a -> Ordering) -> [a] -> Maybe Int
def findIndexBinary(p):
def isFound(bounds):
(lo, hi) = bounds
return lo > hi or 0 == hi
def half(xs):
def choice(lh):
(lo, hi) = lh
mid = (lo + hi) // 2
cmpr = p(xs[mid])
return (lo, mid - 1) if cmpr < 0 else (
(1 + mid, hi) if cmpr > 0 else (mid, 0))
return lambda bounds: choice(bounds)
def go(xs):
(lo, hi) = until(isFound)(
half(xs)
)((0, len(xs) - 1)) if xs else None
return None if 0 != hi else lo
namespace Search {
using System;
public static partial class Extensions {
/// <summary>Use Binary Search to find index of GLB for value</summary>
public static int BinarySearchForGLB(this T[] entries, T value)
where T : IComparable {
return entries.BinarySearchForGLB(value, 0, entries.Length - 1);
}
public static int BinarySearchForGLB(this T[] entries, T value, int left, int right)
where T : IComparable {
while (left <= right) {
var middle = left + (right - left) / 2;
if (entries[middle].CompareTo(value) < 0)
left = middle + 1;
else
right = middle - 1;
}
return right;
┌──────────────────────────────────╖
│ MD IO :: Overview :: (16 Styles) ║ ╭──────────────────╮
├──────────────────────────────────╢ │ Yes, it also has │
│ UPRIGHT ITALIC ║ │ ascii art glyphs │
│ ├╴Thin ├╴Thin Italic ║ ╰───────────╮┄─────╯
│ ├╴Light ├╴Light Italic ║ │
│ ├╴Regular ├╴Italic ║ ╭───────┄╰──────────╮
│ ├╴Medium ├╴Medium Italic ║ │ For all your │
│ ├╴Semibold ├╴Semibold Italic ║ │ box-drawing needs │
│ ├╴Bold ├╴Bold Italic ║ ╰───────────────╮┄──╯
│ ├╴Black ├╴Black Italic ║ │
│ ╰╴Ultra ╰╴Ultra Italic ║ ╭──────╯
├──────────────────────────────────╢ │
│ [BACK] [OK] ║ ╭─┄╰─╮
╘══════════════════════════════════╝ │ <3 │
┏━━━━━━━━━━━━━━━━━━━━━━━┓ ╰────╯
┃ ┌───┬───┐ ┌───┬───┐ ┃ ▒
┃ ├ [[ cFirstHour ]] ┼ [[ cSecondHour ]] ┤ : ├ [[ cFirstMin ]] ┼ [[ cSecondMin ]] ┤ ┃=▒
┃ ╘═══╧═══╛ ╘═══╧═══╛ ┃ ░
┗━━━━━━━━━━━━━━━━━━━━━━━┛
Alternate eszett
Circled Numbers
Black Circled Nums
Ordinals
Superscript
Subscript
Arbitrary Fractions
Slashed Zero
Code Ligatures
Localised Forms
Code ligatures and localised forms are enabled by default where supported.
See the Specimen PDF for full details and usage
instructions.
414 Supported Languages
Language support detection by Hyperglot ↗
For languages with multiple scripts or writing systems, only the Latin script is supported.
Language support is predicted based on codepoint coverage and not guaranteed to be accurate.