Piston physics and flying machine design principles

Piston Fundamentals

Pistons and sticky pistons share the same push mechanics but differ in their retraction behavior. Understanding the underlying block-event model is a prerequisite for reliable machine design.

Push vs. Pull

A normal piston extends to push up to 12 blocks in a line. It cannot retract any block. A sticky piston retracts one block — the block immediately adjacent to its face on the tick the piston retracts. If a second sticky piston pulls that same block simultaneously, the result is version-dependent.

The 12-Block Push Limit

A piston can push a chain of at most 12 movable blocks. The moment a 13th movable block is in the line — or any immovable block is encountered — the piston fails silently and does not extend at all. This constraint governs flying machine payload capacity.

Block Update Sequence

When a piston extends or retracts, it schedules block updates in a specific order. In Java Edition, this order is deterministic and exploitable. The piston head occupies a block position before the arm block is removed, meaning circuits can react to the head's presence before the full animation completes. This is the basis of 0-tick and quasi-connectivity exploits (most are patched in modern versions).

Piston Timing

Each piston extend or retract cycle takes exactly 2 redstone ticks (4 game ticks / ~0.1 s at 20 TPS). Regardless of chain length, the physical animation takes 1 tick to start and completes at the end of the 2nd tick. Circuits that pulse pistons faster than this will drop pulses.

-- Piston timing summary (Java Edition) --

Extend delay:   2 RT  (4 GT)   from power-on to head fully out
Retract delay:  2 RT  (4 GT)   from power-off to head fully in
Minimum ON-pulse to extend:    1 RT (2 GT)
Minimum OFF-pulse to retract:  1 RT (2 GT)

RT = redstone tick (0.05 s at 20 TPS)
GT = game tick     (0.05 s at 20 TPS, 2 GT = 1 RT)

Slime & Honey Block Mechanics

Slime blocks and honey blocks are the structural glue of flying machines. They share push mechanics but differ in entity interaction and cross-block bonding rules.

Drag Adjacency

When a slime or honey block is pushed or pulled, it attempts to drag every movable block it is directly adjacent to (face, edge, or corner — faces only in Java; faces only in Bedrock too, corners excluded in both). Each dragged block can itself drag its own adjacent blocks, propagating a rigid structure. This propagation still cannot exceed the 12-block total per piston push.

Slime vs. Honey: Key Differences

Block Count Accounting

Every block that moves — including the piston head and the slime blocks themselves — counts toward the 12-block limit. When designing a flying machine, sum every block that will be in motion per piston activation. A common mistake is not counting the observer blocks, pistons, or slime blocks within the engine itself.

Observers

An observer detects block state changes in the block directly in front of its face and emits a 1-tick pulse from its back. In the context of flying machines, observers detect the piston extension and retraction of adjacent pistons in the structure, creating the self-triggering loop.

Detection Events

Block placed or broken

Fires on any block addition or removal in the observed position.

Block state change

Fires when the observed block changes state — e.g., a piston extending (unpowered → powered arm) or retracting. The observer sees the state change at the start of the animation tick.

Fluid level change

Fires when water or lava level in the observed position changes.

Observer Facing Direction

The observer's output (arrow face) must be connected to the piston it is triggering, either directly or through the slime-block structure. The observed face points at the piston or block whose state change you want to detect. Misorienting an observer is the most common assembly error.

-- Observer orientation reference --

  Observed face  →  [OBS]  →  Output face

  Placed by looking NORTH:
    Observed = block to the SOUTH of observer
    Output   = NORTH face

  Placed by looking UP (ceiling placement):
    Observed = block BELOW observer
    Output   = TOP face (upward)

Flying Machine Engine Design

A flying machine requires a minimum of two pistons — one to push the structure forward and one to pull it (prevent the rear from being left behind). The observer loop provides the alternating clock signal to both.

Minimal 2-Piston Engine

The canonical minimal design uses two sticky pistons facing the direction of travel, one observer, and two slime blocks. The observer detects the rear piston retracting and fires the front piston; the front piston's extension is detected by the observer, which then fires the rear piston.

Engine Orientation Variants

Start / Stop Mechanisms

A flying machine has no inherent stop state — once started it runs until it hits an immovable block. Practical machines need a way to interrupt the observer loop on demand.

Sticky piston break: Place an additional sticky piston perpendicular to the engine that, when extended, pulls a slime block out of the observer's line of sight, breaking the chain. Retracting it reconnects the chain and the machine continues.

Block insertion stop: A dispenser or piston outside the machine fires a block into the path. The machine hits the block and halts. This is a one-use or reset-required approach.

