Removing Digraphs

Revision history

0.1. R0 September 2026

Original version of the paper.

1. Introduction

Digraphs are a complicated solution to a very old problem, which cause more problems than they solve in a modern environment. Digraphs also severely limit the design space of C++, although as we have seen with [P2996] we are already fine with special-casing our way out of this pickle.

This however leads to a rather unfortunate situation. If you need to use a source encoding that requires use of digraphs, you cannot use all of C++26 directly, resulting in a fragmented and needlessly complex language. Some parts you can use if you require certain digraphs, some you don't.

Since we are most likely going to continue seeing similar problems, this paper proposes to remove the digraphs <%, %>, <:, :>, %: and %:%: from the language entirely. This does not affect the alternative keyword tokens (and, or, etc.).

2. History

The GCC documentation notes:

Apparently in the 1990s some computer systems had trouble inputting these characters, or trouble displaying them. These digraphs almost never appear in C programs nowadays, but we mention them for completeness.

What this refers to is systems that require the source encoding to be something that does not have the characters #, [, ], { or }. In such cases, the corresponding digraphs are required to write those characters in source code.

Such encodings are rather uncommon nowadays, but they do exist.

Historically digraphs were introduced because of [ISO 646], which includes several national variants that do not have square brackets or curly braces. For example, the [ISO-IR-021] (also known as DIN 66003) variant used in Germany replaces [ with Ä, ] with Ü, { with ä and } with ü.

Keld Simonsen pointed out this problem with some ISO 646 variants including the Danish [ISO-646-DK] in a 1984 usenet post. To address this issue, he suggested the following digraphs as a solution ([Simonsen, 1984]):

(. → {

). → }

(* → [

)* → ]

!. → |

!* → \

Even then Martin Minow argued against such a solution, as it was a vanishing problem even at the time.

To quote [Minow, 1984]:

There isn't any really good solution -- it is highly unlikely that the C standardization committee will remove these characters from the language. While most of them can be replaced by suitable #defines, several cannot, notably backslash. The only short-term solution would be for the parties affected to write NRC-specific pre-processors.

In the long term, however, the problem will go away as people move to an 8-bit character set such as Dec-Multinational or the pending ISO standard that is almost identical to it.

That "pending ISO standard" Minow mentions later became [ISO/IEC 8859]. The relevant part of ISO/IEC 8859 for the Danish language is ISO/IEC 8859-1, which was first published in March 1985 as [ECMA-94].

ECMA-94 fully solves the described issue by using the 8th bit in an 8-bit byte to allow for another 96 printable characters, which includes everything that was potentially missing in some ISO 646 variants.

Interestingly, [ISO-IR-027] even lacks :, making four of the digraphs we eventually ended up with unusable. While it is explicitly based on ISO 646, ISO-IR-027 is not a true variant - some of the added letters are mapped to code points which are invariant in ISO 646. However, this shows that even for its original purpose, digraphs are more of a band-aid than a real solution.

2.1. Timeline

So, how did we get here? Unfortunately not a lot of documents from the early days survived. However, the publicly available X3J11, X3J16, WG14 and WG21 documents allow reconstructing roughly this timeline (please reach out if you have corrections or additional information!):

3. Design Space

3.1. Splicers

Splicers from [P2996] were accepted for C++26 with the proposed syntax [: expr :]. However, we are not allowed to use digraphs to spell this as <:: expr ::>.

While that seems to be in direct contradiction of the guarantees we're given in [lex.digraph] paragraph 2

In all respects of the language, each alternative token behaves the same, respectively, as its primary token, except for its spelling.

