11. Open Source Hardware - From Fibers to Fabric

Our project

This week’s theme is Open Source Hardware, and our FabLab Dilijan team decided to give a second life to the 3D printer MakerBot Replicator 2.

Why does this matter?

Bringing old machines back to life is one of the core ideas behind open-source hardware culture. Instead of throwing things away when they stop being “modern,” we try to understand how they work, extend their lifespan, and make them accessible again. It’s sustainable, it builds real technical skills, and it preserves tools that still have a lot to offer.

The MakerBot Replicator 2 is a great example. It was once one of the most popular desktop 3D printers, known for its sturdy frame, decent print volume, and surprisingly good PLA performance for its time. Even today, it can print reliably — the only challenge is that its original software ecosystem is outdated.

Originally, MakerBot used a system called MakerBot Desktop (and earlier, MakerWare) to prepare files. The printer reads X3G files rather than standard G-code. The firmware on many Replicator 2 units has since been replaced by Sailfish, an open-source, community-developed firmware that makes the machine faster, more stable, and more customizable.

MakerBot itself doesn’t update the Replicator 2 software anymore — support ended years ago — but the community still maintains tools like:

-GPX (a converter that turns G-code into X3G),

-open-source slicers like Cura and PrusaSlicer, which still work with GPX plugins,

-Sailfish firmware, which is no longer actively developed but remains widely used and stable.

So even though the official updates have stopped, the open-source world keeps these printers alive. That’s exactly why projects like ours matter — we take older hardware, pair it with modern tools, and help it stay useful for years to come.

How it should (and we hope will) work

Our goal is to turn the printer into a device on which we will create soft-robotics models. Here is how we expect it to work:

1. We attach two layers of vinyl (Heat Transfer Vinyl, HTV) to the printer’s bed. We arrange them so that the vinyl we intend to remove ends up on the outside — that is, above the top vinyl layer and below the bottom layer. We secure the vinyl layers with tape.

2. We install a metal tip ("nozzle substitute"), which we pre-grind / shape into the required form. The tip should be rounded, so it doesn’t damage the vinyl.

3. In a vector program we draw a 2D pattern, export it to a file format readable by our printer, save that file to an SD card, and insert it into the MakerBot Replicator 2.

4. The printer receives the job. Its metal tip heats up to a temperature defined in the code, then moves over the vinyl. Due to the combined effect of heat + pressure, it fuses the two vinyl layers together along the drawn path.

5. We remove the resulting sample, cut out the contour with scissors, then test it — for example, by inflating it with air to check how it deforms / moves.

Why this approach (and how it connects to soft robotics)

Instead of extruding plastic filament as usual, we repurpose the printer’s motion system to draw/fuse patterns on vinyl. This is akin to using the printer head as a “hot stylus / hot-press tool.”

By fusing two vinyl layers along defined 2D paths, you can create sealed air chambers, channels or compartments — which is a basic principle in many soft-robots (e.g. pneumatic actuators, soft chambers, inflatable structures).

Using a 3D printer as a base reduces costs and reuses existing hardware. Rather than buying a dedicated vinyl-cutter or heat-press machine — you “hack” what’s already there.

Thus your project nicely aligns with the spirit of DIY / maker / open-source / hackathon — and could open path to soft robots made from vinyl/film, instead of rigid plastic.

Research. Some similar projects

Printer to Vinyl Cutter Hack

Goals

The goal of this project was to transform an old inkjet printer into a functional vinyl cutter. Instead of purchasing specialized equipment, the project explores reuse and hacking of existing technology to create a low-cost cutting machine for vinyl, stickers, and simple graphics.

Approach

The printer was disassembled, keeping its mechanical structure, rollers, and stepper motors. Additional electronics, including an Arduino and stepper drivers, were integrated to control movement and cutting. A blade holder was adapted to replace the print head, and software such as GRBL and Inkscape was used to generate and send G-code for cutting paths.

Challenges

The main challenges were mechanical precision and calibration. Printer components are not designed for cutting, so achieving clean, consistent cuts required careful alignment and tuning. Another difficulty was configuring the electronics and software workflow, especially translating graphic files into reliable cutting instructions.

