react-zeugma logoreact-zeugmav8.0.0
OverviewLive DemoInteractiveChangelog
v8.0.0 • React 18 & 19 Ready•Release Notes

Spatial layouts for demanding dashboards.

Headless, recursive, drag-and-drop workspace layout engine for React. A modern successor to react-mosaic and golden-layout. Build bento cockpits, multi-tab IDEs, and custom split views without grid constraints.

Try Interactive DemoSKILL.md Spec
~4.8 kB
Bundle footprint
0 reflows
Isolated metadata
100%
Headless & typed
Binary Tree
Split architecture
Live Showcase

Observability Cockpit in Action

Test Zeugma right here. Drag tabs to rearrange, grab resizer handles between panels, or configure split limits using the top toolbar.

Open Dedicated Demo Screen
react-zeugma • workspace-v7.json
Active
Loading live layout engine...
Engine Primitives

Built for Desktop-Grade Web Interfaces

Every detail is engineered for performance, strict typing, and developer autonomy.

Core Engine

Arbitrary Recursive Splits

Split horizontally or vertically without predefined column constraints. Create nested bento workspaces, side-by-side diff viewers, and complex cockpit monitors.

Binary TreeInfinite depth
Flexibility

Multi-Tab Pane Docking

Combine multiple widget panels into a single tabbed container. Drag tabs between panes, detach them into independent views, or reorder tabs on the fly.

Tab StacksDrag & Dock
High Performance

Decoupled Metadata Store

Powered by useSyncExternalStore. Update tab badges, notification counts, and panel titles without triggering layout re-renders or resizer recalculations.

React 18 & 190 re-renders
UX Delight

Drag-to-Dismiss Physics

Drag a panel or tab beyond the dashboard perimeter to dismiss or close it, complete with scale feedback and velocity-aware animations.

Spatial DnDFluid touch & mouse
Persistence

Pure JSON Serialization

The entire topology serializes into a clean, human-readable JSON tree. Save to localStorage, sync across team URLs, or restore user workspaces in milliseconds.

State & URL100% Serializable
Zero Bloat

100% Headless Architecture

Zero bundled CSS runtime. Zeugma calculates coordinates, split math, and drop targets while giving you total freedom over your DOM, Tailwind, and theme tokens.

Unopinionated~4.8 kB gzipped
Layout Engine Comparison & Alternatives

The Modern Successor to Legacy Layout Engines

Searching for a modern alternative to react-mosaic, react-grid-layout, or golden-layout? Here is how react-zeugma redefines spatial workspace engineering for React 18 & 19.

react-mosaic Alternative

Pioneering Tree Splits, Reborn

react-mosaic proved that binary tree partitioning is superior to flat grids. react-zeugma takes that proven mathematical model and strips away legacy CSS wrappers, adds native multi-tab docking, and brings full React 18 & 19 concurrent reactivity.

Zero Blueprint CSS100% Headless
react-grid-layout Alternative

Arbitrary Splits vs. Rigid 12-Columns

Flat 12-column grids break down when users need recursive side-by-side viewports, diff inspectors, or nested bento layouts. With Zeugma, splitting a pane is local to its parent divider — with zero cascading reflows across distant siblings.

No coordinate collisionsLocal splits
golden-layout Alternative

Native React vs. jQuery/DOM Roots

golden-layout and early window managers rely on imperative DOM manipulation that fights against React state synchronization. react-zeugma is built from the ground up as a pure React library weighing just ~4.8 kB gzipped.

~4.8 kB vs. ~60+ kBNative State

Detailed Feature Matrix: React Layout Engines

Comparing architecture, developer experience, and runtime constraints.

