The initial idea

Many projects begin with a very simple idea, hoping that complexity and beauty will magically emerge from that idea. This is the case with this project. The initial idea or rather the question I had was, "what image would result from an infinite line that follows directions determined by some mathematical function" (or perhaps any reference image)? Each point on the canvas is assigned a direction between 0 and 2 pi radians (or 360 degrees). In other words, every point on the canvas has its assigned direction, and as the line passes through, it always takes this only direction. These lines would taper until they disappear.

I started experimenting with reference images, in a scale of gray, so that white corresponded to 0 radians and absolute black to 2 pi radians, with grayscale covering all intermediate values. However, I wasn't satisfied with the results because they were quite chaotic.

So, after that, I turned to mathematical functions, functions that would assign a specific direction to each point on the canvas. This direction has to change progressively for the result to be satisfactory; this is what I call a “vector field”.

To finalize the drawing, a decision must be made; the line must stop at some point. So, I thought one way could be for the line to become thinner and thinner until it disappears.

The idea of just one single infinite line tapering didn't seem aesthetically pleasing to me so I then thought about grouping the lines into 'blobs,' with each blob having hundreds of lines. These groupings allow each line, being slightly offset from the rest, to follow a slightly different path along the vector field, producing more suggestive shapes.

Each blob can have a different color. Thus, an interesting phenomenon occurs—when the lines become very thin and blend together, a subtle mix of colors emerges, along with very interesting textures. At this point, I saw that I was on the right track for the project.

So, I continued to complicate things, reaching the final state with 30+ adjustable parameters, which I will discuss below with examples

Vector fields

One of the critical aspects of this project is the vector fields and knowing which mathematical functions to use to generate visually appealing and suggestive images. So, I have spent a lot of time searching for functions that could be interesting to use. These functions are usually parametric, meaning the internal hash causes variations in their parameters and so in their form.

dir=func(x,y)  with parameters a,b,c,...

Later this fields can be blended in different forms to give more complex patterns.

Color rivers

Despite the thousands of lines, they often overlap as they follow the field's vectors. Moreover, when these lines converge from different points, the effect is like a river of colors that sometimes blend together. As they reach the very end, where they do not extend beyond the canvas, they eventually fade away. Thus, the lines can die in two ways—either because they are so delicate that they vanish or because they exit the frame. However, it's also possible for them to loop back, swirling endlessly within the canvas, neither fully leaving nor entirely fading away until a long time later. This process eventually can take a considerable amount of time

I find that one of the most interesting things about this project is how the lines thin out and blend together, creating intriguing and suggestive shapes. At the same time, this blending generates new colors, even if the color palette is relatively small. In the end, there's a wealth of shades and diverse textures.

Creating Tokens Made Easy. The collector becomes the artist

Given the vast creative possibilities of this project, I thought that instead of generating a random token at the moment of minting, the collector could choose precisely the output they preferred. This chosen output would be exactly what they would obtain at the end of the process.

So here, the internal hash of fxhash is completely ignored, but there is an internal seed as a fx(param)

Considering the numerous parameters involved, I envisioned a simple creation interface where users could select the basic characteristics of their token. Optionally, they could later modify the parameters for finer adjustments. The interface for crafting your artwork includes a series of buttons. First, you can choose the layout. After selecting it, pressing another button triggers completely random outputs with combinations of all parameters. Then, there are two additional buttons—one for adjusting color-related parameters and another for modifying the basic shape. Essentially, the latter changes the vector field parameters, altering the shape while maintaining all other parameters.

Once you have the desired output, you can now mint with confidence, knowing that your token will be exactly the same.

Below the canvas there is a progress bar showing the process and below the buttons information about the current resolution and the number of lines rendered

The multi-layered structure (layouts)

With this project, I wanted to have a wide range of different variations, so the code architecture approach here was to create a multi-layered structure. Each layer of parameters adds complexity. For instance, we have different parameters like the vector field, which defines the shape. Additionally, there are different patterns that decide where the line blobs appear. We also have different ways lines can expand within the blobs—maybe in just one direction, in two directions, or in all directions. Adding more and more parameters increases the complexity until the final 30+.

Letting go of sporadic beauty

As I've been working on this project for many weeks, I've found that it's important not only to add complexity but sometimes to also let go of certain code snippets, experiments, variations and fx(params). In some cases, these experiments result in interesting images, but at the same time, they might convey a completely different philosophy that is not the goal of this project. Often, even though these experiments may yield interesting shapes, it's better to let go of them in favor of maintaining a cohesive aesthetic in line with the project's objectives

fx (params)

Above all, I want to express my gratitude to the fxhash team because their fx(lens) tool has allowed me to approach this project in a different way. I believe it would have been impossible without it. When dealing with many parameters, this interface enables you to experiment with them easily and in a user-friendly manner

List of fx(params) and their meaning

Seed:

The seed parameter defines not only the shape of the vector field but also influences internal random values, such as color distribution.

Direction Field:

This parameter dictates the directions followed by the lines within the vector field.

Filter Mode:

The filter mode determines how the field is interpreted or combined with the next parameter (2nd field).

2nd Field:

When applicable to the filter mode, the 2nd field is utilized for processing.

Line Dispersion:

This parameter controls the dispersion of lines from each blob, with each blob supporting up to thousands of lines.

Bidirectional:

Lines can either follow the field in one direction or, alternatively, 50% in the opposite direction.

Line Density:

Specifies the quantity of lines within each blob.

Blob Speed Gradient:

Determines the variation in speed among lines within a blob.

Blob Progression:

Blobs can either animate sequentially or instantaneously.

Number of Blobs:

Note that with an increased number of blobs, the number of lines within each blob is automatically reduced.

Zoom:

Zooms in the direction field.

Direction Offset:

An offset applied to the direction field.

Canvas Layout:

Choose between square, portrait, or landscape.

Background Color:

Sets the canvas color.

Dithering:

Indicates whether dithering occurs as lines become thinner.

Color Palette:

Select from a predefined palette.

Palette Offset:

Allows the adjustment of the first color in the palette.

Palette Limit:

Adjust the number of colors in the palette.

Color Assignment:

Specifies how colors are assigned to the blobs.

Background Color Probability:

Sets the probability of a blob having the background color.

Black Color Probability:

Sets the probability of a blob being in black color.

Blob Darkening:

Controls the darkening of lines within each blob from the first to the last.

Blob Type:

Defines the shape of each blob.

Line Width:

Sets the initial width of the lines.

Blob Size:

Specifies the initial size of the blobs.

Blob Distribution:

Determines how blobs are distributed across the canvas.

Grid Size:

Sets the scale of blob distribution within the canvas.

Line Thinning:

Controls the rate at which lines fade away; higher values result in slower thinning.

X Displacement:

Horizontal displacement of the vector field.

Y Displacement:

Vertical displacement of the vector field.

Canvas Edge:

Defines the border in the canvas.

Minting instructions

Simple Steps for Minting Using Buttons:

Choose a Layout: Click the "Layout" button and select your preferred canvas arrangement (square, portrait, or landscape).

Generate Random Output: Click the "Random" button until you find an output you like.

Adjust Colors: Click the "Colors" button to modify the color palette according to your preferences.

Shape Customization: Click the "Shape" button repeatedly until the shape aligns with your liking.

Mint the Final Output: Once satisfied with the layout, colors, and shape, mint your personalized artwork.

Advanced minting:

Adjust the fx(params) for your desired output

You can combine also both methods

A Variety of Examples

Here you have a selection of different outputs