s k i n . el e c t r o n i c s¶
Skin Electronics represents a cutting-edge domain where art, science, and technology converge, enabling the human body to interact with the digital world in unprecedented ways. It explores the integration of wearable sensors, conductive materials, and flexible circuits directly on or near the skin to create systems that respond to environmental stimuli or body signals. This fusion of functionality and aesthetics unlocks new dimensions for creative expression, medical innovation, and human-computer interaction, challenging the boundaries between the organic and the synthetic.
This week in the Fabricademy, we delve into the realm of Skin Electronics, seeking inspiration from visionary projects and pioneers at the intersection of art and science.
i n s p i r a t i o n¶
ELECTRONIC TATTOOS BY JOHN A. ROGERS
John A. Rogers revolutionized wearable technology with his development of "Electronic Tattoos." These ultra-thin, flexible circuits adhere seamlessly to the skin, enabling real-time monitoring of physiological data like heart rate, hydration levels, and muscle activity. His work transforms wearable electronics into something unobtrusive and almost imperceptible, paving the way for next-generation medical diagnostics and human-machine interfaces. Rogers’ approach emphasizes functionality and precision, inspiring a pragmatic yet innovative perspective on Skin Electronics.
DAE-HYEONG KIM: SKIN AS A SENSOR, MEDICINE AS DESIGN
Dae-Hyeong Kim’s research pushes the boundaries of what synthetic skin can feel and do, by developing ultra-thin, stretchable electronics that closely mimic the properties of real human skin. One of his team's recent innovations involves a polymer material embedded with dense networks of ultrathin gold and silicon sensors—achieving a tactile sensitivity never seen before. With up to 400 sensors per square millimeter, this “smart skin” can detect heat, pressure, and moisture, offering the kind of feedback that could transform prosthetics into truly sensory tools. The serpentine configuration of brittle silicon allows the sensors to stretch with the natural movement of the body, achieving both flexibility and precision.
What sets Kim’s approach apart is not only the technical performance but also the deep attention to biological realism. By studying how a human hand moves and stretches, his team was able to tune the material’s elasticity depending on location, making it adaptable across different parts of the body. They even integrated actuators that warm the material to the temperature of human skin, creating a more natural feel for the wearer.
KATIA VEGA: BEAUTY THAT CONNECTS, CONTROLS, AND COMMUNICATES
From the very beginning, I was excited about the week of skin electronics. The idea of bringing technology closer to the body—making it part of our skin, our gestures, our identity—felt like a major shift in how we interact with the digital world. As I explored Katia Vega’s work, I found it both amazing and surprising. She pushes the boundaries of what technology can look like, and where it can live on the body. Her projects move beyond wearables and into a space where electronics become embedded in beauty practices—offering new, expressive ways of interacting with the world.
Vega transforms the world of beauty into a technological playground, where cosmetics, accessories, and even hair become interfaces for digital interaction. Through her "Beauty Technology" project, she has developed conductive makeup that can trigger lights or sounds, and false eyelashes that function as switches. By embedding sensors and circuits into fashion and cosmetics, Vega challenges traditional views of femininity, control, and visibility. Her work doesn’t just enhance aesthetics—it turns the body into a platform for expression and control, inviting new ways to think about identity, inclusion, and interaction. Her approach opens space for artists and technologists to explore more intimate, creative, and culturally relevant uses of digital tools.
MELISSA COLEMAN: POLITICAL LACE AND THE BODY AS MEMORIAL
Political Lace was one of the most thought-provoking works I encountered while exploring the intersection of electronics and the body. As I anticipated the week on skin electronics, I was drawn to how artists like Melissa Coleman use technology not only as a tool but as a language for raising awareness. Her Political Lace project does exactly that—it turns a traditional lace collar into a wearable memorial that communicates a deeply urgent message. Using soft, ornamental materials and subtle electronic interaction, the collar lights up with a single white LED for every girl who dies before the age of 18 due to preventable causes related to childbirth.
The work is based on a staggering statistic from UNICEF: every 7.5 minutes, a young girl dies from complications tied to poverty, child marriage, lack of education, and limited access to healthcare. Coleman embeds this reality into the design of the lace, using fading lights to represent lives lost—brief illuminations that disappear just as quickly as they appear. The piece isn’t meant to be flashy; its power lies in its simplicity and intimacy. Political Lace demonstrates how wearable electronics can be more than aesthetic or functional—they can be political. By combining craft, data, and emotion, Coleman gives form to silence and transforms the body into a space of remembrance and resistance.
g l o v e . p r o t o t y p e¶
Trying to make my first glove, I started by following the instructions from the first video I found on YouTube about glove-making.
I traced my hand on paper to create a basic pattern, keeping it simple for a quick test. Since this was just a prototype, I decided to make a three-finger glove using a two-axis stretch, skin-colored Lycra. After finalizing the pattern, I carefully transferred it onto the fabric, ensuring the stretch direction would allow flexibility and comfort.
Once the fabric pieces were cut, I stitched them together, testing the fit and movement. The Lycra’s stretch worked well, but I noticed some areas where the seams needed adjustments for better finger mobility. The tutorial helped guide me through the process, but I quickly realized that small tweaks were necessary to get the right fit. This quick prototype gave me a good understanding of how the material behaves and how I could improve the pattern before attempting a full glove.
The next step was integrating a DIY flex sensor into the glove. My plan was to attach the sensor along the fingers to capture movement and translate it into data.
f l e x . s e n s o r¶
To create the DIY flex sensor, I used conductive thread, tape, and a piece of velostat, guided by this youtube video.
Velostat is a pressure-sensitive material that changes resistance when bent, making it perfect for detecting movement. I started by cutting a thin strip of velostat, ensuring it was long enough to fit along the finger section of my glove. Then, I placed two parallel lines of conductive thread on either side of the velostat, securing them with tape to keep everything in place.
The key was to ensure that the threads didn’t touch each other directly, as the velostat needed to act as a variable resistor between them. When the sensor was straight, the resistance remained high, but as it bent, the resistance decreased, creating a measurable change.
After assembling the sensor, I tested it in the Arduino IDE using an ESP32-C3 Super Mini. I connected the conductive thread ends to one of the analog input pins with pull-down resistor and ground, then ran a simple analog read code to measure resistance changes. The sensor responded when I bent it, but the results were not too satisfying—the range of data variation was quite small, making it difficult to get precise readings.
To enhance performance, I considered layering multiple sheets of velostat or using a different conductive material with better sensitivity.
In the next step, I replaced the conductive thread with conductive textile, hoping to get a more stable and responsive sensor. I cut two thin strips of conductive fabric and placed them on either side of the velostat, ensuring they remained parallel and didn’t touch. I then secured everything with tape, making sure the layers stayed firmly in place while still allowing flexibility. This setup provided a larger conductive surface, which I suspected would improve the sensor’s sensitivity.
After assembling the new version, I tested it again with the ESP32-C3 Super Mini in the Arduino IDE. The difference was immediately noticeable—the range of data variation was much wider, making it easier to detect bending movements. The conductive textile provided a more consistent connection compared to the thread, reducing fluctuations and improving overall accuracy.
After making the flex sensor, I sewed it onto the glove, attaching it to one finger. Initially, I tried sewing through the tape that held the sensor layers together, but the needle couldn’t pass through it properly. To work around this, I decided to sew the conductive fabric directly onto the glove using conductive thread, ensuring a strong electrical connection. Once that was in place, I used regular thread to sew the velostat and the second layer of conductive fabric, securing the entire sensor to the glove.
However, after reconnecting it to the board, I noticed a drop in functionality. The sensor’s response became weaker, and the range of data variation was even smaller than before.
I suspected that the stitching process had altered the sensor’s pressure distribution or caused unwanted resistance in the conductive fabric. The layers might not have been making proper contact, or the conductive thread could have introduced inconsistencies in the electrical pathway.
To fix this, I started looking for a fabric tape that could securely hold all the parts together without interfering with flexibility or conductivity. A softer, non-rigid adhesive could help maintain good contact between the layers while avoiding the issues caused by sewing. This experiment highlighted how delicate the balance is between structure and functionality in wearable electronics, pushing me to refine my approach for the next version of the glove.
The next step is to implement the flex sensors on the glove. Two fingers worked great with two servo motors. I attached my 3D-printed modules to the servos for better demonstration.
p r o g r a m m i n g¶
w i . f i¶ To obtain the mac address
#include <WiFi.h>
void setup() {
Serial.begin(115200);
delay(1000); // Small delay to ensure Serial Monitor is ready
WiFi.mode(WIFI_MODE_STA); // Set WiFi to station mode
Serial.print("ESP32-C3 MAC Address: ");
Serial.println(WiFi.macAddress());
}
void loop() {
// Nothing here
}
Sender Code (ESP32-C3 Super Mini)
This code reads two DIY flex sensors (on pin 0 and pin 2) and sends their values to the XIAO ESP32-C3 using ESP-NOW.
#include <esp_now.h>
#include <WiFi.h>
uint8_t receiverMac[] = {0x64, 0xE8, 0x33, 0xB6, 0xAD, 0x3C}; // XIAO MAC Address
typedef struct {
int flex1;
int flex2;
} SensorData;
SensorData flexData;
void sendData() {
flexData.flex1 = analogRead(0); // Read flex sensor 1
flexData.flex2 = analogRead(2); // Read flex sensor 2
Serial.print("Sending: Flex1 = "); Serial.print(flexData.flex1);
Serial.print(" | Flex2 = "); Serial.println(flexData.flex2);
esp_err_t result = esp_now_send(receiverMac, (uint8_t *)&flexData, sizeof(flexData));
if (result == ESP_OK) {
Serial.println("Data sent successfully!");
} else {
Serial.println("Failed to send data...");
}
}
void setup() {
Serial.begin(115200);
WiFi.mode(WIFI_STA);
if (esp_now_init() != ESP_OK) {
Serial.println("ESP-NOW Init Failed!");
return;
}
esp_now_peer_info_t peerInfo = {};
memcpy(peerInfo.peer_addr, receiverMac, 6);
peerInfo.channel = 0;
peerInfo.encrypt = false;
if (esp_now_add_peer(&peerInfo) != ESP_OK) {
Serial.println("Failed to add peer!");
return;
}
Serial.println("ESP-NOW Sender Ready!");
}
void loop() {
sendData();
delay(500); // Send data every 500ms
}
Receiver Code (XIAO ESP32-C3)
This code receives data from the Super Mini, checks if the flex sensor values are below 300, and moves the servos (on pin 0 and pin 2) to 90° when triggered.
#include <esp_now.h>
#include <WiFi.h>
#include <ESP32Servo.h>
Servo servo1;
Servo servo2;
typedef struct {
int flex1;
int flex2;
} SensorData;
SensorData receivedData;
void OnDataRecv(const esp_now_recv_info_t *info, const uint8_t *data, int len) {
memcpy(&receivedData, data, sizeof(receivedData));
Serial.print("Received: Flex1 = "); Serial.print(receivedData.flex1);
Serial.print(" | Flex2 = "); Serial.println(receivedData.flex2);
// If flex sensor value is below 300, move servo to 90 degrees
if (receivedData.flex1 < 300) {
servo1.write(90);
} else {
servo1.write(0);
}
if (receivedData.flex2 < 300) {
servo2.write(90);
} else {
servo2.write(0);
}
}
void setup() {
Serial.begin(115200);
WiFi.mode(WIFI_STA);
if (esp_now_init() != ESP_OK) {
Serial.println("ESP-NOW Init Failed");
return;
}
esp_now_register_recv_cb(OnDataRecv);
// Attach servos
servo1.attach(0);
servo2.attach(2);
servo1.write(0);
servo2.write(0);
Serial.println("ESP-NOW Receiver Ready!");
}
void loop() {
// Nothing to do here, everything happens in OnDataRecv()
}