Bracket Ballet, Solved: A UK ISO Symbol Layer for People Who Write Code

UK ISO keyboards are designed for people who write sentences, not for people who write const parser = new Map<string, Array<number>>(). The letters are fine. The punctuation is where the stretching begins. Braces, pipes, tildes and hash marks all live just far enough away to make a long debugging session feel like a mild gym class.

The usual answer is to learn a US layout and pretend the pound sign never existed. That works for some people, but it creates its own friction: UK keycaps no longer match, shortcuts move, and you spend a week typing # into places where £ should be. A better answer, for many UK programmers, is to keep the ISO-UK base and build a deliberate symbol layer around AltGr.

This is not about inventing a perfect layout. It is about reducing the small, repeated reaches that make code feel more tiring than it should.

Start with the friction, not the keymap

Before you open QMK Configurator or VIA, spend a day noticing what actually annoys you. For most UK coders the usual suspects are:

• { and } on shifted bracket keys, which pull the right hand away from the home row.
• | on a shifted backslash key, often followed by a stretch for another symbol.
• ~ hiding behind a shifted hash key.
• # itself sitting on AltGr+3 on many UK Windows layouts, which is fine until you need it ten times in a row.
• @ on Shift+apostrophe, which is not terrible but never quite feels natural.

Write these down. Do not try to fix everything at once. The goal of the first pass is a layer that makes the worst five chords less awful, not a layer that wins a design award.

The shape of a good symbol layer

A programmer’s AltGr layer should follow a few simple rules.

First, keep the base layer intact. You still want normal UK punctuation for email, prose and the occasional passive-aggressive note to your landlord. The symbol layer is an addition, not a replacement.

Second, pair opening and closing symbols near each other. If ( and ) live under adjacent fingers, your brain learns the pair as a unit. The same goes for [ and ], and { and }. This is more useful than putting every symbol in strict ASCII order.

Third, avoid making the pinky do everything. AltGr is often pressed with the right thumb or right Alt, so the opposite hand should do most of the symbol work. If every symbol needs a left-pinky stretch while the right thumb holds AltGr, you have simply moved the problem.

Fourth, preserve the AltGr combinations you actually use outside code. The euro sign on AltGr+4 is worth keeping. If you use AltGr+3 for # on the base layer, make sure the layer does not silently break it.

A workable AltGr map

Here is a starting point, not a commandment. It uses the right Alt key as a momentary layer key in QMK, with the usual UK ISO physical layout underneath.

Chord	Symbol	Why it sits there
AltGr + E	[	Left hand, near the home position
AltGr + R	]	Closes the pair without a reach
AltGr + D	(	Strong finger, easy to repeat
AltGr + F	)	Natural partner to D
AltGr + J	{	Right index, close to home
AltGr + K	}	Closes the brace pair
AltGr + U	<	Useful for generics and comparisons
AltGr + I	>	Pairs with U
AltGr + S	#	Keeps hash off the number row
AltGr + W	~	Tilde without the shifted-hash hunt
AltGr + A	`	`
AltGr + semicolon	@	Familiar enough for UK muscle memory
AltGr + apostrophe	`	Useful for shell and markdown
AltGr + G	\	Keeps backslash available for escapes

The exact letters are less important than the logic. You want the symbols you type most often to be reachable without moving your whole hand. You also want the layer to feel boring after a week. If it still feels like a puzzle, simplify it.

QMK, VIA and the layer-tap question

In QMK, the cleanest starting point is a dedicated symbol layer and a layer-tap key on the right Alt position. Something like LT(_SYM, KC_RALT) gives you a tap for AltGr and a hold for symbols. It is compact and works well for many people.

It is not magic. Layer-tap keys can introduce timing quirks, especially if you use AltGr combos in applications that expect a plain modifier. Test your common shortcuts before you commit. If you find yourself misfiring, use a plain momentary layer key on a spare key instead, or keep a normal AltGr key somewhere on the symbol layer. The best keymap is the one that does not make you think about the keymap.

VIA is friendlier for quick experiments. You can assign a momentary layer to a spare key and start mapping symbols in an afternoon. VIA will not give you every QMK trick, but it is excellent for testing whether the idea works before you disappear into a keymap.c file. If you later move to QMK, you can keep the same physical logic and add tuning.

One warning for dual-booters: macOS treats Option differently from Windows AltGr. Do not assume a layer that feels perfect in Windows will behave identically on a Mac. Test both if you switch regularly, and keep a note of which OS needs its own tweak.

Legends, keycaps and the UK ISO problem

UK ISO keycap sets are less common than ANSI sets, and AltGr legends are rarer still. Many base kits include the physical ISO-UK keys but leave the symbol layer blank. That is not a disaster. Blank or front-printed legends are perfectly usable, and they force you to learn the layer rather than read it.

If you want visible legends, look for an ISO-UK base kit plus an international or symbol add-on. Custom dye-sub is another route, especially if you only need a handful of keys. Relegendable keycaps work, but they can make a nice board look like a supermarket till. A small label on the side of a key is sometimes the most honest solution.

Profile matters too. A tall sculpted profile can make front legends hard to read, while a uniform profile such as DSA is more forgiving. Cherry profile looks great but gives you less room for creative labelling. Choose the compromise you can live with.

Test it against real work

A symbol layer is not finished when it looks good in a configurator. It is finished when it survives a normal Tuesday. Try three small tasks:

1. Write a shell one-liner with a pipe, a redirect and a variable: grep -E '^(foo|bar)$' file.txt > out.txt.
2. Write a TypeScript type with generics and an optional field: type User = { id: string; name?: string };.
3. Write a short regex and a markdown code span without looking at the keyboard.

Then make a friction log. A plain text file is enough. Note the symbol, the chord you used, whether it felt awkward, and what you want to try instead. Review it once a week. Change one key at a time. Re-run the same three tasks. Commit the keymap to git so you can go back when an experiment makes things worse.

The important rule is simple: do not rewrite your keymap in the middle of a debugging session. That is how a small annoyance becomes a lost evening. Log it, finish the bug, then change the layer afterwards.

The small repeatable method

A good UK programmer’s layer is not a one-off work of art. It is a small maintenance habit. Log the friction. Change one thing. Test the same snippets. Live with it for a week. Keep the version you liked.

Do that four or five times and you will end up with a layer that fits your hands and your work. The brackets will still be brackets, the pipes will still be pipes, and the AltGr key will finally earn its place on a UK ISO board.