Desk Layouts

Save your window arrangement once. Bring it back with one key.

Desk Layouts is a lightweight window-layout manager for Rebind. Arrange your apps the way you like, save the layout into a slot, and restore it whenever you switch between work, gaming, streaming, or anything else.

It only arranges windows that are already open. It does not launch apps.

Highlights

Four named layout slots: Work, Gaming, Streaming, and Custom by default.
One-key restore: F9 applies the active layout.
One-key capture: F8 saves the current visible windows into the active slot.
Layout menu: F7 opens an overlay menu for applying, saving, and restoring.
Monitor-aware: each window is stored relative to the monitor it was on.
Process and title matching: finds the right windows again even if their position changed.
Up to 8 windows per layout: enough for a normal desktop without turning the layout into clutter.
No app launching: Desk Layouts never starts or closes programs.
Configurable hotkeys and slot names in Rebind's Options panel.
Local only: layouts are stored in a small JSON file beside the script.

Quick Start

Install Desk Layouts from Rebind and start it.
Arrange the windows you want on screen.
Press F7 to open the layout menu.
Choose Save current → Work.
Move things around, then press F9 to restore Work.

To build a second layout:

Open the windows for the second setup.
Press F7.
Choose Save current → Gaming.
Switch between them from the menu or with the active-slot hotkeys.

Controls

Key	Action
F7	Open or close the layout menu.
F8	Save all visible windows into the active slot.
F9	Apply the active slot.
Up / Down	Move through the open menu.
Enter	Select the highlighted item.
1–9	Jump directly to a menu item.
Esc	Close the menu.

The active slot changes whenever you save or apply a layout. All three main hotkeys can be changed in Rebind → Options → Desk Layouts.

The menu is a custom overlay: it uses a dark neutral panel, grouped sections, a highlighted row, and a visible active-slot label. It is keyboard-only and never takes focus from the app underneath.

The menu also has Apply last layout and Help / hotkeys.

What Gets Saved

For each visible window, Desk Layouts stores:

the process name
the window title
the monitor it was on
its position relative to that monitor
its width and height

When you apply a layout, it looks for matching windows by process and title, then moves them back into place. Windows that are closed or cannot be matched are skipped and reported in the result message.

Layout positions are relative to each monitor, so a layout can survive a resolution change or a monitor being rearranged. If a saved monitor is missing, the window falls back to the primary monitor and is clamped on screen.

Limits

Only running windows are arranged. Apps are not launched.
Up to 8 visible windows are saved per layout.
Minimized windows and windows smaller than 80×80 are ignored.
A window whose process and title both changed may not be matched.
Windows that refuse to move, such as some elevated or protected windows, are skipped.
Layouts are manual. There is no automatic switching when a monitor is connected or an app starts.
This is not a tiling window manager and does not snap while you drag.
Windows is the primary target. macOS support depends on Rebind's partial window API.

Settings

Open Rebind → Options → Desk Layouts to change:

menu hotkey
save hotkey
apply hotkey
the four layout names
whether notifications are shown

Changing a keybind reloads the script so the new bind takes effect.

Privacy and Permissions

Desk Layouts does not capture the screen or read pixels.
It does not use the network.
It does not run external programs.
It does not read or write the clipboard.
It only uses Rebind's window list and window movement APIs, plus a local JSON file for saved layouts.
Rebind's overlay engine may ask for overlay-related permissions during installation. Those are used to draw the menu and notifications.

Troubleshooting

A window is not being restored

Make sure the app is still running and has a visible window. If its title changed completely, Desk Layouts may not recognise it.

Nothing moves after F9

The active slot may be empty. Press F7 and check the slot's hint, or save a layout first with F8.

The menu does not open

The hotkey may be taken by another app. Change it in Options, or make sure Rebind overlays are visible. Exclusive-fullscreen games hide Rebind overlays.

A window lands slightly off screen

Desk Layouts clamps positions to the monitor work area, but some apps enforce their own minimum or maximum window sizes.

