Hacker News new | past | comments | ask | show | jobs | submit login
A parametric version of the Spectral font (prototypo.io)
238 points by tbassetto on June 21, 2017 | hide | past | web | favorite | 81 comments



A system and method for letting "The Marketing Guy" choose and design the font instead of a trained graphic designer.

This isn't going to end well.

Have you ever seen a font and thought "oh, that's ugly" but it's really hard to put into words exactly why? Font design is all about aesthetics and custom hand-tweaking every single curve of every single letter and making them look exactly right.


The Marketing Guy already has access to hundreds of fonts with thousands of variations, I fail to see how this will make a difference.


Presumably the designer is setting the constraints.

That's already a problem, modern typefaces will have 10+ weights, with 5+ variations within each weight, 50+ fonts in total.

It's quite easy for The Marketing Guy to make an ugly layout with those options, but for a skilled craftsman having that many options lets them fine tune a design. Same here.


The marketing guy use Comic Sans.


This concept of a parametric font is the modern-day reincarnation of Donald Knuth's https://en.wikipedia.org/wiki/Metafont .


There's also some of Adobe's Multiple Master fonts in there, too: https://en.wikipedia.org/wiki/Multiple_master_fonts




Iosevka is also parametric, but fixed for a given TTF, as far as I can tell.

Very nice for coding.

https://github.com/be5invis/Iosevka


Parametric fonts go back to at least metafont.

Pretty sure you can do all the transformations indicated on the page in 'native' metafont.


The involvement of Metafont with parametric design doesn't necessarily mean that it's a sound typographic principle. As others have mentioned, professional font design is a business of total perfectionism and particularity: you can't really parameterize a font family in a totally satisfactory way (and italic is not in general just an oblique transformation of the standard characters).

This parametric approach is most likely to work if used with a "curve-fitting" mentality to approximate and interpolate sets of hand-tuned characters, rather than a methodology that aims to describe the essence of a character parametrically (as is routine in architectural parametric design).


This is like arguing linguistics is invalid because language is art.


Trust me, reducing a typeface family to a parametric formula with continuous and valid/beautiful transitions between the various fonts, let alone weights, requires superhuman intelligence and effort.

I'm claiming that the scope of parameterized fonts is limited, in an analogous way to linguistics not trying to explain poetry.


I'm using this as my daily-driver font when I remember to install it. :)


It looks really, really bad at my browser's current size:

http://i.imgur.com/ZvyLwjB.png

http://i.imgur.com/LC9cive.png


It's also cut off at 2560x1440 on a Chrome web browser. Dunno how anybody can get excited about a font by Google that even Google can't figure out how to layout properly in a Google browser.


It wasn't made by Google... it's only hosted on Google fonts.


Same here. Kind of ironic that 'user experience' is the only text that was cut off when I loaded the page. https://0x0.st/lRi.png


Does this actually have anything to do with Google? From what i can tell, prototypo is a completely separate startup company with some per-month pricing plan