it actually isn't. The tokens [: and :] are distinct preprocessing tokens rather than being composed from [ and : (or : and ] respectively). Therefore it doesn't matter whether <: is a valid alternative spelling for [ - the splicer syntax does not contain [ tokens.

Unfortunately that doesn't exactly help if your source encoding does not have square brackets. In such cases you cannot use this language feature directly - you'd have to find some workaround (such as inventing some arbitrary replacement sequence that is expanded to [: during or after transcoding).

3.2. Interpolated string literals

The design problems stemming from digraphs do not end there. In some of the recent discussions around the proposed string interpolation feature ([P3412], [P3951]) some interesting code was brought up. Consider the following:

In an interpolated string literal, the interpolated expression field is wrapped in curly braces. To parse an interpolated string literal you must therefore switch between regular string literal parsing and expression parsing as soon as you see a field introducer ({).

However, once you parse the interpolated expression things get a little strange. %> is an alternative spelling of }. We haven't yet returned back to literal parsing, so this would yield the correct token. So, should we be able to signify the end of the interpolation field with %>?

Since allowing anything but literal } to terminate a interpolation field seems extremely surprising and will most likely not match user expectations, we are once again looking for a workaround because of digraphs.

To make matters worse, there is another ambiguity. Consider an interpolated literal:

In this example, is :> the digraph for ] or is it the start of the format specifiers of that field? In a non-interpolated format literal, "{:>5}" would be a valid format specifier.

4. Affected encodings

A common way to support arbitrary source encodings is by normalizing the source code through iconv. Therefore, we are typically limited by what iconv supports. Note that iconv also supports several translation character sets that are irrelevant for our purposes. The codec names in this chapter are the primary/canonical names used by iconv rather than necessarily actual codec names.

To figure out whether a particular encoding needs digraphs, we can check whether iconv fails when trying to convert the characters #, [, ], { or } to that encoding. If it does, then that encoding requires digraphs.

In a similar fashion, other characters that have meaning in C++ can be checked. For example, if an encoding does not support :, several digraphs are not usable either. As mentioned before, one such encoding is LATIN-GREEK-1 ([ISO-IR-027]).

On a somewhat recent Arch Linux system, this gives us the following support matrix: View on Google Sheets

Out of 278 considered encodings, the following 39 codecs require digraphs, but are also missing the \ character:

• EBCDIC-FI-SE
• EBCDIC-FR
• EBCDIC-IT
• EBCDIC-PT
• ISO 646 ES
• GREEK7-OLD
• IBM423
• IBM4517
• ISO 646 IT
• NF_Z_62-010
• NF_Z_62-010_1973
• NS_4551-2
• CSA_Z243.4-1985-1
• CSA_Z243.4-1985-2
• DIN_66003
• DS_2089
• EBCDIC-AT-DE
• EBCDIC-CA-FR
• EBCDIC-IS-FRISS
• ISO 646 ES2
• IBM16804
• IBM274
• IBM281
• IBM290
• IBM420
• IBM4899
• IBM803
• ISO_5427
• JIS_C6229-1984-B
• JUS_I.B1.002
• MSZ_7795.3
• NATS-SEFI
• NC_NC00-10
• NS_4551-1
• ISO 646 PT
• ISO 646 PT2
• SEN_850200_B
• SEN_850200_C
• T.61-8BIT

The following 9 codecs require digraphs and are otherwise fully usable:

• BS_4730
• EBCDIC-ES
• EBCDIC-ES-S
• IBM275
• LATIN-GREEK
• EBCDIC-DK-NO
• EBCDIC-UK
• EBCDIC-US
• IBM880

We can narrow that list down even further. The most interesting digraph is %:, since it can be used to spell #pragma. Some compilers already have pragmas to specify the source encoding - for example, the IBM z/OS XL compilers support #pragma filetag (documentation) for this purpose.

If we only have to retain a digraph for #, this narrows our list of affected codecs down to the following 17 codecs:

• EBCDIC-FI-SE
• EBCDIC-FR
• EBCDIC-IT
• EBCDIC-PT
• ISO 646 ES
• GREEK7-OLD
• IBM423
• IBM4517
• ISO 646 IT
• NF_Z_62-010
• NF_Z_62-010_1973
• NS_4551-2
• BS_4730
• EBCDIC-ES
• EBCDIC-ES-S
• IBM275
• LATIN-GREEK

While this isn't a huge list, it proves the point that there are still encodings that require digraphs. However, the question remains whether there is any actual use of any of these in practice.

Fortunately those are all rather obscure encodings by today's standards.

5. Usage Analysis

So, are people still using digraphs? Are they targeting somewhat modern C++ versions?

A GitHub code search can unfortunately not answer this question for us, since a lot of use might be in code that isn't publicly available. However, it helps getting a rough idea of the situation and how people use digraphs.

Surprisingly, we can actually find quite a lot of code that uses digraphs. For example %:include is included in 850 files!

However, if you take a closer look at those results, you'll quickly notice that aside from a bunch of false positives most of them fall into one of three categories:

1. Compiler test code and other lexer test code
2. Demo code, examples and exercises
3. Inconsistent use of digraphs and the tokens they replace, possibly for obfuscation purposes

Note how this list is missing "actual production code that uses digraphs for anything other than tests".

For the other digraphs the situation is similar. %:%: yields 216 results, most of which are false positives and/or lexer code. %:if yields 22 results, all of which are university assignments, inconsistent or false positives.

For the promising %:pragma we get 107 results, most if not all of which are inconsistent. For %:pragma filetag we get 0 results (even for the trigraph spelling we at least get 106 results).

For the digraphs <:, :>, <% and %> a code search yields a lot more results, but they seem to be almost exclusively false positives - usually because they appear in string literals or comments. Furthermore, <: yields especially bad results due to qualified template arguments being spelled as templ<::arg> (without space after <).

6. Compatibility

At the time of writing almost all major compilers still support trigraphs as an extension. For instance:

• GCC has -trigraphs
• Clang has -ftrigraphs
• MSVC has /Zc:trigraphs
• EDG has --trigraphs

Some compilers already support disabling digraph support altogether. For instance:

• Clang has -fno-digraphs
• EDG has --no_alternative_tokens (which also disables the alternative operators and, or etc.)
• MSVC's documentation of compiler warning C4628 and C4629 suggests using digraphs is not supported with /Ze and will cause a warning with /Za, however Compiler Explorer does not verify that

7. Alternatives to full digraph removal

As mentioned before, compilers that have pragmas such as #pragma filetag only really need some way of spelling #.

In [WG14/N3116] Rajan Bhakta confirms this:

Theoretically the # is the only one we need, to engage the pragma.

While we could retain or reintroduce some standard way of spelling this, there is another alternative. MSVC, GCC and Clang all explicitly support the _Pragma("...") spelling. With this spelling no use of # is required whatsoever.

Either way, this gives us some additional options that need to be considered.

7.1. Partially remove digraphs

Instead of removing all digraphs, we could remove all digraphs except for %: (and possibly %:%:). This would allow users to spell #pragma as %:pragma.

This option seems feasible since %: is relatively harmless - it does not conflict with any other language features in the way <: or %> do and we could still get rid of those.

However, it's not clear whether a tiny amount of actual usage of this feature warrants keeping it around for another couple of decades, especially given that there are alternatives.

Furthermore, the usage analysis in §5. Usage Analysis shows that being able to spell %:pragma filetag is largely a theoretical concern as compilers still have opt-in support for trigraphs.

7.2. Partially reintroduce trigraphs

Since most if not all code that actually uses #pragma filetag with an encoding that cannot represent # uses the trigraph spelling rather than the digraph spelling, we could also reintroduce just the ??= trigraph. This would allow users to once again spell #pragma filetag as ??=pragma filetag.

As with the other options, this mostly is up to whether the C and C++ committees feel like supporting such encodings is worth the effort.

It also seems rather unlikely that either language is going to reuse ??= for any other purposes anytime soon, meaning that this is a conforming extension either way. If compilers want to keep supporting this, they absolutely can.

7.3. Deprecate digraphs first

It seems highly unlikely that deprecation is actually meaningful in this case.

Users that still rely on encodings that require digraphs are likely not going to be able to update their code regardless of deprecation warnings or not. This would just delay removal and is not pursued at this point.

8. Wording

Make the following changes to the C++ Working Draft. All wording is relative to [N5054], the latest draft at the time of writing.

Lexical conventions [lex]

Preprocessing tokens [lex.pptoken]

Operators and punctuators [lex.operators]

Modify as indicated.

Alternative tokens [lex.digraphalt]

Rename to [lex.alt] and update all references accordingly.

Modify Table 3

Remove footnote 10

Preprocessing directives [cpp]

Argument substitution [cpp.subst]

Modify Example 1 as indicated.

Annex C (informative) [diff]

C++ and ISO C++ 2026 [diff.cpp26]

[lex] lexical conventions [diff.cpp26.lex]

Add new entry

9. Acknowledgements

Thanks to Corentin Jabot and Hubert Tong for several rather illuminating discussions on the topic.

Thanks to Jan Schultke for the markup language and document generator used for this paper and thanks to all the awesome people who gave feedback on this proposal.

10. References