Comment by turnsout

It doesn't in this font? Possibly because of what they talk about where it optimistically gives as much space as possible to succeeding glyphs. You can try it on the page; the code sample boxes are editable. I see no jumping when I type "calming", their example word.

[append] Oh, I do see some jumping when I type "optimized". Honestly, it doesn't seem very jarring to me; the jumping is always right where the edit point is so the added or removed letter causes a much bigger jump.

Unrelated, but why is it that Font marketing pages specifically always have such cool-looking demoes? I love the navigation on that site, I might steal that for my own site

If this gets popular, I could see a text editor that lets you use a non-healing version of the font for any text that has been written in the viewport and then swaps it out as soon as you no longer looks at that block of text – or straight up uses a different font for my modifications compared to the committed code.

But even without anything like that, if it’s good for reading I like to use different fonts when reviewing and writing code to help with the context-switch, so I think this could be useful to me. And I guess people in regions where a single keystroke isn’t always a single character such as Korea, China, Japan and the arab world might be used to the jarring effect already?

Could the “jump” problem be improved with a subtle transition (200ms, 1s, etc) from one state to the other?

If the editor “repaints” commit mono on the letter-pair boundary, I could see that being a very jumpy UX — ie: the letter I just typed is moving by a few pixels. But if that repaint happens on the word boundary it might be less noticeable?

In either case, a transition could be helpful for commit mono and/or Monaspace. (But agreed with above comments that Monaspace is more subtle because it spreads the spacing over the entire word, so maybe the transition is not actually percievable or worth it). :)

Exactly my experience as well.

[flagged]

I'm curious: did the team consider applying the technique to letter pairs like Ty and TA that traditionally get kerned closer together in proportional fonts?

As far as I can tell from the demo, these pairs currently aren't affected by texture healing, and they look a little awkward in Radon especially.

Also, type mimi in the first code example: the two 'm's have different width...

I hate ligatures in code.

It sometimes breaks out of the grid, but there still is a grid. Things are sometimes not micro-aligned but still macro-aligned, and that matters (to me).

It only breaks the grid visually (and not by much); for layout purposes, which is what you depend on, the grid is still intact.

Why do we keep using fixed-width fonts? Because a lot of stuff has been written that depends on a columnar grid. Most notably, terminals are absolutely predicated on it and fundamentally cannot support any other mode of operation.

To begin with: visual alignment, ASCII art, diagrams using box-drawing characters, &c., both in code and in the output of diverse tools:

  def function_name(and_long_parameter_list,
                    so_that_it_wraps="like so"):
      pass


  ABC_D   = 1   # Explanation
  ABC_EFG = 2.0 # Another one
  ABC_HI  = 34  # A third one


  ┌────────┬─────────────┐
  │ Tables │ Using       │
  ┝━━━━━━━━┿━━━━━━━━━━━━━┥
  │ Cell   │ Box-drawing │
  │ Cello  │ characters  │
  │ Viola  │ ⋮           │
  │ Voilà  │             │
  └────────┴─────────────┘


  error: cannot find macro `behold` in this scope
   --> <anon>:1:13
    |
  1 | fn main() { behold!() }
    |             ^^^^^^


  $ ls -la
  total 43210
  drwxr-xr-x  17 root root     4096 Jan  1 23:45 .
  drwxr-xr-x  17 root root     4096 Jan  1 23:45 ..
  lrwxrwxrwx   1 root root        7 Feb 29  2020 bin -> usr/bin
  drwxr-xr-x   2 root root        0 Dec 31 23:59 boot
  ⋮

(I included the ⋮ in the box drawing table deliberately, because it demonstrates a weakness in the scheme: terminals and most monospacy text editors force stuff into the grid, just clipping or overflowing the cell if a glyph has to come from a fallback font, but most other things don’t, so you end up with visual alignment breaking if the fallback font used has different metrics. Also the whole East Asian Width thing and ucwidth and whatever is super messy. Your monospace font may or may not include the box-drawing characters, but it’s much more unlikely to include ⋮.)

Terminals are also built on columnar behaviour; there are escape codes for moving the cursor to such-and-such a line and column, for example, and things like a side-by-side split require columnar behaviour.

Text editors can go non-monospaced, but it breaks various content for the reasons discussed, and you’ll need monospace for any terminal because loads of stuff will break otherwise, so combined with inertia, even editors that support proportional fonts aren’t often used that way if they default to monospace.

(Me, I’d rather like to use a proportional font while editing, but I’m not moving off Vim for it, so I’ll probably never get it. But for presentation, I like to go at least partially proportional with the monospace font Triplicate’s Poly variant, which breaks strict monospaceness, widening characters like w/m/W/M and narrowing characters like i/j/l/1. As for what Monaspace’s texture healing, I like it most of the time, but am not sold on cases like some_function_w_, where the last two underscores are markedly shorter than the first and it feels unbalanced.)

To build on to sibling chrismorgan's excellent post, fixed-width fonts/ASCII art/Unicode drawing are a really elegant way to get 80% of what you'd ever want. Getting to 100% involves a full-on rendering system and markup which is 10x the work and complexity. To date, most people don't want that in their editor.

thats not what it does - it maintains monoSPACE while chaning the characters to not look the same width -- the best of both worlds, if anything

The issue with that is that it would reduce the space between pairs that need it (such as mb). Taken to an extreme, mm would run together into one letter.