blog.electrocute.io

the soft computer

may 13, 2026
calm-tech grad-school physical-computing poetry soft-interfaces creative cyberfeminism electrocute generative-text open-source reflection soft-electronics

My NYU ITP - Master’s Degree Thesis Project: the soft computer

A textile-based computing object that imagines a gentler way of being with technology.

Imagine You’re A Kid Again

You walk over to the family computer. You sit down. The chair is too big for you. You turn on the PC and you wait. The monitor hums to life slowly, line by line.

You want to use the internet. But your mom is on the phone. So you wait. And you wait some more. When she finally hangs up, you plug in the modem. You hear the dial-up sound. Some of you know what that is. Some of you have never heard it before in your life.

The page loads one image at a time. One paragraph at a time. And then the cursor freezes. The little hourglass spins. You click anyway. You click again. Nothing. And then, sometimes, the blue screen of death.

You sit there. You wait. You restart. You wait more. You try again.

Here’s the thing. The computer takes its time, and so do you. It’s slow, almost ceremonial. It doesn’t follow you anywhere. It doesn’t ask anything of you. When it works, it just waits with you, until something arrives. When it breaks, it tells you. You fix it, or you walk away.

Somewhere along the way, we lost the patience the machine used to have. I wanted to see if I could find it again.

What It Is

The Soft Computer is my ITP thesis. It’s a compact, all-in-one computing object built out of soft materials, machine-knit accents, and embedded electronics. It senses touch, generates poetry, and outputs physical receipts. It is designed to be sat with, not operated.

Instead of a glass screen and a rigid plastic shell, it has carved upholstery foam, industrial felt, neoprene, a knit wool-cotton panel, and a removable fabric slip cover. Inside, it runs a flexible 10.3” e-ink display, capacitive touch zones, a haptic motor, and a thermal printer. The form is 13” tall, 16” wide, 10” deep. You hold it in your lap.

It asks what becomes possible when we design computers around softness rather than hardness, around care rather than command, around material presence rather than digital abstraction.

What I Mean By Care

The Soft Computer started as an experiment in care, and I should be specific about what I mean by that, because it’s a word that gets used a lot.

Care, for me, means a machine that doesn’t extract from you. That doesn’t optimize you. That doesn’t treat your attention as a resource to mine. Care means the computer assumes you have a body, a tempo, a tolerance for ambiguity. It means the computer is willing to wait for you, instead of demanding you hurry up for it. Care means the relationship between you and the machine is gentle, not transactional.

Mark Weiser, in 1991, called for something close to this. He called it calm technology. But I wanted to go further than calm. I wanted warm. I wanted tactile. I wanted a computer designed around care, not command.

In the age of AI, we need a moment of softness. To slow down. To ask what we actually want from our machines.

The Central Question

Every computer, no matter how fancy, comes down to one simple thing: switches that are either on or off. One or zero. Yes or no. Those switches are wired together into logic gates that ask simple questions, and those gates stack into more gates, until you eventually have a phone in your pocket that can do almost anything.

I love hardware computers. Silicon is genuinely incredible. The computer I’m writing this on wouldn’t exist without it. But the way silicon computers are built today hides those switches behind glass and metal. They’re tiny, fast, and invisible. You can’t see them. You can’t touch them. You can’t slow them down.

I wanted to ask: what if those switches were soft? What if they were visible? What if they were comforting to touch?

Why I’m Making It

My relationship to electronics has always been shadowed by a dissonance with the language of hardness that defines the field. Hard drives, hard logic, hard science. Yet underneath every rigid circuit is something fundamentally soft: flexible wires, malleable solder, human hands, patient care.

That contradiction got louder as I learned more computing history. Long before silicon, computation lived in textiles. The Jacquard loom, in 1804, used punched cards to encode patterns, the ancestors of computer programs. Ada Lovelace, in 1843, wrote that the analytical engine “weaves algebraic patterns just as the Jacquard loom weaves flowers.” In 1757, the mathematician Alexis Clairaut employed two human “computers” to refine predictions for Halley’s Comet. In 1945, six women programmed ENIAC. In the 1960s, the rope core memory that flew Apollo to the moon was woven by hand, mostly by women at Raytheon.

