The ligatures are really interesting, but at a glance I process them so much slower than the raw characters, especially the ones that change the graphical semantics such as <= vs ≤. Does anyone have experience getting used to these and 1) does it end up faster? 2) once you are used to it is it harder than it was before to process the raw characters when reading code in fonts that don't have the same ligatures?

i don't think of it as faster or slower to read, it's just more aesthetically pleasing to me. i use cascadia code in vscode with ligatures enabled, it's really nice looking.

Ligatures became one of my favourite features after trying out Fira Code. It felt like an obvious improvement that I was yearning for, for years.

I guess my brain likes having distinct continuous symbols to represent different operations - it reminds of of math in school & university. And I don't see a problem during editing, knowing they're made of multiple symbols.

And yes - I feel that I do struggle much more without them.

Completely out-of-the-blue, unproven guess - my mind is used to learning new symbols quick, from all the gaming I've done. And it's much easier to learn a new symbol that's cohesive, continuous & unique, rather than having to read disjoint characters and figure out a different meaning for them.

It took me a bit to warm up to them, but now I find myself relying on them to more quickly spot errors, so yes it ends up faster. Somewhat counterintuitively, I find the ligature characters easier to process at a glance and see if there's a problem or not (I suspect its something along the lines of my brain looks at "<=" as two separate characters, one after the other, and has to process each in serial then combine them into the concept of "less than or equal to", whereas the ≤ is a single character that goes straight to the "less than or equal to" concept in the same way its easier to remember the number "six hundred ninety-three" than "six, nine, three". I also find it way easier to spot the "≡" vs the "===" in JS land, which surprised me but here I am.

I wouldn't say its harder to go back, but it does make me do a double take. Overall I would say the effect is quite minor and I'm just fine without the ligatures, but given the option I would enable / prefer them.

Sounds like the way programmers learn to use syntax highlighting. Never occurred to me to view ligatures through that lens .

I initially hated ligatures. Decided to give them a try with JetBrains Mono.

Now when they are turned off I feel like something is missing, and scramble to turn then on again. For whatever reason my brain feels more comfortable with them.

try them. you'll love them.

if you see the <= "less than or equal to" ligature and hit backspace once it will become <. it's very intuitive. this is how emoji operate to combine a face with a skin tone - it is two characters merged into one.

dunno why so many people see ligatures and clutch their pearls like it is some kind of rock and roll devil symbol.

I think people don't like it because it's not intuitive. When I hit backspace next to a character, I expect the character to be deleted, not for it to shapeshift into another character. I see how ligatures can be nice for some people, but it's definitely not as intuitive as showing the actual characters in place.

Also if I type two character, I expect to see two characters - and not a single character that is somehow not aligned with every other character's columns. And because it is not aligned, the space left and right seems to be off. Everything about monospace ligatures feels unintuitive to me.

I have the opposite experience with ligatures owning to years reading academic mathematics papers before coding seriously. I can still parse semantically dense symbology significantly faster than most code (even with years of experience) to the point where code seems almost comically inefficient. That said, I know many programmers take the implicit context intrinsic to mathematics symbology as often times an inexplicable cognitive load.

If you have a lot of different symbols, it makes sense that ligatures would help to distinguish them more easily. So, ligatures for Haskell symbols also probably help, since there are so many infix operators in Haskell. There are also a bunch of old papers that showcase Haskell code and use the ligature representation of its operators.

However, most programming languages really just have a few symbols: arithmetic operators (+, -, /, *), comparison operators (<, >, <=, >=), and logical operators (&&, ||, !). C also has bitwise operators (~, &, |). It's already easy enough to distinguish these without ligatures, so the benefit is negligible here, IMO. I prefer to go without ligatures, because I have no trouble remembering or distinguishing them, and, like someone else mentioned, I find ligatures in a monospace font kind of weird (how they morph into a two column character when you write them, and turn back to a one column character when you delete half of it).

For me it's not a matter of speed, but distinctness and fitness to the meaning.

