1st Experience

submerged in a river

“isolate”;“transcending”

• Bamboo jersey dress w felt details

Designed to hug the body, with no armholes to evoke the underwater isolating sensation, and a human cocoon. With a drooping silhouette, resembling the appearance of wetness. The felted details represent the river moss, growing on the body.

“prickly”;”(…)crystal spikes piercing your skin.(…)”

• 3D-printed wearable sculpture

Structure of prickly spines, extending toward your hand, like the cold water piercing the skin. With water droplets spreading across the surface.

“(…)and you wonder how cold the water will be.(…)”;“rejuvenating”;”transcending”

• Striped bio-plastic scarf

Representing a glossy, light-reflective water texture. With air bubbles forming on the surface, that form as you breathe underwater.

“(…)you feel the sharpness of crystal spikes piercing your skin. It hurts but it also makes you feel alive.(…)”

• Crystallized tights

Representing crystallised skin from the cold water that freezes into solid ice. Starting from the feet, spreading across the legs.

bamboo jersey dress

This sleeveless dress is designed to ensure that the stretchy knit fabric hugs the body closely, while still allowing for movement and comfort. With a drooping silhouette that resembles the appearance of wetness, it evokes a sense of isolation—a kind of human cocoon.

Drawing inspiration from 1920s dropped-waist dresses, the piece reinterprets vintage elegance through a modern, conceptual lens. It is adorned with needle-felted abstract forms in varying shades of green wool, resembling river moss growing along the contours of the body, blurring the line between nature and skin.

For the prototype, I began by draping the fabric on a mannequin to directly develop the foundational ideas for the pattern–no armholes, a draped neckline, two front pockets with darts, a dropped waistline, a short skirt, and a strap for fastening the dress.

After completing the first prototype, I revised the pattern to explore how it could be simplified into a single-piece cutting. This involved merging all the individual pattern pieces and identifying key points for stitching to create a functional, wearable dress while minimizing seams and enhancing efficiency.

For the final dress, I used a grey bamboo jersey fabric. I added two darts at the front, close to their respective welt pockets. The wearer’s arms/hands come through these pockets, as the dress doesn’t have traditional armholes.

It has a simple seam along the back, and I finished all the hems with a grey lace trim. The "skirt" at the bottom of the dress features a sort of tail made with the lace trim, designed to create a “dripping wet” look.

needle felting

As mentioned above, the needle-felted details are meant to resemble river moss, drawing from the context of the experience previously described. To achieve this, I began by experimenting with three different shades of green wool, exploring which combination would appear the most realistic and visually effective. I ultimately chose to work with the medium and light green shades.

To create the effect I was aiming for—something that resembles reeds or aquatic weeds—I used a basic needle felting technique but applied it in an unconventional way: from the reverse side of the fabric. This means that on the inside of the dress, you see the usual needle-felted texture, while on the outside, it creates a furry, organic surface, enhancing the sense of moss growing along the body.

The placement of each felted piece was somewhat random. As I worked, I draped the dress on the mannequin and assessed where it would make sense to add more wool, continuing until I was satisfied with the result and decided to stop.

In the video above, you can see the resulting texture, and I was really happy with how it turned out—it genuinely resembled moss or reeds. It was also very pleasant to the touch.

My initial idea for these needle-felted parts was to use conductive wool, turning the garment into a kind of wearable keyboard, where different sounds would be triggered when someone touched the felted areas. However, I ended up going in a different direction with the sound system. This original concept would have required an additional conductive layer underneath, so that when both layers touched, the circuit would be completed. That setup would have been a full project on its own, so I opted for a simpler solution instead—which you can check out here!

electronics

For the sound system, I used a conductive rubber cord stretch sensor, placed either along the shoulder line at the back of the dress or between the elbows. The sensor is activated through movement—when the wearer stretches that part of the garment, it triggers a sound, and the intensity of the stretch controls the volume of the sample.

The sound consists of one sample created by the artist Unpsii, designed to evoke sensations of underwater movement, vocals and ambient noise.

To output the sound, I’m using a DFPlayer Mini, a compact and affordable MP3 module connected directly to an active speaker (JBL Go 2).

The system also features wireless communication, with a sender and receiver setup between the stretch sensor input and the sound output. This allows the speaker and receiver circuit to be discreetly integrated into the wearable sculpture, while the sender circuit is hidden beneath the dress.

stretch sensor input

Building this Circuit on a Breadboard:

• Connect one end of the stretch sensor to 3.3V and the other to A0.

• Attach a 10kΩ pull-down resistor between A0 and GND.

INPUT (SENDER):

#include <esp_now.h>
#include <WiFi.h>

#define STRETCH_SENSOR_PIN A0  // Analog pin for stretch sensor

const int minSensorValue = 100;  // Value when sensor is NOT stretched
const int maxSensorValue = 2800;  // Value when sensor is fully stretched
const int minVolume = 0;   // Minimum volume
const int maxVolume = 30;  // Maximum volume

// Replace with receiver MAC address
uint8_t broadcastAddress[] = { 0x64, 0xe8, 0x33, 0x51, 0x0f, 0x8c };

// Structure example to send data
// Must match the receiver structure
typedef struct struct_message {
int volume;
} struct_message;

// Create a struct_message called myData
struct_message myData;

esp_now_peer_info_t peerInfo;

// callback when data is sent
void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
Serial.print("\r\nLast Packet Send Status:\t");
Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
}

void setup() {
// Init Serial Monitor
Serial.begin(115200);
pinMode(STRETCH_SENSOR_PIN, INPUT);  // Set sensor pin as input
// Set device as a Wi-Fi Station
WiFi.mode(WIFI_STA);

// Init ESP-NOW
if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
}

// Once ESPNow is successfully Init, we will register for Send CB to
// get the status of Transmitted packet
esp_now_register_send_cb(OnDataSent);

// Register peer
memcpy(peerInfo.peer_addr, broadcastAddress, 6);
peerInfo.channel = 0;
peerInfo.encrypt = false;

// Add peer
if (esp_now_add_peer(&peerInfo) != ESP_OK) {
    Serial.println("Failed to add peer");
    return;
}
}

void loop() {
int sensorValue = analogRead(STRETCH_SENSOR_PIN);  // Read stretch sensor

// Apply a moving average filter to smooth sensor readings
static float smoothSensorValue = sensorValue;
smoothSensorValue = (smoothSensorValue * 0.8) + (sensorValue * 0.2);  // 80% old value, 20% new

// Map the smoothed sensor value to a smooth volume range (0 to 30)
int volume = map(smoothSensorValue, minSensorValue, maxSensorValue, minVolume, maxVolume);
volume = constrain(volume, minVolume, maxVolume);  // Ensure volume stays within range

Serial.print("Sensor Value: ");
Serial.print(sensorValue);
Serial.print(" | Smoothed: ");
Serial.print(smoothSensorValue);
Serial.print(" | Volume: ");
Serial.println(volume);

myData.volume = volume;

// Send message via ESP-NOW
esp_err_t result = esp_now_send(broadcastAddress, (uint8_t *)&myData, sizeof(myData));

if (result == ESP_OK) {
    Serial.println("Sent with success");
} else {
    Serial.println("Error sending the data");
}

delay(200);
}

For the input system, I used a conductive rubber cord. While it's not the most reliable material, it worked well enough for what I needed. That said, I encountered several issues while working with it that are important to keep in mind.

First, when connecting the cord using alligator clips, you need to make sure the rubber is intact—no internal breaks, holes, or damage—otherwise, the readings on the serial monitor will be inconsistent and confusing.

I strongly recommend spending time on both monitoring the sensor values and refining your code, as that's the only way to achieve consistent and accurate results.

The material is highly stretchable, but also quite fragile. You shouldn’t use its absolute maximum stretch capacity for your calibration values. If you push it too far while trying to find those limits, it will likely snap. And when it breaks, you’ll need to recalibrate and update your code with new values.

Also, never sew through the rubber cord—this can damage it and affect its functionality.

STRETCH SENSOR TEST w LED

At the beginning, I was using the stretch sensor with three defined stretch levels—light, medium, and high—each corresponding to a different sound sample that would be triggered when the sensor reached that specific level.

In the video below, I was testing these stretch levels using LED intensity as visual feedback, before I had the sound output system fully set up. You can see that it was working reasonably well at that stage.

However, I eventually decided not to continue with the stretch level code, as it proved to be a bit inconsistent and unreliable during repeated use.

CODE:

#define STRETCH_SENSOR_PIN A0  // Use GPIO1 (A0)
#define LED_PIN 5  // Change this to any PWM-capable GPIO pin

void setup() {
Serial.begin(115200);  // Start serial monitor
pinMode(LED_PIN, OUTPUT);  // Set LED pin as output
analogWrite(LED_PIN, 0);  // Ensure LED starts off
}

void loop() {
int sensorValue = analogRead(STRETCH_SENSOR_PIN);  // Read stretch sensor value

// Map the sensor value from 2600-3400 to 0-100 range
int mappedValue = map(sensorValue, 2600, 3400, 0, 100);

// Map the same value to LED brightness (0-255 for PWM control)
int ledBrightness = map(mappedValue, 0, 100, 0, 255);

// Print the mapped value
Serial.print("Mapped Value: ");
Serial.println(mappedValue);

// Print the LED brightness range
Serial.print("LED Brightness: ");
Serial.println(ledBrightness);

// Determine stretch levels and LED brightness
if (mappedValue < 25) {  
Serial.println("Stretch Level 1: High Stretch - LED Max Brightness");  
ledBrightness = 255;  // Max brightness
} 
else if (mappedValue >= 25 && mappedValue < 45) {  
Serial.println("Stretch Level 2: Medium Stretch - LED Medium Brightness");  
ledBrightness = 128;  // Medium brightness
} 
else if (mappedValue >= 45 && mappedValue < 80) {  
Serial.println("Stretch Level 3: Light Stretch - LED Low Brightness");  
ledBrightness = 50;  // Low brightness
} 
else {  
Serial.println("No Stretch - LED Off");  
ledBrightness = 0;  // Turn off LED when no stretch is detected
}

// Apply brightness to LED using PWM
analogWrite(LED_PIN, ledBrightness);

delay(500);  // Wait before next reading
}

WEARABLE

To make the stretch sensor input system wearable, I used the same method I applied during Skin Electronics Week, which you can check out here!

I began by sketching the schematic and planning the wire connections. As a base for the wearable circuit, I used a piece of mesh fabric. To create the conductive traces, I used conductive fabric bonded to Vliesofix (a fusible webbing) with a heat press. I then cut the traces into droplet shapes.

Once the traces were prepared, I positioned them carefully on the mesh fabric, ensuring no conductive pieces overlapped or touched. Using a heat press set to 320°F, I fused the traces to the mesh for 20 seconds.

For the components connections, I used insulated wires to connect the components to the microcontroller. The power source was a 3.7V LiPo battery, which I connected to the back of the microcontroller. The microcontroller's designated + (positive) and - (negative) terminals.

For the rest of the connections, I matched each wire with its corresponding component, twisting and soldering them for added stability. I then covered each soldered joint with heat shrink tubing for insulation and protection.

I sewed the conductive rubber cord onto the dress, placing it along the elbow line. It’s important to note: do not sew directly through the rubber cord—only around it to avoid damaging the material. I also created a small pocket from the same grey bamboo jersey fabric, allowing the circuit to be securely tucked inside while the wearer has the dress on.

sound output

Building this Circuit on a Breadboard:

• Connect ESP32's TX to DFPlayer Mini's RX through a 1kΩ resistor.

• Connect ESP32's RX directly to DFPlayer Mini's TX.

• Connect DFPlayer Mini’s VCC to ESP32's 5V and GND to GND.

• Insert a microSD card with the sound files into the DFPlayer Mini.

• Add a 1000µF capacitor between DFPlayer Mini's VCC (+) and GND (-) to help stabilize power supply fluctuations.

• Connect a passive speaker to the DFPlayer Mini’s SPK1 and SPK2 pins (); active speaker to DAC_R or DAC_I and GND through an audio jack.

• Connect active speaker via an audio jack as follows:

Connect the positive terminal of the audio jack to the positive terminal of the 10µF capacitor, then route it through two 100Ω resistors in series before connecting to the DAC_C pin of the DFPlayer Mini.

Connect the negative terminal of the audio jack through the negative terminal 10µF capacitor to the GND of the DFPlayer Mini.

• Attach a Bluetooth antenna to the ESP32.

OUTPUT (RECEIVER) CODE:

#include <esp_now.h>
#include <WiFi.h>
#include "DFRobotDFPlayerMini.h"

#define FPSerial Serial1

DFRobotDFPlayerMini myDFPlayer;
int volume;
int lastVolume = -1;  // Store last volume level to detect changes

// Structure example to receive data
// Must match the sender structure
typedef struct struct_message {
int volume;  
} struct_message;

// Create a struct_message called myData
struct_message myData;

// callback function that will be executed when data is received
void OnDataRecv(const esp_now_recv_info_t *recvInfo, const uint8_t *incomingData, int len) {
memcpy(&myData, incomingData, sizeof(myData));

volume = myData.volume;
Serial.print("Received Volume: ");
Serial.println(volume);

if (volume != lastVolume) {  // Only update if volume changes
    lastVolume = volume;
    if (volume == 0) {
    myDFPlayer.pause();  // Pause when volume is 0
    } else {
    myDFPlayer.volume(volume);  // Adjust volume
    myDFPlayer.start();  // Resume playback
    }
}
}

void setup() {
Serial.begin(115200);

WiFi.mode(WIFI_STA);
if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
}
// Once ESPNow is successfully Init, we will register for recv CB to get recv packer info
esp_now_register_recv_cb(esp_now_recv_cb_t(OnDataRecv));


FPSerial.begin(9600, SERIAL_8N1, /*rx =*/44, /*tx =*/43);

Serial.println(F("DFRobot DFPlayer Mini - Smooth Volume Control"));

if (!myDFPlayer.begin(FPSerial, /*isACK = */ true, /*doReset = */ true)) {
    Serial.println(F("Unable to begin DFPlayer! Check connections and SD card."));
    return;
}

Serial.println(F("DFPlayer Mini online."));

myDFPlayer.setTimeOut(2500);
myDFPlayer.volume(0);  // Start at volume 0 (silent)
myDFPlayer.EQ(DFPLAYER_EQ_NORMAL);
myDFPlayer.outputDevice(DFPLAYER_DEVICE_AUX);

Serial.println("Playing track 1...");
myDFPlayer.play(1);  // Start playing track 1

}

void loop() {
// Nothing needed here, volume is updated in OnDataRecv()
delay(200);  // Prevents excessive CPU usage
}

For the sound output, it was a long process to find the right combination of code and circuit to minimize noise and ensure that the volume control responded accurately to the stretch sensor input levels.

In this first iteration, it was essential to gain a solid understanding of the DFPlayer Mini and how to connect it properly to the microcontroller. I actually fried one DFPlayer Mini during the process by wiring it incorrectly. It’s also important to place resistors where needed—you can find detailed documentation on the DFRobot website to guide you through the correct setup.

