I have noticed that the license doesn't allow you to use the TTFs in open-source software, which is something to keep in mind.

> Licensed Content may not be distributed to third parties as standalone files or in a way that unreasonably permits the recipient to extract the Licensed Content for use separately and apart from the Work for Distribution.

> Licensee may not distribute the Licensed Content in any library or reusable template, including but not limited to game templates, website templates intended to allow reproduction by third parties on electronic or printed products.

> Licensee may not distribute Licensed Content in a manner meant to enable third parties to create derivative works incorporating Licensed Content.

To me, a non-lawyer, the last clause reads like it unambiguously forbids it.

https://github.com/ChevyRay/pixel_font_megapack_license/blob...

Though clearly the intent is that these be used more in the final product stage of the kinds of things that are more rarely open source, games vs. engines or templates.

I found myself thinking about a different copyright corner-case when reading the post and this question: the fact that typefaces aren't copyrightable in the US. Fonts are, as computer programs, but typefaces (and so also fonts that are simple bitmaps) aren't. So this workflow goes from a non-copyrighted source, (the original tilesheet) to a copyrighted output (the TTFs) and also back to a non-copyrighted output too (the output tilesheet/atlas).

According to https://en.wikipedia.org/wiki/Intellectual_property_protecti..., typefaces also aren't copyrighted in Japan and South Korea but are in Germany (for no more than 25 years) and the United Kingdom (also 25 years). So bitmap fonts from classic 8- and 16-bit video games should be in the public domain in all of these countries.

> My new fonts were going to support 176 characters, meaning I might have to enter as many as 176² = 37,976 kerning pairs... yeah not going to happen. So this time, since I was (spoiler alert) writing my own tool to generate the fonts, I decided to semi-automate this process to take care of a huge majority of the kerning, and do manual entry when algorithm didn't suffice.

That's when you're limiting the font to purely English usage. If you want to support any other language you have to add more characters, even for languages that also use the latin alphabet (e.g., French, Spanish, Italian, Portuguese, etc). Then you may want to support Greek and Cyrillic, Japanese, Chinese, …

For example, “Noto fonts cover over 77,000 characters, which is around half of the 149,186 characters defined in Unicode 15.0” according to the font's Wikipedia entry.

Truly a rabbit hole, but when it's done well it's very worthwhile. I have a lot of respect for font makers.

I'm sorry I just don't buy this. Its possible to endlessly obsess over anything. I've noticed things like language/writing/music/calligraphy tend to have high draw to people that are prone to obsessing.

It sounds like gatekeeping to me is my point. Discouraging people from entering a field always makes me a bit triggered.

Western fonts derive from Roman lettering which were carved in stone. The dedication inscription at the bottom of Trajan's Column is arguably the most sophisticated example of this. The text at the top of the inscription is larger than that at the bottom so as to appear perceptually uniform from the point of view of the viewer (who is located significantly below the inscription).

Letter forms are weighted towards the bottom. The designers of Bauhaus (who were very reductive in their thinking) tried to do away with this and produced super-regular typefaces based on squares and circles. They quickly realized that this produced a result that humans find unappealing and unreadable.

The digital age saw the adoption of characters that were dimensionally uniform (i.e. monospaced fonts), such as employed in the comment widget of HN. Of course such fonts are easy to digitally express, but as I am sure you will agree for a printed document the effect is clunky and lacks flow.

It is this ongoing dedication to form, structure and readability that is at the heart of effective typography.

I am not a typographer, but have worked with many in my job. I often mock-up page layouts and show it to my designer for their approval. Of course, I think I have done a marvelous job, but their response is always the same: 'yeh, really nice. However, maybe you change this space, this color, this font etc etc'. The result is always 100 times better.

There are three extended chars in Swedish (äöå) and Norwegian/Danish (æøå), but your fonts have æ, but not ø, which means you could drop the æ and still support Swedish, or add an ø to also support Norwegian and Danish. Was this an oversight or is there some locale that has just æ and not ø? (and before anyone asks I did not confuse æ with the oe-ligature œ, which is a different glyph used in French, and which the fonts also do support)

It’s something that I could definitely go through and patch into all the fonts, but I was waiting to see if there was enough demand for the effort. I think supporting two more languages would be very cool though.

In the same vein as VVVVVV or nidhogg or canabalt as I recall

