diff --git a/.ci/validate-rawterm.py b/.ci/validate-rawterm.py
new file mode 100755
index 0000000..2d07590
--- /dev/null
+++ b/.ci/validate-rawterm.py
@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+"""Validate rawterm and menuconfig on all platforms.
+
+Exercises rawterm Color/Style/Region compositing, Windows console API
+(GetStdHandle/SetConsoleMode), Unix termios terminal init/close, and
+menuconfig headless mode with style parsing.
+
+Run from the project root: python .ci/validate-rawterm.py
+"""
+
+import os
+import sys
+
+# Ensure the project root (CWD) is on the import path, since Python
+# adds the script's directory (.ci/) rather than CWD by default.
+sys.path.insert(0, os.getcwd())
+
+_IS_WINDOWS = os.name == "nt"
+
+
+def check_rawterm_units():
+    """rawterm Color, Style, Key, Box -- no terminal required."""
+    from rawterm import Style, Color, Key, Box, NAMED_COLORS
+
+    # Color construction and equality
+    c1 = Color.RED
+    c2 = Color.index(196)
+    c3 = Color.rgb(255, 0, 0)
+    assert c1 == Color.RED, "named color identity"
+    assert c2 == Color.index(196), "index color identity"
+    assert c3 == Color.rgb(255, 0, 0), "rgb color identity"
+    assert c1 != c2, "named vs index differ"
+    assert hash(c1) == hash(Color.RED), "color hash stable"
+    assert Color.DEFAULT == Color.DEFAULT, "DEFAULT identity"
+
+    # Style construction and attributes
+    s1 = Style(fg=c1, bg=Color.DEFAULT)
+    s2 = Style(fg=c1, bg=Color.DEFAULT, bold=True)
+    assert s1 != s2, "bold changes style"
+    assert s1 == Style(fg=c1, bg=Color.DEFAULT), "style equality"
+    assert s2.bold is True, "bold attribute"
+    assert s1.standout is False, "standout default"
+
+    # Key constants exist
+    for attr in (
+        "UP",
+        "DOWN",
+        "LEFT",
+        "RIGHT",
+        "HOME",
+        "END",
+        "PAGE_UP",
+        "PAGE_DOWN",
+        "BACKSPACE",
+        "DELETE",
+        "RESIZE",
+    ):
+        assert getattr(Key, attr) is not None, "Key." + attr
+
+    # Box-drawing constants are single characters
+    for attr in (
+        "HLINE",
+        "VLINE",
+        "ULCORNER",
+        "URCORNER",
+        "LLCORNER",
+        "LRCORNER",
+        "LTEE",
+        "RTEE",
+        "UARROW",
+        "DARROW",
+        "RARROW",
+    ):
+        ch = getattr(Box, attr)
+        assert isinstance(ch, str) and len(ch) == 1, "Box." + attr
+
+    # NAMED_COLORS has the 16 standard colors
+    for name in (
+        "black",
+        "red",
+        "green",
+        "yellow",
+        "blue",
+        "magenta",
+        "cyan",
+        "white",
+    ):
+        assert name in NAMED_COLORS, "missing " + name
+        assert "bright" + name in NAMED_COLORS, "missing bright" + name
+
+    print("rawterm unit checks passed")
+
+
+def _windows_has_console():
+    """Probe whether real Windows console handles are available.
+
+    Returns True if GetStdHandle/GetConsoleMode succeed on stdout,
+    meaning we have a native console (cmd/powershell) rather than a
+    mintty/MSYS2 PTY that lacks Win32 console handles.
+    """
+    if not _IS_WINDOWS:
+        return False
+    try:
+        import ctypes
+        from ctypes import wintypes
+
+        kernel32 = ctypes.windll.kernel32
+        handle = kernel32.GetStdHandle(-11)  # STD_OUTPUT_HANDLE
+        if handle == -1 or handle == 0:
+            return False
+        mode = wintypes.DWORD()
+        if not kernel32.GetConsoleMode(handle, ctypes.byref(mode)):
+            return False
+        return True
+    except (OSError, AttributeError):
+        return False
+
+
+def check_windows_console():
+    """Validate Windows console API at the ctypes level.
+
+    Tests GetStdHandle, GetConsoleMode, SetConsoleMode VT100 toggle
+    without entering alternate screen or changing terminal state
+    permanently.  Only runs on Windows with a real console.
+    """
+    if not _IS_WINDOWS:
+        print("Windows console checks skipped (not Windows)")
+        return
+
+    if not _windows_has_console():
+        print("Windows console checks skipped (no native console handle)")
+        return
+
+    import ctypes
+    from ctypes import wintypes
+
+    kernel32 = ctypes.windll.kernel32
+
+    # Validate stdout handle
+    STD_OUTPUT_HANDLE = -11
+    STD_INPUT_HANDLE = -10
+    stdout_h = kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
+    stdin_h = kernel32.GetStdHandle(STD_INPUT_HANDLE)
+    assert stdout_h not in (-1, 0, None), "invalid stdout handle"
+    assert stdin_h not in (-1, 0, None), "invalid stdin handle"
+
+    # Read current console modes
+    out_mode = wintypes.DWORD()
+    in_mode = wintypes.DWORD()
+    assert kernel32.GetConsoleMode(
+        stdout_h, ctypes.byref(out_mode)
+    ), "GetConsoleMode(stdout) failed"
+    assert kernel32.GetConsoleMode(
+        stdin_h, ctypes.byref(in_mode)
+    ), "GetConsoleMode(stdin) failed"
+
+    # Toggle VT100 output processing on, then restore
+    ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+    new_out = out_mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING
+    assert kernel32.SetConsoleMode(
+        stdout_h, new_out
+    ), "SetConsoleMode(stdout, VT100) failed"
+    # Restore original mode
+    assert kernel32.SetConsoleMode(
+        stdout_h, out_mode.value
+    ), "SetConsoleMode(stdout, restore) failed"
+
+    # Test VT100 input mode (may fail on older Windows -- not fatal)
+    ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200
+    new_in = (in_mode.value | ENABLE_VIRTUAL_TERMINAL_INPUT) & ~0x0007
+    vt_input_ok = kernel32.SetConsoleMode(stdin_h, new_in)
+    kernel32.SetConsoleMode(stdin_h, in_mode.value)  # always restore
+    print(
+        "  VT100 input: {}".format(
+            "supported" if vt_input_ok else "not supported (ReadConsoleInputW fallback)"
+        )
+    )
+
+    print("Windows console checks passed")
+
+
+def check_terminal_init():
+    """Terminal init/close -- full rawterm.Terminal lifecycle.
+
+    On Unix, requires a real TTY on stdin/stdout.
+    On Windows, requires native console handles (cmd/powershell, not
+    MSYS2/mintty).  The workflow uses 'shell: cmd' on Windows to
+    provide this.
+    """
+    from rawterm import Style, Color, Box
+
+    if _IS_WINDOWS:
+        can_init = _windows_has_console()
+    else:
+        can_init = os.isatty(sys.stdin.fileno()) and os.isatty(sys.stdout.fileno())
+
+    if not can_init:
+        reason = "no native console" if _IS_WINDOWS else "no TTY"
+        print("Terminal init/close skipped ({})".format(reason))
+        return
+
+    from rawterm import Terminal
+
+    term = Terminal()
+    assert term.width > 0, "terminal width"
+    assert term.height > 0, "terminal height"
+
+    # Create a region and verify compositing operations
+    reg = term.region(3, 10)
+    reg.fill(Style(fg=Color.WHITE, bg=Color.BLACK))
+    reg.write(0, 0, "test")
+    reg.write_char(1, 0, Box.HLINE)
+    assert reg._cells[0][0][0] == "t", "region write"
+    reg.clear()
+    assert reg._cells[0][0][0] == " ", "region clear"
+    reg.move(1, 2)
+    assert reg.y == 1 and reg.x == 2, "region move"
+    reg.resize(5, 20)
+    assert reg.height == 5 and reg.width == 20, "region resize"
+    term.update()
+    reg.close()
+    term.close()
+    print("Terminal init/close passed")
+
+
+def check_menuconfig_headless():
+    """menuconfig headless mode and style parsing."""
+    from rawterm import Style, Color
+    from kconfiglib import Kconfig
+    import menuconfig
+
+    kconf = Kconfig("examples/Kmenuconfig")
+    menuconfig.menuconfig(kconf, headless=True)
+
+    # Verify style parsing (exercises _parse_color, _style_from_def)
+    menuconfig._init_styles()
+    for key in (
+        "body",
+        "list",
+        "screen",
+        "frame",
+        "selection",
+        "border",
+        "title",
+        "edit",
+        "help",
+        "show-help",
+    ):
+        assert key in menuconfig._style, key + " style missing"
+        assert isinstance(menuconfig._style[key], Style), key + " type"
+
+    # Verify MENUCONFIG_STYLE env override (save/restore any existing value)
+    old_mstyle = os.environ.get("MENUCONFIG_STYLE")
+    os.environ["MENUCONFIG_STYLE"] = "selection=fg:red,bg:white,bold"
+    menuconfig._style.clear()
+    menuconfig._init_styles()
+    sel = menuconfig._style["selection"]
+    assert sel.fg == Color.RED, "MENUCONFIG_STYLE fg override"
+    assert sel.bg == Color.WHITE, "MENUCONFIG_STYLE bg override"
+    if old_mstyle is None:
+        del os.environ["MENUCONFIG_STYLE"]
+    else:
+        os.environ["MENUCONFIG_STYLE"] = old_mstyle
+
+    print("menuconfig headless + style validation passed")
+
+
+if __name__ == "__main__":
+    check_rawterm_units()
+    check_windows_console()
+    check_terminal_init()
+    check_menuconfig_headless()
+    print("All checks passed")
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index aa6a0ea..8fa1309 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -18,9 +18,9 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        # NOTE: Windows runs only headless + menuconfig import tests (no kernel
-        #       tree, no Unix shell). Linux/macOS run selftests, compatibility
-        #       tests, and example scripts.
+        # NOTE: Windows runs only headless tests (no kernel tree, no Unix
+        #       shell). Linux/macOS run selftests, compatibility tests, and
+        #       example scripts.
         target:
         # Python 3.12
         - python: '3.12'
@@ -94,27 +94,18 @@ jobs:
       run: |
         Kconfiglib/tests/reltest python
 
-    - name: Install windows-curses (Windows only)
-      if: matrix.target.os == 'Windows'
+    - name: Validate rawterm and menuconfig (Unix)
+      # Exercises rawterm Color/Style/Region compositing, terminal init/close
+      # (termios on Unix), and menuconfig headless mode with style parsing.
+      if: ${{ matrix.target.os != 'Windows' }}
+      working-directory: Kconfiglib
       run: |
-        python -m pip install windows-curses
+        python .ci/validate-rawterm.py
 
-    - name: Test headless mode
-      # Use root dir for Windows, Kconfiglib subdir for Linux/macOS
-      working-directory: ${{ matrix.target.headless-only && '.' || 'Kconfiglib' }}
-      run: |
-        python << 'EOF'
-        from kconfiglib import Kconfig
-        import menuconfig
-        print('Testing headless mode...')
-        kconf = Kconfig('examples/Kmenuconfig')
-        menuconfig.menuconfig(kconf, headless=True)
-        print('Headless mode test passed')
-        EOF
-
-    - name: Test menuconfig import (Windows Python 3.12)
-      if: matrix.target.os == 'Windows'
-      # Use root dir for Windows (headless-only mode)
-      working-directory: ${{ matrix.target.headless-only && '.' || 'Kconfiglib' }}
+    - name: Validate rawterm and menuconfig (Windows)
+      # On Windows, use cmd so Python gets real console handles (bash
+      # runs through MSYS2/mintty which lacks a native Windows console).
+      if: ${{ matrix.target.os == 'Windows' }}
+      shell: cmd
       run: |
-        python -c "import menuconfig; print('menuconfig import successful')"
+        python .ci/validate-rawterm.py
diff --git a/README.md b/README.md
index 3f2dfe3..65cf17a 100644
--- a/README.md
+++ b/README.md
@@ -86,9 +86,8 @@ Most changes thus far have addressed small issues introduced in the early days o
 ### Manual installation
 
 Just drop `kconfiglib.py` and the scripts you want somewhere.
