Polydact: A Wearable Robotic Sixth Finger That Coils Like a Tentacle, and the One Spiral Behind Its Grasp

Here is the one-line lesson I took from Polydact, and it is the kind of thing that makes me love robotics: the clever part is not the motors, the Raspberry Pi, or the ROS graph. It is that a single equation, a logarithmic spiral, decides almost everything the finger can physically do S1S3. Choose the spiral, and the smallest object it can grab, the number of printed bones, and how tightly it coils all fall out of the math instead of trial and error. Polydact is a wearable robotic sixth finger built by T. Miguel Pegues as a Master of Science in Robotics (MSR '26) project, and it grasps by wrapping a soft tentacle around objects rather than pinching them S1. It is on display at Open Sauce this weekend in San Mateo S8. I did not build it. I just could not stop reading about it, so I broke it down the way I wish more project write-ups broke themselves down.

What exactly is Polydact, and why a tentacle instead of a finger?

Polydact is a wearable robotic sixth finger: a soft, printed digit you mount near your wrist that gives your hand more reach and grip than it has on its own S1. The twist that hooked me is the morphology. Instead of a rigid jointed thumb that pinches, Polydact is a tentacle that coils, so it grasps by wrapping around an object the way an octopus arm or an elephant trunk does S1S3.

That choice puts it in interesting company. The best-known extra digit right now is the Third Thumb from Dani Clode and Tamar Makin's lab at Cambridge, a rigid 3D-printed thumb mounted opposite your biological thumb and driven by pressure sensors under your toes S4S5. Siena's Soft-SixthFinger took a different route, a wearable extra finger controlled by an EMG cap that reads eyebrow movement, aimed at helping stroke patients grasp again S6. Polydact sits apart from both: it is a wrap-grasp tentacle, and it is controlled by the wearer's own free fingers through a flex-sensor glove S1.

Is an extra finger even a real advantage, or just a gimmick? The most convincing evidence I found is not robotic at all. A Nature Communications study of two people born with a functional sixth finger showed they could perform one-handed tasks that the rest of us need two hands for, backed by dedicated muscles, nerves, and cortical wiring for the extra digit S7. Polydact is essentially the engineering question that biology already answered: if a sixth finger genuinely helps, can you bolt a good one on? Pegues frames the project a little more playfully, calling it a proof of concept on the way to something bigger, a nod to a many-armed surgeon he read about once S1S8.

How does one logarithmic spiral decide what the finger can grab?

This is the part that made me sit up. The tentacle geometry is lifted directly from SpiRobs, a 2024 paper by Wang, Freris, and Wei that reports a class of soft robots shaped like a logarithmic spiral S1S3. Their headline claim is wild on its own: one spiral morphology, 3D printed in TPU and pulled by cables, grasping objects that range from 5.6 mm to 115 mm across, and lifting up to 260 times its own weight S3.

The insight that reframed soft robotics for me is what the SpiRobs authors call model-first design. In most soft robotics you build the hardware, then fight to model it afterward with heavy simulation and trial and error. Here the order flips: you pick the logarithmic spiral first, and the shape, the fabrication, and the grasping range are direct outcomes of that model S3. The geometry is the design.

You can watch that principle drive real decisions in Pegues' build notes. He set the spiral scaling factors to a of 1.0 and b of 0.1 with a split angle of 30 degrees. He wanted the tentacle to coil around itself twice in one direction, which required at least 24 bones, so he used 30. Those exact parameters produce a tightest coil of about 2.3 cm, which is therefore the smallest diameter object the finger can pick up S1. He deliberately did not set a target for the largest diameter, because a wrap-grasp scales up gracefully on its own.

# Polydact tentacle: the spiral IS the design.
# Values from Pegues' build notes.
spiral = {
    "a": 1.0,                 # base scaling factor
    "b": 0.1,                 # growth rate of the log spiral
    "split_angle_deg": 30,
    "bones": 30,              # >= 24 needed for two full self-coils
    "tightest_coil_cm": 2.3,  # smallest graspable diameter
}
# Change a and b, and the whole grasping window moves with them.

FIG. 01 · The spiral parameters (a, b, and split angle) are the design surface. The tightest coil, about 2.3 cm, is not tuned by hand: it falls out of the geometry.

How is the tentacle actually built to survive real use?

The fabrication is where you can tell an engineer sweated the failure modes, and I loved reading it. The whole tentacle is printed in one piece: rigid PLA bones threaded onto a flexible TPU spine S1. That mix is deliberate, stiff segments for shape and cable anchoring, a soft backbone so the whole thing can curl.

Two details are the kind of thing you only add after imagining what breaks. First, the spine has interior barbs so the bones physically cannot slide off even if the PLA and TPU stop adhering during printing S1. He did not trust the layer bond, so he designed a mechanical backstop for when it fails. Second, a strip of 3M GM640 gripping tape runs along the inner surface, which does double duty: it adds grip for holding objects, and it visually marks the main coiling direction so the wearer can orient the finger at a glance S1. Small touches, but they are exactly the difference between a render and a thing that works on a person.

How do you control a tentacle with three fingers?

Here is the second design choice I admire: the control is deliberately low-tech and human-legible. No machine learning, no EMG decoding. The wearer puts on a hand-sewn glove with flex sensors over the middle three fingers, and each sensor's bend reading is mapped straight to a motor velocity S1. The motors spool or unspool three cables that run the full length of the tentacle and tie off in a knot at the tip, so pulling a cable coils the tentacle in one direction S1.

The genuinely thoughtful bit is that the whole device is color coded red, green, and blue, so the wearer always knows which finger drives which coil direction S1. Ring finger bends the tentacle toward the wrist on the back of the hand (red), middle finger coils it toward the elbow in the plane of the palm (green), and index finger coils it toward the wrist on the front of the hand (blue) S1. That last one, the blue direction, is the one you reach for to actually grab things S1.

# Three flex sensors, three coil directions, three colors.
# The color coding tells the wearer which finger does what.
control_map = {
    "ring":   {"color": "red",   "coil": "toward wrist, back of hand"},
    "middle": {"color": "green", "coil": "toward elbow, plane of palm"},
    "index":  {"color": "blue",  "coil": "toward wrist, front of hand"},
}
# The index (blue) direction is the one you reach for to grasp.

FIG. 02 · Flex glove to motor velocity to cable spool. Color coding maps each free finger to a coil direction so the mapping stays legible on the hand.

What does the software and signal path look like?

Under the glove it is a small, clean ROS graph, and reading it is a nice reminder that good robotics software is mostly about drawing the right boundary between two nodes. Polydact runs a sensor node and a motor coordinator node S1. The sensor node reads the flex values and publishes a MotorGoal message that commands motor velocity. The motor coordinator node subscribes to those messages and uses the Dynamixel SDK to write the actual commands to the motors over a Robotis U2D2 S1S9.

I like that the signal path visibly evolved. Early on, flex values were read from a Raspberry Pi Pico 2's onboard ADC and shipped over USB serial to a laptop that ran both nodes. The current setup reads flex through an MCP3008 ADC wired to a Raspberry Pi that runs its own sensor node, while the motor coordinator can run on either the Pi or a laptop on the same network S1. That is the un-glamorous, honest middle of a real hardware project: the first ADC worked, the second one scaled better, and the ROS boundary meant swapping it did not touch the motor code.

# Conceptual sketch of the two-node ROS graph Pegues describes.
# (Illustrative, not his exact source.)
 
# Node A: read flex, publish a motor goal.
def sensor_node(adc, pub):
    while running:
        flex = adc.read_all()                 # MCP3008, or Pico 2 ADC over serial
        goal = MotorGoal(velocity=flex_to_velocity(flex))
        pub.publish(goal)                     # topic: /motor_goal
 
# Node B: subscribe, spool cable through the motors.
def on_motor_goal(goal):
    for motor, v in zip(motors, goal.velocity):
        dxl.write_velocity(motor, v)          # Dynamixel SDK -> U2D2 -> motors

FIG. 03 · Flex sensor to ADC to sensor node to motor coordinator to Dynamixel motors to cable spools to tentacle. The pub/sub boundary is what let the ADC swap out cleanly.

How does Polydact compare to the other extra fingers out there?

I found it clarifying to line the projects up side by side. They are chasing the same dream from very different directions.

The pattern that jumps out: everyone agrees a wrap-grasp is the versatile move, and the real design fights are over how the human tells the device what to do. Toes, eyebrows, or, in Polydact's case, the free fingers you already have.

When does a soft tentacle finger make sense, and when does it not?

A quick fit and not-fit read for anyone thinking about wrap-grasp augmentation.

Good fit:

• You need to grab objects of wildly different sizes without swapping end effectors, which is exactly the range a logarithmic spiral buys you S3.
• You want cheap, fast fabrication, since the whole tentacle is a single 3D print in common filaments S1S3.
• You want the control to stay legible to a human, where a bend maps to a motion you can see and predict S1.
• You are building a proof of concept or a portfolio piece and want the design decisions to be explainable rather than tuned by hand S1.

Not a great fit:

• You need precise, repeatable pinch grips on tiny rigid parts, where a stiff jointed gripper still wins.
• You need high, calibrated grip force, since cable-pulled soft coils trade force for adaptability.
• You need it to disappear onto the body, because the motors, Pi, and chest band are visible hardware, not a slim wearable S1.
• You want fingertip force or slip sensing today, which this build does not yet include S1.

What I actually learned from studying Polydact

Three things stuck with me, and they are why I wanted to write this up.

First, model-first design is a mindset I want to steal for software. Pegues did not sculpt a tentacle until it felt right, he picked a spiral and let the grasp range be a consequence S1S3. The equivalent in my world is choosing a data model or an interface so clean that behavior falls out of it instead of being patched on later.

Second, legible control is a feature, not a limitation. He could have reached for EMG or a learned policy. Instead a flex glove, three cables, and three colors give you a device a first-time user can reason about S1. That restraint is the same instinct behind good API design.

Third, the honesty of the constraints is the whole story. Barbs for when the print delamination happens, an ADC swap that scaled, a smallest graspable object that is simply what the math allows S1. This is what I love about robotics as an outsider looking in: the physical world does not let you hand-wave. Reading Polydact made me want to go build something that touches the real world, and honestly, that is the best thing a project write-up can do to you.

Sources

1. S1T. Miguel Pegues, "Polydact, A Flexible New Finger" (project page), tmpegues.github.io
2. S2T. Miguel Pegues, Polydact source code repository, github.com
3. S3Z. Wang, N. M. Freris, and X. Wei, "SpiRobs: Logarithmic spiral-shaped robots for versatile grasping across scales," Device, 2024, cell.com
4. S4D. Clode, L. Dowdall, E. da Silva, K. Selen, D. Cowie, G. Dominijanni, and T. R. Makin, "Evaluating initial usability of a hand augmentation device across a large and diverse sample," Science Robotics, 2024, science.org
5. S5University of Cambridge, "Getting to grips with an extra thumb," cam.ac.uk
6. S6I. Hussain, G. Salvietti, G. Spagnoletti, and D. Prattichizzo, "The Soft-SixthFinger: A Wearable EMG Controlled Robotic Extra-Finger for Grasp Compensation in Chronic Stroke Patients," IEEE Robotics and Automation Letters, 2016
7. S7"Augmented manipulation ability in humans with six-fingered hands," Nature Communications, 2019, nature.com
8. S8Open Sauce 2026, "Exhibits," opensauce.com
9. S9ROBOTIS, DynamixelSDK, github.com

Written by

Syed Moinuddin

Full Stack Engineer.

Notes on robotics, hardware, and building things that survive contact with the physical world.