Requirements

Rebind 3.9.0 or newer
Windows recommended
At least one visible window to save

Desk Layouts v1.0.1 — save and restore your desktop arrangement with Rebind.

Version

main.luau

--[[
  rebind: min_sdk=3.9.0
  rebind: permissions=none
  rebind: tick_rate=10
  rebind: memory_limit_mb=16
]]

local SLOT_COUNT = 4
local MAX_WINDOWS = 8
local STATE_FILE = "desk-layouts.json"
local DEFAULT_NAMES = { "Work", "Gaming", "Streaming", "Custom" }
local EXCLUDED_PROCESSES = {
  ["rebind"] = true,
  ["rebind-desktop"] = true,
  ["kun"] = true,
  ["textinputhost"] = true,
  ["nvidia overlay"] = true,
  ["nvidia share"] = true,
  ["gamebar"] = true,
  ["xboxgamebar"] = true,
  ["xboxgamebarwidgets"] = true,
}

local cfg = rb.ui.schema({
  menu_key = rb.ui.keybind("F7", {
    label = "Open layouts",
    group = "Hotkeys",
  }),
  save_key = rb.ui.keybind("F8", {
    label = "Save active layout",
    group = "Hotkeys",
  }),
  apply_key = rb.ui.keybind("F9", {
    label = "Apply active layout",
    group = "Hotkeys",
  }),
  layout_1_name = rb.ui.text("Work", {
    label = "Slot 1 name",
    group = "Layouts",
    max_length = 24,
  }),
  layout_2_name = rb.ui.text("Gaming", {
    label = "Slot 2 name",
    group = "Layouts",
    max_length = 24,
  }),
  layout_3_name = rb.ui.text("Streaming", {
    label = "Slot 3 name",
    group = "Layouts",
    max_length = 24,
  }),
  layout_4_name = rb.ui.text("Custom", {
    label = "Slot 4 name",
    group = "Layouts",
    max_length = 24,
  }),
  notifications = rb.ui.toggle(true, {
    label = "Show notifications",
    group = "Behavior",
  }),
})

local state = {
  layouts = {},
  active_slot = 1,
  last_slot = 0,
  menu_open = false,
  menu_surface = nil,
  menu_items = {},
  menu_selectable = {},
  menu_cursor = 1,
  menu_timer = nil,
}

local function trim(value)
  return (tostring(value or ""):gsub("^%s+", ""):gsub("%s+$", ""))
end

local function slot_name(slot)
  local name = trim(cfg["layout_" .. slot .. "_name"] or DEFAULT_NAMES[slot])
  if name == "" then
    return DEFAULT_NAMES[slot]
  end
  return name
end

local function notify(message)
  if cfg.notifications == false then
    return
  end
  pcall(rb.overlay.toast, message, {
    title = "Desk Layouts",
    duration = 2800,
  })
end

local function get_displays()
  local ok, displays = pcall(rb.screen.list)
  if ok and type(displays) == "table" and #displays > 0 then
    return displays
  end

  local width, height = 1920, 1080
  local screen_ok, screen_width, screen_height = pcall(rb.system.screen)
  if screen_ok then
    width = tonumber(screen_width) or width
    height = tonumber(screen_height) or height
  end
  return {
    { index = 1, x = 0, y = 0, width = width, height = height, primary = true },
  }
end

local function work_area(display)
  local ok, area = pcall(
    rb.screen.work_area,
    display.x + display.width / 2,
    display.y + display.height / 2
  )
  if ok and type(area) == "table" and area.width and area.height then
    return area
  end
  return display
end

local function display_for_rect(x, y, width, height)
  local displays = get_displays()
  local best = displays[1]
  local best_overlap = -1

  for _, display in ipairs(displays) do
    local overlap_x = math.max(
      0,
      math.min(x + width, display.x + display.width) - math.max(x, display.x)
    )
    local overlap_y = math.max(
      0,
      math.min(y + height, display.y + display.height) - math.max(y, display.y)
    )
    local overlap = overlap_x * overlap_y
    if overlap > best_overlap then
      best = display
      best_overlap = overlap
    end
  end

  return best
