blockchain

Autoglyphs

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. A glyph can be created by anyone who is willing to donate the creation fee of 0.20Ξ ($29.44) to our chosen charity, 350.org. The creator of the glyph will then also become the first owner of the glyph. However, after 512 glyphs have been created, the generator will shut itself off forever and the glyphs will 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 glpyh 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 Fee Goes to Charity

All proceeds from the creation of Autoglyphs are being donated to 350.org, an organization founded to combat climate change. A cool thing about the blockchain is that you can verify that we are in fact donating the money. 350.org accepts Ethereum donations, and their address (0x50990F09d4) can be verified on this page of their website. You can also verify that the Autoglyphs contract is donating the full creation fee of 0.20Ξ ($29.44) to that address upon the creation of each glyph. For example, here is the donation for glyph #129. So for each Autoglyph you create for yourself, you're also easily and transparently donating to a good cause.

Get Your Own Autoglpyh

Each Autoglpyh is unique and created for it's purchaser by the algorithm embedded in the Ethereum blockchain. There will only ever be 512 in existance, and 512 have already been claimed. That means there are 0 left to be created.

Donation Required to Create
0.20Ξ ($29.44)
Number Created so Far
512
Number Available to Create
0

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

View secondary market on Opensea View All Autoglyph Owners

Current Project Status

The complete set of glyphs generated to date can be seen below along with some key stats about the project so far.

Number Created so Far
512
Number Remaining
0

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) {
        revert();
    } 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));
            c++;
        }
        output[c] = byte(0x25);
        c++;
        output[c] = byte(0x30);
        c++;
        output[c] = byte(0x41);
        c++;
    }
    string memory result = string(output);
    return result;
}
                

Rendering the Works

The idea of having the Blockchain dictate "instructions" for the works to be rendered was inpsired 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: