Day 35: Evolution Beyond Biology: Using Genetic Algorithms for Creative Art and Design

Chris Woodruff
September 18, 2025
Genetic Algorithms
.NET, ai, C#, dotnet, genetic algorithms, programming
0 Comments

Genetic Algorithms are often associated with engineering, scheduling, or optimization problems, but their potential extends into the domain of art and design. When applied to visual composition, generative structures, or music synthesis, GAs can produce unexpected and compelling outcomes. These creative applications demonstrate that evolution-inspired algorithms are not limited to purely functional results. In this post, we explore how you can use Genetic Algorithms in C# to evolve digital art and generative designs.

Chromosomes for Artistic Parameters

To evolve art or design, we must represent the artistic space as a chromosome. For generative visual art, a simple chromosome might encode shapes, colors, and layout features.

public class ArtChromosome
{
    public List<ShapeGene> Shapes { get; set; } = new List<ShapeGene>();
    public double Fitness { get; set; }
}

Each shape can be a gene representing a primitive form, such as a circle or square, with attributes like position, size, and color.

public class ShapeGene
{
    public int X { get; set; }
    public int Y { get; set; }
    public int Size { get; set; }
    public Color Color { get; set; }
    public ShapeType ShapeType { get; set; }
}

public enum ShapeType
{
    Circle,
    Square,
    Triangle
}

Fitness by Aesthetic Criteria

Defining a fitness function in a creative context is subjective. You can use metrics such as symmetry, color harmony, balance, or even crowd-sourced preferences or machine-learned aesthetic scores.

Here’s an example of a basic symmetry-based fitness function:

public static double EvaluateSymmetry(ArtChromosome chromosome, int canvasWidth)
{
    int symmetryScore = 0;

    foreach (var shape in chromosome.Shapes)
    {
        int mirroredX = canvasWidth - shape.X;
        bool hasMirror = chromosome.Shapes.Any(s =>
            Math.Abs(s.X - mirroredX) < 5 &&
            s.Y == shape.Y &&
            s.Size == shape.Size &&
            s.ShapeType == shape.ShapeType);

        if (hasMirror) symmetryScore++;
    }

    return symmetryScore / (double)chromosome.Shapes.Count;
}

This example favors art with horizontal symmetry, often perceived as aesthetically pleasing.

Mutation and Crossover for Art

Mutations can change a shape’s attributes to introduce variety.

public static void Mutate(ArtChromosome chromosome)
{
    Random rand = new Random();
    int index = rand.Next(chromosome.Shapes.Count);
    var shape = chromosome.Shapes[index];

    shape.X = rand.Next(0, 800);
    shape.Y = rand.Next(0, 600);
    shape.Size = rand.Next(10, 100);
    shape.Color = Color.FromArgb(rand.Next(256), rand.Next(256), rand.Next(256));
}

Crossover might involve combining half of the shapes from each parent.

public static ArtChromosome Crossover(ArtChromosome parent1, ArtChromosome parent2)
{
    int midpoint = parent1.Shapes.Count / 2;

    return new ArtChromosome
    {
        Shapes = parent1.Shapes.Take(midpoint)
            .Concat(parent2.Shapes.Skip(midpoint))
            .ToList()
    };
}

Rendering the Artwork

Use System.Drawing or a library like SkiaSharp to render the artwork based on the chromosome.

public static void Render(ArtChromosome chromosome, string filePath)
{
    int width = 800;
    int height = 600;

    using var bitmap = new Bitmap(width, height);
    using var graphics = Graphics.FromImage(bitmap);
    graphics.Clear(Color.White);

    foreach (var shape in chromosome.Shapes)
    {
        using var brush = new SolidBrush(shape.Color);
        switch (shape.ShapeType)
        {
            case ShapeType.Circle:
                graphics.FillEllipse(brush, shape.X, shape.Y, shape.Size, shape.Size);
                break;
            case ShapeType.Square:
                graphics.FillRectangle(brush, shape.X, shape.Y, shape.Size, shape.Size);
                break;
            case ShapeType.Triangle:
                // You would implement drawing triangle logic here
                break;
        }
    }

    bitmap.Save(filePath);
}

Interactive Evolution

A compelling way to guide artistic evolution is through human feedback. You could build a simple UI where users rank artwork each generation, and the most liked images influence the next generation. This interactive evolution harnesses subjective preference, which is otherwise hard to encode.

Expanding to Generative Design

The same concepts apply to other creative fields. Use GAs to evolve furniture layouts, architecture structures, or even musical sequences. In each case, define the gene space, fitness criteria, and appropriate variation operators.

For example, in generative product design:

Genes could represent dimensions, materials, and structural properties
Fitness could be a combination of aesthetics and mechanical performance (simulated with physics engines)

Final Thoughts

Applying Genetic Algorithms to art and design flips the usual script. Instead of optimization toward strict numerical goals, we explore open-ended creativity. The stochastic nature of GAs, combined with loosely defined objectives, enables novel and unexpected results.

These techniques can support ideation in design tools, augment human creativity, and inspire hybrid workflows between algorithm and artist. Genetic Algorithms can be more than tools for function; they can be instruments for imagination.

Thank You

As we wrap up this Genetic Algorithms series, I want to thank you for following along. Whether you read a single post or every day from start to finish, I genuinely appreciate the time you invested. Writing this series has been as much about sharing ideas as it has been about learning together, and your support has made it worthwhile. I hope the concepts, examples, and experiments have sparked new ideas for your own projects and inspired you to keep exploring how evolution in code can solve real-world problems. Here’s to continued learning and building smarter solutions… together.

Tags: .NET ai C# dotnet genetic algorithms programming