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.
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.
Very nice for coding.
Pretty sure you can do all the transformations indicated on the page in 'native' metafont.
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).
I'm claiming that the scope of parameterized fonts is limited, in an analogous way to linguistics not trying to explain poetry.
If not, this looks like some bad trademark abuse, as everyone here seems to think this is somehow done by Google :(
Beyond that, there doesn't seem to be a connection.
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 , 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"  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  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  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 .
: https://s3-us-west-2.amazonaws.com/visiblelanguage/pdf/16.4/... / https://www.cs.indiana.edu/pub/techreports/TR136.pdf
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.
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.
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.
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.
On the other hand, I can't imagine seeing myself going "I need something with the Times New Roman curvature, but thicker serifs..."
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...
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.
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.
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. 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 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.
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 for an idea of how many trillions of fonts served that this will affect.
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.
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.
You're more or less describing DPI scaling, no?
Edit: To clarify, a counterpoint to the initial negative comment...
Who would think this is compelling enough to put within the elevator pitch for the concept?
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.
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.)
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.
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/
Is there a tool where I can generate TTFs with different parameters to change the whole Unicode character set, not just ASCII?
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.
edit: also it's absolutely gorgeous, well done
I would prefer not to.