Am I allowed to make stroke fonts (single-line fonts) which take a cue from JuliaMono?

This is an issue that should be resolved privately with @cormullion, but I’ll note it here because I’d like to hear what other developers have to say.

(Edit: Incidentally, I sent this topic to the community category because I believe that JuliaMono is both a great product of @cormullion and a valuable (and non-exclusive) asset of the Julia community.)


I’ve been kind of frustrated with text rendering in Julia ecosystems since before JuliaMono was released.
That means that if we’re trying to achieve “OS-independent” text rendering, there’s practically only one solution we can use: FreeType. It’s a good tool in general, but for the purposes of annotating images for debugging, for example, I think the footprint of the FreeType, the packages to use it and the font data is too huge.
For such use cases, BasicTextRenderer.jl is useful. However, the disadvantage is that we need to prepare pre-rendered images.

So I thought that stroke fonts, rather than richer fonts like OpenType fonts, could be handled Julia-natively. (It’s just a concept; no such framework exists yet.:sweat_smile:)

To the best of my knowledge, many of the existing stroke fonts have obscure licenses or are not compatible with the MIT license. (Edit: In particular, it is usually not stated whether irreversible format conversion is allowed.) Therefore, I thought it would be a good idea to have open-source and free stroke fonts (for Julia developers). I wanted to create two fonts: “JuliaStroke”, which consists of straight line and circular arc elements, and a simplified version, “JuliaPolyline”, which consists of only line elements.


While I was thinking about that and working on something else, the brilliant font JuliaMono was released!

So, am I allowed to make stroke fonts which take a cue from JuliaMono? The figure below shows the prototype.
Top: JuliaPolyline (prototype), Bottom: JuliaMono Light

Now, there are “ethical” issues here which stem from technical issues.

The stroke fonts cannot fully replicate the beauty of JuliaMono. For this reason, I’m not going to adopt the approach of converting JuliaMono data to create the stroke fonts. As a result, the stroke fonts do not contain any data (or reserved names) derived from JuliaMono “data”, so the license based-on “copyright” does not restrict the stroke fonts.

Therefore, there is an ethical issue here of how much to respect the type designer’s intentions. It includes: whether or not imperfect imitation is allowed in the first place, how to handle the “formal” license, etc.

As noted in the background, the goal of the stroke fonts is very different from the goal of JuliaMono (except in terms of benefit to the Julia community). I think it would be better to create the stroke fonts as a separate project from JuliaMono, but I’ll defer to the type designer’s opinion on that as well.


Regardless of our conclusions about the relationship with JuliaMono, I’m going to gradually move forward with Julia-native support for stroke fonts. If you have requests or useful information please wirte them on this topic (as there are no public repositories for this project on GitHub yet).

I can’t devote a lot of time and effort to this stroke font project, so if anyone else has a strong interest in this project, I’ll be happy to assist them. :smile:


Despite your “frustration about fonts in the Julia ecosystem” there is not much information why you feel this is so important. This is my question: What is so important and frustrating?
For you to understand my question: I have never thought about it, nor did I ever felt, that I have a problem with fonts when I use Julia.
And what is the difference to other programming ecosystems? Is there a wide variety of python fonts, or R fonts?

1 Like

Sorry for the lack of explanation.
First of all, as an important correction, I am frustrated with the hassle of “text rendering”, not the “font” (typeface).

And I don’t see it as an important issue.(It’s just that it’s a source of frustration for me.:grapes:)

It’s not a problem specific to Julia. If I want to put text on a single still image, I use Photoshop or something. Wouldn’t it be nice if that could be completed in just Julia?

1 Like

Yes — because human conventions for printed text are terribly complex.

AFAIK stroke-based fonts is a niche application that never really took off. Given the relative unavailability of such fonts, I am not sure that investing in a Julia-based renderer makes a lot of sense. That said, if you want to explore this,

  1. MetaFont is kind of a stroke-based font and you can find free fonts (of various quality/character coverage) on the web,
  2. you can just save paths from a free monospace font in a format you like at a given resolution/weight (there are tools for this), and apply that.

Probably there is no strict definition, but I think the so-called stroke-based font is different from the stroke font. And I don’t think that stroke fonts themselves, such as the one I showed you a prototype of, are by any means niche even today.

The METAFONT specification is a bit too rich, but as an exchange format it’s worth supporting.

My goal is not to support stroke fonts, but to get a means of text rendering with a smaller footprint.

Sorry, then I don’t understand what you mean by “stroke font”.

I don’t think so, it is essentially a mathematical language for generating glyphs using (implicitly defined) curves, not an ideal exchange format. Frankly, pretty much no one really uses it today.

I think in the long run it is best to just bite the bullet and deal with contemporary font specs.

A “stroke-based font” has outlines which corresponds to the shape of a “brush” (as described in the Wikipedia article). The ”stroke font" I’m referring to is the stroke paths themselves, and does not have the shape of a brush. Usually the brush shape is drawn as a circle, but that’s up to the implementation of renderer.

I think the term you are looking for is “single line font” or “plotter font”, used by engravers and plotting machines. You can find plenty of these online (again, limited character coverage etc). Eg


Thanks for the advice. I’ve added it to the subject.

BTW, I wrote the parser for the AutoCAD SHP file (not ESRI SHP file). Also, functions to convert SHP shapes to SVG have been implemented.
Here are examples of the Simplex font.

However, it will be a long time before those features are available as a registered package. I will privately seek advice on the new fonts.