History of Etherpad: How Aaron Iba's Open-Source Editor Shaped the Modern Web (2026)

In 2007, three engineers in their twenties left Google's Search Quality team to start a JavaScript developer-tooling company in Boston called AppJet. As a Friday-afternoon demo for their server-side JS runtime, they built a collaborative pad in the browser.

Eighteen months later, that pad — Etherpad — was being used by Wikipedia editors, NPR newsrooms, Mozilla engineers, and student study groups. Two weeks before Christmas 2009, Google bought the company. The three engineers moved to Sydney to work on Google Wave. The Wave team's OT engine absorbed Etherpad's tricks. Then Wave failed, the team scattered, and one of those engineers — Aaron Iba — eventually showed up as an angel investor in Taskade, the AI workspace platform whose Project editor runs on ot-json0, the open-source descendant of the Wave OT engine.

This is the story of how a Friday demo became the editor that taught Google how to collaborate — and how its OT lineage runs all the way to AI-agent workspaces today.

TL;DR: Etherpad launched November 19, 2008 as the first character-by-character real-time browser editor. Google acquired its parent AppJet in December 2009 for the Wave team. After Wave shut down, Joseph Gentle extracted the OT primitives as open-source ShareJS / ot-json0 — what Taskade Projects runs on today. Aaron Iba (Etherpad co-founder, ex-Wave engineer) is a Taskade angel investor. The lineage isn't a metaphor; it's a cap-table receipt. Try Taskade Genesis →

🌐 Etherpad in One Diagram

Twenty years, four founders, one OT engine, and a cap-table receipt. Let's walk it.

📝 What Is Etherpad?

Etherpad is an open-source real-time collaborative text editor. You open a URL, share the link, and anyone with the link can edit the document at the same time — every keystroke appearing on every screen in roughly the time light travels through the cable.

Today the project lives at github.com/ether/etherpad-lite. Key facts:

Etherpad's contribution to computing history is not size or commercial success — it's the first time the open web saw character-by-character real-time editing actually work.

🎓 2005–2007: The MIT → Google → AppJet Path

Aaron Iba graduated from MIT in 2005 with a Bachelor of Science in Mathematics. After graduation he joined Google's Search Quality team in Mountain View, working on the ranking algorithms that decide which results show up when you search. Search Quality was — and still is — a magnet for people who like solving hard signals problems at large scale.

J.D. Zamfirescu followed a similar path: MIT, then Google Search Quality. David Greenspan had been at MIT around the same window.

In 2006, the three of them watched Google Docs ship its collaborative editing — and noticed something. The Google Docs collaborative engine of 2006-2007 was slow. Edits took around fifteen seconds to propagate between collaborators. For two people writing a document together that was usable; for ten people trying to brainstorm on the same outline it was painful.

The Iba/Greenspan/Zamfirescu insight was simple: what if it was instant?

In 2007 they left Google and founded AppJet in Cambridge, Massachusetts. The pitch was an alternative to Google App Engine — server-side JavaScript hosting for developers, with a built-in editor for writing JavaScript apps in the browser. AppJet would never quite achieve traction on its own — but as a side project, the founders built a multiplayer collaborative pad using AppJet's runtime to demonstrate the platform.

The pad ate the parent company.

🚀 November 19, 2008: Etherpad Goes Live

Etherpad launched publicly on November 19, 2008. The initial demo was simple: open etherpad.com, create a pad, share the URL, and any number of people could type into the document at the same time. Each user got a colored cursor and their text appeared in their assigned color so everyone could tell who wrote what.

     etherpad.com/abc-2008-launch
     ┌──────────────────────────────────────────┐
     │ ▍ alice   ▍ bob    ▍ carol               │
     │                                          │
     │ Welcome to Etherpad. ▍                   │
     │ Try typing here at the                   │
     │ same time as the other ▍ users.          │
     │                                          │
     │ Every keystroke arrives ▍                │
     │ as fast as the network                   │
     │ can carry it.                            │
     └──────────────────────────────────────────┘
        Three colored cursors. One document.

