Durian Lamp: A 3D Printed ESP32 & WLED Lamp
31 Aug 2026(Updated 7 Sept 2026)
It started with a simple problem: my girlfriend was coming to visit for a four-week holiday and my bedroom can get pretty dark at night, so I wanted to get her a small night lamp. I could buy one, of course, but where's the fun in that? So I decided to make one myself.
The next question was what it should look like. My girlfriend loves durian fruit, and me not so much, especially the smell of it. Whenever she buys one, I feel like I can smell it everywhere. So I thought a lamp in the shape of a durian could be the perfect solution for both of us.
The first durian#
The idea was fairly simple: 3D-print a translucent durian, put an addressable LED strip inside and control it with an ESP32 running WLED.
I initially experimented with placing the LEDs vertically inside the lamp, similar to what I did with my word clock. But that required a lot of cutting and soldering. Instead, I found that I could just wrap one continuous LED strip horizontally around a central column. It was much easier and actually gave a better effect as well.
When my girlfriend arrived, she liked the lamp, but as a durian lover she had some suggestions. And she was right. The shape could use some better grooves and the stem didn't look quite right. After changing those, it started looking much more like an actual durian.
She was very happy with the result and showed it to her mom. Her mom wanted one too, but a smaller version. That led to a second design: a mini durian made to fit a simple LED tea light. So before I'd even finished improving the original lamp, it had already produced a smaller spin-off.
An experiment with AI-generated 3D modelling#
The durian was also my first project where I used AI for most of the 3D modelling instead of designing everything myself in Fusion 360. I took it a bit further than simply asking AI to generate a model. I built a Three.js web interface around it where I could configure the durian before exporting it.
I could change the overall size and height, choose between different power inputs, change the spike height and number of spikes, and configure different options for the base, such as USB-C or a regular power input. Everything scaled automatically.
At first, this felt great. I was able to get something fairly complex working surprisingly quickly. I printed it and, even better, the dimensions were right. The stem fitted, the power connector fitted and all those configurable parts actually worked.
Then I needed to start making changes. That's where it became much less fun. Giving AI precise instructions for changes to an existing 3D shape turned out to be much harder than creating the initial version. Once I started printing more versions, I also discovered problems that weren't immediately obvious in the model.
For example, some parts of the shell didn't have a consistent wall thickness, which eventually caused printing problems. It was an interesting experiment and I'm glad I tried it. It showed me how quickly AI can help create a configurable 3D model and even build an interface around it.
It also convinced me not to use this approach again for a model like this. For something I expect to keep modifying and refining, I'd rather go back to Fusion 360 and have full control over the geometry.
Then I broke it#
The physical design was getting better, but the electronics were still very much a prototype. One day I took the lamp into the kitchen to try it out. The resistor connection on the LED data line came loose and the first LED in the strip stopped working.
Annoying, but it taught me a good lesson. If I wanted this to be an actual lamp rather than an electronics experiment sitting next to my bed, I needed to make the inside as reliable as the outside. That's when a simple night lamp started turning into a much bigger electronics project.
Why not just use a light bulb?#
There is, of course, a much easier way to build a lamp. I could have designed the base around a normal E27 socket, screwed in a smart bulb and probably saved myself a ridiculous amount of time.
But where's the fun in that?
I had just bought a new soldering iron and wanted to learn more about electronics, so this seemed like a good excuse. And it definitely turned into a learning project.
I learned how to solder perfboards, how to use a multimeter properly, how to check continuity and find connections that should or shouldn't be there, and how to debug a board before plugging in an ESP32 and hoping for the best. I've killed two or three ESP32s across different projects in the last few months, so that last part was probably a lesson I needed.
Every new perfboard got a little better. Not every solder joint works perfectly the first time, at least not when I make it, but now I actually know how to find the problem instead of staring at a board wondering why nothing works.
And in return for all that extra headache, I also get a completely customizable lamp. WLED gives me effects, brightness control, rainbow colors and pretty much anything else I want to add later.
Could I have done something similar with a smart bulb? Sure, without all the nice effects.
Would I have learned nearly as much? Nope.
Version 1: The prototype#
The first electronics were about as simple as I could make them. An ESP32 running WLED controlled the addressable 5 V LED strip, with a 330 Ω resistor between the ESP32's data output and the LED strip. Power came from a regular 5 V USB supply. The LED strip was wrapped around the central column inside the lamp, with the ESP32 and wiring hidden inside the base.
It proved that the concept worked, but the loose wiring and soldered connections weren't something I wanted to rely on permanently. Breaking the data connection made that very obvious.
There was also another small problem: the lamp could only be controlled through WLED using the app or a browser. That's not very convenient when you're lying in bed in the dark and just want to turn on a lamp.
Main parts:
- ESP32
- 5 V addressable LED strip
- 330 Ω data resistor
- 5 V USB power
- 3D-printed translucent shell, base and column
Version 2: Moving to perfboard#
For the next version, I wanted the electronics to feel less like a prototype. I moved the connections onto perfboard and added a 1000 µF capacitor across the LED power supply. More importantly, I changed the power distribution.
Instead of sending the LED current through the ESP32 board, the incoming 5 V supply was split so the ESP32 and LED strip each had their own connection to the main power rails. That gave me a much cleaner power path and meant the ESP32 wasn't being used as a power distribution board for the LEDs.
I also wanted a physical way to turn the lamp on and off without having to find my phone in the dark. So I cut the USB power cable and added an inline cord switch.
It worked well, but there was another problem. Pretty much everything was soldered together. The board lives inside the central column, so getting it in and out means pushing and pulling the electronics through a fairly small space. Eventually I broke one of the wires while doing that.
That made the next improvement pretty obvious: instead of soldering everything permanently together, I wanted the individual parts to be removable and replaceable.
Main changes:
- Perfboard instead of loose connections
- 1000 µF capacitor
- Dedicated 5 V and ground rails
- Separate power branches for the ESP32 and LED strip
- 330 Ω resistor retained on the data line
- Inline cord switch for physically turning the lamp on and off
Version 3: Making it smaller and cleaner#
The first perfboard worked, but it was larger and messier than it needed to be. Everything was also still soldered together and couldn't easily be disconnected. So I made another one.
The goal wasn't really to change how the lamp worked. I wanted to improve the physical design of the electronics: shorter connections, better component placement and a more compact board that was easier to fit inside the base and easier to remove again.
This was also where I started thinking less about simply making a working circuit and more about making the electronics into an actual module that could be removed, repaired or replaced.
I liked this version a lot more, but there was still one part I didn't trust. The USB-C connector was mounted directly onto the perfboard. I secured it with hot glue, which worked, but every time I plugged or unplugged the USB cable I could feel that this would probably become the next thing to break with heavier use.
Main changes:
- Smaller perfboard
- Cleaner component layout
- Shorter wiring
- More compact power distribution
- Easier to fit inside the lamp base
- More focus on making parts removable
Version 4: Moving USB to the enclosure#
There was still one weak point: the USB connection. The USB-C power connector was attached to the perfboard itself and glued into position. Every time the USB cable was plugged in or removed, some of that force ended up being transferred to the board.
It worked, but I didn't trust it as a long-term solution. For the next version, I separated the USB connector from the electronics completely. The USB-C input is now mounted directly into the wall of the 3D-printed base. From there, two wires carry 5 V and ground to the internal perfboard.
That means plugging in the lamp puts the mechanical stress on the enclosure instead of the electronics. I also changed the rest of the board with repairability in mind. The wiring now uses JST and JST-PH connectors where possible, so parts can be disconnected and replaced instead of being permanently soldered together. The ESP32 itself is removable as well.
I deliberately put much of the wiring on top of the perfboard too. It's not quite as hidden, but it makes the connections much easier to see and understand when I need to work on it.
Finally, I added a resettable fuse to give the power input some extra protection. At this point, the perfboard had gone from being a place to solder some wires together to becoming its own removable controller module.
Main changes:
- USB-C connector mounted in the enclosure
- Separate wires from USB input to the perfboard
- No mechanical load from the USB cable on the circuit board
- JST and JST-PH connectors for removable components
- Removable ESP32
- More visible and easier-to-follow wiring
- Resettable fuse
- More modular internal electronics
- Easier to remove, repair or redesign the controller later
At this point the electronics were basically finished. So naturally I grabbed an ESP32 Mini to make an even smaller version.
No. Finish the lamp.
At least it was a quick test, and I got to enjoy the modularity paying off.
One more problem: heat#
With most of the electronics finally in place, I noticed one more thing during testing: the ESP32 was getting a bit warm inside the column.
My first thought was that it might somehow be related to the LED strip drawing power. Since the ESP32 and LEDs now have separate power paths, I wanted to make sure something wasn't still causing extra load on the board.
So I tested it with the LEDs running and with them completely off. As far as I could tell, the LEDs weren't the cause. The ESP32 still warmed up without them. The more likely problem was much simpler: I had put an ESP32 inside a fairly small, almost completely enclosed 3D-printed column.
So instead of changing the electronics again, I changed the print. I redesigned the column to add more ventilation around the ESP32, allowing heat to escape instead of getting trapped inside.
It's another small thing I probably wouldn't have thought much about when building the first prototype, but something that became obvious once I started treating the lamp as something that should be able to run reliably for longer periods. I like this solution as it’s also saving some filament.
Version 5: Apparently I wasn't done with the electronics#
The extra ventilation helped, but I still wasn't completely convinced that the heat was only caused by the enclosed column. There was one other thing I kept looking at: the way I had wired the perfboard.
So, of course, I made another one.
This time I gave the board proper power rails. Ground runs along one rail and 5 V along another, with the ESP32 and LED strip branching off them separately. I also moved the 1000 µF capacitor right to the LED output, across 5 V and ground, instead of making it part of the route the power had to travel through.
Electrically, this is a much cleaner layout. The capacitor is now simply connected across the LED supply where it's needed, while the main power can continue directly along the rail.
I also went further with the removable connections. Both the USB-C power input and the three wires going to the LED strip now plug into connectors on the perfboard. The LED connector probably doesn't need to be removable, but after breaking enough soldered wires during this project, I like knowing that I can disconnect the whole board without pulling on anything.
It's a small change, but this version finally feels less like a collection of components soldered onto perfboard and more like an actual little controller board. The board didn’t get hot anymore and controlling the lights was no longer flickery, so it was a good improvement.
Main changes:
- Dedicated 5 V and ground rails
- ESP32 and LED strip branch directly from those rails
- Capacitor moved right next to the LED output
- Removable power connector
- Removable three-wire LED connector
- Cleaner and easier-to-follow power distribution
- No more permanently attached external wiring
By this point I had also accumulated a small collection of failed and outdated perfboards. In case you're wondering what happens to those: I cast them into resin skulls and try to sell them.
Version 6: Okay, one actual last change#
A while ago I ordered a bunch of USB cables with inline cord switches, which are perfect for a night lamp. The only problem was that they were all Micro-USB, while I had designed the latest base around USB-C.
I could have ordered new cables. Instead, I changed the lamp again.
I made a second version of the base with a Micro-USB input. The internal wiring stays exactly the same: the connector is mounted in the enclosure, its cable runs through the column and plugs into the perfboard. Because the power connection on the board is removable, it doesn't really care whether the outside of the lamp uses USB-C or Micro-USB.
This also meant I could stop cutting USB cables apart just to add a switch. I can simply use the Micro-USB cables I already have with their built-in inline cord switch, which is much nicer for a bedside lamp.
It's a tiny addition, but also a good test of all the modularity I kept adding. Changing the external power connector no longer means changing the electronics.
Main changes:
- USB-C and Micro-USB base versions
- Both use the same internal electronics
- Enclosure-mounted power connector
- Removable connection to the perfboard
- Support for ready-made cables with an inline cord switch
- No more cutting USB cables
The video created another problem#
Somewhere along the way I made a durian song with Suno, called Durian everywhere. It was too good not to share, so now I needed to make a video.
For the video I gathered all the different durians I'd made and carried them around the house to set up different shots. That exposed another design flaw very quickly: the top shell kept falling off the base.
Until then it hadn't bothered me much. The lamp normally just sits in one place, so gravity was doing a perfectly acceptable job of holding everything together. A video shoot apparently has different requirements. After repeatedly picking the shell up from the floor, I redesigned the internal mechanism and added a proper snap-fit between the shell and the base.
The complete lamp can now be picked up and moved around as one piece without leaving half the durian behind. Yet another problem I probably wouldn't have discovered if I'd simply left the lamp sitting on the nightstand.
Current setup
The lamp currently combines:
- ESP32 running WLED
- 5 V addressable LEDs wrapped around the internal column
- 330 Ω resistor on the LED data line
- 1000 µF capacitor across the LED power supply
- Resettable fuse
- Perfboard-based power distribution
- Separate power paths for the ESP32 and LEDs
- Enclosure-mounted USB-C power input
- JST and JST-PH connectors
- Physical control button
- 3D-printed translucent durian shell
- Redesigned durian stem, grooves and shell details
- Snap-fit connection between the shell and base
- Ventilated internal column for the ESP32
So what did I actually end up with?#
After all these versions, I somehow ended up with a small modular lamp system rather than one finished model.
There is now one Durian shell, but the parts underneath it can be mixed depending on how you want to build the lamp:
- 3 bases: USB-C, Micro-USB, or a simple cable opening for the Bambu LED controller
- 2 columns: one designed for the ESP32/perfboard electronics and one for the simpler LED setup
- 1 finalized perfboard: with removable power and LED connections
- 1 Durian shell: print it in whatever color or translucent material you want
The nice part is that I don't need a completely different lamp for every version. The shell stays the same, and I can swap the parts underneath depending on whether I want the simple Bambu setup or the full ESP32/WLED version.
Which, considering this started as a simple night lamp, is probably a little ridiculous.
Just when I thought I was out...#
...they pull me back in.
At some point I made the mistake of wondering: what if I actually wanted to turn this into a real product one day? What would need to change to make it production-ready?
So I started watching some YouTube videos about taking electronics from a prototype to an actual product, and ended up at this video by John Teel. John is an electronics design engineer and used to work as a senior design engineer at Texas Instruments, so he knows a lot more about this stuff than I do. He does a really good job of explaining all the things that can go wrong once something leaves your desk and ends up in the hands of other people.
And, of course, that gave me a few more things to think about.
The current ESP32 version already has a resettable fuse, a 330 Ω resistor on the LED data line and a 1000 µF capacitor across the LED power supply. But while looking into more production-grade protection, I found two things that were easy enough to improve even on the DIY perfboard.
The ESP32 runs from the 5 V supply, but its GPIO pins still output a 3.3 V data signal. My WS2812B LEDs have been working perfectly fine with that, but a proper level shifter removes that uncertainty. So I'm adding a 74AHCT125 to convert the 3.3 V data signal to 5 V before it reaches the LEDs.
I'm also adding a tiny 100 nF ceramic capacitor next to the level shifter. The big 1000 µF capacitor helps with larger changes in the LED power supply; this tiny one deals with very fast little disturbances right next to the chip.
That should be where I stop adding things to the perfboard. Should.
If I ever actually turn this into something I want to sell, that's a different story. I'd make a custom PCB and properly look at things like ESD, overvoltage and transient protection, PCB trace sizing, thermal behaviour, testing and all the other boring things that suddenly become very important when you're building something for strangers instead of yourself.
For now, the ESP32 version remains what it was supposed to be: a DIY electronics project, not a commercial product.
Almost finished#
It's quite a long way from the simple night lamp I originally planned. The lamp itself is essentially there, but I'm still making some final improvements before I consider it finished.
I'm currently experimenting with printing the internal column upside down. This uses less filament and avoids supports, but required some geometry changes to make it printable. The first attempt technically worked, but ended with a bit of spaghetti inside. Nobody would ever see it and the lamp would still work, but I know it's there, so I want to fix it.
The changes also mean my latest perfboard and ESP32 assembly doesn't quite fit anymore. On the upside, the new design should eventually give me better ventilation, better placement of the electronics and use less filament.
The slightly ridiculous part is that all of this is actually phase two. I still want to release a simple version first using just the Bambu LED strip and controller, with no ESP32, WLED or soldering. The ESP32 version will be the follow-up for anyone who wants to experiment a bit more. So I'm already redesigning phase two of a project whose phase one I haven't even published yet. For me, it's finished when both versions are tested, the video is done, and the files are available for free on MakerWorld.
Until then, this page remains a snapshot of a project that is still getting its last few unnecessary improvements.