Once I had a better understanding, I built my first circuit. As mentioned earlier, my plan was to use the stretch sensor with three different levels, each one triggering a different sound sample through the DFPlayer Mini. To test this idea, I created a prototype circuit using three separate touch pins instead of the stretch sensor. This made it much easier to verify that everything was working before moving on to the actual stretch sensor and integrating wireless communication.

One issue that was bothering me was the electrical noise generated by the circuit. To reduce this, I added two capacitors—a 1000µF capacitor and a 10µF capacitor—to help minimize the noise coming from the DFPlayer Mini and the speaker. This made a significant difference, and I was really happy with the outcome.

VOLUME CONTROL

#include "Arduino.h"
#include "DFRobotDFPlayerMini.h"

#define STRETCH_SENSOR_PIN A0  // Analog pin for stretch sensor
#define FPSerial Serial1

DFRobotDFPlayerMini myDFPlayer;

int lastVolume = -1;  // Store last volume level to detect changes
const int minSensorValue = 2600;  // Value when sensor is NOT stretched
const int maxSensorValue = 2200;  // Value when sensor is fully stretched
const int minVolume = 0;   // Minimum volume
const int maxVolume = 30;  // Maximum volume

void setup() {
Serial.begin(115200);
FPSerial.begin(9600, SERIAL_8N1, /*rx =*/44, /*tx =*/43);

Serial.println(F("DFRobot DFPlayer Mini - Smooth Volume Control"));

if (!myDFPlayer.begin(FPSerial, /*isACK = */ true, /*doReset = */ true)) {
    Serial.println(F("Unable to begin DFPlayer! Check connections and SD card."));
    return;
}

Serial.println(F("DFPlayer Mini online."));

myDFPlayer.setTimeOut(2500);
myDFPlayer.volume(0);  // Start at volume 0 (silent)
myDFPlayer.EQ(DFPLAYER_EQ_NORMAL);
myDFPlayer.outputDevice(DFPLAYER_DEVICE_AUX);

Serial.println("Playing track 1...");
myDFPlayer.play(1);  // Start playing track 1
}

void loop() {
int sensorValue = analogRead(STRETCH_SENSOR_PIN);  // Read stretch sensor

// Apply a moving average filter to smooth sensor readings
static int smoothSensorValue = sensorValue;
smoothSensorValue = (smoothSensorValue * 0.8) + (sensorValue * 0.2);  // 80% old value, 20% new

// Map the smoothed sensor value to a smooth volume range (0 to 30)
int volume = map(smoothSensorValue, minSensorValue, maxSensorValue, minVolume, maxVolume);
volume = constrain(volume, minVolume, maxVolume);  // Ensure volume stays within range

Serial.print("Sensor Value: ");
Serial.print(sensorValue);
Serial.print(" | Smoothed: ");
Serial.print(smoothSensorValue);
Serial.print(" | Volume: ");
Serial.println(volume);

// Update volume only if it changes
if (volume != lastVolume) {
    lastVolume = volume;
    if (volume == 0) {
    myDFPlayer.pause();  // Pause when no stretch
    } else {
    myDFPlayer.volume(volume);  // Adjust volume smoothly
    myDFPlayer.start();  // Resume playing if paused
    }
}

delay(100);  // Faster response while keeping it smooth
}

At this point, I realized it made much more sense for the stretch sensor to control the volume of a single sound sample, rather than triggering different samples. This approach aligned better with the concept of the experience: when the participant rises toward the surface of the river, the sound becomes louder—representing increased awareness of the world around them—and as they descend, the sound becomes quieter, evoking a return to isolation.

To implement this, I started by updating the code. Instead of using stretch levels, I defined two values: a minimum and a maximum for the stretch sensor input, and the corresponding minimum and maximum volume levels (0-30).

From there, I began fine-tuning the values. However, as mentioned earlier, the conductive rubber cord isn't the most reliable material, so I had to adjust the values regularly, often day by day, to ensure consistent results.

