The Cryogenius 10 X 10 X 10 Color LED Cube

"If I have seen further, it is by standing on the shoulders of giants." The quote is attributed to Isaac Newton and I feel that it applies to me as well, albeit on a much smaller scale.

I made my first dive into the world of digital electronics several years ago when I followed the 8 x 8 x 8 LED Cube Instructable by chr. That took a lot of effort for me, but what a great learning experience, and a stunning result! The later Instructable by HiTech further helped clarify the technology and added to the cool effects. These were my first two “giants,” and I later found more of them (ResinChemTech and IntermitTech among them) when I got into WLED projects. I then wondered if I could make an 8 x 8 x 8 LED cube in color using a string of WS2812B fairy lights. This would eliminate most of the soldering labor and all of the layer by layer updating; the entire cube updates all at once. But would it be fast enough?

The answer is yes! My first Cryogenius LED Cube employed an ESP8266 programmed using the FastLED library. For most LED cubes, the LED leads themselves provide the support structure. But for a fairy light cube we must add a frame to support the LED strings, thus some carpentry replaces the soldering. In my case this was a good trade-off, and in any event the results were great. The animations were fast and the multi-color effects were "hey-wow!"

Next I wanted to use an ESP32 for even more speed and RAM. With that extra performance, why not go for a 10 x 10 x 10 cube that has almost double the lights? An extra bonus is that the lights come in rolls of 100; this means the connections to the strings will all occur on the same edge of the frame which makes the wiring a lot easier and the LEDs easier to align.

For the materials cost, expect to pay about $350 - 400 in spring of 2026; most of that is in the power supply and LED strings.

This is an advanced project, and you should have some “maker” experience before taking it on. However, the results are amazing; you will enjoy the “oohs and ahhs” and a great feeling of accomplishment!

Tools

Note: These are the tools I used because I have them; but it is possible to complete the project with hand tools. If you don’t have a tool for cutting the 9 gauge wire, you can use 3/8”wood dowels instead of wire and make the support structure with ¾” x ¾” square wood. Also, look at Step 6 for an alternate possibility.

3D Printer (or use a local 3D printing company or local library to print the files I have included)

Hand drill (a lithium battery cordless drill can work, but a strong one with a cord is better)

Table Saw with wood cutting blade and metal cutting wheel (a hand saw and big wire cutters capable of cutting mild steel will work). Note: For cutting the 9 gauge wire you can also use large vise grips with the cutter blades on the inside of the jaws. These do not cut all the way through the wire but they make notches which break with one or two flexes; the metal hardens between the notches, making that spot brittle. (Photos S1 and S2)

File for smoothing the ends of the cut wire.

Woodworking Square for lining up all the right angles in the wire loom.

Soldering Iron Station

Heat Insert Tool (Optional)

Crimping Tool Use the jaws that are made for heat shrink insulated connectors. In this example use Jaw No 125.

Materials

Structure

1” x 1” x 16 ft wood (Cedar, or poplar, or even treated pine) for the four posts: I had some spare molding that measured one inch by one inch (not ¾” x ¾”). The 3D printed parts are based on a true 1” square, so make sure you have the right dimensions if you want to use the printed parts as is. The wood choice depends on whether you want to display your cube outside in the rain, or keep it inside. I based my design on having it outside in the rain, but not in a howling marine environment.

4 x 3/8” x 36” hardwood dowels for the wire loom: The full 36” will not be required for the loom, but the eight hinge pins are also made from 3/8” dowels, and are just over an inch long. Use the most rigid hardwood available to minimize bowing in the middle. Note: A design improvement is to use 3/8” x 36” aluminum rods instead of wood. Cut them with a hacksaw if you don’t have a metal-cutting machine. The advantage of using aluminum is less deflection in the middle of the top loom spans. The disadvantage is cost, with wood dowels costing $5 each, while aluminum is $9 each. I recommend using aluminum just for the top loom which is supporting the weight of the lights.

2 x 50 ft 9-Gauge Wire: You only need about 60 ft but they come in 50 ft rolls.

Exterior Paint: If you plan to keep the cube inside just use any finish you desire. For outside display, I prefer to use black paint to keep the visual obstruction of the structure as minimal as possible.

E6000 Glue

2 pieces of 180 mm x 888 mm x 12 mm plywood: For the structure support and electronics panel.

