Anyone using proportional fonts for coding?

I've used Input Sans for years. I was expecting to have to deal with alignment issues but in my Java codebase there were almost none. (YMMV depending on language and coding style.) The only alignment we use is with leading spaces only, so everything still aligns as expected. The readability is great and I can fit substantially more characters horizontally than I could with a fixed-width font.

It definitely felt weird at first, like I was reading code that somebody had pasted into Microsoft Word. But that passed and now it's all upside.

I screen-share my IDE from time to time and I've never had anyone comment on it.

I've tried a few times over the years but it never sticks. Proportional fonts make scanning for character-level differences slower and most don't distinguish important characters strongly enough (e.g. parens and brackets taking less space than alphanumerics). I'll echo others' comments on alignment too.

To my eye, they also just make code look… I don't know, messy somehow? Especially with serifs it looks like a tractor trailer wrecked and spilled its payload of characters all over the place.

Try IAWritter DuoSpace: it’s a great mix between fixed width and proportional: https://ia.net/topics/in-search-of-the-perfect-writing-font

I’ve used proportional fonts for more than a decade now. Since auto formatters disallow ascii art or custom alignment anyways, I’m honestly not missing out on anything, and just get to enjoy kerning in my code. I use whatever sans serif is used most on my platform (ATM it’s google sans), using a serif want would probably annoy me a lot.

Oh, what we are really missing are code-oriented ligatures, like -> or ==>. Sad, but I find fixed width so bothering that I’m not willing to try the fixed width fonts that offer such ligatures.

I made my own proportional font Variable.ttf and refined it for over a decade. I am using it daily. Over many iterations I refined space width and each important coding character's shape and size. Added some ligatures in the last few years. It's very good I consider it a work of art, and I cannot think about going back to fixed fonts. Only me and my friend use it.

https://github.com/exebook/variable

I propose we start the revolution with comment blocks.

https://developer.apple.com/library/archive/documentation/Xc...

I know ThinkPascal back in the day used a proportional font, but I think I remember MPW using mono. My CanonCat uses a proportional font when you write FORTH programs for it.

I used Input Sans for some time as my coding font. Most proportional fonts have a small which makes it difficult to figure out alignment in code. Input Sans was the only font I found that was good in this regard.

I use vim keybinds and movement was too unpredictable to keep using as my main font. Now I'm back to a monospaced font.

If you use VS Code, the search results and file explorer text use a proportional font because you cannot change it. Is a long standing bug and is annoying.

Doesn't play nicely with aligned material.

Parallel definitions lined up for readability.

  #define AF_UNSPEC       PF_UNSPEC
  #define AF_LOCAL        PF_LOCAL
  #define AF_UNIX         PF_UNIX
  #define AF_FILE         PF_FILE
  #define AF_INET         PF_INET
  #define AF_AX25         PF_AX25
  #define AF_IPX          PF_IPX
  #define AF_APPLETALK    PF_APPLETALK
  #define AF_NETROM       PF_NETROM
  #define AF_BRIDGE       PF_BRIDGE
  #define AF_ATMPVC       PF_ATMPVC
  #define AF_X25          PF_X25

Similarly in structure definitions where there are line comments:

C preprocessor continuation backslashes.

  /* From some MD5 code */

  #define FF(a, b, c, d, x, s, ac) {                      \
    (a) += F((b), (c), (d)) + (x) + convert(u32_t, ac);   \
    (a) = ROTATE_LEFT ((a), (s));                         \
    (a) += (b);                                           \
  }

  #define GG(a, b, c, d, x, s, ac) {                      \
    (a) += G((b), (c), (d)) + (x) + convert(u32_t, ac);   \
    (a) = ROTATE_LEFT ((a), (s));                         \
    (a) += (b);                                           \
  }

Alignment in parallel definitions.

  struct netent {
    char *n_name;                 // Official name of network.
    char **n_aliases;             // Alias list.
    int n_addrtype;               // Net address type.
    uint32_t n_net;               // Network number.
  };

No, tabs will not fix this issue, unless everyone agrees on exactly the same font, and the same tab stops, in the same editor. What looks vertically aligned in your editor looks staggered in someone else's.

This kind of thing is not unheard of:m

  struct netent {
    char      *n_name;              // Official name of network.
    char     **n_aliases;           // Alias list.
    int        n_addrtype;          // Net address type.
    uint32_t   n_net;               // Network number.
  };

We have the identifiers of the declarators vertically lined up, but the pointer derivators hang to the left. Tabs will just not do this.

Proportional font coders are in the lunatic fringe.

All else being equal, do not hire.

My dad does, which used to drive me nuts when I wanted to help him out when I was in college. These days I think it sounds like a good idea but I haven’t tried it yet.

I bet it would traumatize some of my VIM diehard teammates.

Not exactly proportional, but has the legibility of proportional while actually being monospaced -- Comic Mono [0] is a monospaced font based on Comic Sans.