PITCH CONTROL

To achieve pitch control, I will need an external audio processor or use pre-recorded audio files at different pitches, because the function playBackSpeed(speed) does not exist in the DFPlayer Mini library.

int speed = 150;  // Default speed (medium pitch)

if (myData.stretchLevel == 1) {
Serial.println("Light Stretch - Low Pitch");
speed = 100;  // Slow speed (lower pitch)
} else if (myData.stretchLevel == 2) {
Serial.println("Medium Stretch - Medium Pitch");
speed = 150;  // Default medium speed (medium pitch)
} else if (myData.stretchLevel == 3) {
Serial.println("High Stretch - High Pitch");
speed = 200;  // Fast speed (higher pitch)
}

myDFPlayer.playBackSpeed(speed);  // Apply speed to change pitch

wearable sculpture

The wearable sculpture is designed with a dual purpose. Conceptually, it reflects a key moment from the sensory experience described in the graph and questionnaire. The participant noted, “The moment you enter the water, you feel the sharpness of crystal spikes piercing your skin. It hurts, but it also makes you feel alive.” The piece captures this sensation through a structure of prickly spines extending toward the hand, symbolizing the icy spikes felt when submerged in cold water. It also evokes the visual of water droplets spreading across the skin’s surface, enhancing the tactile and emotional qualities of the piece.

Functionally, the sculpture acts as a discreet and efficient housing for the receiver circuit and speaker, which communicate wirelessly with the sender circuit embedded in the main garment. This integration allows for smooth interaction while keeping all the electronic components subtly hidden, maintaining the visual language and physical comfort of the piece.

I started by creating the 3D model shape for the wearable sculpture using Nomad Sculpt. This initial prototype was intended to help me understand several aspects:

• The scale of both the ergonomic handle and the overall size of the piece.
• The final aesthetic.
• How to implement a system with an opening in the back that would be versatile, manageable, and spacious. This opening would also need integrated holes to allow sound from the speaker inside the bag to project outward.
• Additionally, I needed a way to design the bag in separate parts to join later, since our lab's 3D printers cannot operate overnight. Because the bag would take more than two days to print, I planned to divide the final design into smaller sections that could be connected later.

For my first print test, I used a white PLA filament and cut the design to print only the handle. This allowed me to evaluate whether the handle needed resizing or further ergonomic adjustments. You can find the 3D model for my first print test here¹ and the Prusa Slicer file here²!

However, I applied too much support using the Prusa Slicer software, which made removing the supports after printing very time-consuming. Despite this, the handle turned out fine overall. Here are some alterations I need to make:

• Consider adjusting the pinky finger hole to make it smaller, as it currently feels a bit uncomfortable.

• Adjust the overall width of the sculpture to provide more space for the speaker.

For the final 3D-printed model, I used multicolor silk PLA filament. I ended up not printing the version with the opening in the back—which was originally designed to hold the sound output circuit—simply because I didn’t have enough time.

I had already planned to cut the model into five separate parts to print them individually, but the model was quite large, and in our lab, we’re not allowed to leave the printers running overnight. That meant I only had about seven hours per day to print, and each part was taking approximately that long. As a result, I wasn’t able to finish printing the full version before the deadline to film the final video, so I printed a smaller version without the back opening.

Even with the smaller version, I still had to cut the model into two parts, but I ran into several issues along the way—mostly due to the filament. I kept encountering an error near the end of the prints. The first time, it failed about 20 minutes before completion, which was extremely stressful. I had to re-cut the second half of the model based on where the first print had stopped, so it would look seamless once glued.

This error—Thermal Runaway—had never occurred before in our lab. I was printing on a Prusa, and online sources suggested the problem might be related to nozzle temperature. I had set the temperature higher than usual—around 38–42°C—because the filament was clogging at the beginning of prints. So I was already closely monitoring the printer during each session. I thought it was just a one-time issue, but unfortunately, the same error occurred during the second print, again near the end. I couldn’t fix it in time, and lowering the nozzle temperature just caused more clogging. In the end, I had to cut the model into three parts, and after a long process, I finally managed to get all the pieces printed.