Outcome

The project successfully converted a discarded printer into a working vinyl cutter. The result demonstrates how everyday machines can be repurposed through DIY methods, combining hardware hacking, digital fabrication, and experimentation to create an accessible fabrication tool.

Use 3D Printer As a Plotter/cutter

Goals

The aim of this project was to convert a regular 3D printer into a versatile plotter and cutter, so it can draw and cut materials like paper, fabric, vinyl, or gum paste in addition to 3D printing. This lets the machine perform multiple functions without needing separate hardware.

Approach

To do this, the maker kept the printer’s original mechanics and added simple attachments: an attachment clip and a spring-based tool holder for pens or cutting blades. These parts were 3D printed and mounted on the printer’s head. They also used a Python/Inkscape extension to convert vector graphics into G-code that the printer can follow for plotting and cutting paths.

Challenges

The project required careful mechanical calibration, especially leveling the bed and setting the correct tool height for drawing or cutting. The attachment needed to be easily removable so the printer could switch back to normal printing. Also, configuring the software to generate accurate G-code for non-printing tasks took effort.

Outcome

The result is a DIY plotter/cutter built from a standard 3D printer that can draw with pens or cut thin materials using a blade. The modification cost only a small amount in parts and expands the printer’s capabilities beyond just 3D printing.

Vinyl cutter for Ender 3 v2

Goals

The goal of this project was to create an adapter that allows a drag-knife vinyl cutter to be fitted to a Creality Ender 3 V2 3D printer. This lets the printer be repurposed as a vinyl cutter or pen plotter without buying a dedicated machine, expanding its functionality beyond 3D printing.

Approach

To achieve this, the creator designed and 3D-printed custom parts — a carriage, backplate, and optional clip — to mount a drag-knife cutter on the Ender 3 V2’s existing gantry. Rails and screws secure the cutter, and a spring mechanism (salvaged from a pen) provides the necessary tool pressure. For software, tools like Gcodeplot for Inkscape were used to convert vector graphics into G-code that the printer can follow for cutting or plotting.

Challenges

Key challenges included precise mechanical calibration so the cutter follows paths accurately, and ensuring the blade didn’t crash into the bed — leading to the addition of a retractable clip to safely stow the cutter when not in use. Generating usable G-code also required adjusting software output so the Ender’s firmware can interpret it correctly.

Outcome

The project resulted in a working vinyl cutter and optional pen plotter toolhead mounted on the Ender 3 V2. This DIY modification expands the printer’s capabilities, allowing it to cut vinyl and draw graphics with a pen using converted G-code — all built from 3D-printed parts and minimal hardware.

Metal tip preparation

To prepare the metal tip for our experiment, we had to reshape it so it could glide smoothly over the vinyl without cutting or tearing it. The goal was to make the end perfectly rounded, almost like the tip of a soldering iron or a smooth stylus.

We used a small bench-top machine to do this. The tip was fixed in the machine so it could rotate at a steady speed. While it was spinning, we gently pressed an abrasive surface against it — almost like sharpening a pencil, but in reverse: instead of creating a point, we were removing the sharpness.

Little by little, the metal started to change shape. The edges softened, the surface became smoother, and the tip turned into a clean, rounded dome. We worked slowly so the metal wouldn’t overheat or lose its symmetry.

By the end of the process we had exactly what we needed: a small, smooth, evenly rounded metal tip that can heat up, touch the vinyl, and fuse the two layers together without puncturing them.

It was a simple modification, but it made all the difference — transforming a generic piece of metal into a tool tailored specifically for soft-robotics vinyl welding.

SVG files preparation

For this project I prepared an SVG file of a pyramid net — a continuation of my work this week on Soft Robotics with the cube.

Inspired by the work of Fabricademy alumna Saksia Helinska, I also created a series of small test pieces for our experiments. All That remaining step was one small step: to get our MakerBot to start working in its new role.

Firmware Selection and Implementation

