An offset grid of items that cascade diagonally is easy to fake with transforms, but only if you account for two things: how transform percentages resolve, and the fact that moving pixels doesn't move the layout. Here's the full build.

Why flexbox column-wrap isn't the answer

The obvious first attempt is a flex container with flex-direction: column and flex-wrap: wrap, letting items run down one column and spill into the next. Flexbox does work in either orientation, but this route breaks in two ways. It needs a fixed container height (say 500px) before any wrapping happens, and the tab order runs down the first column (1, 2, 3) and then continues in the second (4, 5, 6) — not the left-right cascade you're after.

A grid version also hard-codes a value, as will become clear, but it sidesteps the tab order problem entirely.

Building the staggered grid

The plan is three steps: lay out a plain two-column grid, select the items in the second column (the even ones), and push them down by half their own height.

Start with a wrapper and five items:

<div class="wrapper">
  <div class="item"></div>
  <div class="item"></div>
  <div class="item"></div>
  <div class="item"></div>
  <div class="item"></div>
</div>
*,
*::before,
*::after {
  box-sizing: border-box;
}

.wrapper {
  display: grid;
  grid-template-columns: 1fr 1fr;
  gap: 16px;
  max-width: 800px;
  margin: 0 auto;
}

.item {
  height: 100px;
  border: 2px solid;
}

box-sizing: border-box is applied globally because otherwise the 100px items are actually taller than 100px once the border is added — and that discrepancy matters shortly.

The shift, and the selector to use

Select every even item and translate it down:

.item:nth-child(even of .item) {
  transform: translateY(50%);
}

For the selector, .item:nth-of-type(even) happens to work in this demo because all the children share one tag name. But nth-of-type matches on tag, not class, so mixed element types inside the wrapper would match unpredictably. :nth-child(even of .item) filters by class explicitly, is supported in modern browsers, and is the safer choice.

The stagger appears right away, and the result is nearly correct — but not quite.

Transform percentages point at the element

Everywhere else in CSS, a percentage measures the parent's available space; that's how a width: 50% element inside a wrapper behaves. Inside a transform, the percentage resolves against the element itself. So translateY(50%) means "half of my own height" — a 200px item moves 100px, and the container's height is irrelevant.

This matches the individual translate(), scale() and rotate() properties, all of which operate in the element's own coordinate space after layout is finished, which is why scale(2) expands from the element's center rather than the page's top-left corner. The zigzag relies on that rule: each even item shifts relative to its own size, so the stagger stays proportional whatever the item height.

Correcting for the row gap

Push gap to 100px and the flaw is visible: the even items stop short of where they belong, because the vertical space between rows isn't reflected in the translation. Store the gap in a custom property so it can be reused, then add half of it to the shift — the full value would overshoot.

.wrapper {
  --gap: 16px;

  display: grid;
  grid-template-columns: 1fr 1fr;
  gap: var(--gap);
  max-width: 800px;
  margin: 0 auto;
}

.item:nth-child(even of .item) {
  transform: translateY(calc(50% + var(--gap) / 2));
}

Divide the gap by 2 because only half the distance between rows needs covering. With 16px the layout looks right; with 100px it still does — the arithmetic doesn't depend on the number.

The overflow problem

Add a border to the wrapper to inspect its bounds:

.wrapper {
  border: 2px solid red;
}

With five items nothing spills. Add a sixth:

<div class="wrapper">
  <div class="item"></div>
  <div class="item"></div>
  <div class="item"></div>
  <div class="item"></div>
  <div class="item"></div>
  <div class="item"></div>
</div>

That item is even, gets translated, and escapes the container. The layout engine never saw the move: the item is still in its original position as far as layout is concerned, the wrapper sizes itself to that phantom position, and the transform only shifts painted pixels.

Reserving room for the translated items

The fix is to pad the bottom of the wrapper by the same amount the items travel: half the item height plus half the gap. Padding percentages resolve against the parent's width, not the child's height, so the 50% trick can't be reused. Instead, store the item height in a variable:

.wrapper {
  --gap: 16px;
  --item-height: 100px;
  
  display: grid;
  grid-template-columns: 1fr 1fr;
  gap: var(--gap);
  margin: 0 auto;
  max-width: 800px;
  padding-bottom: calc(var(--item-height) / 2 + var(--gap) / 2);
}

.item {
  border: 2px solid;
  height: var(--item-height);
}

This is admittedly a hard-coded dimension, the same kind of trade-off flagged for the flexbox approach — though here you lock down item height rather than container height, leaving column structure, gap math and source order flexible.

Accessibility and source order

Source order is preserved, which pays off in three places.

  • Screen readers read DOM order, and transforms are visual only. Assistive tech announces 1 through 6 with no surprises — unlike column-wrap, which can produce a reading order that diverges from the visual one.
  • Tab focus follows the source order as well. In this zigzag the visual flow (left to right, top to bottom) is the same, so the two align naturally; a more complex layout where they diverge calls for deliberate focus management.
  • For motion, the zigzag is static. Should you animate items into their staggered positions on load, gate it behind prefers-reduced-motion:
/* animates when user has no motion preference */
@media (prefers-reduced-motion: no-preference) {
  .item {
    animation: slide-in 0.3s ease-out both;
  }
}

Here the animation is served only to users with no motion preference — frequently the inverse is written — and the layout itself is unaffected either way.

Three pieces, one pattern

  1. A two-column grid establishes the structure.
  2. translateY(50%) produces the stagger, which works only because transform percentages resolve against the element.
  3. padding-bottom reserves the space the transform doesn't claim in layout.

Change the gap or the item height, add more items, and the pattern holds.