Bitmap fonts may not be copyrightable (in the US at least) due to a quirk of copyright law:

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.

This would explain why that 8-bit arcade font (it's in numerous Namco and Atari games) that's everywhere in 70's and 80's arcade games was everywhere.

I thought the same, but this book [0] absolutely staggered me by the creative ways people made 8 by 8 fonts

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

I used to sketch 8x8 bitmap fonts on graph paper using circles four to a square when I was in junior high. I spent a lot of time trying different combinations.

Well also there aren't that many ways to make a legible font using 8x8 (actually less, for spacing) pixels :-P

That font has some unique characteristics (such as the lopsided S and 8). It's not like the Signetics based font from Apple I/II which is very basic, for example.

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.

FWIW, the reason all of the vertical elements in the C-64 font are two pixels wide is to compensate for raster blur on televisions that were common at the time.

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.

I made an 8x8 font that was inspired by Broadway [1] and it ended up in most of the company's video gaming machines back in the 80's.

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

Don't leave us hanging! Tell us more, which games, which company?

While not public domain and not relevant to the specific issue at hand, IBM Plex is a font released by IBM as open source and under a very permissive license.

It's also quite nice.

I don't think font geometries are copyrightable, only names.

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

Genuinely curious!

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!

Thank you. I'm partial for that certain modern sans-serif look, as you may have guessed.

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.

Honestly, I would find it extremely limiting if someone was able to copyright 1664 bits of information. Bitmap 8x8 fonts are absolutely trivial. In one afternoon anyone could make every human readable variation.

Thinking on it: 1664 bits is 26 * 8 * 8, which is a little low. ASCII uses indices 32 to 127 for visible characters, so this would be 95 * 8 * 8, or 6080 bits. It's still a trivially small amount of information and there are very few ways to make unique English fonts out of it, so I still don't think it should be possible to copyright it.

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)));

So I went on a bit of a rabbit hole on this one. The above code is wrong. I have since fixed it. It's the same idea with some added terms to normalize for data size.

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;

Counterpoint, 2^638 is a large number. So a particular 638 bits is very particular.

This is meaningless. Information is information. Specifying a size has virtually no information. The number "638" stored in uint16 has two bits of information using any word size between 8 and 15 bits.

128 bits a reasonable bound for "nontrivial information" (information you'd never arrive at by guessing). 1664 bits is enough to write a short poem.

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.

The size of the work doesn't matter. What matters is what it is. This comment is protected by copyright and is 1048 bits of UTF-8.

Names of things can be protected by trademark, not by copyright.

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.

As a bitmap, there is only one possible representation for that geometry at that given size, so I'd assume it's not possible to protect it.

It is my understanding that typeface hint systems such as those in Adobe Type 1 and TrueType are "programs" for the purposes of copyright law. But I'm not a lawyer, and I would be interested to hear expert opinions. It used to be my interest to deal with typeface hints.

perhaps they thought the serifs would be better suited for word processing

Oh, wow, I haven't thought about simtel in decades. wsmr-simtel20.army.mil. That's a blast from the past.