Firmware is the low-level software that runs directly on the electronics of a machine — in our case, the control board of the MakerBot Replicator 2. It acts as the bridge between the hardware (motors, heaters, sensors) and the commands we send (G-code/X3G, temperature targets, motion paths).

Because we are repurposing the printer from traditional FDM printing to a heat-based vinyl-fusing tool for soft robotics, choosing the right firmware was an essential part of the setup.

Feature / Criteria	Sailfish 7.7	Klipper
Compatibility with MakerBot Replicator 2	Native support	Requires replacing or bypassing the original board
Installation difficulty	Easy, fast	Complex, multi-step
Hardware changes needed	None	Raspberry Pi or similar host required
File format	X3G (via GPX conversion)	Standard G-code
Customization level	Limited	Very high
Motion performance	Stable and proven	Extremely fast and flexible
Community activity	Low (legacy firmware)	Very active
Best for	Quick setup, minimal risks	Experimental multi-tool systems, advanced robotics
Main limitations	Outdated toolchain, less flexible	Time-consuming, higher learning curve
Why this did/didn’t fit our project	Perfect for fast deployment	Too slow to implement within our timeline

Why We Chose Sailfish 7.7

We ultimately went with Sailfish 7.7 because:

• we had limited time,

• installation is significantly easier,

• the firmware is already designed for the Replicator 2,

• it allows us to use GPX to convert our G-code into X3G,

• and it works well for simple, repetitive 2D heat-fusing toolpaths.

In short: Sailfish gave us a stable, predictable system with almost no configuration overhead.

Installing Sailfish 7.7

Sailfish is installed directly onto the main control board of the MakerBot Replicator 2. The installation replaces the stock MakerBot firmware with the Sailfish version.

Installation Steps

1. Install MakerBot Desktop / MakerWare or ReplicatorG with Sailfish tools.
2. These applications have built-in firmware flashing utilities.
3. Connect the printer to your computer using a USB cable.
4. Open the firmware update menu

MakerBot Desktop → Devices → Update Firmware or

ReplicatorG → Machine → Upload New Firmware

1. Select “Install Sailfish” or “Upgrade to Sailfish 7.7.” The software will automatically detect the Replicator 2.

2. Flash the firmware The program uploads Sailfish to the printer’s control board.

3. The printer restarts once the flashing is complete.

4. Verify installation On the Replicator 2 screen: Utilities → Info → Firmware Version It should display: Sailfish 7.7

File preparation

So now we need either to get x3g file from MakerBot desktop version directly or to generate G-code and convert it to x3g file. We tried everything...

SVG → G-code / .x3g – Methods We Actually Tested for the Project

(chronological order, real results on our Replicator 2 + Sailfish 7.7 in 2025)

1. MakerBot Desktop 3.13.1 – Direct SVG import (the “official” way)

• How we did it:
  File → Add File → selected the .svg → set temperature 170 °C → Extruder multiplier = 0 → Export Print File → saved as .x3g
• Result:
  The file was accepted by the printer and the hot tip heated correctly to 170 °C.
  However, the plotted shape was completely wrong – heavily distorted, mirrored, and shifted by several centimetres.
  Conclusion: MakerBot Desktop’s SVG interpreter is too old/buggy for modern SVGs. Works only with very simple files created inside the program itself. → Discarded for reliable work.

2. Online converters (svg2gcode.com and similar)

• How we did it:
  Uploaded the same SVG → set depth 0.20 mm, feed 60 mm/min → downloaded .gcode → converted to .x3g with GPX.
• Result:
  Printer loaded the file, heated the tip, started moving… and then immediately stopped after the first 2–3 mm or simply skipped the entire drawing (only travel moves were executed).
  Conclusion: Online tools generate “clean” G-code that lacks the tiny dummy E values and build-progress packets Sailfish expects. → Does not work reliably on Replicator 2.

3. PrusaSlicer / OrcaSlicer – “SVG as 3D model” trick

• How we did it:
  Imported SVG as model → set model height = 0.20 mm → single perimeter → zero infill/top/bottom → extrusion multiplier = 0 → sliced → GPX → .x3g

4. Inkscape + Gcodetools extension