Computation has always been textile, and it has always been touched by women’s hands. That history was systematically erased as the field professionalized. It’s worth looking up. My thesis picks up that thread.

Softness is not weakness. Softness is the ability to flex, mend, feel, and adapt.

The Form + Electronics

What’s inside?

The Soft Computer is built in layers. Months of trying different combinations until it felt right. Soft enough to hold. Firm enough to hold itself.

  • Machine-knit yarn made on a Brother KH-930 knitting machine

  • Felt for the soft buttons

  • Upholstery foam carved out in the middle for the electronics, filled with batting for structure

  • Neoprene on the outside, holding everything together

  • A removable fabric slip cover in macintosh beige open-weave linen

A machine-knit lavender panel frames the e-ink display on the front, and a second knit pouch in the same yarn holds the Raspberry Pi 5 inside. The whole object looks and feels like a textile. There is no visible hardware.

The chassis is modular. The slip cover is removable. The buttons snap on and off. The whole thing is designed to be repairable, opened, and modified, which is a counter to consumer electronics that ship sealed.

Embedded electronics

Underneath the plushy softness, these are the bits and pieces that make it work.

An Adafruit Fruit Jam handles all the sensing, every press of the soft keys, every move across the soft matrix keypad. It talks over USB to a Raspberry Pi 5, which is the brains: it runs the Markov chain that generates the poetry, and it drives the flexible e-ink display. There’s a thermal printer for the receipts, all powered by a single source.

When you touch one of the soft buttons or the keypad, the fabric senses it. That signal goes to the sensing board, which talks to the brain, which generates a poem one word at a time and renders it onto the flexible screen. When you walk away, a small printer prints the poem on paper.

Everything happens locally. No internet, no cloud, no large language model. Nothing you say or do leaves this object. That’s becoming rare.

The Inputs

Four felt buttons act as a poetic keyboard. They are soft, snap-on, and color-coded:

  • Blush — care corpus

  • Sky blue — dreamlike corpus

  • Mint — textile vocabulary corpus

  • Yellow — subverted CS documentation

Each button biases the generative text engine toward a different body of writing. Pressing a button is a way of asking the computer to speak from a different lineage.

A soft matrix keypad sits alongside the buttons as a 3×3 grid of capacitive zones built from conductive tape under the fabric. Each cell is its own touch point, and together they modulate the mood of generation. The keypad lets you shape the language, not just choose its source.

Under the fabric, the matrix is listening for a pattern: not a tap, but a hold. A half-second to register as presence, two seconds of absence to release it.

DROP_THRESHOLD = 35000
HOLD_TIME = 0.5
RELEASE_TIME = 2.0

if touch_now:
    release_start = None
    if touch_start is None:
        touch_start = now
    elif now - touch_start > HOLD_TIME and not is_present:
        is_present = True
        print("presence=on")
else:
    touch_start = None
    if is_present:
        if release_start is None:
            release_start = now
        elif now - release_start > RELEASE_TIME:
            is_present = False
            print("presence=off")

The Outputs

A flexible 10.3” e-ink display is the face of the machine, framed by the knit panel. Text builds slowly, word by word, in response to touch. E-ink was the right choice here because it doesn’t glow. It doesn’t demand attention. It looks like paper, settles into the textile around it, and asks you to lean in rather than be pulled toward it.

A haptic motor pulses with each interaction. Each button has its own pulse signature, so the object responds to your touch in a felt way, not just a visible way.

A thermal printer outputs ritual receipts: physical poem artifacts you can take with you. The receipt is the object’s gift, a small printed memory that lives outside the screen.

Poetry Mechanism

Most people hear “the computer generates text” and picture something like a massive model trained on the whole internet, predicting the most likely thing anyone could say. The soft computer is the opposite of that.

modes = {

    "button_1": {"corpus": "corpora/lineage.txt"},    # blush

    "button_2": {"corpus": "corpora/dreamlike.txt"},  # sky blue

    "button_3": {"corpus": "corpora/textile.txt"},    # mint

    "button_4": {"corpus": "corpora/subverted.txt"},  # yellow

}

Four buttons, four corpora. Each one is a few pages of text I chose on purpose. Press blush, the machine speaks in the vocabulary of Ada Lovelace, the ENIAC programmers, the Apollo rope memory weavers. Press yellow, it only has CS documentation and error messages to work with. It can’t reach outside the corpus to find something more likely. It has to stay in the small specific world I built for it.