[0] https://dtinth.github.io/comic-mono-font/

I tried using proportional fonts for a while, but I couldn't get used to them. For me, the make it more difficult to read (and write) the source code because I didn't have predictable landmarks to follow anymore.

Also, they make creating diagrams and aligning things essentially impossible.

If only there were a modern code editor that supported variable-width tabs that would maintain vertical alignment with variable-width fonts...

I use them from time to time. I'm not working on large codebases with collaborators, just my dotfiles and CSS and stuff. If I was auditing other people's code I don't think I'd want proportional fonts, simply because in code every character matters.

This should be workable and reasonable if you use tabs to indent and don't do any alignment. Imho that's good practice but there's always somebody stubborn.

Yes, I like Iosevka Aile a lot. And it's free! So worth a try.

https://chris.printf.net/iosevka-aile.png

https://typeof.net/Iosevka/

stroustrup switched to using a proportional font in TC++PL 3rd ed. i really didn't like it, but i know quite a few people did. all comes down to taste as far as rendering is concerned, i suppose. but the program text must be able to be rendered in either a fixed or a proportional font, and look sensible in either. and that is not so easy.

Broadly, it just seems weird that this appears to be such a difficult problem TODAY.

As in "Just tell the AI what code you want to write and the language and it will just magically do it for you" is like, sure, no problem, but we absolutely draw the line at "Use proportional fonts to make the code read nice on a page" because thats WAY TOO HARD

The hallmark of a good font is that it does not draw attention to itself. It does not interfere with the reader’s grasp of the author’s meaning, and it recedes into the background.

I use Verdana. Everyone thinks I'm nuts, but I like reading code that way.

I've been using cuis smalltalk with proportional fonts, even a slightly cursive looking one.

And before you get your pitchforks out, that's from a longtime (since 1998) vim user, whose other current weapon of choice is a neovim setup which acts as as its own multiplexer, thereby replacing gnu-screen (tmux for the rest of you).

In cuis, the morphic graphics system has been rebuilt to be entirely vector-graphics based. Entirely. Everything. The text rendering is beautiful. Each window can be scaled up or down with just a right click to bring up the 'halo', and then just drag the icon. The fonts are redrawn with vector graphics. There is zero quality loss, up or down.

Scaling up or down to cater for different dpi screens is no longer an issue.

The beauty of it is actually a little inspirational, as silly as that sounds. You feel like you have an expensive Japanese-nibbed fountain pen, and high quality parchment, and it forces you to write something.

(yes, the rendering quality remains, even if you also rotate the window as well).

I have been using Comic Sans for years. I like it.

Smalltalk environments have defaulted to proportional fonts back to the beginning of time [1]. Some of the newer ones allow for richtext code, so if you really need to make that ascii art drawing, you can change the font in the comment. Also look up elastic tabstops for an alternate alignment solution.

The tricky part is there aren't many proportional fonts designed for coding (but more than there used to be). One early 90s version of ST defaulted to Helvetica, which was a nightmare to read on the then current lowres screens. Of the current choices, Input is probably the best place to start. Verdana is popular with some, and I've used Lucida a bunch, both sans and serifed. I have also had fun using not really suited display fonts like Zapfino or surprisingly readable drafting handwriting fonts like Tekton. I am currently fiddling with using various ports of the TeX fonts, particularly the CM Concrete as I find the big serifs easy to read. It is usually recommened to use a sans font for readability, but I think that advice is outdated on modern very hires displays with subpixel antialising.

[1] https://fontstruct.com/fontstructions/show/1693628/cream-10p...

The proportional fonts question recurrs periodically:

2005 https://ask.metafilter.com/16469/Proportional-programming-fo...

2010 https://slashdot.org/story/130020

https://www.quora.com/Are-monospace-or-proportional-fonts-be...

2019 https://news.ycombinator.com/item?id=18958046

You'd probably have to use tabs to make your indented blocks and other alignment look nice. Then you get into the whole tabs vs. spaces debate.

I switch between golang's proportional font and Nirmala UI. They look really good on high dpi screens and are just generally attractive fonts. Indentation width is a drawback since space characters tend to be small. Code that uses two spaces for indentation is not nearly enough of an offset in my opinion. Four space indentation looks like two space for a monospace font, which is generally good enough. Also punctuation can be an issue as proportional fonts tend to have small, easy to miss punctuation.

This sounds like a nightmare for Python. No auto formatter would solve inconsistent indentation for you.

You would need to put a little more effort into using your caret to find issues when a compiler gives a row and column coordinate.

Max width restrictions (i.e. 80 columns) would become meaningless and arbitrary.

Your entire team would likely have to agree to the font choice for consistency.

OS font rendering differences would make life very interesting.

They preclude ASCII and Unicode diagrams.

Good luck with positional languages :)

What are you, a monster?

Yes, but my workflow is very unconventional: https://www.youtube.com/watch?v=aD6vmbmzdBo

fonts? real programmers use paper and pencil

nope.