Input: Fonts for Code

Agreed. Coming from SourceCode Pro, everything seemed a bit taller, but adjusting the space between the lines fixed that perception. Looks smooth on my 2015 MBP, and external 24" 1920x1200 monitor.

If you like Iosevka as much as I do, throw a few bucks the way of the creator via Patreon.

(I’m not affiliated, just a big fan of the font).

I agree! Fira Code and Input are my top choices, and Inconsolata / Ricty Diminished Discord are pretty close second.

I wish Input didn't remove ligatures from their latest release.

I found out about Consolas by way of Inconsolata.

One day I spent an afternoon looking for a better coding font.

I liked Inconsolata. When I Googled to find out more about it, I learned it is a knock-off of something that was hiding right under my very nose: Consolas found on Windows boxes.

I tried that and found it better. I now have Consolas all over the place. I'm typing in it on Firefox. I have it in Ubuntu right inside Gnome terminal and other places.

Thank you, Microsoft!

this is exactly right. condensed is my favorite, but there's no wrong answer.

In the example in that stream of tweets, you have:

    put   = blah
    get   = blah
    post  = blah
    patch = blah

gofmt accepts it as aligned, but the equals signs are visually unaligned when using a proportional font.

I wonder what it would take to create an editing environment where you have a proportional font that shrinks or grows the (visual) whitespace to align those, and whether it could scale to things like nested functions.

I gave up on proportional fonts after a while. That was about 15 years ago, though... I think using clang-format and Comment Reflower/Emacs M-q/etc. would solve most of the problems I had with creating code that looked sensible when other people looked at it. If you've got the whole team layout out their code using tools like that, then the proportional font people won't find themselves having to line things up and whatnot.

Still doesn't solve the issue of having ASCII art diagrams in your comments. Though... the comment word wrap plugin I use for Visual Studio has markup to say that it should leave a section of the comment alone (I use this for ASCII art bits). And clang-format has similar directives for blocks of code that it should leave alone. Would be nice if text editors could recognise these (and other similar markup - or perhaps markup could even be standardized between tools?) and render the appropriate sections in a monospaced font. That might be a useful compromise.

I tried Input for a bit but wasn't really fond of the way it looked. My favorite coding font for some time has been Trebuchet MS. It looks really nice in the environment I use: fairly large fonts on a high-DPI display.

With one exception, it has easily distinguished punctuation and characters like 0Oo and 1lI|. The exception is that it has a rather poor tilde. One of these days I'll load it into a font editor and put in a better tilde.

Regarding deeply-nested functions not lining up, the solution there is to stop using column alignment and use indentation instead. As an example, the Rust team recently changed their style from this alignment-based format:

    let mut rewrites = try_opt!(subexpr_list.iter()
                                            .rev()
                                            .map(|e| {
                                                rewrite_chain_expr(e,
                                                                   total_span,
                                                                   context,
                                                                   max_width,
                                                                   indent)
                                            })
                                            .collect::<Option<Vec<_>>>());

to this indentation-based format:

    let mut rewrites = try_opt!(
        subexpr_list
            .iter()
            .rev()
            .map( |e| {
                rewrite_chain_expr( e, total_span, context, max_width, indent )
            })
            .collect::<Option<Vec<_>>>()
    );

Even if you use a monospaced font, the latter style is much more practical. For example, if the arguments to `rewrite_chain_expr` were longer in length, you would simply change it to:

    let mut rewrites = try_opt!(
        subexpr_list
            .iter()
            .rev()
            .map( |e| {
                rewrite_chain_expr(
                    e,
                    total_span,
                    context,
                    max_width,
                    indent
                )
            })
            .collect::<Option<Vec<_>>>()
    );

I would get pissed to shit trying to click between 'i's and 'l's when coding. Proportional fonts are for sequential writing, reading, and editing. They are designed to hide mistakes. The are designed to make all words have a similar texture. None of that is what I would would want a programming font to do.