Autoglyphs are the first “on-chain” generative art on the Ethereum blockchain. They are a completely self-contained mechanism for the creation and ownership of an artwork.

Autoglyphs are an experiment in generative art, each one unique and created by code running on the Ethereum blockchain. The glyphs were originally created in 2019 by anyone who was willing to donate the creation fee of 0.2Ξ (around $35 at the time) to our chosen charity, The creator of each glyph became the first owner of that glyph. After 512 glyphs were created, the generator shut itself off forever and the glyphs are only be available on the secondary market.

Now that we have deployed the project to Ethereum, it is important to note that we no longer control the code that generates the art, nor the code that manages the ownership of the glyphs. This is a crucial difference from art that is editioned and sold by an artist or gallery. It allows a long-term guarantee of ownership, provenance and edition size that is independent of any central authority.

Technical Details

The Autoglyphs are a highly optimized generative algorithm capable of creating billions of unique artworks, wrapped inside an ERC-721 interface. While ERC-721 is the standard for “non-fungible tokens” (something that the CryptoPunks helped define), it is generally used to manage ownership of digital items stored elsewhere. The key difference with the Autoglyphs is that the art is inside the contract itself, it is literally “art on the blockchain.”

This becomes obvious if you examine any glyph creation transaction on the blockchain. The event data contains the full output of the generator, and hence the artwork itself. See here for an example. It doesn't look like much as hex data, but it encodes a character art pattern. This pattern can then be drawn to a screen or even on paper by following the written instructions in the comments of the smart contract itself.

The Creation Fees Went to Charity

All proceeds from the creation of Autoglyphs were donated to, an organization founded to combat climate change. A cool thing about the blockchain is that you can verify that we did in fact donate the money. accepted Ethereum donations, and you can verify that their address (0x50990F09d4) received the full creation fee of 0.2Ξ upon the creation of each glyph. For example, here is the donation for glyph #129.

Get Your Own Autoglpyh

All 512 Autoglyphs have now been created, to get an Autoglyph you will need to acquire them on the secondary market.

View All Autoglyphs View secondary market on Opensea View All Autoglyph Types and Owners

More Details

The actual code to generate the Autoglyphs is tiny and optimized to run efficiently on Ethereum nodes. Here is the drawing function from the Solidity contract:

// The following code generates art.

function draw(uint id) public view returns (string) {
    uint a = uint(uint160(keccak256(abi.encodePacked(idToSeed[id]))));
    bytes memory output = new bytes(USIZE * (USIZE + 3) + 30);
    uint c;
    for (c = 0; c < 30; c++) {
        output[c] = prefix[c];
    int x = 0;
    int y = 0;
    uint v = 0;
    uint value = 0;
    uint mod = (a % 11) + 5;
    bytes5 symbols;
    if (idToSymbolScheme[id] == 0) {
    } else if (idToSymbolScheme[id] == 1) {
        symbols = 0x2E582F5C2E; // X/\
    } else if (idToSymbolScheme[id] == 2) {
        symbols = 0x2E2B2D7C2E; // +-|
    } else if (idToSymbolScheme[id] == 3) {
        symbols = 0x2E2F5C2E2E; // /\
    } else if (idToSymbolScheme[id] == 4) {
        symbols = 0x2E5C7C2D2F; // \|-/
    } else if (idToSymbolScheme[id] == 5) {
        symbols = 0x2E4F7C2D2E; // O|-
    } else if (idToSymbolScheme[id] == 6) {
        symbols = 0x2E5C5C2E2E; // \
    } else if (idToSymbolScheme[id] == 7) {
        symbols = 0x2E237C2D2B; // #|-+
    } else if (idToSymbolScheme[id] == 8) {
        symbols = 0x2E4F4F2E2E; // OO
    } else if (idToSymbolScheme[id] == 9) {
        symbols = 0x2E232E2E2E; // #
    } else {
        symbols = 0x2E234F2E2E; // #O
    for (int i = int(0); i < SIZE; i++) {
        y = (2 * (i - HALF_SIZE) + 1);
        if (a % 3 == 1) {
            y = -y;
        } else if (a % 3 == 2) {
            y = abs(y);
        y = y * int(a);
        for (int j = int(0); j < SIZE; j++) {
            x = (2 * (j - HALF_SIZE) + 1);
            if (a % 2 == 1) {
                x = abs(x);
            x = x * int(a);
            v = uint(x * y / ONE) % mod;
            if (v < 5) {
                value = uint(symbols[v]);
            } else {
                value = 0x2E;
            output[c] = byte(bytes32(value << 248));
        output[c] = byte(0x25);
        output[c] = byte(0x30);
        output[c] = byte(0x41);
    string memory result = string(output);
    return result;

IRL Rendering

The idea of having the Blockchain dictate "instructions" for the works to be rendered was inspired by Sol LeWitt's Wall Drawings. Along with the digital renderings you see on this site, we use a CNC plotter to render our Autoglyphs in physical form. Here it is hard at work:

Autoglyph owners can now generate SVGs designed specifically for use with the CNC plotters. Visit the detail page of a glyph and validate ownership to access the functionality.

Autoglyphs Font

Because the Autoglyphs are effectively “ASCII art”, we thought it would be appropriate to make a custom font that renders the raw text of glyphs directly. Included are the full spectrum of font weights from 100 (Ultralight) to 900 (Extrablack).

Try out the fonts on an Autoglyph fragment below, or download the entire set of TrueType fonts.




  • Follow the Autoglyphs market tracking Twitter bot (not maintained by Larva Labs).
  • Turn your Autoglyphs into generative music! This functionality is available to owners on the Autoglyph detail pages once they have cryptographically proven ownership of their glyphs. Often works well when combined into ensembles of multiple glyphs. Listen to an example here.