Since you move through 1, 2 or 3 dimensional noise space, you can't really 'loop' the noise itself.

One solution is to linearly interpolate the last values towards the first value. Ideally the barrier to start doing this is as close to the end as possible. The advantage of this method is that it really focuses on the problem while causing minimal 'collateral damage'. Everything before the barrier is unaffected (which is 95% in the example below) and the final range is only affected as much as required, while still ensuring that the values interpolate to the correct value.

Code Example

1. int num = 256;
2. float rot = TWO_PI/num;
   
3. float innerRadZero, outerRad = 250;
4. float barrier = 0.95;
5.  
6. void setup() {
7.   size(700, 700);
8.   smooth();
9. }
10.  
11. void draw() {
12.   background(255);
13.   translate(width/2, height/2);
14.   strokeWeight(15);
15.   ellipse(0, 0, outerRad*2, outerRad*2);
16.   strokeWeight(0.5);
17.   beginShape(LINES);
18.   for (int i=0; i<num; i++) {
19.     float angle = i*rot;
20.     float x = cos(angle);
21.     float y = sin(angle);
    
22.     float innerRad = 50 + noise(i*0.025, frameCount*0.01) * 200;
23.     if (i == 0) {
24.       innerRadZero = innerRad;
25.     } else if (i>num*barrier) {
26.       float perc = map(i, num*barrier, num, 0, 1);
27.       innerRad = lerp(innerRad, innerRadZero, perc);
28.     }
29.     vertex(x*innerRad, y*innerRad);
30.     vertex(x*outerRad, y*outerRad);
31.   }
32.   endShape();
33. }

This is exactly what I was trying to achieve (including the animation part), thank you so much, this was a huge help.. I tried something similar, I lineary changed the noise amplitude to zero at it's start and end and I didn't try your approach because I thought it'd give the same result, but it works perfect.

Btw, another thing that I'm trying to achieve is to make the whole inital state to loop because I want to make a gif out of it and it would look best if the whole animation looped seamlessly. I already came up with the solution for that and here's how I did it. I animated  the line's length using the sin function, sin(millis()), but every line had it's own starting point which is set by noise so it then looked like sin(noise(i) + millis()), (ofcourse, I had to slow things down by multiplying noise() and millis() with a small factor, but you've got the idea).
Here's your code edited with my animation loop code:

1. int num = 256;
2. float rot = TWO_PI/num;
3. float innerRadZero, outerRad = 250;
4. float barrier = 0.96;
5. void setup() {
6.   size(700, 700);
7.   smooth();
8. }
9. void draw() {
10.   background(255);
11.   translate(width/2, height/2);
12.   strokeWeight(0.5);
13.   beginShape(LINES);
14.   for (int i=0; i<num; i++) {
15.     float angle = i*rot;
16.     float x = cos(angle);
17.     float y = sin(angle);
18.     float innerRad = 150 + 40*sin( radians(360*noise(i*0.015)) + millis()*0.003);
19.     if (i == 0) {
20.       innerRadZero = innerRad;
21.     }
22.     else if (i>num*barrier) {
23.       float perc = map(i, num*barrier, num, 0, 1);
24.       innerRad = lerp(innerRad, innerRadZero, perc);
25.     }
26.     line(x*innerRad, y*innerRad, x*outerRad, y*outerRad);
27.   }
28.   endShape();
29. }

Thanks again!!

Hi there.

I was too lazy so I just edited my code and calculated the same thing for two points (start and end points of the line).

Here you go:

1. int num = 200;
2. float rot = TWO_PI/num;
3. float innerRadZero1,innerRadZero2, outerRad = 250;
4. float barrier = 0.9;
5. void setup() {
6.   size(700, 700);
7.   smooth();
8.   background(0);
9.   stroke(255);
10. }
11. void draw() {
12.   background(0);
13.   translate(width/2, height/2);
14.   strokeWeight(0.5);
15.   for (int i=0; i<num; i++) {
16.     // calculating the first point of the line
17.     float angle1 = i*rot;
18.     float x1 = cos(angle1);
19.     float y1 = sin(angle1);
20.     float innerRad1 = 150 + 40*sin( radians(360*noise(i*0.035)) + millis()*0.003);
21.     if (i == 0) {
22.       innerRadZero1 = innerRad1;
23.     }
24.     else if (i>num*barrier) {
25.       float perc = map(i, num*barrier, num, 0, 1);
26.       innerRad1 = lerp(innerRad1, innerRadZero1, perc);
27.     }
28.    
29.     // calculating the second point
30.     float angle2 = ((i+1)%num)*rot;
31.     float x2 = cos(angle2);
32.     float y2 = sin(angle2);
33.     float innerRad2 = 150 + 40*sin( radians(360*noise(((i+1)%num)*0.035)) + millis()*0.003);
34.     if (((i+1)%num) == 0) {
35.       innerRadZero2 = innerRad2;
36.     }
37.     else if (((i+1)%num)>num*barrier) {
38.       float perc = map(((i+1)%num), num*barrier, num, 0, 1);
39.       innerRad2 = lerp(innerRad2, innerRadZero2, perc);
40.     }
41.     line(x1*innerRad1, y1*innerRad1, x2*innerRad2, y2*innerRad2);
42.   }
43. }

The code could maybe be shorter, but this works just fine, the only difference between the two points is that the first one uses 'i' and the second one uses '(i+1)%num', that's it.

Great!!!

I'm going to answer this too, just for the sake of people who end up here from google - if you need closed or looping perlin noise, a simple way of generating it is just to sample 2D perlin noise at points on the circumference of a circle.

I'm a C++ person really, and const didn't highlight, so I left it, but thanks for the heads up!