Three things made Etherpad land:

1. The latency was right

Google Docs collaborative editing in 2008 had a noticeable lag — Etherpad felt instant. The pad's central server linearized every changeset and broadcast it to all clients via long-poll HTTP (WebSockets didn't exist yet); the round-trip was tens of milliseconds. Typing into a shared Etherpad felt like typing into your local editor while someone read over your shoulder.

2. The URL was the share button

You created a pad, copied the URL, sent it. No accounts. No invitations. No permission dialogs. Anyone who clicked the link was in. That permissionless model fit the open web of the late 2000s perfectly and made viral propagation trivial.

3. The "Time Slider"

Etherpad shipped one feature Google Docs wouldn't ship for years: a time slider that let you scrub through the document's edit history. You could replay how a meeting transcript was written, character by character, in whatever order it happened. It was an extraordinary debugging tool for collaborative work and the most-screenshotted feature of the product.

Within months Etherpad had:

• Wikipedia editors drafting articles in pads before pasting them in
• NPR newsrooms doing live coverage and editorial briefings
• Mozilla engineers running team standup notes
• University study groups working through problem sets
• Conference organizers running collaborative agendas

The product had hit nerve-endings.

⚙️ How Etherpad Actually Worked — The Easysync Engine

Etherpad's OT engine — called Easysync internally (and sometimes the Changeset library) — is one of the canonical references in the collaborative-editing literature. The Easysync Technical Manual in the Etherpad docs is still recommended reading for anyone implementing a text OT engine.

The model:

A pad is a string with attributes.
A changeset is a delta: (old_length → new_length, ops, char_bank).
Three operators:
=N              retain N characters (no change)
-N              delete N characters
+N              insert N characters (drawn from char_bank)

Each op carries an attribute spec.
Attributes are interned in an attribute pool keyed by short IDs.


A typical Etherpad changeset for inserting "H" at index 1 with author "alice" into the document "cat" would look something like:

Z:3>1|0=1*0+1$H

Decoded:

• Z:3>1 — changeset header: source length 3, increases by 1
• |0 — no line-attribute changes
• =1 — retain 1 character
• *0 — apply attribute pool entry 0 (which references author:alice)
• +1 — insert 1 character
• $H — the character bank: the letter H

When two clients submit concurrent changesets, the Etherpad server:

1. Linearizes the order (whichever it received first wins the local order)
2. Follows (transforms) the later changeset against the earlier one so indices stay correct
3. Composes both into the canonical document state
4. Broadcasts both transformed changesets to all participants

This is OT — central-server, TP1-compliant, rich-text-via-attribute-pool. The full transformation rules for compose, follow, and unpack are spelled out in the canonical Easysync paper that ships with the Etherpad source code. It's the kind of document that takes a careful reader an afternoon to internalize and a lifetime to forget.

Joseph Gentle would later extract these primitives into open source as ShareJS and the ot-json0 type. Today's ot-json0 traces its operational genetics through ShareJS, through the Wave OT engine, through Easysync, into Taskade Projects.

📰 The Press Wave (2008–2009)

The 2008-2009 press cycle for Etherpad reads like a primer on how a developer-tools cult builds a category.

TechCrunch, December 2008 — "Etherpad: Real-Time Collaborative Editing That Doesn't Suck." The post called out the contrast with Google Docs' lag and predicted Google would either buy or copy.

LWN, early 2009 — extended write-ups on the Easysync engine and the implications for open-source documentation infrastructure.

TidBITS, Hacker News, Slashdot — community-driven amplification. Etherpad threads regularly hit Hacker News' front page through 2009.

Wikipedia community, mid-2009 — the Wikipedia Foundation began running a self-hosted Etherpad instance (still live today at etherpad.wikimedia.org) for collaborative article drafting. Wikipedia's adoption was the most consequential — it told the open-source world that Etherpad was production-grade.

By summer 2009, the pad service handled tens of thousands of pads per day. AppJet's other products (the original developer-tools play) were essentially abandoned. The pad was the company.