To assemble the model, I used plastic glue, first sanding the areas, then applying a generous amount of glue and letting it dry for 24 hours. The result held up really well. It wasn’t perfectly seamless due to the printing issues, and the finger holes ended up being too small, but since it was meant to function as a clutch bag, that didn’t bother me too much.

striped bio-plastic scarf

The striped bio-plastic scarf is designed to evoke the glossy, light-reflective texture of water. The surface subtly mimics the way air bubbles form as you breathe underwater, capturing a fleeting, immersive moment beneath the surface.

This scarf is intentionally biodegradable, reflecting the ephemeral nature of water—it appears and disappears, never static. As an experimental accessory, it explores how simple design elements, like stripes, can be introduced into bio-materials. By hand-crafting it, I aim to test both its durability and its potential for future applications in sustainable fashion.

For the first sample, I used tape to create walls on the mini tray I was using to cast the bio-plastic. I prepared gelatine bio-plastic. I created two different batches, adding green food coloring to one of them.

I began by pouring the uncolored bio-plastic into the side stripes, leaving the middle stripe empty. I let it dry for 15–20 minutes, and once it had partially hardened, I removed the tape walls and poured the green bio-plastic into the middle stripe. The green bio-plastic blended seamlessly with the other two, resulting in a striped sample.

For the real size scarf, I really wanted to try a gelatin-based recipe that would fall somewhere between resin and silicone. From the initial samples we made during BioFabricating Materials Week, I realized that the flexibility of the gelatin-silicone mix would be a bit too soft, while resin, on the other hand, would be too rigid. So I decided to experiment with a formula somewhere in between—one that would give me a material strong enough to hold its shape as a scarf, but still flexible enough to be gently molded around a mannequin, achieving that folded, wrapped look around the neck.

Recipe between Gelatine Bio-RESIN and Bio-SILICONE:

• 48gr gelatine
• 36gr glycerine
• 240ml water
• Ecoline for dyes
• Straw to create air bubbles

Step-by-Step Guide to Making a Striped Gelatine Bio-Plastic Scarf:

1. Prepare the Mold: Create a mold for casting the bio-plastic. I used a plastic sheet as the base and built walls around it using aluminum tape to achieve the desired size and shape of the scarf.

2. Create the Stripes: Use the aluminum tape again to mark out the stripes on the mold.

3. Prepare the Gelatine Bio-Plastic: Make your gelatine bio-plastic mixture and divide it into two separate containers. In one of them, mix in blue Ecoline pigment to create the color contrast for the stripes.

4. Pouring the Stripes: Pour the bio-plastic mixture one stripe at a time. Allow each stripe to dry slightly before adding the next one. Each time you pour a new stripe, remove the tape from the previous stripe to maintain clean lines.

5. Drying the Scarf: Once all the stripes are complete, let the entire scarf dry on the mold for 48 hours.

6. Shaping on a Mannequin: If you want to mold the scarf to a mannequin, do so after the initial 48-hour drying period while the material is still slightly flexible. Shape it as desired and let it continue drying until it is completely hardened.

I’m really happy with the outcome of the gelatin bio-plastic scarf—the transparency, the air bubbles on both sides of the sheet, and the overall size turned out beautifully. There were some challenges along the way, especially when casting on a mold that wasn’t perfectly flat. The tape technique worked reasonably well, but I’d love to find a more sustainable and user-friendly alternative. As it stands, it’s not the most precise or efficient method.

