Created with Processing
This version highlights the inner 6 pointed star

// Metatron’s Cube Expanded 011
// by Rupert Russell
// December 18 2018
// based on https://i.ytimg.com/vi/iQeXxu3-YNI/maxresdefaul...
// Artwork on Redbubble at: https://www.redbubble.com/people/rupertrussell/...
// this version highlights the large 6 pointed star
// MIT licence

int scale = 800;
float[] xInner = new float⁶;
float[] yInner = new float⁶;

float[] xOuter = new float⁶;
float[] yOuter = new float⁶;

float[] xOuterMost = new float⁶;
float[] yOuterMost = new float⁶;

float[] xNesting = new float⁶;
float[] yNesting = new float⁶;

float[] xTurningPoint = new float⁶;
float[] yTurningPoint = new float⁶;

int count = 0;
int sWeight = 20;

void setup() {
size(4625, 4625);
background(0);
stroke(255);
noLoop();
noFill();
strokeWeight(sWeight);
// strokeCap(SQUARE);
}

void draw() {
translate(width/2, height/2);
ellipse(0, 0, scale, scale); // inner circle

// calculate 6 points around the inner circle

float step = 2 * PI/6;
float r = scale ;
float theta = radians(90);
for (int count = 0; count < 6; count ++) {
xInner[count] = r * cos(theta);
yInner[count] = r * sin(theta);
ellipse(xInner[count], yInner[count], scale, scale);
theta = theta + step;
}

ellipse(0, 0, scale * 5, scale * 5); // outer guide circle

// calculate 6 points around the Outer circle

r = scale * 2 ;
for (int count = 0; count < 6; count ++) {
xOuter[count] = r * cos(theta);
yOuter[count] = r * sin(theta);
ellipse(xOuter[count], yOuter[count], scale, scale);
theta = theta + step;
}

// calculate last 6 points nesting between the inner circles

stroke(255, 0, 0);
theta = radians(0);
r = scale * 1.73205 ;
for (int count = 0; count < 6; count ++) {
xNesting [count] = r * cos(theta);
yNesting [count] = r * sin(theta);
// ellipse(xNesting [count], yNesting [count], 10, 10);
theta = theta + step;
}

stroke(255);

// calculate 6 points around the OuterMost circle

theta = radians(90);
r = scale * 2.5 ;
for (int count = 0; count < 6; count ++) {
xOuterMost[count] = r * cos(theta);
yOuterMost[count] = r * sin(theta);
// ellipse(xOuterMost[count], yOuterMost[count], scale, scale);
theta = theta + step;
}

//// markers//stroke(255, 0, 0);//strokeWeight(2);//ellipse(xInner⁰, yInner⁰, 10, 10);//ellipse(xOuter⁰, yOuter⁰, 10, 10);//ellipse(xOuterMost⁰, yOuterMost⁰, 10, 10);//stroke(255, 0, 255);//ellipse(xNesting⁰, yNesting⁰, 10, 10);//stroke(255);// 4 banding circles

ellipse(0, 0, scale * 2, scale * 2);
ellipse(0, 0, scale * 3, scale * 3);
ellipse(0, 0, scale * 4, scale * 4);
ellipse(0, 0, scale * 5, scale * 5);

// inner hexagon

for (int counter = 0; counter < 5; counter ++) {
line(xOuter[counter], yOuter[counter], xOuter[counter +1], yOuter[counter +1]);
}
line(xOuter⁵, yOuter⁵, xOuter⁰, yOuter⁰);

// Outer hexagon

for (int counter = 0; counter < 5; counter ++) {
line(xOuterMost[counter], yOuterMost[counter], xOuterMost[counter +1], yOuterMost[counter +1]);
}
line(xOuterMost⁵, yOuterMost⁵, xOuterMost⁰, yOuterMost⁰);

//3 connecting lines

line(xOuterMost³, yOuterMost³, xOuterMost⁰, yOuterMost⁰); // Central vertical line
line(xOuterMost¹, yOuterMost¹, xOuterMost⁴, yOuterMost⁴); // lower left to upper right
line(xOuterMost², yOuterMost², xOuterMost⁵, yOuterMost⁵); // upperleft to lower right

// inner triangle (1)

line(xInner¹, yInner¹, xInner⁵, yInner⁵); // bottom
line(xInner¹, yInner¹, xInner³, yInner³); // left
line(xInner⁵, yInner⁵, xInner³, yInner³); // right

// inner triangle (2)

line(xInner², yInner², xInner⁴, yInner⁴); // top
line(xInner⁴, yInner⁴, xInner⁰, yInner⁰); // right
line(xInner⁰, yInner⁰, xInner², yInner²); // right

// outer triangle (3)

line(xOuter¹, yOuter¹, xOuter⁵, yOuter⁵); // bottom
line(xOuter¹, yOuter¹, xOuter³, yOuter³); // left
line(xOuter⁵, yOuter⁵, xOuter³, yOuter³); // right

// outerMost triangle (4)

line(xOuterMost¹, yOuterMost¹, xOuterMost⁵, yOuterMost⁵); // bottom
line(xOuterMost¹, yOuterMost¹, xOuterMost³, yOuterMost³); // left
line(xOuterMost⁵, yOuterMost⁵, xOuterMost³, yOuterMost³); // right

// outer triangle (5)

line(xOuter², yOuter², xOuter⁴, yOuter⁴); // top
line(xOuter⁴, yOuter⁴, xOuter⁰, yOuter⁰); // left
line(xOuter⁰, yOuter⁰, xOuter², yOuter²); // right

// outerMost triangle (6)

line(xOuterMost², yOuterMost², xOuterMost⁴, yOuterMost⁴); // top
line(xOuterMost⁴, yOuterMost⁴, xOuterMost⁰, yOuterMost⁰); // left
line(xOuterMost⁰, yOuterMost⁰, xOuterMost², yOuterMost²); // right

// Pairs

line(xOuter³, yOuter³, xInner¹, yInner¹); // left
line(xOuter³, yOuter³, xInner⁵, yInner⁵); // right

line(xOuter⁴, yOuter⁴, xInner², yInner²); // left
line(xOuter⁴, yOuter⁴, xInner⁰, yInner⁰); // right

line(xOuter⁵, yOuter⁵, xInner³, yInner³); // left
line(xOuter⁵, yOuter⁵, xInner¹, yInner¹); // right

line(xOuter⁰, yOuter⁰, xInner⁴, yInner⁴); // left
line(xOuter⁰, yOuter⁰, xInner², yInner²); // right

line(xOuter¹, yOuter¹, xInner³, yInner³); // left
line(xOuter¹, yOuter¹, xInner⁵, yInner⁵); // right

line(xOuter², yOuter², xInner⁰, yInner⁰); // left
line(xOuter², yOuter², xInner⁴, yInner⁴); // right

// Hexagram 1

line(xNesting⁰, yNesting⁰, xNesting⁴, yNesting⁴);
line(xNesting⁰, yNesting⁰, xNesting², yNesting²);

line(xNesting¹, yNesting¹, xNesting³, yNesting³);
line(xNesting¹, yNesting¹, xNesting⁵, yNesting⁵); // right

line(xNesting¹, yNesting¹, xNesting³, yNesting³);
line(xNesting¹, yNesting¹, xNesting⁵, yNesting⁵);

line(xNesting², yNesting², xNesting⁴, yNesting⁴); // left
line(xNesting³, yNesting³, xNesting⁵, yNesting⁵);

// Hexagon

line(xNesting⁰, yNesting⁰, xNesting¹, yNesting¹);
line(xNesting¹, yNesting¹, xNesting², yNesting²);
line(xNesting², yNesting², xNesting³, yNesting³);
line(xNesting³, yNesting³, xNesting⁴, yNesting⁴);
line(xNesting⁴, yNesting⁴, xNesting⁵, yNesting⁵);
line(xNesting⁵, yNesting⁵, xNesting⁰, yNesting⁰);

// final lines

line(xNesting⁰, yNesting⁰, xNesting³, yNesting³); // Horozontal
line(xNesting¹, yNesting¹, xNesting⁴, yNesting⁴);
line(xNesting², yNesting², xNesting⁵, yNesting⁵);

//println(" x Outer 1 = " + xOuter¹ );//println(" x Nesting 0 = " + xNesting⁰ );// Locate turning points// calculate 6 points around the OuterMost circle

theta = step;
r = scale * 1.1547022 ;
for (int count = 0; count < 6; count ++) {
xTurningPoint[count] = r * cos(theta);
yTurningPoint[count] = r * sin(theta);
theta = theta + step;
}
// ellipse(0, 0, r, r);
// ellipse(xTurningPoint⁰, yTurningPoint⁰, 5, 5);
// trace thicker lines
strokeWeight(sWeight * 3);

line(xOuter⁰, yOuter⁰, xTurningPoint⁰, yTurningPoint⁰);
line(xOuter⁰, yOuter⁰, xTurningPoint¹, yTurningPoint¹);

line(xOuter¹, yOuter¹, xTurningPoint¹, yTurningPoint¹);
line(xOuter¹, yOuter¹, xTurningPoint², yTurningPoint²);

line(xOuter², yOuter², xTurningPoint², yTurningPoint²);
line(xOuter², yOuter², xTurningPoint³, yTurningPoint³);

line(xOuter³, yOuter³, xTurningPoint³, yTurningPoint³);
line(xOuter³, yOuter³, xTurningPoint⁴, yTurningPoint⁴);

line(xOuter⁴, yOuter⁴, xTurningPoint⁴, yTurningPoint⁴);
line(xOuter⁴, yOuter⁴, xTurningPoint⁵, yTurningPoint⁵);

line(xOuter⁵, yOuter⁵, xTurningPoint⁵, yTurningPoint⁵);
line(xOuter⁵, yOuter⁵, xTurningPoint⁰, yTurningPoint⁰);

// black inner hairline

strokeWeight(sWeight * 1.2);
stroke(0);

line(xOuter⁰, yOuter⁰, xTurningPoint⁰, yTurningPoint⁰);
line(xOuter⁰, yOuter⁰, xTurningPoint¹, yTurningPoint¹);

line(xOuter¹, yOuter¹, xTurningPoint¹, yTurningPoint¹);
line(xOuter¹, yOuter¹, xTurningPoint², yTurningPoint²);

line(xOuter², yOuter², xTurningPoint², yTurningPoint²);
line(xOuter², yOuter², xTurningPoint³, yTurningPoint³);

line(xOuter³, yOuter³, xTurningPoint³, yTurningPoint³);
line(xOuter³, yOuter³, xTurningPoint⁴, yTurningPoint⁴);

line(xOuter⁴, yOuter⁴, xTurningPoint⁴, yTurningPoint⁴);
line(xOuter⁴, yOuter⁴, xTurningPoint⁵, yTurningPoint⁵);

line(xOuter⁵, yOuter⁵, xTurningPoint⁵, yTurningPoint⁵);
line(xOuter⁵, yOuter⁵, xTurningPoint⁰, yTurningPoint⁰);

//println(" y Outer 1 = " + yOuter¹ );//println(" y Nesting 3 = " + yTurningPoint³ );

save(“Matatrons-cube-expanded_011.png”);

exit();
}