💼 December 4, 2009: The Google Acquisition

On December 4, 2009, TechCrunch broke the news: Google was acquiring AppJet. The deal was reported in the "low eight figures" — by all accounts under $20 million. Other coverage at GigaOM and the Wall Street Journal confirmed the rumor within hours.

What Google wanted:

• The Etherpad team — specifically Iba, Greenspan, and Zamfirescu — for the Google Wave project, which was struggling to scale its OT engine for public launch
• The Easysync rich-text-OT know-how that Etherpad had productionized
• The user community, which Google initially planned to migrate to Wave

What Google did not want:

• The Etherpad codebase as a Google product. The plan was to shut Etherpad down within weeks.

The community erupted.

📢 The Backlash and the Apache License

The Etherpad shutdown announcement triggered one of the largest open-source community responses of 2009. Hacker News threads, Wikipedia editorial discussion, Mozilla developer letters, university newsroom petitions — the consensus was that Google was killing a beloved product to acquire-hire a team, and that the loss to the open web would be significant.

To Google's credit, they reversed course quickly. On December 17, 2009 — thirteen days after the acquisition announcement — Google open-sourced the entire Etherpad codebase under the Apache 2.0 license and committed to running the hosted etherpad.com service through March 2010 to give the community time to spin up self-hosted instances.

The Apache 2.0 release was the inflection point that made Etherpad's lineage durable. Without it, Etherpad would be a Wikipedia footnote. With it, Etherpad became:

• A self-hostable real-time editor used at universities, NGOs, and EU institutions across the next decade
• The reference open-source OT engine cited in dozens of subsequent academic and engineering papers
• The codebase that the Etherpad Lite rewrite would later build on

🔄 2011–2014: Peter Martischka and the Etherpad Lite Rewrite

By 2011 the original Etherpad codebase was showing its age. Built in a mix of Java, Scala, and JavaScript with a custom build system, it was difficult for community contributors to extend.

Peter Martischka, a German developer, began a Node.js rewrite called Etherpad Lite in 2011. The "Lite" suffix was meant to distinguish it from the legacy code — but the design goals were ambitious:

1. Single-language stack — Node.js end to end
2. Plugin architecture — third parties should be able to extend Etherpad without forking
3. Simpler deployment — npm install and you're running
4. Modern UI — HTML5 instead of the original Etherpad's heavier client

Etherpad Lite's progress was steady. By 2012-2013 it had feature parity with the legacy codebase. By 2014 it had overtaken it, the "Lite" suffix was dropped, and Etherpad Lite became simply Etherpad — the canonical implementation under the new Etherpad Foundation stewardship.

Today the project lives at github.com/ether/etherpad-lite with roughly 18,300 GitHub stars and 290+ community plugins. The plugin ecosystem includes spell-checking, version-control integration, image embedding, math rendering, custom authentication providers, and dozens of UI variants — most contributed without coordination by self-hosting administrators who needed specific features.

🌐 Who Runs Etherpad in 2026

Etherpad has a quiet but enormous self-hosted footprint. A non-exhaustive list of production deployments:

Etherpad doesn't have a single mega-customer story like Google Docs. It has thousands of medium-sized deployments quietly doing the work, owned by the institutions running them, in a way that Google Docs structurally cannot offer.

🧬 The Diaspora: Where the Etherpad / Wave Team Went

After Google Wave was killed in August 2010, the engineers spread out:

Aaron Iba's path

• 2011: One of six full-time Y Combinator partners. Helped early-stage startups through the YC program for two years.
• 2013: Left YC to found PayGarden, an alternative-payments startup focused on prepaid-card-to-merchant conversion.
• Later: Co-founder of Matrix Operations, a high-frequency trading infrastructure company with offices in New York and London. Designed real-time trading systems — the same low-latency coordination problems Etherpad solved for text, applied to finance.
• Today: Active angel investor in early-stage workspace and real-time collaboration startups. Listed as an angel investor in Taskade in the company's Genesis launch pitch deck (slides 04 and 12, "Authority chain" and "Featured angel"). The real-time-collaboration thread runs through eighteen years of his career.

