Unified touch, pointer, and mouse interaction abstraction for the early multi-input web

Deep Tissue is a JavaScript library created in 2012–2013 to normalize user interaction across mouse, touch, and early pointer APIs during a period of significant platform fragmentation on the web.

At the time, developers were forced to write separate code paths for:

• Mouse events (desktop browsers)
• Touch events (iOS and select Android browsers)
• Emerging Pointer and MSGesture APIs (Internet Explorer / Windows 8 hybrid devices)

Deep Tissue abstracted these differences into a single, gesture-oriented interaction layer focused on user intent rather than raw input mechanics.

⚠️ Project status: This library is now obsolete due to the standardization and widespread adoption of Pointer Events. It remains published as a historical and architectural reference.

In the early 2010s, the web was in the middle of a major transition:

• Touch-first devices were rapidly gaining adoption
• Hybrid devices (mouse + touch + pen) were emerging
• Browser vendors exposed incompatible event models with differing semantics

Common interactions such as tap, swipe, rotate, scale, and press-and-hold required device- and browser-specific implementations, often duplicated throughout applications.

Deep Tissue was created to:

• Normalize interaction semantics across input types
• Abstract away browser-specific event models
• Support hybrid hardware gracefully
• Allow developers to program against gestures, not devices

Rather than exposing low-level event listeners, Deep Tissue provided a higher-level API:

deeptissue(element)
  .tap(onTap)
  .swipeLeft(onSwipeLeft)
  .scale(onScale)
  .rotate(onRotate);

This allowed application code to express intent directly, reducing complexity and improving readability.

Attribute-Driven Interaction Model

Interactions were enabled declaratively using HTML attributes:

<div data-swipeleft data-move-horizontal></div>    

• Kept JavaScript loosely coupled to markup
• Supported progressive enhancement
• Avoided framework lock-in
• Anticipated later trends in component-driven and declarative UI design

Deep Tissue explicitly supported:

• MSPointer* events
• MSGesture
• MSCSSMatrix

This enabled proper handling of mouse, touch, and pen input on early Windows hybrid devices — a scenario most web libraries ignored at the time.

• Unified mouse, touch, and pointer input under a single abstraction
• Normalized gesture behavior across browsers
• Supported multi-input and hybrid hardware
• Enabled declarative interaction design
• Reduced application-level complexity during platform instability
• Provided a clean, expressive API for interaction design

This was platform-gap code — built to solve a real problem during a specific window of technological change.

As browser vendors converged on the Pointer Events specification, the need for custom abstraction layers like Deep Tissue disappeared.

Modern browsers now provide:

A unified input model

Consistent gesture handling primitives

Better performance and native optimizations

Deep Tissue is no longer appropriate for production use, and it is not maintained.

Why This Project Still Matters

While obsolete as a library, Deep Tissue remains relevant as an example of:

Designing abstractions under uncertainty

Anticipating platform convergence

Balancing pragmatism with forward-looking architecture

Building solutions meant to be temporary, but robust

Knowing when to build an abstraction — and when to let it go — is a critical senior engineering skill.

A modern implementation would likely:

Rely directly on Pointer Events

Use passive event listeners where appropriate

Be packaged as ES modules

Avoid DOM attribute state in favor of component state

Integrate with modern frameworks only as adapters, not dependencies

The core idea — designing around user intent rather than device mechanics — remains valid.

Deep Tissue was created by Chris Love, a senior software engineer and architect with extensive experience building production systems, internal tools, developer platforms, and UI frameworks across multiple generations of the web.

This library was originally implemented during cross-country travel and refined through real-world experimentation and browser vendor collaboration.

License

MIT License — see source headers for details.

Deep Tissue represents a moment in the web’s evolution — and the kind of engineering judgment required to navigate it.

If you’d like, next we can:

• Tighten this further for GitHub SEO / discoverability
• Add a short architectural diagram section
• Write a “Code Archaeology” note explaining design choices line-by-line
• Or adapt this into portfolio-site copy rather than a README

Just tell me the next move.