
Show HN: FontEdit – A desktop app to develop fonts for embedded systems displays - ayoy
https://github.com/ayoy/fontedit
======
t0astbread
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!

~~~
derefr
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.)

~~~
t0astbread
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.

------
pan69
Very handy.

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

[https://int10h.org/oldschool-pc-
fonts/fontlist/](https://int10h.org/oldschool-pc-fonts/fontlist/)

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

[http://robhagemans.github.io/monobit/](http://robhagemans.github.io/monobit/)

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

[https://github.com/robhagemans/hoard-of-
bitfonts](https://github.com/robhagemans/hoard-of-bitfonts)

------
karmakaze
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.

~~~
ayoy
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/](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.

------
andrewshadura
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](https://github.com/kreativekorp/bitsnpicas)

~~~
ayoy
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.

~~~
andrewshadura
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

------
roland35
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/](http://en.radzio.dxp.pl/bitmap_converter/)

------
maxbaines
Windows also has a built in 'Private Character Editor'
[https://www.howtogeek.com/163197/create-your-own-custom-
char...](https://www.howtogeek.com/163197/create-your-own-custom-characters-
or-fonts-with-private-character-editor/)

------
jasonhansel
This kind of reminds me of IcoFX ([https://icofx.ro/](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.

------
spongeb00b
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.

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

------
masnao
nitpick: font sprite editor.

~~~
ayoy
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.

~~~
viler
'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'. :)

~~~
RoryH
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.

------
RL_Quine
Well done.

------
skrebbel
Or for oldschool demos!

