diff --git a/Doc/using/cmdline.rst b/Doc/using/cmdline.rst
index 74c18c2a6ede9c..e89c7f862914af 100644
--- a/Doc/using/cmdline.rst
+++ b/Doc/using/cmdline.rst
@@ -1283,6 +1283,13 @@ conflict.
 
    .. versionadded:: 3.13
 
+.. envvar:: PYTHON_BASIC_COMPLETER
+
+   If this variable is set to any value, PyREPL will use :mod:`rlcompleter` to
+   implement tab completion, instead of the default one which uses colors.
+
+   .. versionadded:: 3.15
+
 .. envvar:: PYTHON_HISTORY
 
    This environment variable can be used to set the location of a
diff --git a/Lib/_colorize.py b/Lib/_colorize.py
index d35486296f2684..81b3a618fd858a 100644
--- a/Lib/_colorize.py
+++ b/Lib/_colorize.py
@@ -183,6 +183,30 @@ class Difflib(ThemeSection):
     reset: str = ANSIColors.RESET
 
 
+@dataclass(frozen=True, kw_only=True)
+class FancyCompleter(ThemeSection):
+    # functions and methods
+    function: str = ANSIColors.BOLD_BLUE
+    builtin_function_or_method: str = ANSIColors.BOLD_BLUE
+    method: str = ANSIColors.BOLD_CYAN
+    method_wrapper: str = ANSIColors.BOLD_CYAN
+    wrapper_descriptor: str = ANSIColors.BOLD_CYAN
+    method_descriptor: str = ANSIColors.BOLD_CYAN
+
+    # numbers
+    int: str = ANSIColors.BOLD_YELLOW
+    float: str = ANSIColors.BOLD_YELLOW
+    complex: str = ANSIColors.BOLD_YELLOW
+    bool: str = ANSIColors.BOLD_YELLOW
+
+    # others
+    type: str = ANSIColors.BOLD_MAGENTA
+    module: str = ANSIColors.CYAN
+    NoneType: str = ANSIColors.GREY
+    bytes: str = ANSIColors.BOLD_GREEN
+    str: str = ANSIColors.BOLD_GREEN
+
+
 @dataclass(frozen=True, kw_only=True)
 class Syntax(ThemeSection):
     prompt: str = ANSIColors.BOLD_MAGENTA
