Perlin noise is the algorithm used for computing values of a pseudo-random function, smoothly depending on its parameters. It was originally developed in 1982 by Ken Perlin and named after him. Today, it's called **classical noise**. In 2001, Ken Perlin developed a modification of the algorithm and called it **simplex noise**. Simplex noise works faster than classical noise, but the results differ a little.

Nowadays both noises are widely used. Often it is not very important which algorithm is used in a given case; that's why we will refer to both of them as just **Perlin noise**.

For a developer, the Perlin noise function `ofNoise( t )`

just takes values in the range [0, 1] and depends on the parameter `t`

. The dependence is smooth; that is, a small change in the value of the input parameter `t`

leads to a small change in the output result. But, unlike any other mathematical function such as `sin( t )`

or `exp( t )`

, Perlin noise is not periodic and is not constantly increasing. It has complex and non-repetitive behavior, which is called **pseudo-random behavior**. That is, on one hand it is a function that seems random, and on the other hand it is fixed. No matter how many times you compute `ofNoise( t )`

for the given `t`

, you will obtain exactly the same result.

The main advantage of Perlin noise compared to an ordinary pseudo-random number generator, `ofRandom( a, b )`

, is the controllable smoothness. Indeed, if we will consider float values `A0 = ofNoise( t ), A1 = ofNoise( t+0.01 )`

, and `A2 = ofNoise( t+0.1 )`

for different values of `t`

, we will find that often `A1`

is closer to `A0`

than `A2`

. Hence we can control the resultant smoothness of the graph of `ofNoise( t )`

, built for discrete set of values `t`

, by controlling the step of incrementing these values. Contradictorily, two calls of `ofRandom( 0, 1 )`

generate two **uncorrelated** numbers, and there is no way to control their proximity.

Now let's see how to use Perlin noise in openFrameworks projects.