+1

This provides a signal for what kind of font the author desires, regardless of whether or not it actually ends up being used. WebKit (and other browsers too?) will consider this kind of signal when we "fall off the end" of the font-family list and have to pick a font for the content but can't use any of the fonts in the specified list.

Yeah, Blink wishes to do this too.

I'm in favor of deleting that sentence.

I'm in favor of encouraging authors to use generics, and specifically motivating this (beyond general "it is good to do so") by saying this affects browser behavior when the end of the font stack is reached.

WebKit (and other browsers too?) will consider this kind of signal when we "fall off the end" of the font-family list and have to pick a font for the content but can't use any of the fonts in the specified list.

Can you elaborate on this? I don't understand what you mean - are you saying that if the author puts serif at the end of their stack, but they use a character not mapped by the font that WebKit assigns to serif, it'll still influence what additional fonts WebKit looks for to find a mapping for the character?

It was my understanding that generic families always matched (even if they had not usefully distinct character to provide), and therefore that it made no sense to put any fallback after a generic font family, as it would never be reached. However, It doesn't seem to actually be true, and it seems that when a generic font family does not provide a glyph for a particular unicode code point, browsers do allow fallback to font families specified after it in font-family.

I can think of a few possible variants of what the "Each generic font family must always map to at least one matched font face." might mean:

1. It means nothing, generic families behave like any other font family: they may be composites of multiple actual font faces in order to cover a broad unicode range, and when they don't match for a given character, we fallback to whatever is next in the specified font stack, and eventually to the system fallback if nothing matches.
2. It means that generic font families include the "fall off the end" fallback, and always match. Due to limitations on what's available on the system, not all components of a generic family will be usefully differentiated to match the requested style, and multiple generic families may share some font faces in their stack, but regardless, they always match, even if it is just to show a tofu glyph. Listing a font (generic or not) after a generic one in font-family never has any effect.
3. Generic families, like any other family, may or may not have glyphs for the characters at hand, and when they don't, fonts listed after them are used as fallbacks. They may possibly contain no glyph at all, depending on what's available on the system, but even in that case, if no specified font family prior to in in the font stack has a glyph for U+0020, the (empty) generic family still counts as the "first available font", and this impacts things like the line-height or the size of the font relative units.

I think variant 3 is not useful, and we should not do that.

I (and at least some other people as well, given the recent discussions around this topic) thought that variant 2 was the specified (and implemented behavior). It does not seem to be the implemented behavior. As far as specs go, they all seem somewhat ambiguous, and the wording has evolved between css2, fonts-3, and fonts-4. The older wordings (see css2 for example) seem to me to be more strongly calling for behavior 2 than the newer ones, but none of them is 100% clear cut.

Variant 1 is explicitly the one we said we wanted for system-ui and the like. For other generic families, it seems to be what browsers actually implement, and may be a good idea: I always assumed that writing @font-face { font-family: "micho fallback"; src: …; } html {font-family: serif, "mincho fallback"; } was not a thing I could do in order to supply a web-font based fallback for systems that didn't have a Mincho font, while leaving those that do use the system font. But it seems it's actually possible, and it is very useful, so I support behavior 1 for all generic font families.

Picking behavior 1 also makes questions like the one I raised in #4425 largely go away, as behavior 2 was the assumption underlying that question.

are you saying that if the author puts serif at the end of their stack, but they use a character not mapped by the font that WebKit assigns to serif, it'll still influence what additional fonts WebKit looks for to find a mapping for the character?

That question only makes sense if we go for behavior 1 (or 3), because with behavior 2, the fallback is part of the generic font family itself, not something that happens after it.

If we do go with behavior 1, in order to set author's expectations it would be useful to specify whether:

• the fallback must be independent of the specified font stack
• the fallback may be influenced by the last font in the specified font stack if it is generic
• the fallback may be influenced by the last generic font in the specified font stack, even if it is followed by non generics
• the fallback may be influenced by [... some other specific thing ...]
• the fallback may be influenced by the specified font stack in arbitrary ways up to the UA

WebKit (and other browsers too?) will consider this kind of signal when we "fall off the end" of the font-family list and have to pick a font for the content but can't use any of the fonts in the specified list.

Can you elaborate on this? I don't understand what you mean - are you saying that if the author puts serif at the end of their stack, but they use a character not mapped by the font that WebKit assigns to serif, it'll still influence what additional fonts WebKit looks for to find a mapping for the character?

Our impl is very similar to what @litherum explained; generic families (except system-ui) are mapped to single font, so it is not guaranteed to match. We even allow users to change the mapping.

Regardless generic families are used or not, we have a logic to run when all specified families are exhausted and still the glyph is missing. This logic doesn't have a good name, I think this is what @litherum called "fall off the end". I usually call it "system fallback" but this isn't probably a common name, I think you called it "last resort font" (in broad sense, not the "LastResort" font unicode.org provides), this is probably more common.