A ligature happening is kind of a "syntax affordance" saying that the code is correct, and it indeed says "!=" and not "! =". It kind of helps my brain elevate the code from "sequences of characters" to "serialised syntax tree".

The fact that the "not equals" operator is the exclamation mark followed by an equals sign is purely an artefact of the practicality of keyboard input. Ligatures are a simple way of stepping away from the raw text and into the meaning of things, just like syntax highlighting helps transform "words" into "tokens" on our brains, or rainbow parens help us visualise the hierarchy of the language in question.

(Though I find rainbow parens a bit too colorful and distracting, so I don't use them in practice, I like the idea behind them)

It is the same idea that proponents of visual coding advocate for, but text as a medium is much better because of how compact we are able to make it without feeling cramped.

Which leads me to another tangent, which is that there is a very clear split between programmers that "manipulate text" and programmers that "manipulate structure".

It can be seen in the choice of tooling, some people really go ham with multi-cursor editing, find-and-replace patterns, "select next word", editor macros, and other text manipulation based tools. While others (myself included) prefer a more content-aware tool like JetBrains' "rename field", "extract method", "widen selection" (select AST parent's text span), etc.

Which is not to say that either group is more correct or efficient, it's just a pattern I see on people.

I'm in the first group (these are text files first and foremost) and I think that's a really interesting observation. Do you have any thoughts on what the consequences might be?

As someone who manipulates structure, the refactoring tools and the like, as well as the formatting IntelliJ does for you, make my programming less portable between editors. Text-driven development is very portable, but I actively dislike using VSCode in comparison to IntelliJ because it refactors and formats code in different ways.

