This project explores what happens when typography is broken apart into thousands of fragments and recombined into new systems of meaning.

Turning Fonts into Systems: A Creative Coding Project

Sometimes projects begin with a small technical curiosity. In this case, the question was simple:

Can we turn fonts into individual artwork files that artists can use?

Fonts are everywhere: on websites, posters, books, and apps. But inside every font file are individual shapes called glyphs. Each glyph is a letter, number, or symbol. forthe longest time i was calling them characters. What started as a small experiment in extracting those glyphs gradually developed into a much larger system for exploring typography, language, and fragmented communication. The project now sits somewhere between a software tool, a typography archive, and a generative art system.

The Raw Material: A Large Font Archive

The project began with a large collection of fonts. AKA our Source. And where do we all look for truth in 2026?

G O O G L E

Google Fonts alone contains nearly 1,700 typefaces, many of which include multiple families and style variations. For this project, the collection was carefully reduced and cleaned to around 1,170 distinct-ish fonts. This created a large but manageable dataset that could be explored computationally. conceptually but about all carefully. Once collected, the fonts were organised in two different ways.

1. Font-based structure

The first structure preserves the original typographic logic.

Each font sits inside its own folder, with each glyphs assigned to designated sub folders:

Uppercase / Lowercase / Maths / Symbols /

This keeps the typefaces intact as the designers intended them.

2. Character-based structure

The second structure reorganises the entire archive.Instead of grouping by font, all fonts are reorganised by character value.

For example:

A
a
&
£
5
?

Each folder contains every version of that character across the full font archive. This means you can look at hundreds of versions of the letter “A” side by side. Typography stops being a single system and becomes a collection of variations.

Characters as Families

The next step treats each character as its own “family.” as we went to work to take family portraits

All versions of:

A
a
&
£

become related objects.

Once grouped this way, characters can be remixed and recombined with each other. This remixing process uses the same generative engine we developed in earlier projects, including Remix and Lessons from Departure Stories. Instead of thinking about fonts as fixed systems, letters become interchangeable building blocks that when combined represent the whole.

Typography becomes something closer to a modular visual language.

Building the Extraction System

To create this dataset, we wrote a Python program that automatically extracts glyphs from font files.

The software can:

• load font files (.ttf and .otf)
• render individual characters
• export them as SVG or PNG images
• organise them into structured folders

The program includes a simple interface where you can:

• choose fonts
• select character groups (A–Z, numbers, symbols)
• add custom characters
• generate the outputs automatically.

When the system runs, it can produce thousands of images in minutes.

Across the full dataset, the system generated over 100,000 glyph images. (over a few days)

This is where coding becomes a creative tool.

Tasks that would be impossible manually become simple once automated.

When Fonts Collide

When letters from hundreds of fonts are placed next to each other, unexpected things happen. Different typefaces were never designed to live together. Their proportions, weights, and rhythms clash. This raises design questions about:

• scale
• proportion
• legibility
• visual balance

Sometimes the results look awkward or chaotic. But those clashes become part of the visual language of the project.