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.
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
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.
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.
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.
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.
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.
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.
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 :) )
>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.)
>Created for the Apple II program The Terminal. Copyright (c) 1981 Michael C. Koss
>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.
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.
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.
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.
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.
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?
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.
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.
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.
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.
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.
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.
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.
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.