Architectural Deep-Dive
Capabilityreact-zeugmareact-mosaicreact-grid-layoutgolden-layout
Layout Topology
Recursive Binary Tree (Arbitrary split depth)
Binary Tree (Arbitrary split depth)Flat 12-Column Grid (Row/col locked)Multi-root Tree (Stack/row/col)
Headless / Styling
100% Headless & Style-Agnostic
Opinionated CSS / Blueprint themeInline transforms / CSS stylesHeavy bundled CSS/LESS themes
React 18 & 19 Support
Full Concurrent Mode & useSyncExternalStore
Legacy lifecycle hooks (React 16-17 era)React 18 compatibleImperative DOM wrapper layer
Multi-Tab Pane Docking
Native multi-tab stacks & tab drag-transfer
Single widget per node (No tab stacks)No native tabs (Requires manual nesting)Built-in tab headers
Native Multi-Window Popouts
Native popout window with synced state & CSS
No native popout supportNo native popout supportPopout window support (complex bridge)
Re-render Isolation
0 layout reflows (Decoupled widget metadata)
Parent re-renders on node state changeCascading recalculation on sibling changeDOM mutations bypass React tree
Bundle Footprint
~4.8 kB gzipped (Zero CSS bloat)
~30 kB (Excluding Blueprint CSS)~45 kB~60+ kB (Excluding theme assets)
Ready to replace your existing layout engine with a modern headless solution?
SpecificationTest in Demo
Declarative Simplicity

Clean API. Pure React Primitives.

Create recursive split views by passing your layout tree and render functions. No complex configuration files or CSS overrides.

  • ✓useZeugma() hook: Layout state, split controllers, and active tab management.
  • ✓<Pane> & <Pane.Content>: Pure headless layout containers.
  • ✓<Pane.Tabs>: Fully customizable tab bars with dock and detach capabilities.
Explore SKILL.md Specification
WorkspaceLayout.tsxTypeScript
import { useZeugma, Zeugma, Pane } from 'react-zeugma'

export function Workspace() {
  const controller = useZeugma({
    initialLayout: {
      type: 'split', direction: 'row', splitPercentage: 50,
      first: { type: 'pane', id: 'editor', tabIds: ['App.tsx'] },
      second: { type: 'pane', id: 'terminal', tabIds: ['Terminal'] },
    },
  })

  return (
    <Zeugma controller={controller} renderPane={(paneId) => (
      <Pane id={paneId}>
        <Pane.DragHandle />
        <Pane.Tabs />
        <Pane.Content>{/* your view */}</Pane.Content>
      </Pane>
    } />
  )
}
Knowledge Base & Search FAQ

Frequently Asked Questions

Everything you need to know about choosing react-zeugma over traditional coordinate grids and legacy tiling managers.

react-mosaic pioneered recursive binary-tree tiling in React, but it relies on older React lifecycle patterns and bundles opinionated Blueprint CSS styling. react-zeugma modernizes this architecture: it is 100% headless (zero bundled CSS runtime), fully compatible with React 18 & 19 concurrent features, uses useSyncExternalStore for zero-reflow isolated metadata updates, and provides built-in multi-tab pane docking and native multi-window popouts.
“From ancient tesserae to recursive digital workspaces.”

Zeugma was an ancient Greco-Roman bridge city on the Euphrates known for its breathtaking mosaics — individual stone tiles fitting together to form an unbreakable whole. We built react-zeugma on that same principle: independent pane tiles harmonizing in a fluid, unified layout.

Start Building
react-zeugma logoreact-zeugmav8.0.0

Headless, recursive, drag-and-drop workspace layout engine for React. Built for complex bento grids, observability cockpits, and multi-tab code editors.

React 18 & 19 Ready • Fully Typed

Product

  • Overview
  • Interactive Demo
  • Release Notes

AI & Standards

  • SKILL.md Spec
  • llms.txt Index

References

  • GitHub Repository
  • NPM Package
  • MIT License

Community

  • Contributing
  • Issues & RFCs
© 2026 react-zeugma • Open source software under MIT.
Named after the mosaic city of Zeugma inGaziantep, Turkey