This is only kind of related, but the syntax-tree-unaware C preprocessor makes it impossible to parse a C file without doing macro substitution first. You have a lot of stuff like this:

    #ifdef FOO
        if (A && B) {
    #else
        if (C && D) {
    #endif
            /* code */
        }

Even so, it can be useful for things like the implementation of assert, which can be implemented like this in standard C99:

    #ifdef NDEBUG
    #define assert(EXPR) ((void)(EXPR))
    #else
    static inline void __internal_assert(const char *file, int line, const char *func, const char *expr) {
        fprintf(stderr, "%s:%d:%s: Assertion `%s` failed.\n", file, line, func, expr);
        abort();
    }
    #define assert(EXPR) __internal_assert(__FILE__, __LINE__, __func__, #EXPR)
    #endif

Can only speak of experience writing code for both groups and seeing them work, don't take any of the info below as statistical truth.

As I said before, it certainly affects the choice of tooling, and therefore this property of programmers often places them in either side of the eternal "IDE vs text editor" wars. Which is distinct from the GUI vs TUI wars, but in practice most IDEs are somehow graphical. Structure-ers generally prefer tools to be thorough even if they're slow, while Text-ers prefers tools to be as fast as possible so they can be thorough themselves.

I don't think there is really that much of a difference in code style, the general pains of weirdly styled code are often universal regardless of how you look at it. (Text-ers might dislike identifiers with multiple words because it takes longer to navigate through, while Structure-ers might dislike having complicated expressions for the same reason.)

I guess the main impact I see is from pair programming, it is supremely distracting to watch someone with a different mental model of the code do things in what appears to be this "inefficient" way.

As someone in the second group the IDE is basically just doing the first thing efficiently for you when you do the second thing. Not a good or bad thing but I do think that that’s interesting to note

Yep, it's just the mental framing, which is why it doesn't really have noticeable effects elsewhere in code.

I’ve never really thought about, but I’m in the first group for sure.

I’m also someone that likes getting the most out of a basic set of tools or features. A less is more kinda person.

Although I’m old skool Mac OS so I need some kind of GUI.

I have nothing to add, just wanted to say I think this is the best-written explanation I’ve come across for why I like both ligatures and good syntax highlighting.

I never use ligatures. I want to know the raw characters in the code, I don't want to have to parse then convert them in my mind.

Coming from a math background and using latex a lot, ligatures were really godsend for me. Without ligatures code looks unnatural but it's just an aesthetic thing in the end and I don't mind either way

I tried to get used to them, but eventually gave up when I found that I was getting ligatures for parts of runs of symbols when they weren't actually appropriate. I think it was `|` and `>` placed next to each other that pushed me over the edge.

The is obviously completely subjective.

I find ligatures more interesting for the slightly more "exotic" syntaxes like arrows → instead of ->, ⇒ instead of =>, etc. Most of them are incredibly similar to their non-ligature counterparts, and even ones like != don't seem to cause much trouble.

I don't seem to have any trouble switching between ligatures in the IDE and no ligatures on github. I haven't really had to think of them.

I initially liked them, but later changed my mind. The same goes for e.g. prettify-symbols-mode in Emacs or conceal in Vim, which takes the same concept further.

I often work with files (both documents and code) where Unicode input is permitted, and it can then be important to know what exactly is written in the file. Moreover, when reading code, I find it easier to remember how to write the corresponding code with the fancy ligatures turned off.

I also can’t use ligatures. In my head it’s two symbols and to see it as only one just complicates it. But I also feel like if you had a language and it just supported a Unicode symbol then I’d be fine with it. I think it has to do with the fact that I know / sense the facade and it causes me to always resolve it to its two character canonical form.

I just think they are pretty to look at while coding. I have to stare at code for long stretches of time. It's easier to do so when things are aesthetically pleasing.

I guess looking at font that doesn't support ligatures does become a little bit harder, but I can't imagine the switch being too time consuming.

I've been using JetBrains Mono for years now. It's great.

I never actually understood the whole fuss about fonts. I tried playing around with them few years ago and i never noticed that something is easier to read with some font or another, especially in the long term. Whenever i started using some font, i got completely used to it in few days. Therefore i just use the default fonts now.

To each is own but I'm a huge design and typography nut and when my entire physical workspace and software interface looks aesthetically pleasing, I'm much more inclined to actually do work.

I use this type face on pretty much everything that involves reading or writing code. It's great! Even comes with ligatures.

Victor Mono[0] is another great monospace font.

[0]: https://rubjo.github.io/victor-mono/

It does look good but oof I dislike the cursive italics. I find cursive hard to read, since I never really learned to write it, and I constantly trip over letters like "s" and "r" that don't look liker their normal counterparts.

Well, the cursive is optional anyway. Also not my cup of tea, and I write in cursive.

Font looks awesome otherwise.

Check out Fira Code - it's another good programming font. I don't think it has the cursive italics thing.

I love this font, but I am currently giving Commit Mono (https://commitmono.com/) a spin. JetBrains did a great job.

They are very similar typefaces I think one can be quite happy with either.

Oooh, that does look great. Very similar to JB Mono, but I like the defaults in Commit Mono a bit better overall. The asterisk, the positioning of the quote marks, the slashed 0 instead of dotted.

Great alternative. A side-grade, maybe. Thanks!

I kinda love the fancy-silly features (ligatures/etc) so i didn't give CommitMono a try. BUT, i adore the smart kerning.

Any other fonts with smart kerning?

It's weird how much I've come to like this font. And like @tentacleuno, I use it pretty much anywhere and everywhere I can get away using it.

This, and Roboto Mono, are my two desert island monospace typefaces. Are you allowed to have two desert island mono typefaces? I don't think I could could choose between them.

If you were to extend it to three then this would be me, but with the addition of agave and mononoki.

There are a lot of code fonts on HN today. Rather than make a new post I will talk about some of my favorite that are a little less common. None of these are free I don't think.

Cartograph CF - The one I've been using for code for years. Very readable, almost "comic mono"-like choices of some of the lower case glyphs but in a good way. All the character is in the italic which you will either love or hate.

Quadraat sans mono - The entire quadraat family is a collection of masterpieces imo, but are generally too distinctive to be appropriate for most public-facing work. But it's your computer so who cares. I use the mono sans one for my terminal. The lowercase f seems so out of place there but you learn to love it.

Alegreya sans - Not a mono font, but it almost is so if you've ever flirted with proportional fonts for code this is a fun one to try. There is a lot of careful line width variation that gives a lot of the appearance and readability advantages of serifs but keeps most of the visual coherence of sans.

I like all of these because they feel more like normal fonts rather than code fonts. They have careful variation that adds character and improves readability for me. I've switched to an almost-no-color code theme that uses font weight instead, and the details like this become more important that way.

And then only kind of related but if you want to use unusual fonts in your terminal but you have a complex prompt setup, install font forge and learn to use something like https://github.com/ryanoasis/nerd-fonts/blob/master/font-pat... to patch in the extra characters. This can also solve your "I love this font but want a dotted zero" type problems as well. Small skill investment for a small return over a long period of time. You'll always be using fonts.

I've been using Operator Mono SSM [https://www.typography.com/fonts/operator/overview], but Cartograph CF is really nice and reasonably priced.

I don't get the fuss about the JB typeface. I tried it, couldn't get used to the ligatures, and in the end, stopped using it after a few days.

They include versions without the ligatures for exactly that reason. It is the files with NL in the name.

Not a fan of the ligatures, it's a pleasant looking garnish that requires translating to its underlying parts. So it would probably work for one person but butb not so great when sharing screen time with others, then it just becomes a distraction.

JetBrains Mono NL is the no-ligature version of it and it is also included in the official zip file.

Personally it is what I use, I like its aesthetic but I also dislike ligatures for coding.

It doesn't require translating, that's the whole point. In most lanĝuages, >= actually means ≥, so it makes sense to render it like that.

For me nothing can dethrone Inconsolata[0], there's just something elegant about it that I haven't found in other fonts I've tried. Been using it for almost ten years now. Also I don't like ligatures...

[0]:https://en.wikipedia.org/wiki/Inconsolata

Was at the same camp but when I moved to retina screens source code pro seemed a bit better to me.

Don’t ask why. It just feels right lol.

I don't like fonts where the zero has a dot (or nothing). I need to have that slash in my zeroes.

> Also I don't like ligatures...

Ligatures are optional, so you don’t have to let the existence of those glyphs stop you from using an otherwise-better(-for-you) typeface. Additionally, in VSCode at least, there are extensions that give you even more contextual control.

For Intellij IDEs, there's the plugin Ligatures Limited.

I really like using Cascadia Code PL Nerd Font.

What do most people use?

This. I was late to trying it out but just started with it last week and love it. Right up there with Menlo for me.

I really like Inconsolata except for one letter. The “g” just looks wrong to me, and it puts me right off!

Funnily enough I think recently I had to do something in Rider (the IDE) and everywhere in the file where I had a "g" it got cut off somewhere on the last 1/3 of the letter. It was a visual bug that disappeared after restart, but it also made me notice the "g" in a bit more detail. I attribute this to the fact that of all the Latin letters lowercase "g" is by far.. should I say "fanciest"? I can see how the loop tail variation might seem out of place.

I stick with https://www.nerdfonts.com/font-downloads, I need the glyphs. This would be a good candidate for nerdification.

If you use Kitty or Wezterm, you don't need patched fonts.

For Kitty, just install the Symbols Nerd Font (it's a fontset that contains only nerd symbols).

For Wezterm, you don't need to do anything, the glyphs are already built in.

JetBrains Mono has been nerdified, in four varieties, for a long time, and is already there. I use it with oh-my-posh.

There are non-ligature and non-monospace (for icons only - everything else is monospace) versions.

I'm not even a Mac user by choice, but Monaco[0] has been a favorite of mine for years.

[0] https://en.m.wikipedia.org/wiki/Monaco_(typeface)

Me too. The only con is that Monaco does not have bold variants.

Fortunately, someone has created them!

https://github.com/vjpr/monaco-bold

Yep. I have Monaco installed on my Linux and Windows machines as a basic requirement for doing any sort of plain text editing.

Monaco is very good and, to me, the way Monaco does the lowercase 'l' letter is the only proper way to do it. Several other coding fonts thankfully get the lowercase 'l' right, like JetBrains Mono btw.

All roads lead to Monaco. I miss the bitmap version though.

Monaco’s my go to coding font and has been for at least 15 years. Really love the letter forms, and it’s just so immediately readable for me.

But I don’t really like it in terminals - I use SF Mono there.

I love JetBrains Mono

Me too. Just install this on Windows boxes and TUIs in putty are good.

Nothing beats Iosevka (https://github.com/be5invis/Iosevka) for me. It's narrow yet super readable, making great use of screen real estate. Lots of customization, ligatures, weights, and a nerd font patch for terminal.

Yes, I guess what I like it that it still looks good when I'm on the ultrawide, low DPI display. On the Mac display all those fonts look great.

What's new here?

(2020)

I wish they could have a brackets change like there is for Input font family.

You can always create a request for new character variants. They are pretty receptive of community requests.

Been using this Font for a couple of years now, it's amazing.

Personally not a fan of ligatures in monotype typefaces in general, although I understand why some may like them.

There are non-ligatured variants included in the download.

I think that JetBrains Mono and Cascadia Code are simply the two best fonts for programming.

I personally prefer classic "typewriter-style" monospace fonts - "sans-serif" monospace fonts always look unbalanced to me, because they avoid serifs as much as possible, but then are forced to use them to avoid thin glyphs like i, j, l, 1 etc looking "lost". Unfortunately the designers seem to focus on sans-serif anyway. One good contender with serifs is "Go Mono" - it also uses the trick of increasing the height of lowercase letters to be more readable at small sizes, and it notably doesn't have ligatures. It also doesn't have a fancy demo page, but here's the blog post introducing the Go font family: https://go.dev/blog/go-fonts

JetBrains Mono is nice, but it's a little too sharp, and it's too tightly packed IMO. Cascadia Code is a little better, but nothing beats Menlo for me.

It looks too ... squished to me.

I do love conversations about fonts

I see a lot of folks in this thread lamenting the usage of ligatures, but note that the downloaded set of font files includes a "JetBrainsMonoNL" version of all variants, which does not include ligatures ("NL", as in, "No Ligatures").

I do not like ligatures either, yet this is my favorite monospaced font. I use JetBrainsMonoNL in all the places.

I'm starting to wonder if this is becoming spaces vs tabs. It seems silly to heavily critique a font because it supports ligatures and inversely seems silly to critique a font because it does not.

Most fonts with ligatures can be used without them anyway, making the whole thing moot

However, not all IDEs, text editors, and terminal emulators support disabling the use of ligatures, so it's often easiest to just switch to a font that doesn't include them if you don't want them.

huh, I'm surprised from searching that there isn't a quick tool to just disable ligatures given a font file. It should just be a matter of removing the ligatures in the GSUB table from the font.

Just switch the font variant to NL - no need for editor support.

Doesn't that depend on the font author providing a NL version?

e.g if I wanted the FiraCode improvements[1] over FiraMono without the ligatures. If my editor doesn't support disabling ligatures I basically have to build it myself since they don't distribute a NL version.

[1] https://github.com/tonsky/FiraCode#whats-in-the-box

That's what I mean; it's often easier to use a font that doesn't have ligatures (like the NL variant) than to use a font with ligatures and hope your editor lets you disable ligatures.

I like ligatures but only when they help to remove ambiguity. For example, the ligatures for “=>” (⇒) and “>=“ (≥) are helpful because they make a syntactic problem visually prominent with how different they look. Any ligature that doesn’t help you be a better code reader is a useless visual artifact, a distraction even.

Envy Code R is another favorite of mine

Is there really a better typeface than Apple's San Francisco Mono? I use it on all my machines, even my Windows and Linux ones. There are also versions with patched glyphs so you don't get boxes when trying to render certain characters.

Better is subjective but I was too a big fan until Fira Code. I love ligatures

I'm not a fan of ligatures personally, they obscure the raw source code that I want to see rather than a layer on top of the code.

Ligatures are optional. Don't let that detract from its excellence.

SF Mono and Monaco are my two all-time favourite monospaced fonts - weirdly, I really like SF Mono for terminals and Monaco for code editors!

Yep I use this one everywhere I can on my Macs, and Roboto Mono as a decent approximation everywhere else. Discovered it because I accidentally opened something in XCode one day and went "wow, that's a nice font!"

fwiw most (all?) JetBrains IDEs have a setting to enable/disable the ligatures.

Doesn't apply to everyone but I'm assuming some familiar with the JetBrains font will also be using some other things JetBrains makes.

You should check out Fira Code if you get a chance - another great (imo) programming font.

Nerd Fonts has a version of it too if you need the glyphs.

Also it has ligatures too which I love.

In my eyes, Liberation Mono is still the best programming font, due to how readable it is even in smaller sizes (and it comes with LibreOffice I think): https://en.wikipedia.org/wiki/Liberation_fonts

There's also the Cousine version, which is more or less the same, both are also metrically compatible with Courier New: https://en.wikipedia.org/wiki/Croscore_fonts

After that, I rather enjoy PT Mono, except that the full stop (dot) symbol feels too small, I actually use the PT Fonts for most of my personal webpages because they're decently readable and not too stylized, nor too boring: https://en.wikipedia.org/wiki/PT_Fonts

But frankly, there's a lot of good fonts out there and it's entirely a matter of taste. Some like ligatures, some don't. Some like monospaced fonts, others like proportional ones.

It's also really cool when the OS itself lets you set your font preferences for most applications that you're going to use, I catch myself wishing it'd be easy to do that for all of the JetBrains IDEs and other dev tools at the same time, though. Maybe a simple GUI program or a script that'd let me set those particular preferences for all of my editors in one go.

Berkeley Mono has been my go to font for a while now. https://berkeleygraphics.com/typefaces/berkeley-mono/

What a nice demonstration page!

For me the best part was the image comparing various letters that look alike in other fonts (and that are removed in Crockford's Base32 precisely due to this):

> q9g (C iI1lL 0Oo8

I just prefer Berkeley Mono.

https://berkeleygraphics.com/typefaces/berkeley-mono/

While now there are many other good typefaces for programming languages, which are more or less equivalent to JetBrains Mono when restricted to the ASCII character set, JetBrains Mono has much better coverage of various Unicode blocks, e.g. of the mathematical symbols, and this is why I normally prefer it.

I greatly appreciate Jetbrains' software. But the only thing that I care about in a code font is balancing legibility with maximizing columns of text. Their overlay comparison to consolas fails on my main concern.

I have been using it for a few months, both in JetBrains products as well as in Neovim. Looks great. I'm comfortable with their style of ligatures.

Absolutely the best font I’ve ever used. I can easily read letters from far, from close, in bright light, in darkness.. used it since day one. Also using it in my terminal. Thanks JetBrains, I love it.

This was my favorite font ever, made me stop font hopping...until I found that italic A and italic O are too similar, now I'm back to don't hopping.

This has quickly become my favorite, replacing my previous favorite, Monaco, in the terminal also.

I like to try out coding typefaces, but always find myself returning to Apple’s SF Mono.

I’m a Mac user so….

Dupe

https://news.ycombinator.com/item?id=22053998

https://news.ycombinator.com/item?id=36788767

https://news.ycombinator.com/item?id=22061018

https://news.ycombinator.com/item?id=22108261

https://news.ycombinator.com/item?id=32803484

https://news.ycombinator.com/item?id=31192775

https://news.ycombinator.com/item?id=22093393