Camel Mono; Don’t Be A Base Font Size Monster; A Labyrinth Of Type

I desperately wanted to show off the first resource on Tuesday, but this “actually sleeping again” habit seems to be sticking (I didn’t realize how mentally stressing the previous gig was). So, we dedicate the Bonus Drop time to the topic of typography.

In other news, I try to keep “AI” out of the Drops since it’s now a religious subject, especially after da Pope weighed in. So, instead of a deep dive, I’ll shunt whomever is interested to a recent Wired article on how “AI” is comin’ fer your serifs. To be honest, “AP” can keep most of the serifs.

TL;DR

(This is an LLM/GPT-generated summary of today’s Drop. Ollama and ibm/granite4.1:8b.)

• Camel Mono adapts Commit Mono with subtle optical spacing at camelCase word boundaries, aiming to ease the extra visual parsing cost that eye-tracking research found camelCase imposes relative to snake_case (https://github.com/TJHdev/camel-mono)
  
• Adrian Roselli argues the ideal base font-size is none at all, letting reader and browser preferences cascade through rem/em/% sizing while patching form controls with font: inherit (https://adrianroselli.com/2024/03/the-ultimate-ideal-bestest-base-font-size-that-everyone-is-keeping-a-secret-especially-chet.html)
  
• Matteo Bertin’s Borges Square Pixel, an OFL-licensed release from Collletttivo, builds a dense pixel grid that turns blocks of Latin text into a labyrinthine pattern echoing Borges’s recurring themes of infinite mazes (https://www.collletttivo.it/typefaces/borges)

Camel Mono

Back in July of 2023 we covered Commit Mono, and today we’re covering a newderivative of it that fits squarely into the “monster” category (since camelCase is only delibertely used by monsters)

In 2010, Bonita Sharif and Jonathan I. Maletic strapped a Tobii 1750 eye-tracker (section header) to 15 Kent State subjects and had them resolve camelCase vs. snake_case identifiers, and the gaze plots were pretty visceral. Something like mouseTheaterTicket generated three distinct fixations – one parked on each sub-word – because there’s no visual boundary to tell your eye where one token ends and the next begins except a capital letter you have to notice mid-fixation. Meanwhile, mouse_theater_ticket chunks like prose. After all the tests came in and were analyzed, camelCase took 932ms longer to resolve on average (20%, p=0.037), and the effect compounds with word count – 3-word identifiers were 36% slower to parse, while 2-word ones barely registered a difference. I should note that this is more of a cognitive load story, than an accuracy story since there was only one wrong answer across 120 trials.

TJHdev watched a Syntax episode covering that study, had the obvious thought that most of us have had (why can’t the font just handle this?), and went and built the thing. Camel Mono is a derivative of Eigil Nikolajsen’s Commit Mono that adds subtle optical gaps at camelCase word boundaries. getUserName renders with just enough extra spacing between get, User, and Name that your visual system can chunk it without hunting for the capital letters. You get something close to the parsing ease of snake_case without touching a single character of code.

The implementation is clever as — despite the extra spacing — column alignment stays monospace. The glyphs all shift within their cells rather than widening them – so your carefully constructed indentation doesn’t go sideways. It’s built via Python and Shell tooling on top of the Commit Mono source, and the repo is MIT-licensed and genuinely small (12 commits, one contributor, no cruft). The original study used isolated identifiers shown out of context, not identifiers embedded in real code with syntax highlighting in play, so the perceptual gains in actual editor use may be smaller than the raw numbers suggest. But even a fraction of that 932ms compounds nicely across a few thousand identifiers in a workday.

Swift and other languages do “require” camelCase, so this will be a handy addition to the typography toolbox.

Don’t Set a Base Font Size

Adrian Roselli’s advice in “The Ultimate Ideal Bestest Base Font Size That Everyone Is Keeping a Secret, Especially Chet” is bracingly simple: the ideal base font-size is…nothing. DO NOT SET ONE. Your readers already have one – whatever they chose in their browser or configured at the OS level – and the moment you slap a pixel value on body, you override that choice on their behalf. (As someone who is doing font size adjustments as the old eyes start to wane, I find it very frustrating when a site or app fails to allow me to adjust font sizes well.)

If a linter or a pedantic reviewer absolutely insists something appear in your stylesheet, html { font-size: 100%; } is the peace offering. It satisfies the checker without actually doing anything useful, because 100% of the inherited size is…(shocklingly)…the inherited size. Everything else – headings, nav, footer, whatever – should use rem, em, or % built off that base, and in most cases those relative sizes shouldn’t dip below the default.

While you’re auditing your CSS for this, Roselli also recommends dropping this snippet in:

select, textarea, input, button {
  font: inherit;
}

Form controls don’t pick up body styles automatically in most browsers; they pull from their own internal UA stylesheet instead, which is why your carefully considered type ends up looking oddly mismatched inside your own <input> fields. The font: inherit shorthand fixes that, passing your readers’s preferred size all the way down into the controls.

The one carved-out exception is in a print context. Screen text scaling is inherently dynamic – folks zoom, OSes intervene, viewports narrow. Print is most certainly not dynamic. An @media print block with a fixed point size on body is entirely reasonable, and all your relative sizes will cascade off it as expected.

If you’re still with me, the update trail on this post is worth a skim. Mike Mai pushed back shortly after publication, arguing that if you’re imposing a custom typeface on your readers anyway (one that might read too small or large at the default), stacking a font-size declaration isn’t a meaningful stretch. Roselli acknowledges the logic – the caveat being that the font actually reaches the human and they haven’t blocked it. Miriam Suzanne’s Reimagining Fluid Typography grew partly from this conversation, and the two OddBird livestream references in subsequent updates are worth watching if you care about this stuff enough to go deeper.

The most recent update, from February 2026, ties the whole approach to the CSSWG’s work on OS-level text-scaling preferences – browser vendors are moving toward surfacing system text-size settings directly to the web. Roselli frames not setting a base font size as the right position to be in when that happens, and based on the direction of the spec work, it’s hard to argue otherwise. Adjust your boilerplate now rather than retrofitting later.

A Labyrinth Of Type

Matteo Bertin’s Borges Square Pixel dropped at Collletttivo this past March as a single-style release built on a grid tight enough that every letter reads as its own small maze. The premise, as the foundry frames it, is almost a dare: can a typeface hold the image of a labyrinth the way a page of prose does, each line opening onto branching paths the reader can’t quite map?

The reference isn’t subtle, as Borges spent a career obsessed with infinite libraries, gardens that fork into every possible version of themselves, texts that loop back on their own commentary. A typeface built from square pixels and committed to density over clarity is a fitting echo of that obsession – treating each glyph less as a vessel for a sound than as a tile in a larger pattern, one that resists settling into any rhythm the eye can predict.

Readability gets set aside on purpose here. Strokes and counters trade places until black and white carry equal weight, and the texture stays unstable enough that no block of text quite resolves into the calm grey a body font usually settles into. This is the opposite of what most type design optimizes for (which is kind of the whole point) – a font that performs the disorientation Borges wrote about rather than just naming it.

It’s released under the OFL, so the files are free to grab from the Collletttivo page. Drop a long block of Latin text through it and watch the maze take shape – then compare that against a single word sitting on its own.

This might be a great way to pass notes along to humans since I don’t think most of the AI models today are going to be able to turn these text mazes into something they grok.

FIN

Remember, you can follow and interact with the full text of The Daily Drop’s free posts on:

• 🐘 Mastodon via @dailydrop.hrbrmstr.dev@dailydrop.hrbrmstr.dev
• 🦋 Bluesky via https://bsky.app/profile/dailydrop.hrbrmstr.dev.web.brid.gy

☮️