A discussion we had before was that, during this "fall off the end or system fallback or last resort font in broad sense" process, we may find multiple candidates, and the idea was that generic families in the font-family property can provide a hint to which candidates we want to choose. font-weight or font-style can also provide more hints.

Back to the original discussion, I don't have strong opinion on whether the spec should encourage authors to use generic families or not, I'm fine with it or without it, but I agree with @litherum that more hints from authors could improve our font choice.

/cc @drott

@tabatkins

are you saying that if the author puts serif at the end of their stack, but they use a character not mapped by the font that WebKit assigns to serif, it'll still influence what additional fonts WebKit looks for to find a mapping for the character?

Yes, in some situations.

@frivoal What's the difference between option 1 and 3? They sound the same to me.

Let's say your font stack is: p {font-family: fantasy, Helvetica; } on a system which has chosen not to map fantasy to anything (or equivalently, to a conceptual font with no glyphs in it).
You try to display <p>hello world</p> with it. If you don't like the idea of mapping fantasy to nothing, replace with fangsong with no loss of generality.

If we've ruled out option 2 (which disallows falling back from a generic family and requires that it maps to something for all glyphs), the logical thing (option 1) to do is to say that since fantasy doesn't match, then not only is helvetica (assuming it's actually available) the font that's actually used to render the text, but also since fantasy has no glyphs, Helvetica is also the first available font, and therefore its metrics are used to determine the line-height, ch unit, ex unit, etc. I support this.

"option 3" proposes one possible way to interpret the sentence that you propose to delete (about generic families always having to match), which would be to say that fantasy is in this case the first available font, and that the various measurments discussed above are based on it. That doesn't really say what they'd be, given that it's a conceptual font with no glyphs (and no obvious metrics) in it, but at least it wouldn't be based on helvetica. I think this is far fetched and undesirable, but if that sentence is there and means something I can't think of anything else than "option 2" or this "option 3".

Option 1 seems useful. Option 2 less so, but still sane. Option 3 seems just bad/silly to me. If anyone has a different understanding of what that sentence means, it'd be good to hear it before we remove it.

Oh, I think I understand. You're proving that my statement:

The difference between fantasy mapping to a font that supports 0 characters, and fantasy not mapping to any font, is untestable.

is false.

I believe you are correct, and my statement is false. Even if fantasy supports 0 characters, its presence is still observable, because it still will have metrics and therefore affect line height. Cool.

I'd like to propose option 1.

Agree, option 1 seems best all around.

Looping back to @frivoal's earlier question:

If we do go with behavior 1, in order to set author's expectations it would be useful to specify whether:

• the fallback must be independent of the specified font stack
• the fallback may be influenced by the last font in the specified font stack if it is generic
• the fallback may be influenced by the last generic font in the specified font stack, even if it is followed by non generics
• the fallback may be influenced by [... some other specific thing ...]
• the fallback may be influenced by the specified font stack in arbitrary ways up to the UA

Any opinions? @koji seems to be suggesting it's the last one (influenced in arbitrary UA-specific ways) in Chrome.

I assume that, in those questions, "fallback" means "the font that is used when the browser falls off the end of the font-family list".

In that case, I don't see any benefit to specifying how this font is picked. If the author wants the browser to pick a particular font, they should just name the font in the font-family list.

I do see benefit in leaving it unspecified because:

• We use platform (Core Text) APIs to do it, and these APIs were not created with the web, or any web concepts, in mind
• Browsers should be free to gather insight from any/all signals that the author has already provided in order to make the best pick possible.

(I believe I'm agreeing with @kojiishi)

Cool, that's a useful answer. I think it would still be useful to give authors the advice that using a generic font-family can be used in that resolution, so they should use one, but other than that leaving it up to the UA sounds great to me.

Re Florian's suggested list of possible heuristics:

If the generic keywords match as regular fonts (and may not match all characters), that means that font-family: serif, monospace; is valid. So any answer to the question about how generics affect after-the-stack fallbacks needs to consider this case. I'd read that declaration as a sign that the author prefers a proportional serif font, so it should be the first generic in the list that should influence additional generics, not the last one.

It would also be nice if UAs other than Firefox offered a built-in way for multilingual users to select composite families for how the keywords apply to different scripts.

But that said: I'm OK leaving this vague and UA dependent. UAs should try to find a font to render each glyph in the text and they may use the information in the font stack to help select a harmonious font if there are multiple options available.

That's consistent with the current text for the font-matching algorithm, but extra notes for authors sound reasonable.

So there would be the following changes to the spec text:

(1) change the authoring guidance for font-family.

The current text is:

Authors are encouraged to append a generic font family as a last alternative for improved robustness.

New text would be something like:

Authors are encouraged to include a generic font family in the list, for improved robustness.

Note: A generic font family is not guaranteed to match every characters in every script.
However, generic keywords used in the font stack may affect additional fallback fonts selected by the user agent according to the [link]font-matching algorithm.
Alternatively, authors may choose to provide a web font for fallback for the generic font family.
This font would only be downloaded if the user agent's font for that generic family does not include the necessary characters for the text being rendered.

(2) Remove the requirement on having generic fonts match something.

Current text:

Each generic font family must always map to at least one matched font face. However, a single generic font family may be a composite face combining different typefaces…

User agents should provide reasonable default choices for the generic font families, that express the characteristics of each family as well as possible, within the limits allowed by the underlying technology. User agents are encouraged to allow users to select alternative faces for the generic font families.

Replacement (borrowing some of the text from the new "standard font families" section):

Generic font family keywords map to specific installed or system fonts based on their characteristics.
They may not all exist on every platform or operating system, and are not required to map to a concrete font face.
A single generic font family may be a composite face combining different typefaces…

Any default choices provided by a user agents for the generic font families should express the characteristics of each family as well as possible, within the limits allowed by the underlying technology. User agents are encouraged to allow users to select alternative faces for the generic font families.

(3) Remove the distinction between generics and the new "standard" families

That means including the new keywords within the definition of <generic-font-family> & probably collapsing those two sections.

I agree with option 1.

which would be to say that fantasy is in this case the first available font, and that the various measurments discussed above are based on it. That doesn't really say what they'd be, given that it's a conceptual font with no glyphs (and no obvious metrics) in it

A very good reason to not pick option 3.

My mental model is that the font stack consists of the following items, in order

1. Whatever real font families have been specified
2. Whatever generic family has been specified, if there is one
3. Some sort of unspecified and implementation-specific fallback font, which may be composite, and is going for widest codepoint coverage. Details of this are not exposed in CSS (but the point about first available font and metrics makes me wonder
4. Often, and unspecified and implementation-specific last-resort fallback. This may be a special font (like the one with the hex code as the glyph) or just a font with a missing-glyph.

Thus, I would not have expected any font(s0 specified after the first generic family to be used. I wouldn't have expected them to cause an error, just that they would not be used.

@Amelia, I like all your suggested wording changes.

It sounds like there's general agreement on this. I'll Agenda+ it to try to get a resolution.

Thus, I would not have expected any font(s) specified after the first generic family to be used. I wouldn't have expected them to cause an error, just that they would not be used.

I don't understand this. Unless generic font families are required to produce some glyph for every code point (in other words option 2, which you're not advocating for), then falling through a generic font family to whatever is after it, be it another generic, or a "real" font family, seems to be a logical necessity.

Unless generic font families are required to produce some glyph for every code point (in other words option 2, which you're not advocating for),

correct

then falling through a generic font family to whatever is after it,

which is step 3 in my mental model, listed above. If the generic (step 2) fails to produce a glyph, you are onto steps 3 and then 4.

@svgeesus Not sure I understand. What happens if the author specified font-family: serif, Helvetica instead of font-family: Helvetica, serif?

The difference is that @frivoal says

falling through a generic font family to whatever is after it, be it another generic, or a "real" font family

so Helvetica would be used

while I am thinking that if serif fails, we are on to step 3 listed above

so the implementation-specific, wide-coverage fallback font would be used.

Do we need to add wording about which generic, if multiple are listed, influence any implementation specific system fallback?

@jfkthame

Presumably the first generic mentioned should be the one to influence fallback after we fall off the end of the font-family list.

@svgeesus wrote:

My mental model is that the font stack consists of the following items, in order

1. Whatever real font families have been specified

2. Whatever generic family has been specified, if there is one

3. Some sort of unspecified and implementation-specific fallback font, which may be composite, and is going for widest codepoint coverage. Details of this are not exposed in CSS (but the point about first available font and metrics makes me wonder

4. Often, and unspecified and implementation-specific last-resort fallback. This may be a special font (like the one with the hex code as the glyph) or just a font with a missing-glyph.

Thus, I would not have expected any font(s0 specified after the first generic family to be used. I wouldn't have expected them to cause an error, just that they would not be used.

FWIW, I don't think I agree with this model. If the author specifies intermingled real font families and generic families in the font-family list, we try each of them in the order listed, regardless of which kind of family name they are.

So it's entirely legitimate (although rarely useful, I expect) to say something like

font-family: serif, "My Serif Font", sans-serif;

and the expectation is that we'll first try whatever font (or set of fonts) the UA provides for serif; but if a character is not available in that (those) font(s), we next try the specifically-named "My Serif Font" (perhaps it's a webfont that provides rare characters, but we don't want to download it at all if the serif generic has adequate coverage); and if that also fails, try the UA's sans-serif as well.

As I said, that was my mental model (ie my interpretation of the spec). I agree that the other interpretation is also plausible.

I'm fine with clarifying the spec in whichever way maximizes interop.

The CSS Working Group just discussed [css-fonts] Don't require browsers to always match every generic font family to a concrete font family, and agreed to the following:

• RESOLVED: serif, sanserif, and monospace must match, all other generics should match if appropriate.

Removing the needs edits as they have been made ages ago