EBGaramond (original Duffner version) was made with fontforge and is on github. He only keeps the source and related files on github with instructions how to generate the otfs etc.
https://github.com/georgd/EB-Garamond
this post was submitted on 11 Mar 2024
35 points (97.3% liked)
Open Source
31224 readers
278 users here now
All about open source! Feel free to ask questions, and share news, and interesting stuff!
Useful Links
- Open Source Initiative
- Free Software Foundation
- Electronic Frontier Foundation
- Software Freedom Conservancy
- It's FOSS
- Android FOSS Apps Megathread
Rules
- Posts must be relevant to the open source ideology
- No NSFW content
- No hate speech, bigotry, etc
Related Communities
Community icon from opensource.org, but we are not affiliated with them.
founded 5 years ago
MODERATORS
Store the fontforge file and a Makefile to generate TTF and other formats in git and provide an archive with generated fonts as a release.
Share the code that can be edited.
Release .ttf, .wotf or .otf in form of releases for people to download them. Or dont, and let users do that themselves.
Make sure to include screenshots haha.
I think the most important step is to get it out there. So:
- Choose a license. These resources might help:
- https://fontsarena.com/licenses-explained/
- https://choosealicense.com/
- https://opensource.org/licenses
I'd stick with the licenses made for fonts or in use by other font projects, as there are some specifics to fonts licensing.
-
Choose a name
-
Sign up and create a repo. Upload your project.
That is the "get it out there" step. If you want to be open, generally speaking you want to include a LICENSE file, your creation in the format you're editing it and other people can load and edit it, too. And the exported file in case of something like this, so people can directly use it without learning how to convert a font into a format that is usable. It's also good practice to include a README.md with explanations and a summary of what this is.
I think that's a sound approach for open source. And it's generally alright to learn as you go. Even if you don't get everything perfect at once, the most important thing is that it's available. People might pick up on it. And they will file bug reports and issues if they like it some other way. So you'll be directed into the right direction anyways. And once you have something to show off, you can start talking about it or make people aware of its existence.
(And maybe skip all the boilerplate and complicated extra stuff at first. You don't need an AUTHORS file, no code of conduct, no documentation if there isn't anything complicated to explain... Just stick to the important stuff and don't make it unnecessarily complicated and distracting for your users.)
The thing is, could an otf or ttf file be considered a file suitable for the free modification and redistribution of a font? That's the question I have, because for me, sharing any of those file formats is not enough for a font to be considered open source, especially since those two files are binary. Would I have to share the sfd file that fontforge generates so that the font can be open source? Because that file is editable through a code editor
I think the more important file is the fontforge one. As this is the thing people can edit and build upon. (the "source")
The otf, ttf and woff are just a bonus for people who don't want to install fontforge and and go through the process of exporting it themselves.
Ultimately it's your decision what you release. It's a similar concept whether you share a cake, or a recipe for a cake. The free software / open-source movement is concerned with sharing the recipes. That's why they share source code and files in the format they've edited it in. (And often include instructions on how to build it, since that is usually a bit more complicated with software.) It enables people to also load it in their editors and customize it, adapt it to their use-cases and fix issues.
You can also just publish the end-result, which are the otf and ttf files in your case. But people can't really modify or customize those. It'd be called a freeware font, then. It'd help people who just want to use it, but doesn't provide much more.
I'd invite you to upload both the sfd and the resulting otf and ttf. Usually that's how people do it. Distributing digital files comes at practically no cost. On the internet you can share a recipe and the actual cake alongside at no extra cost.
Ok, thanks for the clarification, I needed it, now with everything clarified, I can make a description of the directory. There are 3 types of folders, images to show the fonts in images, fonts for the ttf and otf binaries and finally sources for the sfd files, which would be the source code of the fonts, outside those 3 folders, there would be Makefile, README and the license. Thanks for the help, now you can make the directory in an organized way
It wouldn't technically be open source if it was a binary, but it would be freely-licensed.
I have more of a question than an answer - is the Monaspace repo a good example of how to do this properly, or a bad one?
It includes generated font files together with sources. There's no point in storing them in VCS. Instead of this, the repo should contain scripts to generate font files from sources.
This font was made with glyphr. In a conventional program (Let's say that this program is made in C), for it to be considered open source, the c file that contains the code has to be distributed, outside of that, there is the compilation file and additionally a README, in fonts it is different, the majority use a different programming language from one to the other to create the typography, and the only way I see that a font made in fontforge can be considered open source is for it to be shared the sfd file that fontforge generates when saving the font, this file is editable in a code editor, not like other files such as otf or ttf, which are directly binary
I'm not familiar with creating fonts specifically, but you'll want to commit any resources necessary to recreate the font file, including any build scripts to help ease the process and instructions specifying compatible versions of tooling (FontForge in this case). Don't include FontForge in the repository, of course.
The compiled font files should be under releases in GitHub for the repository.
Git isn't generally meant for binary resources but as long as they're not too large, they'll be fine. You just may not have meaningful ways to compare changes easily.