from shoestrings import TextGenerator, SimpleWordTokenizer

corpus = open(modes[button_event]["corpus"]).read()
gen = TextGenerator(SimpleWordTokenizer(), n=3)
gen.feed(corpus)
output = " ".join(gen.generate(40))

An order-2 Markov chain, looking at the previous two words to pick the next one. The math is so small you could do it on paper with a tally chart. 

n=1 is gibberish
n=3 is the seam where statistics start to feel like writing.
n=5 just regurgitates the source

The soft computer doesn’t predict the most likely word. It picks the next word from a list of words it has actually seen, in a small specific world I made for it. That’s the whole model.

You might ask why the output is a poem and not, say, a useful tool. The answer is care.

A tool tells you what to do. A poem invites you to interpret. A poem doesn’t optimize anything. It asks you to slow down and pay attention.

The poems are generated by a Markov chain. That means I feed it a small set of source texts, what’s called a corpus, and it learns the patterns of which words tend to follow which other words. When you interact with the piece, it picks the next word, and the next, based on those patterns.

It’s not predicting what you want to read. It’s not trained on the entire internet. It’s small, local, and shaped by the specific texts I chose. The corpus is the conversation. That’s where the personality of the soft computer lives.

This approach is in conversation with Allison Parrish’s computational poetics practice, where the goal is not to make text that passes for human but to make text that feels discovered.

Soft OS States + Architecture

The system cycles through three states:

Wake is a short ritual when the object turns on. The display greets you. The object orients itself toward presence.

Play is active interaction. Each button selects a corpus, and the keypad shapes the mood of generation. The Markov chain builds a poem word by word on the screen, drawn from the corpus you chose.

Dream is idle ambient mode. The display drifts with self-generated text from across the corpora. The object waits for someone to return.

There is no productivity state. There is no notifications state. There is no urgency anywhere in the system.

The Knit Panel and The Pouch

The knit panel that frames the e-ink display is the part of the object you see first. It is a wool-cotton blend in lavender (my favorite color, after black), knit flat on my Brother KH-930. The final spec:

  • Cast on: 70 stitches

  • Rows: 56

  • Finished dimensions: roughly 10” × 8”

  • Tension: 5

  • Gauge: ~7 stitches per inch in worsted weight

  • Stitch: plain stockinette

Wool gives it warmth and a slight halo. Cotton keeps it stable enough to sit cleanly behind the e-ink without sagging. I blocked the panel briefly after coming off the machine to keep the edges from curling, then mounted it so the e-ink reads as if it’s sitting inside a soft window.

I also machine-knitted a small pouch in the same lavender yarn to hold the Raspberry Pi 5. It’s a flat knit panel seamed up the sides into a pocket. Tucking the Pi inside a soft sleeve felt right. The part of the computer doing the most thinking is also the part you can’t see, wrapped in the same material as the face.

Using the KH-930 mattered to me. The machine is from 1986. It’s the same kind of domestic technology that has historically been coded as women’s work and dismissed as not-really-engineering, even though it’s a programmable patterning system that predates much of what we now call computing. It sat a few feet from the Raspberry Pi on my desk and quietly makes the same point the thesis is making.

The Sensory System

The Soft Computer engages multiple senses at once, plus one often overlooked:

Touch. Felt buttons, knit wool, soft textile surface, haptic pulse.

Sight. Slow text on e-ink, framed in soft lavender wool.

Proprioception. The sense of your own body in space. The object has weight. You hold it. A screen has no body. This does.

And underneath all of them, one design principle: slowness. The object is rate-limited and intentional. It resists speed. In a world of optimized interfaces, the Soft Computer asks you to wait, to stay, to notice.

User Testing

Testing happened in two phases.

With the prototype, conversations with peers and advisors shaped the early decisions: the inputs should be ambiguous, the output slow, the piece something you live with rather than operate.

With the actual build, what I didn’t expect was how much it tested people’s patience. The e-ink updates slowly. There’s no progress bar. Some people leaned in. Others got visibly restless within seconds, reaching for their phone or asking if it was broken. That restlessness was the most interesting finding. The people who stayed described it as calming, even meditative. But getting there required unlearning something.