David Greenspan's path

Founded Meteor, the full-stack JavaScript framework, in 2011. Meteor's real-time-data-sync architecture inherits intellectually from the Etherpad/Wave model — the framework's meteor.subscribe pattern is conceptually a thin OT replication layer over MongoDB.

Joseph Gentle's path

Independent. Extracted Wave's OT primitives as ShareJS (2011) → ShareDB → ot-json0. Later built Diamond Types (a state-of-the-art text CRDT, 2023). Gentle's blog posts — "Implementing OT sucks" (2011), "I was wrong. CRDTs are the future" (2020), "CRDTs go brrr" (2021) — are the most-cited practitioner writing in the field.

🧷 The Lineage Receipt — Etherpad → Wave → ot-json0 → Taskade

Most "lineage" claims in tech writing are metaphors. This one isn't.

Three primary-source receipts connect Etherpad to Taskade:

Receipt 1 — The Code

Taskade's Project editor — the substrate of every list, board, calendar, table, mind map, Gantt chart, and org chart you can build — is built on ot-json0, the open-source JSON OT type extracted by ex-Google-Wave engineer Joseph Gentle. The Wave OT engine that Gentle extracted absorbed Etherpad's Easysync know-how when AppJet was acquired in December 2009.

The Taskade entry point literally is:

// Taskade Projects · OT type registration (shape only)
import { type as json0 } from 'ot-json0';
import DeltaSubtype from './subtypes/Delta';   // Quill rich-text subtype
import Text0Subtype from './subtypes/Text0';   // plain-text subtype
json0.registerSubtype(DeltaSubtype);
json0.registerSubtype(Text0Subtype);
export default json0;

The public ot-json0 library — github.com/ottypes/json0, extracted from Wave by Joseph Gentle and descended from Easysync conceptually — is imported directly. Taskade's Project editor registers Delta (Quill rich text) and Text0 (plain text) subtypes on top, then layers a custom changeset compose / transform / invert engine to drive every list, board, calendar, table, mind map, Gantt chart, and org chart view from one OT-driven document.

Receipt 2 — The Organization

December 4, 2009: Google acquires AppJet. The Etherpad founders join the Google Wave team. The Wave OT engine — already in development under Lars and Jens Rasmussen — absorbs the Easysync experience. The combined know-how becomes the OT primitives Gentle later extracts.

Receipt 3 — The Cap Table

Aaron Iba is an angel investor in Taskade. Listed in the Genesis launch pitch deck (slides 04 and 12). The same person who co-founded Etherpad in 2008 and joined Google Wave in 2009 has now backed the workspace-software company shipping the same architectural conviction across two more decades.

Three receipts. Engineering, organizational, and capital. Not a metaphor.

🤖 The Next Chapter: AI Agents on the Etherpad Lineage

What Etherpad did in 2008 was put colored cursors on the same document. What Taskade Genesis ships in 2026 is the next class of cursor: AI agents.

Where Etherpad showed:

• ▍ alice ▍ bob ▍ carol

Taskade shows:

• ▍ alice ▍ EVE (meta-agent) ▍ Sales Agent ▍ Onboarding Agent ▍ bob

Same substrate. Same OT engine (via ot-json0). New class of participant.

Workspace DNA: Memory + Intelligence + Execution

Taskade frames the runtime loop as Workspace DNA:

• Memory — Projects, the OT-edited substrate. Every edit (human or agent) is captured in causal order.
• Intelligence — AI Agents v2 with 22+ built-in tools (web search, file editing, image generation, slash commands, web fetch, project read/write, agent-to-agent, MCP tool calling), persistent memory accumulating expertise across sessions, custom tools via the Model Context Protocol
• Execution — Automations across 100+ bidirectional integrations (Slack, Stripe, Notion, GitHub, Shopify, Salesforce, Calendar, Linear, Monday, Airtable, Telegram, RSS, Webhooks). Triggers pull external events in; actions push data out.