I ran into a few issues due to the mold and the tape walls—notably, inconsistent thickness throughout the scarf. The stripes don’t always appear as clean lines, depending on how much time and patience you invest in letting each one dry before adding the next. That said, a perfectly uniform stripe wasn’t my goal for this piece. There were also a **few areas where the material started to tear**, but on the second day of drying, I **added a bit more of the gelatin mixture** to those spots, which solved the problem—though the repairs weren’t seamless.

Despite these minor setbacks, I’m very satisfied with the final result. I’m excited to experiment further with this material and method, trying out new patterns like polka dots or tartan, and exploring its potential in different garments or accessories.

crystallised tights

The crystallised tights are designed to represent the moment when cold river water meets the participant skin, freezing upon contact and spreading upward like solid ice. Beginning at the feet and climbing along the legs, the crystallisation effect captures the sensation of being overtaken by cold—skin turning to crystal in a silent, gradual transformation.

This piece draws from the physical and emotional response to cold immersion—sharp, beautiful, and uncomfortable all at once. “(…)you feel the sharpness of crystal spikes piercing your skin. It hurts but it also makes you feel alive.(…)”

My first test was on a random pair of black tights I had at home. At that point, I wasn’t completely sure if this would be part of the final look—but in my mind, it had to be, because it made so much sense in relation to the experience I was exploring.

After completing the test, I realized it would make much more sense to use skin-colored tights, so that became my final choice. For this first trial, I simply submerged the tights in the alum solution and left them there until a reasonable amount of crystals had formed all over. I wanted to see if it would still be possible to wear them afterwards, and whether the crystals would grow together and bond the two sides of the tights. Fortunately, that didn’t happen—I was able to separate them by hand, and the result was beautiful.

Of course, with the black tights, the white crystals stood out much more, so I knew that on the skin-colored version the effect would appear more subtle. One thing I noticed was that the crystals added quite a bit of weight, especially to the lower sections. This caused some stretching at the top part of the tights where there were no crystals—but once worn, that wasn’t really visible.

Step-by-Step Guide to Crystallized Tights:

1. Prepare the Container: Choose a container large enough to fully submerge the tights in the alum-water solution without them touching the sides or bottom. To suspend the tights properly, I created a support system using wooden sticks across the top of the container. Sew a few stitches onto the tights and secure them to the sticks to prevent them from floating. Additionally, use vertical wooden sticks to keep them positioned toward the bottom without direct contact.

2. Prepare and Pour the Alum Solution: Carefully pour the alum-water solution into the container, ensuring the tights are fully submerged. Keep a close watch on the process—if you want a lighter crystal effect so the tights remain flexible, limit the submersion time to 25–40 minutes, depending on the concentration of your solution and the speed of crystal formation.

3. Create a Gradient Effect: To achieve a gradient of crystal growth, gradually remove certain sections of the tights from the solution at different times. This stops crystal formation on those areas while allowing the submerged parts to continue growing.

4. Opening the Tights: Once satisfied with the crystallization, remove the tights from the solution and immediately begin separating the crystalized sections to prevent them from sticking together. Carefully stretch them with your hands to break apart any connecting crystals, ensuring they remain wearable.

5. Dry and Seal: Let the tights dry completely. If you want to preserve the crystals for longer, consider applying a protective topcoat, such as clear nail polish.

I’m really happy with how these tights turned out. The crystals are surprisingly durable—even after wearing them multiple times, they remain almost intact. It’s important to keep them away from water, especially warm or hot water, as that would cause the crystals to dissolve.

The gradient effect worked beautifully. The only downside is that they’re not the most comfortable to wear—they can scratch the skin a bit, and walking in them is quite difficult. But in a way, that discomfort is part of the experience itself.

Next time, I would try taping the sole of the foot to prevent crystals from forming there, which might make walking easier. I would also consider reducing the time the tights spend in the alum solution, so the crystals don’t grow as large and abrasive against the skin.

half-fabrication files

---

1. File: Wearable Sculpture_PrintTest 1 ↩

2. File: Wearable Sculpture Prusa Slicer_PrintTest 1 ↩