The things people asked for, sound, scent, warmth, are the things I can’t wait to build next.

An Offering Of Connection

The Soft Computer is, more than anything, an offering of connection. Not connection in the way we use that word now, wifi, signal, push notifications, always on. Connection in the older sense. The kind that requires presence. The kind that asks you to stay.

What does it offer? It offers slowness. It offers a small object that doesn’t want anything from you, and a small voice that’s just trying to make something with you. It offers the surprise of a sentence that you and the corpus made together, that wouldn’t have existed if you hadn’t sat down. And it offers a receipt you keep. Proof that something happened between you and a soft machine.

What does it leave behind? Everything else. All the noise. All the metrics. All the urgency. You and the Soft Computer are just two presences, taking turns making a poem.

I think that’s the prize. It’s a small one, but it’s real.

Research and Lineage

The Soft Computer sits within several intersecting lineages.

The most foundational is the historical entanglement of textiles and computing: Alexis Clairaut employed human “computers” to predict Halley’s Comet (1757); the Jacquard loom introduced punched cards as pattern logic (1804); Ada Lovelace described computation through weaving metaphors (1843); six women wired and programmed ENIAC (1945); and rope core memory for the Apollo missions was woven by hand at Raytheon, predominantly by women (1960s). Lillian Schwartz’s early computational art extended this lineage into aesthetics. Computation has a soft origin that was systematically erased as the field industrialized.

The theoretical frame draws from Mark Weiser and John Seely Brown’s calm technology (1996), Hiroshi Ishii and Brygg Ullmer’s tangible bits and embodied interaction (1997), Shaowen Bardzell’s feminist HCI (2010), Steven Jackson’s broken world thinking and repair culture (2014), and Olia Lialina’s ongoing work arguing for the visible computer and the rights of users.

The e-textiles lineage, particularly the work of Hannah Perner-Wilson (KOBAKANT), Leah Buechley’s LilyPad Arduino, Irene Posch’s embroidered computers, and XS Labs’ reactive garments, establishes the material and technical vocabulary the project builds on. I’m endlessly inspired by their work alongside Allison Parrish’s, and I’m building on what they’ve made.

For output, the project takes cues from Kelli Anderson’s work on paper as a computational medium and the Conditional Design Workbook’s approach to constraint-based generation. For text, the project draws from Allison Parrish’s computational poetics practice, using lightweight generative text methods over large language models deliberately, in alignment with the project’s values of interpretability and slowness. The flexible e-ink display is informed by research into plastic logic substrates and large-format flexible display technology. Malcolm McCullough’s The Fabric of Interface grounds the project’s thinking on tactile interaction as a serious interface philosophy.

Where It Lives

The Soft Computer is exhibited at the ITP Thesis Show at NYC Resistor, the ITP/IMA Spring Show (May 9–10, 2026), and the Open Hardware Summit in Berlin (May 23, 2026), where I’m attending as a fellow.

The object needs only one wall outlet and a stable surface. It is designed for public interaction and for all ages: children who touch without hesitation, adults who slow down and get curious, anyone who has ever felt alienated by the hardness of machines.

Coming Back To Where We Started

I want to come back to the dial-up. The blue screen of death. The family computer.

We had one growing up. But really, it was mine. I was the technical one, the kid who fixed everything for everyone else. Computers were the first thing I loved figuring out.

I’ve watched technology go from some of the slowest times to what it is now. During my time, we used to wait until 9pm to talk to people for unlimited minutes. Twenty years later, we pay for unlimited minutes and don’t call anyone. And what’s strange is that even the current generation, people who never heard a modem, who never waited for a pixelated photo to load line by line, sometimes feel a kind of nostalgia for it. For LimeWire downloads that took an hour and might be a virus. For blowing into a Nintendo cartridge to make it work. For staying up to write the perfect away message.

We used to log on. Now we don’t ever log off.

Back then, computing was a hobby. You taught yourself HTML on Neopets and MySpace. You burned mix CDs for your friends. There was room for tinkering. But with that creativity came constraints.

The Soft Computer is built around constraints on purpose. It has a small corpus, not the whole internet. One poem at a time, not endless content. A receipt you can hold, not a feed you scroll. And a finite memory, like the computers we grew up with, the ones that made you choose what to keep, and what to let go. The constraint isn’t a workaround. The constraint is the point. That’s what makes the encounter feel like a golden ticket, small, specific, yours.