@@ -228,6 +252,7 @@ class Theme:
     """
     argparse: Argparse = field(default_factory=Argparse)
     difflib: Difflib = field(default_factory=Difflib)
+    fancycompleter: FancyCompleter = field(default_factory=FancyCompleter)
     syntax: Syntax = field(default_factory=Syntax)
     traceback: Traceback = field(default_factory=Traceback)
     unittest: Unittest = field(default_factory=Unittest)
@@ -237,6 +262,7 @@ def copy_with(
         *,
         argparse: Argparse | None = None,
         difflib: Difflib | None = None,
+        fancycompleter: FancyCompleter | None = None,
         syntax: Syntax | None = None,
         traceback: Traceback | None = None,
         unittest: Unittest | None = None,
@@ -249,6 +275,7 @@ def copy_with(
         return type(self)(
             argparse=argparse or self.argparse,
             difflib=difflib or self.difflib,
+            fancycompleter=fancycompleter or self.fancycompleter,
             syntax=syntax or self.syntax,
             traceback=traceback or self.traceback,
             unittest=unittest or self.unittest,
@@ -265,6 +292,7 @@ def no_colors(cls) -> Self:
         return cls(
             argparse=Argparse.no_colors(),
             difflib=Difflib.no_colors(),
+            fancycompleter=FancyCompleter.no_colors(),
             syntax=Syntax.no_colors(),
             traceback=Traceback.no_colors(),
             unittest=Unittest.no_colors(),
diff --git a/Lib/_pyrepl/fancycompleter.py b/Lib/_pyrepl/fancycompleter.py
new file mode 100644
index 00000000000000..c0c2081e66b52b
--- /dev/null
+++ b/Lib/_pyrepl/fancycompleter.py
@@ -0,0 +1,181 @@
+#   Copyright 2010-2025 Antonio Cuni
+#                       Daniel Hahler
+#
+#                        All Rights Reserved
+"""Colorful tab completion for Python prompt"""
+from _colorize import ANSIColors, get_colors, get_theme
+import rlcompleter
+import types
+import keyword
+
+class Completer(rlcompleter.Completer):
+    """
+    When doing someting like a.b.<tab>, display only the attributes of
+    b instead of the full a.b.attr string.
+
+    Optionally, display the various completions in different colors
+    depending on the type.
+    """
+    def __init__(
+        self,
+        namespace=None,
+        *,
+        use_colors='auto',
+        consider_getitems=True,
+    ):
+        from _pyrepl import readline
+        rlcompleter.Completer.__init__(self, namespace)
+        if use_colors == 'auto':
+            # use colors only if we can
+            use_colors = get_colors().RED != ""
+        self.use_colors = use_colors
+        self.consider_getitems = consider_getitems
+
+        if self.use_colors:
+            readline.parse_and_bind('set dont-escape-ctrl-chars on')
+            self.theme = get_theme()
+        else:
+            self.theme = None
+
+        if self.consider_getitems:
+            delims = readline.get_completer_delims()
+            delims = delims.replace('[', '')
+            delims = delims.replace(']', '')
+            readline.set_completer_delims(delims)
+
+    def complete(self, text, state):
+        # if you press <tab> at the beginning of a line, insert an actual
+        # \t. Else, trigger completion.
+        if text == "":
+            return ('\t', None)[state]
+        else:
+            return rlcompleter.Completer.complete(self, text, state)
+
+    def _callable_postfix(self, val, word):
+        # disable automatic insertion of '(' for global callables
+        return word
+
+    def global_matches(self, text):
+        names = rlcompleter.Completer.global_matches(self, text)
+        prefix = commonprefix(names)
+        if prefix and prefix != text:
+            return [prefix]
+
+        names.sort()
+        values = []
+        for name in names:
+            clean_name = name.rstrip(': ')
+            if clean_name in keyword.kwlist:
+                values.append(None)
+            else:
+                try:
+                    values.append(eval(name, self.namespace))
+                except Exception as exc:
+                    values.append(None)
+        if self.use_colors and names:
+            return self.colorize_matches(names, values)
+        return names
+
+    def attr_matches(self, text):
+        expr, attr = text.rsplit('.', 1)
+        if '(' in expr or ')' in expr:  # don't call functions
+            return []
+        try:
+            thisobject = eval(expr, self.namespace)
+        except Exception:
+            return []
+
+        # get the content of the object, except __builtins__
+        words = set(dir(thisobject)) - {'__builtins__'}
+
+        if hasattr(thisobject, '__class__'):
+            words.add('__class__')
+            words.update(rlcompleter.get_class_members(thisobject.__class__))
+        names = []
+        values = []
+        n = len(attr)
+        if attr == '':
+            noprefix = '_'
+        elif attr == '_':
+            noprefix = '__'
+        else:
+            noprefix = None
+
+        # sort the words now to make sure to return completions in
+        # alphabetical order. It's easier to do it now, else we would need to
+        # sort 'names' later but make sure that 'values' in kept in sync,
+        # which is annoying.
+        words = sorted(words)
+        while True:
+            for word in words:
+                if (
+                    word[:n] == attr
+                    and not (noprefix and word[:n+1] == noprefix)
+                ):
+                    try:
+                        val = getattr(thisobject, word)
+                    except Exception:
+                        val = None  # Include even if attribute not set
+
+                    names.append(word)
+                    values.append(val)
+            if names or not noprefix:
+                break
+            if noprefix == '_':
+                noprefix = '__'
+            else:
+                noprefix = None
+
+        if not names:
+            return []
+
+        if len(names) == 1:
+            return [f'{expr}.{names[0]}']  # only option, no coloring.
+
+        prefix = commonprefix(names)
+        if prefix and prefix != attr:
+            return [f'{expr}.{prefix}']  # autocomplete prefix
+
+        if self.use_colors:
+            return self.colorize_matches(names, values)
+
+        if prefix:
+            names.append(' ')
+        return names
+
+    def colorize_matches(self, names, values):
+        matches = [self.color_for_obj(i, name, obj)
+                   for i, (name, obj)
+                   in enumerate(zip(names, values))]
+        # We add a space at the end to prevent the automatic completion of the
+        # common prefix, which is the ANSI escape sequence.
+        matches.append(' ')
+        return matches
+
+    def color_for_obj(self, i, name, value):
+        t = type(value)
+        color = self.color_by_type(t)
+        # hack: prepend an (increasing) fake escape sequence,
+        # so that readline can sort the matches correctly.
+        N = f"\x1b[{i:03d};00m"
+        return f"{N}{color}{name}{ANSIColors.RESET}"
+
+    def color_by_type(self, t):
+        typename = t.__name__
+        # this is needed e.g. to turn method-wrapper into method_wrapper,
+        # because if we want _colorize.FancyCompleter to be "dataclassable"
+        # our keys need to be valid identifiers.
+        typename = typename.replace('-', '_').replace('.', '_')
+        return getattr(self.theme.fancycompleter, typename, ANSIColors.RESET)
+
+
+def commonprefix(names):
+    """Return the common prefix of all 'names'"""
+    if not names:
+        return ''
+    s1 = min(names)
+    s2 = max(names)
+    for i, c in enumerate(s1):
+        if c != s2[i]:
+            return s1[:i]
+    return s1
diff --git a/Lib/_pyrepl/readline.py b/Lib/_pyrepl/readline.py
index 23b8fa6b9c7625..e45162c17e36e7 100644
--- a/Lib/_pyrepl/readline.py
+++ b/Lib/_pyrepl/readline.py
@@ -40,6 +40,7 @@
 from .completing_reader import CompletingReader
 from .console import Console as ConsoleType
 from ._module_completer import ModuleCompleter, make_default_module_completer
+from .fancycompleter import Completer as FancyCompleter
 
 Console: type[ConsoleType]
 _error: tuple[type[Exception], ...] | type[Exception]
@@ -608,8 +609,13 @@ def _setup(namespace: Mapping[str, Any]) -> None:
     # set up namespace in rlcompleter, which requires it to be a bona fide dict
     if not isinstance(namespace, dict):
         namespace = dict(namespace)
+
+    if os.getenv('PYTHON_BASIC_COMPLETER'):
+        Completer = RLCompleter
+    else:
+        Completer = FancyCompleter
     _wrapper.config.module_completer = ModuleCompleter(namespace)
-    _wrapper.config.readline_completer = RLCompleter(namespace).complete
+    _wrapper.config.readline_completer = Completer(namespace).complete
 
     # this is not really what readline.c does.  Better than nothing I guess
     import builtins
diff --git a/Lib/test/test_pyrepl/test_fancycompleter.py b/Lib/test/test_pyrepl/test_fancycompleter.py
new file mode 100644
index 00000000000000..88c5dfd306602f
--- /dev/null
+++ b/Lib/test/test_pyrepl/test_fancycompleter.py
@@ -0,0 +1,172 @@
+import unittest
+
+from _colorize import ANSIColors, get_theme
+from _pyrepl.fancycompleter import Completer, commonprefix
+
+class MockPatch:
+    def __init__(self):
+        self.original_values = {}
+
+    def setattr(self, obj, name, value):
+        if obj not in self.original_values:
+            self.original_values[obj] = {}
+        if name not in self.original_values[obj]:
+            self.original_values[obj][name] = getattr(obj, name)
+        setattr(obj, name, value)
+
+    def restore_all(self):
+        for obj, attrs in self.original_values.items():
+            for name, value in attrs.items():
+                setattr(obj, name, value)
+
+class FancyCompleterTests(unittest.TestCase):
+    def setUp(self):
+        self.mock_patch = MockPatch()
+
+    def tearDown(self):
+        self.mock_patch.restore_all()
+
+    def test_commonprefix(self):
+        self.assertEqual(commonprefix(['isalpha', 'isdigit', 'foo']), '')
+        self.assertEqual(commonprefix(['isalpha', 'isdigit']), 'is')
+        self.assertEqual(commonprefix([]), '')
+
+    def test_complete_attribute(self):
+        compl = Completer({'a': None}, use_colors=False)
+        self.assertEqual(compl.attr_matches('a.'), ['a.__'])
+        matches = compl.attr_matches('a.__')
+        self.assertNotIn('a.__class__', matches)
+        self.assertIn('__class__', matches)
+        self.assertEqual(compl.attr_matches('a.__class'), ['a.__class__'])
+
+    def test_complete_attribute_prefix(self):
+        class C(object):
+            attr = 1
+            _attr = 2
+            __attr__attr = 3
+        compl = Completer({'a': C}, use_colors=False)
+        self.assertEqual(compl.attr_matches('a.'), ['attr', 'mro'])
+        self.assertEqual(compl.attr_matches('a._'), ['_C__attr__attr', '_attr', ' '])
+        matches = compl.attr_matches('a.__')
+        self.assertNotIn('a.__class__', matches)
+        self.assertIn('__class__', matches)
+        self.assertEqual(compl.attr_matches('a.__class'), ['a.__class__'])
+
+        compl = Completer({'a': None}, use_colors=False)
+        self.assertEqual(compl.attr_matches('a._'), ['a.__'])
+
+    def test_complete_attribute_colored(self):
+        theme = get_theme()
+        compl = Completer({'a': 42}, use_colors=True)
+        matches = compl.attr_matches('a.__')
+        self.assertGreater(len(matches), 2)
+        expected_color = theme.fancycompleter.type
+        expected_part = f'{expected_color}__class__{ANSIColors.RESET}'
+        for match in matches:
+            if expected_part in match:
+                break
+        else:
+            self.assertFalse(True, matches)
+        self.assertIn(' ', matches)
+
+    def test_complete_colored_single_match(self):
+        """No coloring, via commonprefix."""
+        compl = Completer({'foobar': 42}, use_colors=True)
+        matches = compl.global_matches('foob')
+        self.assertEqual(matches, ['foobar'])
+
+    def test_does_not_color_single_match(self):
+        class obj:
+            msgs = []
+
+        compl = Completer({'obj': obj}, use_colors=True)
+        matches = compl.attr_matches('obj.msgs')
+        self.assertEqual(matches, ['obj.msgs'])
+
+    def test_complete_global(self):
+        compl = Completer({'foobar': 1, 'foobazzz': 2}, use_colors=False)
+        self.assertEqual(compl.global_matches('foo'), ['fooba'])
+        matches = compl.global_matches('fooba')
+        self.assertEqual(set(matches), set(['foobar', 'foobazzz']))
+        self.assertEqual(compl.global_matches('foobaz'), ['foobazzz'])
+        self.assertEqual(compl.global_matches('nothing'), [])
+
+    def test_complete_global_colored(self):
+        theme = get_theme()
+        compl = Completer({'foobar': 1, 'foobazzz': 2}, use_colors=True)
+        self.assertEqual(compl.global_matches('foo'), ['fooba'])
+        matches = compl.global_matches('fooba')
+
+        # these are the fake escape sequences which are needed so that
+        # readline displays the matches in the proper order
+        N0 = f"\x1b[000;00m"
+        N1 = f"\x1b[001;00m"
+        int_color = theme.fancycompleter.int
+        self.assertEqual(set(matches), {
+            ' ',
+            f'{N0}{int_color}foobar{ANSIColors.RESET}',
+            f'{N1}{int_color}foobazzz{ANSIColors.RESET}',
+        })
+        self.assertEqual(compl.global_matches('foobaz'), ['foobazzz'])
+        self.assertEqual(compl.global_matches('nothing'), [])
+
+    def test_complete_with_indexer(self):
+        compl = Completer({'lst': [None, 2, 3]}, use_colors=False)
+        self.assertEqual(compl.attr_matches('lst[0].'), ['lst[0].__'])
+        matches = compl.attr_matches('lst[0].__')
+        self.assertNotIn('lst[0].__class__', matches)
+        self.assertIn('__class__', matches)
+        self.assertEqual(compl.attr_matches('lst[0].__class'), ['lst[0].__class__'])
+
+    def test_autocomplete(self):
+        class A:
+            aaa = None
+            abc_1 = None
+            abc_2 = None
+            abc_3 = None
+            bbb = None
+        compl = Completer({'A': A}, use_colors=False)
+        #
+        # In this case, we want to display all attributes which start with
+        # 'a'. Moreover, we also include a space to prevent readline to
+        # automatically insert the common prefix (which will the the ANSI escape
+        # sequence if we use colors).
+        matches = compl.attr_matches('A.a')
+        self.assertEqual(sorted(matches), [' ', 'aaa', 'abc_1', 'abc_2', 'abc_3'])
+        #
+        # If there is an actual common prefix, we return just it, so that readline
+        # will insert it into place
+        matches = compl.attr_matches('A.ab')
+        self.assertEqual(matches, ['A.abc_'])
+        #
+        # Finally, at the next tab, we display again all the completions available
+        # for this common prefix. Again, we insert a spurious space to prevent the
+        # automatic completion of ANSI sequences.
+        matches = compl.attr_matches('A.abc_')
+        self.assertEqual(sorted(matches), [' ', 'abc_1', 'abc_2', 'abc_3'])
+
+    def test_complete_exception(self):
+        compl = Completer({}, use_colors=False)
+        self.assertEqual(compl.attr_matches('xxx.'), [])
+
+    def test_complete_invalid_attr(self):
+        compl = Completer({'str': str}, use_colors=False)
+        self.assertEqual(compl.attr_matches('str.xx'), [])
+
+    def test_complete_function_skipped(self):
+        compl = Completer({'str': str}, use_colors=False)
+        self.assertEqual(compl.attr_matches('str.split().'), [])
+
+    def test_unicode_in___dir__(self):
+        class Foo(object):
+            def __dir__(self):
+                return ['hello', 'world']
+
+        compl = Completer({'a': Foo()}, use_colors=False)
+        matches = compl.attr_matches('a.')
+        self.assertEqual(matches, ['hello', 'world'])
+        self.assertIs(type(matches[0]), str)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Misc/NEWS.d/next/Library/2025-09-19-13-54-54.gh-issue-130472.LODfdk.rst b/Misc/NEWS.d/next/Library/2025-09-19-13-54-54.gh-issue-130472.LODfdk.rst
new file mode 100644
index 00000000000000..3d2a7f00d3e6a8
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2025-09-19-13-54-54.gh-issue-130472.LODfdk.rst
@@ -0,0 +1 @@
+Add fancycompleter and enable it by default when using pyrepl. This gives colored tab completion.