Detector rail trigger: Place a powered rail or tripwire on the payload platform wired to a sticky piston that intercepts the observer pulse. When the platform reaches the target position, it triggers the interruptor.

Payload Design

Everything not part of the engine is payload. Payload blocks are dragged by slime blocks and must not push the total count past 12 per piston activation.

Block Budget Calculation

Each side of a two-piston engine (front push and rear pull) has its own 12-block budget. Blocks dragged by the front piston activation are counted separately from blocks dragged by the rear piston activation. In most symmetric designs, both pistons push/pull the same total, so count one side and verify it applies to both.

-- Example block budget (one piston activation) --

Engine components (always present):
  2 × slime blocks         = 2
  1 × observer             = 1
  1 × sticky piston body   = 1
  1 × sticky piston head   = 1   (counts separately in Java)
                          ───
  Engine subtotal          = 5

Available for payload: 12 − 5 = 7 blocks

Each additional slime block you add to increase payload
grip costs 1 block of budget itself.
Each observer added for multi-directional detection = 1 block.

Glazed Terracotta as Structural Member

Glazed terracotta is pushed but not dragged by slime blocks. It counts toward the block limit when pushed but does not propagate drag to its neighbors. Use it as a controlled boundary when you want a slime cluster to push a surface without accidentally dragging unintended adjacent blocks.

Extending Payload with Dual Engines

Two independent engines can be placed side-by-side, each controlling its own 12-block cluster, with honey blocks forming the non-sticky boundary between clusters. Both engines receive the same observer signal (wire the clocks together or use a shared observer). This effectively doubles the movable payload without exceeding per-piston limits.

Bidirectional Machines

A bidirectional flying machine travels in both directions along an axis. The simplest approach is a mirrored engine pair — one engine per direction, both dormant until activated.

Mirror Engine Layout

Direction-Locking

If both engines start simultaneously (e.g., both observers detect each other's pistons), the machine will oscillate in place or deadlock depending on exact timing. Prevent this by ensuring only one engine is active at a time. The simplest lock is a T flip-flop on each engine's power line: one toggle starts A and disables B; the next starts B and disables A.

Turnarounds

A machine can automatically reverse direction by placing a detector (observer, tripwire, or pressure plate on the payload) that fires the opposite engine when the structure reaches the endpoint. Wire the arrival detector to stop the active engine (block insertion or piston intercept) then start the return engine.

Vertical Flying Machines

Vertical machines follow the same engine logic. The primary engineering differences are gravity and entity standing surface.

Ascending Machines

Pistons face upward. The engine is structurally identical to a horizontal design rotated 90°. Gravity does not affect blocks held by slime drag — once extended, blocks stay in place until the next retract cycle pulls them up.

Descending Machines

Pistons face downward. The observer must fire the pistons in the correct sequence — the front (lower) piston pushes down first, the rear (upper) piston retracts and is then pulled down by slime drag. The timing is the same as horizontal; gravity assists downward movement, which can allow smaller engines.

Diagonal Travel

True diagonal travel (e.g., northeast + up simultaneously) is not achievable with a single engine set. Combine two independent engines — one horizontal, one vertical — both started simultaneously. The result appears diagonal but is actually two interleaved linear motions at potentially different speeds, which means the structure must be able to tolerate asynchronous block updates on both axes.

Java vs. Bedrock Compatibility

The core piston and observer physics are conceptually similar across editions, but there are enough implementation differences that a design should be tested on its target edition before deploying at scale.

Debugging Common Failures

Piston extends but nothing moves

Block count exceeds 12, or an immovable block is in the push line. Count all blocks the piston would need to move, including those dragged by slime. Break the chain down and isolate the offending block.

Machine moves one block then stops

Observer pulse not reaching the second piston. Check observer facing — the output face must point toward the piston it should activate, either directly or through the slime structure. Also verify the piston is sticky; a normal piston cannot pull the machine back.

Machine oscillates without traveling

The engine is firing both pistons simultaneously, or the observer is detecting its own output piston. Rebuild with one observer watching the rear piston only; the rear piston's state change should trigger the front, not vice versa directly.

Payload blocks left behind

A payload block is not attached to any slime block's face-adjacency chain. Each block must have a slime face touching it. Add an intermediate slime block or reposition the payload within the drag radius.

Machine destroys itself on stop

The machine ran into an immovable block while still receiving observer pulses. The last piston fires but cannot extend, leaving the structure in a half-extended state. Add a mechanism to cut observer power before the stop block is reached.

Works in creative, not survival

Lag under server load (TPS below 20) desynchronizes piston timing. The machine was designed with zero tolerance for timing variation. Add a 1-RT buffer between observer detection and piston activation using a repeater on the power line.

Quick Reference