diff --git a/CHANGES b/CHANGES
index 437f7e4a7..ce74e5aae 100644
--- a/CHANGES
+++ b/CHANGES
@@ -14,6 +14,31 @@ $ pip install --user --upgrade --pre libtmux
 
 <!-- Maintainers and contributors: Insert change notes for the next release above -->
 
+### New features
+
+- `Window.set_option()` (#516)
+
+  Learned params:
+
+  - `format` -> `-F`
+  - `unset` -> `-u`
+  - `global` -> `-g`
+  - `unset_panes` -> `-U`: Also unset other panse in windows
+  - `prevent_overwrite`: `-o`
+  - `suppress_warnings`: `-q`
+  - `append`: `-a`
+
+- `Window.show_option()` (#516)
+- `Window.show_options()` (#516)
+
+### Breaking changes
+
+#### Deprecations
+
+- Deprecated `Window.set_window_option()` in favor of `Window.set_option()` (#516)
+- Deprecated `Window.show_window_option()` in favor of `Window.show_option()` (#516)
+- Deprecated `Window.show_window_options()` in favor of `Window.show_options()` (#516)
+
 ## libtmux 0.27.0 (2024-02-07)
 
 ### Improvement
diff --git a/src/libtmux/common.py b/src/libtmux/common.py
index c8bb6ccc4..e52189978 100644
--- a/src/libtmux/common.py
+++ b/src/libtmux/common.py
@@ -7,12 +7,20 @@
 """
 import logging
 import re
+import shlex
 import shutil
 import subprocess
 import sys
 import typing as t
 from typing import Dict, Optional, Union
 
+from libtmux.constants import (
+    DEFAULT_SCOPE,
+    OPTION_SCOPE_FLAG_MAP,
+    OptionScope,
+    _DefaultScope,
+)
+
 from . import exc
 from ._compat import LooseVersion, console_to_str, str_from_console
 
@@ -32,9 +40,270 @@
 SessionDict = t.Dict[str, t.Any]
 WindowDict = t.Dict[str, t.Any]
 WindowOptionDict = t.Dict[str, t.Any]
+PaneOptionDict = t.Dict[str, t.Any]
 PaneDict = t.Dict[str, t.Any]
 
 
+class CmdProtocol(t.Protocol):
+    """Command protocol for tmux command."""
+
+    def __call__(self, cmd: str, *args: t.Any, **kwargs: t.Any) -> "tmux_cmd":
+        """Wrap tmux_cmd."""
+        ...
+
+
+class CmdMixin:
+    """Command mixin for tmux command."""
+
+    cmd: CmdProtocol
+
+
+class OptionMixin(CmdMixin):
+    """Mixin for manager session and server level environment variables in tmux."""
+
+    default_scope: OptionScope | None
+
+    def __init__(self, default_scope: OptionScope) -> None:
+        self.default_scope = default_scope
+
+    def set_option(
+        self,
+        option: str,
+        value: t.Union[int, str],
+        _format: t.Optional[bool] = None,
+        unset: t.Optional[bool] = None,
+        unset_panes: t.Optional[bool] = None,
+        prevent_overwrite: t.Optional[bool] = None,
+        suppress_warnings: t.Optional[bool] = None,
+        append: t.Optional[bool] = None,
+        g: t.Optional[bool] = None,
+        scope: t.Optional[t.Union[OptionScope, _DefaultScope]] = DEFAULT_SCOPE,
+    ) -> "t.Self":
+        """Set option for tmux window.
+
+        Wraps ``$ tmux set-option <option> <value>``.
+
+        Parameters
+        ----------
+        option : str
+            option to set, e.g. 'aggressive-resize'
+        value : str
+            window option value. True/False will turn in 'on' and 'off',
+            also accepts string of 'on' or 'off' directly.
+
+        Raises
+        ------
+        :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
+        :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
+        """
+        if scope is DEFAULT_SCOPE:
+            scope = self.default_scope
+
+        flags: t.List[str] = []
+        if isinstance(value, bool) and value:
+            value = "on"
+        elif isinstance(value, bool) and not value:
+            value = "off"
+
+        if unset is not None and unset:
+            assert isinstance(unset, bool)
+            flags.append("-u")
+
+        if unset_panes is not None and unset_panes:
+            assert isinstance(unset_panes, bool)
+            flags.append("-U")
+
+        if _format is not None and _format:
+            assert isinstance(_format, bool)
+            flags.append("-F")
+
+        if prevent_overwrite is not None and prevent_overwrite:
+            assert isinstance(prevent_overwrite, bool)
+            flags.append("-o")
+
+        if suppress_warnings is not None and suppress_warnings:
+            assert isinstance(suppress_warnings, bool)
+            flags.append("-q")
+
+        if append is not None and append:
+            assert isinstance(append, bool)
+            flags.append("-a")
+
+        if g is not None and g:
+            assert isinstance(g, bool)
+            flags.append("-g")
+
+        if scope is not None and not isinstance(scope, _DefaultScope):
+            assert scope in OPTION_SCOPE_FLAG_MAP
+            flags.append(
+                OPTION_SCOPE_FLAG_MAP[scope],
+            )
+
+        cmd = self.cmd(
+            "set-option",
+            *flags,
+            option,
+            value,
+        )
+
+        if isinstance(cmd.stderr, list) and len(cmd.stderr):
+            handle_option_error(cmd.stderr[0])
+
+        return self
+
+    @t.overload
+    def show_options(
+        self,
+        g: t.Optional[bool],
+        scope: t.Optional[t.Union[OptionScope, _DefaultScope]],
+        include_hooks: t.Optional[bool],
+        include_parents: t.Optional[bool],
+        values_only: t.Literal[True],
+    ) -> t.List[str]:
+        ...
+
+    @t.overload
+    def show_options(
+        self,
+        g: t.Optional[bool],
+        scope: t.Optional[t.Union[OptionScope, _DefaultScope]],
+        include_hooks: t.Optional[bool],
+        include_parents: t.Optional[bool],
+        values_only: t.Literal[None] = None,
+    ) -> "WindowOptionDict":
+        ...
+
+    @t.overload
+    def show_options(
+        self,
+        g: t.Optional[bool] = None,
+        scope: t.Optional[t.Union[OptionScope, _DefaultScope]] = DEFAULT_SCOPE,
+        include_hooks: t.Optional[bool] = None,
+        include_parents: t.Optional[bool] = None,
+        values_only: t.Literal[False] = False,
+    ) -> "WindowOptionDict":
+        ...
+
+    def show_options(
+        self,
+        g: t.Optional[bool] = False,
+        scope: t.Optional[t.Union[OptionScope, _DefaultScope]] = DEFAULT_SCOPE,
+        include_hooks: t.Optional[bool] = None,
+        include_parents: t.Optional[bool] = None,
+        values_only: t.Optional[bool] = False,
+    ) -> t.Union["WindowOptionDict", t.List[str]]:
+        """Return a dict of options for the window.
+
+        Parameters
+        ----------
+        g : str, optional
+            Pass ``-g`` flag for global variable, default False.
+        """
+        if scope is DEFAULT_SCOPE:
+            scope = self.default_scope
+
+        tmux_args: t.Tuple[str, ...] = ()
+
+        if g:
+            tmux_args += ("-g",)
+
+        if scope is not None and not isinstance(scope, _DefaultScope):
+            assert scope in OPTION_SCOPE_FLAG_MAP
+            tmux_args += (OPTION_SCOPE_FLAG_MAP[scope],)
+
+        if include_parents is not None and include_parents:
+            tmux_args += ("-A",)
+
+        if include_hooks is not None and include_hooks:
+            tmux_args += ("-H",)
+
+        if values_only is not None and values_only:
+            tmux_args += ("-v",)
+
+        cmd = self.cmd("show-options", *tmux_args)
+
+        output = cmd.stdout
+
+        # The shlex.split function splits the args at spaces, while also
+        # retaining quoted sub-strings.
+        #   shlex.split('this is "a test"') => ['this', 'is', 'a test']
+
+        window_options: "WindowOptionDict" = {}
+        for item in output:
+            try:
+                key, val = shlex.split(item)
+            except ValueError:
+                logger.exception(f"Error extracting option: {item}")
+            assert isinstance(key, str)
+            assert isinstance(val, str)
+
+            if isinstance(val, str) and val.isdigit():
+                window_options[key] = int(val)
+
+        return window_options
+
+    def show_option(
+        self,
+        option: str,
+        g: bool = False,
+        scope: t.Optional[t.Union[OptionScope, _DefaultScope]] = DEFAULT_SCOPE,
+        include_hooks: t.Optional[bool] = None,
+        include_parents: t.Optional[bool] = None,
+    ) -> t.Optional[t.Union[str, int]]:
+        """Return option value for the target window.
+
+        todo: test and return True/False for on/off string
+
+        Parameters
+        ----------
+        option : str
+        g : bool, optional
+            Pass ``-g`` flag, global. Default False.
+
+        Raises
+        ------
+        :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
+        :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
+        """
+        if scope is DEFAULT_SCOPE:
+            scope = self.default_scope
+
+        tmux_args: t.Tuple[t.Union[str, int], ...] = ()
+
+        if g:
+            tmux_args += ("-g",)
+
+        if scope is not None and not isinstance(scope, _DefaultScope):
+            assert scope in OPTION_SCOPE_FLAG_MAP
+            tmux_args += (OPTION_SCOPE_FLAG_MAP[scope],)
+
+        if include_parents is not None and include_parents:
+            tmux_args += ("-A",)
+
+        if include_hooks is not None and include_hooks:
+            tmux_args += ("-H",)
+
+        tmux_args += (option,)
+
+        cmd = self.cmd("show-options", *tmux_args)
+
+        if len(cmd.stderr):
+            handle_option_error(cmd.stderr[0])
+
+        window_options_output = cmd.stdout
+
+        if not len(window_options_output):
+            return None
+
+        value_raw = next(shlex.split(item) for item in window_options_output)
+
+        value: t.Union[str, int] = (
+            int(value_raw[1]) if value_raw[1].isdigit() else value_raw[1]
+        )
+
+        return value
+
+
 class EnvironmentMixin:
     """Mixin for manager session and server level environment variables in tmux."""
 
diff --git a/src/libtmux/constants.py b/src/libtmux/constants.py
new file mode 100644
index 000000000..2a3d23181
--- /dev/null
+++ b/src/libtmux/constants.py
@@ -0,0 +1,28 @@
+"""Constant variables for libtmux."""
+import enum
+import typing as t
+
+
+class _DefaultScope:
+    # Sentinel value for default scope
+    ...
+
+
+DEFAULT_SCOPE: _DefaultScope = _DefaultScope()
+
+
+class OptionScope(enum.Enum):
+    """Scope used with ``set-option`` and ``show-option(s)`` commands."""
+
+    Server = "SERVER"
+    Session = "SESSION"
+    Window = "WINDOW"
+    Pane = "PANE"
+
+
+OPTION_SCOPE_FLAG_MAP: t.Dict[OptionScope, str] = {
+    OptionScope.Server: "-s",
+    OptionScope.Session: "",
+    OptionScope.Window: "-w",
+    OptionScope.Pane: "-p",
+}
diff --git a/src/libtmux/pane.py b/src/libtmux/pane.py
index 907b23205..93017a086 100644
--- a/src/libtmux/pane.py
+++ b/src/libtmux/pane.py
@@ -7,16 +7,19 @@
 """
 import dataclasses
 import logging
+import shlex
 import typing as t
 import warnings
 from typing import overload
 
-from libtmux.common import tmux_cmd
+from libtmux.common import handle_option_error, tmux_cmd
+from libtmux.constants import OPTION_SCOPE_FLAG_MAP, OptionScope
 from libtmux.neo import Obj, fetch_obj
 
 from . import exc
 
 if t.TYPE_CHECKING:
+    from .common import PaneOptionDict
     from .server import Server
     from .session import Session
     from .window import Window
@@ -113,7 +116,7 @@ def cmd(self, cmd: str, *args: t.Any, **kwargs: t.Any) -> tmux_cmd:
         Specifying ``('-t', 'custom-target')`` or ``('-tcustom_target')`` in
         ``args`` will override using the object's ``pane_id`` as target.
         """
-        if not any(arg.startswith("-t") for arg in args):
+        if not any("-t" in str(x) for x in args):
             args = ("-t", self.pane_id, *args)
 
         return self.server.cmd(cmd, *args, **kwargs)
@@ -326,6 +329,174 @@ def split_window(
             percent=percent,
         )
 
+    def set_option(
+        self,
+        option: str,
+        value: t.Union[int, str],
+        _format: t.Optional[bool] = None,
+        unset: t.Optional[bool] = None,
+        unset_panes: t.Optional[bool] = None,
+        prevent_overwrite: t.Optional[bool] = None,
+        suppress_warnings: t.Optional[bool] = None,
+        append: t.Optional[bool] = None,
+        g: t.Optional[bool] = None,
+        scope: t.Optional[OptionScope] = None,
+    ) -> "Pane":
+        """Set option for tmux pane.
+
+        Wraps ``$ tmux set-option -p <option> <value>``.
+
+        Parameters
+        ----------
+        option : str
+            option to set, e.g. 'aggressive-resize'
+        value : str
+            window option value. True/False will turn in 'on' and 'off',
+            also accepts string of 'on' or 'off' directly.
+
+        Raises
+        ------
+        :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
+        :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
+        """
+        flags: t.List[str] = []
+        if isinstance(value, bool) and value:
+            value = "on"
+        elif isinstance(value, bool) and not value:
+            value = "off"
+
+        if unset is not None and unset:
+            assert isinstance(unset, bool)
+            flags.append("-u")
+
+        if unset_panes is not None and unset_panes:
+            assert isinstance(unset_panes, bool)
+            flags.append("-U")
+
+        if _format is not None and _format:
+            assert isinstance(_format, bool)
+            flags.append("-F")
+
+        if prevent_overwrite is not None and prevent_overwrite:
+            assert isinstance(prevent_overwrite, bool)
+            flags.append("-o")
+
+        if suppress_warnings is not None and suppress_warnings:
+            assert isinstance(suppress_warnings, bool)
+            flags.append("-q")
+
+        if append is not None and append:
+            assert isinstance(append, bool)
+            flags.append("-a")
+
+        if g is not None and g:
+            assert isinstance(g, bool)
+            flags.append("-g")
+
+        if scope is not None:
+            assert scope in OPTION_SCOPE_FLAG_MAP
+            flags.append(
+                OPTION_SCOPE_FLAG_MAP[scope],
+            )
+
+        cmd = self.cmd(
+            "set-option",
+            f"-t{self.pane_id}",
+            option,
+            value,
+            *flags,
+        )
+
+        if isinstance(cmd.stderr, list) and len(cmd.stderr):
+            handle_option_error(cmd.stderr[0])
+
+        return self
+
+    def show_options(
+        self,
+        g: t.Optional[bool] = False,
+        scope: t.Optional[OptionScope] = OptionScope.Pane,
+    ) -> "PaneOptionDict":
+        """Return a dict of options for the pane.
+
+        For familiarity with tmux, the option ``option`` param forwards to
+        pick a single option, forwarding to :meth:`Pane.show_option`.
+
+        Parameters
+        ----------
+        g : str, optional
+            Pass ``-g`` flag for global variable, default False.
+        """
+        tmux_args: t.Tuple[str, ...] = ()
+
+        if g:
+            tmux_args += ("-g",)
+
+        if scope is not None:
+            assert scope in OPTION_SCOPE_FLAG_MAP
+            tmux_args += (OPTION_SCOPE_FLAG_MAP[scope],)
+
+        cmd = self.cmd("show-pane-options", *tmux_args)
+
+        output = cmd.stdout
+
+        pane_options: "PaneOptionDict" = {}
+        for item in output:
+            key, val = shlex.split(item)
+            assert isinstance(key, str)
+            assert isinstance(val, str)
+
+            if isinstance(val, str) and val.isdigit():
+                pane_options[key] = int(val)
+
+        return pane_options
+
+    def show_option(
+        self,
+        option: str,
+        g: bool = False,
+        scope: t.Optional[OptionScope] = OptionScope.Pane,
+    ) -> t.Optional[t.Union[str, int]]:
+        """Return a list of options for the pane.
+
+        todo: test and return True/False for on/off string
+
+        Parameters
+        ----------
+        option : str
+        g : bool, optional
+            Pass ``-g`` flag, global. Default False.
+
+        Raises
+        ------
+        :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
+        :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
+        """
+        tmux_args: t.Tuple[t.Union[str, int], ...] = ()
+
+        if g:
+            tmux_args += ("-g",)
+
+        tmux_args += (option,)
+
+        cmd = self.cmd("show-options", *tmux_args)
+
+        if len(cmd.stderr):
+            handle_option_error(cmd.stderr[0])
+
+        pane_options_output = cmd.stdout
+
+        if not len(pane_options_output):
+            return None
+
+        value_raw = next(shlex.split(item) for item in pane_options_output)
+
+        value: t.Union[str, int] = (
+            int(value_raw[1]) if value_raw[1].isdigit() else value_raw[1]
+        )
+
+        return value
+
     """
     Commands (helpers)
     """
diff --git a/src/libtmux/session.py b/src/libtmux/session.py
index 9ea495779..bf8eab5c0 100644
--- a/src/libtmux/session.py
+++ b/src/libtmux/session.py
@@ -11,7 +11,8 @@
 import warnings
 
 from libtmux._internal.query_list import QueryList
-from libtmux.common import tmux_cmd
+from libtmux.common import OptionMixin, tmux_cmd
+from libtmux.constants import OptionScope
 from libtmux.formats import FORMAT_SEPARATOR
 from libtmux.neo import Obj, fetch_obj, fetch_objs
 from libtmux.pane import Pane
@@ -21,7 +22,6 @@
 from .common import (
     EnvironmentMixin,
     WindowDict,
-    handle_option_error,
     has_gte_version,
     has_version,
     session_check_name,
@@ -35,7 +35,7 @@
 
 
 @dataclasses.dataclass()
-class Session(Obj, EnvironmentMixin):
+class Session(Obj, EnvironmentMixin, OptionMixin):
     """:term:`tmux(1)` :term:`Session` [session_manual]_.
 
     Holds :class:`Window` objects.
@@ -71,6 +71,7 @@ class Session(Obj, EnvironmentMixin):
        https://man.openbsd.org/tmux.1#DESCRIPTION. Accessed April 1st, 2018.
     """
 
+    default_scope: OptionScope | None = None
     server: "Server"
 
     def refresh(self) -> None:
@@ -170,155 +171,6 @@ def cmd(self, *args: t.Any, **kwargs: t.Any) -> tmux_cmd:
     Commands (tmux-like)
     """
 
-    def set_option(
-        self,
-        option: str,
-        value: t.Union[str, int],
-        _global: bool = False,
-    ) -> "Session":
-        """Set option ``$ tmux set-option <option> <value>``.
-
-        Parameters
-        ----------
-        option : str
-            the window option. such as 'default-shell'.
-        value : str, int, or bool
-            True/False will turn in 'on' and 'off'. You can also enter 'on' or
-            'off' directly.
-        _global : bool, optional
-            check for option globally across all servers (-g)
-
-        Raises
-        ------
-        :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
-        :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
-
-        Notes
-        -----
-        .. todo::
-
-            Needs tests
-        """
-        if isinstance(value, bool) and value:
-            value = "on"
-        elif isinstance(value, bool) and not value:
-            value = "off"
-
-        tmux_args: t.Tuple[t.Union[str, int], ...] = ()
-
-        if _global:
-            tmux_args += ("-g",)
-
-        assert isinstance(option, str)
-        assert isinstance(value, (str, int))
-
-        tmux_args += (
-            option,
-            value,
-        )
-
-        proc = self.cmd("set-option", *tmux_args)
-
-        if isinstance(proc.stderr, list) and len(proc.stderr):
-            handle_option_error(proc.stderr[0])
-
-        return self
-
-    def show_options(
-        self,
-        _global: t.Optional[bool] = False,
-    ) -> t.Dict[str, t.Union[str, int]]:
-        """Return dict of options for the session.
-
-        Parameters
-        ----------
-        _global : bool, optional
-            Pass ``-g`` flag for global variable (server-wide)
-
-        Returns
-        -------
-        :py:obj:`dict`
-
-        Notes
-        -----
-        Uses ``_global`` for keyword name instead of ``global`` to avoid
-        colliding with reserved keyword.
-        """
-        tmux_args: t.Tuple[str, ...] = ()
-
-        if _global:
-            tmux_args += ("-g",)
-
-        tmux_args += ("show-options",)
-        session_output = self.cmd(*tmux_args).stdout
-
-        session_options: t.Dict[str, t.Union[str, int]] = {}
-        for item in session_output:
-            key, val = item.split(" ", maxsplit=1)
-            assert isinstance(key, str)
-            assert isinstance(val, str)
-
-            if isinstance(val, str) and val.isdigit():
-                session_options[key] = int(val)
-
-        return session_options
-
-    def show_option(
-        self,
-        option: str,
-        _global: bool = False,
-    ) -> t.Optional[t.Union[str, int, bool]]:
-        """Return option value for the target session.
-
-        Parameters
-        ----------
-        option : str
-            option name
-        _global : bool, optional
-            use global option scope, same as ``-g``
-
-        Returns
-        -------
-        str, int, or bool
-
-        Raises
-        ------
-        :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
-        :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
-
-        Notes
-        -----
-        Uses ``_global`` for keyword name instead of ``global`` to avoid
-        colliding with reserved keyword.
-
-        Test and return True/False for on/off string.
-        """
-        tmux_args: t.Tuple[str, ...] = ()
-
-        if _global:
-            tmux_args += ("-g",)
-
-        tmux_args += (option,)
-
-        cmd = self.cmd("show-options", *tmux_args)
-
-        if isinstance(cmd.stderr, list) and len(cmd.stderr):
-            handle_option_error(cmd.stderr[0])
-
-        if not len(cmd.stdout):
-            return None
-
-        value_raw: t.List[str] = next(item.split(" ") for item in cmd.stdout)
-
-        assert isinstance(value_raw[0], str)
-        assert isinstance(value_raw[1], str)
-
-        value: t.Union[str, int] = (
-            int(value_raw[1]) if value_raw[1].isdigit() else value_raw[1]
-        )
-
-        return value
-
     def select_window(self, target_window: t.Union[str, int]) -> "Window":
         """Select window, return selected window.
 
diff --git a/src/libtmux/window.py b/src/libtmux/window.py
index 8283a0903..3b2960d30 100644
--- a/src/libtmux/window.py
+++ b/src/libtmux/window.py
@@ -13,11 +13,12 @@
 
 from libtmux._internal.query_list import QueryList
 from libtmux.common import has_gte_version, tmux_cmd
+from libtmux.constants import OptionScope
 from libtmux.neo import Obj, fetch_obj, fetch_objs
 from libtmux.pane import Pane
 
 from . import exc
-from .common import PaneDict, WindowOptionDict, handle_option_error
+from .common import OptionMixin, PaneDict, WindowOptionDict
 from .formats import FORMAT_SEPARATOR
 
 if t.TYPE_CHECKING:
@@ -28,7 +29,14 @@
 
 
 @dataclasses.dataclass()
-class Window(Obj):
+class WindowOptions:
+    aggressive_resize: t.Optional[bool]
+    automatic_rename: t.Optional[bool]
+    automatic_rename_format: t.Optional[str]
+
+
+@dataclasses.dataclass()
+class Window(Obj, OptionMixin):
     """:term:`tmux(1)` :term:`Window` [window_manual]_.
 
     Holds :class:`Pane` objects.
@@ -76,6 +84,7 @@ class Window(Obj):
        https://man.openbsd.org/tmux.1#DESCRIPTION. Accessed April 1st, 2018.
     """
 
+    default_scope: OptionScope | None = None
     server: "Server"
 
     def refresh(self) -> None:
@@ -139,9 +148,11 @@ def cmd(self, cmd: str, *args: t.Any, **kwargs: t.Any) -> tmux_cmd:
         Specifying ``('-t', 'custom-target')`` or ``('-tcustom_target')`` in
         ``args`` will override using the object's ``window_id`` as target.
         """
-        if not any(arg.startswith("-t") for arg in args):
+        if not any("-t" in str(x) for x in args):
             args = ("-t", self.window_id, *args)
 
+        print(cmd, args, kwargs)
+
         return self.server.cmd(cmd, *args, **kwargs)
 
     """
@@ -326,123 +337,55 @@ def select_layout(self, layout: t.Optional[str] = None) -> "Window":
 
         return self
 
-    def set_window_option(self, option: str, value: t.Union[int, str]) -> "Window":
-        """Set option for tmux window.
+    def set_window_option(
+        self,
+        option: str,
+        value: t.Union[int, str],
+    ) -> "Window":
+        """Set option for tmux window. Deprecated by :meth:`Window.set_option()`.
 
-        Wraps ``$ tmux set-window-option <option> <value>``.
+        .. deprecated:: 0.26
 
-        Parameters
-        ----------
-        option : str
-            option to set, e.g. 'aggressive-resize'
-        value : str
-            window option value. True/False will turn in 'on' and 'off',
-            also accepts string of 'on' or 'off' directly.
+           Deprecated by :meth:`Window.set_option()`.
 
-        Raises
-        ------
-        :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
-        :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
         """
-        if isinstance(value, bool) and value:
-            value = "on"
-        elif isinstance(value, bool) and not value:
-            value = "off"
+        warnings.warn("Window.set_window_option() is deprecated", stacklevel=2)
 
-        cmd = self.cmd(
-            "set-window-option",
-            f"-t{self.session_id}:{self.window_index}",
-            option,
-            value,
-        )
-
-        if isinstance(cmd.stderr, list) and len(cmd.stderr):
-            handle_option_error(cmd.stderr[0])
-
-        return self
+        return self.set_option(option=option, value=value)
 
     def show_window_options(self, g: t.Optional[bool] = False) -> "WindowOptionDict":
-        """Return dict of options for window.
+        """Show options for tmux window. Deprecated by :meth:`Window.show_options()`.
 
-        .. versionchanged:: 0.13.0
+        .. deprecated:: 0.26
 
-           ``option`` removed, use show_window_option to return an individual option.
+           Deprecated by :meth:`Window.show_options()`.
 
-        Parameters
-        ----------
-        g : str, optional
-            Pass ``-g`` flag for global variable, default False.
         """
-        tmux_args: t.Tuple[str, ...] = ()
-
-        if g:
-            tmux_args += ("-g",)
-
-        tmux_args += ("show-window-options",)
-        cmd = self.cmd(*tmux_args)
-
-        output = cmd.stdout
-
-        # The shlex.split function splits the args at spaces, while also
-        # retaining quoted sub-strings.
-        #   shlex.split('this is "a test"') => ['this', 'is', 'a test']
-
-        window_options: "WindowOptionDict" = {}
-        for item in output:
-            key, val = shlex.split(item)
-            assert isinstance(key, str)
-            assert isinstance(val, str)
-
-            if isinstance(val, str) and val.isdigit():
-                window_options[key] = int(val)
-
-        return window_options
+        warnings.warn("Window.show_window_options() is deprecated", stacklevel=2)
+        return self.show_options(
+            g=g,
+            scope=OptionScope.Window,
+        )
 
     def show_window_option(
         self,
         option: str,
         g: bool = False,
     ) -> t.Optional[t.Union[str, int]]:
-        """Return option value for the target window.
+        """Return option for target window. Deprecated by :meth:`Window.show_option()`.
 
-        todo: test and return True/False for on/off string
+        .. deprecated:: 0.26
 
-        Parameters
-        ----------
-        option : str
-        g : bool, optional
-            Pass ``-g`` flag, global. Default False.
+           Deprecated by :meth:`Window.show_option()`.
 
-        Raises
-        ------
-        :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
-        :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
         """
-        tmux_args: t.Tuple[t.Union[str, int], ...] = ()
-
-        if g:
-            tmux_args += ("-g",)
-
-        tmux_args += (option,)
-
-        cmd = self.cmd("show-window-options", *tmux_args)
-
-        if len(cmd.stderr):
-            handle_option_error(cmd.stderr[0])
-
-        window_options_output = cmd.stdout
-
-        if not len(window_options_output):
-            return None
-
-        value_raw = next(shlex.split(item) for item in window_options_output)
-
-        value: t.Union[str, int] = (
-            int(value_raw[1]) if value_raw[1].isdigit() else value_raw[1]
+        warnings.warn("Window.show_window_option() is deprecated", stacklevel=2)
+        return self.show_option(
+            option=option,
+            g=g,
+            scope=OptionScope.Window,
         )
 
-        return value
-
     def rename_window(self, new_name: str) -> "Window":
         """Rename window.
 
@@ -461,8 +404,6 @@ def rename_window(self, new_name: str) -> "Window":
         >>> window.rename_window('New name')
         Window(@1 1:New name, Session($1 ...))
         """
-        import shlex
-
         lex = shlex.shlex(new_name)
         lex.escape = " "
         lex.whitespace_split = False
diff --git a/tests/legacy_api/test_window.py b/tests/legacy_api/test_window.py
index 924049d0f..ccb03a6c9 100644
--- a/tests/legacy_api/test_window.py
+++ b/tests/legacy_api/test_window.py
@@ -211,8 +211,8 @@ def test_show_window_options(session: Session) -> None:
     assert isinstance(options, dict)
 
 
-def test_set_show_window_options(session: Session) -> None:
-    """Set option then Window.show_window_options(key)."""
+def test_set_window_and_show_window_options(session: Session) -> None:
+    """Window.set_window_option() then Window.show_window_options(key)."""
     window = session.new_window(window_name="test_window")
 
     window.set_window_option("main-pane-height", 20)
@@ -227,6 +227,22 @@ def test_set_show_window_options(session: Session) -> None:
         assert window.show_window_option("pane-border-format") == " #P "
 
 
+def test_set_and_show_options(session: Session) -> None:
+    """Window.set_option() then Window.show_options(key)."""
+    window = session.new_window(window_name="test_window")
+
+    window.set_option("main-pane-height", 20)
+    assert window.show_option("main-pane-height") == 20
+
+    window.set_option("main-pane-height", 40)
+    assert window.show_option("main-pane-height") == 40
+    assert window.show_options()["main-pane-height"] == 40
+
+    if has_gte_version("2.3"):
+        window.set_option("pane-border-format", " #P ")
+        assert window.show_option("pane-border-format") == " #P "
+
+
 def test_empty_window_option_returns_None(session: Session) -> None:
     """Verify unset window option returns None."""
     window = session.new_window(window_name="test_window")
diff --git a/tests/test_window.py b/tests/test_window.py
index 47ec07205..da80eadbe 100644
--- a/tests/test_window.py
+++ b/tests/test_window.py
@@ -9,6 +9,7 @@
 from libtmux import exc
 from libtmux._internal.query_list import ObjectDoesNotExist
 from libtmux.common import has_gte_version, has_lt_version
+from libtmux.constants import OptionScope
 from libtmux.pane import Pane
 from libtmux.server import Server
 from libtmux.session import Session
@@ -183,7 +184,7 @@ def test_window_rename(
     window_name_before = "test"
     window_name_after = "ha ha ha fjewlkjflwef"
 
-    session.set_option("automatic-rename", "off")
+    session.set_option("automatic-rename", "off", scope=None)
     window = session.new_window(window_name=window_name_before, attach=True)
 
     assert window == session.attached_window
@@ -222,9 +223,30 @@ def test_show_window_options(session: Session) -> None:
     options = window.show_window_options()
     assert isinstance(options, dict)
 
+    options_2 = window.show_options()
+    assert isinstance(options_2, dict)
+
+    pane_options = window.show_options(scope=OptionScope.Pane)
+    assert isinstance(pane_options, dict)
+
+    pane_options_global = window.show_options(scope=OptionScope.Pane, g=True)
+    assert isinstance(pane_options_global, dict)
+
+    window_options = window.show_options(scope=OptionScope.Window)
+    assert isinstance(window_options, dict)
+
+    window_options_global = window.show_options(scope=OptionScope.Window, g=True)
+    assert isinstance(window_options_global, dict)
+
+    server_options = window.show_options(scope=OptionScope.Server)
+    assert isinstance(server_options, dict)
+
+    server_options_global = window.show_options(scope=OptionScope.Server, g=True)
+    assert isinstance(server_options_global, dict)
+
 
-def test_set_show_window_options(session: Session) -> None:
-    """Set option then Window.show_window_options(key)."""
+def test_set_window_and_show_window_options(session: Session) -> None:
+    """Window.set_window_option() then Window.show_window_options(key)."""
     window = session.new_window(window_name="test_window")
 
     window.set_window_option("main-pane-height", 20)
@@ -239,6 +261,22 @@ def test_set_show_window_options(session: Session) -> None:
         assert window.show_window_option("pane-border-format") == " #P "
 
 
+def test_set_and_show_window_options(session: Session) -> None:
+    """Window.set_option() then Window.show_options(key)."""
+    window = session.new_window(window_name="test_window")
+
+    window.set_option("main-pane-height", 20)
+    assert window.show_option("main-pane-height") == 20
+
+    window.set_option("main-pane-height", 40)
+    assert window.show_option("main-pane-height") == 40
+    assert window.show_options()["main-pane-height"] == 40
+
+    if has_gte_version("2.3"):
+        window.set_option("pane-border-format", " #P ")
+        assert window.show_option("pane-border-format") == " #P "
+
+
 def test_empty_window_option_returns_None(session: Session) -> None:
     """Verify unset window option returns None."""
     window = session.new_window(window_name="test_window")