What’s Next

Beyond the spring show and Berlin, I want to keep building soft peripherals, things that are soft and fully functional. Soft keyboards, soft pointing devices, soft screens, soft cases. And I want to keep iterating on the Soft Computer itself. A v2 with the sensory layers people asked for.

The entire project lives at thesoft.computer, and I’m releasing all the documentation and making it open source. I want people to be able to take it apart, remix it, and make their own.

Because that’s the thing I would like to encourage: make your own soft computer. Or your own computer of any kind. It doesn’t have to be soft. It just has to be yours. Something built around your values, not someone else’s. There’s so much more this lineage can hold.

Citations & Further Reading

A loose bibliography of the texts and projects that shaped this work. Grouped by theme, with links where they exist.

On calm technology and tangible interaction

Weiser, M. and Brown, J. S. (1996). “The Coming Age of Calm Technology.” Xerox PARC. calmtech.com/papers/coming-age-calm-technology

Weiser, M. (1991). “The Computer for the 21st Century.” Scientific American, September 1991.

Ishii, H. and Ullmer, B. (1997). “Tangible Bits: Towards Seamless Interfaces Between People, Bits and Atoms.” In Proceedings of the SIGCHI Conference on Human Factors in Computing Systems, ACM Press, 234–241.

McCullough, M. (2004). Digital Ground: Architecture, Pervasive Computing, and Environmental Knowing. MIT Press. See also his earlier Abstracting Craft: The Practiced Digital Hand (1996).

On feminist HCI and repair

Bardzell, S. (2010). “Feminist HCI: Taking Stock and Outlining an Agenda for Design.” In Proceedings of CHI ‘10, ACM Press, 1301–1310.

Jackson, S. J. (2014). “Rethinking Repair.” In Gillespie, T., Boczkowski, P. J., and Foot, K. A. (Eds.), Media Technologies: Essays on Communication, Materiality, and Society. MIT Press, 221–240.

Lialina, O. (ongoing). “Turing Complete User.” contemporary-home-computing.org/turing-complete-user

On e-textiles and soft circuits

Buechley, L., Eisenberg, M., Catchen, J., and Crockett, A. (2008). “The LilyPad Arduino: Using Computational Textiles to Investigate Engagement, Aesthetics, and Diversity in Computer Science Education.” In Proceedings of CHI ‘08, ACM Press, 423–432.

Perner-Wilson, H. and Satomi, M. KOBAKANT, How To Get What You Want. kobakant.at/DIY

Posch, I. (2017). The Embroidered Computer. ireneposch.net

XS Labs (Joanna Berzowska et al.). xslabs.net

On the textile lineage of computation

Plant, S. (1997). Zeros + Ones: Digital Women and the New Technoculture. Doubleday.

Light, J. S. (1999). “When Computers Were Women.” Technology and Culture, 40(3), 455–483.

Essinger, J. (2004). Jacquard’s Web: How a Hand-Loom Led to the Birth of the Information Age. Oxford University Press.

Mindell, D. A. (2008). Digital Apollo: Human and Machine in Spaceflight. MIT Press.

Lovelace, A. (1843). “Notes by the Translator” on Menabrea’s “Sketch of the Analytical Engine.”

On computational poetics and paper as medium

Parrish, A. Reading and Writing Electronic Text (NYU ITP). decontextualize.com

Anderson, K. (2017). This Book Is a Planetarium: And Other Extraordinary Pop-Up Contraptions. Chronicle Books.

van der Velden, L., Brouwer, J., and Mulder, A. (eds.) (2013). Conditional Design Workbook. Valiz.

♡ ♡ ♡ Heartfelt Thanks ♡ ♡ ♡

To my parents for their unconditional love and support. To my ITP community; professors, advisors, residents, my wonderful classmates. To my fellow softies. And to everyone who tested this piece and pushed back on it.

And to my younger self, the kid who loved figuring out computers, who mixed potions and made up worlds and built things out of scraps. Thank you for not letting that part of me go. I hope it makes you proud.

This project is, in every way, made of other people’s hands and ideas alongside mine. And that, to me, is what computing should feel like.

Thank you. ☻