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

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 (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, 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 (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 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 (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 (line 510) and src/managers/fullscreen/FullscreenController.cpp (line 450) enforce these "allowed-over-fullscreen" rules. For example, 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.

Here are the standard bindings to toggle each mode:

# 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 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.
• Fullscreen windows bypass normal passes, occupy the full work-area calculated by 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 (line 510) and 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, 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 (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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}