1 piece of approx. 100mm x 1000m x 12 mm plywood, and 1 piece of 200mm x 800 mm x 6 mm plywood: For the electronics panel cover.

Screws: About forty #8 – 32 x ½” wood screws for fastening the wooden parts and hinges , eight #8-32 x 1" wood screws for attaching the plywood panels to the posts, two M3 x 8 mm hex head bolts for mounting the ESP32, 6 M2 x 8 mm pan head screws for the ESP32 and WAGO project box lids.

1" Wire Nails for holding together the electronics cover while the white glue dries

White Glue

Electrical

300 W 12 Volt Power Supply: I used one that is waterproof like this one.

Voltage converter: 12 V to 5 V Buck Converter Module

ESP32 38 Pin Narrow : Be sure to get a narrow 38 pin version – it has to fit on a solderable prototype breadboard.

SN74AHCT125 level shifter: SN74AHCT125N and Socket. This is probably optional – the purpose is to buck up the 3.3 volt data signal to the 5 volts needed for the LED strings. However, my LED strings worked fine with the 3.3 volt data going to them directly.

Electrocookie Solderable Half Breadboard: Electrocookie Prototype

LED Fairy Light Strings: 12 Volt Fairy Lights Buy five of the 2 x 32 ft 12 Volt lights, which will give you 5 x 200 = 1000 LEDs. You might also want to get an extra string “just in case…”

3D printing filament: 500 gram should be plenty

Heat Shrink Tubing – Various Sizes

WAGO Connectors (221-413): WAGO 3 Conductor Connectors

Waterproof Heat Shrink Butt Connectors: Connectors

4 x 20 pin female PCB headers.

18-Gauge stranded wire

20-Gauge solid wire

Breadboard and breadboard wires/connectors

2 x PCB Screw Terminals (2-pin) for 18-Gauge stranded wire (if including a level shifter)

As I design and build a project, I like to summarize the capabilities and functions. This guides my decisions on what to buy and how to put it all together. My design complies (for the most part) with the list below. If you decide some of these are beyond what you need, or there is something missing that should be there, you can make the necessary adjustments:

1. Design for exterior operation. Use waterproof electrical connections, or provide protection for any that are not waterproof. The goal is to provide a high degree of water resistance, but not necessarily good for a screaming hurricane.
2. Provide a design that can fit through an interior door. The dimensions of the structure are almost 1 meter x 1 meter x 1.2 meters (actually 35” x 35” x 48”). As for me, I do have a back door that would barely accommodate bringing the monster inside, but then my options become limited. I have decided to install hinges to enable folding it up for doors and storage.
3. Keep the weight as light as possible while providing enough strength to prevent unscheduled disassembly.
4. Make the structure as visually unobtrusive as possible.
5. Align the lights perfectly; well, as perfectly as possible given the limits of my hands and tools. This requires the following measures:
6. Careful measurement and assembly. Account for the serpentine pattern in the structure design by including allowance for the distance required to bend around the 9-gauge support wires.
7. Set up the serpentine layers such that the strings hang vertically, to avoid sagging in the middle of the 1 meter span. Put any horizontal runs in the short distance between the loom wires.
8. Design for a pixel cube that is not perfectly cubical. The lights are separated by 100 mm, and this distance is fine for the vertical distance between pixels. However, by the time the string goes around the wire looms, horizontal distance between the pixels on the serpentine plane is only about 84-85 mm. Thus the size of an eight pixel cube is 84mm x 84mm x 100mm. Although it would be possible to make a cube 84mm x 100mm x 100mm I expect that limiting the long dimension to the vertical axis is more pleasing to the eye.
9. Take advantage of the ESP32 parallel output capability to maximize frames per second.
10. Use Over the Air (OTA) WIFI for maximum convenience when programming the ESP32.
11. Use the FastLED Arduino library for programming effects.

Photo 1 shows my first version of the fairy light cube where the frame was all wood and it was 8 x 8 x 8. It easily fit through door openings without folding up. The serpentine planes were horizontal in this version which led to some sagging in the middle. That distraction was minor, but easily solved in the current version with vertical serpentine planes. If you do not want to deal with straightening and cutting heavy wires you can do a solution like this.