-There are no third-party dependencies, but the terminal `menuconfig` will not work on Windows unless a package like
-[windows-curses](https://github.com/zephyrproject-rtos/windows-curses)
-is installed.
+There are no third-party dependencies.
+The terminal `menuconfig` uses a pure-Python terminal I/O module and works on all platforms without additional packages.
 
 ### Installation for the Linux kernel
 
@@ -345,7 +344,7 @@ This warning can also be toggled by setting `Kconfig.warn_assign_undef` to `True
 
 Three configuration interfaces are currently available:
 
-- [menuconfig.py](menuconfig.py) is a terminal-based configuration interface implemented using the standard Python `curses` module.
+- [menuconfig.py](menuconfig.py) is a terminal-based configuration interface using a pure-Python terminal I/O module.
   It includes `xconfig` features such as showing invisible symbols and symbol names,
   and it allows jumping directly to a symbol in the menu tree (even if it is currently invisible).
 
@@ -353,15 +352,7 @@ Three configuration interfaces are currently available:
 
   There is also a show-help mode that displays the help text of the currently selected symbol in the bottom help window.
 
-  `menuconfig.py` requires Python 3.6+.
-
-  There are no third-party dependencies on Unix-like systems.
-  On Windows, the `curses` module is not included by default, but can be added by installing the `windows-curses` package:
-  ```shell
-  pip install windows-curses
-  ```
-  These wheels are built from [this repository](https://github.com/zephyrproject-rtos/windows-curses),
-  which is based on Christoph Gohlke's [Python Extension Packages for Windows](https://www.cgohlke.com/#curses).
+  `menuconfig.py` requires Python 3.6+. No third-party dependencies or C extensions are needed on any platform.
 
   See the docstring at the top of [menuconfig.py](menuconfig.py) for more information about the terminal menuconfig implementation.
 
diff --git a/kconfiglib.py b/kconfiglib.py
index 8b9dc76..258c213 100644
--- a/kconfiglib.py
+++ b/kconfiglib.py
@@ -52,7 +52,7 @@
 make kmenuconfig
 ----------------
 
-This target runs the curses menuconfig interface with Python 3. As of
+This target runs the terminal menuconfig interface with Python 3. As of
 Kconfiglib 12.2.0, Python 3 (3.6+) is required.
 
 
diff --git a/menuconfig.py b/menuconfig.py
index c54e59f..55f6ee1 100755
--- a/menuconfig.py
+++ b/menuconfig.py
@@ -1,27 +1,30 @@
 #!/usr/bin/env python3
 
-# Copyright (c) 2018-2019 Nordic Semiconductor ASA and Ulf Magnusson
+# Copyright (c) 2018-2020 Nordic Semiconductor ASA and Ulf Magnusson
+# Copyright (c) 2024-2026 Kconfiglib contributors
 # SPDX-License-Identifier: ISC
 
 """
 Overview
 ========
 
-A curses-based menuconfig implementation. The interface should feel
-familiar to people used to mconf ('make menuconfig').
+A terminal-based menuconfig implementation using rawterm (pure-Python terminal
+I/O). The interface should feel familiar to people used to mconf
+('make menuconfig').
 
 Supports the same keys as mconf, and also supports a set of keybindings
 inspired by Vi:
 
-  J/K     : Down/Up
-  L       : Enter menu/Toggle item
-  H       : Leave menu
-  Ctrl-D/U: Page Down/Page Up
-  G/End   : Jump to end of list
-  g/Home  : Jump to beginning of list
+  J/K      : Down/Up
+  L        : Enter menu/Toggle item
+  H        : Leave menu
+  Ctrl-D/U : Page Down/Page Up
+  G/End    : Jump to end of list
+  g/Home   : Jump to beginning of list
 
-[Space] toggles values if possible, and enters menus otherwise. [Enter] works
-the other way around.
+The bottom of the dialog shows five buttons: Select, Exit, Help, Save, Load.
+[Tab]/[Left]/[Right] cycle between buttons. [Enter] activates the focused
+button. [Space] toggles values if possible, and enters menus otherwise.
 
 The mconf feature where pressing a key jumps to a menu entry with that
 character in it in the current menu isn't supported. A jump-to feature for
@@ -76,6 +79,7 @@
 It is possible to customize the current style by changing colors of UI
 elements on the screen. This is the list of elements that can be stylized:
 
+    - screen        Full-screen background behind the dialog
     - path          Top row in the main display, with the menu path
     - separator     Separator lines between windows. Also used for the top line
                     in the symbol information display.
@@ -87,11 +91,15 @@
     - help          Help text windows at the bottom of various fullscreen
                     dialogs
     - show-help     Window showing the help text in show-help mode
-    - frame         Frame around dialog boxes
-    - body          Body of dialog boxes
+    - frame         Frame around pop-up dialog boxes
+    - body          Body of the main dialog
     - edit          Edit box in pop-up dialogs
     - jump-edit     Edit box in jump-to dialog
     - text          Symbol information text
+    - title         Dialog title text
+    - border        Border of the main dialog box
+    - menubox       Inner menu box border (left/top edges)
+    - menubox-border Inner menu box border (right/bottom edges and fill)
 
 The color definition is a comma separated list of attributes:
 
@@ -101,16 +109,14 @@
                     brightred). On terminals that support more than 8 colors,
                     you can also directly put in a color number, e.g. fg:123
                     (hexadecimal and octal constants are accepted as well).
-                    Colors outside the range -1..curses.COLORS-1 (which is
-                    terminal-dependent) are ignored (with a warning). The COLOR
-                    can be also specified using a RGB value in the HTML
-                    notation, for example #RRGGBB. If the terminal supports
-                    color changing, the color is rendered accurately.
-                    Otherwise, the visually nearest color is used.
+                    Colors outside the range -1..255 are ignored (with a
+                    warning). The COLOR can be also specified using a RGB
+                    value in the HTML notation, for example #RRGGBB. The
+                    color is rendered using the closest available
+                    representation for the terminal.
 
                     If the background or foreground color of an element is not
-                    specified, it defaults to -1, representing the default
-                    terminal foreground or background color.
+                    specified, it defaults to the terminal default color.
 
                     Note: On some terminals a bright version of the color
                     implies bold.
@@ -142,8 +148,7 @@
     MENUCONFIG_STYLE="linux selection=fg:white,bg:red"
 
 If the terminal doesn't support colors, the 'monochrome' theme is used, and
-MENUCONFIG_STYLE is ignored. The assumption is that the environment is broken
-somehow, and that the important thing is to get something usable.
+MENUCONFIG_STYLE is ignored.
 
 
 Other features
@@ -151,8 +156,8 @@
 
   - Seamless terminal resizing
 
-  - No dependencies on *nix, as the 'curses' module is in the Python standard
-    library
+  - No curses dependency -- uses rawterm, a pure-Python terminal I/O module.
+    Works on Unix and Windows 10+ without any pip install.
 
   - Unicode text entry
 
@@ -170,16 +175,6 @@
       * The include path is shown, listing the locations of the 'source'
         statements that included the Kconfig file of the symbol (or other
         item)
-
-
-Limitations
-===========
-
-Doesn't work out of the box on Windows, but can be made to work with
-
-    pip install windows-curses
-
-See the https://github.com/zephyrproject-rtos/windows-curses repository.
 """
 
 import os
@@ -187,15 +182,14 @@
 
 _IS_WINDOWS = os.name == "nt"  # Are we running on Windows?
 
-# Defer curses import to runtime - it will be imported by _ensure_curses()
-# when menuconfig() is called. This avoids import errors in headless CI/CD
-# environments where menuconfig UI is not used.
-
 import errno
 import locale
 import re
 import textwrap
 
+import rawterm
+from rawterm import Key, Box, Style, Color, NAMED_COLORS
+
 from kconfiglib import (
     Symbol,
     Choice,
@@ -226,8 +220,8 @@
 #
 
 # If True, try to change LC_CTYPE to a UTF-8 locale if it is set to the C
-# locale (which implies ASCII). This fixes curses Unicode I/O issues on systems
-# with bad defaults. ncurses configures itself from the locale settings.
+# locale (which implies ASCII). This fixes Unicode I/O issues on systems with
+# bad defaults.
 #
 # Related PEP: https://www.python.org/dev/peps/pep-0538/
 _CHANGE_C_LC_CTYPE_TO_UTF8 = True
@@ -254,13 +248,20 @@
 # Number of arrows pointing up/down to draw when a window is scrolled
 _N_SCROLL_ARROWS = 14
 
-# Lines of help text shown at the bottom of the "main" display
-_MAIN_HELP_LINES = """
-[Space/Enter] Toggle/enter  [ESC] Leave menu           [S] Save
-[O] Load                    [?] Symbol info            [/] Jump to symbol
-[F] Toggle show-help mode   [C] Toggle show-name mode  [A] Toggle show-all mode
-[Q] Quit (prompts for save) [D] Save minimal config (advanced)
-"""[1:-1].split("\n")
+# Instruction text shown inside the mconf-style dialog, above the menu box.
+# Matches the menu_instructions[] string in mconf/mconf.c.
+_MENU_INSTRUCTIONS = (
+    "Arrow keys navigate the menu.  "
+    "<Enter> selects submenus ---> (or empty submenus ----).  "
+    "Highlighted letters are hotkeys.  "
+    "Pressing <Y> includes, <N> excludes, <M> modularizes features.  "
+    "Press <Esc><Esc> to exit, <?> for Help, </> for Search.  "
+    "Legend: [*] built-in  [ ] excluded  <M> module  < > module capable"
+)
+
+# Button labels for the main menu (matching mconf/lxdialog/menubox.c
+# print_buttons()).  Spaces in labels provide visual padding.
+_MENU_BUTTONS = ["Select", " Exit ", " Help ", " Save ", " Load "]
 
 # Lines of help text shown at the bottom of the information dialog
 _INFO_HELP_LINES = """
@@ -284,6 +285,7 @@
     # Style matching the Linux kernel's menuconfig (mconf/lxdialog)
     # Precisely matches lxdialog's set_bluetitle_theme() and set_classic_theme()
     "linux": """
+    screen=fg:cyan,bg:blue,bold
     path=fg:white,bg:blue,bold
     separator=fg:white,bg:blue
     list=fg:black,bg:white
@@ -297,18 +299,23 @@
     edit=fg:black,bg:white
     jump-edit=fg:black,bg:white
     text=fg:black,bg:white
+    title=fg:blue,bg:white,bold
+    border=fg:white,bg:white,bold
+    menubox=fg:black,bg:white
+    menubox-border=fg:white,bg:white,bold
     shadow=fg:black,bg:black,bold
-    button-active=fg:black,bg:white
-    button-inactive=fg:white,bg:blue,bold
-    button-key-active=fg:red,bg:white
-    button-key-inactive=fg:white,bg:blue,bold
-    button-label-active=fg:black,bg:white,bold
-    button-label-inactive=fg:yellow,bg:blue,bold
+    button-active=fg:white,bg:blue,bold
+    button-inactive=fg:black,bg:white
+    button-key-active=fg:yellow,bg:blue,bold
+    button-key-inactive=fg:red,bg:white
+    button-label-active=fg:white,bg:blue,bold
+    button-label-inactive=fg:black,bg:white,bold
     dialog=fg:black,bg:white
     dialog-frame=fg:white,bg:blue,bold
     """,
     # This style is forced on terminals that do not support colors
     "monochrome": """
+    screen=bold
     path=bold
     separator=bold,standout
     list=
@@ -322,199 +329,62 @@
     edit=standout
     jump-edit=
     text=
+    title=bold
+    border=bold
+    menubox=
+    menubox-border=bold
     """,
 }
 
-# Curses module - will be imported by _ensure_curses()
-curses = None
-
-# Named colors cache - will be initialized by _get_named_colors()
-_named_colors_cache = None
-
-
-def _get_named_colors():
-    """Returns the named colors dictionary. Initializes it on first call."""
-    global _named_colors_cache
-    if _named_colors_cache is None:
-        _named_colors_cache = {
-            # Basic colors
-            "black": curses.COLOR_BLACK,
-            "red": curses.COLOR_RED,
-            "green": curses.COLOR_GREEN,
-            "yellow": curses.COLOR_YELLOW,
-            "blue": curses.COLOR_BLUE,
-            "magenta": curses.COLOR_MAGENTA,
-            "cyan": curses.COLOR_CYAN,
-            "white": curses.COLOR_WHITE,
-            # Bright versions
-            "brightblack": curses.COLOR_BLACK + 8,
-            "brightred": curses.COLOR_RED + 8,
-            "brightgreen": curses.COLOR_GREEN + 8,
-            "brightyellow": curses.COLOR_YELLOW + 8,
-            "brightblue": curses.COLOR_BLUE + 8,
-            "brightmagenta": curses.COLOR_MAGENTA + 8,
-            "brightcyan": curses.COLOR_CYAN + 8,
-            "brightwhite": curses.COLOR_WHITE + 8,
-            # Aliases
-            "purple": curses.COLOR_MAGENTA,
-            "brightpurple": curses.COLOR_MAGENTA + 8,
-        }
-    return _named_colors_cache
-
-
-def _rgb_to_6cube(rgb):
-    # Converts an 888 RGB color to a 3-tuple (nice in that it's hashable)
-    # representing the closest xterm 256-color 6x6x6 color cube color.
-    #
-    # The xterm 256-color extension uses a RGB color palette with components in
-    # the range 0-5 (a 6x6x6 cube). The catch is that the mapping is nonlinear.
-    # Index 0 in the 6x6x6 cube is mapped to 0, index 1 to 95, then 135, 175,
-    # etc., in increments of 40. See the links below:
-    #
-    #   https://commons.wikimedia.org/wiki/File:Xterm_256color_chart.svg
-    #   https://github.com/tmux/tmux/blob/master/colour.c
-
-    # 48 is the middle ground between 0 and 95.
-    return tuple(0 if x < 48 else int(round(max(1, (x - 55) / 40))) for x in rgb)
-
-
-def _6cube_to_rgb(r6g6b6):
-    # Returns the 888 RGB color for a 666 xterm color cube index
-
-    return tuple(0 if x == 0 else 40 * x + 55 for x in r6g6b6)
-
-
-def _rgb_to_gray(rgb):
-    # Converts an 888 RGB color to the index of an xterm 256-color grayscale
-    # color with approx. the same perceived brightness
-
-    # Calculate the luminance (gray intensity) of the color. See
-    #   https://stackoverflow.com/questions/596216/formula-to-determine-brightness-of-rgb-color
-    # and
-    #   https://www.w3.org/TR/AERT/#color-contrast
-    luma = 0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2]
-
-    # Closest index in the grayscale palette, which starts at RGB 0x080808,
-    # with stepping 0x0A0A0A
-    index = int(round((luma - 8) / 10))
-
-    # Clamp the index to 0-23, corresponding to 232-255
-    return max(0, min(index, 23))
 
-
-def _gray_to_rgb(index):
-    # Convert a grayscale index to its closet single RGB component
-
-    return 3 * (10 * index + 8,)  # Returns a 3-tuple
-
-
-# Obscure Python: We never pass a value for rgb2index, and it keeps pointing to
-# the same dict. This avoids a global.
-def _alloc_rgb(rgb, rgb2index={}):
-    # Initialize a new entry in the xterm palette to the given RGB color,
-    # returning its index. If the color has already been initialized, the index
-    # of the existing entry is returned.
-    #
-    # ncurses is palette-based, so we need to overwrite palette entries to make
-    # new colors.
-    #
-    # The colors from 0 to 15 are user-defined, and there's no way to query
-    # their RGB values, so we better leave them untouched. Also leave any
-    # hypothetical colors above 255 untouched (though we're unlikely to
-    # allocate that many colors anyway).
-
-    if rgb in rgb2index:
-        return rgb2index[rgb]
-
-    # Many terminals allow the user to customize the first 16 colors. Avoid
-    # changing their values.
-    color_index = 16 + len(rgb2index)
-    if color_index >= 256:
-        _warn(
-            "Unable to allocate new RGB color ", rgb, ". Too many colors " "allocated."
+def _parse_color(color_def):
+    """Parse a color definition string, returning a rawterm.Color."""
+    # HTML format, #RRGGBB
+    if re.match("^#[A-Fa-f0-9]{6}$", color_def):
+        return Color.rgb(
+            int(color_def[1:3], 16),
+            int(color_def[3:5], 16),
+            int(color_def[5:7], 16),
         )
-        return 0
 
-    # Map each RGB component from the range 0-255 to the range 0-1000, which is
-    # what curses uses
-    curses.init_color(color_index, *(int(round(1000 * x / 255)) for x in rgb))
-    rgb2index[rgb] = color_index
+    if color_def in NAMED_COLORS:
+        return NAMED_COLORS[color_def]
 
-    return color_index
+    try:
+        num = int(color_def, 0)
+        if 0 <= num <= 255:
+            return Color.index(num)
+        _warn("Ignoring color {} outside range 0..255".format(color_def))
+        return Color.DEFAULT
+    except ValueError:
+        _warn("Ignoring color", color_def, "that's neither predefined nor a number")
+        return Color.DEFAULT
 
 
-def _color_from_num(num):
-    # Returns the index of a color that looks like color 'num' in the xterm
-    # 256-color palette (but that might not be 'num', if we're redefining
-    # colors)
+def _style_from_def(style_def):
+    """Parse a style definition string, returning a rawterm.Style."""
+    fg = Color.DEFAULT
+    bg = Color.DEFAULT
+    bold = False
+    standout = False
+    underline = False
 
-    # - _alloc_rgb() won't touch the first 16 colors or any (hypothetical)
-    #   colors above 255, so we can always return them as-is
-    #
-    # - If the terminal doesn't support changing color definitions, or if
-    #   curses.COLORS < 256, _alloc_rgb() won't touch any color, and all colors
-    #   can be returned as-is
-    if num < 16 or num > 255 or not curses.can_change_color() or curses.COLORS < 256:
-        return num
-
-    # _alloc_rgb() might redefine colors, so emulate the xterm 256-color
-    # palette by allocating new colors instead of returning color numbers
-    # directly
-
-    if num < 232:
-        num -= 16
-        return _alloc_rgb(_6cube_to_rgb(((num // 36) % 6, (num // 6) % 6, num % 6)))
-
-    return _alloc_rgb(_gray_to_rgb(num - 232))
-
-
-def _color_from_rgb(rgb):
-    # Returns the index of a color matching the 888 RGB color 'rgb'. The
-    # returned color might be an ~exact match or an approximation, depending on
-    # terminal capabilities.
-
-    # Calculates the Euclidean distance between two RGB colors
-    def dist(r1, r2):
-        return sum((x - y) ** 2 for x, y in zip(r1, r2))
-
-    if curses.COLORS >= 256:
-        # Assume we're dealing with xterm's 256-color extension
-
-        if curses.can_change_color():
-            # Best case -- the terminal supports changing palette entries via
-            # curses.init_color(). Initialize an unused palette entry and
-            # return it.
-            return _alloc_rgb(rgb)
-
-        # Second best case -- pick between the xterm 256-color extension colors
-
-        # Closest 6-cube "color" color
-        c6 = _rgb_to_6cube(rgb)
-        # Closest gray color
-        gray = _rgb_to_gray(rgb)
-
-        if dist(rgb, _6cube_to_rgb(c6)) < dist(rgb, _gray_to_rgb(gray)):
-            # Use the "color" color from the 6x6x6 color palette. Calculate the
-            # color number from the 6-cube index triplet.
-            return 16 + 36 * c6[0] + 6 * c6[1] + c6[2]
-
-        # Use the color from the gray palette
-        return 232 + gray
-
-    # Terminal not in xterm 256-color mode. This is probably the best we can
-    # do, or is it? Submit patches. :)
-    min_dist = float("inf")
-    best = -1
-    for color in range(curses.COLORS):
-        # ncurses uses the range 0..1000. Scale that down to 0..255.
-        d = dist(
-            rgb, tuple(int(round(255 * c / 1000)) for c in curses.color_content(color))
-        )
-        if d < min_dist:
-            min_dist = d
-            best = color
+    if style_def:
+        for field in style_def.split(","):
+            if field.startswith("fg:"):
+                fg = _parse_color(field.split(":", 1)[1])
+            elif field.startswith("bg:"):
+                bg = _parse_color(field.split(":", 1)[1])
+            elif field == "bold":
+                bold = not _IS_WINDOWS
+            elif field == "standout":
+                standout = True
+            elif field == "underline":
+                underline = True
+            else:
+                _warn("Ignoring unknown style attribute", field)
 
-    return best
+    return Style(fg=fg, bg=bg, bold=bold, standout=standout, underline=underline)
 
 
 def _parse_style(style_str, parsing_default):
@@ -527,13 +397,9 @@ def _parse_style(style_str, parsing_default):
     # 'default'/'monochrome' style, to prevent warnings.
 
     for sline in style_str.split():
-        # Words without a "=" character represents a style template
         if "=" in sline:
             key, data = sline.split("=", 1)
 
-            # The 'default' style template is assumed to define all keys. We
-            # run _style_to_curses() for non-existing keys as well, so that we
-            # print warnings for errors to the right of '=' for those too.
             if key not in _style and not parsing_default:
                 _warn("Ignoring non-existent style", key)
 
@@ -541,134 +407,25 @@ def _parse_style(style_str, parsing_default):
             if data in _style:
                 _style[key] = _style[data]
             else:
-                _style[key] = _style_to_curses(data)
+                _style[key] = _style_from_def(data)
 
         elif sline in _STYLES:
-            # Recursively parse style template. Ignore styles that don't exist,
-            # for backwards/forwards compatibility.
             _parse_style(_STYLES[sline], parsing_default)
 
         else:
             _warn("Ignoring non-existent style template", sline)
 
 
-# Dictionary mapping element types to the curses attributes used to display
-# them
+# Dictionary mapping element names to rawterm.Style objects
 _style = {}
 
 
-def _style_to_curses(style_def):
-    # Parses a style definition string (<element>=<style>), returning
-    # a (fg_color, bg_color, attributes) tuple.
-
-    def parse_color(color_def):
-        color_def = color_def.split(":", 1)[1]
-
-        # HTML format, #RRGGBB
-        if re.match("^#[A-Fa-f0-9]{6}$", color_def):
-            return _color_from_rgb(
-                (
-                    int(color_def[1:3], 16),
-                    int(color_def[3:5], 16),
-                    int(color_def[5:7], 16),
-                )
-            )
-
-        named_colors = _get_named_colors()
-        if color_def in named_colors:
-            color_num = _color_from_num(named_colors[color_def])
-        else:
-            try:
-                color_num = _color_from_num(int(color_def, 0))
-            except ValueError:
-                _warn(
-                    "Ignoring color",
-                    color_def,
-                    "that's neither " "predefined nor a number",
-                )
-                return -1
-
-        if not -1 <= color_num < curses.COLORS:
-            _warn(
-                "Ignoring color {}, which is outside the range "
-                "-1..curses.COLORS-1 (-1..{})".format(color_def, curses.COLORS - 1)
-            )
-            return -1
-
-        return color_num
-
-    fg_color = -1
-    bg_color = -1
-    attrs = 0
-
-    if style_def:
-        for field in style_def.split(","):
-            if field.startswith("fg:"):
-                fg_color = parse_color(field)
-            elif field.startswith("bg:"):
-                bg_color = parse_color(field)
-            elif field == "bold":
-                # A_BOLD tends to produce faint and hard-to-read text on the
-                # Windows console, especially with the old color scheme, before
-                # the introduction of
-                # https://blogs.msdn.microsoft.com/commandline/2017/08/02/updating-the-windows-console-colors/
-                attrs |= curses.A_NORMAL if _IS_WINDOWS else curses.A_BOLD
-            elif field == "standout":
-                attrs |= curses.A_STANDOUT
-            elif field == "underline":
-                attrs |= curses.A_UNDERLINE
-            else:
-                _warn("Ignoring unknown style attribute", field)
-
-    return _style_attr(fg_color, bg_color, attrs)
-
-
 def _init_styles():
-    if curses.has_colors():
-        try:
-            curses.use_default_colors()
-        except curses.error:
-            # Ignore errors on funky terminals that support colors but not
-            # using default colors. Worst it can do is break transparency and
-            # the like. Ran across this with the MSYS2/winpty setup in
-            # https://github.com/msys2/MINGW-packages/issues/5823, though there
-            # seems to be a lot of general brokenness there.
-            pass
-
-        # Use the 'linux' theme as the base, and add any user-defined style
-        # settings from the environment
-        _parse_style("linux", True)
-        if "MENUCONFIG_STYLE" in os.environ:
-            _parse_style(os.environ["MENUCONFIG_STYLE"], False)
-    else:
-        # Force the 'monochrome' theme if the terminal doesn't support colors.
-        # MENUCONFIG_STYLE is likely to mess things up here (though any colors
-        # would be ignored), so ignore it.
-        _parse_style("monochrome", True)
-
-
-# color_attribs holds the color pairs we've already created, indexed by a
-# (<foreground color>, <background color>) tuple.
-#
-# Obscure Python: We never pass a value for color_attribs, and it keeps
-# pointing to the same dict. This avoids a global.
-def _style_attr(fg_color, bg_color, attribs, color_attribs={}):
-    # Returns an attribute with the specified foreground and background color
-    # and the attributes in 'attribs'. Reuses color pairs already created if
-    # possible, and creates a new color pair otherwise.
-    #
-    # Returns 'attribs' if colors aren't supported.
-
-    if not curses.has_colors():
-        return attribs
-
-    if (fg_color, bg_color) not in color_attribs:
-        # Create new color pair. Color pair number 0 is hardcoded and cannot be
-        # changed, hence the +1s.
-        curses.init_pair(len(color_attribs) + 1, fg_color, bg_color)
-        color_attribs[(fg_color, bg_color)] = curses.color_pair(len(color_attribs) + 1)
-
-    return color_attribs[(fg_color, bg_color)] | attribs
+    # Use the 'linux' theme as the base, and add any user-defined style
+    # settings from the environment
+    _parse_style("linux", True)
+    if "MENUCONFIG_STYLE" in os.environ:
+        _parse_style(os.environ["MENUCONFIG_STYLE"], False)
 
 
 #
@@ -676,39 +433,6 @@ def _style_attr(fg_color, bg_color, attribs, color_attribs={}):
 #
 
 
-def _ensure_curses():
-    """
-    Imports curses module if not already imported. This allows the module
-    to be imported in headless CI/CD environments without triggering import
-    errors, as long as menuconfig() is not called.
-    """
-    global curses
-    if curses is not None:
-        return
-
-    try:
-        import curses as curses_module
-
-        curses = curses_module
-    except ImportError as e:
-        if not _IS_WINDOWS:
-            raise
-        sys.exit("""\
-menuconfig failed to import the standard Python 'curses' library. Try
-installing a package like windows-curses
-(https://github.com/zephyrproject-rtos/windows-curses) by running this command
-in cmd.exe:
-
-    pip install windows-curses
-
-Starting with Kconfiglib 13.0.0, windows-curses is no longer automatically
-installed when installing Kconfiglib via pip on Windows (because it breaks
-installation on MSYS2).
-
-Exception:
-{}: {}""".format(type(e).__name__, e))
-
-
 def _main():
     menuconfig(standard_kconfig(__doc__))
 
@@ -726,10 +450,6 @@ def menuconfig(kconf, headless=False):
       processing. In headless mode, the function only loads the configuration
       and returns immediately without user interaction.
     """
-    # Import curses at runtime to avoid issues in headless environments
-    if not headless:
-        _ensure_curses()
-
     global _kconf
     global _conf_filename
     global _conf_changed
@@ -761,12 +481,12 @@ def menuconfig(kconf, headless=False):
             )
             return
 
-    # Disable warnings. They get mangled in curses mode, and we deal with
+    # Disable warnings. They get mangled in terminal mode, and we deal with
     # errors ourselves.
     kconf.warn = False
 
     try:
-        # Make curses use the locale settings specified in the environment
+        # Make the locale settings specified in the environment active
         locale.setlocale(locale.LC_ALL, "")
     except locale.Error:
         # fall back to the default locale
@@ -780,68 +500,9 @@ def menuconfig(kconf, headless=False):
     if headless:
         return
 
-    # Get rid of the delay between pressing ESC and jumping to the parent menu,
-    # unless the user has set ESCDELAY (see ncurses(3)). This makes the UI much
-    # smoother to work with.
-    #
-    # Note: This is strictly pretty iffy, since escape codes for e.g. cursor
-    # keys start with ESC, but I've never seen it cause problems in practice
-    # (probably because it's unlikely that the escape code for a key would get
-    # split up across read()s, at least with a terminal emulator). Please
-    # report if you run into issues. Some suitable small default value could be
-    # used here instead in that case. Maybe it's silly to not put in the
-    # smallest imperceptible delay here already, though I don't like guessing.
-    #
-    # (From a quick glance at the ncurses source code, ESCDELAY might only be
-    # relevant for mouse events there, so maybe escapes are assumed to arrive
-    # in one piece already...)
-    os.environ.setdefault("ESCDELAY", "0")
-
-    # Enter curses mode. _menuconfig() returns a string to print on exit, after
-    # curses has been de-initialized.
-    print(_wrapper(_menuconfig))
-
-
-def _wrapper(func):
-    # Workaround for windows-curses bug on Python 3.12+
-    # See: https://github.com/zephyrproject-rtos/windows-curses/issues/50
-    if os.name == "nt" and sys.version_info >= (3, 12):
-        stdscr = None
-        try:
-            import _curses
-        except ImportError:
-            # _curses not available, fall back to standard wrapper
-            return curses.wrapper(func)
-
-        try:
-            # setupterm() crashes on Python 3.12 with windows-curses
-            stdscr = _curses.initscr()
-
-            # Copy ACS_* and LINES/COLS to curses module
-            for key, value in _curses.__dict__.items():
-                if key.startswith("ACS_") or key in ("LINES", "COLS"):
-                    setattr(curses, key, value)
-
-            curses.noecho()
-            curses.cbreak()
-
-            try:
-                curses.start_color()
-            except curses.error:
-                # Color support not available
-                pass
-
-            if stdscr is not None:
-                stdscr.keypad(True)
-                return func(stdscr)
-        finally:
-            if stdscr is not None:
-                stdscr.keypad(False)
-            curses.echo()
-            curses.nocbreak()
-            curses.endwin()
-    else:
-        return curses.wrapper(func)
+    # Enter terminal mode via rawterm. _menuconfig() returns a string to print
+    # on exit.
+    print(rawterm.run(_menuconfig))
 
 
 def _load_config():
@@ -865,8 +526,8 @@ def _needs_save():
 
 # Global variables used below:
 #
-#   _stdscr:
-#     stdscr from curses
+#   _term:
+#     rawterm.Terminal instance
 #
 #   _cur_menu:
 #     Menu node of the menu (or menuconfig symbol, or choice) currently being
@@ -905,59 +566,109 @@ def _needs_save():
 #     from the save dialog.
 
 
-def _menuconfig(stdscr):
+def _menuconfig(term):
     # Logic for the main display, with the list of symbols, etc.
 
-    global _stdscr
+    global _term
     global _conf_filename
     global _conf_changed
     global _minconf_filename
     global _show_help
     global _show_name
+    global _active_button
 
-    _stdscr = stdscr
+    _term = term
 
     _init()
 
     while True:
         _draw_main()
-        curses.doupdate()
+        _term.update()
 
-        c = _getch_compat(_menu_win)
+        c = _term.read_key()
 
-        if c == curses.KEY_RESIZE:
+        if c == Key.RESIZE:
             _resize_main()
 
-        elif c in (curses.KEY_DOWN, "j", "J"):
+        #
+        # Menu item navigation (Up/Down/PgUp/PgDn/Home/End)
+        #
+
+        elif c in (Key.DOWN, "j", "J"):
             _select_next_menu_entry()
 
-        elif c in (curses.KEY_UP, "k", "K"):
+        elif c in (Key.UP, "k", "K"):
             _select_prev_menu_entry()
 
-        elif c in (curses.KEY_NPAGE, "\x04"):  # Page Down/Ctrl-D
-            # Keep it simple. This way we get sane behavior for small windows,
-            # etc., for free.
+        elif c in (Key.PAGE_DOWN, "\x04"):  # Page Down/Ctrl-D
             for _ in range(_PG_JUMP):
                 _select_next_menu_entry()
 
-        elif c in (curses.KEY_PPAGE, "\x15"):  # Page Up/Ctrl-U
+        elif c in (Key.PAGE_UP, "\x15"):  # Page Up/Ctrl-U
             for _ in range(_PG_JUMP):
                 _select_prev_menu_entry()
 
-        elif c in (curses.KEY_END, "G"):
+        elif c in (Key.END, "G"):
             _select_last_menu_entry()
 
-        elif c in (curses.KEY_HOME, "g"):
+        elif c in (Key.HOME, "g"):
             _select_first_menu_entry()
 
+        #
+        # Button navigation (Tab/Left/Right cycle buttons, matching mconf)
+        #
+
+        elif c == "\t" or c == Key.RIGHT:
+            _active_button = (_active_button + 1) % len(_MENU_BUTTONS)
+
+        elif c == Key.LEFT:
+            _active_button = (_active_button - 1) % len(_MENU_BUTTONS)
+
+        #
+        # Enter activates the currently focused button (matching mconf)
+        #
+
+        elif c == "\n":
+            if _active_button == 0:  # Select
+                sel_node = _shown[_sel_node_i]
+                if not _enter_menu(sel_node):
+                    _change_node(sel_node)
+
+            elif _active_button == 1:  # Exit
+                if _cur_menu is _kconf.top_node:
+                    res = _quit_dialog()
+                    if res:
+                        return res
+                else:
+                    _leave_menu()
+
+            elif _active_button == 2:  # Help
+                _info_dialog(_shown[_sel_node_i], False)
+                _resize_main()
+
+            elif _active_button == 3:  # Save
+                filename = _save_dialog(
+                    _kconf.write_config, _conf_filename, "configuration"
+                )
+                if filename:
+                    _conf_filename = filename
+                    _conf_changed = False
+
+            elif _active_button == 4:  # Load
+                _load_dialog()
+
+        #
+        # Direct item operations (matching mconf key codes)
+        #
+
         elif c == " ":
             # Toggle the node if possible
             sel_node = _shown[_sel_node_i]
             if not _change_node(sel_node):
                 _enter_menu(sel_node)
 
-        elif c in (curses.KEY_RIGHT, "\n", "l", "L"):
-            # Enter the node if possible
+        elif c in ("l", "L"):
+            # Vi: enter menu/toggle item
             sel_node = _shown[_sel_node_i]
             if not _enter_menu(sel_node):
                 _change_node(sel_node)
@@ -971,15 +682,8 @@ def _menuconfig(stdscr):
         elif c in ("y", "Y"):
             _set_sel_node_tri_val(2)
 
-        elif c in (
-            curses.KEY_LEFT,
-            curses.KEY_BACKSPACE,
-            _ERASE_CHAR,
-            "\x1b",
-            "h",
-            "H",
-        ):  # \x1B = ESC
-
+        elif c in (Key.BACKSPACE, "\x1b", "h", "H"):
+            # Leave menu (ESC/Backspace/Vi H)
             if c == "\x1b" and _cur_menu is _kconf.top_node:
                 res = _quit_dialog()
                 if res:
@@ -987,6 +691,15 @@ def _menuconfig(stdscr):
             else:
                 _leave_menu()
 
+        elif c in ("e", "x", "E", "X"):
+            # Exit (mconf: 'e' and 'x' trigger ESC behavior)
+            if _cur_menu is _kconf.top_node:
+                res = _quit_dialog()
+                if res:
+                    return res
+            else:
+                _leave_menu()
+
         elif c in ("o", "O"):
             _load_dialog()
 
@@ -1007,25 +720,20 @@ def _menuconfig(stdscr):
 
         elif c == "/":
             _jump_to_dialog()
-            # The terminal might have been resized while the fullscreen jump-to
-            # dialog was open
             _resize_main()
 
         elif c == "?":
             _info_dialog(_shown[_sel_node_i], False)
-            # The terminal might have been resized while the fullscreen info
-            # dialog was open
             _resize_main()
 
         elif c in ("f", "F"):
             _show_help = not _show_help
-            _set_style(_help_win, "show-help" if _show_help else "help")
             _resize_main()
 
         elif c in ("c", "C"):
             _show_name = not _show_name
 
-        elif c in ("a", "A"):
+        elif c in ("a", "A", "z", "Z"):
             _toggle_show_all()
 
         elif c in ("q", "Q"):
@@ -1074,15 +782,24 @@ def _quit_dialog():
 def _init():
     # Initializes the main display with the list of symbols, etc. Also does
     # misc. global initialization that needs to happen after initializing
-    # curses.
-
-    global _ERASE_CHAR
+    # the terminal.
+    #
+    # The layout matches mconf/lxdialog's dialog_menu():
+    #   _screen_win  - full screen background (cyan/blue)
+    #   _dialog_win  - centered dialog body (white, with border/title/
+    #                  instructions/inner menu box/separator/buttons)
+    #   _menu_win    - inner menu item area (positioned inside the dialog)
+    #   _help_win    - help text (show-help mode only)
+    #
+    # Shadow regions for the dialog are created in _resize_main().
 
-    global _path_win
-    global _top_sep_win
+    global _screen_win
+    global _dialog_win
     global _menu_win
-    global _bot_sep_win
     global _help_win
+    global _dlg_bottom_shadow
+    global _dlg_right_shadow
+    global _active_button
 
     global _parent_screen_rows
     global _cur_menu
@@ -1093,39 +810,32 @@ def _init():
     global _show_help
     global _show_name
 
-    # Looking for this in addition to KEY_BACKSPACE (which is unreliable) makes
-    # backspace work with TERM=vt100. That makes it likely to work in sane
-    # environments.
-    # erasechar() returns a one-byte bytes object. This sets _ERASE_CHAR to a
-    # blank string if it can't be decoded, which should be harmless.
-    _ERASE_CHAR = curses.erasechar().decode("utf-8", "ignore")
-
     _init_styles()
 
-    # Set stdscr background to match main list style
-    # This ensures areas not covered by subwindows have correct background
-    _stdscr.bkgd(" ", _style.get("list", 0))
-
     # Hide the cursor
-    _safe_curs_set(0)
+    _term.hide_cursor()
+
+    # Initialize regions -- creation order determines compositing order
+    # (painter's algorithm: later regions paint on top of earlier ones)
 
-    # Initialize windows
+    # Full-screen background (lowest layer)
+    _screen_win = _styled_region("screen")
 
-    # Top row, with menu path
-    _path_win = _styled_win("path")
+    # The main dialog body (above screen background)
+    _dialog_win = _styled_region("body")
 
-    # Separator below menu path, with title and arrows pointing up
-    _top_sep_win = _styled_win("separator")
+    # Inner menu item area (above dialog body)
+    _menu_win = _styled_region("list")
 
-    # List of menu entries with symbols, etc.
-    _menu_win = _styled_win("list")
-    _menu_win.keypad(True)
+    # Help text window for show-help mode (above dialog, initially hidden)
+    _help_win = _styled_region("show-help")
 
-    # Row below menu list, with arrows pointing down
-    _bot_sep_win = _styled_win("separator")
+    # Shadow regions -- created in _resize_main()
+    _dlg_bottom_shadow = None
+    _dlg_right_shadow = None
 
-    # Help window with keys at the bottom. Shows help texts in show-help mode.
-    _help_win = _styled_win("help")
+    # Currently focused button (0=Select, 1=Exit, 2=Help, 3=Save, 4=Load)
+    _active_button = 0
 
     # The rows we'd like the nodes in the parent menus to appear on. This
     # prevents the scroll from jumping around when going in and out of menus.
@@ -1139,68 +849,112 @@ def _init():
 
     _show_help = _show_name = False
 
-    # Give windows their initial size
+    # Give regions their initial size
     _resize_main()
 
 
 def _resize_main():
-    # Resizes the main display, with the list of symbols, etc., to fill the
-    # terminal
+    # Resizes the main display to match mconf/lxdialog's dialog_menu() layout.
+    #
+    # Layout (matching menubox.c):
+    #   Screen background (full terminal, cyan/blue):
+    #     Row 0: backtitle (mainmenu_text)
+    #     Row 1: subtitle path + hline
+    #   Shadow (right 2 cols + bottom 1 row of dialog)
+    #   Dialog (centered, white background):
+    #     Row 0:            top border with title
+    #     Rows 1..box_y-1:  instruction text
+    #     Row box_y:        inner menu box top border
+    #     Rows box_y+1...:  menu items (menu_height rows)
+    #     Row box_y+mh+1:   inner menu box bottom border
+    #     Row dlg_h-3:      separator (LTEE + HLINE + RTEE)
+    #     Row dlg_h-2:      buttons
+    #     Row dlg_h-1:      bottom border
+    #   Menu items region (_menu_win) overlaid inside the inner box
 
     global _menu_scroll
+    global _dlg_bottom_shadow
+    global _dlg_right_shadow
 
-    screen_height, screen_width = _stdscr.getmaxyx()
-
-    help_win_height = _SHOW_HELP_HEIGHT if _show_help else len(_MAIN_HELP_LINES)
+    screen_height = _term.height
+    screen_width = _term.width
 
-    # Screen layout:
-    # Row 0: _path_win, Row 1: _top_sep_win, Row 2+: _menu_win
-    # Row (2+menu_win_height): _bot_sep_win
-    # Row (2+menu_win_height+1): _help_win
-    # Total: 1 + 1 + menu_win_height + 1 + help_win_height = screen_height
-    menu_win_height = screen_height - help_win_height - 3
-    menu_win_width = screen_width
+    # Dialog dimensions -- matching mconf/lxdialog/menubox.c dialog_menu()
+    dlg_height = screen_height - 4
+    dlg_width = screen_width - 5
 
-    _path_win.resize(1, screen_width)
-    _top_sep_win.resize(1, menu_win_width)
+    # Clamp to minimum usable sizes
+    if dlg_height < 10:
+        dlg_height = max(screen_height - 2, 6)
+    if dlg_width < 40:
+        dlg_width = max(screen_width - 2, 20)
 
-    if menu_win_height >= 1:
-        _menu_win.resize(menu_win_height, menu_win_width)
-        _bot_sep_win.resize(1, menu_win_width)
-        # _help_win uses full screen width for blue background to extend to right edge
-        _help_win.resize(help_win_height, screen_width)
+    # Menu item area dimensions within the dialog
+    # mconf: menu_height = height - 10;  menu_width = width - 6;
+    menu_height = max(dlg_height - 10, 1)
+    menu_width = max(dlg_width - 6, 10)
 
-        _top_sep_win.mvwin(1, 0)
-        _menu_win.mvwin(2, 0)
-        _bot_sep_win.mvwin(2 + menu_win_height, 0)
-        _help_win.mvwin(2 + menu_win_height + 1, 0)
+    # In show-help mode, steal rows from the menu area for help text
+    help_in_dialog = 0
+    if _show_help:
+        help_in_dialog = min(_SHOW_HELP_HEIGHT, max(menu_height - 2, 0))
+        menu_height = max(menu_height - help_in_dialog, 1)
+
+    # Menu box position within dialog
+    # mconf: box_y = height - menu_height - 5;
+    #        box_x = (width - menu_width) / 2 - 1;
+    box_y = dlg_height - menu_height - 5 - help_in_dialog
+    box_x = (dlg_width - menu_width) // 2 - 1
+    if box_y < 1:
+        box_y = 1
+
+    # Center dialog on screen
+    dlg_y = (screen_height - dlg_height) // 2
+    dlg_x = (screen_width - dlg_width) // 2
+
+    # --- Resize and position regions ---
+
+    # Screen background
+    _screen_win.resize(screen_height, screen_width)
+    _screen_win.move(0, 0)
+    _screen_win.fill(_style["screen"])
+
+    # Dialog body
+    _dialog_win.resize(dlg_height, dlg_width)
+    _dialog_win.move(dlg_y, dlg_x)
+    _dialog_win.fill(_style["body"])
+
+    # Menu items (positioned inside the inner menu box of the dialog)
+    _menu_win.resize(menu_height, menu_width)
+    _menu_win.move(dlg_y + box_y + 1, dlg_x + box_x + 1)
+    _menu_win.fill(_style["list"])
+
+    # Help window -- positioned below inner menu box in show-help mode,
+    # or moved off-screen when not needed
+    if _show_help and help_in_dialog > 0:
+        help_y = dlg_y + box_y + menu_height + 2
+        _help_win.resize(help_in_dialog, menu_width)
+        _help_win.move(help_y, dlg_x + box_x + 1)
+        _help_win.fill(_style["show-help"])
     else:
-        # Degenerate case. Give up on nice rendering and just prevent errors.
-
-        menu_win_height = 1
+        _help_win.resize(1, 1)
+        _help_win.move(screen_height, 0)  # off-screen
 
-        _menu_win.resize(1, screen_width)
-        _help_win.resize(1, screen_width)
+    # Shadow regions for the dialog
+    _close_shadow_windows(_dlg_bottom_shadow, _dlg_right_shadow)
+    _dlg_bottom_shadow, _dlg_right_shadow = _create_shadow_for_win(_dialog_win)
 
-        for win in _top_sep_win, _menu_win, _bot_sep_win, _help_win:
-            win.mvwin(0, 0)
-
-    # Adjust the scroll so that the selected node is still within the window,
-    # if needed
-    if _sel_node_i - _menu_scroll >= menu_win_height:
-        _menu_scroll = _sel_node_i - menu_win_height + 1
+    # Adjust the scroll so that the selected node is still within the window
+    if _sel_node_i - _menu_scroll >= menu_height:
+        _menu_scroll = _sel_node_i - menu_height + 1
 
 
 def _height(win):
-    # Returns the height of 'win'
-
-    return win.getmaxyx()[0]
+    return win.height
 
 
 def _width(win):
-    # Returns the width of 'win'
-
-    return win.getmaxyx()[1]
+    return win.width
 
 
 def _enter_menu(menu):
@@ -1457,181 +1211,252 @@ def _center_vertically():
 
 
 def _draw_main():
-    # Draws the "main" display, with the list of symbols, the header, and the
-    # footer.
-    #
-    # This could be optimized to only update the windows that have actually
-    # changed, but keep it simple for now and let curses sort it out.
+    # Draws the mconf-style "main" display: screen background with path,
+    # centered dialog with title/instructions/inner menu box/buttons, and
+    # shadow.
 
-    term_width = _width(_stdscr)
+    screen_height = _term.height
+    screen_width = _term.width
+    dlg_h = _height(_dialog_win)
+    dlg_w = _width(_dialog_win)
 
-    #
-    # Update the separator row below the menu path
-    #
+    menu_height = _height(_menu_win)
+    menu_width = _width(_menu_win)
 
-    _top_sep_win.erase()
+    # --- Compute inner box position within the dialog ---
+    # These must match _resize_main() calculations.
+    help_in_dialog = 0
+    if _show_help:
+        help_in_dialog = min(_SHOW_HELP_HEIGHT, max(dlg_h - 10 - 2, 0))
+        # Recalculate menu_height for positioning only (actual size is from
+        # the _menu_win region).
+    box_y = dlg_h - menu_height - 5 - help_in_dialog
+    box_x = (dlg_w - menu_width) // 2 - 1
+    if box_y < 1:
+        box_y = 1
+
+    # item_x: indent of menu items within the inner box (matching mconf)
+    if menu_width >= 80:
+        item_x = (menu_width - 70) // 2
+    else:
+        item_x = 4
 
-    # Add the 'mainmenu' text as the title, centered at the top
-    # Use _top_sep_win width instead of term_width for correct centering
-    top_sep_width = _width(_top_sep_win)
-    _safe_addstr(
-        _top_sep_win,
-        0,
-        max((top_sep_width - len(_kconf.mainmenu_text)) // 2, 0),
-        _kconf.mainmenu_text,
-    )
+    # ---------------------------------------------------------------
+    # 1. Screen background
+    # ---------------------------------------------------------------
+    _screen_win.clear()
 
-    _top_sep_win.noutrefresh()
+    screen_style = _style["screen"]
 
-    # Note: The menu path at the top is deliberately updated last. See below.
+    # Backtitle at row 0 (like mconf's dialog_clear() + backtitle)
+    _screen_win.write(0, 1, _kconf.mainmenu_text, screen_style)
 
-    #
-    # Update the symbol window
-    #
+    # Subtitle path at row 1 (like mconf's subtitle trail)
+    subtitle_parts = []
+    menu = _cur_menu
+    while menu is not _kconf.top_node:
+        subtitle_parts.append(
+            menu.prompt[0] if menu.prompt else standard_sc_expr_str(menu.item)
+        )
+        menu = menu.parent
+    subtitle_parts.reverse()
+
+    if subtitle_parts:
+        path_str = ""
+        for part in subtitle_parts:
+            path_str += Box.RARROW + " " + part + " "
+        _screen_win.write(1, 1, path_str[: screen_width - 2], screen_style)
+        hline_start = min(1 + len(path_str), screen_width - 1)
+    else:
+        hline_start = 1
 
-    _menu_win.erase()
+    # Fill rest of row 1 with horizontal line
+    for j in range(hline_start, screen_width - 1):
+        _screen_win.write_char(1, j, Box.HLINE, screen_style)
 
-    # Draw box around the menu window (like lxdialog's menubox)
-    menu_win_height, menu_win_width = _menu_win.getmaxyx()
+    # Mode indicators on screen background (show-name/show-all/show-help)
+    enabled_modes = []
+    if _show_help:
+        enabled_modes.append("show-help")
+    if _show_name:
+        enabled_modes.append("show-name")
+    if _show_all:
+        enabled_modes.append("show-all")
+    if enabled_modes:
+        mode_str = "[" + "+".join(enabled_modes) + "]"
+        _screen_win.write(
+            0,
+            max(screen_width - len(mode_str) - 1, 0),
+            mode_str,
+            screen_style,
+        )
+
+    # ---------------------------------------------------------------
+    # 2. Dialog body
+    # ---------------------------------------------------------------
+    _dialog_win.clear()
+
+    body_style = _style["body"]
+    border_style = _style.get("border", _style["frame"])
+
+    # Outer dialog box: body for interior, frame for border
+    # Matches mconf: draw_box(dialog, 0, 0, h, w, dlg.dialog.atr, dlg.border.atr)
+    _draw_box(_dialog_win, 0, 0, dlg_h, dlg_w, body_style, border_style)
+
+    # Separator line (LTEE + HLINE + RTEE) at row dlg_h - 3
+    _dialog_win.write_char(dlg_h - 3, 0, Box.LTEE, border_style)
+    for j in range(1, dlg_w - 1):
+        _dialog_win.write_char(dlg_h - 3, j, Box.HLINE, border_style)
+    _dialog_win.write_char(dlg_h - 3, dlg_w - 1, Box.RTEE, border_style)
+
+    # Title centered in top border (like mconf's print_title())
+    title = _cur_menu.prompt[0] if _cur_menu.prompt else _kconf.mainmenu_text
+    title_style = _style.get("title", border_style)
+    tlen = min(dlg_w - 2, len(title))
+    title_x = (dlg_w - tlen) // 2
+    _dialog_win.write_char(0, title_x - 1, " ", title_style)
+    _dialog_win.write(0, title_x, title[:tlen], title_style)
+    _dialog_win.write_char(0, title_x + tlen, " ", title_style)
+
+    # Instruction text (autowrapped, like mconf's print_autowrap())
+    # mconf: print_autowrap(dialog, prompt, width - 2, 1, 3)
+    # Centers text if the entire string fits in one line, otherwise
+    # wraps at column 3 with width (width - 2).
+    inst_x = 3
+    inst_width = dlg_w - 2 * inst_x
+    if inst_width > 0:
+        if len(_MENU_INSTRUCTIONS) <= inst_width:
+            # Entire text fits -- center it (like mconf's
+            # print_text_centered)
+            cx = (dlg_w - len(_MENU_INSTRUCTIONS)) // 2
+            _dialog_win.write(1, cx, _MENU_INSTRUCTIONS, body_style)
+        else:
+            inst_lines = textwrap.wrap(_MENU_INSTRUCTIONS, inst_width)
+            for idx, line in enumerate(inst_lines):
+                row = 1 + idx
+                if row >= box_y:
+                    break
+                _dialog_win.write(row, inst_x, line, body_style)
+
+    # Inner menu box (like mconf's inner draw_box for the menu area)
+    # mconf: draw_box(dialog, box_y, box_x, mh+2, mw+2,
+    #                 dlg.menubox_border.atr, dlg.menubox.atr)
+    # box = menubox_border (white/white/bold), border = menubox (black/white)
+    inner_box_style = _style.get("menubox-border", _style["frame"])
+    inner_border_style = _style.get("menubox", _style["list"])
     _draw_box(
-        _menu_win, 0, 0, menu_win_height, menu_win_width, _style["list"], _style["list"]
+        _dialog_win,
+        box_y,
+        box_x,
+        menu_height + 2,
+        menu_width + 2,
+        inner_box_style,
+        inner_border_style,
     )
 
-    # Calculate max scroll for scrollbar
-    max_scroll = _max_scroll(_shown, _menu_win)
+    # Scroll arrows (like mconf's print_arrows())
+    _draw_scroll_arrows(
+        _dialog_win,
+        len(_shown),
+        _menu_scroll,
+        box_y,
+        box_x + item_x + 1,
+        menu_height,
+        _style["list"],
+        border_style,
+    )
 
-    # Determine text display width (leave space for scrollbar if needed)
-    if max_scroll > 0:
-        text_display_width = (
-            menu_win_width - 4
-        )  # Leave space for: border(1) + text(1) + scrollbar(1) + border(1)
-    else:
-        text_display_width = menu_win_width - 2  # Normal: border(1) on each side
+    # Buttons (like mconf's print_buttons())
+    _draw_main_buttons(_dialog_win, dlg_h, dlg_w)
 
-    # Draw the _shown nodes starting from index _menu_scroll up to either as
-    # many as fit in the window, or to the end of _shown
-    # Note: Now we need to account for the border (1 character on each side)
-    for i in range(
-        _menu_scroll, min(_menu_scroll + _height(_menu_win) - 2, len(_shown))
-    ):
+    # ---------------------------------------------------------------
+    # 3. Menu items (drawn into _menu_win, positioned inside inner box)
+    # ---------------------------------------------------------------
+    _menu_win.clear()
 
+    text_width = menu_width - item_x
+    for i in range(_menu_scroll, min(_menu_scroll + menu_height, len(_shown))):
         node = _shown[i]
 
-        # The 'not _show_all' test avoids showing invisible items in red
-        # outside show-all mode, which could look confusing/broken. Invisible
-        # symbols show up outside show-all mode if an invisible symbol has
-        # visible children in an implicit (indented) menu.
         if _visible(node) or not _show_all:
             style = _style["selection" if i == _sel_node_i else "list"]
         else:
             style = _style["inv-selection" if i == _sel_node_i else "inv-list"]
 
-        # Draw inside the box (offset by 1 row and 1 column)
-        # Truncate text if scrollbar is present
-        node_text = _node_str(node)
-        if max_scroll > 0:
-            node_text = node_text[:text_display_width]
-        _safe_addstr(_menu_win, 1 + i - _menu_scroll, 1, node_text, style)
-
-    # Draw scrollbar if content is scrollable
-    if max_scroll > 0:
-        _draw_scrollbar(
-            _menu_win,
-            _menu_scroll,
-            max_scroll,
-            menu_win_width - 2,
-            1,
-            menu_win_height - 2,
-            _style["list"],
-            _style.get("selection", _style["list"]),
-        )
-
-    _menu_win.noutrefresh()
-
-    #
-    # Update the bottom separator window
-    #
-
-    _bot_sep_win.erase()
-
-    # Indicate when show-name/show-help/show-all mode is enabled
-    enabled_modes = []
-    if _show_help:
-        enabled_modes.append("show-help (toggle with [F])")
-    if _show_name:
-        enabled_modes.append("show-name")
-    if _show_all:
-        enabled_modes.append("show-all")
-    if enabled_modes:
-        s = " and ".join(enabled_modes) + " mode enabled"
-        _safe_addstr(_bot_sep_win, 0, max(term_width - len(s) - 2, 0), s)
-
-    _bot_sep_win.noutrefresh()
-
-    #
-    # Update the help window, which shows either key bindings or help texts
-    #
-
-    _help_win.erase()
+        # Clear entire row with list style, then draw text
+        _menu_win.write(i - _menu_scroll, 0, " " * menu_width, _style["list"])
 
-    if _show_help:
+        node_text = _node_str(node)
+        node_text = node_text[:text_width].ljust(text_width)
+        _menu_win.write(i - _menu_scroll, item_x, node_text, style)
+
+    # ---------------------------------------------------------------
+    # 4. Help text (show-help mode only)
+    # ---------------------------------------------------------------
+    if _show_help and _help_win.height > 1:
+        _help_win.clear()
         node = _shown[_sel_node_i]
+        sh_style = _style["show-help"]
         if isinstance(node.item, (Symbol, Choice)) and node.help:
             help_lines = textwrap.wrap(node.help, _width(_help_win))
             for i in range(min(_height(_help_win), len(help_lines))):
-                _safe_addstr(_help_win, i, 0, help_lines[i])
+                _help_win.write(i, 0, help_lines[i], sh_style)
         else:
-            _safe_addstr(_help_win, 0, 0, "(no help)")
-    else:
-        for i, line in enumerate(_MAIN_HELP_LINES):
-            _safe_addstr(_help_win, i, 0, line)
-
-    _help_win.noutrefresh()
-
-    #
-    # Update the top row with the menu path.
-    #
-    # Doing this last leaves the cursor on the top row, which avoids some minor
-    # annoying jumpiness in gnome-terminal when reducing the height of the
-    # terminal. It seems to happen whenever the row with the cursor on it
-    # disappears.
-    #
+            _help_win.write(0, 0, "(no help)", sh_style)
 
-    _path_win.erase()
+    # ---------------------------------------------------------------
+    # 5. Shadow
+    # ---------------------------------------------------------------
+    _refresh_shadow_windows(_dlg_bottom_shadow, _dlg_right_shadow)
 
-    # Draw the menu path ("(Top) -> Menu -> Submenu -> ...")
 
-    menu_prompts = []
+def _draw_scroll_arrows(
+    win, item_count, scroll, box_y, x, menu_height, menubox_style, border_style
+):
+    # Draw scroll indicator arrows matching mconf/lxdialog's print_arrows().
+    #
+    # When scrolled up: up-arrow "^(-)" at the top of the inner box
+    # When more below: down-arrow "v(+)" at the bottom of the inner box
+    # Otherwise: horizontal lines (part of the box border)
 
-    menu = _cur_menu
-    while menu is not _kconf.top_node:
-        # Promptless choices can be entered in show-all mode. Use
-        # standard_sc_expr_str() for them, so they show up as
-        # '<choice (name if any)>'.
-        menu_prompts.append(
-            menu.prompt[0] if menu.prompt else standard_sc_expr_str(menu.item)
-        )
-        menu = menu.parent
-    menu_prompts.append("(Top)")
-    menu_prompts.reverse()
+    # Up arrow position: box_y row, at x
+    if scroll > 0:
+        win.write_char(box_y, x, Box.UARROW, border_style)
+        win.write(box_y, x + 1, "(-)", border_style)
+    else:
+        for j in range(4):
+            if x + j < _width(win) - 1:
+                win.write_char(box_y, x + j, Box.HLINE, menubox_style)
+
+    # Down arrow position: box_y + menu_height + 1 row, at x
+    down_y = box_y + menu_height + 1
+    if menu_height < item_count and scroll + menu_height < item_count:
+        win.write_char(down_y, x, Box.DARROW, border_style)
+        win.write(down_y, x + 1, "(+)", border_style)
+    else:
+        for j in range(4):
+            if x + j < _width(win) - 1:
+                win.write_char(down_y, x + j, Box.HLINE, border_style)
 
-    # Hack: We can't put ACS_RARROW directly in the string. Temporarily
-    # represent it with NULL.
-    menu_path_str = " \0 ".join(menu_prompts)
 
-    # Scroll the menu path to the right if needed to make the current menu's
-    # title visible
-    if len(menu_path_str) > term_width:
-        menu_path_str = menu_path_str[len(menu_path_str) - term_width :]
+def _draw_main_buttons(win, dlg_h, dlg_w):
+    # Draw the 5 main menu buttons matching mconf/lxdialog's print_buttons().
+    #
+    # In mconf, buttons are spaced 12 apart starting at (width/2 - 28):
+    #   print_button(win, "Select", y, x,      selected == 0);
+    #   print_button(win, " Exit ", y, x + 12, selected == 1);
+    #   print_button(win, " Help ", y, x + 24, selected == 2);
+    #   print_button(win, " Save ", y, x + 36, selected == 3);
+    #   print_button(win, " Load ", y, x + 48, selected == 4);
 
-    # Print the path with the arrows reinserted
-    split_path = menu_path_str.split("\0")
-    _safe_addstr(_path_win, split_path[0])
-    for s in split_path[1:]:
-        _safe_addch(_path_win, curses.ACS_RARROW)
-        _safe_addstr(_path_win, s)
+    button_y = dlg_h - 2
+    start_x = max(dlg_w // 2 - 28, 1)
 
-    _path_win.noutrefresh()
+    for i, label in enumerate(_MENU_BUTTONS):
+        bx = start_x + i * 12
+        if bx + len(label) + 2 > dlg_w:
+            break
+        _print_button(win, label, button_y, bx, i == _active_button)
 
 
 def _parent_menu(node):
@@ -1878,68 +1703,75 @@ def _input_dialog(title, initial_text, info_text=None):
     #   String to show next to the input field. If None, just the input field
     #   is shown.
 
-    win = _styled_win("body")
-    win.keypad(True)
+    win = None
+    bottom_shadow = right_shadow = None
 
-    info_lines = info_text.split("\n") if info_text else []
+    try:
+        win = _styled_region("body")
 
-    # Give the input dialog its initial size
-    _resize_input_dialog(win, title, info_lines)
+        info_lines = info_text.split("\n") if info_text else []
 
-    _safe_curs_set(2)
+        # Give the input dialog its initial size
+        _resize_input_dialog(win, title, info_lines)
 
-    # Input field text
-    s = initial_text
+        _term.show_cursor(very_visible=True)
 
-    # Cursor position
-    i = len(initial_text)
+        # Input field text
+        s = initial_text
 
-    def edit_width():
-        return _width(win) - 4
+        # Cursor position
+        i = len(initial_text)
 
-    # Horizontal scroll offset
-    hscroll = max(i - edit_width() + 1, 0)
+        def edit_width():
+            return _width(win) - 4
 
-    bottom_shadow, right_shadow = _create_shadow_for_win(win)
+        # Horizontal scroll offset
+        hscroll = max(i - edit_width() + 1, 0)
 
-    while True:
-        # Draw the "main" display with the menu, etc., so that resizing still
-        # works properly. This is like a stack of windows, only hardcoded for
-        # now.
-        _draw_main()
+        bottom_shadow, right_shadow = _create_shadow_for_win(win)
+        while True:
+            # Draw the "main" display with the menu, etc., so that resizing
+            # still works properly. This is like a stack of windows, only
+            # hardcoded for now.
+            _draw_main()
 
-        _draw_input_dialog(win, title, info_lines, s, i, hscroll)
+            _draw_input_dialog(win, title, info_lines, s, i, hscroll)
 
-        _refresh_shadow_windows(bottom_shadow, right_shadow)
+            _refresh_shadow_windows(bottom_shadow, right_shadow)
 
-        curses.doupdate()
+            _term.update()
 
-        c = _getch_compat(win)
+            c = _term.read_key()
 
-        if c == curses.KEY_RESIZE:
-            _resize_main()
-            _resize_input_dialog(win, title, info_lines)
-            bottom_shadow, right_shadow = _create_shadow_for_win(win)
+            if c == Key.RESIZE:
+                _resize_main()
+                _resize_input_dialog(win, title, info_lines)
+                _close_shadow_windows(bottom_shadow, right_shadow)
+                bottom_shadow, right_shadow = _create_shadow_for_win(win)
 
-        elif c == "\n":
-            _safe_curs_set(0)
-            return s
+            elif c == "\n":
+                _term.hide_cursor()
+                return s
 
-        elif c == "\x1b":  # \x1B = ESC
-            _safe_curs_set(0)
-            return None
+            elif c == "\x1b":  # \x1B = ESC
+                _term.hide_cursor()
+                return None
 
-        elif c == "\0":  # \0 = NUL, ignore
-            pass
+            elif c == "\0":  # \0 = NUL, ignore
+                pass
 
-        else:
-            s, i, hscroll = _edit_text(c, s, i, hscroll, edit_width())
+            else:
+                s, i, hscroll = _edit_text(c, s, i, hscroll, edit_width())
+    finally:
+        _close_shadow_windows(bottom_shadow, right_shadow)
+        if win:
+            win.close()
 
 
 def _resize_input_dialog(win, title, info_lines):
     # Resizes the input dialog to a size appropriate for the terminal size
 
-    screen_height, screen_width = _stdscr.getmaxyx()
+    screen_height, screen_width = _term.height, _term.width
 
     win_height = 5
     if info_lines:
@@ -1952,29 +1784,25 @@ def _resize_input_dialog(win, title, info_lines):
     win_width = min(win_width, screen_width)
 
     win.resize(win_height, win_width)
-    win.mvwin((screen_height - win_height) // 2, (screen_width - win_width) // 2)
+    win.move((screen_height - win_height) // 2, (screen_width - win_width) // 2)
 
 
 def _draw_input_dialog(win, title, info_lines, s, i, hscroll):
     edit_width = _width(win) - 4
 
-    win.erase()
+    win.clear()
 
     # Note: Perhaps having a separate window for the input field would be nicer
     visible_s = s[hscroll : hscroll + edit_width]
-    _safe_addstr(
-        win, 2, 2, visible_s + " " * (edit_width - len(visible_s)), _style["edit"]
-    )
+    win.write(2, 2, visible_s + " " * (edit_width - len(visible_s)), _style["edit"])
 
     for linenr, line in enumerate(info_lines):
-        _safe_addstr(win, 4 + linenr, 2, line)
+        win.write(4 + linenr, 2, line, _style["body"])
 
     # Draw the frame last so that it overwrites the body text for small windows
     _draw_frame(win, title)
 
-    _safe_move(win, 2, 2 + i - hscroll)
-
-    win.noutrefresh()
+    _term.set_cursor(win, 2, 2 + i - hscroll)
 
 
 def _load_dialog():
@@ -2116,42 +1944,49 @@ def _key_dialog(title, text, keys):
     #   converted to lowercase. ESC will always close the dialog, and returns
     #   None.
 
-    win = _styled_win("body")
-    win.keypad(True)
+    win = None
+    bottom_shadow = right_shadow = None
 
-    _resize_key_dialog(win, text)
+    try:
+        win = _styled_region("body")
 
-    bottom_shadow, right_shadow = _create_shadow_for_win(win)
+        _resize_key_dialog(win, text)
 
-    while True:
-        _draw_main()
+        bottom_shadow, right_shadow = _create_shadow_for_win(win)
+        while True:
+            _draw_main()
 
-        _draw_key_dialog(win, title, text)
+            _draw_key_dialog(win, title, text)
 
-        _refresh_shadow_windows(bottom_shadow, right_shadow)
+            _refresh_shadow_windows(bottom_shadow, right_shadow)
 
-        curses.doupdate()
+            _term.update()
 
-        c = _getch_compat(win)
+            c = _term.read_key()
 
-        if c == curses.KEY_RESIZE:
-            _resize_main()
-            _resize_key_dialog(win, text)
-            bottom_shadow, right_shadow = _create_shadow_for_win(win)
+            if c == Key.RESIZE:
+                _resize_main()
+                _resize_key_dialog(win, text)
+                _close_shadow_windows(bottom_shadow, right_shadow)
+                bottom_shadow, right_shadow = _create_shadow_for_win(win)
 
-        elif c == "\x1b":  # \x1B = ESC
-            return None
+            elif c == "\x1b":  # \x1B = ESC
+                return None
 
-        elif isinstance(c, str):
-            c = c.lower()
-            if c in keys:
-                return c
+            elif isinstance(c, str):
+                c = c.lower()
+                if c in keys:
+                    return c
+    finally:
+        _close_shadow_windows(bottom_shadow, right_shadow)
+        if win:
+            win.close()
 
 
 def _resize_key_dialog(win, text):
     # Resizes the key dialog to a size appropriate for the terminal size
 
-    screen_height, screen_width = _stdscr.getmaxyx()
+    screen_height, screen_width = _term.height, _term.width
 
     lines = text.split("\n")
 
@@ -2159,22 +1994,18 @@ def _resize_key_dialog(win, text):
     win_width = min(max(len(line) for line in lines) + 4, screen_width)
 
     win.resize(win_height, win_width)
-    win.mvwin((screen_height - win_height) // 2, (screen_width - win_width) // 2)
+    win.move((screen_height - win_height) // 2, (screen_width - win_width) // 2)
 
 
 def _draw_key_dialog(win, title, text):
-    win.erase()
+    win.clear()
 
     # Draw the frame first
     _draw_frame(win, title)
 
     # Then draw text content inside the frame
-    win.attron(_style["body"])
     for i, line in enumerate(text.split("\n")):
-        _safe_addstr(win, 2 + i, 2, line)
-    win.attroff(_style["body"])
-
-    win.noutrefresh()
+        win.write(2 + i, 2, line, _style["body"])
 
 
 def _button_dialog(title, text, buttons, default_button=0):
@@ -2187,129 +2018,133 @@ def _button_dialog(title, text, buttons, default_button=0):
     #
     # Returns: Index of selected button, or None if ESC pressed
 
-    win = _styled_win("dialog")
-    win.keypad(True)
+    win = None
+    bottom_shadow = right_shadow = None
 
-    selected_button = default_button
+    try:
+        win = _styled_region("dialog")
+
+        selected_button = default_button
+
+        # Calculate window size based on content
+        lines = text.split("\n")
+        # Height: border(1) + text lines + blank + separator(1) + buttons +
+        # border(1) = 1 + len(lines) + 1 + 1 + 1 + 1 = len(lines) + 5
+        win_height = min(len(lines) + 5, _term.height - 4)
+        # Calculate width from longest line and button row
+        # Button row width includes buttons + spacing between them
+        # 2 buttons: spacing 13, 3+ buttons: spacing 4
+        spacing = 13 if len(buttons) == 2 else 4
+        button_row_width = sum(len(b) + 2 for b in buttons) + spacing * (
+            len(buttons) - 1
+        )
+        win_width = min(
+            max(max(len(line) for line in lines) + 4, button_row_width + 4),
+            _term.width - 4,
+        )
 
-    # Calculate window size based on content
-    lines = text.split("\n")
-    # Height: border(1) + text lines + blank + separator(1) + buttons + border(1)
-    # = 1 + len(lines) + 1 + 1 + 1 + 1 = len(lines) + 5
-    win_height = min(len(lines) + 5, _height(_stdscr) - 4)
-    # Calculate width from longest line and button row
-    # Button row width includes buttons + spacing between them
-    # 2 buttons: spacing 13, 3+ buttons: spacing 4
-    spacing = 13 if len(buttons) == 2 else 4
-    button_row_width = sum(len(b) + 2 for b in buttons) + spacing * (len(buttons) - 1)
-    win_width = min(
-        max(max(len(line) for line in lines) + 4, button_row_width + 4),
-        _width(_stdscr) - 4,
-    )
+        win.resize(win_height, win_width)
+        win.move((_term.height - win_height) // 2, (_term.width - win_width) // 2)
 
-    win.resize(win_height, win_width)
-    win.mvwin((_height(_stdscr) - win_height) // 2, (_width(_stdscr) - win_width) // 2)
+        bottom_shadow, right_shadow = _create_shadow_for_win(win)
 
-    bottom_shadow, right_shadow = _create_shadow_for_win(win)
+        frame_style = _style.get("dialog-frame", _style["dialog"])
+        while True:
+            # Draw main display behind dialog
+            _draw_main()
 
-    frame_style = _style.get("dialog-frame", _style["dialog"])
+            win.clear()
 
-    while True:
-        # Draw main display behind dialog (calls noutrefresh on all subwindows)
-        _draw_main()
+            # Draw box border
+            _draw_box(win, 0, 0, win_height, win_width, frame_style, frame_style)
 
-        win.erase()
+            row_fill = " " * (win_width - 2)
 
-        # Draw box border
-        _draw_box(win, 0, 0, win_height, win_width, frame_style, frame_style)
+            # Draw title bar if title provided
+            if title:
+                win.write(0, 1, row_fill, frame_style)
+                win.write(0, (win_width - len(title)) // 2, title, frame_style)
 
-        # Draw title bar if title provided
-        if title:
-            win.attron(frame_style)
+            # Draw horizontal separator line before buttons (height - 3)
+            win.write_char(win_height - 3, 0, Box.LTEE, frame_style)
             for i in range(1, win_width - 1):
-                _safe_addch(win, 0, i, ord(" "))
-            _safe_addstr(win, 0, (win_width - len(title)) // 2, title)
-            win.attroff(frame_style)
-
-        # Draw horizontal separator line before buttons (height - 3)
-        win.attron(frame_style)
-        _safe_addch(win, win_height - 3, 0, curses.ACS_LTEE)
-        for i in range(1, win_width - 1):
-            _safe_addch(win, win_height - 3, i, curses.ACS_HLINE)
-        _safe_addch(win, win_height - 3, win_width - 1, curses.ACS_RTEE)
-        win.attroff(frame_style)
-
-        # Draw text content
-        win.attron(frame_style)
-        for i in range(1, win_height - 3):
-            for j in range(1, win_width - 1):
-                _safe_addch(win, i, j, ord(" "))
-        for i, line in enumerate(lines):
-            _safe_addstr(win, 1 + i, 2, line)
-        win.attroff(frame_style)
-
-        # Buttons at row (height - 2)
-        button_y = win_height - 2
-
-        # Fill button row background
-        win.attrset(frame_style)
-        for i in range(1, win_width - 1):
-            _safe_addch(win, button_y, i, ord(" "))
-
-        # Calculate button positions with spacing
-        # 2 buttons: 13 chars spacing (from lxdialog/yesno.c), 3+: spacing 4
-        btn_spacing = 13 if len(buttons) == 2 else 4
-        total_width = sum(len(b) + 2 for b in buttons) + btn_spacing * (
-            len(buttons) - 1
-        )
-        button_positions = []
-        current_x = (win_width - total_width) // 2
-        for b in buttons:
-            button_positions.append(current_x)
-            current_x += len(b) + 2 + btn_spacing
-
-        # Draw buttons at calculated positions
-        for i, button_label in enumerate(buttons):
-            _print_button(
-                win, button_label, button_y, button_positions[i], i == selected_button
+                win.write_char(win_height - 3, i, Box.HLINE, frame_style)
+            win.write_char(win_height - 3, win_width - 1, Box.RTEE, frame_style)
+
+            # Draw text content
+            for i in range(1, win_height - 3):
+                win.write(i, 1, row_fill, frame_style)
+            for i, line in enumerate(lines):
+                win.write(1 + i, 2, line, frame_style)
+
+            # Buttons at row (height - 2)
+            button_y = win_height - 2
+
+            # Fill button row background
+            win.write(button_y, 1, row_fill, frame_style)
+
+            # Calculate button positions with spacing
+            # 2 buttons: 13 chars spacing (from lxdialog/yesno.c), 3+: spacing 4
+            btn_spacing = 13 if len(buttons) == 2 else 4
+            total_width = sum(len(b) + 2 for b in buttons) + btn_spacing * (
+                len(buttons) - 1
             )
+            button_positions = []
+            current_x = (win_width - total_width) // 2
+            for b in buttons:
+                button_positions.append(current_x)
+                current_x += len(b) + 2 + btn_spacing
 
-        win.noutrefresh()
+            # Draw buttons at calculated positions
+            for i, button_label in enumerate(buttons):
+                _print_button(
+                    win,
+                    button_label,
+                    button_y,
+                    button_positions[i],
+                    i == selected_button,
+                )
 
-        # Refresh shadow windows after dialog window to ensure they're on top
-        _refresh_shadow_windows(bottom_shadow, right_shadow)
+            # Refresh shadow windows after dialog window to ensure they're on top
+            _refresh_shadow_windows(bottom_shadow, right_shadow)
 
-        curses.doupdate()
+            _term.update()
 
-        # Handle input
-        c = _getch_compat(win)
+            # Handle input
+            c = _term.read_key()
 
-        if c == curses.KEY_RESIZE:
-            _resize_main()
-            win.resize(win_height, win_width)
-            win.mvwin(
-                (_height(_stdscr) - win_height) // 2, (_width(_stdscr) - win_width) // 2
-            )
-            bottom_shadow, right_shadow = _create_shadow_for_win(win)
+            if c == Key.RESIZE:
+                _resize_main()
+                win.resize(win_height, win_width)
+                win.move(
+                    (_term.height - win_height) // 2,
+                    (_term.width - win_width) // 2,
+                )
+                _close_shadow_windows(bottom_shadow, right_shadow)
+                bottom_shadow, right_shadow = _create_shadow_for_win(win)
 
-        elif c == "\x1b":  # ESC
-            return None
+            elif c == "\x1b":  # ESC
+                return None
 
-        elif c == "\t" or c == curses.KEY_RIGHT:  # TAB or RIGHT arrow
-            selected_button = (selected_button + 1) % len(buttons)
+            elif c == "\t" or c == Key.RIGHT:  # TAB or RIGHT arrow
+                selected_button = (selected_button + 1) % len(buttons)
 
-        elif c == curses.KEY_LEFT:  # LEFT arrow
-            selected_button = (selected_button - 1) % len(buttons)
+            elif c == Key.LEFT:  # LEFT arrow
+                selected_button = (selected_button - 1) % len(buttons)
 
-        elif c == " " or c == "\n":  # SPACE or ENTER
-            return selected_button
+            elif c == " " or c == "\n":  # SPACE or ENTER
+                return selected_button
 
-        elif isinstance(c, str):
-            # Check for hotkey match
-            c_lower = c.lower()
-            for i, button_label in enumerate(buttons):
-                if button_label.strip().lower().startswith(c_lower):
-                    return i
+            elif isinstance(c, str):
+                # Check for hotkey match
+                c_lower = c.lower()
+                for i, button_label in enumerate(buttons):
+                    if button_label.strip().lower().startswith(c_lower):
+                        return i
+    finally:
+        _close_shadow_windows(bottom_shadow, right_shadow)
+        if win:
+            win.close()
 
 
 def _print_button(win, label, y, x, selected):
@@ -2329,67 +2164,51 @@ def _print_button(win, label, y, x, selected):
     key_style = _style["button-key-" + sfx]
     lbl_style = _style["button-label-" + sfx]
 
-    # Move to position
-    _safe_move(win, y, x)
-
     # Draw bracket "<"
-    win.attrset(btn_style)
-    _safe_addstr(win, y, x, "<")
+    win.write(y, x, "<", btn_style)
 
     # Draw leading spaces with label style
-    win.attrset(lbl_style)
-    for _ in range(leading_spaces):
-        _safe_addch(win, y, x + 1 + _, ord(" "))
+    if leading_spaces:
+        win.write(y, x + 1, " " * leading_spaces, lbl_style)
 
     # Draw first character (hotkey) with key style, then rest with label style
     if label_stripped:
-        win.attrset(key_style)
-        _safe_addch(win, y, x + 1 + leading_spaces, ord(label_stripped[0]))
-
-        win.attrset(lbl_style)
-        _safe_addstr(win, y, x + 1 + leading_spaces + 1, label_stripped[1:])
+        win.write_char(y, x + 1 + leading_spaces, label_stripped[0], key_style)
+        win.write(y, x + 1 + leading_spaces + 1, label_stripped[1:], lbl_style)
 
     # Draw bracket ">"
-    win.attrset(btn_style)
-    _safe_addstr(win, y, x + 1 + len(label), ">")
-
-    # Move cursor to the hotkey position for selected button
-    _safe_move(win, y, x + 1 + leading_spaces)
+    win.write(y, x + 1 + len(label), ">", btn_style)
 
 
-def _draw_box(win, y, x, height, width, box_attr, border_attr):
-    # Draw a rectangular box with line drawing characters, matching lxdialog's draw_box()
+def _draw_box(win, y, x, height, width, box_style, border_style):
+    # Draw a rectangular box with line drawing characters, matching lxdialog's
+    # draw_box().  Fills the interior with box_style, matching the C version
+    # which writes (box | ' ') for every interior cell.
     #
-    # box_attr: attribute for box body and right/bottom borders
-    # border_attr: attribute for left/top borders
+    # box_style: style for interior, right/bottom borders
+    # border_style: style for left/top borders
 
     last_row = y + height - 1
     last_col = x + width - 1
 
-    # Top border (left/top attr)
-    win.attrset(border_attr)
-    _safe_addch(win, y, x, curses.ACS_ULCORNER)
+    # Top border (border_style for left/top edge)
+    win.write_char(y, x, Box.ULCORNER, border_style)
     for j in range(x + 1, last_col):
-        _safe_addch(win, y, j, curses.ACS_HLINE)
+        win.write_char(y, j, Box.HLINE, border_style)
+    win.write_char(y, last_col, Box.URCORNER, box_style)
 
-    # Top-right corner (right/bottom attr)
-    win.attrset(box_attr)
-    _safe_addch(win, y, last_col, curses.ACS_URCORNER)
-
-    # Side borders
+    # Interior rows: left border + fill + right border
+    fill = " " * (width - 2)
     for i in range(y + 1, last_row):
-        win.attrset(border_attr)
-        _safe_addch(win, i, x, curses.ACS_VLINE)
-        win.attrset(box_attr)
-        _safe_addch(win, i, last_col, curses.ACS_VLINE)
-
-    # Bottom border
-    win.attrset(border_attr)
-    _safe_addch(win, last_row, x, curses.ACS_LLCORNER)
-    win.attrset(box_attr)
+        win.write_char(i, x, Box.VLINE, border_style)
+        win.write(i, x + 1, fill, box_style)
+        win.write_char(i, last_col, Box.VLINE, box_style)
+
+    # Bottom border (box_style for right/bottom edge)
+    win.write_char(last_row, x, Box.LLCORNER, border_style)
     for j in range(x + 1, last_col):
-        _safe_addch(win, last_row, j, curses.ACS_HLINE)
-    _safe_addch(win, last_row, last_col, curses.ACS_LRCORNER)
+        win.write_char(last_row, j, Box.HLINE, box_style)
+    win.write_char(last_row, last_col, Box.LRCORNER, box_style)
 
 
 def _draw_scrollbar(
@@ -2418,97 +2237,100 @@ def _draw_scrollbar(
     for i in range(height):
         y = y_start + i
         if i == 0:
-            _safe_addch(win, y, x, curses.ACS_UARROW, track_style)
+            win.write_char(y, x, Box.UARROW, track_style)
         elif i == height - 1:
-            _safe_addch(win, y, x, curses.ACS_DARROW, track_style)
+            win.write_char(y, x, Box.DARROW, track_style)
         elif i == thumb_pos:
-            _safe_addch(win, y, x, ord(" "), thumb_style)
+            win.write_char(y, x, " ", thumb_style)
         else:
-            _safe_addch(win, y, x, curses.ACS_VLINE, track_style)
+            win.write_char(y, x, Box.VLINE, track_style)
 
 
 def _create_shadow_for_win(win, right_y_offset=1):
-    # Convenience wrapper: creates shadow windows from a curses window's
+    # Convenience wrapper: creates shadow regions from a rawterm Region's
     # position and size
-    y, x = win.getbegyx()
-    h, w = win.getmaxyx()
-    return _create_shadow_windows(y, x, h, w, right_y_offset)
+    return _create_shadow_windows(win.y, win.x, win.height, win.width, right_y_offset)
 
 
 def _create_shadow_windows(y, x, height, width, right_y_offset=1):
-    # Create shadow windows for bottom and right edges
-    # Returns tuple of (bottom_shadow_win, right_shadow_win)
+    # Create shadow regions for bottom and right edges
+    # Returns tuple of (bottom_shadow, right_shadow)
     #
     # Based on lxdialog's draw_shadow():
     # - Bottom: at y + height, from x + 2, width chars
     # - Right: from y + right_y_offset to y + height (inclusive), at x + width, 2 chars wide
 
-    if not curses.has_colors():
-        return None, None
-
     try:
-        shadow_attr = _style.get("shadow", 0)
+        shadow_style = _style.get("shadow", Style())
 
-        # Bottom shadow window (1 line high, width wide, offset by 2 on x)
+        # Bottom shadow region (1 line high, width wide, offset by 2 on x)
         bottom_shadow = None
-        if y + height < _height(_stdscr) and x + 2 + width <= _width(_stdscr):
+        if y + height < _term.height and x + 2 + width <= _term.width:
             try:
-                bottom_shadow = curses.newwin(1, width, y + height, x + 2)
-                bottom_shadow.bkgd(" ", shadow_attr)
-            except:
+                bottom_shadow = _term.region(1, width, y + height, x + 2)
+                bottom_shadow.fill(shadow_style)
+            except Exception:
                 pass
 
-        # Right shadow window
-        # lxdialog: for (i = y + 1; i < y + height + 1; i++)
-        # Draw from y+right_y_offset to y+height (inclusive)
+        # Right shadow region
         right_shadow = None
-        if x + width + 2 <= _width(_stdscr) and y + height <= _height(_stdscr):
+        if x + width + 2 <= _term.width and y + height <= _term.height:
             try:
-                # From (y + right_y_offset) to (y + height) inclusive
-                # Total rows = (y + height) - (y + right_y_offset) + 1 = height - right_y_offset + 1
                 shadow_height = height - right_y_offset + 1
                 if shadow_height > 0:
-                    right_shadow = curses.newwin(
+                    right_shadow = _term.region(
                         shadow_height, 2, y + right_y_offset, x + width
                     )
-                    right_shadow.bkgd(" ", shadow_attr)
-            except:
+                    right_shadow.fill(shadow_style)
+            except Exception:
                 pass
 
         return bottom_shadow, right_shadow
-    except:
+    except Exception:
         return None, None
 
 
+def _close_shadow_windows(bottom_shadow, right_shadow):
+    # Unregister shadow regions from the compositor so they stop rendering.
+    if bottom_shadow:
+        try:
+            bottom_shadow.close()
+        except Exception:
+            pass
+    if right_shadow:
+        try:
+            right_shadow.close()
+        except Exception:
+            pass
+
+
 def _refresh_shadow_windows(bottom_shadow, right_shadow):
-    # Refresh shadow windows, refilling them each time to ensure visibility
+    # Shadow regions are composited automatically by _term.update().
+    # Just clear and refill them to ensure correct content.
     if bottom_shadow:
         try:
-            bottom_shadow.erase()  # Clear and refill with background
-            bottom_shadow.noutrefresh()
-        except:
+            bottom_shadow.clear()
+        except Exception:
             pass
     if right_shadow:
         try:
-            right_shadow.erase()  # Clear and refill with background
-            right_shadow.noutrefresh()
-        except:
+            right_shadow.clear()
+        except Exception:
             pass
 
 
 def _draw_frame(win, title):
     # Draw a frame around the inner edges of 'win', with 'title' at the top
-    # Now uses _draw_box() for proper box drawing characters
+    # Uses _draw_box() for proper box drawing characters
 
-    win_height, win_width = win.getmaxyx()
+    win_height = win.height
+    win_width = win.width
 
     # Draw box with frame style for both border and box
     _draw_box(win, 0, 0, win_height, win_width, _style["frame"], _style["frame"])
 
     # Draw title
-    win.attron(_style["frame"])
-    _safe_addstr(win, 0, max((win_width - len(title)) // 2, 0), title)
-    win.attroff(_style["frame"])
+    win.write(0, max((win_width - len(title)) // 2, 0), title, _style["frame"])
 
 
 def _jump_to_dialog():
@@ -2518,222 +2340,232 @@ def _jump_to_dialog():
     # Returns True if the user jumped to a symbol, and False if the dialog was
     # canceled.
 
-    s = ""  # Search text
-    prev_s = None  # Previous search text
-    s_i = 0  # Search text cursor position
-    hscroll = 0  # Horizontal scroll offset
-
-    sel_node_i = 0  # Index of selected row
-    scroll = 0  # Index in 'matches' of the top row of the list
-
-    # Edit box at the top
-    edit_box = _styled_win("jump-edit")
-    edit_box.keypad(True)
-
-    # List of matches
-    matches_win = _styled_win("list")
+    edit_box = matches_win = bot_sep_win = help_win = None
+    bottom_shadow = right_shadow = None
 
-    # Bottom separator, with arrows pointing down
-    bot_sep_win = _styled_win("separator")
-
-    # Help window with instructions at the bottom
-    help_win = _styled_win("help")
-
-    # Give windows their initial size
-    _resize_jump_to_dialog(
-        edit_box, matches_win, bot_sep_win, help_win, sel_node_i, scroll
-    )
+    try:
+        s = ""  # Search text
+        prev_s = None  # Previous search text
+        s_i = 0  # Search text cursor position
+        hscroll = 0  # Horizontal scroll offset
 
-    def _jump_to_shadows():
-        # Shadow windows cover the dialog area (everything except help window)
-        sh, sw = _stdscr.getmaxyx()
-        dh = sh - len(_JUMP_TO_HELP_LINES) - 1
-        return _create_shadow_windows(0, 0, dh, sw, right_y_offset=1)
+        sel_node_i = 0  # Index of selected row
+        scroll = 0  # Index in 'matches' of the top row of the list
 
-    bottom_shadow, right_shadow = _jump_to_shadows()
+        # Edit box at the top
+        edit_box = _styled_region("jump-edit")
 
-    _safe_curs_set(2)
+        # List of matches
+        matches_win = _styled_region("list")
 
-    # Logic duplication with _select_{next,prev}_menu_entry(), except we do a
-    # functional variant that returns the new (sel_node_i, scroll) values to
-    # avoid 'nonlocal'. TODO: Can this be factored out in some nice way?
+        # Bottom separator, with arrows pointing down
+        bot_sep_win = _styled_region("separator")
 
-    def select_next_match():
-        if sel_node_i == len(matches) - 1:
-            return sel_node_i, scroll
+        # Help window with instructions at the bottom
+        help_win = _styled_region("help")
 
-        if sel_node_i + 1 >= scroll + _height(
-            matches_win
-        ) - _SCROLL_OFFSET and scroll < _max_scroll(matches, matches_win):
+        # Give windows their initial size
+        _resize_jump_to_dialog(
+            edit_box, matches_win, bot_sep_win, help_win, sel_node_i, scroll
+        )
 
-            return sel_node_i + 1, scroll + 1
+        def _jump_to_shadows():
+            # Shadow windows cover the dialog area (everything except help win)
+            _close_shadow_windows(bottom_shadow, right_shadow)
+            sh, sw = _term.height, _term.width
+            dh = sh - len(_JUMP_TO_HELP_LINES) - 1
+            return _create_shadow_windows(0, 0, dh, sw, right_y_offset=1)
 
-        return sel_node_i + 1, scroll
+        bottom_shadow, right_shadow = _jump_to_shadows()
 
-    def select_prev_match():
-        if sel_node_i == 0:
-            return sel_node_i, scroll
+        _term.show_cursor(very_visible=True)
 
-        if sel_node_i - 1 < scroll + _SCROLL_OFFSET:
-            return sel_node_i - 1, max(scroll - 1, 0)
+        # Logic duplication with _select_{next,prev}_menu_entry(), except we
+        # do a functional variant that returns the new (sel_node_i, scroll)
+        # values to avoid 'nonlocal'. TODO: Can this be factored out in some
+        # nice way?
 
-        return sel_node_i - 1, scroll
+        def select_next_match():
+            if sel_node_i == len(matches) - 1:
+                return sel_node_i, scroll
 
-    while True:
-        if s != prev_s:
-            # The search text changed. Find new matching nodes.
+            if sel_node_i + 1 >= scroll + _height(
+                matches_win
+            ) - _SCROLL_OFFSET and scroll < _max_scroll(matches, matches_win):
 
-            prev_s = s
+                return sel_node_i + 1, scroll + 1
 
-            try:
-                # We could use re.IGNORECASE here instead of lower(), but this
-                # is noticeably less jerky while inputting regexes like
-                # '.*debug$' (though the '.*' is redundant there). Those
-                # probably have bad interactions with re.search(), which
-                # matches anywhere in the string.
-                #
-                # It's not horrible either way. Just a bit smoother.
-                regex_searches = [
-                    re.compile(regex).search for regex in s.lower().split()
-                ]
+            return sel_node_i + 1, scroll
 
-                # No exception thrown, so the regexes are okay
-                bad_re = None
-
-                # List of matching nodes
-                matches = []
-                add_match = matches.append
-
-                # Search symbols and choices
-
-                for node in _sorted_sc_nodes():
-                    # Symbol/choice
-                    sc = node.item
-
-                    for search in regex_searches:
-                        # Both the name and the prompt might be missing, since
-                        # we're searching both symbols and choices
-
-                        # Does the regex match either the symbol name or the
-                        # prompt (if any)?
-                        if not (
-                            sc.name
-                            and search(sc.name.lower())
-                            or node.prompt
-                            and search(node.prompt[0].lower())
-                        ):
-
-                            # Give up on the first regex that doesn't match, to
-                            # speed things up a bit when multiple regexes are
-                            # entered
-                            break
-
-                    else:
-                        add_match(node)
-
-                # Search menus and comments
-
-                for node in _sorted_menu_comment_nodes():
-                    for search in regex_searches:
-                        if not search(node.prompt[0].lower()):
-                            break
-                    else:
-                        add_match(node)
-
-            except re.error as e:
-                # Bad regex. Remember the error message so we can show it.
-                bad_re = "Bad regular expression"
-                # re.error.msg was added in Python 3.5
-                if hasattr(e, "msg"):
-                    bad_re += ": " + e.msg
-
-                matches = []
-
-            # Reset scroll and jump to the top of the list of matches
-            sel_node_i = scroll = 0
-
-        _draw_jump_to_dialog(
-            edit_box,
-            matches_win,
-            bot_sep_win,
-            help_win,
-            s,
-            s_i,
-            hscroll,
-            bad_re,
-            matches,
-            sel_node_i,
-            scroll,
-        )
+        def select_prev_match():
+            if sel_node_i == 0:
+                return sel_node_i, scroll
 
-        # Refresh shadow windows after all other windows
-        _refresh_shadow_windows(bottom_shadow, right_shadow)
+            if sel_node_i - 1 < scroll + _SCROLL_OFFSET:
+                return sel_node_i - 1, max(scroll - 1, 0)
 
-        curses.doupdate()
+            return sel_node_i - 1, scroll
 
-        c = _getch_compat(edit_box)
+        while True:
+            if s != prev_s:
+                # The search text changed. Find new matching nodes.
+
+                prev_s = s
+
+                try:
+                    # We could use re.IGNORECASE here instead of lower(), but
+                    # this is noticeably less jerky while inputting regexes like
+                    # '.*debug$' (though the '.*' is redundant there). Those
+                    # probably have bad interactions with re.search(), which
+                    # matches anywhere in the string.
+                    #
+                    # It's not horrible either way. Just a bit smoother.
+                    regex_searches = [
+                        re.compile(regex).search for regex in s.lower().split()
+                    ]
+
+                    # No exception thrown, so the regexes are okay
+                    bad_re = None
+
+                    # List of matching nodes
+                    matches = []
+                    add_match = matches.append
+
+                    # Search symbols and choices
+
+                    for node in _sorted_sc_nodes():
+                        # Symbol/choice
+                        sc = node.item
+
+                        for search in regex_searches:
+                            # Both the name and the prompt might be missing,
+                            # since we're searching both symbols and choices
+
+                            # Does the regex match either the symbol name or
+                            # the prompt (if any)?
+                            if not (
+                                sc.name
+                                and search(sc.name.lower())
+                                or node.prompt
+                                and search(node.prompt[0].lower())
+                            ):
+
+                                # Give up on the first regex that doesn't
+                                # match, to speed things up a bit when multiple
+                                # regexes are entered
+                                break
+
+                        else:
+                            add_match(node)
+
+                    # Search menus and comments
+
+                    for node in _sorted_menu_comment_nodes():
+                        for search in regex_searches:
+                            if not search(node.prompt[0].lower()):
+                                break
+                        else:
+                            add_match(node)
+
+                except re.error as e:
+                    # Bad regex. Remember the error message so we can show it.
+                    bad_re = "Bad regular expression"
+                    # re.error.msg was added in Python 3.5
+                    if hasattr(e, "msg"):
+                        bad_re += ": " + e.msg
+
+                    matches = []
+
+                # Reset scroll and jump to the top of the list of matches
+                sel_node_i = scroll = 0
+
+            _draw_jump_to_dialog(
+                edit_box,
+                matches_win,
+                bot_sep_win,
+                help_win,
+                s,
+                s_i,
+                hscroll,
+                bad_re,
+                matches,
+                sel_node_i,
+                scroll,
+            )
 
-        if c == "\n":
-            if matches:
-                _jump_to(matches[sel_node_i])
-                _safe_curs_set(0)
-                return True
+            # Refresh shadow windows after all other windows
+            _refresh_shadow_windows(bottom_shadow, right_shadow)
 
-        elif c == "\x1b":  # \x1B = ESC
-            _safe_curs_set(0)
-            return False
+            _term.update()
 
-        elif c == curses.KEY_RESIZE:
-            # We adjust the scroll so that the selected node stays visible in
-            # the list when the terminal is resized, hence the 'scroll'
-            # assignment
-            scroll = _resize_jump_to_dialog(
-                edit_box, matches_win, bot_sep_win, help_win, sel_node_i, scroll
-            )
+            c = _term.read_key()
 
-            bottom_shadow, right_shadow = _jump_to_shadows()
+            if c == "\n":
+                if matches:
+                    _jump_to(matches[sel_node_i])
+                    _term.hide_cursor()
+                    return True
 
-        elif c == "\x06":  # \x06 = Ctrl-F
-            if matches:
-                _safe_curs_set(0)
-                _info_dialog(matches[sel_node_i], True)
-                _safe_curs_set(2)
+            elif c == "\x1b":  # \x1B = ESC
+                _term.hide_cursor()
+                return False
 
+            elif c == Key.RESIZE:
+                # We adjust the scroll so that the selected node stays visible
+                # in the list when the terminal is resized, hence the 'scroll'
+                # assignment
                 scroll = _resize_jump_to_dialog(
                     edit_box, matches_win, bot_sep_win, help_win, sel_node_i, scroll
                 )
 
                 bottom_shadow, right_shadow = _jump_to_shadows()
 
-        elif c == curses.KEY_DOWN:
-            sel_node_i, scroll = select_next_match()
+            elif c == "\x06":  # \x06 = Ctrl-F
+                if matches:
+                    _term.hide_cursor()
+                    _info_dialog(matches[sel_node_i], True)
+                    _term.show_cursor(very_visible=True)
+
+                    scroll = _resize_jump_to_dialog(
+                        edit_box, matches_win, bot_sep_win, help_win, sel_node_i, scroll
+                    )
 
-        elif c == curses.KEY_UP:
-            sel_node_i, scroll = select_prev_match()
+                    bottom_shadow, right_shadow = _jump_to_shadows()
 
-        elif c in (curses.KEY_NPAGE, "\x04"):  # Page Down/Ctrl-D
-            # Keep it simple. This way we get sane behavior for small windows,
-            # etc., for free.
-            for _ in range(_PG_JUMP):
+            elif c == Key.DOWN:
                 sel_node_i, scroll = select_next_match()
 
-        # Page Up (no Ctrl-U, as it's already used by the edit box)
-        elif c == curses.KEY_PPAGE:
-            for _ in range(_PG_JUMP):
+            elif c == Key.UP:
                 sel_node_i, scroll = select_prev_match()
 
-        elif c == curses.KEY_END:
-            sel_node_i = len(matches) - 1
-            scroll = _max_scroll(matches, matches_win)
+            elif c in (Key.PAGE_DOWN, "\x04"):  # Page Down/Ctrl-D
+                # Keep it simple. This way we get sane behavior for small
+                # windows, etc., for free.
+                for _ in range(_PG_JUMP):
+                    sel_node_i, scroll = select_next_match()
 
-        elif c == curses.KEY_HOME:
-            sel_node_i = scroll = 0
+            # Page Up (no Ctrl-U, as it's already used by the edit box)
+            elif c == Key.PAGE_UP:
+                for _ in range(_PG_JUMP):
+                    sel_node_i, scroll = select_prev_match()
 
-        elif c == "\0":  # \0 = NUL, ignore
-            pass
+            elif c == Key.END:
+                sel_node_i = len(matches) - 1
+                scroll = _max_scroll(matches, matches_win)
 
-        else:
-            s, s_i, hscroll = _edit_text(c, s, s_i, hscroll, _width(edit_box) - 2)
+            elif c == Key.HOME:
+                sel_node_i = scroll = 0
+
+            elif c == "\0":  # \0 = NUL, ignore
+                pass
+
+            else:
+                s, s_i, hscroll = _edit_text(c, s, s_i, hscroll, _width(edit_box) - 2)
+    finally:
+        _close_shadow_windows(bottom_shadow, right_shadow)
+        for r in (edit_box, matches_win, bot_sep_win, help_win):
+            if r:
+                r.close()
 
 
 # Obscure Python: We never pass a value for cached_nodes, and it keeps pointing
@@ -2784,7 +2616,7 @@ def _resize_jump_to_dialog(
     # Returns the new scroll index. We adjust the scroll if needed so that the
     # selected node stays visible.
 
-    screen_height, screen_width = _stdscr.getmaxyx()
+    screen_height, screen_width = _term.height, _term.width
 
     bot_sep_win.resize(1, screen_width)
 
@@ -2796,9 +2628,9 @@ def _resize_jump_to_dialog(
         matches_win.resize(matches_win_height, screen_width)
         help_win.resize(help_win_height, screen_width)
 
-        matches_win.mvwin(3, 0)
-        bot_sep_win.mvwin(3 + matches_win_height, 0)
-        help_win.mvwin(3 + matches_win_height + 1, 0)
+        matches_win.move(3, 0)
+        bot_sep_win.move(3 + matches_win_height, 0)
+        help_win.move(3 + matches_win_height + 1, 0)
     else:
         # Degenerate case. Give up on nice rendering and just prevent errors.
 
@@ -2809,7 +2641,7 @@ def _resize_jump_to_dialog(
         help_win.resize(1, screen_width)
 
         for win in matches_win, bot_sep_win, help_win:
-            win.mvwin(0, 0)
+            win.move(0, 0)
 
     # Adjust the scroll so that the selected row is still within the window, if
     # needed
@@ -2838,10 +2670,11 @@ def _draw_jump_to_dialog(
     # Update list of matches
     #
 
-    matches_win.erase()
+    matches_win.clear()
 
     # Draw box border around matches window
-    matches_win_height, matches_win_width = matches_win.getmaxyx()
+    matches_win_height = matches_win.height
+    matches_win_width = matches_win.width
     _draw_box(
         matches_win,
         0,
@@ -2877,11 +2710,10 @@ def _draw_jump_to_dialog(
             else:  # node.item == COMMENT
                 node_str = 'comment "{}"'.format(node.prompt[0])
 
-            # Truncate text if needed
-            node_str = node_str[:text_display_width]
+            # Truncate and pad text to fill full row width
+            node_str = node_str[:text_display_width].ljust(text_display_width)
 
-            _safe_addstr(
-                matches_win,
+            matches_win.write(
                 1 + i - scroll,  # Offset by 1 for top border
                 1,  # Offset by 1 for left border
                 node_str,
@@ -2902,45 +2734,36 @@ def _draw_jump_to_dialog(
             )
 
     else:
-        # bad_re holds the error message from the re.error exception on errors
-        _safe_addstr(matches_win, 1, 1, bad_re or "No matches")  # Inside border
-
-    matches_win.noutrefresh()
+        matches_win.write(1, 1, bad_re or "No matches", _style["list"])
 
     #
     # Update bottom separator line
     #
 
-    bot_sep_win.erase()
-
-    bot_sep_win.noutrefresh()
+    bot_sep_win.clear()
 
     #
     # Update help window at bottom
     #
 
-    help_win.erase()
+    help_win.clear()
 
     for i, line in enumerate(_JUMP_TO_HELP_LINES):
-        _safe_addstr(help_win, i, 0, line)
-
-    help_win.noutrefresh()
+        help_win.write(i, 0, line, _style["help"])
 
     #
     # Update edit box. We do this last since it makes it handy to position the
     # cursor.
     #
 
-    edit_box.erase()
+    edit_box.clear()
 
     _draw_frame(edit_box, "Jump to symbol/choice/menu/comment")
 
     visible_s = s[hscroll : hscroll + edit_width]
-    _safe_addstr(edit_box, 1, 1, visible_s)
-
-    _safe_move(edit_box, 1, 1 + s_i - hscroll)
+    edit_box.write(1, 1, visible_s, _style["jump-edit"])
 
-    edit_box.noutrefresh()
+    _term.set_cursor(edit_box, 1, 1 + s_i - hscroll)
 
 
 def _info_dialog(node, from_jump_to_dialog):
@@ -2951,86 +2774,93 @@ def _info_dialog(node, from_jump_to_dialog):
     # information dialog just return, to avoid a confusing recursive invocation
     # of the jump-to-dialog.
 
-    win = _styled_win("body")
-    win.keypad(True)
+    win = None
+    bottom_shadow = right_shadow = None
 
-    # Get lines of help text in mconf format
-    lines = _info_str_mconf(node).split("\n")
+    try:
+        win = _styled_region("body")
 
-    # Index of first row in 'lines' to show
-    scroll = 0
+        # Get lines of help text in mconf format
+        lines = _info_str_mconf(node).split("\n")
 
-    # Give window its initial size
-    _resize_info_dialog(win, node, lines)
+        # Index of first row in 'lines' to show
+        scroll = 0
 
-    bottom_shadow, right_shadow = _create_shadow_for_win(win)
+        # Give window its initial size
+        _resize_info_dialog(win, node, lines)
 
-    while True:
-        _draw_main()
+        bottom_shadow, right_shadow = _create_shadow_for_win(win)
+        while True:
+            _draw_main()
 
-        _draw_info_dialog(win, node, lines, scroll)
+            _draw_info_dialog(win, node, lines, scroll)
 
-        _refresh_shadow_windows(bottom_shadow, right_shadow)
+            _refresh_shadow_windows(bottom_shadow, right_shadow)
 
-        curses.doupdate()
+            _term.update()
 
-        c = _getch_compat(win)
+            c = _term.read_key()
 
-        if c == curses.KEY_RESIZE:
-            _resize_main()
-            _resize_info_dialog(win, node, lines)
-            bottom_shadow, right_shadow = _create_shadow_for_win(win)
+            if c == Key.RESIZE:
+                _resize_main()
+                _resize_info_dialog(win, node, lines)
+                _close_shadow_windows(bottom_shadow, right_shadow)
+                bottom_shadow, right_shadow = _create_shadow_for_win(win)
 
-        elif c in (curses.KEY_DOWN, "j", "J"):
-            if scroll < _max_scroll_info(lines, win):
-                scroll += 1
+            elif c in (Key.DOWN, "j", "J"):
+                if scroll < _max_scroll_info(lines, win):
+                    scroll += 1
 
-        elif c in (curses.KEY_NPAGE, "\x04"):  # Page Down/Ctrl-D
-            scroll = min(scroll + _PG_JUMP, _max_scroll_info(lines, win))
+            elif c in (Key.PAGE_DOWN, "\x04"):  # Page Down/Ctrl-D
+                scroll = min(scroll + _PG_JUMP, _max_scroll_info(lines, win))
 
-        elif c in (curses.KEY_PPAGE, "\x15"):  # Page Up/Ctrl-U
-            scroll = max(scroll - _PG_JUMP, 0)
+            elif c in (Key.PAGE_UP, "\x15"):  # Page Up/Ctrl-U
+                scroll = max(scroll - _PG_JUMP, 0)
 
-        elif c in (curses.KEY_END, "G"):
-            scroll = _max_scroll_info(lines, win)
+            elif c in (Key.END, "G"):
+                scroll = _max_scroll_info(lines, win)
 
-        elif c in (curses.KEY_HOME, "g"):
-            scroll = 0
+            elif c in (Key.HOME, "g"):
+                scroll = 0
 
-        elif c in (curses.KEY_UP, "k", "K"):
-            if scroll > 0:
-                scroll -= 1
+            elif c in (Key.UP, "k", "K"):
+                if scroll > 0:
+                    scroll -= 1
 
-        elif c == "/":
-            # Support starting a search from within the information dialog
+            elif c == "/":
+                # Support starting a search from within the information dialog
 
-            if from_jump_to_dialog:
-                return  # Avoid recursion
+                if from_jump_to_dialog:
+                    return  # Avoid recursion
 
-            if _jump_to_dialog():
-                return  # Jumped to a symbol. Cancel the information dialog.
+                if _jump_to_dialog():
+                    return  # Jumped to a symbol. Cancel the info dialog.
 
-            # Stay in the information dialog if the jump-to dialog was
-            # canceled. Resize it in case the terminal was resized while the
-            # fullscreen jump-to dialog was open.
-            _resize_main()
-            _resize_info_dialog(win, node, lines)
-            bottom_shadow, right_shadow = _create_shadow_for_win(win)
-
-        elif c in (
-            curses.KEY_LEFT,
-            curses.KEY_BACKSPACE,
-            _ERASE_CHAR,
-            "\x1b",  # \x1B = ESC
-            "\n",  # Enter
-            " ",  # Space
-            "q",
-            "Q",
-            "h",
-            "H",
-        ):
+                # Stay in the information dialog if the jump-to dialog was
+                # canceled. Resize it in case the terminal was resized while
+                # the fullscreen jump-to dialog was open.
+                _resize_main()
+                _resize_info_dialog(win, node, lines)
+                _close_shadow_windows(bottom_shadow, right_shadow)
+                bottom_shadow, right_shadow = _create_shadow_for_win(win)
 
-            return
+            elif c in (
+                Key.LEFT,
+                Key.BACKSPACE,
+                "\x1b",  # \x1B = ESC
+                "\n",  # Enter
+                " ",  # Space
+                "q",
+                "Q",
+                "h",
+                "H",
+            ):
+
+                return
+    finally:
+        _close_shadow_windows(bottom_shadow, right_shadow)
+        if win:
+            win.close()
 
 
 def _info_dialog_title(node):
@@ -3046,102 +2876,82 @@ def _info_dialog_title(node):
 
 
 def _resize_info_dialog(win, node, lines):
-    # Resizes the info dialog to appropriate size
-
-    screen_height, screen_width = _stdscr.getmaxyx()
+    # Resizes the info dialog to match mconf's dialog_textbox() -- nearly
+    # full-screen: height = screen_height - 4, width = screen_width - 5,
+    # centered on the terminal.
 
-    title = _info_dialog_title(node)
+    screen_height, screen_width = _term.height, _term.width
 
-    # Calculate window dimensions
-    # Height: border(1) + text lines + blank + separator(1) + button + border(1)
-    max_text_lines = min(len(lines), screen_height - 10)
-    win_height = min(max_text_lines + 5, screen_height - 4)
+    # Match dialog_textbox() sizing
+    dlg_height = screen_height - 4
+    dlg_width = screen_width - 5
 
-    # Width from longest line
-    max_line_len = max(len(line) for line in lines) if lines else 40
-    win_width = min(max(max_line_len + 4, len(title) + 4, 30), screen_width - 4)
+    # Clamp to minimums (TEXTBOX_HEIGHT_MIN=8, TEXTBOX_WIDTH_MIN=8)
+    if dlg_height < 8:
+        dlg_height = min(8, screen_height)
+    if dlg_width < 8:
+        dlg_width = min(8, screen_width)
 
-    win.resize(win_height, win_width)
-    win.mvwin((screen_height - win_height) // 2, (screen_width - win_width) // 2)
+    win.resize(dlg_height, dlg_width)
+    win.move((screen_height - dlg_height) // 2, (screen_width - dlg_width) // 2)
 
 
 def _draw_info_dialog(win, node, lines, scroll):
-    # Draws the info dialog matching mconf style
+    # Draws the info dialog matching mconf's dialog_textbox() layout:
+    #   Row 0:           top border with title
+    #   Rows 1..h-4:     text content (boxh = height - 4)
+    #   Row h-3:         separator (LTEE + HLINE + RTEE) with scroll %
+    #   Row h-2:         Exit button
+    #   Row h-1:         bottom border
 
-    win_height, win_width = win.getmaxyx()
+    win_height = win.height
+    win_width = win.width
 
     title = _info_dialog_title(node)
 
-    frame_style = _style.get("dialog-frame", _style["frame"])
+    body_style = _style["body"]
+    border_style = _style.get("border", _style["frame"])
+    title_style = _style.get("title", border_style)
 
-    win.erase()
+    win.clear()
 
-    # Draw box border with frame style
-    _draw_box(win, 0, 0, win_height, win_width, frame_style, frame_style)
+    # Outer box -- same styles as the main dialog
+    _draw_box(win, 0, 0, win_height, win_width, body_style, border_style)
 
-    # Draw title bar
+    # Title centered in top border
     if title:
-        win.attron(frame_style)
-        for i in range(1, win_width - 1):
-            _safe_addch(win, 0, i, ord(" "))
-        _safe_addstr(win, 0, (win_width - len(title)) // 2, title)
-        win.attroff(frame_style)
-
-    # Draw horizontal separator line before buttons (height - 3)
-    win.attron(frame_style)
-    _safe_addch(win, win_height - 3, 0, curses.ACS_LTEE)
-    for i in range(1, win_width - 1):
-        _safe_addch(win, win_height - 3, i, curses.ACS_HLINE)
-    _safe_addch(win, win_height - 3, win_width - 1, curses.ACS_RTEE)
-    win.attroff(frame_style)
-
-    # Text area height: between top border and separator
-    text_area_height = win_height - 4
+        tlen = min(win_width - 2, len(title))
+        title_x = (win_width - tlen) // 2
+        win.write_char(0, title_x - 1, " ", title_style)
+        win.write(0, title_x, title[:tlen], title_style)
+        win.write_char(0, title_x + tlen, " ", title_style)
+
+    # Separator line at height - 3
+    win.write_char(win_height - 3, 0, Box.LTEE, border_style)
+    for j in range(1, win_width - 1):
+        win.write_char(win_height - 3, j, Box.HLINE, border_style)
+    win.write_char(win_height - 3, win_width - 1, Box.RTEE, border_style)
+
+    # Text area: rows 1 .. height-4
+    text_height = win_height - 4
+    text_width = win_width - 3  # borders + 1 space margin
     max_scroll = _max_scroll_info(lines, win)
 
-    # Leave extra space for scrollbar column when content is scrollable
-    text_display_width = win_width - (5 if max_scroll > 0 else 4)
-
-    # Draw text content with body style
-    for i in range(text_area_height):
+    for i in range(text_height):
         line_idx = scroll + i
         if line_idx < len(lines):
-            _safe_addstr(win, 1 + i, 2, lines[line_idx][:text_display_width])
+            win.write(1 + i, 2, lines[line_idx][:text_width], body_style)
 
-    # Draw scrollbar if content is scrollable
-    if max_scroll > 0:
-        _draw_scrollbar(
-            win,
-            scroll,
-            max_scroll,
-            win_width - 2,
-            1,
-            text_area_height,
-            _style["body"],
-            _style.get("selection", _style["body"]),
-        )
-
-    # Scroll percentage in bottom right
+    # Scroll percentage on the separator line (matching mconf position)
     percentage = int((float(scroll) / max_scroll) * 100) if max_scroll > 0 else 100
     percent_str = "({:3d}%)".format(percentage)
-    _safe_addstr(
-        win, win_height - 2, win_width - len(percent_str) - 2, percent_str, frame_style
-    )
-
-    # Draw Exit button at bottom
-    button_y = win_height - 2
-    button_label = " Exit "
-    button_x = (win_width - len(button_label) - 2) // 2
-
-    # Fill button row with frame background
-    win.attrset(frame_style)
-    for i in range(1, win_width - 1):
-        _safe_addch(win, button_y, i, ord(" "))
-
-    # Draw Exit button
-    _print_button(win, button_label, button_y, button_x, True)
+    if win_width > len(percent_str) + 2:
+        win.write(
+            win_height - 3, win_width - len(percent_str) - 2, percent_str, body_style
+        )
 
-    win.noutrefresh()
+    # Exit button at height - 2, centered (matching dialog_textbox)
+    _print_button(win, " Exit ", win_height - 2, win_width // 2 - 4, True)
 
 
 def _max_scroll_info(lines, win):
@@ -3153,47 +2963,121 @@ def _max_scroll_info(lines, win):
 
 
 def _info_str_mconf(node):
-    # Returns information about the menu node 'node' in mconf format.
+    # Returns information about the menu node 'node' in mconf format,
+    # matching menu_get_ext_help() + get_symbol_str() from mconf.c.
 
-    # sc = symbol/choice, or None for MENU/COMMENT
     sc = node.item if isinstance(node.item, (Symbol, Choice)) else None
 
-    lines = []
+    s = ""
 
-    # Help text first (or "no help available")
-    if sc and sc.nodes and sc.nodes[0].help:
-        lines.append(sc.nodes[0].help.rstrip())
-    else:
-        lines.append("There is no help available for this option.")
+    # MENU/COMMENT nodes lack a 'help' slot assignment, so use getattr
+    # to avoid AttributeError.
+    node_help = getattr(node, "help", None)
 
-    lines.append("")
+    # CONFIG_NAME header (only when node has help and symbol/choice has name)
+    if node_help and sc and sc.name:
+        s += "CONFIG_{}:\n\n".format(sc.name)
 
-    # Symbol/choice-specific header line
-    if isinstance(node.item, Symbol):
-        sym = node.item
-        value_str = sym.str_value
-        if sym.orig_type in (BOOL, TRISTATE):
-            value_str = TRI_TO_STR[sym.tri_value]
-        lines.append(
-            "Symbol: {} [={}]".format(sym.name if sym.name else "<unnamed>", value_str)
-        )
-    elif isinstance(node.item, Choice):
-        if node.item.name:
-            lines.append("Choice: {}".format(node.item.name))
+    # Help text or default
+    if node_help:
+        s += node_help.rstrip() + "\n"
+    else:
+        s += "There is no help available for this option.\n"
 
-    # Type, prompt, and location are common to Symbol and Choice
+    # get_symbol_str() equivalent -- only for symbols/choices
     if sc:
-        lines.append("Type  : {}".format(TYPE_TO_STR[sc.orig_type].lower()))
+        # Symbol: NAME [=VALUE] and Type (only if named)
+        if sc.name:
+            s += "Symbol: {} [={}]\n".format(sc.name, sc.str_value)
+            s += "Type  : {}\n".format(TYPE_TO_STR[sc.orig_type].lower())
+            if isinstance(sc, Symbol) and sc.orig_type in (INT, HEX):
+                for low, high, cond in sc.orig_ranges:
+                    if expr_value(cond):
+                        s += "Range : [{}..{}]\n".format(low.str_value, high.str_value)
+                        break
 
-    if node.prompt:
-        lines.append("Prompt: {}".format(node.prompt[0]))
+        # Definitions with prompts first
+        for n in sc.nodes:
+            if n.prompt:
+                s += "Defined at {}:{}\n".format(n.filename, n.linenr)
+                s += "  Prompt: {}\n".format(n.prompt[0])
+                if n.dep is not _kconf.y:
+                    s += "  Depends on: {}\n".format(_expr_str(n.dep))
+                # Location hierarchy (matching get_prompt_str in mconf)
+                submenu = []
+                m = n
+                while m is not _kconf.top_node and len(submenu) < 8:
+                    submenu.append(m)
+                    m = m.parent
+                s += "  Location:\n"
+                for j in range(len(submenu)):
+                    pm = submenu[len(submenu) - 1 - j]
+                    indent = 2 * j + 4
+                    prompt_text = (
+                        pm.prompt[0] if pm.prompt else standard_sc_expr_str(pm.item)
+                    )
+                    s += "{}-> {}".format(" " * indent, prompt_text)
+                    if isinstance(pm.item, (Symbol, Choice)):
+                        name = pm.item.name if pm.item.name else "<choice>"
+                        s += " ({} [={}])".format(name, pm.item.str_value)
+                    s += "\n"
+
+        # Definitions without prompts
+        for n in sc.nodes:
+            if not n.prompt:
+                s += "Defined at {}:{}\n".format(n.filename, n.linenr)
+                if n.dep is not _kconf.y:
+                    s += "  Depends on: {}\n".format(_expr_str(n.dep))
+
+        # Selects (symbols only)
+        if isinstance(sc, Symbol) and sc.selects:
+            sel_strs = [_expr_str(sel_sym) for sel_sym, cond in sc.orig_selects]
+            s += "Selects: {}\n".format(" && ".join(sel_strs))
+
+        # Selected by
+        if isinstance(sc, Symbol) and sc.rev_dep is not _kconf.n:
+            for val, label in (
+                (2, "Selected by [y]:"),
+                (1, "Selected by [m]:"),
+                (0, "Selected by [n]:"),
+            ):
+                sels = [
+                    si for si in split_expr(sc.rev_dep, OR) if expr_value(si) == val
+                ]
+                if sels:
+                    s += label + "\n"
+                    for si in sels:
+                        parts = split_expr(si, AND)
+                        if parts and isinstance(parts[0], Symbol):
+                            s += "  - {}\n".format(parts[0].name)
+
+        # Implies (symbols only)
+        if isinstance(sc, Symbol) and sc.implies:
+            imp_strs = [_expr_str(imp_sym) for imp_sym, cond in sc.orig_implies]
+            s += "Implies: {}\n".format(" && ".join(imp_strs))
+
+        # Implied by
+        if isinstance(sc, Symbol) and sc.weak_rev_dep is not _kconf.n:
+            for val, label in (
+                (2, "Implied by [y]:"),
+                (1, "Implied by [m]:"),
+                (0, "Implied by [n]:"),
+            ):
+                imps = [
+                    si
+                    for si in split_expr(sc.weak_rev_dep, OR)
+                    if expr_value(si) == val
+                ]
+                if imps:
+                    s += label + "\n"
+                    for si in imps:
+                        parts = split_expr(si, AND)
+                        if parts and isinstance(parts[0], Symbol):
+                            s += "  - {}\n".format(parts[0].name)
 
-    if sc and sc.nodes:
-        lines.append(
-            "  Defined at {}:{}".format(sc.nodes[0].filename, sc.nodes[0].linenr)
-        )
+        s += "\n\n"
 
-    return "\n".join(lines)
+    return s
 
 
 def _info_str(node):
@@ -3518,23 +3402,16 @@ def _expr_str(expr):
     return expr_str(expr, _name_and_val_str)
 
 
-def _styled_win(style):
-    # Returns a new curses window with style 'style' and space as the fill
-    # character. The initial dimensions are (1, 1), so the window needs to be
+def _styled_region(style):
+    # Returns a new rawterm Region with style 'style' and space as the fill
+    # character. The initial dimensions are (1, 1), so the region needs to be
     # sized and positioned separately.
 
-    win = curses.newwin(1, 1)
-    _set_style(win, style)
+    win = _term.region(1, 1)
+    win.fill(_style[style])
     return win
 
 
-def _set_style(win, style):
-    # Changes the style of an existing window
-    # Use bkgd() to immediately fill window with background
-
-    win.bkgd(" ", _style[style])
-
-
 def _max_scroll(lst, win):
     # Assuming 'lst' is a list of items to be displayed in 'win',
     # returns the maximum number of steps 'win' can be scrolled down.
@@ -3545,8 +3422,8 @@ def _max_scroll(lst, win):
 
 def _edit_text(c, s, i, hscroll, width):
     # Implements text editing commands for edit boxes. Takes a character (which
-    # could also be e.g. curses.KEY_LEFT) and the edit box state, and returns
-    # the new state after the character has been processed.
+    # could also be e.g. Key.LEFT) and the edit box state, and returns the new
+    # state after the character has been processed.
     #
     # c:
     #   Character from user
@@ -3567,26 +3444,26 @@ def _edit_text(c, s, i, hscroll, width):
     # Return value:
     #   An (s, i, hscroll) tuple for the new state
 
-    if c == curses.KEY_LEFT:
+    if c == Key.LEFT:
         if i > 0:
             i -= 1
 
-    elif c == curses.KEY_RIGHT:
+    elif c == Key.RIGHT:
         if i < len(s):
             i += 1
 
-    elif c in (curses.KEY_HOME, "\x01"):  # \x01 = CTRL-A
+    elif c in (Key.HOME, "\x01"):  # \x01 = CTRL-A
         i = 0
 
-    elif c in (curses.KEY_END, "\x05"):  # \x05 = CTRL-E
+    elif c in (Key.END, "\x05"):  # \x05 = CTRL-E
         i = len(s)
 
-    elif c in (curses.KEY_BACKSPACE, _ERASE_CHAR):
+    elif c == Key.BACKSPACE:
         if i > 0:
             s = s[: i - 1] + s[i:]
             i -= 1
 
-    elif c == curses.KEY_DC:
+    elif c == Key.DELETE:
         s = s[:i] + s[i + 1 :]
 
     elif c == "\x17":  # \x17 = CTRL-W
@@ -3860,101 +3737,18 @@ def _is_num(name):
     return True
 
 
-def _getch_compat(win):
-    # Uses get_wch() if available (Python 3.3+) and getch() otherwise.
-    #
-    # Also falls back on getch() if get_wch() raises curses.error, to work
-    # around an issue when resizing the terminal on at least macOS Catalina.
-    # See https://github.com/ulfalizer/Kconfiglib/issues/84.
-    #
-    # Also handles a PDCurses resizing quirk.
-
-    try:
-        c = win.get_wch()
-    except (AttributeError, curses.error):
-        c = win.getch()
-        if 0 <= c <= 255:
-            c = chr(c)
-
-    # Decent resizing behavior on PDCurses requires calling resize_term(0, 0)
-    # after receiving KEY_RESIZE, while ncurses (usually) handles terminal
-    # resizing automatically in get(_w)ch() (see the end of the
-    # resizeterm(3NCURSES) man page).
-    #
-    # resize_term(0, 0) reliably fails and does nothing on ncurses, so this
-    # hack gives ncurses/PDCurses compatibility for resizing. I don't know
-    # whether it would cause trouble for other implementations.
-    if c == curses.KEY_RESIZE:
-        try:
-            curses.resize_term(0, 0)
-        except curses.error:
-            pass
-
-    return c
-
-
 def _warn(*args):
-    # Temporarily returns from curses to shell mode and prints a warning to
-    # stderr. The warning would get lost in curses mode.
-    curses.endwin()
-    print("menuconfig warning: ", end="", file=sys.stderr)
-    print(*args, file=sys.stderr)
-    curses.doupdate()
-
-
-# Ignore exceptions from some functions that might fail, e.g. for small
-# windows. They usually do reasonable things anyway.
-
-
-def _safe_curs_set(visibility):
+    # Temporarily exits terminal mode and prints a warning to stderr.
+    # The warning would get lost in terminal mode.
     try:
-        curses.curs_set(visibility)
-    except curses.error:
+        _term.suspend()
+    except Exception:
         pass
-
-
-def _safe_addstr(win, *args):
-    # Clip the line to avoid wrapping to the next line, which looks glitchy.
-    # addchstr() would do it for us, but it's not available in the 'curses'
-    # module.
-
-    attr = None
-    if isinstance(args[0], str):
-        y, x = win.getyx()
-        s = args[0]
-        if len(args) == 2:
-            attr = args[1]
-    else:
-        y, x, s = args[:3]
-        if len(args) == 4:
-            attr = args[3]
-
-    maxlen = _width(win) - x
-    s = s.expandtabs()
-
-    try:
-        # The 'curses' module uses wattr_set() internally if you pass 'attr',
-        # overwriting the background style, so setting 'attr' to 0 in the first
-        # case won't do the right thing
-        if attr is None:
-            win.addnstr(y, x, s, maxlen)
-        else:
-            win.addnstr(y, x, s, maxlen, attr)
-    except curses.error:
-        pass
-
-
-def _safe_addch(win, *args):
-    try:
-        win.addch(*args)
-    except curses.error:
-        pass
-
-
-def _safe_move(win, *args):
+    print("menuconfig warning: ", end="", file=sys.stderr)
+    print(*args, file=sys.stderr)
     try:
-        win.move(*args)
-    except curses.error:
+        _term.resume()
+    except Exception:
         pass
 
 
diff --git a/rawterm.py b/rawterm.py
new file mode 100644
index 0000000..a9d0de5
--- /dev/null
+++ b/rawterm.py
@@ -0,0 +1,1143 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2026 Kconfiglib contributors
+# SPDX-License-Identifier: ISC
+
+"""
+rawterm -- pure-Python terminal I/O for menuconfig
+
+NOT a curses emulation layer. A clean API designed from menuconfig's
+functional requirements: rectangular screen regions, styled text output,
+staged updates with frame diffing, and keyboard input including function
+keys.
+
+Zero external dependencies. Uses only Python stdlib: termios, select,
+signal, shutil, os, sys, codecs, unicodedata on Unix; ctypes on Windows.
+
+Platform support:
+  - Unix (Linux, macOS): termios cbreak mode, poll(2)-based input
+  - Windows 10 build 1511+: VT100 output via SetConsoleMode,
+    three input paths (VT100, ReadConsoleInputW, MSYS2/mintty PTY)
+
+Minimum: Python 3.6+, any VT100-capable terminal.
+"""
+
+import atexit
+import codecs
+import os
+import shutil
+import signal
+import sys
+import unicodedata
+
+_IS_WINDOWS = os.name == "nt"
+
+if not _IS_WINDOWS:
+    import select
+    import termios
+    import tty
+
+
+# ---------------------------------------------------------------------------
+# Colors
+# ---------------------------------------------------------------------------
+
+
+class Color:
+    """Terminal color: named constant, 256-color index, or 24-bit RGB."""
+
+    __slots__ = ("_kind", "_value")
+
+    # kind: "default", "named", "index", "rgb"
+    def __init__(self, kind, value):
+        self._kind = kind
+        self._value = value
+
+    # Predefined named colors (indices 0-7 in standard palette)
+    DEFAULT = None  # will be assigned below
+
+    BLACK = None
+    RED = None
+    GREEN = None
+    YELLOW = None
+    BLUE = None
+    MAGENTA = None
+    CYAN = None
+    WHITE = None
+
+    # Bright variants (indices 8-15)
+    BRIGHT_BLACK = None
+    BRIGHT_RED = None
+    BRIGHT_GREEN = None
+    BRIGHT_YELLOW = None
+    BRIGHT_BLUE = None
+    BRIGHT_MAGENTA = None
+    BRIGHT_CYAN = None
+    BRIGHT_WHITE = None
+
+    @staticmethod
+    def rgb(r, g, b):
+        """Create a 24-bit RGB color."""
+        return Color("rgb", (r, g, b))
+
+    @staticmethod
+    def index(n):
+        """Create a color from xterm 256-color palette index."""
+        return Color("index", n)
+
+    def _sgr_fg(self):
+        """Return SGR escape for foreground."""
+        if self._kind == "default":
+            return "39"
+        if self._kind == "named":
+            idx = self._value
+            if idx < 8:
+                return str(30 + idx)
+            return str(90 + idx - 8)
+        if self._kind == "index":
+            return "38;5;{}".format(self._value)
+        r, g, b = self._value
+        return "38;2;{};{};{}".format(r, g, b)
+
+    def _sgr_bg(self):
+        """Return SGR escape for background."""
+        if self._kind == "default":
+            return "49"
+        if self._kind == "named":
+            idx = self._value
+            if idx < 8:
+                return str(40 + idx)
+            return str(100 + idx - 8)
+        if self._kind == "index":
+            return "48;5;{}".format(self._value)
+        r, g, b = self._value
+        return "48;2;{};{};{}".format(r, g, b)
+
+    def __eq__(self, other):
+        if not isinstance(other, Color):
+            return NotImplemented
+        return self._kind == other._kind and self._value == other._value
+
+    def __hash__(self):
+        return hash((self._kind, self._value))
+
+    # Reverse map filled after named constants are created
+    _NAMED_REPRS = {}
+
+    def __repr__(self):
+        if self._kind == "default":
+            return "Color.DEFAULT"
+        if self._kind == "named":
+            return Color._NAMED_REPRS.get(
+                self._value, "Color('named', {})".format(self._value)
+            )
+        if self._kind == "index":
+            return "Color.index({})".format(self._value)
+        return "Color.rgb({},{},{})".format(*self._value)
+
+
+# Initialize named color constants
+Color.DEFAULT = Color("default", None)
+Color.BLACK = Color("named", 0)
+Color.RED = Color("named", 1)
+Color.GREEN = Color("named", 2)
+Color.YELLOW = Color("named", 3)
+Color.BLUE = Color("named", 4)
+Color.MAGENTA = Color("named", 5)
+Color.CYAN = Color("named", 6)
+Color.WHITE = Color("named", 7)
+Color.BRIGHT_BLACK = Color("named", 8)
+Color.BRIGHT_RED = Color("named", 9)
+Color.BRIGHT_GREEN = Color("named", 10)
+Color.BRIGHT_YELLOW = Color("named", 11)
+Color.BRIGHT_BLUE = Color("named", 12)
+Color.BRIGHT_MAGENTA = Color("named", 13)
+Color.BRIGHT_CYAN = Color("named", 14)
+Color.BRIGHT_WHITE = Color("named", 15)
+
+# Populate reverse map for __repr__
+for _attr in dir(Color):
+    _obj = getattr(Color, _attr)
+    if isinstance(_obj, Color) and _obj._kind == "named":
+        Color._NAMED_REPRS[_obj._value] = "Color." + _attr
+del _attr, _obj
+
+# Map curses-style color names to Color constants (used by menuconfig style
+# parser)
+NAMED_COLORS = {
+    "black": Color.BLACK,
+    "red": Color.RED,
+    "green": Color.GREEN,
+    "yellow": Color.YELLOW,
+    "blue": Color.BLUE,
+    "magenta": Color.MAGENTA,
+    "cyan": Color.CYAN,
+    "white": Color.WHITE,
+    "purple": Color.MAGENTA,
+    "brightblack": Color.BRIGHT_BLACK,
+    "brightred": Color.BRIGHT_RED,
+    "brightgreen": Color.BRIGHT_GREEN,
+    "brightyellow": Color.BRIGHT_YELLOW,
+    "brightblue": Color.BRIGHT_BLUE,
+    "brightmagenta": Color.BRIGHT_MAGENTA,
+    "brightcyan": Color.BRIGHT_CYAN,
+    "brightwhite": Color.BRIGHT_WHITE,
+    "brightpurple": Color.BRIGHT_MAGENTA,
+}
+
+
+# ---------------------------------------------------------------------------
+# Style
+# ---------------------------------------------------------------------------
+
+
+class Style:
+    """Immutable style combining foreground, background, and attributes."""
+
+    __slots__ = ("fg", "bg", "bold", "standout", "underline", "_sgr_cache")
+
+    def __init__(self, fg=None, bg=None, bold=False, standout=False, underline=False):
+        self.fg = fg if fg is not None else Color.DEFAULT
+        self.bg = bg if bg is not None else Color.DEFAULT
+        self.bold = bold
+        self.standout = standout
+        self.underline = underline
+        self._sgr_cache = None
+
+    def __or__(self, other):
+        """Combine two styles. 'other' overrides non-default fields."""
+        if not isinstance(other, Style):
+            return NotImplemented
+        return Style(
+            fg=other.fg if other.fg != Color.DEFAULT else self.fg,
+            bg=other.bg if other.bg != Color.DEFAULT else self.bg,
+            bold=self.bold or other.bold,
+            standout=self.standout or other.standout,
+            underline=self.underline or other.underline,
+        )
+
+    def sgr(self):
+        """Return the SGR escape sequence string for this style."""
+        if self._sgr_cache is not None:
+            return self._sgr_cache
+
+        parts = ["0"]  # reset first
+        parts.append(self.fg._sgr_fg())
+        parts.append(self.bg._sgr_bg())
+        if self.bold:
+            parts.append("1")
+        if self.underline:
+            parts.append("4")
+        if self.standout:
+            parts.append("7")
+
+        self._sgr_cache = "\x1b[{}m".format(";".join(parts))
+        return self._sgr_cache
+
+    def __eq__(self, other):
+        if not isinstance(other, Style):
+            return NotImplemented
+        return (
+            self.fg == other.fg
+            and self.bg == other.bg
+            and self.bold == other.bold
+            and self.standout == other.standout
+            and self.underline == other.underline
+        )
+
+    def __hash__(self):
+        return hash((self.fg, self.bg, self.bold, self.standout, self.underline))
+
+    def __repr__(self):
+        parts = []
+        if self.fg != Color.DEFAULT:
+            parts.append("fg={}".format(self.fg))
+        if self.bg != Color.DEFAULT:
+            parts.append("bg={}".format(self.bg))
+        if self.bold:
+            parts.append("bold")
+        if self.standout:
+            parts.append("standout")
+        if self.underline:
+            parts.append("underline")
+        return "Style({})".format(", ".join(parts))
+
+
+# Default style (terminal defaults, no attributes)
+STYLE_DEFAULT = Style()
+
+
+# ---------------------------------------------------------------------------
+# Input constants
+# ---------------------------------------------------------------------------
+
+
+class Key:
+    """Named constants for special keys."""
+
+    UP = "key_up"
+    DOWN = "key_down"
+    LEFT = "key_left"
+    RIGHT = "key_right"
+    PAGE_UP = "key_page_up"
+    PAGE_DOWN = "key_page_down"
+    HOME = "key_home"
+    END = "key_end"
+    BACKSPACE = "key_backspace"
+    DELETE = "key_delete"
+    RESIZE = "key_resize"
+
+
+# ---------------------------------------------------------------------------
+# Box-drawing characters (Unicode, no ACS_ needed)
+# ---------------------------------------------------------------------------
+
+
+class Box:
+    HLINE = "\u2500"  # ─
+    VLINE = "\u2502"  # │
+    ULCORNER = "\u250c"  # ┌
+    URCORNER = "\u2510"  # ┐
+    LLCORNER = "\u2514"  # └
+    LRCORNER = "\u2518"  # ┘
+    LTEE = "\u251c"  # ├
+    RTEE = "\u2524"  # ┤
+    DARROW = "\u2193"  # ↓
+    UARROW = "\u2191"  # ↑
+    RARROW = "\u2192"  # →
+
+
+# ---------------------------------------------------------------------------
+# Character width
+# ---------------------------------------------------------------------------
+
+
+def _char_width(ch):
+    """Return the display width of a character in terminal cells.
+
+    - ASCII printable (0x20-0x7E): 1 cell (fast path)
+    - East Asian Wide/Fullwidth: 2 cells
+    - Combining marks, control chars: 0 cells
+    - Everything else: 1 cell
+    """
+    o = ord(ch)
+
+    # Fast path for ASCII
+    if 0x20 <= o <= 0x7E:
+        return 1
+
+    # Control characters
+    if o < 0x20 or o == 0x7F:
+        return 0
+
+    # Check east asian width
+    eaw = unicodedata.east_asian_width(ch)
+    if eaw in ("W", "F"):
+        return 2
+
+    # Combining marks
+    cat = unicodedata.category(ch)
+    if cat.startswith("M"):
+        return 0
+
+    return 1
+
+
+def _str_width(s):
+    """Return the display width of a string in terminal cells."""
+    w = 0
+    for ch in s:
+        w += _char_width(ch)
+    return w
+
+
+# ---------------------------------------------------------------------------
+# Escape sequence trie for input parsing
+# ---------------------------------------------------------------------------
+
+# Map escape sequences to Key constants. Multiple entries per key to
+# handle terminal variants (xterm, rxvt, tmux, application mode).
+_ESCAPE_SEQUENCES = {
+    # Arrow keys
+    "\x1b[A": Key.UP,
+    "\x1bOA": Key.UP,  # application mode
+    "\x1b[B": Key.DOWN,
+    "\x1bOB": Key.DOWN,
+    "\x1b[C": Key.RIGHT,
+    "\x1bOC": Key.RIGHT,
+    "\x1b[D": Key.LEFT,
+    "\x1bOD": Key.LEFT,
+    # Page Up / Page Down
+    "\x1b[5~": Key.PAGE_UP,
+    "\x1b[6~": Key.PAGE_DOWN,
+    # Home
+    "\x1b[H": Key.HOME,  # xterm
+    "\x1bOH": Key.HOME,  # application mode
+    "\x1b[1~": Key.HOME,  # tmux/linux
+    "\x1b[7~": Key.HOME,  # rxvt
+    # End
+    "\x1b[F": Key.END,  # xterm
+    "\x1bOF": Key.END,  # application mode
+    "\x1b[4~": Key.END,  # tmux/linux
+    "\x1b[8~": Key.END,  # rxvt
+    # Delete
+    "\x1b[3~": Key.DELETE,
+}
+
+
+def _build_trie(sequences):
+    """Build a trie (nested dict) from escape sequence table."""
+    root = {}
+    for seq, key in sequences.items():
+        node = root
+        for ch in seq[:-1]:
+            if ch not in node:
+                node[ch] = {}
+            node = node[ch]
+        node[seq[-1]] = key
+    return root
+
+
+_ESCAPE_TRIE = _build_trie(_ESCAPE_SEQUENCES)
+
+
+# ---------------------------------------------------------------------------
+# Region -- rectangular cell buffer
+# ---------------------------------------------------------------------------
+
+
+class Region:
+    """Rectangular cell buffer with position, size, and dirty tracking.
+
+    Created via terminal.region(), not standalone constructor.
+    """
+
+    def __init__(self, terminal, height, width, y, x):
+        self._terminal = terminal
+        self._height = height
+        self._width = width
+        self._y = y
+        self._x = x
+        self._dirty = True
+        self._fill_style = STYLE_DEFAULT
+        # Cell buffer: list of rows, each row is list of (char, style) tuples
+        self._cells = self._make_cells(height, width)
+
+    def _make_cells(self, height, width):
+        default = (" ", self._fill_style)
+        return [[default] * width for _ in range(height)]
+
+    @property
+    def height(self):
+        return self._height
+
+    @property
+    def width(self):
+        return self._width
+
+    @property
+    def y(self):
+        return self._y
+
+    @property
+    def x(self):
+        return self._x
+
+    def close(self):
+        """Unregister from compositor."""
+        if self._terminal:
+            try:
+                self._terminal._regions.remove(self)
+            except ValueError:
+                pass
+            if self._terminal._cursor_region is self:
+                self._terminal._cursor_region = None
+            self._terminal = None
+
+    def resize(self, height, width):
+        """Resize the region, clearing its contents."""
+        self._height = height
+        self._width = width
+        self._cells = self._make_cells(height, width)
+        self._dirty = True
+
+    def move(self, y, x):
+        """Move the region to a new position."""
+        self._y = y
+        self._x = x
+        self._dirty = True
+
+    def clear(self):
+        """Clear the region to spaces using the stored fill style."""
+        self.fill(self._fill_style)
+
+    def fill(self, style):
+        """Set background style for entire region and remember it for clear()."""
+        self._fill_style = style
+        cell = (" ", style)
+        for row in self._cells:
+            for j in range(len(row)):
+                row[j] = cell
+        self._dirty = True
+
+    def write(self, y, x, text, style=None, max_len=None):
+        """Write text at (y, x) with optional style. Clips to region bounds.
+
+        Returns number of cells written (useful for cursor positioning
+        after CJK characters).
+        """
+        if style is None:
+            style = STYLE_DEFAULT
+        if y < 0 or y >= self._height or x >= self._width:
+            return 0
+
+        text = text.expandtabs()
+        col = x
+        cells_written = 0
+
+        for ch in text:
+            if max_len is not None and cells_written >= max_len:
+                break
+
+            w = _char_width(ch)
+            if w == 0:
+                continue
+
+            if col < 0:
+                col += w
+                continue
+
+            if col + w > self._width:
+                # Wide char would overflow -- stop
+                break
+
+            self._cells[y][col] = (ch, style)
+            cells_written += w
+
+            # For wide (CJK) chars, fill the second cell with a placeholder
+            if w == 2 and col + 1 < self._width:
+                self._cells[y][col + 1] = ("", style)
+
+            col += w
+
+        self._dirty = True
+        return cells_written
+
+    def write_char(self, y, x, char, style=None):
+        """Write a single character at (y, x)."""
+        if style is None:
+            style = STYLE_DEFAULT
+        if y < 0 or y >= self._height or x < 0 or x >= self._width:
+            return
+
+        w = _char_width(char)
+        if x + w > self._width:
+            return
+
+        self._cells[y][x] = (char, style)
+        if w == 2 and x + 1 < self._width:
+            self._cells[y][x + 1] = ("", style)
+
+        self._dirty = True
+
+    def getyx(self):
+        """Compatibility: return (y, x) position. Always (0, 0) for regions."""
+        return (0, 0)
+
+
+# ---------------------------------------------------------------------------
+# Terminal
+# ---------------------------------------------------------------------------
+
+
+class Terminal:
+    """Manages terminal state, screen compositing, and input."""
+
+    def __init__(self):
+        if not _IS_WINDOWS:
+            if not os.isatty(sys.stdin.fileno()):
+                raise RuntimeError("stdin is not a terminal")
+            if not os.isatty(sys.stdout.fileno()):
+                raise RuntimeError("stdout is not a terminal")
+
+        self._regions = []
+        self._cursor_region = None
+        self._cursor_y = 0
+        self._cursor_x = 0
+        self._cursor_visible = False
+        self._cursor_very_visible = False
+        self._suspended = False
+        self._resize_pending = False
+        self._prev_frame = None  # Previous frame for diffing
+
+        # Query initial terminal size
+        sz = shutil.get_terminal_size()
+        self._width = sz.columns
+        self._height = sz.lines
+
+        # Platform-specific init
+        if _IS_WINDOWS:
+            self._init_windows()
+        else:
+            self._init_unix()
+
+        # Enter alternate screen
+        self._write_raw("\x1b[?1049h")
+        # Hide cursor by default
+        self._write_raw("\x1b[?25l")
+        self._flush()
+
+    def _init_unix(self):
+        """Set up Unix terminal: cbreak mode, SIGWINCH."""
+        fd = sys.stdin.fileno()
+        self._old_termios = termios.tcgetattr(fd)
+
+        new = termios.tcgetattr(fd)
+        # LFLAG: clear ICANON, ECHO, IEXTEN; keep ISIG for Ctrl-C
+        new[3] &= ~(termios.ICANON | termios.ECHO | termios.IEXTEN)
+        # IFLAG: clear IXON, IXOFF, ICRNL, INLCR, IGNCR
+        new[1] &= ~(
+            termios.IXON | termios.IXOFF | termios.ICRNL | termios.INLCR | termios.IGNCR
+        )
+        # Set VMIN=1 (Solaris: VMIN shares slot with VEOF)
+        new[6][termios.VMIN] = 1
+        new[6][termios.VTIME] = 0
+        termios.tcsetattr(fd, termios.TCSANOW, new)
+
+        # UTF-8 incremental decoder for input
+        self._decoder = codecs.getincrementaldecoder("utf-8")("replace")
+
+        # Escape sequence parser state
+        self._esc_buf = []
+        self._esc_node = None
+        self._pending_key = None
+
+        # SIGWINCH handler
+        self._old_sigwinch = signal.getsignal(signal.SIGWINCH)
+        signal.signal(signal.SIGWINCH, self._sigwinch_handler)
+
+        # Poller for input readability checks
+        self._poller = select.poll()
+        self._poller.register(sys.stdin.fileno(), select.POLLIN)
+
+    def _init_windows(self):
+        """Set up Windows terminal: VT100 output, console input."""
+        import ctypes
+        from ctypes import wintypes
+
+        kernel32 = ctypes.windll.kernel32
+
+        # Get handles
+        STD_INPUT_HANDLE = -10
+        STD_OUTPUT_HANDLE = -11
+        self._stdin_handle = kernel32.GetStdHandle(STD_INPUT_HANDLE)
+        self._stdout_handle = kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
+
+        # Save original console modes
+        self._old_out_mode = wintypes.DWORD()
+        kernel32.GetConsoleMode(self._stdout_handle, ctypes.byref(self._old_out_mode))
+        self._old_in_mode = wintypes.DWORD()
+        kernel32.GetConsoleMode(self._stdin_handle, ctypes.byref(self._old_in_mode))
+
+        # Enable VT100 output
+        ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+        new_out = self._old_out_mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING
+        kernel32.SetConsoleMode(self._stdout_handle, new_out)
+
+        # Try VT100 input
+        ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200
+        self._win_vt_input = False
+        new_in = (self._old_in_mode.value | ENABLE_VIRTUAL_TERMINAL_INPUT) & ~(
+            0x0004 | 0x0002 | 0x0001
+        )  # clear ECHO, LINE, PROCESSED
+        if kernel32.SetConsoleMode(self._stdin_handle, new_in):
+            self._win_vt_input = True
+            self._decoder = codecs.getincrementaldecoder("utf-8")("replace")
+            self._esc_buf = []
+            self._esc_node = None
+            self._pending_key = None
+        else:
+            # Fall back to ReadConsoleInputW
+            new_in = self._old_in_mode.value & ~(0x0004 | 0x0002 | 0x0001)
+            new_in |= 0x0008  # ENABLE_WINDOW_INPUT
+            kernel32.SetConsoleMode(self._stdin_handle, new_in)
+
+        self._kernel32 = kernel32
+
+    def close(self):
+        """Restore terminal state."""
+        # Show cursor
+        self._write_raw("\x1b[?25h")
+        # Leave alternate screen
+        self._write_raw("\x1b[?1049l")
+        # Reset attributes
+        self._write_raw("\x1b[0m")
+        self._flush()
+
+        if _IS_WINDOWS:
+            self._kernel32.SetConsoleMode(self._stdout_handle, self._old_out_mode)
+            self._kernel32.SetConsoleMode(self._stdin_handle, self._old_in_mode)
+        else:
+            # Restore termios
+            fd = sys.stdin.fileno()
+            termios.tcsetattr(fd, termios.TCSANOW, self._old_termios)
+            # Restore SIGWINCH handler
+            signal.signal(signal.SIGWINCH, self._old_sigwinch)
+
+    @property
+    def width(self):
+        return self._width
+
+    @property
+    def height(self):
+        return self._height
+
+    def region(self, height, width, y=0, x=0):
+        """Create and register a new Region."""
+        r = Region(self, height, width, y, x)
+        self._regions.append(r)
+        return r
+
+    def hide_cursor(self):
+        self._cursor_visible = False
+        self._cursor_very_visible = False
+
+    def show_cursor(self, very_visible=False):
+        self._cursor_visible = True
+        self._cursor_very_visible = very_visible
+
+    def set_cursor(self, region, y, x):
+        """Position cursor in a region (for edit fields)."""
+        self._cursor_region = region
+        self._cursor_y = y
+        self._cursor_x = x
+
+    def suspend(self):
+        """Temporarily exit for stderr output."""
+        self._suspended = True
+        # Leave alternate screen, show cursor, restore terminal
+        self._write_raw("\x1b[?25h")
+        self._write_raw("\x1b[?1049l")
+        self._write_raw("\x1b[0m")
+        self._flush()
+
+        if not _IS_WINDOWS:
+            fd = sys.stdin.fileno()
+            termios.tcsetattr(fd, termios.TCSANOW, self._old_termios)
+
+    def resume(self):
+        """Re-enter terminal mode after suspend."""
+        if not _IS_WINDOWS:
+            fd = sys.stdin.fileno()
+            new = termios.tcgetattr(fd)
+            new[3] &= ~(termios.ICANON | termios.ECHO | termios.IEXTEN)
+            new[1] &= ~(
+                termios.IXON
+                | termios.IXOFF
+                | termios.ICRNL
+                | termios.INLCR
+                | termios.IGNCR
+            )
+            new[6][termios.VMIN] = 1
+            new[6][termios.VTIME] = 0
+            termios.tcsetattr(fd, termios.TCSANOW, new)
+
+        # Re-enter alternate screen
+        self._write_raw("\x1b[?1049h")
+        if not self._cursor_visible:
+            self._write_raw("\x1b[?25l")
+        self._flush()
+
+        # Requery terminal size
+        sz = shutil.get_terminal_size()
+        old_w, old_h = self._width, self._height
+        self._width = sz.columns
+        self._height = sz.lines
+
+        # Force full repaint
+        self._prev_frame = None
+        for r in self._regions:
+            r._dirty = True
+
+        self._suspended = False
+
+        # Queue resize if dimensions changed during suspend
+        if old_w != self._width or old_h != self._height:
+            self._resize_pending = True
+
+    def _sigwinch_handler(self, signum, frame):
+        """SIGWINCH: set flag, don't resize mid-render."""
+        self._resize_pending = True
+
+    def _check_resize(self):
+        """Check and handle pending resize."""
+        if self._resize_pending:
+            self._resize_pending = False
+            sz = shutil.get_terminal_size()
+            self._width = sz.columns
+            self._height = sz.lines
+            self._prev_frame = None  # force full repaint
+            # Clear screen so full repaint starts from clean slate.
+            # Terminal emulators may garble the alternate screen on resize.
+            self._write_raw("\x1b[2J")
+            self._flush()
+            return True
+        return False
+
+    # --- Output ---
+
+    def _write_raw(self, s):
+        """Append raw string to output. Caller must call _flush()."""
+        # We write to stdout.buffer for binary safety
+        try:
+            sys.stdout.buffer.write(s.encode("utf-8"))
+        except OSError:
+            pass
+
+    def _flush(self):
+        """Flush stdout."""
+        try:
+            # Ensure blocking I/O for flush
+            fd = sys.stdout.fileno()
+            was_blocking = os.get_blocking(fd)
+            if not was_blocking:
+                os.set_blocking(fd, True)
+            try:
+                sys.stdout.buffer.flush()
+            finally:
+                if not was_blocking:
+                    os.set_blocking(fd, False)
+        except OSError:
+            pass
+
+    def update(self):
+        """Composite all regions and flush to terminal.
+
+        Painter's algorithm: render regions back-to-front by registration
+        order. Frame diffing: only emit ANSI for changed cells.
+        """
+        if self._suspended:
+            return
+
+        h = self._height
+        w = self._width
+
+        # Build current frame: 2D array of (char, style)
+        default_cell = (" ", STYLE_DEFAULT)
+        frame = [[default_cell] * w for _ in range(h)]
+
+        # Painter's algorithm: paint regions in order (later = on top)
+        for region in self._regions:
+            ry, rx = region._y, region._x
+            rh, rw = region._height, region._width
+            for row in range(rh):
+                screen_row = ry + row
+                if screen_row < 0 or screen_row >= h:
+                    continue
+                for col in range(rw):
+                    screen_col = rx + col
+                    if screen_col < 0 or screen_col >= w:
+                        continue
+                    cell = region._cells[row][col]
+                    if cell[0] != "":  # skip wide-char placeholders
+                        frame[screen_row][screen_col] = cell
+
+        # Diff against previous frame and emit changes
+        buf = []
+        prev = self._prev_frame
+
+        last_style = None
+        last_row = -1
+        last_col = -1
+
+        for row in range(h):
+            for col in range(w):
+                cell = frame[row][col]
+                if prev and prev[row][col] == cell:
+                    continue
+
+                ch, style = cell
+
+                # Move cursor if not contiguous
+                if row != last_row or col != last_col:
+                    buf.append("\x1b[{};{}H".format(row + 1, col + 1))
+
+                # Set style if changed
+                if style != last_style:
+                    buf.append(style.sgr())
+                    last_style = style
+
+                if ch:
+                    buf.append(ch)
+                else:
+                    buf.append(" ")
+
+                cw = _char_width(ch) if ch else 1
+                last_row = row
+                last_col = col + cw
+
+        # Handle cursor visibility and position
+        if self._cursor_visible and self._cursor_region:
+            r = self._cursor_region
+            abs_y = r._y + self._cursor_y
+            abs_x = r._x + self._cursor_x
+            buf.append("\x1b[{};{}H".format(abs_y + 1, abs_x + 1))
+            if self._cursor_very_visible:
+                buf.append("\x1b[?12;25h")  # blink + show
+            else:
+                buf.append("\x1b[?12l\x1b[?25h")  # no blink + show
+        elif not self._cursor_visible:
+            buf.append("\x1b[?25l")
+
+        if buf:
+            self._write_raw("".join(buf))
+            self._flush()
+
+        self._prev_frame = frame
+
+    # --- Input ---
+
+    def read_key(self):
+        """Block and return next key event: Key constant or str character.
+
+        Esc returned as "\\x1b" (after timeout to disambiguate from
+        escape sequences). Regular characters returned as str.
+        """
+        if self._suspended:
+            raise RuntimeError("terminal is suspended")
+
+        # Return any key buffered from a previous escape dead-end
+        if self._pending_key is not None:
+            pending = self._pending_key
+            self._pending_key = None
+            return pending
+
+        # Check for pending resize first
+        if self._check_resize():
+            return Key.RESIZE
+
+        if _IS_WINDOWS:
+            return self._read_key_windows()
+        return self._read_key_unix()
+
+    def _read_key_unix(self):
+        """Read key on Unix using os.read + escape parser."""
+        fd = sys.stdin.fileno()
+
+        while True:
+            try:
+                data = os.read(fd, 1024)
+            except OSError:
+                # EINTR from SIGWINCH
+                if self._check_resize():
+                    return Key.RESIZE
+                continue
+
+            if not data:
+                continue
+
+            chars = self._decoder.decode(data)
+
+            for ch in chars:
+                result = self._feed_escape(ch)
+                if result is not None:
+                    return result
+
+            # If we have a partial escape sequence, wait briefly for more
+            if self._esc_buf:
+                if self._poller.poll(25):
+                    # More data available, keep reading
+                    continue
+                # Timeout -- flush escape buffer
+                result = self._flush_escape()
+                if result is not None:
+                    return result
+
+            # Check resize
+            if self._check_resize():
+                return Key.RESIZE
+
+    def _feed_escape(self, ch):
+        """Feed a character to the escape sequence parser.
+
+        Returns a Key constant or str if a complete key was parsed,
+        or None if more input is needed.
+        """
+        if self._esc_node is not None:
+            # We're in the middle of an escape sequence
+            if ch not in self._esc_node:
+                # Dead end -- flush first (before _feed_char can
+                # overwrite _esc_buf when ch is ESC), then buffer ch
+                result = self._flush_escape()
+                self._pending_key = self._feed_char(ch)
+                return result
+
+            val = self._esc_node[ch]
+            if isinstance(val, dict):
+                # More characters expected
+                self._esc_buf.append(ch)
+                self._esc_node = val
+                return None
+
+            # Complete match
+            self._esc_buf = []
+            self._esc_node = None
+            return val
+
+        return self._feed_char(ch)
+
+    def _feed_char(self, ch):
+        """Process a non-escape-sequence character."""
+        if ch == "\x1b":
+            # Start of potential escape sequence
+            self._esc_buf = [ch]
+            self._esc_node = _ESCAPE_TRIE["\x1b"]
+            return None
+
+        if ch == "\x7f":
+            return Key.BACKSPACE
+
+        # Normalize CR to LF so callers can check "\n" for Enter.
+        # On Unix, ICRNL is cleared for raw input; on Windows,
+        # msvcrt.getwch() and ReadConsoleInputW both return "\r".
+        if ch == "\r":
+            return "\n"
+
+        return ch
+
+    def _flush_escape(self):
+        """Flush partial escape sequence buffer, returning first char."""
+        if not self._esc_buf:
+            return None
+
+        # The first char is always ESC
+        self._esc_buf = []
+        self._esc_node = None
+        return "\x1b"
+
+    def _read_key_windows(self):
+        """Read key on Windows."""
+        if self._win_vt_input:
+            return self._read_key_windows_vt()
+        return self._read_key_windows_console()
+
+    def _read_key_windows_vt(self):
+        """Windows VT100 input mode -- reuse Unix escape parser."""
+        import msvcrt
+
+        while True:
+            if msvcrt.kbhit():
+                ch = msvcrt.getwch()
+                result = self._feed_escape(ch)
+                if result is not None:
+                    return result
+            else:
+                if self._esc_buf:
+                    result = self._flush_escape()
+                    if result is not None:
+                        return result
+                if self._check_resize():
+                    return Key.RESIZE
+                # Small sleep to avoid busy-wait
+                import time
+
+                time.sleep(0.01)
+
+    def _read_key_windows_console(self):
+        """Windows console input via ReadConsoleInputW."""
+        import ctypes
+        from ctypes import wintypes
+
+        kernel32 = self._kernel32
+
+        # VK code to Key constant mapping
+        VK_MAP = {
+            33: Key.PAGE_UP,
+            34: Key.PAGE_DOWN,
+            35: Key.END,
+            36: Key.HOME,
+            37: Key.LEFT,
+            38: Key.UP,
+            39: Key.RIGHT,
+            40: Key.DOWN,
+            46: Key.DELETE,
+        }
+
+        class KEY_EVENT_RECORD(ctypes.Structure):
+            _fields_ = [
+                ("bKeyDown", wintypes.BOOL),
+                ("wRepeatCount", wintypes.WORD),
+                ("wVirtualKeyCode", wintypes.WORD),
+                ("wVirtualScanCode", wintypes.WORD),
+                ("uChar", wintypes.WCHAR),
+                ("dwControlKeyState", wintypes.DWORD),
+            ]
+
+        class INPUT_RECORD(ctypes.Structure):
+            class _Event(ctypes.Union):
+                _fields_ = [("KeyEvent", KEY_EVENT_RECORD)]
+
+            _fields_ = [
+                ("EventType", wintypes.WORD),
+                ("Event", _Event),
+            ]
+
+        KEY_EVENT = 0x0001
+        WINDOW_BUFFER_SIZE_EVENT = 0x0004
+
+        ir = INPUT_RECORD()
+        n_read = wintypes.DWORD()
+
+        while True:
+            kernel32.ReadConsoleInputW(
+                self._stdin_handle, ctypes.byref(ir), 1, ctypes.byref(n_read)
+            )
+
+            if ir.EventType == KEY_EVENT:
+                ke = ir.Event.KeyEvent
+                if not ke.bKeyDown:
+                    continue
+
+                vk = ke.wVirtualKeyCode
+                ch = ke.uChar
+
+                if vk in VK_MAP:
+                    return VK_MAP[vk]
+
+                if vk == 8:  # VK_BACK
+                    return Key.BACKSPACE
+
+                if vk == 27:  # VK_ESCAPE
+                    return "\x1b"
+
+                if ch and ch != "\0":
+                    return self._feed_char(ch)
+
+            elif ir.EventType == WINDOW_BUFFER_SIZE_EVENT:
+                self._resize_pending = True
+                if self._check_resize():
+                    return Key.RESIZE
+
+
+# ---------------------------------------------------------------------------
+# Safe entry point
+# ---------------------------------------------------------------------------
+
+
+def run(fn):
+    """Safe wrapper: init terminal, call fn(terminal), restore on exit.
+
+    Catches KeyboardInterrupt (Ctrl-C via SIGINT) and always restores
+    terminal state.
+    """
+    term = None
+    try:
+        term = Terminal()
+        # Register atexit as safety net
+        atexit.register(lambda: term.close() if term else None)
+        return fn(term)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        if term:
+            term.close()
diff --git a/setup.py b/setup.py
index c8b9f32..0265e1f 100644
--- a/setup.py
+++ b/setup.py
@@ -21,6 +21,7 @@
     license="ISC",
     py_modules=(
         "kconfiglib",
+        "rawterm",
         "menuconfig",
         "guiconfig",
         "genconfig",
@@ -52,8 +53,8 @@
             "setconfig = setconfig:main",
         )
     },
-    # Note: windows-curses is not automatically installed on Windows anymore,
-    # because it made Kconfiglib impossible to install on MSYS2 with pip
+    # No C extensions or third-party dependencies required.
+    # menuconfig uses pure-Python terminal I/O instead of curses.
     python_requires=">=3.6",
     project_urls={
         "GitHub repository": "https://github.com/sysprog21/Kconfiglib",