4x4 ASCII Font (2016) | Hacker News Reader

4x4 ASCII Font (2016)

simplifier.neocities.org

184 pointsthunderbong96 comments

This is smaller than I've ventured to go; I used 4×6 in http://canonical.org/~kragen/sw/dofonts-1k.html (and I think the font is Janne Kujala's design; I wouldn't be surprised if I changed a few things, but it's been more than ten years, so I don't remember) and a proportional font that averaged 3.6×6 in http://canonical.org/~kragen/sw/netbook-misc-devel/6-pixel-1..., used by http://canonical.org/~kragen/sw/netbook-misc-devel/propfontr... to render http://canonical.org/~kragen/bible-columns.

4×6 is 24 pixels, which is one pixel less than 5×5.

If you're rendering a single column of characters, I think you can do 3×n, where n ranges up to 7 or 8 but is usually more like 5: http://canonical.org/~kragen/sw/netbook-misc-devel/3xnfont.

All of these are larger than 4×4.

My hat is off to the Simplifier.

Unlike the font in the linked example, your font is actually legible. Good job. The lowercase in the link is virtually unintelligible unless you really squint.

Fully agree.

Again, just to clarify, the 4×6 font is (at least mostly, maybe entirely, I don't remember) the work of Janne V. Kujala in 4x6.bdf, as distributed by Markus Kuhn and now included in XFree86 (and presumably X.org, unless they've dropped BDFs entirely). The XLFD is -misc-fixed-medium-r-normal--6-60-75-75-c-40-iso10646-1, so you can try it by running

    xterm -fn -misc-fixed-medium-r-normal--6-60-75-75-c-40-iso10646-1

My proportional n×6 and 3×n fonts are derived from it.

The smallest I ever did was 4x8 on a Commodore 64. The actual text was 3x7, with a one pixel spacer on the right and bottom. Did this for a terminal emulator that output 80x24 text (plus a status line) on the 320x200 screen.

Rending was slow, but that's OK because 1200 baud was state of the art at the time, and the computer could keep up OK. 2400 baud worked, if there wasn't too much scrolling.

Eventually we came up with a way of doing a 8x8 characters on a 640x200 screen using some of the scrolling methods we saw from the demo scene, but it was blurry, even on a good monitor, and we couldn't output the characters fast enough to be usable. By then the 128 was out, and it was assumed people who wanted 80 columns would just use that machine's real 80-column mode.

I think I remember seeing 4x6 (3x5) on the C64, possibly in an environment like GEOS. That’s about the limit of what is usable, pixelation-wise.

Edit: The smaller GEOS UI font indeed had a cap height of 5 pixels, but it was variable-width: https://upload.wikimedia.org/wikipedia/en/e/e2/GeOS_Commodor... (the font of the icon labels)

Tasword 2 (word processor) on the Spectrum did 4x8 (3x7 with a spacer) to get 64 characters per line which was miraculous at the time.