1. Refer to Drawing 1. Cut wood – posts, hinge pins, and loom dowels. Sand and paint.
2. Cut the loom wire. The final length after straightening will be 830 mm, so cut longer than this, say 860 mm.
3. Straighten the loom wire (Photo 2). Look on YouTube and find a video where wire is straightened by using a vise and a drill. I will admit that 9-gauge wire is right at the maximum of what is possible using this method. Although I used a corded drill to do mine, I also tested with an 18V lithium battery drill. I set the speed at minimum and the torque clutch at maximum (the setting just below the drill icon). Hold on tight and let it do 4-5 turns. The vise jaws and drill chuck must be as tight as you can possibly make them. Lots of forces at work here so wear eye protection, be careful, and be aware that the wire may be hot after you finish the twisting. If your vise and drill can't handle this, see the very last step (Step 6: Design Improvements) for an alternate possibility. Or do a search on straightening 9 Gauge wire and see if there is a method you are willing to try.
4. Cut the 20 loom wires to the 830 mm final length. Use a jig or stop block if necessary to make them all exactly the same length. After cutting remove burrs by filing. Then, with all the wires laid down together, butted up against a straight edge, mark them all using a Sharpie. The marks start 37 mm from one end, then 10 marks spaced 84 mm apart. These marks will make it easier to align the LED string when weaving the serpentine pattern.
5. 3D print the wire connectors (quantity: 40 for looms + 2 for the locking mechanism). Start by printing only one and adjust scale as needed to get a good fit between the wire and hole. These can be printed without support. I used the default settings for Generic PLA on a Bambu P1S printer.
6. 3D print the eight hinges, each hinge has two parts. Again, test with one for fit before printing the batch of them.
7. Refer to Drawing 2 and begin assembly of the two looms. The spacing between the wires allows for the fact that there will be two LED strings inside two loom wires and then two outside of two loom wires. Mark the loom spars (the 3/8” dowels) with the proper intervals (Photo 3).
8. Now comes the challenge of lining everything up and keeping it together while applying the glue. The loom wires will most likely have some tolerance in length and will not be exactly the same. If you insert them completely into the connectors the loom spars will not press into place.
9. Start with one spar, and on one end of the 9-Gauge wires apply a spot of E6000 in the connector hole and then insert the wire half way. Do this on all ten wires.
10. Put the spar against a solid straight object. Then apply glue to the connector where it clips on to the loom spar, and clip on the connectors at the proper intervals on the one spars. Arrange the wires to line up with the marks on the second spar, apply E6000 to the connectors and clip them on to the second spar (Photo 4).
11. Lay the loom on a flat surface and put one spar of the loom against a straight piece of scrap wood. As with the first spar, glue where the connector clips on to the spar, and clip all 10 connectors onto the marked locations. If the connectors do not clip on it may be necessary to tap lightly with a hammer to seat the loom wires. Some of the connectors may not be completely clipped, but as long as there is glue in the space between the spar and connector it should be OK. Use a square to line everything up at right angles (Photo 5).
12. Do the same things for the top loom and allow the glue to cure overnight (Photo 6).
13. Once the glue is cured, glue the 3D printed hinge pieces to the spars. Watch the orientation, as illustrated in Drawings 3 and 4. The hinge pins are just press fitted into the holes - I did not glue mine. Photo 7 shows the hinge pieces together, but at this point you only want the pieces with the 3/8" (9.5 mm) holes attached to the spars.
14. Now assemble the posts. Begin by screwing on four hinge pieces, one to the top of each post (for all the screwed assemblies it is helpful to drill pilot holes). There are four #8 – 32 x ½” screws for each hinge, two on one side and two on the opposite side. Use diagonal holes such that the screws on one side are not opposing those on the other side. With the top loom hinge pieces installed, lay out two posts with the hinge pieces of the loom and posts placed together (no pin yet). Make sure that the two posts are parallel and in line with the loom spars. Screw one of the plywood panels to the posts, after squaring it up.
15. Do the same procedure to the other side of the top loom. You should now have two post assemblies each with 2 posts and one plywood panel.
16. Now take one of the post assemblies and put it on its side such that one hinge is up and one is down (i.e. the plywood panel is vertical). Support the piece either by putting heavy objects around it or using a clamp. The top loom can now be positioned with the hinge pieces in place and aligned with the post hinge pieces. Insert hinge pins into each hinge (again refer to Photo 7) shows how the hinge pieces go together once the posts are assembled). Do the same with the second post assembly, and turn the frame upright (top loom on top). Photo 8 shows the frame turned on the side in order to do the top hinge assembly, before turning it upright. Support the frame (it can be leaning slightly against a wall) once it is turned upright, because the hinges are not yet locked in place.
17. Place the four lower post hinge pieces on the posts without making the attachment permanent, by using clamps or tape. Place the bottom loom in the frame so that two hinges are aligned and insert two pins. Then pin the second two hinges. On the next step attach the lower hinges to the posts once the LED strings are strung in the serpentine pattern and the tension is adjusted to align the lights.
18. Take a string of LEDs and clip it on to the edge of the first wire of the top loom such that the first pixel is just below the wire. Count off ten pixels and adjust the bottom hinge so that the tenth pixel is just above the wire when the LED string is pulled taut. Do this for all four of the bottom hinges, and then screw them in. The frame is nearly done, and the only remaining item is a locking mechanism to keep it from unintentionally folding flat.
19. Put the last two wire connectors on the bottom loom spars, clip on the lock wires, square up the structure and mark holes for the lock wire holes in the posts. Drill the holes and insert the lock wires which prevent the cube from collapsing. See Photo 9.
20. Almost done with the frame. All that remains is the cover that will slide down over the electronics panel, as shown in Drawing 8. The cover is more or less glued together. Use wire nails and clamps to hold the pieces together while the white glue dries. After the glue dries, sand and paint the cover.

