diff --git a/Lib/test/.ruff.toml b/Lib/test/.ruff.toml
index fa8b2b42579..54126bf3261 100644
--- a/Lib/test/.ruff.toml
+++ b/Lib/test/.ruff.toml
@@ -7,6 +7,9 @@ extend-exclude = [
     # Non UTF-8 files
     "encoded_modules/module_iso_8859_1.py",
     "encoded_modules/module_koi8_r.py",
+    # SyntaxError because of t-strings
+    "test_tstring.py",
+    "test_string/test_templatelib.py",
     # New grammar constructions may not yet be recognized by Ruff,
     # and tests re-use the same names as only the grammar is being checked.
     "test_grammar.py",
diff --git a/Lib/test/support/ast_helper.py b/Lib/test/support/ast_helper.py
index 8a0415b6aae..173d299afee 100644
--- a/Lib/test/support/ast_helper.py
+++ b/Lib/test/support/ast_helper.py
@@ -16,6 +16,9 @@ def traverse_compare(a, b, missing=object()):
                 self.fail(f"{type(a)!r} is not {type(b)!r}")
             if isinstance(a, ast.AST):
                 for field in a._fields:
+                    if isinstance(a, ast.Constant) and field == "kind":
+                        # Skip the 'kind' field for ast.Constant
+                        continue
                     value1 = getattr(a, field, missing)
                     value2 = getattr(b, field, missing)
                     # Singletons are equal by definition, so further
diff --git a/Lib/test/test_ast/data/ast_repr.txt b/Lib/test/test_ast/data/ast_repr.txt
index 3778b9e70a4..1c1985519cd 100644
--- a/Lib/test/test_ast/data/ast_repr.txt
+++ b/Lib/test/test_ast/data/ast_repr.txt
@@ -206,4 +206,9 @@ Module(body=[Expr(value=IfExp(test=Name(...), body=Call(...), orelse=Call(...)))
 Module(body=[Expr(value=JoinedStr(values=[FormattedValue(...)]))], type_ignores=[])
 Module(body=[Expr(value=JoinedStr(values=[FormattedValue(...)]))], type_ignores=[])
 Module(body=[Expr(value=JoinedStr(values=[FormattedValue(...)]))], type_ignores=[])
-Module(body=[Expr(value=JoinedStr(values=[Constant(...), ..., Constant(...)]))], type_ignores=[])
\ No newline at end of file
+Module(body=[Expr(value=JoinedStr(values=[Constant(...), ..., Constant(...)]))], type_ignores=[])
+Module(body=[Expr(value=TemplateStr(values=[Interpolation(...)]))], type_ignores=[])
+Module(body=[Expr(value=TemplateStr(values=[Interpolation(...)]))], type_ignores=[])
+Module(body=[Expr(value=TemplateStr(values=[Interpolation(...)]))], type_ignores=[])
+Module(body=[Expr(value=TemplateStr(values=[Interpolation(...)]))], type_ignores=[])
+Module(body=[Expr(value=TemplateStr(values=[Constant(...), ..., Constant(...)]))], type_ignores=[])
\ No newline at end of file
diff --git a/Lib/test/test_ast/snippets.py b/Lib/test/test_ast/snippets.py
index 28d32b2941f..b76f98901d2 100644
--- a/Lib/test/test_ast/snippets.py
+++ b/Lib/test/test_ast/snippets.py
@@ -364,6 +364,12 @@
   "f'{a:.2f}'",
   "f'{a!r}'",
   "f'foo({a})'",
+  # TemplateStr and Interpolation
+  "t'{a}'",
+  "t'{a:.2f}'",
+  "t'{a!r}'",
+  "t'{a!r:.2f}'",
+  "t'foo({a})'",
 ]
 
 
@@ -597,5 +603,10 @@ def main():
 ('Expression', ('JoinedStr', (1, 0, 1, 10), [('FormattedValue', (1, 2, 1, 9), ('Name', (1, 3, 1, 4), 'a', ('Load',)), -1, ('JoinedStr', (1, 4, 1, 8), [('Constant', (1, 5, 1, 8), '.2f', None)]))])),
 ('Expression', ('JoinedStr', (1, 0, 1, 8), [('FormattedValue', (1, 2, 1, 7), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 114, None)])),
 ('Expression', ('JoinedStr', (1, 0, 1, 11), [('Constant', (1, 2, 1, 6), 'foo(', None), ('FormattedValue', (1, 6, 1, 9), ('Name', (1, 7, 1, 8), 'a', ('Load',)), -1, None), ('Constant', (1, 9, 1, 10), ')', None)])),
+('Expression', ('TemplateStr', (1, 0, 1, 6), [('Interpolation', (1, 2, 1, 5), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 'a', -1, None)])),
+('Expression', ('TemplateStr', (1, 0, 1, 10), [('Interpolation', (1, 2, 1, 9), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 'a', -1, ('JoinedStr', (1, 4, 1, 8), [('Constant', (1, 5, 1, 8), '.2f', None)]))])),
+('Expression', ('TemplateStr', (1, 0, 1, 8), [('Interpolation', (1, 2, 1, 7), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 'a', 114, None)])),
+('Expression', ('TemplateStr', (1, 0, 1, 12), [('Interpolation', (1, 2, 1, 11), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 'a', 114, ('JoinedStr', (1, 6, 1, 10), [('Constant', (1, 7, 1, 10), '.2f', None)]))])),
+('Expression', ('TemplateStr', (1, 0, 1, 11), [('Constant', (1, 2, 1, 6), 'foo(', None), ('Interpolation', (1, 6, 1, 9), ('Name', (1, 7, 1, 8), 'a', ('Load',)), 'a', -1, None), ('Constant', (1, 9, 1, 10), ')', None)])),
 ]
 main()
diff --git a/Lib/test/test_ast/test_ast.py b/Lib/test/test_ast/test_ast.py
index dd459487afe..eeac7c21eda 100644
--- a/Lib/test/test_ast/test_ast.py
+++ b/Lib/test/test_ast/test_ast.py
@@ -880,6 +880,25 @@ def f():
         for src in srcs:
             ast.parse(src)
 
+    def test_tstring(self):
+        # Test AST structure for simple t-string
+        tree = ast.parse('t"Hello"')
+        self.assertIsInstance(tree.body[0].value, ast.TemplateStr)
+        self.assertIsInstance(tree.body[0].value.values[0], ast.Constant)
+
+        # Test AST for t-string with interpolation
+        tree = ast.parse('t"Hello {name}"')
+        self.assertIsInstance(tree.body[0].value, ast.TemplateStr)
+        self.assertIsInstance(tree.body[0].value.values[0], ast.Constant)
+        self.assertIsInstance(tree.body[0].value.values[1], ast.Interpolation)
+
+        # Test AST for implicit concat of t-string with f-string
+        tree = ast.parse('t"Hello {name}" f"{name}"')
+        self.assertIsInstance(tree.body[0].value, ast.TemplateStr)
+        self.assertIsInstance(tree.body[0].value.values[0], ast.Constant)
+        self.assertIsInstance(tree.body[0].value.values[1], ast.Interpolation)
+        self.assertIsInstance(tree.body[0].value.values[2], ast.FormattedValue)
+
 
 class CopyTests(unittest.TestCase):
     """Test copying and pickling AST nodes."""
diff --git a/Lib/test/test_fstring.py b/Lib/test/test_fstring.py
index e75e7db378c..a10d1fd5fd2 100644
--- a/Lib/test/test_fstring.py
+++ b/Lib/test/test_fstring.py
@@ -1358,7 +1358,6 @@ def test_conversions(self):
         self.assertAllRaise(SyntaxError, "f-string: expecting '}'",
                             ["f'{3!'",
                              "f'{3!s'",
-                             "f'{3!g'",
                              ])
 
         self.assertAllRaise(SyntaxError, 'f-string: missing conversion character',
diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py
index 35cd6984267..c0681bccd9e 100644
--- a/Lib/test/test_grammar.py
+++ b/Lib/test/test_grammar.py
@@ -1507,6 +1507,8 @@ def check(test):
         check('[None (3, 4)]')
         check('[True (3, 4)]')
         check('[... (3, 4)]')
+        check('[t"{x}" (3, 4)]')
+        check('[t"x={x}" (3, 4)]')
 
         msg=r'is not subscriptable; perhaps you missed a comma\?'
         check('[{1, 2} [i, j]]')
@@ -1529,6 +1531,8 @@ def check(test):
         check('[f"x={x}" [i, j]]')
         check('["abc" [i, j]]')
         check('[b"abc" [i, j]]')
+        check('[t"{x}" [i, j]]')
+        check('[t"x={x}" [i, j]]')
 
         msg=r'indices must be integers or slices, not tuple;'
         check('[[1, 2] [3, 4]]')
@@ -1549,6 +1553,8 @@ def check(test):
         check('[[1, 2] [f"{x}"]]')
         check('[[1, 2] [f"x={x}"]]')
         check('[[1, 2] ["abc"]]')
+        check('[[1, 2] [t"{x}"]]')
+        check('[[1, 2] [t"x={x}"]]')
         msg=r'indices must be integers or slices, not'
         check('[[1, 2] [b"abc"]]')
         check('[[1, 2] [12.3]]')
diff --git a/Lib/test/test_string.py b/Lib/test/test_string.py
deleted file mode 100644
index f6d112d8a93..00000000000
--- a/Lib/test/test_string.py
+++ /dev/null
@@ -1,550 +0,0 @@
-import unittest
-import string
-from string import Template
-import types
-
-
-class ModuleTest(unittest.TestCase):
-
-    def test_attrs(self):
-        # While the exact order of the items in these attributes is not
-        # technically part of the "language spec", in practice there is almost
-        # certainly user code that depends on the order, so de-facto it *is*
-        # part of the spec.
-        self.assertEqual(string.whitespace, ' \t\n\r\x0b\x0c')
-        self.assertEqual(string.ascii_lowercase, 'abcdefghijklmnopqrstuvwxyz')
-        self.assertEqual(string.ascii_uppercase, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
-        self.assertEqual(string.ascii_letters, string.ascii_lowercase + string.ascii_uppercase)
-        self.assertEqual(string.digits, '0123456789')
-        self.assertEqual(string.hexdigits, string.digits + 'abcdefABCDEF')
-        self.assertEqual(string.octdigits, '01234567')
-        self.assertEqual(string.punctuation, '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~')
-        self.assertEqual(string.printable, string.digits + string.ascii_lowercase + string.ascii_uppercase + string.punctuation + string.whitespace)
-
-    def test_capwords(self):
-        self.assertEqual(string.capwords('abc def ghi'), 'Abc Def Ghi')
-        self.assertEqual(string.capwords('abc\tdef\nghi'), 'Abc Def Ghi')
-        self.assertEqual(string.capwords('abc\t   def  \nghi'), 'Abc Def Ghi')
-        self.assertEqual(string.capwords('ABC DEF GHI'), 'Abc Def Ghi')
-        self.assertEqual(string.capwords('ABC-DEF-GHI', '-'), 'Abc-Def-Ghi')
-        self.assertEqual(string.capwords('ABC-def DEF-ghi GHI'), 'Abc-def Def-ghi Ghi')
-        self.assertEqual(string.capwords('   aBc  DeF   '), 'Abc Def')
-        self.assertEqual(string.capwords('\taBc\tDeF\t'), 'Abc Def')
-        self.assertEqual(string.capwords('\taBc\tDeF\t', '\t'), '\tAbc\tDef\t')
-
-    def test_basic_formatter(self):
-        fmt = string.Formatter()
-        self.assertEqual(fmt.format("foo"), "foo")
-        self.assertEqual(fmt.format("foo{0}", "bar"), "foobar")
-        self.assertEqual(fmt.format("foo{1}{0}-{1}", "bar", 6), "foo6bar-6")
-        self.assertRaises(TypeError, fmt.format)
-        self.assertRaises(TypeError, string.Formatter.format)
-
-    def test_format_keyword_arguments(self):
-        fmt = string.Formatter()
-        self.assertEqual(fmt.format("-{arg}-", arg='test'), '-test-')
-        self.assertRaises(KeyError, fmt.format, "-{arg}-")
-        self.assertEqual(fmt.format("-{self}-", self='test'), '-test-')
-        self.assertRaises(KeyError, fmt.format, "-{self}-")
-        self.assertEqual(fmt.format("-{format_string}-", format_string='test'),
-                         '-test-')
-        self.assertRaises(KeyError, fmt.format, "-{format_string}-")
-        with self.assertRaisesRegex(TypeError, "format_string"):
-            fmt.format(format_string="-{arg}-", arg='test')
-
-    def test_auto_numbering(self):
-        fmt = string.Formatter()
-        self.assertEqual(fmt.format('foo{}{}', 'bar', 6),
-                         'foo{}{}'.format('bar', 6))
-        self.assertEqual(fmt.format('foo{1}{num}{1}', None, 'bar', num=6),
-                         'foo{1}{num}{1}'.format(None, 'bar', num=6))
-        self.assertEqual(fmt.format('{:^{}}', 'bar', 6),
-                         '{:^{}}'.format('bar', 6))
-        self.assertEqual(fmt.format('{:^{}} {}', 'bar', 6, 'X'),
-                         '{:^{}} {}'.format('bar', 6, 'X'))
-        self.assertEqual(fmt.format('{:^{pad}}{}', 'foo', 'bar', pad=6),
-                         '{:^{pad}}{}'.format('foo', 'bar', pad=6))
-
-        with self.assertRaises(ValueError):
-            fmt.format('foo{1}{}', 'bar', 6)
-
-        with self.assertRaises(ValueError):
-            fmt.format('foo{}{1}', 'bar', 6)
-
-    def test_conversion_specifiers(self):
-        fmt = string.Formatter()
-        self.assertEqual(fmt.format("-{arg!r}-", arg='test'), "-'test'-")
-        self.assertEqual(fmt.format("{0!s}", 'test'), 'test')
-        self.assertRaises(ValueError, fmt.format, "{0!h}", 'test')
-        # issue13579
-        self.assertEqual(fmt.format("{0!a}", 42), '42')
-        self.assertEqual(fmt.format("{0!a}",  string.ascii_letters),
-            "'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'")
-        self.assertEqual(fmt.format("{0!a}",  chr(255)), "'\\xff'")
-        self.assertEqual(fmt.format("{0!a}",  chr(256)), "'\\u0100'")
-
-    def test_name_lookup(self):
-        fmt = string.Formatter()
-        class AnyAttr:
-            def __getattr__(self, attr):
-                return attr
-        x = AnyAttr()
-        self.assertEqual(fmt.format("{0.lumber}{0.jack}", x), 'lumberjack')
-        with self.assertRaises(AttributeError):
-            fmt.format("{0.lumber}{0.jack}", '')
-
-    def test_index_lookup(self):
-        fmt = string.Formatter()
-        lookup = ["eggs", "and", "spam"]
-        self.assertEqual(fmt.format("{0[2]}{0[0]}", lookup), 'spameggs')
-        with self.assertRaises(IndexError):
-            fmt.format("{0[2]}{0[0]}", [])
-        with self.assertRaises(KeyError):
-            fmt.format("{0[2]}{0[0]}", {})
-
-    def test_auto_numbering_lookup(self):
-        fmt = string.Formatter()
-        namespace = types.SimpleNamespace(foo=types.SimpleNamespace(bar='baz'))
-        widths = [None, types.SimpleNamespace(qux=4)]
-        self.assertEqual(
-            fmt.format("{.foo.bar:{[1].qux}}", namespace, widths), 'baz ')
-
-    def test_auto_numbering_reenterability(self):
-        class ReenteringFormatter(string.Formatter):
-            def format_field(self, value, format_spec):
-                if format_spec.isdigit() and int(format_spec) > 0:
-                    return self.format('{:{}}!', value, int(format_spec) - 1)
-                else:
-                    return super().format_field(value, format_spec)
-        fmt = ReenteringFormatter()
-        x = types.SimpleNamespace(a='X')
-        self.assertEqual(fmt.format('{.a:{}}', x, 3), 'X!!!')
-
-    def test_override_get_value(self):
-        class NamespaceFormatter(string.Formatter):
-            def __init__(self, namespace={}):
-                string.Formatter.__init__(self)
-                self.namespace = namespace
-
-            def get_value(self, key, args, kwds):
-                if isinstance(key, str):
-                    try:
-                        # Check explicitly passed arguments first
-                        return kwds[key]
-                    except KeyError:
-                        return self.namespace[key]
-                else:
-                    string.Formatter.get_value(key, args, kwds)
-
-        fmt = NamespaceFormatter({'greeting':'hello'})
-        self.assertEqual(fmt.format("{greeting}, world!"), 'hello, world!')
-
-
-    def test_override_format_field(self):
-        class CallFormatter(string.Formatter):
-            def format_field(self, value, format_spec):
-                return format(value(), format_spec)
-
-        fmt = CallFormatter()
-        self.assertEqual(fmt.format('*{0}*', lambda : 'result'), '*result*')
-
-
-    def test_override_convert_field(self):
-        class XFormatter(string.Formatter):
-            def convert_field(self, value, conversion):
-                if conversion == 'x':
-                    return None
-                return super().convert_field(value, conversion)
-
-        fmt = XFormatter()
-        self.assertEqual(fmt.format("{0!r}:{0!x}", 'foo', 'foo'), "'foo':None")
-
-
-    def test_override_parse(self):
-        class BarFormatter(string.Formatter):
-            # returns an iterable that contains tuples of the form:
-            # (literal_text, field_name, format_spec, conversion)
-            def parse(self, format_string):
-                for field in format_string.split('|'):
-                    if field[0] == '+':
-                        # it's markup
-                        field_name, _, format_spec = field[1:].partition(':')
-                        yield '', field_name, format_spec, None
-                    else:
-                        yield field, None, None, None
-
-        fmt = BarFormatter()
-        self.assertEqual(fmt.format('*|+0:^10s|*', 'foo'), '*   foo    *')
-
-    def test_check_unused_args(self):
-        class CheckAllUsedFormatter(string.Formatter):
-            def check_unused_args(self, used_args, args, kwargs):
-                # Track which arguments actually got used
-                unused_args = set(kwargs.keys())
-                unused_args.update(range(0, len(args)))
-
-                for arg in used_args:
-                    unused_args.remove(arg)
-
-                if unused_args:
-                    raise ValueError("unused arguments")
-
-        fmt = CheckAllUsedFormatter()
-        self.assertEqual(fmt.format("{0}", 10), "10")
-        self.assertEqual(fmt.format("{0}{i}", 10, i=100), "10100")
-        self.assertEqual(fmt.format("{0}{i}{1}", 10, 20, i=100), "1010020")
-        self.assertRaises(ValueError, fmt.format, "{0}{i}{1}", 10, 20, i=100, j=0)
-        self.assertRaises(ValueError, fmt.format, "{0}", 10, 20)
-        self.assertRaises(ValueError, fmt.format, "{0}", 10, 20, i=100)
-        self.assertRaises(ValueError, fmt.format, "{i}", 10, 20, i=100)
-
-    def test_vformat_recursion_limit(self):
-        fmt = string.Formatter()
-        args = ()
-        kwargs = dict(i=100)
-        with self.assertRaises(ValueError) as err:
-            fmt._vformat("{i}", args, kwargs, set(), -1)
-        self.assertIn("recursion", str(err.exception))
-
-
-# Template tests (formerly housed in test_pep292.py)
-
-class Bag:
-    pass
-
-class Mapping:
-    def __getitem__(self, name):
-        obj = self
-        for part in name.split('.'):
-            try:
-                obj = getattr(obj, part)
-            except AttributeError:
-                raise KeyError(name)
-        return obj
-
-
-class TestTemplate(unittest.TestCase):
-    def test_regular_templates(self):
-        s = Template('$who likes to eat a bag of $what worth $$100')
-        self.assertEqual(s.substitute(dict(who='tim', what='ham')),
-                         'tim likes to eat a bag of ham worth $100')
-        self.assertRaises(KeyError, s.substitute, dict(who='tim'))
-        self.assertRaises(TypeError, Template.substitute)
-
-    def test_regular_templates_with_braces(self):
-        s = Template('$who likes ${what} for ${meal}')
-        d = dict(who='tim', what='ham', meal='dinner')
-        self.assertEqual(s.substitute(d), 'tim likes ham for dinner')
-        self.assertRaises(KeyError, s.substitute,
-                          dict(who='tim', what='ham'))
-
-    def test_regular_templates_with_upper_case(self):
-        s = Template('$WHO likes ${WHAT} for ${MEAL}')
-        d = dict(WHO='tim', WHAT='ham', MEAL='dinner')
-        self.assertEqual(s.substitute(d), 'tim likes ham for dinner')
-
-    def test_regular_templates_with_non_letters(self):
-        s = Template('$_wh0_ likes ${_w_h_a_t_} for ${mea1}')
-        d = dict(_wh0_='tim', _w_h_a_t_='ham', mea1='dinner')
-        self.assertEqual(s.substitute(d), 'tim likes ham for dinner')
-
-    def test_escapes(self):
-        eq = self.assertEqual
-        s = Template('$who likes to eat a bag of $$what worth $$100')
-        eq(s.substitute(dict(who='tim', what='ham')),
-           'tim likes to eat a bag of $what worth $100')
-        s = Template('$who likes $$')
-        eq(s.substitute(dict(who='tim', what='ham')), 'tim likes $')
-
-    def test_percents(self):
-        eq = self.assertEqual
-        s = Template('%(foo)s $foo ${foo}')
-        d = dict(foo='baz')
-        eq(s.substitute(d), '%(foo)s baz baz')
-        eq(s.safe_substitute(d), '%(foo)s baz baz')
-
-    def test_stringification(self):
-        eq = self.assertEqual
-        s = Template('tim has eaten $count bags of ham today')
-        d = dict(count=7)
-        eq(s.substitute(d), 'tim has eaten 7 bags of ham today')
-        eq(s.safe_substitute(d), 'tim has eaten 7 bags of ham today')
-        s = Template('tim has eaten ${count} bags of ham today')
-        eq(s.substitute(d), 'tim has eaten 7 bags of ham today')
-
-    def test_tupleargs(self):
-        eq = self.assertEqual
-        s = Template('$who ate ${meal}')
-        d = dict(who=('tim', 'fred'), meal=('ham', 'kung pao'))
-        eq(s.substitute(d), "('tim', 'fred') ate ('ham', 'kung pao')")
-        eq(s.safe_substitute(d), "('tim', 'fred') ate ('ham', 'kung pao')")
-
-    def test_SafeTemplate(self):
-        eq = self.assertEqual
-        s = Template('$who likes ${what} for ${meal}')
-        eq(s.safe_substitute(dict(who='tim')), 'tim likes ${what} for ${meal}')
-        eq(s.safe_substitute(dict(what='ham')), '$who likes ham for ${meal}')
-        eq(s.safe_substitute(dict(what='ham', meal='dinner')),
-           '$who likes ham for dinner')
-        eq(s.safe_substitute(dict(who='tim', what='ham')),
-           'tim likes ham for ${meal}')
-        eq(s.safe_substitute(dict(who='tim', what='ham', meal='dinner')),
-           'tim likes ham for dinner')
-
-    def test_invalid_placeholders(self):
-        raises = self.assertRaises
-        s = Template('$who likes $')
-        raises(ValueError, s.substitute, dict(who='tim'))
-        s = Template('$who likes ${what)')
-        raises(ValueError, s.substitute, dict(who='tim'))
-        s = Template('$who likes $100')
-        raises(ValueError, s.substitute, dict(who='tim'))
-        # Template.idpattern should match to only ASCII characters.
-        # https://bugs.python.org/issue31672
-        s = Template("$who likes $\u0131")  # (DOTLESS I)
-        raises(ValueError, s.substitute, dict(who='tim'))
-        s = Template("$who likes $\u0130")  # (LATIN CAPITAL LETTER I WITH DOT ABOVE)
-        raises(ValueError, s.substitute, dict(who='tim'))
-
-    def test_idpattern_override(self):
-        class PathPattern(Template):
-            idpattern = r'[_a-z][._a-z0-9]*'
-        m = Mapping()
-        m.bag = Bag()
-        m.bag.foo = Bag()
-        m.bag.foo.who = 'tim'
-        m.bag.what = 'ham'
-        s = PathPattern('$bag.foo.who likes to eat a bag of $bag.what')
-        self.assertEqual(s.substitute(m), 'tim likes to eat a bag of ham')
-
-    def test_flags_override(self):
-        class MyPattern(Template):
-            flags = 0
-        s = MyPattern('$wHO likes ${WHAT} for ${meal}')
-        d = dict(wHO='tim', WHAT='ham', meal='dinner', w='fred')
-        self.assertRaises(ValueError, s.substitute, d)
-        self.assertEqual(s.safe_substitute(d), 'fredHO likes ${WHAT} for dinner')
-
-    def test_idpattern_override_inside_outside(self):
-        # bpo-1198569: Allow the regexp inside and outside braces to be
-        # different when deriving from Template.
-        class MyPattern(Template):
-            idpattern = r'[a-z]+'
-            braceidpattern = r'[A-Z]+'
-            flags = 0
-        m = dict(foo='foo', BAR='BAR')
-        s = MyPattern('$foo ${BAR}')
-        self.assertEqual(s.substitute(m), 'foo BAR')
-
-    def test_idpattern_override_inside_outside_invalid_unbraced(self):
-        # bpo-1198569: Allow the regexp inside and outside braces to be
-        # different when deriving from Template.
-        class MyPattern(Template):
-            idpattern = r'[a-z]+'
-            braceidpattern = r'[A-Z]+'
-            flags = 0
-        m = dict(foo='foo', BAR='BAR')
-        s = MyPattern('$FOO')
-        self.assertRaises(ValueError, s.substitute, m)
-        s = MyPattern('${bar}')
-        self.assertRaises(ValueError, s.substitute, m)
-
-    def test_pattern_override(self):
-        class MyPattern(Template):
-            pattern = r"""
-            (?P<escaped>@{2})                   |
-            @(?P<named>[_a-z][._a-z0-9]*)       |
-            @{(?P<braced>[_a-z][._a-z0-9]*)}    |
-            (?P<invalid>@)
-            """
-        m = Mapping()
-        m.bag = Bag()
-        m.bag.foo = Bag()
-        m.bag.foo.who = 'tim'
-        m.bag.what = 'ham'
-        s = MyPattern('@bag.foo.who likes to eat a bag of @bag.what')
-        self.assertEqual(s.substitute(m), 'tim likes to eat a bag of ham')
-
-        class BadPattern(Template):
-            pattern = r"""
-            (?P<badname>.*)                     |
-            (?P<escaped>@{2})                   |
-            @(?P<named>[_a-z][._a-z0-9]*)       |
-            @{(?P<braced>[_a-z][._a-z0-9]*)}    |
-            (?P<invalid>@)                      |
-            """
-        s = BadPattern('@bag.foo.who likes to eat a bag of @bag.what')
-        self.assertRaises(ValueError, s.substitute, {})
-        self.assertRaises(ValueError, s.safe_substitute, {})
-
-    def test_braced_override(self):
-        class MyTemplate(Template):
-            pattern = r"""
-            \$(?:
-              (?P<escaped>$)                     |
-              (?P<named>[_a-z][_a-z0-9]*)        |
-              @@(?P<braced>[_a-z][_a-z0-9]*)@@   |
-              (?P<invalid>)                      |
-           )
-           """
-
-        tmpl = 'PyCon in $@@location@@'
-        t = MyTemplate(tmpl)
-        self.assertRaises(KeyError, t.substitute, {})
-        val = t.substitute({'location': 'Cleveland'})
-        self.assertEqual(val, 'PyCon in Cleveland')
-
-    def test_braced_override_safe(self):
-        class MyTemplate(Template):
-            pattern = r"""
-            \$(?:
-              (?P<escaped>$)                     |
-              (?P<named>[_a-z][_a-z0-9]*)        |
-              @@(?P<braced>[_a-z][_a-z0-9]*)@@   |
-              (?P<invalid>)                      |
-           )
-           """
-
-        tmpl = 'PyCon in $@@location@@'
-        t = MyTemplate(tmpl)
-        self.assertEqual(t.safe_substitute(), tmpl)
-        val = t.safe_substitute({'location': 'Cleveland'})
-        self.assertEqual(val, 'PyCon in Cleveland')
-
-    def test_invalid_with_no_lines(self):
-        # The error formatting for invalid templates
-        # has a special case for no data that the default
-        # pattern can't trigger (always has at least '$')
-        # So we craft a pattern that is always invalid
-        # with no leading data.
-        class MyTemplate(Template):
-            pattern = r"""
-              (?P<invalid>) |
-              unreachable(
-                (?P<named>)   |
-                (?P<braced>)  |
-                (?P<escaped>)
-              )
-            """
-        s = MyTemplate('')
-        with self.assertRaises(ValueError) as err:
-            s.substitute({})
-        self.assertIn('line 1, col 1', str(err.exception))
-
-    def test_unicode_values(self):
-        s = Template('$who likes $what')
-        d = dict(who='t\xffm', what='f\xfe\fed')
-        self.assertEqual(s.substitute(d), 't\xffm likes f\xfe\x0ced')
-
-    def test_keyword_arguments(self):
-        eq = self.assertEqual
-        s = Template('$who likes $what')
-        eq(s.substitute(who='tim', what='ham'), 'tim likes ham')
-        eq(s.substitute(dict(who='tim'), what='ham'), 'tim likes ham')
-        eq(s.substitute(dict(who='fred', what='kung pao'),
-                        who='tim', what='ham'),
-           'tim likes ham')
-        s = Template('the mapping is $mapping')
-        eq(s.substitute(dict(foo='none'), mapping='bozo'),
-           'the mapping is bozo')
-        eq(s.substitute(dict(mapping='one'), mapping='two'),
-           'the mapping is two')
-
-        s = Template('the self is $self')
-        eq(s.substitute(self='bozo'), 'the self is bozo')
-
-    def test_keyword_arguments_safe(self):
-        eq = self.assertEqual
-        raises = self.assertRaises
-        s = Template('$who likes $what')
-        eq(s.safe_substitute(who='tim', what='ham'), 'tim likes ham')
-        eq(s.safe_substitute(dict(who='tim'), what='ham'), 'tim likes ham')
-        eq(s.safe_substitute(dict(who='fred', what='kung pao'),
-                        who='tim', what='ham'),
-           'tim likes ham')
-        s = Template('the mapping is $mapping')
-        eq(s.safe_substitute(dict(foo='none'), mapping='bozo'),
-           'the mapping is bozo')
-        eq(s.safe_substitute(dict(mapping='one'), mapping='two'),
-           'the mapping is two')
-        d = dict(mapping='one')
-        raises(TypeError, s.substitute, d, {})
-        raises(TypeError, s.safe_substitute, d, {})
-
-        s = Template('the self is $self')
-        eq(s.safe_substitute(self='bozo'), 'the self is bozo')
-
-    def test_delimiter_override(self):
-        eq = self.assertEqual
-        raises = self.assertRaises
-        class AmpersandTemplate(Template):
-            delimiter = '&'
-        s = AmpersandTemplate('this &gift is for &{who} &&')
-        eq(s.substitute(gift='bud', who='you'), 'this bud is for you &')
-        raises(KeyError, s.substitute)
-        eq(s.safe_substitute(gift='bud', who='you'), 'this bud is for you &')
-        eq(s.safe_substitute(), 'this &gift is for &{who} &')
-        s = AmpersandTemplate('this &gift is for &{who} &')
-        raises(ValueError, s.substitute, dict(gift='bud', who='you'))
-        eq(s.safe_substitute(), 'this &gift is for &{who} &')
-
-        class PieDelims(Template):
-            delimiter = '@'
-        s = PieDelims('@who likes to eat a bag of @{what} worth $100')
-        self.assertEqual(s.substitute(dict(who='tim', what='ham')),
-                         'tim likes to eat a bag of ham worth $100')
-
-    def test_is_valid(self):
-        eq = self.assertEqual
-        s = Template('$who likes to eat a bag of ${what} worth $$100')
-        self.assertTrue(s.is_valid())
-
-        s = Template('$who likes to eat a bag of ${what} worth $100')
-        self.assertFalse(s.is_valid())
-
-        # if the pattern has an unrecognized capture group,
-        # it should raise ValueError like substitute and safe_substitute do
-        class BadPattern(Template):
-            pattern = r"""
-            (?P<badname>.*)                  |
-            (?P<escaped>@{2})                   |
-            @(?P<named>[_a-z][._a-z0-9]*)       |
-            @{(?P<braced>[_a-z][._a-z0-9]*)}    |
-            (?P<invalid>@)                      |
-            """
-        s = BadPattern('@bag.foo.who likes to eat a bag of @bag.what')
-        self.assertRaises(ValueError, s.is_valid)
-
-    def test_get_identifiers(self):
-        eq = self.assertEqual
-        raises = self.assertRaises
-        s = Template('$who likes to eat a bag of ${what} worth $$100')
-        ids = s.get_identifiers()
-        eq(ids, ['who', 'what'])
-
-        # repeated identifiers only included once
-        s = Template('$who likes to eat a bag of ${what} worth $$100; ${who} likes to eat a bag of $what worth $$100')
-        ids = s.get_identifiers()
-        eq(ids, ['who', 'what'])
-
-        # invalid identifiers are ignored
-        s = Template('$who likes to eat a bag of ${what} worth $100')
-        ids = s.get_identifiers()
-        eq(ids, ['who', 'what'])
-
-        # if the pattern has an unrecognized capture group,
-        # it should raise ValueError like substitute and safe_substitute do
-        class BadPattern(Template):
-            pattern = r"""
-            (?P<badname>.*)                  |
-            (?P<escaped>@{2})                   |
-            @(?P<named>[_a-z][._a-z0-9]*)       |
-            @{(?P<braced>[_a-z][._a-z0-9]*)}    |
-            (?P<invalid>@)                      |
-            """
-        s = BadPattern('@bag.foo.who likes to eat a bag of @bag.what')
-        self.assertRaises(ValueError, s.get_identifiers)
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/test/test_string/__init__.py b/Lib/test/test_string/__init__.py
new file mode 100644
index 00000000000..4b16ecc3115
--- /dev/null
+++ b/Lib/test/test_string/__init__.py
@@ -0,0 +1,5 @@
+import os
+from test.support import load_package_tests
+
+def load_tests(*args):
+    return load_package_tests(os.path.dirname(__file__), *args)
diff --git a/Lib/test/test_string/_support.py b/Lib/test/test_string/_support.py
new file mode 100644
index 00000000000..eaa3354a559
--- /dev/null
+++ b/Lib/test/test_string/_support.py
@@ -0,0 +1,55 @@
+import unittest
+from string.templatelib import Interpolation
+
+
+class TStringBaseCase:
+    def assertTStringEqual(self, t, strings, interpolations):
+        """Test template string literal equality.
+
+        The *strings* argument must be a tuple of strings equal to *t.strings*.
+
+        The *interpolations* argument must be a sequence of tuples which are
+        compared against *t.interpolations*. Each tuple consists of
+        (value, expression, conversion, format_spec), though the final two
+        items may be omitted, and are assumed to be None and '' respectively.
+        """
+        self.assertEqual(t.strings, strings)
+        self.assertEqual(len(t.interpolations), len(interpolations))
+
+        for i, exp in zip(t.interpolations, interpolations, strict=True):
+            if len(exp) == 4:
+                actual = (i.value, i.expression, i.conversion, i.format_spec)
+                self.assertEqual(actual, exp)
+                continue
+
+            if len(exp) == 3:
+                self.assertEqual((i.value, i.expression, i.conversion), exp)
+                self.assertEqual(i.format_spec, '')
+                continue
+
+            self.assertEqual((i.value, i.expression), exp)
+            self.assertEqual(i.format_spec, '')
+            self.assertIsNone(i.conversion)
+
+
+def convert(value, conversion):
+    if conversion == "a":
+        return ascii(value)
+    elif conversion == "r":
+        return repr(value)
+    elif conversion == "s":
+        return str(value)
+    return value
+
+
+def fstring(template):
+    parts = []
+    for item in template:
+        match item:
+            case str() as s:
+                parts.append(s)
+            case Interpolation(value, _, conversion, format_spec):
+                value = convert(value, conversion)
+                value = format(value, format_spec)
+                parts.append(value)
+    return "".join(parts)
diff --git a/Lib/test/test_string/test_string.py b/Lib/test/test_string/test_string.py
new file mode 100644
index 00000000000..f6d112d8a93
--- /dev/null
+++ b/Lib/test/test_string/test_string.py
@@ -0,0 +1,550 @@
+import unittest
+import string
+from string import Template
+import types
+
+
+class ModuleTest(unittest.TestCase):
+
+    def test_attrs(self):
+        # While the exact order of the items in these attributes is not
+        # technically part of the "language spec", in practice there is almost
+        # certainly user code that depends on the order, so de-facto it *is*
+        # part of the spec.
+        self.assertEqual(string.whitespace, ' \t\n\r\x0b\x0c')
+        self.assertEqual(string.ascii_lowercase, 'abcdefghijklmnopqrstuvwxyz')
+        self.assertEqual(string.ascii_uppercase, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
+        self.assertEqual(string.ascii_letters, string.ascii_lowercase + string.ascii_uppercase)
+        self.assertEqual(string.digits, '0123456789')
+        self.assertEqual(string.hexdigits, string.digits + 'abcdefABCDEF')
+        self.assertEqual(string.octdigits, '01234567')
+        self.assertEqual(string.punctuation, '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~')
+        self.assertEqual(string.printable, string.digits + string.ascii_lowercase + string.ascii_uppercase + string.punctuation + string.whitespace)
+
+    def test_capwords(self):
+        self.assertEqual(string.capwords('abc def ghi'), 'Abc Def Ghi')
+        self.assertEqual(string.capwords('abc\tdef\nghi'), 'Abc Def Ghi')
+        self.assertEqual(string.capwords('abc\t   def  \nghi'), 'Abc Def Ghi')
+        self.assertEqual(string.capwords('ABC DEF GHI'), 'Abc Def Ghi')
+        self.assertEqual(string.capwords('ABC-DEF-GHI', '-'), 'Abc-Def-Ghi')
+        self.assertEqual(string.capwords('ABC-def DEF-ghi GHI'), 'Abc-def Def-ghi Ghi')
+        self.assertEqual(string.capwords('   aBc  DeF   '), 'Abc Def')
+        self.assertEqual(string.capwords('\taBc\tDeF\t'), 'Abc Def')
+        self.assertEqual(string.capwords('\taBc\tDeF\t', '\t'), '\tAbc\tDef\t')
+
+    def test_basic_formatter(self):
+        fmt = string.Formatter()
+        self.assertEqual(fmt.format("foo"), "foo")
+        self.assertEqual(fmt.format("foo{0}", "bar"), "foobar")
+        self.assertEqual(fmt.format("foo{1}{0}-{1}", "bar", 6), "foo6bar-6")
+        self.assertRaises(TypeError, fmt.format)
+        self.assertRaises(TypeError, string.Formatter.format)
+
+    def test_format_keyword_arguments(self):
+        fmt = string.Formatter()
+        self.assertEqual(fmt.format("-{arg}-", arg='test'), '-test-')
+        self.assertRaises(KeyError, fmt.format, "-{arg}-")
+        self.assertEqual(fmt.format("-{self}-", self='test'), '-test-')
+        self.assertRaises(KeyError, fmt.format, "-{self}-")
+        self.assertEqual(fmt.format("-{format_string}-", format_string='test'),
+                         '-test-')
+        self.assertRaises(KeyError, fmt.format, "-{format_string}-")
+        with self.assertRaisesRegex(TypeError, "format_string"):
+            fmt.format(format_string="-{arg}-", arg='test')
+
+    def test_auto_numbering(self):
+        fmt = string.Formatter()
+        self.assertEqual(fmt.format('foo{}{}', 'bar', 6),
+                         'foo{}{}'.format('bar', 6))
+        self.assertEqual(fmt.format('foo{1}{num}{1}', None, 'bar', num=6),
+                         'foo{1}{num}{1}'.format(None, 'bar', num=6))
+        self.assertEqual(fmt.format('{:^{}}', 'bar', 6),
+                         '{:^{}}'.format('bar', 6))
+        self.assertEqual(fmt.format('{:^{}} {}', 'bar', 6, 'X'),
+                         '{:^{}} {}'.format('bar', 6, 'X'))
+        self.assertEqual(fmt.format('{:^{pad}}{}', 'foo', 'bar', pad=6),
+                         '{:^{pad}}{}'.format('foo', 'bar', pad=6))
+
+        with self.assertRaises(ValueError):
+            fmt.format('foo{1}{}', 'bar', 6)
+
+        with self.assertRaises(ValueError):
+            fmt.format('foo{}{1}', 'bar', 6)
+
+    def test_conversion_specifiers(self):
+        fmt = string.Formatter()
+        self.assertEqual(fmt.format("-{arg!r}-", arg='test'), "-'test'-")
+        self.assertEqual(fmt.format("{0!s}", 'test'), 'test')
+        self.assertRaises(ValueError, fmt.format, "{0!h}", 'test')
+        # issue13579
+        self.assertEqual(fmt.format("{0!a}", 42), '42')
+        self.assertEqual(fmt.format("{0!a}",  string.ascii_letters),
+            "'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'")
+        self.assertEqual(fmt.format("{0!a}",  chr(255)), "'\\xff'")
+        self.assertEqual(fmt.format("{0!a}",  chr(256)), "'\\u0100'")
+
+    def test_name_lookup(self):
+        fmt = string.Formatter()
+        class AnyAttr:
+            def __getattr__(self, attr):
+                return attr
+        x = AnyAttr()
+        self.assertEqual(fmt.format("{0.lumber}{0.jack}", x), 'lumberjack')
+        with self.assertRaises(AttributeError):
+            fmt.format("{0.lumber}{0.jack}", '')
+
+    def test_index_lookup(self):
+        fmt = string.Formatter()
+        lookup = ["eggs", "and", "spam"]
+        self.assertEqual(fmt.format("{0[2]}{0[0]}", lookup), 'spameggs')
+        with self.assertRaises(IndexError):
+            fmt.format("{0[2]}{0[0]}", [])
+        with self.assertRaises(KeyError):
+            fmt.format("{0[2]}{0[0]}", {})
+
+    def test_auto_numbering_lookup(self):
+        fmt = string.Formatter()
+        namespace = types.SimpleNamespace(foo=types.SimpleNamespace(bar='baz'))
+        widths = [None, types.SimpleNamespace(qux=4)]
+        self.assertEqual(
+            fmt.format("{.foo.bar:{[1].qux}}", namespace, widths), 'baz ')
+
+    def test_auto_numbering_reenterability(self):
+        class ReenteringFormatter(string.Formatter):
+            def format_field(self, value, format_spec):
+                if format_spec.isdigit() and int(format_spec) > 0:
+                    return self.format('{:{}}!', value, int(format_spec) - 1)
+                else:
+                    return super().format_field(value, format_spec)
+        fmt = ReenteringFormatter()
+        x = types.SimpleNamespace(a='X')
+        self.assertEqual(fmt.format('{.a:{}}', x, 3), 'X!!!')
+
+    def test_override_get_value(self):
+        class NamespaceFormatter(string.Formatter):
+            def __init__(self, namespace={}):
+                string.Formatter.__init__(self)
+                self.namespace = namespace
+
+            def get_value(self, key, args, kwds):
+                if isinstance(key, str):
+                    try:
+                        # Check explicitly passed arguments first
+                        return kwds[key]
+                    except KeyError:
+                        return self.namespace[key]
+                else:
+                    string.Formatter.get_value(key, args, kwds)
+
+        fmt = NamespaceFormatter({'greeting':'hello'})
+        self.assertEqual(fmt.format("{greeting}, world!"), 'hello, world!')
+
+
+    def test_override_format_field(self):
+        class CallFormatter(string.Formatter):
+            def format_field(self, value, format_spec):
+                return format(value(), format_spec)
+
+        fmt = CallFormatter()
+        self.assertEqual(fmt.format('*{0}*', lambda : 'result'), '*result*')
+
+
+    def test_override_convert_field(self):
+        class XFormatter(string.Formatter):
+            def convert_field(self, value, conversion):
+                if conversion == 'x':
+                    return None
+                return super().convert_field(value, conversion)
+
+        fmt = XFormatter()
+        self.assertEqual(fmt.format("{0!r}:{0!x}", 'foo', 'foo'), "'foo':None")
+
+
+    def test_override_parse(self):
+        class BarFormatter(string.Formatter):
+            # returns an iterable that contains tuples of the form:
+            # (literal_text, field_name, format_spec, conversion)
+            def parse(self, format_string):
+                for field in format_string.split('|'):
+                    if field[0] == '+':
+                        # it's markup
+                        field_name, _, format_spec = field[1:].partition(':')
+                        yield '', field_name, format_spec, None
+                    else:
+                        yield field, None, None, None
+
+        fmt = BarFormatter()
+        self.assertEqual(fmt.format('*|+0:^10s|*', 'foo'), '*   foo    *')
+
+    def test_check_unused_args(self):
+        class CheckAllUsedFormatter(string.Formatter):
+            def check_unused_args(self, used_args, args, kwargs):
+                # Track which arguments actually got used
+                unused_args = set(kwargs.keys())
+                unused_args.update(range(0, len(args)))
+
+                for arg in used_args:
+                    unused_args.remove(arg)
+
+                if unused_args:
+                    raise ValueError("unused arguments")
+
+        fmt = CheckAllUsedFormatter()
+        self.assertEqual(fmt.format("{0}", 10), "10")
+        self.assertEqual(fmt.format("{0}{i}", 10, i=100), "10100")
+        self.assertEqual(fmt.format("{0}{i}{1}", 10, 20, i=100), "1010020")
+        self.assertRaises(ValueError, fmt.format, "{0}{i}{1}", 10, 20, i=100, j=0)
+        self.assertRaises(ValueError, fmt.format, "{0}", 10, 20)
+        self.assertRaises(ValueError, fmt.format, "{0}", 10, 20, i=100)
+        self.assertRaises(ValueError, fmt.format, "{i}", 10, 20, i=100)
+
+    def test_vformat_recursion_limit(self):
+        fmt = string.Formatter()
+        args = ()
+        kwargs = dict(i=100)
+        with self.assertRaises(ValueError) as err:
+            fmt._vformat("{i}", args, kwargs, set(), -1)
+        self.assertIn("recursion", str(err.exception))
+
+
+# Template tests (formerly housed in test_pep292.py)
+
+class Bag:
+    pass
+
+class Mapping:
+    def __getitem__(self, name):
+        obj = self
+        for part in name.split('.'):
+            try:
+                obj = getattr(obj, part)
+            except AttributeError:
+                raise KeyError(name)
+        return obj
+
+
+class TestTemplate(unittest.TestCase):
+    def test_regular_templates(self):
+        s = Template('$who likes to eat a bag of $what worth $$100')
+        self.assertEqual(s.substitute(dict(who='tim', what='ham')),
+                         'tim likes to eat a bag of ham worth $100')
+        self.assertRaises(KeyError, s.substitute, dict(who='tim'))
+        self.assertRaises(TypeError, Template.substitute)
+
+    def test_regular_templates_with_braces(self):
+        s = Template('$who likes ${what} for ${meal}')
+        d = dict(who='tim', what='ham', meal='dinner')
+        self.assertEqual(s.substitute(d), 'tim likes ham for dinner')
+        self.assertRaises(KeyError, s.substitute,
+                          dict(who='tim', what='ham'))
+
+    def test_regular_templates_with_upper_case(self):
+        s = Template('$WHO likes ${WHAT} for ${MEAL}')
+        d = dict(WHO='tim', WHAT='ham', MEAL='dinner')
+        self.assertEqual(s.substitute(d), 'tim likes ham for dinner')
+
+    def test_regular_templates_with_non_letters(self):
+        s = Template('$_wh0_ likes ${_w_h_a_t_} for ${mea1}')
+        d = dict(_wh0_='tim', _w_h_a_t_='ham', mea1='dinner')
+        self.assertEqual(s.substitute(d), 'tim likes ham for dinner')
+
+    def test_escapes(self):
+        eq = self.assertEqual
+        s = Template('$who likes to eat a bag of $$what worth $$100')
+        eq(s.substitute(dict(who='tim', what='ham')),
+           'tim likes to eat a bag of $what worth $100')
+        s = Template('$who likes $$')
+        eq(s.substitute(dict(who='tim', what='ham')), 'tim likes $')
+
+    def test_percents(self):
+        eq = self.assertEqual
+        s = Template('%(foo)s $foo ${foo}')
+        d = dict(foo='baz')
+        eq(s.substitute(d), '%(foo)s baz baz')
+        eq(s.safe_substitute(d), '%(foo)s baz baz')
+
+    def test_stringification(self):
+        eq = self.assertEqual
+        s = Template('tim has eaten $count bags of ham today')
+        d = dict(count=7)
+        eq(s.substitute(d), 'tim has eaten 7 bags of ham today')
+        eq(s.safe_substitute(d), 'tim has eaten 7 bags of ham today')
+        s = Template('tim has eaten ${count} bags of ham today')
+        eq(s.substitute(d), 'tim has eaten 7 bags of ham today')
+
+    def test_tupleargs(self):
+        eq = self.assertEqual
+        s = Template('$who ate ${meal}')
+        d = dict(who=('tim', 'fred'), meal=('ham', 'kung pao'))
+        eq(s.substitute(d), "('tim', 'fred') ate ('ham', 'kung pao')")
+        eq(s.safe_substitute(d), "('tim', 'fred') ate ('ham', 'kung pao')")
+
+    def test_SafeTemplate(self):
+        eq = self.assertEqual
+        s = Template('$who likes ${what} for ${meal}')
+        eq(s.safe_substitute(dict(who='tim')), 'tim likes ${what} for ${meal}')
+        eq(s.safe_substitute(dict(what='ham')), '$who likes ham for ${meal}')
+        eq(s.safe_substitute(dict(what='ham', meal='dinner')),
+           '$who likes ham for dinner')
+        eq(s.safe_substitute(dict(who='tim', what='ham')),
+           'tim likes ham for ${meal}')
+        eq(s.safe_substitute(dict(who='tim', what='ham', meal='dinner')),
+           'tim likes ham for dinner')
+
+    def test_invalid_placeholders(self):
+        raises = self.assertRaises
+        s = Template('$who likes $')
+        raises(ValueError, s.substitute, dict(who='tim'))
+        s = Template('$who likes ${what)')
+        raises(ValueError, s.substitute, dict(who='tim'))
+        s = Template('$who likes $100')
+        raises(ValueError, s.substitute, dict(who='tim'))
+        # Template.idpattern should match to only ASCII characters.
+        # https://bugs.python.org/issue31672
+        s = Template("$who likes $\u0131")  # (DOTLESS I)
+        raises(ValueError, s.substitute, dict(who='tim'))
+        s = Template("$who likes $\u0130")  # (LATIN CAPITAL LETTER I WITH DOT ABOVE)
+        raises(ValueError, s.substitute, dict(who='tim'))
+
+    def test_idpattern_override(self):
+        class PathPattern(Template):
+            idpattern = r'[_a-z][._a-z0-9]*'
+        m = Mapping()
+        m.bag = Bag()
+        m.bag.foo = Bag()
+        m.bag.foo.who = 'tim'
+        m.bag.what = 'ham'
+        s = PathPattern('$bag.foo.who likes to eat a bag of $bag.what')
+        self.assertEqual(s.substitute(m), 'tim likes to eat a bag of ham')
+
+    def test_flags_override(self):
+        class MyPattern(Template):
+            flags = 0
+        s = MyPattern('$wHO likes ${WHAT} for ${meal}')
+        d = dict(wHO='tim', WHAT='ham', meal='dinner', w='fred')
+        self.assertRaises(ValueError, s.substitute, d)
+        self.assertEqual(s.safe_substitute(d), 'fredHO likes ${WHAT} for dinner')
+
+    def test_idpattern_override_inside_outside(self):
+        # bpo-1198569: Allow the regexp inside and outside braces to be
+        # different when deriving from Template.
+        class MyPattern(Template):
+            idpattern = r'[a-z]+'
+            braceidpattern = r'[A-Z]+'
+            flags = 0
+        m = dict(foo='foo', BAR='BAR')
+        s = MyPattern('$foo ${BAR}')
+        self.assertEqual(s.substitute(m), 'foo BAR')
+
+    def test_idpattern_override_inside_outside_invalid_unbraced(self):
+        # bpo-1198569: Allow the regexp inside and outside braces to be
+        # different when deriving from Template.
+        class MyPattern(Template):
+            idpattern = r'[a-z]+'
+            braceidpattern = r'[A-Z]+'
+            flags = 0
+        m = dict(foo='foo', BAR='BAR')
+        s = MyPattern('$FOO')
+        self.assertRaises(ValueError, s.substitute, m)
+        s = MyPattern('${bar}')
+        self.assertRaises(ValueError, s.substitute, m)
+
+    def test_pattern_override(self):
+        class MyPattern(Template):
+            pattern = r"""
+            (?P<escaped>@{2})                   |
+            @(?P<named>[_a-z][._a-z0-9]*)       |
+            @{(?P<braced>[_a-z][._a-z0-9]*)}    |
+            (?P<invalid>@)
+            """
+        m = Mapping()
+        m.bag = Bag()
+        m.bag.foo = Bag()
+        m.bag.foo.who = 'tim'
+        m.bag.what = 'ham'
+        s = MyPattern('@bag.foo.who likes to eat a bag of @bag.what')
+        self.assertEqual(s.substitute(m), 'tim likes to eat a bag of ham')
+
+        class BadPattern(Template):
+            pattern = r"""
+            (?P<badname>.*)                     |
+            (?P<escaped>@{2})                   |
+            @(?P<named>[_a-z][._a-z0-9]*)       |
+            @{(?P<braced>[_a-z][._a-z0-9]*)}    |
+            (?P<invalid>@)                      |
+            """
+        s = BadPattern('@bag.foo.who likes to eat a bag of @bag.what')
+        self.assertRaises(ValueError, s.substitute, {})
+        self.assertRaises(ValueError, s.safe_substitute, {})
+
+    def test_braced_override(self):
+        class MyTemplate(Template):
+            pattern = r"""
+            \$(?:
+              (?P<escaped>$)                     |
+              (?P<named>[_a-z][_a-z0-9]*)        |
+              @@(?P<braced>[_a-z][_a-z0-9]*)@@   |
+              (?P<invalid>)                      |
+           )
+           """
+
+        tmpl = 'PyCon in $@@location@@'
+        t = MyTemplate(tmpl)
+        self.assertRaises(KeyError, t.substitute, {})
+        val = t.substitute({'location': 'Cleveland'})
+        self.assertEqual(val, 'PyCon in Cleveland')
+
+    def test_braced_override_safe(self):
+        class MyTemplate(Template):
+            pattern = r"""
+            \$(?:
+              (?P<escaped>$)                     |
+              (?P<named>[_a-z][_a-z0-9]*)        |
+              @@(?P<braced>[_a-z][_a-z0-9]*)@@   |
+              (?P<invalid>)                      |
+           )
+           """
+
+        tmpl = 'PyCon in $@@location@@'
+        t = MyTemplate(tmpl)
+        self.assertEqual(t.safe_substitute(), tmpl)
+        val = t.safe_substitute({'location': 'Cleveland'})
+        self.assertEqual(val, 'PyCon in Cleveland')
+
+    def test_invalid_with_no_lines(self):
+        # The error formatting for invalid templates
+        # has a special case for no data that the default
+        # pattern can't trigger (always has at least '$')
+        # So we craft a pattern that is always invalid
+        # with no leading data.
+        class MyTemplate(Template):
+            pattern = r"""
+              (?P<invalid>) |
+              unreachable(
+                (?P<named>)   |
+                (?P<braced>)  |
+                (?P<escaped>)
+              )
+            """
+        s = MyTemplate('')
+        with self.assertRaises(ValueError) as err:
+            s.substitute({})
+        self.assertIn('line 1, col 1', str(err.exception))
+
+    def test_unicode_values(self):
+        s = Template('$who likes $what')
+        d = dict(who='t\xffm', what='f\xfe\fed')
+        self.assertEqual(s.substitute(d), 't\xffm likes f\xfe\x0ced')
+
+    def test_keyword_arguments(self):
+        eq = self.assertEqual
+        s = Template('$who likes $what')
+        eq(s.substitute(who='tim', what='ham'), 'tim likes ham')
+        eq(s.substitute(dict(who='tim'), what='ham'), 'tim likes ham')
+        eq(s.substitute(dict(who='fred', what='kung pao'),
+                        who='tim', what='ham'),
+           'tim likes ham')
+        s = Template('the mapping is $mapping')
+        eq(s.substitute(dict(foo='none'), mapping='bozo'),
+           'the mapping is bozo')
+        eq(s.substitute(dict(mapping='one'), mapping='two'),
+           'the mapping is two')
+
+        s = Template('the self is $self')
+        eq(s.substitute(self='bozo'), 'the self is bozo')
+
+    def test_keyword_arguments_safe(self):
+        eq = self.assertEqual
+        raises = self.assertRaises
+        s = Template('$who likes $what')
+        eq(s.safe_substitute(who='tim', what='ham'), 'tim likes ham')
+        eq(s.safe_substitute(dict(who='tim'), what='ham'), 'tim likes ham')
+        eq(s.safe_substitute(dict(who='fred', what='kung pao'),
+                        who='tim', what='ham'),
+           'tim likes ham')
+        s = Template('the mapping is $mapping')
+        eq(s.safe_substitute(dict(foo='none'), mapping='bozo'),
+           'the mapping is bozo')
+        eq(s.safe_substitute(dict(mapping='one'), mapping='two'),
+           'the mapping is two')
+        d = dict(mapping='one')
+        raises(TypeError, s.substitute, d, {})
+        raises(TypeError, s.safe_substitute, d, {})
+
+        s = Template('the self is $self')
+        eq(s.safe_substitute(self='bozo'), 'the self is bozo')
+
+    def test_delimiter_override(self):
+        eq = self.assertEqual
+        raises = self.assertRaises
+        class AmpersandTemplate(Template):
+            delimiter = '&'
+        s = AmpersandTemplate('this &gift is for &{who} &&')
+        eq(s.substitute(gift='bud', who='you'), 'this bud is for you &')
+        raises(KeyError, s.substitute)
+        eq(s.safe_substitute(gift='bud', who='you'), 'this bud is for you &')
+        eq(s.safe_substitute(), 'this &gift is for &{who} &')
+        s = AmpersandTemplate('this &gift is for &{who} &')
+        raises(ValueError, s.substitute, dict(gift='bud', who='you'))
+        eq(s.safe_substitute(), 'this &gift is for &{who} &')
+
+        class PieDelims(Template):
+            delimiter = '@'
+        s = PieDelims('@who likes to eat a bag of @{what} worth $100')
+        self.assertEqual(s.substitute(dict(who='tim', what='ham')),
+                         'tim likes to eat a bag of ham worth $100')
+
+    def test_is_valid(self):
+        eq = self.assertEqual
+        s = Template('$who likes to eat a bag of ${what} worth $$100')
+        self.assertTrue(s.is_valid())
+
+        s = Template('$who likes to eat a bag of ${what} worth $100')
+        self.assertFalse(s.is_valid())
+
+        # if the pattern has an unrecognized capture group,
+        # it should raise ValueError like substitute and safe_substitute do
+        class BadPattern(Template):
+            pattern = r"""
+            (?P<badname>.*)                  |
+            (?P<escaped>@{2})                   |
+            @(?P<named>[_a-z][._a-z0-9]*)       |
+            @{(?P<braced>[_a-z][._a-z0-9]*)}    |
+            (?P<invalid>@)                      |
+            """
+        s = BadPattern('@bag.foo.who likes to eat a bag of @bag.what')
+        self.assertRaises(ValueError, s.is_valid)
+
+    def test_get_identifiers(self):
+        eq = self.assertEqual
+        raises = self.assertRaises
+        s = Template('$who likes to eat a bag of ${what} worth $$100')
+        ids = s.get_identifiers()
+        eq(ids, ['who', 'what'])
+
+        # repeated identifiers only included once
+        s = Template('$who likes to eat a bag of ${what} worth $$100; ${who} likes to eat a bag of $what worth $$100')
+        ids = s.get_identifiers()
+        eq(ids, ['who', 'what'])
+
+        # invalid identifiers are ignored
+        s = Template('$who likes to eat a bag of ${what} worth $100')
+        ids = s.get_identifiers()
+        eq(ids, ['who', 'what'])
+
+        # if the pattern has an unrecognized capture group,
+        # it should raise ValueError like substitute and safe_substitute do
+        class BadPattern(Template):
+            pattern = r"""
+            (?P<badname>.*)                  |
+            (?P<escaped>@{2})                   |
+            @(?P<named>[_a-z][._a-z0-9]*)       |
+            @{(?P<braced>[_a-z][._a-z0-9]*)}    |
+            (?P<invalid>@)                      |
+            """
+        s = BadPattern('@bag.foo.who likes to eat a bag of @bag.what')
+        self.assertRaises(ValueError, s.get_identifiers)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_string/test_templatelib.py b/Lib/test/test_string/test_templatelib.py
new file mode 100644
index 00000000000..5cf18782851
--- /dev/null
+++ b/Lib/test/test_string/test_templatelib.py
@@ -0,0 +1,122 @@
+import pickle
+import unittest
+from string.templatelib import Template, Interpolation
+
+from test.test_string._support import TStringBaseCase, fstring
+
+
+class TestTemplate(unittest.TestCase, TStringBaseCase):
+
+    def test_common(self):
+        self.assertEqual(type(t'').__name__, 'Template')
+        self.assertEqual(type(t'').__qualname__, 'Template')
+        self.assertEqual(type(t'').__module__, 'string.templatelib')
+
+        a = 'a'
+        i = t'{a}'.interpolations[0]
+        self.assertEqual(type(i).__name__, 'Interpolation')
+        self.assertEqual(type(i).__qualname__, 'Interpolation')
+        self.assertEqual(type(i).__module__, 'string.templatelib')
+
+    def test_basic_creation(self):
+        # Simple t-string creation
+        t = t'Hello, world'
+        self.assertIsInstance(t, Template)
+        self.assertTStringEqual(t, ('Hello, world',), ())
+        self.assertEqual(fstring(t), 'Hello, world')
+
+        # Empty t-string
+        t = t''
+        self.assertTStringEqual(t, ('',), ())
+        self.assertEqual(fstring(t), '')
+
+        # Multi-line t-string
+        t = t"""Hello,
+world"""
+        self.assertEqual(t.strings, ('Hello,\nworld',))
+        self.assertEqual(len(t.interpolations), 0)
+        self.assertEqual(fstring(t), 'Hello,\nworld')
+
+    def test_creation_interleaving(self):
+        # Should add strings on either side
+        t = Template(Interpolation('Maria', 'name', None, ''))
+        self.assertTStringEqual(t, ('', ''), [('Maria', 'name')])
+        self.assertEqual(fstring(t), 'Maria')
+
+        # Should prepend empty string
+        t = Template(Interpolation('Maria', 'name', None, ''), ' is my name')
+        self.assertTStringEqual(t, ('', ' is my name'), [('Maria', 'name')])
+        self.assertEqual(fstring(t), 'Maria is my name')
+
+        # Should append empty string
+        t = Template('Hello, ', Interpolation('Maria', 'name', None, ''))
+        self.assertTStringEqual(t, ('Hello, ', ''), [('Maria', 'name')])
+        self.assertEqual(fstring(t), 'Hello, Maria')
+
+        # Should concatenate strings
+        t = Template('Hello', ', ', Interpolation('Maria', 'name', None, ''),
+                     '!')
+        self.assertTStringEqual(t, ('Hello, ', '!'), [('Maria', 'name')])
+        self.assertEqual(fstring(t), 'Hello, Maria!')
+
+        # Should add strings on either side and in between
+        t = Template(Interpolation('Maria', 'name', None, ''),
+                     Interpolation('Python', 'language', None, ''))
+        self.assertTStringEqual(
+            t, ('', '', ''), [('Maria', 'name'), ('Python', 'language')]
+        )
+        self.assertEqual(fstring(t), 'MariaPython')
+
+    def test_template_values(self):
+        t = t'Hello, world'
+        self.assertEqual(t.values, ())
+
+        name = "Lys"
+        t = t'Hello, {name}'
+        self.assertEqual(t.values, ("Lys",))
+
+        country = "GR"
+        age = 0
+        t = t'Hello, {name}, {age} from {country}'
+        self.assertEqual(t.values, ("Lys", 0, "GR"))
+
+    def test_pickle_template(self):
+        user = 'test'
+        for template in (
+            t'',
+            t"No values",
+            t'With inter {user}',
+            t'With ! {user!r}',
+            t'With format {1 / 0.3:.2f}',
+            Template(),
+            Template('a'),
+            Template(Interpolation('Nikita', 'name', None, '')),
+            Template('a', Interpolation('Nikita', 'name', 'r', '')),
+        ):
+            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+                with self.subTest(proto=proto, template=template):
+                    pickled = pickle.dumps(template, protocol=proto)
+                    unpickled = pickle.loads(pickled)
+
+                    self.assertEqual(unpickled.values, template.values)
+                    self.assertEqual(fstring(unpickled), fstring(template))
+
+    def test_pickle_interpolation(self):
+        for interpolation in (
+            Interpolation('Nikita', 'name', None, ''),
+            Interpolation('Nikita', 'name', 'r', ''),
+            Interpolation(1/3, 'x', None, '.2f'),
+        ):
+            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+                with self.subTest(proto=proto, interpolation=interpolation):
+                    pickled = pickle.dumps(interpolation, protocol=proto)
+                    unpickled = pickle.loads(pickled)
+
+                    self.assertEqual(unpickled.value, interpolation.value)
+                    self.assertEqual(unpickled.expression, interpolation.expression)
+                    self.assertEqual(unpickled.conversion, interpolation.conversion)
+                    self.assertEqual(unpickled.format_spec, interpolation.format_spec)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_syntax.py b/Lib/test/test_syntax.py
index 4c001f9c9b0..55492350d00 100644
--- a/Lib/test/test_syntax.py
+++ b/Lib/test/test_syntax.py
@@ -1877,6 +1877,14 @@
 Traceback (most recent call last):
 SyntaxError: cannot assign to f-string expression here. Maybe you meant '==' instead of '='?
 
+>>> t'{x}' = 42
+Traceback (most recent call last):
+SyntaxError: cannot assign to t-string expression here. Maybe you meant '==' instead of '='?
+
+>>> t'{x}-{y}' = 42
+Traceback (most recent call last):
+SyntaxError: cannot assign to t-string expression here. Maybe you meant '==' instead of '='?
+
 >>> (x, y, z=3, d, e)
 Traceback (most recent call last):
 SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?
diff --git a/Lib/test/test_tstring.py b/Lib/test/test_tstring.py
new file mode 100644
index 00000000000..e72a1ea5417
--- /dev/null
+++ b/Lib/test/test_tstring.py
@@ -0,0 +1,313 @@
+import unittest
+
+from test.test_string._support import TStringBaseCase, fstring
+
+
+class TestTString(unittest.TestCase, TStringBaseCase):
+    def test_string_representation(self):
+        # Test __repr__
+        t = t"Hello"
+        self.assertEqual(repr(t), "Template(strings=('Hello',), interpolations=())")
+
+        name = "Python"
+        t = t"Hello, {name}"
+        self.assertEqual(repr(t),
+            "Template(strings=('Hello, ', ''), "
+            "interpolations=(Interpolation('Python', 'name', None, ''),))"
+        )
+
+    def test_interpolation_basics(self):
+        # Test basic interpolation
+        name = "Python"
+        t = t"Hello, {name}"
+        self.assertTStringEqual(t, ("Hello, ", ""), [(name, "name")])
+        self.assertEqual(fstring(t), "Hello, Python")
+
+        # Multiple interpolations
+        first = "Python"
+        last = "Developer"
+        t = t"{first} {last}"
+        self.assertTStringEqual(
+            t, ("", " ", ""), [(first, 'first'), (last, 'last')]
+        )
+        self.assertEqual(fstring(t), "Python Developer")
+
+        # Interpolation with expressions
+        a = 10
+        b = 20
+        t = t"Sum: {a + b}"
+        self.assertTStringEqual(t, ("Sum: ", ""), [(a + b, "a + b")])
+        self.assertEqual(fstring(t), "Sum: 30")
+
+        # Interpolation with function
+        def square(x):
+            return x * x
+        t = t"Square: {square(5)}"
+        self.assertTStringEqual(
+            t, ("Square: ", ""), [(square(5), "square(5)")]
+        )
+        self.assertEqual(fstring(t), "Square: 25")
+
+        # Test attribute access in expressions
+        class Person:
+            def __init__(self, name):
+                self.name = name
+
+            def upper(self):
+                return self.name.upper()
+
+        person = Person("Alice")
+        t = t"Name: {person.name}"
+        self.assertTStringEqual(
+            t, ("Name: ", ""), [(person.name, "person.name")]
+        )
+        self.assertEqual(fstring(t), "Name: Alice")
+
+        # Test method calls
+        t = t"Name: {person.upper()}"
+        self.assertTStringEqual(
+            t, ("Name: ", ""), [(person.upper(), "person.upper()")]
+        )
+        self.assertEqual(fstring(t), "Name: ALICE")
+
+        # Test dictionary access
+        data = {"name": "Bob", "age": 30}
+        t = t"Name: {data['name']}, Age: {data['age']}"
+        self.assertTStringEqual(
+            t, ("Name: ", ", Age: ", ""),
+            [(data["name"], "data['name']"), (data["age"], "data['age']")],
+        )
+        self.assertEqual(fstring(t), "Name: Bob, Age: 30")
+
+    def test_format_specifiers(self):
+        # Test basic format specifiers
+        value = 3.14159
+        t = t"Pi: {value:.2f}"
+        self.assertTStringEqual(
+            t, ("Pi: ", ""), [(value, "value", None, ".2f")]
+        )
+        self.assertEqual(fstring(t), "Pi: 3.14")
+
+    def test_conversions(self):
+        # Test !s conversion (str)
+        obj = object()
+        t = t"Object: {obj!s}"
+        self.assertTStringEqual(t, ("Object: ", ""), [(obj, "obj", "s")])
+        self.assertEqual(fstring(t), f"Object: {str(obj)}")
+
+        # Test !r conversion (repr)
+        t = t"Data: {obj!r}"
+        self.assertTStringEqual(t, ("Data: ", ""), [(obj, "obj", "r")])
+        self.assertEqual(fstring(t), f"Data: {repr(obj)}")
+
+        # Test !a conversion (ascii)
+        text = "Café"
+        t = t"ASCII: {text!a}"
+        self.assertTStringEqual(t, ("ASCII: ", ""), [(text, "text", "a")])
+        self.assertEqual(fstring(t), f"ASCII: {ascii(text)}")
+
+        # Test !z conversion (error)
+        num = 1
+        with self.assertRaises(SyntaxError):
+            eval("t'{num!z}'")
+
+    def test_debug_specifier(self):
+        # Test debug specifier
+        value = 42
+        t = t"Value: {value=}"
+        self.assertTStringEqual(
+            t, ("Value: value=", ""), [(value, "value", "r")]
+        )
+        self.assertEqual(fstring(t), "Value: value=42")
+
+        # Test debug specifier with format (conversion default to !r)
+        t = t"Value: {value=:.2f}"
+        self.assertTStringEqual(
+            t, ("Value: value=", ""), [(value, "value", None, ".2f")]
+        )
+        self.assertEqual(fstring(t), "Value: value=42.00")
+
+        # Test debug specifier with conversion
+        t = t"Value: {value=!s}"
+        self.assertTStringEqual(
+            t, ("Value: value=", ""), [(value, "value", "s")]
+        )
+
+        # Test white space in debug specifier
+        t = t"Value: {value = }"
+        self.assertTStringEqual(
+            t, ("Value: value = ", ""), [(value, "value", "r")]
+        )
+        self.assertEqual(fstring(t), "Value: value = 42")
+
+    def test_raw_tstrings(self):
+        path = r"C:\Users"
+        t = rt"{path}\Documents"
+        self.assertTStringEqual(t, ("", r"\Documents"), [(path, "path")])
+        self.assertEqual(fstring(t), r"C:\Users\Documents")
+
+        # Test alternative prefix
+        t = tr"{path}\Documents"
+        self.assertTStringEqual(t, ("", r"\Documents"), [(path, "path")])
+
+
+    def test_template_concatenation(self):
+        # Test template + template
+        t1 = t"Hello, "
+        t2 = t"world"
+        combined = t1 + t2
+        self.assertTStringEqual(combined, ("Hello, world",), ())
+        self.assertEqual(fstring(combined), "Hello, world")
+
+        # Test template + string
+        t1 = t"Hello"
+        combined = t1 + ", world"
+        self.assertTStringEqual(combined, ("Hello, world",), ())
+        self.assertEqual(fstring(combined), "Hello, world")
+
+        # Test template + template with interpolation
+        name = "Python"
+        t1 = t"Hello, "
+        t2 = t"{name}"
+        combined = t1 + t2
+        self.assertTStringEqual(combined, ("Hello, ", ""), [(name, "name")])
+        self.assertEqual(fstring(combined), "Hello, Python")
+
+        # Test string + template
+        t = "Hello, " + t"{name}"
+        self.assertTStringEqual(t, ("Hello, ", ""), [(name, "name")])
+        self.assertEqual(fstring(t), "Hello, Python")
+
+    def test_nested_templates(self):
+        # Test a template inside another template expression
+        name = "Python"
+        inner = t"{name}"
+        t = t"Language: {inner}"
+
+        t_interp = t.interpolations[0]
+        self.assertEqual(t.strings, ("Language: ", ""))
+        self.assertEqual(t_interp.value.strings, ("", ""))
+        self.assertEqual(t_interp.value.interpolations[0].value, name)
+        self.assertEqual(t_interp.value.interpolations[0].expression, "name")
+        self.assertEqual(t_interp.value.interpolations[0].conversion, None)
+        self.assertEqual(t_interp.value.interpolations[0].format_spec, "")
+        self.assertEqual(t_interp.expression, "inner")
+        self.assertEqual(t_interp.conversion, None)
+        self.assertEqual(t_interp.format_spec, "")
+
+    def test_syntax_errors(self):
+        for case, err in (
+            ("t'", "unterminated t-string literal"),
+            ("t'''", "unterminated triple-quoted t-string literal"),
+            ("t''''", "unterminated triple-quoted t-string literal"),
+            ("t'{", "'{' was never closed"),
+            ("t'{'", "t-string: expecting '}'"),
+            ("t'{a'", "t-string: expecting '}'"),
+            ("t'}'", "t-string: single '}' is not allowed"),
+            ("t'{}'", "t-string: valid expression required before '}'"),
+            ("t'{=x}'", "t-string: valid expression required before '='"),
+            ("t'{!x}'", "t-string: valid expression required before '!'"),
+            ("t'{:x}'", "t-string: valid expression required before ':'"),
+            ("t'{x;y}'", "t-string: expecting '=', or '!', or ':', or '}'"),
+            ("t'{x=y}'", "t-string: expecting '!', or ':', or '}'"),
+            ("t'{x!s!}'", "t-string: expecting ':' or '}'"),
+            ("t'{x!s:'", "t-string: expecting '}', or format specs"),
+            ("t'{x!}'", "t-string: missing conversion character"),
+            ("t'{x=!}'", "t-string: missing conversion character"),
+            ("t'{x!z}'", "t-string: invalid conversion character 'z': "
+                         "expected 's', 'r', or 'a'"),
+            ("t'{lambda:1}'", "t-string: lambda expressions are not allowed "
+                              "without parentheses"),
+            ("t'{x:{;}}'", "t-string: expecting a valid expression after '{'"),
+        ):
+            with self.subTest(case), self.assertRaisesRegex(SyntaxError, err):
+                eval(case)
+
+    def test_runtime_errors(self):
+        # Test missing variables
+        with self.assertRaises(NameError):
+            eval("t'Hello, {name}'")
+
+    def test_literal_concatenation(self):
+        # Test concatenation of t-string literals
+        t = t"Hello, " t"world"
+        self.assertTStringEqual(t, ("Hello, world",), ())
+        self.assertEqual(fstring(t), "Hello, world")
+
+        # Test concatenation with interpolation
+        name = "Python"
+        t = t"Hello, " t"{name}"
+        self.assertTStringEqual(t, ("Hello, ", ""), [(name, "name")])
+        self.assertEqual(fstring(t), "Hello, Python")
+
+        # Test concatenation with string literal
+        name = "Python"
+        t = t"Hello, {name}" "and welcome!"
+        self.assertTStringEqual(
+            t, ("Hello, ", "and welcome!"), [(name, "name")]
+        )
+        self.assertEqual(fstring(t), "Hello, Pythonand welcome!")
+
+        # Test concatenation with Unicode literal
+        name = "Python"
+        t = t"Hello, {name}" u"and welcome!"
+        self.assertTStringEqual(
+            t, ("Hello, ", "and welcome!"), [(name, "name")]
+        )
+        self.assertEqual(fstring(t), "Hello, Pythonand welcome!")
+
+        # Test concatenation with f-string literal
+        tab = '\t'
+        t = t"Tab: {tab}. " f"f-tab: {tab}."
+        self.assertTStringEqual(t, ("Tab: ", ". f-tab: \t."), [(tab, "tab")])
+        self.assertEqual(fstring(t), "Tab: \t. f-tab: \t.")
+
+        # Test concatenation with raw string literal
+        tab = '\t'
+        t = t"Tab: {tab}. " r"Raw tab: \t."
+        self.assertTStringEqual(
+            t, ("Tab: ", r". Raw tab: \t."), [(tab, "tab")]
+        )
+        self.assertEqual(fstring(t), "Tab: \t. Raw tab: \\t.")
+
+        # Test concatenation with raw f-string literal
+        tab = '\t'
+        t = t"Tab: {tab}. " rf"f-tab: {tab}. Raw tab: \t."
+        self.assertTStringEqual(
+            t, ("Tab: ", ". f-tab: \t. Raw tab: \\t."), [(tab, "tab")]
+        )
+        self.assertEqual(fstring(t), "Tab: \t. f-tab: \t. Raw tab: \\t.")
+
+        what = 't'
+        expected_msg = 'cannot mix bytes and nonbytes literals'
+        for case in (
+            "t'{what}-string literal' b'bytes literal'",
+            "t'{what}-string literal' br'raw bytes literal'",
+        ):
+            with self.assertRaisesRegex(SyntaxError, expected_msg):
+                eval(case)
+
+    def test_triple_quoted(self):
+        # Test triple-quoted t-strings
+        t = t"""
+        Hello,
+        world
+        """
+        self.assertTStringEqual(
+            t, ("\n        Hello,\n        world\n        ",), ()
+        )
+        self.assertEqual(fstring(t), "\n        Hello,\n        world\n        ")
+
+        # Test triple-quoted with interpolation
+        name = "Python"
+        t = t"""
+        Hello,
+        {name}
+        """
+        self.assertTStringEqual(
+            t, ("\n        Hello,\n        ", "\n        "), [(name, "name")]
+        )
+        self.assertEqual(fstring(t), "\n        Hello,\n        Python\n        ")
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_unparse.py b/Lib/test/test_unparse.py
index 839326f6436..d3af7a8489e 100644
--- a/Lib/test/test_unparse.py
+++ b/Lib/test/test_unparse.py
@@ -202,6 +202,15 @@ def test_fstrings_pep701(self):
         self.check_ast_roundtrip('f" something { my_dict["key"] } something else "')
         self.check_ast_roundtrip('f"{f"{f"{f"{f"{f"{1+1}"}"}"}"}"}"')
 
+    def test_tstrings(self):
+        self.check_ast_roundtrip("t'foo'")
+        self.check_ast_roundtrip("t'foo {bar}'")
+        self.check_ast_roundtrip("t'foo {bar!s:.2f}'")
+        self.check_ast_roundtrip("t'foo {bar}' f'{bar}'")
+        self.check_ast_roundtrip("f'{bar}' t'foo {bar}'")
+        self.check_ast_roundtrip("t'foo {bar}' fr'\\hello {bar}'")
+        self.check_ast_roundtrip("t'foo {bar}' u'bar'")
+
     def test_strings(self):
         self.check_ast_roundtrip("u'foo'")
         self.check_ast_roundtrip("r'foo'")
@@ -918,7 +927,7 @@ class DirectoryTestCase(ASTTestCase):
     run_always_files = {"test_grammar.py", "test_syntax.py", "test_compile.py",
                         "test_ast.py", "test_asdl_parser.py", "test_fstring.py",
                         "test_patma.py", "test_type_alias.py", "test_type_params.py",
-                        "test_tokenize.py"}
+                        "test_tokenize.py", "test_tstring.py"}
 
     _files_to_test = None