# Hyprland Tiling vs Floating vs Pseudotiling vs Fullscreen: Window Mode Differences Explained

> Explore Hyprland's window modes: tiling, floating, pseudotiling, and fullscreen. Understand their unique geometry, rendering, and workspace differences to optimize your workflow.

- Repository: [Hypr Development/Hyprland](https://github.com/hyprwm/Hyprland)
- Tags: deep-dive
- Published: 2026-07-23

---

**Hyprland implements four distinct window states—tiling, floating, pseudotiling, and fullscreen—each managed by separate code paths that control geometry assignment, rendering passes, and workspace integration.**

Hyprland is a dynamic tiling Wayland compositor that supports multiple window management modes. Understanding the differences between **tiling**, **floating**, **pseudotiling**, and **fullscreen** is essential for optimizing your workflow. Each mode follows distinct architectural paths in the source code, affecting how windows are positioned, rendered, and interact with the layout engine.

## Tiling Mode in Hyprland

In **tiling mode**, windows are managed by layout algorithms such as Master, Dwindle, or Scrolling. The compositor assigns each window a tile rectangle using `target->setPositionGlobal(...)`, storing the geometry in `CWindowTarget::m_position`.

### Geometry and Layout Integration

Tiled windows never overlap one another. The window becomes part of the workspace's `CSpace` tiling data, specifically using `CSpace::workArea(false)` to determine available space. Unlike floating windows, all moves and resizes are performed **by the layout algorithm**, not by direct user manipulation.

### Rendering Pipeline

According to the Hyprland source code in [`src/render/Renderer.cpp`](https://github.com/hyprwm/Hyprland/blob/main/src/render/Renderer.cpp) (lines 284-455), tiling windows are rendered in the regular pass. The window's floating offset remains `Vector2D{}`, indicating no additional translation is applied during composition.

## Floating Mode in Hyprland

**Floating mode** removes the window from the tiled data-structure entirely, allowing free movement and resizing independent of the layout algorithm.

### Offset-Based Positioning

Each floating window maintains a per-window `Vector2D m_floatingOffset`. As implemented in [`src/render/Renderer.cpp`](https://github.com/hyprwm/Hyprland/blob/main/src/render/Renderer.cpp), the renderer applies this offset using `windowBox.translate(pWindow->m_floatingOffset)` during the composition phase.

### Separate Render Passes

Floating windows are excluded from the tiled pass and instead processed in a dedicated "floating" pass. They reside in the workspace's floating work-area, accessed via `CSpace::workArea(true)`. This allows floating windows to visually overlay tiled windows while maintaining their independent position state.

## Pseudotiling Mode: The Hybrid State

**Pseudotiling** offers a hybrid approach where the window remains part of the tiled layout but can exceed its allocated tile dimensions.

### Pseudo-Size Calculation

The target stores a pseudo size in `m_pseudoSize`. In [`src/layout/target/WindowTarget.cpp`](https://github.com/hyprwm/Hyprland/blob/main/src/layout/target/WindowTarget.cpp) (lines 198-215), the compositor calculates scaled dimensions using `calcSize = m_pseudoSize * scale`. The pseudo flag itself is tracked via `ITarget::pseudo()` as seen in [`WindowTarget.cpp`](https://github.com/hyprwm/Hyprland/blob/main/WindowTarget.cpp) at line 198.

### Overlap Behavior

While the window continues to be tracked by the tiled algorithm, the oversized geometry creates a *pseudo* area that can overlap neighboring tiles. During rendering, the compositor adds a floating-offset-like delta only when the pseudo size exceeds the allocated tile, giving a "floating look" while preserving tiled z-order and focus behavior.

## Fullscreen Mode Implementation

When a window enters **fullscreen**, it occupies the entire monitor or the monitor's work-area, temporarily hiding all other windows.

### Work-Area Calculation

[`FullscreenHandler.cpp`](https://github.com/hyprwm/Hyprland/blob/main/FullscreenHandler.cpp) (lines 196-253) computes a new work-area using `WORKAREA = WORKSPACE->m_space->workArea(target->floating())` and repositions the window via `LAYOUT_TARGET->setPositionGlobal(...)`. Fullscreen windows are removed from both normal tiling and floating passes and instead rendered in a dedicated fullscreen pass.

### Floating Over Fullscreen

Special rules allow certain floating windows to remain visible above fullscreen content. [`src/managers/input/InputManager.cpp`](https://github.com/hyprwm/Hyprland/blob/main/src/managers/input/InputManager.cpp) (line 510) and [`src/managers/fullscreen/FullscreenController.cpp`](https://github.com/hyprwm/Hyprland/blob/main/src/managers/fullscreen/FullscreenController.cpp) (line 450) enforce these "allowed-over-fullscreen" rules. For example, [`ScrollingFullscreenHandler.cpp`](https://github.com/hyprwm/Hyprland/blob/main/ScrollingFullscreenHandler.cpp) manages scenarios where floating fullscreen windows might sit atop tiled fullscreen windows.

## Configuring Window State Transitions

You can toggle between these states using key bindings defined in your Hyprland configuration. The actions are exposed through [`src/config/shared/actions/ConfigActions.cpp`](https://github.com/hyprwm/Hyprland/blob/main/src/config/shared/actions/ConfigActions.cpp).

Here are the standard bindings to toggle each mode:

```lua

# Toggle tiling – forces the window back into the layout

bind = SUPER, T, toggletiling

# Toggle floating – detach the window from the layout

bind = SUPER, F, togglefloating

# Toggle pseudotiling – enable/disable pseudo-size behaviour

bind = SUPER, P, pseudo

# Toggle fullscreen – make the window cover the whole monitor

bind = SUPER, M, fullscreen

```

The `pseudo` action maps to `CA::pseudoWindow` (see [`src/config/shared/actions/ConfigActions.cpp`](https://github.com/hyprwm/Hyprland/blob/main/src/config/shared/actions/ConfigActions.cpp) line 208). The `fullscreen` command ultimately calls `FullscreenController::toggleWindowFullscreen`, which can also be triggered via the `hyprctl` CLI for scripting purposes.

## Summary

- **Tiling** windows are assigned non-overlapping rectangles by the layout algorithm and rendered in the standard pass with zero floating offset.
- **Floating** windows use `m_floatingOffset` for positioning, render in a separate pass, and can overlay tiled windows.
- **Pseudotiling** keeps windows in the tiled layout while allowing `m_pseudoSize` to exceed tile boundaries, creating managed overlap via scaling logic in [`WindowTarget.cpp`](https://github.com/hyprwm/Hyprland/blob/main/WindowTarget.cpp).
- **Fullscreen** windows bypass normal passes, occupy the full work-area calculated by [`FullscreenHandler.cpp`](https://github.com/hyprwm/Hyprland/blob/main/FullscreenHandler.cpp), and can optionally allow floating overlays based on input manager rules.

## Frequently Asked Questions

### What is the difference between floating and pseudotiling in Hyprland?

Floating windows are completely removed from the tiled layout and manage their own position via `m_floatingOffset`, while pseudotiling windows remain tracked by the layout algorithm but can exceed their tile size using `m_pseudoSize`. Pseudotiling preserves the window's place in the tiling stack order, whereas floating windows exist in a separate layer.

### Can I use floating windows while in fullscreen mode?

Yes, Hyprland supports floating-over-fullscreen behavior. As implemented in [`src/managers/input/InputManager.cpp`](https://github.com/hyprwm/Hyprland/blob/main/src/managers/input/InputManager.cpp) (line 510) and [`src/managers/fullscreen/FullscreenController.cpp`](https://github.com/hyprwm/Hyprland/blob/main/src/managers/fullscreen/FullscreenController.cpp) (line 450), certain floating windows can remain visible above fullscreen content depending on the fullscreen handler configuration and window rules.

### How do I force a window back into the tiling layout?

Use the `toggletiling` action in your configuration. According to [`src/config/shared/actions/ConfigActions.cpp`](https://github.com/hyprwm/Hyprland/blob/main/src/config/shared/actions/ConfigActions.cpp), this action reinserts the window into the workspace's `CSpace` tiling data and clears its floating state, subjecting it once again to the active layout algorithm.

### Why does my pseudotiled window overlap other tiles?

This is by design. When a pseudotiled window's `m_pseudoSize` exceeds its allocated tile dimensions, [`src/layout/target/WindowTarget.cpp`](https://github.com/hyprwm/Hyprland/blob/main/src/layout/target/WindowTarget.cpp) (lines 198-215) calculates a scaled size that intentionally overlaps neighboring tiles. The window remains part of the tiled layout structurally but visually expands beyond its boundaries, creating the characteristic pseudotiling behavior.