SUPER+RETURN: open the terminal in the focused Nautilus folder

[danielgccr]

What I'd like

SUPER+RETURN already opens a terminal in the active terminal's directory —
omarchy-launch-terminal resolves it with omarchy-cmd-terminal-cwd. I'd love
that same behaviour when the focused window is the file manager: standing in
~/Documents/mystuff in Nautilus, SUPER+RETURN gives me a terminal already
in ~/Documents/mystuff.

No new keybinding to learn, no new mental model — just the cwd inheritance
Omarchy already has, extended one window class further.

Related, but asking for something slightly different: #3845 (Nautilus' own
Ctrl+. "Open in Console") and #3422 (ship nautilus-open-any-terminal for
the right-click menu). Both are about a shortcut inside Nautilus. This one is
about the Omarchy binding people already use.

The catch, and a working implementation

Nautilus won't tell you where it is. On Nautilus 50 / nautilus-python 4.1:

• LocationWidgetProvider is gone, so the usual "watch the location" hook no
  longer exists (this is also why nautilus-open-any-terminal's keybinding
  path had to move to an app-level GAction).
• The window's org.gtk.Actions on D-Bus exposes go-home, new-tab,
  current-location-menu… but no location state to read.

MenuProvider.get_background_items turns out to be the one hook that still
fires on every folder load, including in-window navigation. So a small
extension can publish the path, and the binding can read it.

I've been running this on Omarchy 4.0.0 (Nautilus 50.2.2) and it works well.

~/.local/share/nautilus-python/extensions/current-folder.py

import os
import tempfile

from gi import require_version

require_version("Nautilus", "4.1")

from gi.repository import GObject, Nautilus

STATE_FILE = os.path.join(
    os.environ.get("XDG_RUNTIME_DIR") or "/tmp", "nautilus-current-folder"
)
HISTORY = 20


class RecordCurrentFolder(GObject.GObject, Nautilus.MenuProvider):
    """Record the folder Nautilus is showing so keybindings can reuse it."""

    def get_background_items(self, *args):
        folder = self._folder_path(args[-1])

        if folder:
            self._record(folder)

        return []

    def get_file_items(self, *args):
        return []

    def _folder_path(self, folder):
        if folder is None:
            return None

        location = folder.get_location()
        if location is None:
            return None

        path = location.get_path()

        return path if path and os.path.isdir(path) else None

    def _record(self, folder):
        history = self._read()

        if history and history[-1] == folder:
            return

        history = [path for path in history if path != folder]
        history.append(folder)

        self._write(history[-HISTORY:])

    def _read(self):
        try:
            with open(STATE_FILE) as state:
                return [line.strip() for line in state if line.strip()]
        except OSError:
            return []

    def _write(self, history):
        handle, temp = tempfile.mkstemp(dir=os.path.dirname(STATE_FILE))

        try:
            with os.fdopen(handle, "w") as state:
                state.write("\n".join(history) + "\n")
            os.replace(temp, STATE_FILE)
        except OSError:
            os.unlink(temp)

The binding wrapper

#!/bin/bash

# Open a terminal in the directory the focused window is showing.

state="${XDG_RUNTIME_DIR:-/tmp}/nautilus-current-folder"

nautilus_cwd() {
  local title=$1
  local folder recent="" titled=""

  [[ -r $state ]] || return

  while IFS= read -r folder; do
    [[ -d $folder ]] || continue

    recent=$folder
    [[ ${folder##*/} == "$title" ]] && titled=$folder
  done <"$state"

  # Several Nautilus windows can be open, so prefer the folder whose name
  # matches the window title and fall back to whichever was visited last.
  printf '%s' "${titled:-$recent}"
}

active=$(hyprctl activewindow -j)

if [[ $(jq -r '.class // empty' <<<"$active") == "org.gnome.Nautilus" ]]; then
  cwd=$(nautilus_cwd "$(jq -r '.title // empty' <<<"$active")")

  if [[ -n $cwd ]]; then
    exec setsid uwsm-app -- xdg-terminal-exec --dir="$cwd" "$@"
  fi
fi

exec omarchy-launch-terminal "$@"

-- ~/.config/hypr/bindings.lua
hl.unbind("SUPER + RETURN")
o.bind("SUPER + RETURN", "Terminal", "launch-terminal-here")

Nautilus titles a window with the folder's name, which is enough to pick the
right entry when several windows are open; anything unmatched (Home, Recent)
falls back to the most recently visited folder. Non-Nautilus windows fall
straight through to omarchy-launch-terminal, so nothing about today's
behaviour changes.

Why it might fit Omarchy

Omarchy already ships its own nautilus-python extensions (localsend.py,
transcode.py) into ~/.local/share/nautilus-python/extensions/, so there's a
home for this already — and folding the lookup into omarchy-cmd-terminal-cwd
would keep it to one "where am I?" helper.

Worth noting for #3422: nautilus-open-any-terminal is already in the Omarchy
package repo (omarchy pkg add nautilus-open-any-terminal). It solves the
right-click case nicely, but it can't cover this one — its shortcut is a GTK
accelerator inside Nautilus, and SUPER+RETURN never reaches the app because
Hyprland grabs it first. The two would complement each other rather than
overlap.

Happy to open a PR if this is something you'd take.

[seantimm]

Your note that "Nautilus won't tell you where it is" is right for this direction — Hyprland
takes SUPER+RETURN before Nautilus ever sees it, so something has to publish the location
from inside the app, as your extension does.

Worth knowing it isn't true in reverse: when Nautilus initiates, it hands the folder over
itself. Its built-in "Open in Console" (Ctrl+.) activates the org.gnome.Console D-Bus
service with the folder URI, and that shortcut is dead on Omarchy only because nothing
claims that bus name. I've opened #9017 to stand in for it.

That fixes Ctrl+. and the right-click entry, and nothing else — it can't provide
SUPER+RETURN, so it isn't a substitute for what you've proposed here.

Posted by Claude Code on @seantimm's behalf.