Show HN: FontEdit – A desktop app to develop fonts for embedded systems displays | Hacker News Reader

Show HN: FontEdit – A desktop app to develop fonts for embedded systems displays

github.com

130 pointsayoy23 comments

Only tangentially related but I've recently looked into how fonts usually work (OpenType, TrueType and the like) and it's astonishing to me how complicated this all is.

For example: TrueType includes the ability to embed small executable programs in your font to adjust little details in the rasterization process (I believe it's called "hinting"). It has its own VM and bytecode for that!

If you really break it down, a font is just a pixel shader that happens to embed its own texture atlas.

(I wonder if we could achieve a win by actually having a font-format that is just an abstract pixel shader that could be handed off to the GPU driver for compilation? Either way, we'd probably just pre-render glyph tiles to a texture, so I'm not sure it'd make much of a difference.)

I wonder if we could achieve a win by just deprecating OpenType with its weird custom database format and having fonts be ZIP files with images and a JSON manifest (or shaders and a manifest, whatever). The manifest could contain all the meta-information and information about ligatures and kerning and so on.

Very handy.

For anyone interested, there is a nice collection of system fonts available on int10h.org:

https://int10h.org/oldschool-pc-fonts/fontlist/

Thanks for the mention - I should note that there's a rather large update coming soon, with even more of them. :)

There's also a bigger pile of system/bitmap fonts in raw binary format, included with my DOS-based font editor (https://int10h.org/blog/2019/05/fontraption-vga-text-mode-fo...). Perhaps more pertinent to this thread, since the format is natural for embedded systems/direct video chip usage.

By chance, yesterday I was exploring tiny bitmap fonts and found this collection:

http://robhagemans.github.io/monobit/

They're in some kind of human-readable text format:

https://github.com/robhagemans/hoard-of-bitfonts

I love this.

When I was learning to program games in my teens on the Atari 8-bit, one of my favorite passtimes was making fonts and sprites. This takes me right back in time. And I can use it for mini game assets, maybe tiny raster fonts for code (like log windows). Thanks for making it and sharing.

Thanks! That's right, and I haven't even thought about it at all. So cool :)

It's a hobby/educational project, but I'm happy to see it solving some people's problems. I once wanted to add a good-looking font to my e-paper display for the air quality monitor project and I stumbled upon a simple MacOS app that converted images with text to byte arrays (https://luckyresistor.me/font-to-byte/). I picked it up, updated to Swift 3 and adjusted to my needs. When I blogged about it, somebody complained that it's MacOS only, so I decided to rewrite it in C++ with Qt (learning some modern C++ on that occasion).

The app was still quite cumbersome as it required you to prepare input images in external software like GIMP or Ps, and people had a hard time understanding the process. I was being asked repeatedly to help generate an image for a given font, so I figured out that the app could (should) be generating those input images programmatically. From there I added a minimal graphical editor to allow making corrections to auto-generated bitmaps (or drawing ones from scratch) and here we are.

Last but not least, I had a great fun learning C++17 and writing a template-based source code generator.

While this is cool, I think it would be better to write a set of convertors to and from well-recognised formats like BDF. There are far more professional tools that work with those, e.g. gbdfed, FontForge and Bits'N'Picas:

https://github.com/kreativekorp/bitsnpicas

Thanks for sharing that, I'll have a read. Knowing very little on the subject, I was missing the keywords to duck-duck-go for to find any info on the topic of generating font sprites for embedded systems.

I myself had written a tool like yours for a similar purpose except I needed it done quick'n'dirty, so I wrote it in C with GTK and just used a grid of toggle buttons :D

It all went fine until I needed a variable width modern-looking font, so I wrote a convertor from BDF to the proprietory format the video chip used (vertical middle-endian scan lines arranged in a weird order) and generated the BDF using gbdfed or FontForge, I don't remember which one. I must admit the convertor was horrible :D

Interestingly enough, when I needed fonts/sprites again in a couple of years, I resorted to a set of multi-layer GIMP files with a set of rulers and grids which I would export into the X bitmap format (which is a text format consisting of a bunch of C constants). (I didn't need to dynamically generate text on that project, just fixed pre-prepared strings.)

Thanks, this looks very nice! A similar tool I've used before is LCD Assistant, but there are several limitations (and I had to use MS Paint to create and edit the bitmaps). http://en.radzio.dxp.pl/bitmap_converter/

Windows also has a built in 'Private Character Editor' https://www.howtogeek.com/163197/create-your-own-custom-char...

This kind of reminds me of IcoFX (https://icofx.ro/), which I recommend for pixel-by-pixel editing of small graphics. I'm wondering if this project could turn into a FOSS implementation of the same concept.

Well timed! I'm working on an LED matrix project and wanted my own font that would fit my specifics. Started writing something like this using the canvas element and JavaScript, but this should save me.

Much needed. Fonts are such a pain on embedded systems. Congrats on shipping.

nitpick: font sprite editor.

Perfect, thank you. I struggled with the naming the whole time, and I seriously hate the current project name, but decided to ship it anyway.

'FontEdit' was also the name of a program published in PC Magazine eons ago, for creating VGA text-mode fonts in executable format. There were probably others that shared the name, but that's the one I actually remember typing in from the magazine printout(!), and it's the one that got me started fiddling with fonts.

I can appreciate the naming struggle - I had to resort to calling my own editor 'Fontraption'. :)

I too remember this.. back in school we used to create fonts with messed up characters (backwards/upside-down/invisible) and load them into the autoexec.bat ... Confused a lot of people.

Well done.

Or for oldschool demos!

Reply on news.ycombinator.com