For my earlier outdoor projects, I would have a power supply inside the house, with 5 volt lines going to the LEDs outside. This was OK for 400 – 500 LEDs, but for 1,000 LEDs the 5 Volt lines were getting big. Even with 12 volt power I was feeling limited by moving power over a suitable distance, with expensive electrical wires capable of supporting suspension bridges. The solution I selected was to run 120 V AC out to the cube, and put a waterproof 12 DCV power supply there. The ESP32 and level shifter needs 5 V, so I included a (again waterproof) buck converter to drop the ESP32 input voltage from 12V to 5V. 12 V LED light strings reduce voltage drop along the length, compared to 5V. There are four points of voltage injection thus the higher voltage may not be necessary, but it is not difficult to do given the physical layout.

Before putting it all together it is always best to upload the program to the ESP32 and then breadboard all components and wiring.

The overall wiring diagram is shown in Drawing 5. The power supply has 3 x 100 W lines, which split into 6 pairs of 12 volt wires. Five of the pairs go to the LED strips and these are terminated with JST connectors. The sixth pair goes to the converter. I wanted to be able to disconnect everything for troubleshooting and the ability to quickly change out components needing repair, thus I used WAGO connectors to do the splicing. By the time I was done with this I realized I did not save all that much time and I could have soldered everything up! The WAGO connections are housed in a 3D printed box for weather protection and a more spiffy appearance, as shown in Photo 10. The 5 volt wires leaving the converter go to the +5V and GND pins of the ESP32.

The ESP32 is mounted on pin headers as shown in Photo 11. The photo also shows components that I ended up not using, such as capacitors and the level shifter. I have included two versions of the wiring diagrams; both with and without the extra items. I admit that I was having trouble getting the level shifter to work reliably (I probably burned it out by mistaken wiring) so I bypassed it. The capacitors I started with are way beyond anything needed and are not strictly speaking required. However, the WLED web site does recommend some capacitors for max stability.

Referring to Drawing 6 and 9, these are the connections for the version with the level shifter. If a wire is on side of the ElectroCookie being viewed it is opaque, and if it is on the other side it is 40% transparent.

It is best to solder the wires to the ElectroCookie board before soldering in the pin headers and level shifter mount. Otherwise, there is always the temptation to put the soldering iron on the plastic headers when soldering the wires, thus rendering them non-functional. I never do anything like this; I’m just speaking for a friend.

Note that with the quad level shifter the data line for String 0 is not shifted to 5 volts, even in the level shifted version. All I had was quad, but there are level shifters available that will handle 8 data lines. For the most robust design this is what I would use, especially if you are running data lines over a longer distance. String 0 worked fine for me, though, and I just made sure the non-shifted data line was closest to the ESP32.

During breadboard testing I discovered that I was able to get stable operation without any level shifter or capacitors at all, and that I was able to go directly to the LED strings. That prompted me to go with Version 2.0, where there are only two power connections and five data connections all directly to/from the ESP32.