end

local function display_by_index(index)
  local displays = get_displays()
  for _, display in ipairs(displays) do
    if display.index == index then
      return display
    end
  end
  for _, display in ipairs(displays) do
    if display.primary then
      return display
    end
  end
  return displays[1]
end

local function norm_process(value)
  local process = tostring(value or ""):lower()
  return (process:gsub("%.exe$", ""))
end

local function is_excluded(window)
  return EXCLUDED_PROCESSES[norm_process(window.process)] == true
end

local function is_minimized(window)
  local ok, window_state = pcall(rb.window.get_state, window.handle)
  return ok and window_state == "minimized"
end

local function capture_windows()
  local ok, windows = pcall(rb.window.list)
  if not ok or type(windows) ~= "table" then
    return {}, 0
  end

  local captured = {}
  for _, window in ipairs(windows) do
    local width = tonumber(window.width) or 0
    local height = tonumber(window.height) or 0
    local title = trim(window.title)

    if window.handle
      and title ~= ""
      and title ~= "Program Manager"
      and width >= 80
      and height >= 80
      and not is_excluded(window)
      and not is_minimized(window) then
      local display = display_for_rect(
        tonumber(window.x) or 0,
        tonumber(window.y) or 0,
        width,
        height
      )
      captured[#captured + 1] = {
        process = tostring(window.process or ""),
        title = title:sub(1, 160),
        display = display.index,
        x = (tonumber(window.x) or 0) - display.x,
        y = (tonumber(window.y) or 0) - display.y,
        w = width,
        h = height,
      }
    end
  end

  table.sort(captured, function(a, b)
    if a.y == b.y then
      return a.x < b.x
    end
    return a.y < b.y
  end)

  local total = #captured
  while #captured > MAX_WINDOWS do
    captured[#captured] = nil
  end
  return captured, total
end

local function save_state()
  local payload = {
    version = 1,
    active_slot = state.active_slot,
    last_slot = state.last_slot,
    layouts = state.layouts,
  }
  local ok = pcall(rb.file.write_json, STATE_FILE, payload)
  if not ok then
    rb.log.warn("Desk Layouts: could not save " .. STATE_FILE)
  end
end

local function load_state()
  if not rb.file.exists(STATE_FILE) then
    return
  end

  local ok, data = pcall(rb.file.read_json, STATE_FILE)
  if not ok or type(data) ~= "table" then
    return
  end

  state.active_slot = math.max(
    1,
    math.min(SLOT_COUNT, math.floor(tonumber(data.active_slot) or 1))
  )
  state.last_slot = math.max(
    0,
    math.min(SLOT_COUNT, math.floor(tonumber(data.last_slot) or 0))
  )

  if type(data.layouts) ~= "table" then
    return
  end

  for slot = 1, SLOT_COUNT do
    local layout = data.layouts[slot] or data.layouts[tostring(slot)]
    if type(layout) == "table" and type(layout.windows) == "table" then
      local windows = {}
      for _, window in ipairs(layout.windows) do
        if type(window) == "table"
          and type(window.process) == "string"
          and type(window.title) == "string"
          and not EXCLUDED_PROCESSES[norm_process(window.process)] then
          windows[#windows + 1] = {
            process = window.process,
            title = window.title,
            display = tonumber(window.display) or 1,
            x = tonumber(window.x) or 0,
            y = tonumber(window.y) or 0,
            w = tonumber(window.w) or 800,
            h = tonumber(window.h) or 600,
          }
        end
      end
      if #windows > 0 then
        state.layouts[slot] = {
          windows = windows,
          captured_at = tonumber(layout.captured_at) or 0,
        }
      end
    end
  end

  if state.last_slot > SLOT_COUNT then
    state.last_slot = 0
  end
end

local function find_window(slot)
  local ok, windows = pcall(rb.window.list)
  if not ok or type(windows) ~= "table" then
    return nil
  end

  local best = nil
  local best_score = 0
  local wanted_process = norm_process(slot.process)
  local wanted_title = trim(slot.title):lower()

  for _, window in ipairs(windows) do
    if not is_excluded(window) then
      local score = 0
      if norm_process(window.process) == wanted_process then
        score = score + 4
      end

      local title = trim(window.title):lower()
      if wanted_title ~= "" and title == wanted_title then
        score = score + 8
      elseif wanted_title ~= ""
        and (title:find(wanted_title, 1, true) or wanted_title:find(title, 1, true)) then
        score = score + 3
      end

      if score > best_score then
        best = window
        best_score = score
      end
    end
  end

  if best_score > 0 then
    return best
  end
  return nil
end

local function clamp(value, minimum, maximum)
  return math.max(minimum, math.min(value, maximum))
end

local function apply_layout(slot)
  local layout = state.layouts[slot]
  if not layout or #layout.windows == 0 then
    notify(slot_name(slot) .. " is empty. Save a layout first.")
    return
  end

  local moved = 0
  local missing = 0
  local missing_names = {}

  for _, saved in ipairs(layout.windows) do
    local window = find_window(saved)
    if window then
      local display = display_by_index(saved.display)
      local area = work_area(display)
      local width = clamp(math.floor(saved.w), 120, area.width)
      local height = clamp(math.floor(saved.h), 80, area.height)
      local x = clamp(
        math.floor(display.x + saved.x),
        area.x,
        area.x + area.width - width
      )
      local y = clamp(
        math.floor(display.y + saved.y),
        area.y,
        area.y + area.height - height
      )

      local ok = pcall(rb.window.move, window.handle, {
        x = x,
        y = y,
        width = width,
        height = height,
      })
      if ok then
        moved = moved + 1
      else
        missing = missing + 1
        if #missing_names < 3 then
          missing_names[#missing_names + 1] = trim(window.title)
        end
      end
    else
      missing = missing + 1
      if #missing_names < 3 then
        missing_names[#missing_names + 1] = trim(saved.title)
      end
    end
  end

  state.active_slot = slot
  state.last_slot = slot
  save_state()

  local message = string.format(
    "%s · moved %d/%d windows",
    slot_name(slot),
    moved,
    #layout.windows
  )
  if missing > 0 then
    message = message .. " · " .. missing .. " missing"
    if #missing_names > 0 then
      message = message .. " (" .. table.concat(missing_names, ", ") .. ")"
    end
  end
  notify(message)
end

local function capture_layout(slot)
  local windows, total = capture_windows()
  if #windows == 0 then
    notify("No visible windows found to capture.")
    return
  end

  state.layouts[slot] = {
    windows = windows,
    captured_at = rb.system.time(),
  }
  state.active_slot = slot
  state.last_slot = slot
  save_state()

  local message = string.format(
    "Saved %d window%s to %s",
    #windows,
    #windows == 1 and "" or "s",
    slot_name(slot)
  )
  if total > MAX_WINDOWS then
    message = message .. " (capped at " .. MAX_WINDOWS .. ")"
  end
  notify(message)
end

local function layout_hint(slot)
  local layout = state.layouts[slot]
  if not layout or #layout.windows == 0 then
    return "empty"
  end
  return string.format(
    "%d window%s",
    #layout.windows,
    #layout.windows == 1 and "" or "s"
  )
end

local MENU_WIDTH = 620
local COLORS = {
  accent = "#C7F36B",
  text = "#F4F1E8",
  soft = "#D8DDD3",
  muted = "#98A398",
}

local close_menu

local function menu_height(items)
  local height = 92
  for _, item in ipairs(items) do
    height = height + (item.kind == "header" and 30 or 40)
  end
  return height + 52
end

local function menu_rect(ops, x, y, width, height, fill, radius, border, border_width)
  local op = {
    kind = "rect",
    x = x,
    y = y,
    w = width,
    h = height,
    fill = fill,
    radius = radius or 0,
  }
  if border then
    op.border = border
    op.border_width = border_width or 1
  end
  ops[#ops + 1] = op
end

local function menu_text(ops, x, y, size, text, color, bold)
  ops[#ops + 1] = {
    kind = "text",
    x = x,
    y = y,
    size = size,
    text = text,
    color = color,
    bold = bold == true,
  }
end

local function text_width(text, size, bold)
  local ok, width = pcall(rb.overlay.measure, text, size, bold)
  if ok and width then
    return width
  end
  return #text * size * 0.62
end

local function draw_menu()
  if not state.menu_open then
    return
  end

  local items = state.menu_items
  local width = MENU_WIDTH
  local height = menu_height(items)
  local ops = {}

  menu_rect(ops, 0, 0, width, height, "#0E110FF5", 18, "#2B332C", 1)
  menu_rect(ops, 24, 24, 3, 18, COLORS.accent, 1)
  menu_text(ops, 38, 20, 20, "DESK LAYOUTS", COLORS.text, true)
  menu_text(ops, 38, 47, 11, "Saved window arrangements", COLORS.muted)

  local menu_hint = "F7  MENU"
  menu_text(
    ops,
    width - 24 - text_width(menu_hint, 10, false),
    22,
    10,
    menu_hint,
    COLORS.muted
  )
  local active = "ACTIVE  " .. string.upper(slot_name(state.active_slot))
  menu_text(
    ops,
    width - 24 - text_width(active, 10, true),
    43,
    10,
    active,
    COLORS.accent,
    true
  )

  local y = 84
  for _, item in ipairs(items) do
    if item.kind == "header" then
      menu_text(ops, 24, y + 10, 10, item.label, COLORS.muted, true)
      y = y + 30
    else
      local selected = item.number == state.menu_cursor
      local fill = selected and "#C7F36B14" or "#171C18"
      local border = selected and "#C7F36B55" or "#242C25"

      menu_rect(ops, 16, y, width - 32, 36, fill, 9, border, 1)
      if selected then
        menu_rect(ops, 16, y, 3, 36, COLORS.accent, 1)
      end
      menu_text(
        ops,
        32,
        y + 10,
        13,
        item.label,
        selected and COLORS.text or COLORS.soft,
        selected
      )

      local hint = string.format("%d   %s", item.number, item.hint or "")
      menu_text(
        ops,
        width - 32 - text_width(hint, 10, false),
        y + 11,
        10,
        hint,
        selected and COLORS.accent or COLORS.muted,
        false
      )
      y = y + 40
    end
  end

  local footer_y = y + 12
  menu_rect(ops, 16, footer_y, width - 32, 1, "#283029", 0)
  menu_text(
    ops,
    24,
    footer_y + 12,
    10,
    "UP/DOWN  navigate      ENTER  select      ESC  close",
    COLORS.muted
  )

  if not state.menu_surface then
    local ok, surface = pcall(rb.overlay.surface, {
      anchor = "center",
      width = width,
      height = height,
      ops = ops,
    })
    if not ok then
      rb.log.warn("Desk Layouts menu: " .. tostring(surface))
      state.menu_open = false
      return
    end
    state.menu_surface = surface
  else
    local updated = pcall(function()
      state.menu_surface:set({
        width = width,
        height = height,
        ops = ops,
      })
    end)
    if not updated then
      close_menu()
    end
  end
end

close_menu = function()
  state.menu_open = false
  if state.menu_timer then
    pcall(function()
      state.menu_timer:stop()
    end)
    state.menu_timer = nil
  end
  if state.menu_surface then
    pcall(function()
      state.menu_surface:remove()
    end)
    state.menu_surface = nil
  end
end

local function show_help()
  notify(
    "F7  open menu\n"
      .. "F8  save active layout\n"
      .. "F9  apply active layout\n\n"
      .. "Only running windows move.\n"
      .. "Up to 8 windows per layout.\n"
      .. "Positions follow each monitor."
  )
end

local function select_item(item)
  if not item then
    return
  end
  close_menu()
  if item.action then
    item.action()
  end
end

local function move_cursor(delta)
  if not state.menu_open then
    return
  end
  local count = #state.menu_selectable
  if count == 0 then
    return
  end
  state.menu_cursor = ((state.menu_cursor - 1 + delta) % count) + 1
  draw_menu()
end

local function select_number(number)
  if not state.menu_open then
    return
  end
  select_item(state.menu_selectable[number])
end

local function open_menu()
  if state.menu_open then
    close_menu()
    return
  end

  local items = {
    { kind = "header", label = "APPLY A LAYOUT" },
  }
  for slot = 1, SLOT_COUNT do
    local index = slot
    items[#items + 1] = {
      label = slot_name(index),
      hint = layout_hint(index),
      action = function()
        apply_layout(index)
      end,
    }
  end

  items[#items + 1] = { kind = "header", label = "SAVE CURRENT WINDOWS" }
  for slot = 1, SLOT_COUNT do
    local index = slot
    items[#items + 1] = {
      label = "Save to " .. slot_name(index),
      hint = "replace",
      action = function()
        capture_layout(index)
      end,
    }
  end

  items[#items + 1] = { kind = "header", label = "GENERAL" }
  items[#items + 1] = {
    label = "Apply last layout",
    hint = state.last_slot > 0 and slot_name(state.last_slot) or "none",
    action = function()
      if state.last_slot > 0 then
        apply_layout(state.last_slot)
      else
        notify("No layout has been applied yet.")
      end
    end,
  }
  items[#items + 1] = {
    label = "Help / hotkeys",
    hint = "keys and limits",
    action = show_help,
  }

  state.menu_items = items
  state.menu_selectable = {}
  for _, item in ipairs(items) do
    if item.kind ~= "header" then
      state.menu_selectable[#state.menu_selectable + 1] = item
      item.number = #state.menu_selectable
    end
  end
  state.menu_cursor = 1
  state.menu_open = true
  draw_menu()

  if state.menu_open then
    local ok, timer = pcall(rb.timer.after, 30000, function()
      close_menu()
    end)
    if ok then
      state.menu_timer = timer
    end
  end
end

local function save_active()
  if state.menu_open then
    close_menu()
  end
  capture_layout(state.active_slot)
end

local function apply_active()
  if state.menu_open then
    close_menu()
  end
  apply_layout(state.active_slot)
end

local function menu_is_open()
  return state.menu_open
end

rb.bind(cfg.menu_key, open_menu)
rb.bind(cfg.save_key, save_active)
rb.bind(cfg.apply_key, apply_active)

rb.bind("Up", function()
  move_cursor(-1)
end, { when = menu_is_open })
rb.bind("Down", function()
  move_cursor(1)
end, { when = menu_is_open })
rb.bind("Enter", function()
  select_item(state.menu_selectable[state.menu_cursor])
end, { when = menu_is_open })
rb.bind("Escape", close_menu, { when = menu_is_open })

for number = 1, 9 do
  local value = number
  rb.bind(tostring(value), function()
    select_number(value)
  end, { when = menu_is_open })
end

function OnStart()
  load_state()
  notify("F7 layouts  ·  F8 save  ·  F9 apply")
end

function OnStop()
  save_state()
end

No reviews yet. Be the first, from the app.

Link

BYOH

desk-layouts

Desk Layouts

Highlights

Quick Start

Controls

What Gets Saved

Limits

Settings

Privacy and Permissions

Troubleshooting

A window is not being restored

Nothing moves after F9

The menu does not open

A window lands slightly off screen

Requirements

desk-layouts

Readme

Desk Layouts

Highlights

Quick Start

Controls

What Gets Saved

Limits

Settings

Privacy and Permissions

Troubleshooting

A window is not being restored

Nothing moves after F9

The menu does not open

A window lands slightly off screen

Requirements

Files

Reviews