(They probably kept it on an 8-high grid because the Spectrum's screen layout was a bit bonkers if you went off 8-alignment.)

I guess it is a 50% increase, but yours is really good, it could actually legitimately be used.

Thank you! My proportional font is about a 35% increase over 4×4, so I guess what you mean by "yours" is Janne Kujala's 4×6 design (from which I think I derived my proportional one).

I think that if you use grayscale, and certainly if you use LCD subpixels, you can get readability down to a smaller size.

The Simplifier's font is 4x4 including 1 pixel space on horizontal and vertical borders. The 4x6 font does not include that space, so it's an extra difference between them.

I'm not sure whether you're saying that three lines of text in the Simplifier's font would be 15 pixels tall, or that three lines of text in Kujala's or my font would be 21 pixels tall, but I think neither of those is the case; the former would be 12 pixels tall, and the latter 18 pixels.

I'm also saying that three letters of text in Simplifier's font would be 12 pixels wide, and in your font they will be 15 pixels wide.

You're talking about Kujala's 4×6 font, then, but you have it wrong; three letters of text are 12 pixels wide in it. There's no extra implicit spacing pixel, either horizontally or vertically.

As you can see from the code in http://canonical.org/~kragen/sw/dofonts-1k.html, moving to the next character position is "x += 4" and moving to the next line is "x = 0\n y += 6".

Amazing how only an extra 2 pixels horizontally adds a ton of readability. If I was ever going to use a font like this I would hands down use your 4x6 version over the barely legible 4x4 that was linked.

4x4 is impressive, but your 4x6 is shockingly good. Probably my new favorite.

It's a little annoying that my mobile browser refuses to zoom in far enough on that final image, now I can't properly admire the result of your work!

The font sample looks great though

Tangent: does anyone know how to tell mobile Firefox to use crisp rendering by default when directly loading images?

It's a 10 meg image. Drag it off the browser onto the desktop (or save it) then use an image viewer/editor to zoom.

Impressive how readable that still is, and how good our brains are at filling blanks, but you wouldn't want to rely on it. I'm not sure I can parse || as an x reliably for example. The uppercase alone works, lowercase is pretty challenging.

I found the test sentence that we all know and love to be legible.

I find a string of random characters to be impossible to read.

I wonder if the test sentence is easier to read just because it is very familiar.

Yes! I read "The quick brown fox jumps over the lazy dog [something] times", and was scratching my head over the penultimate "word". Had to go into the source to recognize it as a string of digits.

Test sentence is actually the training data for us. Luke one shot training. Author should have given random sentences after that one so that we could test how well have learned the font.

Oh, totally; your brain is great at error correction, but the more you can reduce the search space / prefill the better it'll do.

(that’s the point being made)

On the upside, x isn't used that much.

As much as j, more than q and z.

I can only encourage you to try yourself making a small font. It's amazingly playful and easy, and you can do it online here: https://www.pentacom.jp/pentacom/bitfontmaker2/ (yes, you can export as a ttf :) )

Here is a quick example of a 3x6 I made to test the tool: https://www.pentacom.jp/pentacom/bitfontmaker2/gallery/?id=1...

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

DonHopkins on July 9, 2021 | parent | context | favorite | on: Hoard-of-bitfonts: bitmap fonts from disused opera...

It should include the 3x5 pixel font from Mike Koss's "The Terminal" on the Apple ][.

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

>DonHopkins on Oct 4, 2018 | parent | favorite | on: Sans Forgetica, a font designed to help you rememb...

Who can possibly forget the font that Mike Koss's "The Terminal" Apple ][ terminal emulator used to get 32 lines of 70 characters each in HIRES graphics mode in 1981? It's the most difficult to read font I've ever used regularly! (Don't try using it on a color TV, though.)

https://web.archive.org/web/20120206091422/http://mckoss.com...

>Tiny (3x5) Font

>In 1981 I wrote a terminal emulator for the Apple II. At the time, the Apple II could only display upper case characters. I used the hi-res display (280 x 192 pixels!) to display my own character set. In order to come close to showing an 80-column display, I created a truly tiny font, displaying the full ASCII character set (upper and lower case).

>I created a font within a 3x5 pixel dimension, allowing the display of 32 lines of 70 characters each. The font definitely takes some training and getting used to (especially recognition of characters that use descenders); but I found it to be quite readable after a while.

When you are at 4 by 4 you might as well use the entire 16 pixel space for every font, rather than worry about them lining up when lower case.

That way you can have a Q that looks like a Q:

    ***
    * *
    ***
       *

You do still have to worry somewhat about space in between characters; if it's missing too often, you can't recognize the character boundaries.

If subpixels don't count as cheating, you could maybe get away with 1 1/3 x 1 1/3 pixels https://github.com/tangmi/really-small-font

Although I'll admit (ab)using subpixels like this doesn't do good things for readability.

The smallest "readable" I've seen is 1x5: https://advent.blinry.org/2018/17

You can go smaller. Here I made 3x3, 3x4, 3x5:

https://twitter.com/tosuto_studio/status/1520071869529001984...