For the purpose of minimizing soldered connections and wire-bending, I just put a second pin header right next to the ESP32 header and I stuck 20-Gauge wires into them for transmitting data. On the other end I used waterproof heat-shrink butt connectors to 18-Gauge wires which then have heat-shrink butt connectors connecting to the JST connectors (the large male end). The data lines connect to the smaller female end of the LED strings. This greatly simplifies things, and the cube operation has been very reliable. I hope the photos aren’t too confusing; the level shifter and capacitors are visible but they are not connected in any way. The wiring is as shown in Drawing 7. The data lines come from ESP32 pins GPIO 16, 17, 18, 21 and 22 (PCB coordinates A 8, 9, 11, 14, and 17, respectively). Strip about ¼” of insulation off of the solid 20-gauge wires and stick them into the outside pin headers. Photo 12 shows the ESP32 in the project box with the data wires ending in one side of the crimped butt connectors. When routing the wires avoid going over the ESP32 antenna. I used M3 heat inserts on the two posts and an M3 bolt to mount the ESP32 board.

I am not going into all the details on how the effects work, but there are some features worth knowing about. These include

1. FastLED library
2. Visual Studio Code with the Platformio extension
3. Minimal OTA programming (OTA = Over the Air)

The FastLED library provides support for many different LED types, and handles the timing between the LED strings and Micro Control Unit (MCU – in our case the ESP32). I have read that the 12 volt fairy lights are not made to true WS2812B specs, but this is the type that works in the FastLED.addLeds<> statement. In the main.cpp program we specify a five member array of LED strings, each receiving an output from an ESP32 pin. Each string has 200 LEDs.

In the draw.h file the LEDs are mapped such that every x, y, z, coordinate corresponds to a unique string (0 to 4) and index along the string (0 to 199). This mapping accounts for the serpentine patterns on the X and Z planes by using different formulas for even and odd rows.

For maximum speed I ended up using lookup tables for trigonometric functions (sine_lut.h and sphere_lut.h), but FastLED does have fast functions such as sin8() which are also employed. OK, the FastLED functions are also “lookup” and they are probably better than mine, but I was just learning the FastLED ropes at the time!

Another great feature FastLED has to offer is color palettes. This makes it possible to create cool effects with flowing color gradients, without too much effort. Here is a great video showing how to do it, and how to make your own gradients: FastLED Basics. The palette.h file contains all the palettes used in this project.

I use Visual Studio Code (VSC) with Platformio for programming large projects, and this project qualifies. I find the artificial intelligence aids a lot with its coding suggestions and it saves me time dealing with multiple large files. This tutorial was very useful when I started down that path: Random Nerd Tutorial on ESP32-VSC-Platformio.

Once you install VSC and Platformio, install the FastLED library from the Platformio home page. Click on the library icon in the left pane and search for FastLED. The version used for this project is 3.10.3.

The purpose of OTA is to allow uploading programs to the ESP32 over WiFi. This is convenient when dealing with a physically large project or one that is remote from the programming device. The OTA is built into the Arduino framework, and requires no build flags or extra libraries in platformio.ini. I used this example to get started with the ESP32 OTA:

Techoverflow.net Minimal-platformio-esp32-ArduinoOTA-example

With this code included in the program upload once using USB. After that it is possible to upload via WiFi. You need to get the IP address of the ESP32, either by looking for an ESP32 device on your router device list, or starting up a Platformio serial monitor while the ESP32 is still USB connected. You also need to have the SSID and password for your WiFi.

OTA is not mandatory but it makes developing new effects much easier. The platformio.ini file includes the following lines to activate OTA (you need to change the upload port to your ESP32 IP). The main.cpp runs and starts WiFi communications.

upload_protocol = espota

upload_port =192.168.1.85

To use a USB cable, just comment out those two lines.

Summarizing:

1. Install VSC
2. Install Platformio (use Random Nerd tutorial for these two steps)
3. Create a new project from the Platformio home page named LEDCube. This folder will be in the C:\Users\username\Documents\PlatformIO\Projects\ folder. Use espressif32 for the platform, esp32dev for the board and arduino for the framework. The new project will have its own platformio.ini file, and you need to cut the contents from that file and paste in the contents from the platformio.txt included in this Instructable.
4. After editing the platformio.ini file, hit CTRL-S to save. This will kick off a big process of installing a lot of files, including the FastLED library. Download the project files below. Place all of the downloaded header files (the .h file type) in the \include directory. Put the main.cpp file in the \src directory. You can actually drag the files from the operating system file manager and put them in to the folders in the Visual Studio Code Explorer.
5. Use the Platformio file explorer to open platformio.ini.
6. Comment out the upload protocol and port entries (i.e. the two lines mentioned above).
7. Connect the ESP32 using a USB cable, and make sure it’s a DATA cable (man, if only I could get all those hours back)!
8. Hit the arrow button on the lower left of the screen to begin compilation and upload (Photo 14). The first time it compiles it takes a long time.
9. When the upload starts you will see something like uploading to COM3… If the dots continue and the process times out, it means you have to press the EN button on the ESP32 board. Do this when the dots first show up to avoid the time out. Usually I only have to do this once but if you have to push the EN button every time, put a 10 uF capacitor across the EN pin and GND and that behavior will stop.
10. After a successful upload, open the serial monitor by hitting the button that looks like an electrical plug. The ESP32 will reset. It will tell you when it has started its WiFi, and then the IP address.
11. If you want to use OTA, uncomment the upload entries in the platformio.ini file and put in your own ESP32 IP address.

More notes on OTA: If you are compiling and uploading a short program it works great if you just a) power down the ESP32, b) start the upload in Platformio, and c) power on the ESP32. The ArduinoOTA.handle() activates and begins the upload. However, the loop only calls the handle once, and for a long upload time the handle times out. The handle should be called every 10 – 100 ms. I dealt with this by putting in a loop to call the handle for about 10 seconds before the program proceeds. This results in some waiting but usually gave me enough time to develop two or three effects at a time. It takes a while to get used to the OTA handle, but once you do it is very convenient. This is the loop, and you can reduce the 10000 value or completely get rid of it if you time your power cycles and uploads correctly:

for(int otaLoop=0; otaLoop<10000; otaLoop++) {

ArduinoOTA.handle();

FastLED.delay(10);

}

Alright, once this is working there is still one more challenge. With the USB data transfer one can debug using serial.print() to the Platformio monitor. With OTA the serial connection is not available, thus for debugging it is necessary to set up communications over WiFi. The #include file “TCPUtils.h” serves this purpose. It is not completely straight forward because you can’t just replace serial.print statements (the new print command requires strings), but it does provide a way to watch variables during program execution. Here is an example of implementing it to monitor the integer variable “y” in effect_loadbar.

Main.cpp:

effect_loadbar(&client,100, CRGB::DarkViolet);

Effect.h:

void effect_loadbar(WiFiClient* clientPtr, int delay, CRGB color)

{

FastLED.clear();

TCPPrintln(clientPtr, "loadbar\n");

int y;

CHSV hsvcolor = rgb2hsv_approximate(color);

for(y=0;y<CUBE_SIZE;y++)

{

TCPPrintln(clientPtr, String(y));

setplane_y(y,hsvcolor.hue,hsvcolor.sat,hsvcolor.val/2);

FastLED.show();

FastLED.delay(delay);

}

FastLED.delay(delay*3);

for(y=0;y<CUBE_SIZE;y++)

{

TCPPrintln(clientPtr, String(y));

setplane_y(y,0,0,0);

FastLED.show();

FastLED.delay(delay);

}

}

To monitor output, any function parameters have to include the WiFi Client pointer (clientPtr), which must be addressed (&client) when the function is called. The TCPPrintln function requires the client pointer and a string. This is not as convenient as serial.println but it gets the job done. You just have to convert any variable you want to monitor to a string. Now, it is possible to upload and debug over WiFi. To see the output, open a new Platformio terminal and type the command “pio device monitor –port socket://192.168.1.85:23” using your own ESP32 IP. In platformio.ini the option “monitor_filters = direct, log2file” allows you to log the text output file in the \logs directory for further examination.

