Hacker News Reader

As others pointed out, font hinting is solving a completely different problem from the one that Apple faces or that you describe. You describe the problem of displaying small text on a low-resolution grid. Font hinting is indeed a passable solution to that problem. However Apple's problem is displaying small text, period (Retina displays have plenty of resolution). The first sentence of the top link you give, "A quality outline font is one that provides legibility at small sizes on low resolution devices" tells us why this is not relevant. Nobody cares about low-resolution devices anymore. Apple set out to make things legible assuming infinite resolution.

Maybe we should have a hinting equivalent for physical size then (rather than pixel hinting or an entirely different font).

Adobe used to have this feature in their typeface format and type design tools in the 1990s. The format was called “Multiple Master”, see https://en.wikipedia.org/wiki/Multiple_master_fonts and http://blog.typekit.com/2014/07/30/the-adobe-originals-silve.... (Metafont also has this feature.)

In practice, type designers found that making such fonts took dramatically more work, and typographers/publishers weren’t willing to pay commensurately more money. So it didn’t see much adoption outside Adobe.

As a result, the format died out, and we stuck with descendants of the original PostScript font format.

More recently, many companies (but especially Adobe) ship “pro” typefaces with separate fonts for various “optical sizes”. Again, producing these takes a lot of extra work, so most type designers don’t bother with it, and because it is designed to work with standard tools (which don’t have special knowledge of the feature), typographers/designers must explicitly choose which optical size they want to use in each context. So in theory it’s inferior to the Multiple Master format, but in practice it is backwards compatible, which ends up being more important.

Apple can solve this problem for their UI fonts specifically, because they have full control. Unfortunately, they haven’t offered these features for use with other typefaces.

I believe that's already possible with TrueType now if the person doing the hinting is willing to make the effort.

TrueType hints are restricted programs stored as bytecode. One instruction, MPPEM, requests the pixels per em. Another instruction, MPS, gets the current point size. There are also instructions to find pixel lengths across various axes. I'd have to think about the details but it should be possible to estimate the DPI and physical glyph size from those and then adjust the hinting accordingly.

TrueType hints are not used in many contexts, or are not used consistently. So this isn’t useful in practice. Also, I don’t believe that TT hints can handle the range of letter-form and spacing changes required to properly scale from small captions up to large headings.

Font hinting lets you move points around based on sizes, dpi and rendering modes using a stack-based bytecode language.

Sure the primary use case for many years was to cope with low-resolution but it can be used in the way the poster above described. In fact you can use it in the other direction too so that larger sizes take on more specific characteristics instead of having two fonts and a hack that switches at 20pt like they're doing with San Francisco.

Source: Have actually TrueType hinted fonts.

Switching between two fonts in different circumstances seems like less of a hack than embedding some kind of Virtual Machine into your font engine with all the security issues that follow.

The language is elegant, lets you perform tweaks down to an individual level and works across many platforms and can be used in any font.

It's totally possible to create a safe virtual machine for specific uses. There have been many attack vectors for fonts over the years due to the complexity in parsing them. I do not recall any of them being due to the hinting language.

The Mac one is hard coded for a single OS and font combination and a specific size down in the operating system.

I disagree that the later is less of a hack.

I'm not sure OSX can respect the pixel grid, at least any more. People think "Retina" means "one virtual pixel is 2x2 physical pixels", and on iOS it does mean that; on OSX, though, it means "we render to a back-buffer that's at least 1.5x as large, using our unscaled 2x assets, and then downsample[1] to the physical display size." That means that the physical pixel grid is truly a black-box abstraction from the text renderer's perspective. Applications have no idea how many physical pixels there are (unless they draw to an OpenGL buffer instead of going through Quartz.)

[1] This settings panel (http://i.imgur.com/TRtR17g.png), despite looking like a DPI adjuster, is actually to choose what size backbuffer gets rendered-onto-and-downsampled. Note the shitty blurry edges of the text in that just-taken screenshot (no, it's not a JPEG): the text is obviously sitting on non-integral pixel positions after downsampling. It actually looks fine, when it's shrunk down onto your 15" screen and you're sitting two feet from it; it just doesn't look terribly clean at examinable 1:1 scale.

It doesn't even mean that on iOS since the advent of the iPhone 6 Plus.

Hinted fonts did look great on low-DPI screens. To my taste, Microsoft's Tahoma, the Win95 / NT4 system font designed by Matthew Carter, is probably the best font that you can squeeze into a grid about 9 pixels high:

https://www.microsoft.com/typography/fonts/family.aspx?FID=1...

However, nicely hinted fonts were designed from scratch for that purpose. You can see it in Tahoma's letter shapes at larger sizes, the construction is very grid-like overall.

A well-hinted Helvetica really wouldn't look any different from Arial back in 1995. The low resolution makes Helvetica lose its character.

I think Apple made a good choice in designing a more contemporary font.

That wouldn't be Helvetica, so they would probably give it a new name. Given the ambiguous ubiquity of Helvetica, it's possible they'd have chosen a name like San Francisco anyway. Whether the feature is provided by hinting or a pair of fonts is moot.

I'm not sure how font hinting would solve this problem. The resolution of the Apple Watch is 326ppi, so the pixel grid doesn't matter so much.

Seems like the different San Francisco variants were designed to solve problems due to the physical dimensions of the letterforms at small sizes, not anything to do with a pixel grid.

The DPI may be high, yes, but the number of actual pixels is still quite low. Looking it up, I see that the smaller watch has a 272x340 display and the larger has a 312x390. That's either 92k or 122k pixels to work with -- about 1/3 VGA -- over the entire display. At those scales, hinting is absolutely relevant unless perhaps you're only displaying a few relatively large words.

It's less than an inch across, and viewed typically at arm's length. Yes, you're only displaying a few relatively large words. They're not trying to display 80 column text on a watchface.