3x3 in your link is exactly same size as 4x4 in initial post. It's just difference whether you include required amount of space in the dimensions.

Edit: I was wrong. Some of Simplifier characters like j actually use full 4 pixel height and poke out of 3x3 block.

I get it, no problem. Some characters are extremely hard to make them fit in 3-4 pixels and I cheated on some too!

Looks like the text on some of the modern Atari 2600 games.

Simplifier's 4x4 includes both upper and lower case.

Yes, I was simply experimenting on how low you can go. I love small fonts! And Simplifier's one is clearly impressive.

Hats off to your experiment, it's still impressive :).

Its super hard to read. I don't like it. I generally like these low-fi fonts but this just doesn't lend itself to anything.

I could be a code mini-map thing. That would be perfectly reasonable.

Compare with the 3x3 Fakoo alphabet [1] discussed here earlier [2].

[1] https://omniglot.com/conscripts/fakoo.htm

[2] https://news.ycombinator.com/item?id=33092239

The thought was that maybe we can have "visual" alphabet the same as "non-visual" - that is, letters which are the same for both ways of reading.

If you want to go even smaller, the number of patterns that can fit in 2x4 would exhaustively represent all the values of a byte, although the majority of them will not be easily recognisable as letters without some extreme "applied imagination". At that point you might as well be reading raw binary.

1x5 https://dotsies.org

At that point you might as well just use morse code

That's closer to https://en.wikipedia.org/wiki/Baudot_code

Those who used a Commodore-64 and yearned for 80-column displays ended up using 4x7 or 4x8 fonts, in other words this font with more vertical headroom. It worked relatively well, good enough for me to use it to write many a report in a version of SpeedScript [1] I had modified to use 80 column text using just such a font plus the necessary code to actually use it. I could switch between 40- and 80-character mode using a key combination and tended to use 40-character mode while entering text, 80-character mode while formatting the document.

[1] https://www.c64-wiki.com/wiki/SpeedScript

I think some of the lowercase letters, and many of the symbols, aren’t recognizable in isolation, but we know that typical English sentences are read word-by-word rather than letter-by-letter, which might add enough context to overcome this.

Even smaller than in 80ies/90ies games. Like in Wing Commander.

https://en.wikipedia.org/wiki/Wing_Commander_(video_game)

Was that 5x4 (which would have been almost square with the pixel aspect ratio of 1:1.2)?

The uppercase version is kind of ok. I'm not a fan of the 9 or the D, but I think you'd quickly get used to that. What's even more impressive is that if you consider just uppercase and numbers, it's a 3x3 font.

I like this, it's like code golf but for fonts. It's cool that it can be done but not something I would use regularly.

I think the end game would be a 3x2 font that is basically Braille.

The linked font has 92 characters (lowercase, uppercase, digits, symbols, punctuation)

A 3x2 font can only represent 64 (2^6) characters.

So I guess part of the golfing would be defining what the minimum set of characters is.

BESM-6 had indicator of kernel registers - http://www.mailcom.com/besm6/ . Using economic font, one could provide more information directly to the user than if the font takes too many pixels.

In other words, we may have situations where the font size is at premium.

As much as I love bitmapped fonts I just don't know if there's one that supports unicode yet and since I work internationally it's kind of a sticking point in wanting to go all the way to using them in my terminal or whatever, even though it looks incredibly crisp. Is there anything like that out there which at least covers characters in latin alphabets with diacritics and cyrillic?

Unifont[0] covers a lot of Unicode codepoints.

[0] https://savannah.gnu.org/projects/unifont/

Once upon a time I made something like this [1]. It does cover most (precomposed) Latin and Cyrillic characters.

[1] https://github.com/lifthrasiir/unison

I'm impressed by how most of it seems to be for Korean. Didn't realize there was a code point for each combo in hanguel.

Fixedsys Excelsior?

I’ve often wanted to try and see how minimal one could make a font that covers some subset of Chinese hanzi, but I’ve never quite found the time.

I feel strongly that it should be possible to do this better.