1. Run each 18-Gauge data wire from the ESP32 project box to the appropriate LED string JST connector. The LED string data wire is the center wire. Cut the wires a little bit long at this time, and then cut to final length when making the connection to the LEDs. Crimp the 18 and 20-Gauge wires together (running the 18-Gauge wires through the hole in the project box) and use a heat gun to make the connector waterproof seal.
2. For the connections between the 18-Gauge stranded wire and the LED string center wire, again use the heat shrink butt connector. In my case the LED wire is too thin to get a water tight connection, and I put a little E6000 glue in the end of the connector after crimping and before applying heat. Now the wiring for the data is all connected, and we move to the power wiring.
3. At this point just keep the power supply, buck converter and project boxes in their approximate locations without mounting them – we will need to make adjustments along the way for wiring runs.
4. Starting with the power supply, begin by removing about 2 inches of the outer insulation, and 1 inch of the red wire insulation. Put heat shrink tubing on the red wires and solder on an inline fuse holder (automotive – waterproof). Move the heat shrink tube to cover the solder joint and apply heat. Do this for each of the positive lines from your power supply, and adjust the fuse rating. For example, a single wire would need at least a single 25 Amp fuse. For maximum security, put a fuse on each of the five LED strings rated for 5 Amps.
5. The other ends of the inline fuses go into the WAGO project box. Within the box there are six 221-413 connectors: three +12 V and three GND. Each WAGO splits each pair of incoming power lines into two pairs of exit lines. Five of the +12 V lines go the five LED strings connecting with the red wire, and five GND go to the five LED GND wires. The sixth pair of exit lines goes to the converter. All power connections are accomplished with the heat shrink butt connectors, with the exception of the converter which has long enough leads to go all the way to the WAGO. The power lines for the LEDs are also thin, just like the data lines. Use E6000 before applying heat.
6. The outlet wires of the converter connect to 20-Gauge solid wire, which then goes into the female pin headers in the ESP32 box (connected to +5 V and GND pins on the ESP32). See Photo 15.
7. It is a big tangle of wires at this point, but some order can be brought to bear on it by using the 3D printed wire clips. Then adding the cover provides weather protection in addition to hiding the wiring disorder.
8. After the assembly, check continuity between +12 and GND to make sure there are no short circuits (if all is good resistance is nearly infinite), and then… power it on! If all goes well, the lights will operate according to the programming.
9. Now the various items can be attached to the panel using wood screws. The WAGO box mounts in the inside using flat head wood screws. Press the WAGOs into their slots after mounting the box. Attach the lids of the ESP32 and WAGO boxes (Photo 16). Before going through the effort of weaving the LED strings, turn on the power and confirm everything is working.
10. Run the LED strings along the serpentine paths, starting with LED String 2 (the middle one). All of the strings go under the first bottom loom wire and then go the top loom. Direction is important for the data wires: the Female End of the first 100 pixel LED String is the one that connects to the ESP32, and the Male End connects to the second string Female End (see Photo 17 for gender assignment). If we set the convention that the electronics panel is on the back of the cube, the first string of each pair goes from back to front and connects to the second string of the pair which goes front to back. Use the 3D printed LED clips as needed to keep the LEDs aligned, but do so at least on the first and last LED of each layer of 100.
11. Go along the length of each string, and make sure there are no twists that would shorten the effective length of the string and affect the LED alignments.
12. Waterproof the JST connections by slipping on (it is a tight fit) 3/8" heat shrink tubing. Before applying the heat put some E6000 glue in the annular space between the wires and the tubing. Heat shrink the tubing and the adhesive should fill the annular space to create a waterproof seal. I also use those small clamps that are like clothes pins to keep everything together until the glue cures. See Photos 18 through 21.
13. The finished cube is shown in Photos 22 and 23. Make final adjustment to the horizontal LED alignments by sighting along the vertical serpentine planes and making them as flat as possible and equally spaced apart. If lights are mis-aligned vertically check again for twists in the string. However, the effects are still very good even with a little mis-alignment.

The most difficult part of this design is dealing with the 9-Gauge wire. Just about every aspect, from cutting, straightening, to lining them up to install on the spars, is a big task. The 9-Gauge wire takes a good drill and vise at a minimum, or special wire rollers, stretchers, etc. in the worst case. If I build another one of these I will first attempt replacing the wires with taut fishing line. Just install the loom spars in the hinges and then use fishing line pulled tight between the spars. I have not tried this, but the only problem I see is that the lines must be taut, and this puts torque on the posts which will then deflect inwards as a result. Putting dowels between the posts would solve this without obstructing the view too much, but some post bowing may not be a big problem; there will still be room for all ten rows of LED strings. If anyone builds the cube with fishing line for the loom wires I would certainly be interested in the results!

Another improvement would be a better way to lock the hinges. Something used for a folding chair or table would be an improvement, but by the time I got to this part of the design I was just wanting to finish. I will probably come back to this some day, but in the meantime I plan to put the posts into four pieces of PVC piping driven into the ground to keep the cube upright and more resistant to the wind.

And finally, there is a lot more space on the ESP32 for even more great effects. Colored fireworks and perhaps a simulated 3D space invaders video game come to mind. So many possibilities... have fun!