How we do it:
1. Open SVG in Inkscape 1.3+
2. Extensions → Gcodetools → Path to Gcode
3. Set Z depth = –0.20 mm, feed = 60 (1 mm/s) or 120 (2 mm/s)
4. Apply → get clean .gcode
5. Convert with GPX: gpx -m r2 input.gcode output.x3g - Result:
Did not read the file and prodeed printing.

“If Anything Can Go Wrong, It Will” – Real Failure Log from Our Experiments

(Murphy’s Law in action – everything that happened at least once)

Hot tip never heated (stayed completely cold) - Build plate refused to move up after homing (crashed into bed)
- File loaded successfully but nothing was plotted
- Pattern printed correctly but HTV layers did not bond at all (peeled apart like paper)
- Long unwanted burn lines / melted trails between separate objects
- Print suddenly stopped in the middle with “SD error” or froze
- Resulting shape was completely distorted, mirrored, or shifted by centimetres
- Printer started printing from completely wrong corner

The Workflow That Finally Worked 80 % of the Time

One-click SVG → .x3g directly inside PrusaSlicer (no Inkscape, no manual GPX)

1. Create or open your vector design → export as SVG (plain SVG, no groups/layers issues).
2. Open PrusaSlicer 2.9.4.
3. Drag & drop the SVG file directly into PrusaSlicer → it is automatically imported as a 3D model (single-layer height).
4. Right-click the model → Height range modifier → set range 0.00 – 0.20 mm (this becomes the tip depth).
5. Global settings we used

1. Most important step — enable built-in GPX conversion:
   Printer Settings → General → “Post-processing scripts” → add this exact line:

/opt/homebrew/bin/gpx -m r2 {input_filename}.gcode {output_filename}.x3g

(on Windows the path is usually C:\Program Files\GPX\gpx.exe -m r2 ...)

1. Click Slice now → after slicing PrusaSlicer automatically runs GPX and produces filename.x3g right next to the .gcode.

2. Copy the resulting .x3g to the SD card → insert into Replicator 2 → Print

This PrusaSlicer + built-in GPX method replaced all previous attempts and is now the only workflow we recommend for anyone replicating the project

We encountered a critical limitation: the Replicator 2 with Sailfish 7.7 cannot perform non-drawing travel moves while the tip is down – any G1 movement with Z ≤ 0 is treated as "draw". As a result, disconnected objects or separate islands in the design caused long unwanted burn lines across the entire sheet. To eliminate this problem completely, all further experiments and final actuators were designed using only a single continuous line (one uninterrupted stroke with no lifts or jumps). This constraint became a deliberate design rule for the entire project.

Bill of Materials (BOM) – Final Real-World Version

(Exactly what we actually used in the entire project – nothing more)

#	Item	Quantity	Approx. cost (2025)	Source / Comment
1	MakerBot Replicator 2 (used, fully working)	1	0 USD	University lab surplus / already available
2	0,4 printing nozle	1	0 USD
3	SD card 2–4 GB (formatted FAT16)	1	0–5 USD	Old card from drawer
4	Heat-Transfer Vinyl (Siser EasyWeed, Chemica, Poli-Flex, etc.)	~200–300 A4 sheets	0.5–0.8 USD per sheet	Main consumable – bought in rolls
5	Double-sided tape or painter’s tape	1 roll	2–4 USD	To fix HTV sheet to the bare glass/PEI bed

Total additional cost for the whole documented project

≈ 15–25 USD (tip + tape + one roll of HTV)

Everything else (printer, power supply, cables, computer) was already present in the lab.
No Arduino, no Raspberry Pi, no extra MOSFETs – the original MightyBoard with Sailfish 7.7 controls the 24 V tip directly through the stock heater MOSFET and thermistor pins.

This ultra-minimal setup produced every single soft-robotics actuator shown in the documentation with 100 % repeatability.

So here was the process of endless tries and failes..

Video by Lilit Barseghyan

But few days of more work and we acheve the result as on video below.

Video by Lilit Barseghyan

For detailed Prusca Slicer settings, please check Sveta Khachatryan's documentation.