4x4 box, yet most characters seem to be confined to 3x3 box. This can't be right.

The "character canvas" includes the space between characters and rows. Think about it like you have a fixed 4x4 grid into which you copy the 4x4 bitmaps without the possibility to offset them to create whitespace between the characters.

A humble attempt to make an even smaller but barely readable 3x2 font (probably the smallest possible) : https://zserge.com/posts/tiny-font/

Just what you need for a 44x46 character display on a VIC-20 with sufficient memory.

This is readable... if I zoom in. Might be good for screens that are extremely low-resolution, but large. Maybe something that isn't actually intended to be a screen or something.

Great for writing terms of service small print!

My eyes.

Nope.

Isn't everything on the page in a 3x3 grid?

Nope. Take a look at lowercase j.

It sounds to me like it should be possible to use a 4x4 grid but add a single bit to express whether the letter is shifted up or down by 1px. Then your characters are 4x4 but occupying a 5x4 space.

I dont agree with the capital D.

So 4x4 is too small for readable font

Seems 5x5 is the limit. 5x5 is perfectly readable to me, while this 4x4 one is not always very clear.

Example of 5x5: https://www.dafont.com/5x5.font?text=Small+fonts+have+always...

Nice but keep in mind that 5x5 font just punted on lower case letters entirely. So there are no descenders and they use the full 5x5 for upper case.

The 4x4 font has lower case, so it reserves the bottom row for descenders gjpqy. Its upper case letters don't use the descenders row so they're really 3x3, which is barely readable. It's actually interesting that the all caps 3x3 is almost readable!

For comparison it would be interesting to see a 4x4 all caps font, or a 5x5 with lower case.

Indeed, and for upper/lowercase there's a reason why 5x7 has become a de-facto standard for character LCDs; the letters EeMmWw all have 5 "elements" horizontally, and vertically you'd want more than 5 in order to distinguish upper/lowercase.

The submission is really a 3x3 font on a 4x4 canvas, but your linked font is a 5x5 font that would (presumably) be on a 6x6 canvas.

Tasword on the ZX Spectrum used a font that fitted into 4x8 (so the characters were 3 pixels wide). It wasn't brilliant by today's standards, especially given it would usually be plugged into an 80s TV. However, this allowed 64 character lines on a 32x24 screen.

I worked for Tasman Software and answered lots of phone calls and written queries, so I know it was the first word processor used by a great many people. I wonder how many are now blind.

https://en.wikipedia.org/wiki/Tasword https://en.wikipedia.org/wiki/ZX_Spectrum

Looks like the 5x5 example doesn’t even bother recreating lowercase letters.

This makes it completely unusable.

I mean, not completely. Lots of games use all uppercase so did many old computers. So, it’s got some potential uses.

Only free for personal use, alas.

If it's for commercial use, paying for a useful component should be plausibly reasonable?

Technically that is correct although when replying I had in mind use cases that are neither commercial nor personal.

I remember these from various forum signature prestige graphics lol

Uppercase is readable.

Only in context. Letters like B, D, E, G, O, M and W are just literal blobs of pixels without any indication of what the actual letter might be. You can only tell C and E apart if you know what the other one looks like. Even worse for lower case. See x for example.

THE QUICK BROWN FOX JUMPS OVER THE LASY OOO TED4PLTO7O TIMESY

I wonder if - and if so, how much - its readability improves with readers' experience with it.

Yes indeed. I am sure the author learned to read texts with this font quite fluently while working on it, and you'd learn too with little practice.

It's carp. The author should go back to art school(actually i bet he dropped out of engineering).

Found the index on my tiny screen: https://simplifier.neocities.org/index.html

Interesting! I read the about section. Does the author say who he actually is anywhere?

This is an interesting idea, but given how inexpensive the high resolution small SPI-connected LCD displays already are, this might not be a very useful solution.

Still good for even cheaper kit, or retro gear.

Unfortunately there’s no hope for upgrading it to full Unicode coverage, as 2^16 is less than half the number of Unicode characters :(

Reply on news.ycombinator.com