EVE — Taskade's meta-agent — reads the entire workspace DNA and orchestrates work across all three loops. EVE writes through the same OT engine humans and agents use; her edits interleave with everyone else's in causal order.

Genesis Apps: One Prompt → One App in Seven Minutes

The Etherpad demo of 2008 was "watch this document being edited live." The Taskade Genesis demo of 2026 is "watch this app being built live."

150,000+ Genesis apps built since launch. 3M+ automations executed. MIT Technology Review recognized vibe coding as a "breakthrough technology of 2026."

Vibe Coding & Living Software

The Etherpad pattern that Genesis carries forward:

• Vibe Coding — describe apps in plain language → instant builds
• Vibe Payments — Stripe-powered flows triggering automations
• Vibe Workflows — forms and requests creating automated processes
• Vibe Marketing — content aggregation and cross-platform publishing
• Vibe Tracking — leads and data synced across tools via webhooks
• MCP both sides — Taskade-as-Server (Claude Desktop / Cursor / VS Code drive your workspace) and Taskade-as-Client (your agents call external Notion / Linear / Salesforce MCP servers)

Eighteen years after Etherpad opened the first pad in November 2008, the same architectural conviction — real-time, OT-based, server-mediated, rich-text-first — runs through one of the most interesting workspace platforms on the market, with the original founder on the cap table.

📊 Etherpad vs the 2026 Real-Time Workspace Stack

Etherpad's 2008 design choices set the bar for every collaborative editor that followed. Here's how the lineage's three best-known descendants stack up — and where the only one that ships the full Workspace DNA loop lands:

Etherpad's permissionless URL-as-share-button design is still the right call. Google Docs scaled the OT engine to consumer mass. Notion built the workspace database. Only Taskade Genesis carries Etherpad's open-source OT lineage forward and adds AI agents, automations, and a cloneable Genesis App surface on the same substrate.

📚 What We Can Learn from Etherpad

For builders today:

1. The substrate outlives the product

Etherpad's hosted service ran from November 2008 to March 2010. Sixteen months. The substrate — Easysync, the OT engine, the open-source code, the lineage to ShareJS and ot-json0 — has been running for eighteen years and counting. Products fade. Substrates compound.

2. Open-source under fire is the highest-leverage decision you can make

If Google had shut Etherpad down quietly in December 2009 without open-sourcing, there would be no Etherpad Lite, no Etherpad Foundation, no Wikipedia / Mozilla / EU deployments, no eighteen-year lineage. The Apache 2.0 license decision — made under community pressure within thirteen days of acquisition — is one of the highest-leverage decisions in the history of collaborative software.

3. URL is the share button

Etherpad's permissionless URL-as-share-button design is still the right call in 2026 for collaborative tools. Most failed real-time-collaboration products of the last fifteen years lost at the "how do I invite Bob" step.

4. Latency is the product

Google Docs' 15-second sync lag in 2008 was a design choice (batch-and-merge), not a technical constraint. Etherpad's near-instant sync was also a design choice. Users feel latency in their fingertips; they don't read engineering blog posts about why your sync is slow. Make it instant.

5. People are the lineage

The "Etherpad lineage" is not a metaphor — it's a set of named engineers (Iba, Greenspan, Zamfirescu, Gentle, Martischka) who carried the same architectural conviction across multiple companies over twenty years. Tech history is biography. Track the people, not just the products.

🔗 Further Reading

• History of Real-Time Collaboration: From Engelbart to AI Agents — the pillar piece on the full lineage
• Google Wave Lessons: OT Internals + Aaron Iba Lineage — the product that absorbed Etherpad
• OT vs CRDT: The Two Algorithms Behind Every Real-Time App — engineering deep-dive
• History of ServiceNow — enterprise workflow lineage sister piece
• History of Markdown — the text-format lineage Etherpad influenced
• What Is Taskade? Complete History — the AI workspace built on the Etherpad/Wave OT lineage
• Etherpad project on GitHub — 18.3K stars, 290+ plugins, active community
• Easysync Technical Manual — the canonical OT-engine documentation

❓ Frequently Asked Questions