[0] https://int10h.org/oldschool-pc-fonts/fontlist/#ibmvgamcga

[1] https://www.dafont.com/nouveau-ibm.font

"qemu seabios 8x8 and 8x14 are exact matches to IBM's VGA and XGA fonts. These files are in fntcol16.zip from simtel. VGA-ROM.F08 and VGA-ROM.F14. qemu source comment claims this is public domain. I doubt IBM would release a font to public domain. Does this mean, qemu relied on claims by package creator and now they use a illegal copy?"

https://www.crowdspring.com/blog/font-law-licensing/

> Generally, copyright law in the U.S. does not protect typefaces.

> Fonts may be protected as long as the font qualifies as computer software or a program (and in fact, most fonts are programs or software).

> Bitmapped fonts are considered to be computerized representations of a typeface (and are not protected by copyright law).

> On the other hand, scalable fonts (because they are incorporated as part of a program or software) are protected by copyright.

[0]: https://www.amazon.co.uk/Arcade-Game-Typography-Pixel-Type/d...

Also if you look at all the ways letters and numbers have been drawn in C-64, NES, Genesis, and SNES games; there's lots of room for creativity and design even in an 8x8 space.

If you made a vertical line only one pixel wide, on many televisions like the Panasonic I used it would be nearly impossible to see.

And while color monitors of the day were an improvement, they still weren't what we would consider acceptable today. I eventually upgraded to a Commodore CM-141, and single pixel vertical lines still weren't great.

[1] https://en.wikipedia.org/wiki/Broadway_(typeface)

It's also quite nice.

In any case, the IBM PC fonts are horrendous. They should have gone with the sans-serif they used in their mainframe terminals.

Are you talking about AFP fonts[1]? In that case Sonoran Sans Serif[2]? Then you should probably be happy with Arial[3]. Fun story[4].

Or are you talking about a 3270 font? Then you should have a look at 3270font[5]

[1] https://www-01.ibm.com/servers/resourcelink/svc00100.nsf/pag...

[2] https://www-01.ibm.com/common/ssi/cgi-bin/ssialias?subtype=c...

[3] https://en.wikipedia.org/wiki/Arial

[4] http://idsgn.org/posts/sonoran-the-hidden-truths/

[5] https://github.com/rbanffy/3270font

...and then I saw the username i was responding to. I'll post anyway if you do not want to toot your own horn. Nice work!

BTW, that IBM bundles Arial with their mainframes is outrageous. If you are paying more than a million dollars for a machine, you should be getting proper Helvetica.

Looking at the actual IBM_VGA_8x8.bin file: the file size is 1024 bytes (8192 bits). I calculated the entropy of the data to be only 638 bits of information.

MATLAB code:

  fid = fopen('IBM_PC_BIOS_1981-04-24_HALF_8x8.bin','r');
  ibmVga = fread(fid);
  fclose(fid);
  p = histogram(double(ibmVga),255);
  E = -sum(log2(p.Values(p.Values > 0)).*log2(p.Values(p.Values > 0)));

Word size matters when calculating entropy. Calculating entropy on this file using 2 to 64 bits nets a minimum information of 860 bits using a 64 bit word size. Moving past a 64 bit word size requires rethinking some things. MATLAB doesn't have great support for data sizes greater than 64 bits (and I'm certain the performance impact would be great).

  words = double(unique(X))';
  binEdges = [words-0.5; words+0.5];
  binEdges = unique(binEdges(:));
  P = histcounts(X, binEdges) / M;
  P(P == 0) = [];
  M = numel(X);
  H = -sum(P .* log(P) ./ log(max([nBits, 2]))) / nBits * log2(max([nBits, 2]));
  E = H * M * nBits;

However I don't think a 1664 bits is an accurate count. You must subtract the information provided by knowing it represents the alphabet, which constrains the number of possibilities to only a few choices per letter - say 2 or 3 bits at most. So a 64-character alphabet is right on the edge of "reasonably nontrivial", due entirely down to the combinatorial complexity of choosing which glyph to use in each case. A single glyph should not be copyrightable.

re: copyright-ability of fonts. That's a muddy area. The visual representation of the font cannot be copyrighted. I can make a font that looks like yours with no copyright concern. If I copy the code that creates the visual representation (i.e. the binary definition of the font) that may be a concern. That could be considered program code (particularly for vector fonts, but I could see an attorney trying to argue that for bitmaps, similar to assets for a game), which is protected by copyright.

[1] https://github.com/spacerace/romfont/tree/master/font-images

[2] http://dwarffortresswiki.org/index.php/DF2014:Tilesets

Are there pictures of the fonts? I didn’t see any.

Then I got my first VGA output with a 386.

The exclamation mark was now curvy and sexy! Thick at the top, curving down to a point, finished with a round dot. I thought everything was right in the world.

I miss that font.

I've tried reusing bitmapped fonts that give me my desired output but I find it just doesn't work in enough places that it's too annoying. Maybe it messes up curses output, or UTF-8 incompatibilities?

VGA (in typically used character modes) had more bits per character, and its fonts didn’t have to be designed to be legible when displayed on a television set (screen not designed for text display, and signal converted to antenna signal and back)

Also, are you sure about that “round dot”? https://github.com/spacerace/romfont/blob/master/font-images... doesn’t show it, and any non-squareness would require a width of at least 3 pixels (more likely 4) to draw.

I don't doubt the C64 designers did the best with what they could; but I was absolutely impressed with how good the "!" looked on that VGA screen.

Then you must have missed the atrocity that was the Commodore's @ symbol.

None of the early computers did a good job with it. I remember the Tandy machines were particularly bad.

Heck—if you spent years reading your terminal upside down, you'd get very good at that too. Eventually you might get nostalgic for it.

https://wiki.osdev.org/VGA_Fonts

http://reboot.pro/topic/19076-grub4dos-menu-font-type/

I've made upscaled versions for high-density displays and a truetype version, with contributed postscript: http://sciops.net/downloads/vga/

http://pelulamu.net/unscii/

If the Fontstruct thing is better or easier, the author might benefit from a pointer to it.

Also it was mentioned that the https://int10h.org site has its own article on the method they used, but I can't find the link now.

https://github.com/Swordfish90/cool-retro-term

Sorry for the music in this video, but cool-retro-term really is a thing of beauty:

https://www.youtube.com/watch?v=jWx7REAQ2MY

Also iirc the authors went to some lengths to accurately simulate the effects of phosphor—which is also a topic in game emulation (in the spirit of https://pics.me.me/what-indie-developers-think-what-retro-ga...).

like real vector fonts, like those found in old arcade games like Omega Race

https://www.arcade-museum.com/game_detail.php?game_id=8920

it would look like this:

https://www.arcade-museum.com/images/118/1181242142159.png

Of course, it's not only the font, but the whole technology (analog devices have analog responses etc). But some looked really nice.

Is there any resource with non-PC terminal fonts?

It draws the eye and usually I get at least one person commenting on the nostalgia factor of the font, which means they will remember that part of the presentation.