Da Vinci types like the author here always remind me that there was a time when being an artist and an engineer were one and the same, with no clear distinction between the two.

Amdahl’s Law still gets a vote, but at least your app won’t blow up in your face.

I'm wondering if you're referring to the async await addition from a few years back, to use of Tokio's crate(s), or something else.

In other languages those violations are things you have to run a race detector and actually evoke the condition to find, or you abandon fine grained/tracked ownership and use garbage collection.

It's easy to forget how fast on-the-ground languages like Rust and C++ and Go are, not to mention when you use their multi-threading primitives and worker queues/etc.

Question: Did you find that your automated kerning generator was always satisfactory? Or did you ever catch letter pairings that technically satisfied the criteria but that tripped your subjective kerning radar? I'm wondering if you had to hard-code kerning exceptions, or if your system even allowed for that.

I find typography resists my attempts to wrap my head around it, because even though I can do basic analysis like serif vs sans serif, I get a sort of brain fog when it comes to telling fonts apart or intuiting which fonts to use in different situations.

It's really hard to wrap my head around the idea that one person could make 175 fonts and that they would each be meaningfully different from each other. Like, how does one not accidentally recreate the same font?

Where do the people who use them become of aware of them and how?

After that wave, they get used in various projects here and there, and those projects eventually release or post screenshots. Because it's indie, lots of people also attribute the fonts directly when they post screenshots of their games, posters, videos, and stream overlays where they use them. I am very supportive of people using them, and repost their work, and so it's very casually symbiotic.

They're not lucrative on the scale that you might expect from a company or a popular vector font, but as supplementary income for a solo developer what they bring in helps put food on my table and also helps indie games get made which I think is great.

In the "mixed-case kerning pairs" quality testing image, I notice that the letter "j" sometimes reaches under the previous letter, like in "Fdj". Sometimes it creates a lot of space, like in "Fjo". Is there a stylistic reason for this? The Fjo spacing is the only thing that stood out to me.

Kudos

I added this parameter because I fouund that for a lot of fonts, squeezing letters together over a certain distance would just look bad, so I would set -1 or -2 as a cap.

It looks like that's just one that snuck past my notice. The word "Fjord" would look strange because of this. This is a good example of how even with the quality testing, things can get through, because I still have to visually glance over hundreds of kerning tests.

One thing that might be a nice adjustment is to have an algorithm that detects the "area" between two letters, so basically how many pixels can volumetrically fit between them, and flag ones that go over a certain threshold. I could then color those tuples as red in the sample text, basically the system marking them as "potential problems" that required an author's look.

Usually the way I do things is I start by doing work manually. If I find that there's a common pattern in something I'm doing that could be automated, then I am able to transcribe it into the algorithm because I just follow the same steps I've been using in my head.

This wasn't a thing that actually came up a huge amount, as these glaring pairs aren't tremendously common. But they're just common enough that if I sat down and examined them, I could probably say something like "hey if 1.5 vertical lines worth of pixels are between two letters, kern this extra" or something like that.

It also creates a tendency to use quite light font weights for all-uppercase text, so that whitespace is not so prominent.

That kind of thing is another level of polish that I could definitely do, or even just providing more spaced variations.

8 Billion people seems like a lot, but it cuts down fast. When 1/10 people have the freedom and, 1/100 the resources and time, 1/100 the training and experience, and 1/100 have the drive, and with hundreds of domains each with hubdreds of major unfilled niches...

That's 800 people split among tens of thousands of gaps. It pretty quickly gets down to you, the reader, to pick up that keyboard and start tapping away!

These are obviously wild-a* numbers. Constraints may be overstated or understated & they're not fully independent. I'm missing others. The point stands: you need only to cut 8 billion by 100 a few times to get <1.

Looking forward to trying this exciting rust tool in my chain as well to see what additional formats I can include.

(Update: Seems the PIFO tool is not open-source :( I guess I'll stick to using scripts + FontLab Studio 5)

I've done fonts in both categories.

These look to be variable-width fonts. I believe the heights are multiples of 16, but the width will vary by character.

I agree that it would be overall more valuable to have the whole thing open source online, but sometimes I want to share how I solved problems without open sourcing all my code directly, for various personal reasons. But from the many comments I'm getting across the internet on the article it seems like people are getting a lot of value and motivation out of it, which was the intent, so that makes me happy.