If not, this looks like some bad trademark abuse, as everyone here seems to think this is somehow done by Google :(


As far as I can tell, Spectral is listed in Google Fonts:

https://fonts.google.com/specimen/Spectral

Beyond that, there doesn't seem to be a connection.


OK, we've changed the title above from "Spectral, the first parametric Google font".


Parametric fonts are cool. I think it's a stretch to say things like "Opening up to a new era of type design" though. Yes, the feature of "variable fonts" was added to the OpenType specification somewhat recently, in September 2016. But before that there was Adobe's "multiple master fonts", and even before that, there was Knuth's METAFONT, something that could have been a truly "new era of type design" but never took off.

See http://www.metaflop.com/modulator for an example of parametric fonts, inspired by Knuth's system: you can drag the sliders to adjust various font parameters, and get many different fonts. Knuth's article The Concept of a Meta-Font [1], published in Visible Language, is a classic. As you read the article he plays various tricks with the fonts as he describes them; it's a delightful read. (His followup article "Lessons learned from Metafont" [2] is also interesting.)

Unfortunately METAFONT as envisioned by Knuth never gained much adoption by other font designers, for (AFAICT) two reasons:

1. Douglas Hofstadter wrote a response [3] pointing out that it is not possible to mechanize all typefaces into a single one, which although a valid point (the article is great), attacks a straw man, arguing against an absurd claim that Knuth never even suggested IMO. So some may have got the wrong impression from it.

2. More importantly, as Richard Southall or Chuck Bigelow (I forget who) said, most type designers think with shapes; they don't think about shapes. Only a mind like Knuth's would prefer to think deeply about the shape of each letter and come up with symbolic descriptions of each, parametrized across the whole family (see Knuth's article The letter S [4] on his struggles with doing this for just one character).

Knuth has often said that we understand things better when we can teach them to a computer, and I still have hope for a future with parametric fonts that are better "understood": not because the shapes will be better, but simply because humanity will be better off with a deeper understanding of letterforms. But I think that whatever the technology, the task of parametrizing shapes will run into similar challenges, some of which were described in the above-mentioned articles and say Richard Southall's Designing New Typefaces with Metafont [5].

[1]: http://www.zigzaganimal.be/elements/the-concept-of-metafont....

[2]: https://s3-us-west-2.amazonaws.com/visiblelanguage/pdf/19.1/...

[3]: https://s3-us-west-2.amazonaws.com/visiblelanguage/pdf/16.4/... / https://www.cs.indiana.edu/pub/techreports/TR136.pdf

[4]: http://www.cnd.mcgill.ca/~ivan/Papers/The%20letter%20S.pdf

[5]: http://i.stanford.edu/pub/cstr/reports/cs/tr/85/1074/CS-TR-8...


> Parametric fonts are cool. I think it's a stretch to say things like "Opening up to a new era of type design" though. Yes, the feature of "variable fonts" was added to the OpenType specification somewhat recently, in September 2016. But before that there was Adobe's "multiple master fonts", and even before that, there was Knuth's METAFONT, something that could have been a truly "new era of type design" but never took off.

I think the reason it's a stretch to say "opening up to a new era of type design" has less to do with the tech itself, and more the lack of implementation/support. variable fonts seem promising because they were a joint effort by apple, microsoft, google, and adobe (i.e. the major browser vendors plus the major design software vendor), but it won't be a new era until we can finally use these things. when arbitrary axes for interpolation are well supported in CSS using something like a GX font file, and when they're supported in adobe photoshop, indesign etc, I think that will be the point when we can adopt the tech, and when the "new era" can really begin.


I thought the problem was that font designers didn't like creating their font in a text editor.

The whole system seemed to be designed to cater to users who were both computer programmers and typographic artists. That's a demographic set that may consist of a single member: Donald Knuth.


Yes I agree, to a first approximation that's true. Dave Crossland (another computer programmer who works with typography) has said similar stuff: https://www.youtube.com/watch?v=zwPObPbk90I, http://understandinglimited.com/2008/07/24/why-metafont-didn..., https://www.tug.org/TUGboat/tb29-3/tb93crossland.pdf, https://speakerdeck.com/davelab6/anrt-2016-why-didnt-metafon...

This is related to the "thinking with shapes" versus "thinking about shapes" comment.

But looking more closely, there were a few people who made fonts with Metafont: Georgia Tobin, Neenie Billawala etc. made a few, as did a lot of people working with non-Latin scripts: e.g. Frans Velthuis and Charles Wikner made really nice Devanagari fonts. (See "The Many Faces of TeX" for Metafont-fonts as of 1988: https://www.tug.org/tugboat/tb09-2/tb21wujastyk.pdf -- that was probably their peak though.)

Still you're right, no "mainstream" type designers switched over.


What's the usefulness of this?

Part of the reason I ask is because while I would trust a UI designer to design the layout, colors, for an application, I think font design isn't as simple because there's a lot of factors that go into it, in some ways scientific and some ways artistic. I wouldn't trust someone who isn't trained in font/typeface design to use a tool like this.

Also: On Safari, this took maybe 5-8 seconds to load, and bogged down the entire browser for that time. Afterwards it took a lot of power to render something else on the page. For something that is only showcasing a font demo to take up that much power is pretty crazy.


I was thinking it might make more sense to design your font and then bake it into something normal for the browser.

On the other hand, I can't imagine seeing myself going "I need something with the Times New Roman curvature, but thicker serifs..."


Generally: it's a way to tweak a font family for use in a specific design context. Obvious parameters would be weight and width, but others could be imagined as well.

In the case of Prototypo, it looks like you tweak things upstream, and then generate concrete font files for each variant you want; those are what you then use in your project.

This still has the downside though of having to distribute multiple fonts, though, even if they're related.

Looking into the future, I wonder if it will ever make sense to push that downstream, and distribute one parametric font to clients. You could then use some styling language on the client end to have the client render the variants you want...


Pre-link-click: Ooo another site by Google these are usually pretty cool; at least they're well made... First impression: LOL this site was made by Google?! Page load is atrocious. Interaction using mobile is very bad. Lasting impression: This is like some weird developer designer hybrid that encourages...I don't even know...Extra....Weird...serifs


I'm just about 100% positive at this point that Google had nothing to do with this. I can't find anything internally that makes me believe we did (and i've looked really hard)


What a wonderful way to add massive complexity to font rendering while delivering spectacularly little value.

Don't get me wrong, it's cool, I just don't see the point. And I don't look forward to my battery life being used for pointless sugar.


Best not to confuse this demo of their parametric font, with the idea of parametric fonts in the first place. This page tries to vary the font as you scroll etc., which is just a (suboptimal) way of interactively demonstrating the font parameters, but not the point.

For a better demo (that does not use the same tech), see http://www.metaflop.com/modulator -- you vary the parameters, then a fixed font is generated that you can download and use. (I mentioned this in another comment below: https://news.ycombinator.com/item?id=14604890)

As for the value: the entire Computer Modern family of typefaces (used in TeX/LaTeX and friends) was generated with METAFONT which embodies the idea of font generation through "pens, programs, and parameters" -- the regular, bold, italic (even typewriter) variants of the font, and at various point sizes, are generated from common font definitions. Similarly the shapes of the loops in say p and d, etc. This ensures consistency and lets you experiment. (Though to be honest, very few people have successfully designed good font families with this approach.)

The articles that I mentioned in the other comment are better at seeing what's the point.


That metaflop link is not only a great visual example of what makes this tech cool, but is also fun to use. The immediate feedback which shows input-output relations reminds me of fun had while messing with character-creation sliders in games like Elder Scrolls and Dark Souls.


> What a wonderful way to add massive complexity to font rendering while delivering spectacularly little value.

I'll attempt to explain the value, because I don't think this demo is doing a good job of showing that. parametric and variable fonts might seem like "pointless sugar," but it's the combination of mostly two things that make this a huge deal: responsive typography for better legibility, and reducing the number and size of font files served over the web.

let's say I have four font files being used on my website -- regular, bold, italic, bold italic. let's say that's 50k per file, so 200k for four network requests. with a variable font, it's maybe ~70k for a single request. that's a huge improvement, but it's not even all that these fonts offer.

responsive typography (adjusting for the right font weight and characteristics depending on the size of the display) is very important for legibility.[1] The slick ultrathin fonts that look good on a 27" 5k display are unreadable on a smaller display. fonts optimized for body text look terrible when used at large sizes, hence the existence of "display" typefaces. there is so much bloat in having tons of different files for this, when the libraries that interpolate fonts in font creation software[2] can be used on the fly instead of during a compilation step.

font rendering is cheap, sending fonts over the wire is not -- so when you frame this new font tech as something that is just as much about speeding up the web as it is about speeding up the design process, it's a little less pointless.

1. https://alistapart.com/blog/post/variable-fonts-for-responsi...

2. https://github.com/LettError/MutatorMath


You can look at it from two ways. It might save some network bandwidth when designers want multiple fonts, but is it worth adding even more complexity to browsers?

Does the average user really care about fonts? I would say definitely not. Most people don't even notice the font.


> Does the average user really care about fonts? I would say definitely not. Most people don't even notice the font.

most people don't think consciously about the font, but that doesn't mean they don't notice or that their experience will be the same reading in one font vs another. some companies spend a lot of money on this. facebook and google, for example, do a/b testing on fonts to see which perform best in ads.

but users also care when a font becomes illegible on the wrong size display, and/or wrong pixel density. the less pixel dense a display is, for example, the bolder a font needs to be. this new tech makes it super easy for developers to actually execute these best practices, eliminates multiple steps from the asset pipeline, reduces network requests, and reduces file size. check out the google fonts analytics page[1] for an idea of how many trillions of fonts served that this will affect.

1. https://fonts.google.com/analytics


Making use of the fonts on the users machine requires even less bandwidth while allowing the user to view things in whatever font they find easiest on their eyes. Including fonts on web sites has always been about designers getting their way. This is just more of the same.


Couldn't you say the same about images?

Besides, the OP clearly described the benefits in being able to adjust the font according to screen density. Using system fonts doesn't magically solve that issue.


> Couldn't you say the same about images?

I would, if the user's machine came with a preinstalled set of images that were a close match to the need. I don't think the web browser exposes the user's standard icon sets on the web, but it absolutely should.

> Besides, the OP clearly described the benefits in being able to adjust the font according to screen density. Using system fonts doesn't magically solve that issue.

Using any font made in the last 20 years solves that issue. Vector fonts scale to any screen density just fine.

On top of that, if you don't shove a webfont down the user's throat, a user can even pick their favorite font size and density to match their screen and viewing preferences.


Sure it does, let the client render the font based on what is best for the given user on the given device.

You're more or less describing DPI scaling, no?


Wow, what a cynical viewpoint for a very cool, useful technology that we've been begging for for quite a while. Maybe you're confusing the demo with practical applications, but this is a demo.


It's a shame such a negative, snarky comment got so many upvotes. You could express disinterest in this parametric font stuff without doing it in such a nasty way.


On the other hand, it allows for a clear, concise counterpoint to be upvoted and seen fairly quickly by those that shared that view, so they may see something to change their mind prior to expressing similar views.

Edit: To clarify, a counterpoint to the initial negative comment...


If you think that's complex, read the spec for the TrueType hinting VM sometime.


I found this justification particularly ridiculous: "Imagine shop windows that react according to the movements of passers-by."

Who would think this is compelling enough to put within the elevator pitch for the concept?


I think a better justification along the same lines would be: "Imagine shop windows that react according to the weather to always make themselves as easy to see through as possible, regardless of whether it's overcast or a sunny day."

Get your window in the desired dimensions, and let some automated protocol make sure it's as easy to see through as possible for all your potential customers.

Write your content, and let the setting in the OS or application automatically make sure it's as legible as possible regardless the size of screen, pixel density, and expected viewing distance.


That is really supposed to be a major selling point of a new font standard?

The point I was trying to get across is that the creators seem to have become intoxicated on their own fumes. That use is a crazy small niche, and if you really wanted to blow money on eye catching displays, there are any number of more creative and engaging ways to do so.

(I used to know a person who had the privilege of doing the windows for Barney's in LA, and another designer who did amazing creative interactive displays for the flagship Levi's store in Soho, London.)


> That use is a crazy small niche, and if you really wanted to blow money on eye catching displays, there are any number of more creative ways to do so.

I'm not sure if that's supposed to be a followup to the simile, but it sounds just as likely that you've missed the point I was trying to relay, so I'll elaborate.

The point is not to wow your customers, it's to make things clear. Different tactics work for that in different circumstances. A high density phone display, an older desktop display, and a 4K desktop display may all benefit from slightly different settings such as thickness in a font. Allowing the OS to optimize for functional legibility based on device and usage specifications is a good capability, in my opinion. That the demo allows you to see how the system works easily through dynamic changes does not mean that's the intended use.

As other have pointed out, just the ability to ship one font for your website and allow it to generate the correct variation based on responsive web design parameters is itself a win in the bandwidth it saves.


You don't see the point, but you think it delivers little value. You don't understand it, but you're going to assert as fact that it's unhelpful. I don't wish you luck with that perspective, it's ignorance followed promptly by pontificating, not merely contrary or skeptical.


"I don't see the point" is not the same as "I don't understand the point".


Pshaw, where's my raytraced font.


I also wasn't that impressed by the fact that I had to wait a few seconds for it to work. A font demo -especially a parametric font demo- really should be instant.


I guess they haven't heard of METAFONT.


The heavily animated demo is worrying. Animation is making the Web very unpleasant lately. It's extremely distracting when trying to consume text content. Please don't animate your fonts.


I really hope this doesn't become popular like Lato and Montserrat. This is horrible to me as a dyslexic. It's near unreadable and distracting with the constant size changes.


I think the purpose is so people can create their own variations of the available fonts, not to make animated text.


I really hope so. The web will be an unusable mess to me if fonts change size on scroll like in their demo page.


They're just demoing the parameters you can adjust to build a font. I assume they built the demo the way they did because it's more approachable for most than a long list of sliders with names that might not be meaningful to a lot of people.

That said, the way it works would certainly be off-putting to some. You may find their actual font builder app provides a better experience: https://app.prototypo.io/


The constantly changing box is almost impossible to read.


It's a good thing you would never do that for text you wanted someone to read, and would only do it to show what you can do with the font.


You would never do that. You probably wouldn't commit any of the other extremely common typographical/design sins out there either, and yet the web is awash in ugly design.


I'm collecting Chinese fonts for a project for a deep learning course.

Is there a tool where I can generate TTFs with different parameters to change the whole Unicode character set, not just ASCII?


The number of fonts that cover the whole Unicode character set is zero, as the Unicode character set grows faster than fonts are designed for obscure scripts.

The fonts that come closest are Google's Noto Sans (an Android-esque font that covers every script that's realistically in use), GNU Unifont (a monospaced raster font, great for multilingual coding), and Arial (bringing standardized mediocrity to the whole world).

These projects put a lot of work into finding one visual style that works across many different scripts. I doubt you will find anything that works with a parameterized range of visual styles across different scripts.

However, if you narrow your scope to fonts that just cover Chinese characters, I believe I've seen some projects that parameterize how to draw the strokes. I doubt the output will be neatly packaged in a TTF file.


I think the serif width / serif height axes are switched


I've spent so much time playing with the parameters that now letters don't make any sense to me.

edit: also it's absolutely gorgeous, well done


This site doesn't load at all on Firefox on OS X for me. Loading your experience stays on indefinitely.


Very cool. I'm seeing a future where fonts are stored as a series of transformations rather than a bunch of bitmaps/glyphs/vectors. A client could have specifications for adapting any font to make it more readable for their particular set of eyes while letting the font maintain a unique "look".


The vast majority of fonts are not stored as bitmaps. Most font formats store glyphs as vectors with a variety of additional information for pixel hinting, ligatures and probably a handful of other details that I can't even think of off the top of my head.


Right. They're even parameterized, in a sense, but pretty much the only parameter available on the client side is size, right? (Unless I misunderstand how boldface is applied these days.)


I think Prototypo demonstrates the parameterization is possible, but typically (for now) font weights are distinct fonts. Sometimes boldness or italics can be naively faked, but it's usually not pretty.


Right – I meant even traditional fonts could be seen as "parameterized" if you were squinting at them through a slightly foggy lens. :-)


Aside from, well, bitmap fonts, fonts aren't stored as bitmaps...


Page explodes for me into an unhappy tab, on OpenBSD/Chrome at least.


This is a great example of a terrible website.


Wow, this could be so GeoCities. Remember that a proportionately small, but numerically large, number of people really like blinking text. :-)



...is this a good thing? It seems so? Being able to fine-tune your fonts seems like it's better than using something static.


Does not load for me, CORS request failed


Imagine shop windows that react according to the movements of passers-by

I would prefer not to.


Not font related, but I'm imagining this -- http://hackaday.com/2010/10/15/window-curtain-moves-to-scree...


I have to admit this is oddly delightful




Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact

Search: