diff --git a/docs/antlr.rst b/docs/antlr.rst
index 52846491..082d535b 100644
--- a/docs/antlr.rst
+++ b/docs/antlr.rst
@@ -1,8 +1,8 @@
 .. include:: links.rst
 
 
-Using ANTLR Grammars
---------------------
+ANTLR Grammars
+--------------
 
 .. _grammars: https://github.com/antlr/grammars-v4
 
diff --git a/docs/asjson.rst b/docs/asjson.rst
deleted file mode 100644
index 7edd772c..00000000
--- a/docs/asjson.rst
+++ /dev/null
@@ -1,25 +0,0 @@
-.. include:: links.rst
-
-Viewing Models as JSON
-----------------------
-
-
-Models generated by |TatSu| can be viewed by converting them to a JSON-compatible structure
-with the help of ``tatsu.util.asjson()``. The protocol tries to provide the best
-representation for common types, and can handle any type using ``repr()``. There are provisions for structures with back-references, so there's no infinite recursion.
-
-.. code:: python
-
-    import json
-
-    print(json.dumps(asjson(model), indent=2))
-
-The ``model``, with richer semantics, remains unaltered.
-
-Conversion to a JSON-compatible structure relies on the protocol defined by
-``tatsu.utils.AsJSONMixin``.  The mixin defines a ``__json__(seen=None)``
-method that allows classes to define their best translation. You can use ``AsJSONMixin``
-as a base class in your own models to take advantage of ``asjson()``, and you can
-specialize the conversion by overriding ``AsJSONMixin.__json__()``.
-
-You can also write your own version of ``asjson()`` to handle special cases that are recurrent in your context.
diff --git a/docs/grako.rst b/docs/grako.rst
deleted file mode 100644
index 2b7ecc5f..00000000
--- a/docs/grako.rst
+++ /dev/null
@@ -1,19 +0,0 @@
-.. include:: links.rst
-
-Grako Compatibility
--------------------
-
-|TatSu| is routinely tested over major projects developed with Grako_. The
-backwards-compatibility suite includes (at least) translators for COBOL_, Java_, and (Oracle) SQL_.
-
-Grako_ grammars and projects can be used with |TatSu|, with these caveats:
-
-*   The `AST`_ type retuned when a sequence of elements is matched is now ``tuple`` (instead of a descendant of ``list``). This change improves efficiency and avoids unwanted manipulations of a value that should be inmutable.
-
-*   The Python_ module name changed to ``tatsu``.
-
-*   ``ignorecase`` no longer applies to regular expressions in grammars. Use ``(?i)`` in the pattern to enable ``re.IGNORECASE``
-
-*   Left recursion is enabled by default because it works and has zero impact on non-recursive grammars.
-
-*   Deprecated grammar syntax is no longer documented. It's best not to use it, as it will be removed in a future version of |TatSu|.
diff --git a/docs/index.rst b/docs/index.rst
index e50f9bf5..3163e585 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -46,13 +46,10 @@ input, much like the `re`_ module does with regular expressions, or it can gener
     ast
     semantics
     models
-    asjson
-    print_translation
     translation
     left_recursion
     mini-tutorial
     traces
-    grako
     antlr
     examples
     support
diff --git a/docs/install.rst b/docs/install.rst
index b359b7e1..c7c2d931 100644
--- a/docs/install.rst
+++ b/docs/install.rst
@@ -9,5 +9,6 @@ Installation
     $ pip install tatsu
 
 .. warning::
-    Versions of |TatSu| since 5.0.0 may require Python>=3.8. Python 2.7 is no longer supported
+    Modern versions of |TatSu| require active versions of Python (if the Python
+    version is more than one and a half years old, things may not work).
 
diff --git a/docs/models.rst b/docs/models.rst
index 21867e33..b54dcb6d 100644
--- a/docs/models.rst
+++ b/docs/models.rst
@@ -1,8 +1,12 @@
 .. include:: links.rst
 
 
+Models
+------
+
+
 Building Models
----------------
+~~~~~~~~~~~~~~~
 
 Naming elements in grammar rules makes the parser discard uninteresting
 parts of the input, like punctuation, to produce an *Abstract Syntax
@@ -41,6 +45,32 @@ You can also use `Python`_'s built-in types as node types, and
 default behavior can be overidden by defining a method to handle the
 result of any particular grammar rule.
 
+
+
+Viewing Models as JSON
+~~~~~~~~~~~~~~~~~~~~~~
+
+
+Models generated by |TatSu| can be viewed by converting them to a JSON-compatible structure
+with the help of ``tatsu.util.asjson()``. The protocol tries to provide the best
+representation for common types, and can handle any type using ``repr()``. There are provisions for structures with back-references, so there's no infinite recursion.
+
+.. code:: python
+
+    import json
+
+    print(json.dumps(asjson(model), indent=2))
+
+The ``model``, with richer semantics, remains unaltered.
+
+Conversion to a JSON-compatible structure relies on the protocol defined by
+``tatsu.utils.AsJSONMixin``.  The mixin defines a ``__json__(seen=None)``
+method that allows classes to define their best translation. You can use ``AsJSONMixin``
+as a base class in your own models to take advantage of ``asjson()``, and you can
+specialize the conversion by overriding ``AsJSONMixin.__json__()``.
+
+You can also write your own version of ``asjson()`` to handle special cases that are recurrent in your context.
+
 Walking Models
 ~~~~~~~~~~~~~~
 
@@ -82,19 +112,18 @@ methods such as:
         return s
 
     def walk_object(self, o):
-        raise Exception('Unexpected tyle %s walked', type(o).__name__)
+        raise Exception(f'Unexpected type {type(o).__name__} walked')
 
-Predeclared classes can be passed to ``ModelBuilderSemantics`` instances
-through the ``types=`` parameter:
-
-.. code:: python
+Which nodes get *walked* is up to the ``NodeWalker`` implementation. Some
+strategies for walking *all* or *most* nodes are implemented as classes
+in ``tatsu.wakers``,  such as ``PreOrderWalker`` and ``DepthFirstWalker``.
 
-    from mymodel import AddOperator, MulOperator
+Sometimes nodes must be walked more than once for the purpose at hand, and it's
+up to the walker how and when to do that.
 
-    semantics=ModelBuilderSemantics(types=[AddOperator, MulOperator])
+Take a look at ``tatsu.ngcodegen.PythonCodeGenerator`` for the walker that generates
+a parser in Python from the model of a parsed grammar.
 
-``ModelBuilderSemantics`` assumes nothing about ``types=``, so any
-constructor (a function, or a partial function) can be used.
 
 Model Class Hierarchies
 ~~~~~~~~~~~~~~~~~~~~~~~
diff --git a/docs/print_translation.rst b/docs/print_translation.rst
deleted file mode 100644
index da477b88..00000000
--- a/docs/print_translation.rst
+++ /dev/null
@@ -1,41 +0,0 @@
-.. include:: links.rst
-
-Print Translation
------------------
-
-
-|TatSu| doesn't impose a way to create translators, but it
-exposes the facilities it uses to generate the `Python`_ source code for
-parsers.
-
-Translation in |TatSu| is based on subclasses of ``Walker`` and on classes that
-inherit from ``IndentPrintMixin``, a strategy copied from the new PEG_ parser
-in Python_ (see `PEP 617`_).
-
-``IndentPrintMixin`` provides an ``indent()`` method, which is a context manager,
-and should be used thus:
-
-.. code:: python
-
-    class MyTranslationWalker(NodeWalker, IndentPrintMixin):
-
-        def walk_SomeNode(self, node):
-            with self.indent():
-                # ccontinue walking the tree
-
-
-The ``self.print()`` method takes note of the current level of indentation, so
-output will be indented by the ``indent`` passed to
-the ``IndentPrintConstructor``:
-
-.. code:: python
-
-    def walk_SomeNode(self, node):
-        with self.indent():
-            self.print(walk_expression(node.exp))
-
-The printed code can be retrieved using the ``printed_text()`` method. Other
-posibilities are available by assigning a text-like object to
-``self.output_stream`` in the ``__init__()`` method.
-
-.. _PEP 617: https://peps.python.org/pep-0617/
diff --git a/docs/translation.rst b/docs/translation.rst
index 192ac503..9a8277be 100644
--- a/docs/translation.rst
+++ b/docs/translation.rst
@@ -5,12 +5,68 @@
 .. _pegen: https://github.com/we-like-parsers/pegen
 .. _PEG parser: https://peps.python.org/pep-0617/
 
-Declarative Translation
------------------------
+Translation
+-----------
 
 Translation is one of the most common tasks in language processing.
 Analysis often sumarizes the parsed input, and *walkers* are good for that.
-In translation, the output can often be as verbose as the input, so a systematic approach that avoids bookkeeping as much as possible is convenient.
+
+
+|TatSu| doesn't impose a way to create translators, but it
+exposes the facilities it uses to generate the `Python`_ source code for
+parsers.
+
+
+Print Translation
+~~~~~~~~~~~~~~~~~
+
+Translation in |TatSu| is based on subclasses of ``NodeWalker``. Print-based translation
+relies on classes that inherit from ``IndentPrintMixin``, a strategy copied from
+the new PEG_ parser in Python_ (see `PEP 617`_).
+
+``IndentPrintMixin`` provides an ``indent()`` method, which is a context manager,
+and should be used thus:
+
+.. code:: python
+
+    class MyTranslationWalker(NodeWalker, IndentPrintMixin):
+
+        def walk_SomeNodeType(self, node: NodeType):
+            self.print('some preamble')
+            with self.indent():
+                # continue walking the tree
+                self.print('something else')
+
+
+The ``self.print()`` method takes note of the current level of indentation, so
+output will be indented by the `indent` passed to
+the ``IndentPrintMixin`` constructor, or to the ``indent(amount: int)`` method.
+The mixin keeps as stack of the indent ammounts so it can go back to where it
+was after each ``with indent(amount=n):`` statement:
+
+
+.. code:: python
+
+    def walk_SomeNodeType(self, node: NodeType):
+        with self.indent(amount=2):
+            self.print(node.exp)
+
+The printed code can be retrieved using the ``printed_text()`` method, but other
+posibilities are available by assigning a stream-like object to
+``self.output_stream`` in the ``__init__()`` method.
+
+A good example of how to do code generation with a ``NodeWalker`` and ``IndentPrintMixin``
+is |TatSu|'s own code generator, which can be
+found in ``tatsu/ngcodegen/python.py``, or the model
+generation found in ``tatsu/ngcodegen/objectomdel.py``.
+
+
+.. _PEP 617: https://peps.python.org/pep-0617/
+
+
+Declarative Translation (deprecated)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
 
 |TatSu| provides support for template-based code generation ("translation", see below)
 in the ``tatsu.codegen`` module.
@@ -26,8 +82,6 @@ breadth or depth first, using only standard Python_. The procedural code must kn
 to navigate it, although other strategies are available with ``PreOrderWalker``, ``DepthFirstWalker``,
 and ``ContextWalker``.
 
-**deprecated**
-
 |TatSu| doesn't impose a way to create translators with it, but it
 exposes the facilities it uses to generate the `Python`_ source code for
 parsers.
diff --git a/grammar/tatsu.ebnf b/grammar/tatsu.ebnf
index 340b4a14..a70e42fc 100644
--- a/grammar/tatsu.ebnf
+++ b/grammar/tatsu.ebnf
@@ -1,4 +1,4 @@
-@@grammar :: Tatsu
+@@grammar :: TatSu
 @@whitespace :: /\s+/
 @@comments :: ?"(?sm)[(][*](?:.|\n)*?[*][)]"
 @@eol_comments :: ?"#[^\n]*$"
diff --git a/ruff.toml b/ruff.toml
index 04687d63..28ca6f1e 100644
--- a/ruff.toml
+++ b/ruff.toml
@@ -20,6 +20,7 @@ ignore = [
     "PLR0904",  # too-many-public-methods
     "PLR0913",  # too-many-arguments
     "PLR0915",  # too-many-statements
+    "PLR0917",  # too many possitional arguments
     "PLR2004",  # magic-value-comparison
     "PLW1514",  # unspecified-encoding
 #    "PLW0603",  # global-statement
diff --git a/tatsu/_version.py b/tatsu/_version.py
index a19f16d9..6f0b6fd4 100644
--- a/tatsu/_version.py
+++ b/tatsu/_version.py
@@ -1 +1 @@
-__version__ = '5.10.7b1'
+__version__ = '5.11.0b1'
diff --git a/tatsu/bootstrap.py b/tatsu/bootstrap.py
index 6c3be580..ce462d20 100644
--- a/tatsu/bootstrap.py
+++ b/tatsu/bootstrap.py
@@ -1,15 +1,15 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
-# CAVEAT UTILITOR
+# WARNING: CAVEAT UTILITOR
 #
-# This file was automatically generated by TatSu.
+#  This file was automatically generated by TatSu.
 #
-#    https://pypi.python.org/pypi/tatsu/
+#     https://pypi.python.org/pypi/tatsu/
 #
-# Any changes you make to it will be overwritten the next time
-# the file is generated.
+#  Any changes you make to it will be overwritten the next time
+#  the file is generated.
 
-# ruff: noqa: C405, I001, F401, SIM117
+# ruff: noqa: C405, COM812, I001, F401, SIM117
 
 import sys
 from pathlib import Path
@@ -30,7 +30,7 @@ def __init__(self, text, /, config: ParserConfig | None = None, **settings):
         config = ParserConfig.new(
             config,
             owner=self,
-            whitespace=re.compile(r"\s+"),
+            whitespace='\\s+',
             nameguard=None,
             ignorecase=False,
             namechars='',
@@ -41,38 +41,39 @@ def __init__(self, text, /, config: ParserConfig | None = None, **settings):
             start='start',
         )
         config = config.replace(**settings)
-        super().__init__(text, config=config)
 
+        super().__init__(text, config=config)
 
 class EBNFBootstrapParser(Parser):
     def __init__(self, /, config: ParserConfig | None = None, **settings):
         config = ParserConfig.new(
             config,
             owner=self,
-            whitespace=re.compile(r"\s+"),
+            whitespace='\\s+',
             nameguard=None,
             ignorecase=False,
             namechars='',
             parseinfo=True,
             comments_re='(?sm)[(][*](?:.|\\n)*?[*][)]',
             eol_comments_re='#[^\\n]*$',
-            left_recursion=False,
             keywords=KEYWORDS,
             start='start',
         )
         config = config.replace(**settings)
+
         super().__init__(config=config)
 
     @tatsumasu()
     def _start_(self):
         self._grammar_()
 
+
     @tatsumasu('Grammar')
     def _grammar_(self):
         self._constant('TATSU')
         self.name_last_node('title')
 
-        def block1():
+        def block0():
             with self._choice():
                 with self._option():
                     self._directive_()
@@ -82,13 +83,13 @@ def block1():
                     self.add_last_node_to_name('keywords')
                 self._error(
                     'expecting one of: '
-                    '<directive> <keyword>'  # noqa: COM812
+                    '<directive> <keyword>'
                 )
-        self._closure(block1)
+        self._closure(block0)
         self._rule_()
         self.add_last_node_to_name('rules')
 
-        def block6():
+        def block1():
             with self._choice():
                 with self._option():
                     self._rule_()
@@ -98,10 +99,14 @@ def block6():
                     self.add_last_node_to_name('keywords')
                 self._error(
                     'expecting one of: '
-                    '<keyword> <rule>'  # noqa: COM812
+                    '<keyword> <rule>'
                 )
-        self._closure(block6)
+        self._closure(block1)
         self._check_eof()
+        self._define(
+            ['title'],
+            ['directives', 'keywords', 'rules'],
+        )
 
         self._define(
             ['title'],
@@ -125,7 +130,7 @@ def _directive_(self):
                                 self._token('eol_comments')
                             self._error(
                                 'expecting one of: '
-                                "'comments' 'eol_comments'"  # noqa: COM812
+                                "'comments' 'eol_comments'"
                             )
                     self.name_last_node('name')
                     self._cut()
@@ -134,11 +139,7 @@ def _directive_(self):
                     self._cut()
                     self._regex_()
                     self.name_last_node('value')
-
-                    self._define(
-                        ['name', 'value'],
-                        [],
-                    )
+                    self._define(['name', 'value'], [])
                 with self._option():
                     with self._group():
                         self._token('whitespace')
@@ -159,14 +160,10 @@ def _directive_(self):
                                 self._constant('None')
                             self._error(
                                 'expecting one of: '
-                                "'False' 'None' <regex>"  # noqa: COM812
+                                "'False' 'None' <regex>"
                             )
                     self.name_last_node('value')
-
-                    self._define(
-                        ['name', 'value'],
-                        [],
-                    )
+                    self._define(['name', 'value'], [])
                 with self._option():
                     with self._group():
                         with self._choice():
@@ -181,7 +178,7 @@ def _directive_(self):
                             self._error(
                                 'expecting one of: '
                                 "'ignorecase' 'left_recursion'"
-                                "'nameguard' 'parseinfo'"  # noqa: COM812
+                                "'nameguard' 'parseinfo'"
                             )
                     self.name_last_node('name')
                     self._cut()
@@ -192,23 +189,15 @@ def _directive_(self):
                                 self._cut()
                                 self._boolean_()
                                 self.name_last_node('value')
-
-                                self._define(
-                                    ['value'],
-                                    [],
-                                )
+                                self._define(['value'], [])
                             with self._option():
                                 self._constant(True)
                                 self.name_last_node('value')
                             self._error(
                                 'expecting one of: '
-                                "'::'"  # noqa: COM812
+                                "'::'"
                             )
-
-                    self._define(
-                        ['name', 'value'],
-                        [],
-                    )
+                    self._define(['name', 'value'], [])
                 with self._option():
                     with self._group():
                         self._token('grammar')
@@ -218,11 +207,7 @@ def _directive_(self):
                     self._cut()
                     self._word_()
                     self.name_last_node('value')
-
-                    self._define(
-                        ['name', 'value'],
-                        [],
-                    )
+                    self._define(['name', 'value'], [])
                 with self._option():
                     with self._group():
                         self._token('namechars')
@@ -232,24 +217,18 @@ def _directive_(self):
                     self._cut()
                     self._string_()
                     self.name_last_node('value')
-
-                    self._define(
-                        ['name', 'value'],
-                        [],
-                    )
+                    self._define(['name', 'value'], [])
                 self._error(
                     'expecting one of: '
                     "'comments' 'eol_comments' 'grammar'"
                     "'ignorecase' 'left_recursion'"
                     "'namechars' 'nameguard' 'parseinfo'"
-                    "'whitespace'"  # noqa: COM812
+                    "'whitespace'"
                 )
         self._cut()
+        self._define(['name', 'value'], [])
 
-        self._define(
-            ['name', 'value'],
-            [],
-        )
+        self._define(['name', 'value'], [])
 
     @tatsumasu()
     def _keywords_(self):
@@ -258,6 +237,7 @@ def block0():
             self._keywords_()
         self._positive_closure(block0)
 
+
     @tatsumasu()
     def _keyword_(self):
         self._token('@@keyword')
@@ -277,10 +257,11 @@ def block0():
                             self._token('=')
                         self._error(
                             'expecting one of: '
-                            "':' '='"  # noqa: COM812
+                            "':' '='"
                         )
         self._closure(block0)
 
+
     @tatsumasu()
     def _paramdef_(self):
         with self._choice():
@@ -289,11 +270,7 @@ def _paramdef_(self):
                 self._cut()
                 self._params_()
                 self.name_last_node('params')
-
-                self._define(
-                    ['params'],
-                    [],
-                )
+                self._define(['params'], [])
             with self._option():
                 self._token('(')
                 self._cut()
@@ -309,35 +286,28 @@ def _paramdef_(self):
                             self._cut()
                             self._kwparams_()
                             self.name_last_node('kwparams')
-
-                            self._define(
-                                ['kwparams', 'params'],
-                                [],
-                            )
+                            self._define(['kwparams', 'params'], [])
                         with self._option():
                             self._params_()
                             self.name_last_node('params')
                         self._error(
                             'expecting one of: '
-                            '<kwparams> <params>'  # noqa: COM812
+                            '<kwparams> <params>'
                         )
                 self._token(')')
-
-                self._define(
-                    ['kwparams', 'params'],
-                    [],
-                )
+                self._define(['kwparams', 'params'], [])
             self._error(
                 'expecting one of: '
-                "'(' '::'"  # noqa: COM812
+                "'(' '::'"
             )
 
+
     @tatsumasu('Rule')
     def _rule_(self):
 
-        def block1():
+        def block0():
             self._decorator_()
-        self._closure(block1)
+        self._closure(block0)
         self.name_last_node('decorators')
         self._name_()
         self.name_last_node('name')
@@ -349,11 +319,7 @@ def block1():
                     self._cut()
                     self._params_()
                     self.name_last_node('params')
-
-                    self._define(
-                        ['params'],
-                        [],
-                    )
+                    self._define(['params'], [])
                 with self._option():
                     self._token('(')
                     self._cut()
@@ -369,49 +335,35 @@ def block1():
                                 self._cut()
                                 self._kwparams_()
                                 self.name_last_node('kwparams')
-
-                                self._define(
-                                    ['kwparams', 'params'],
-                                    [],
-                                )
+                                self._define(['kwparams', 'params'], [])
                             with self._option():
                                 self._params_()
                                 self.name_last_node('params')
                             self._error(
                                 'expecting one of: '
-                                '<kwparams> <params>'  # noqa: COM812
+                                '<kwparams> <params>'
                             )
                     self._token(')')
-
-                    self._define(
-                        ['kwparams', 'params'],
-                        [],
-                    )
+                    self._define(['kwparams', 'params'], [])
                 self._error(
                     'expecting one of: '
-                    "'(' '::'"  # noqa: COM812
+                    "'(' '::'"
                 )
         with self._optional():
             self._token('<')
             self._cut()
             self._known_name_()
             self.name_last_node('base')
-
-            self._define(
-                ['base'],
-                [],
-            )
+            self._define(['base'], [])
         self._token('=')
         self._cut()
         self._expre_()
         self.name_last_node('exp')
         self._token(';')
         self._cut()
+        self._define(['base', 'decorators', 'exp', 'kwparams', 'name', 'params'], [])
 
-        self._define(
-            ['base', 'decorators', 'exp', 'kwparams', 'name', 'params'],
-            [],
-        )
+        self._define(['base', 'decorators', 'exp', 'kwparams', 'name', 'params'], [])
 
     @tatsumasu()
     def _decorator_(self):
@@ -429,23 +381,25 @@ def _decorator_(self):
                     self._token('nomemo')
                 self._error(
                     'expecting one of: '
-                    "'name' 'nomemo' 'override'"  # noqa: COM812
+                    "'name' 'nomemo' 'override'"
                 )
         self.name_last_node('@')
 
+
     @tatsumasu()
     def _params_(self):
         self._first_param_()
         self.add_last_node_to_name('@')
 
-        def block1():
+        def block0():
             self._token(',')
             self._literal_()
             self.add_last_node_to_name('@')
             with self._ifnot():
                 self._token('=')
             self._cut()
-        self._closure(block1)
+        self._closure(block0)
+
 
     @tatsumasu()
     def _first_param_(self):
@@ -458,18 +412,20 @@ def _first_param_(self):
                 'expecting one of: '
                 '(?!\\d)\\w+(?:::(?!\\d)\\w+)+ <boolean>'
                 '<float> <hex> <int> <literal> <null>'
-                '<path> <raw_string> <string> <word>'  # noqa: COM812
+                '<path> <raw_string> <string> <word>'
             )
 
+
     @tatsumasu()
     def _kwparams_(self):
 
         def sep0():
             self._token(',')
 
-        def block0():
+        def block1():
             self._pair_()
-        self._positive_gather(block0, sep0)
+        self._positive_gather(block1, sep0)
+
 
     @tatsumasu()
     def _pair_(self):
@@ -480,6 +436,7 @@ def _pair_(self):
         self._literal_()
         self.add_last_node_to_name('@')
 
+
     @tatsumasu()
     def _expre_(self):
         with self._choice():
@@ -490,9 +447,10 @@ def _expre_(self):
             self._error(
                 'expecting one of: '
                 "'|' <choice> <element> <option>"
-                '<sequence>'  # noqa: COM812
+                '<sequence>'
             )
 
+
     @tatsumasu('Choice')
     def _choice_(self):
         with self._optional():
@@ -501,26 +459,30 @@ def _choice_(self):
         self._option_()
         self.add_last_node_to_name('@')
 
-        def block1():
+        def block0():
             self._token('|')
             self._cut()
             self._option_()
             self.add_last_node_to_name('@')
-        self._positive_closure(block1)
+        self._positive_closure(block0)
+
 
     @tatsumasu('Option')
     def _option_(self):
         self._sequence_()
         self.name_last_node('@')
 
+
     @tatsumasu('Sequence')
     def _sequence_(self):
 
-        def block1():
+        def block0():
             self._element_()
-        self._positive_closure(block1)
+        self._positive_closure(block0)
         self.name_last_node('sequence')
 
+        self._define(['sequence'], [])
+
     @tatsumasu()
     def _element_(self):
         with self._choice():
@@ -543,9 +505,10 @@ def _element_(self):
                 '<override_single_deprecated>'
                 '<positive_closure> <right_join>'
                 '<rule_include> <skip_to> <special>'
-                '<term> <void>'  # noqa: COM812
+                '<term> <void>'
             )
 
+
     @tatsumasu('RuleInclude')
     def _rule_include_(self):
         self._token('>')
@@ -553,6 +516,7 @@ def _rule_include_(self):
         self._known_name_()
         self.name_last_node('@')
 
+
     @tatsumasu()
     def _named_(self):
         with self._choice():
@@ -562,9 +526,10 @@ def _named_(self):
                 self._named_single_()
             self._error(
                 'expecting one of: '
-                '<name> <named_list> <named_single>'  # noqa: COM812
+                '<name> <named_list> <named_single>'
             )
 
+
     @tatsumasu('NamedList')
     def _named_list_(self):
         self._name_()
@@ -573,11 +538,9 @@ def _named_list_(self):
         self._cut()
         self._term_()
         self.name_last_node('exp')
+        self._define(['exp', 'name'], [])
 
-        self._define(
-            ['exp', 'name'],
-            [],
-        )
+        self._define(['exp', 'name'], [])
 
     @tatsumasu('Named')
     def _named_single_(self):
@@ -587,11 +550,9 @@ def _named_single_(self):
         self._cut()
         self._term_()
         self.name_last_node('exp')
+        self._define(['exp', 'name'], [])
 
-        self._define(
-            ['exp', 'name'],
-            [],
-        )
+        self._define(['exp', 'name'], [])
 
     @tatsumasu()
     def _override_(self):
@@ -606,9 +567,10 @@ def _override_(self):
                 'expecting one of: '
                 "'@' '@+:' '@:' <override_list>"
                 '<override_single>'
-                '<override_single_deprecated>'  # noqa: COM812
+                '<override_single_deprecated>'
             )
 
+
     @tatsumasu('OverrideList')
     def _override_list_(self):
         self._token('@+:')
@@ -616,6 +578,7 @@ def _override_list_(self):
         self._term_()
         self.name_last_node('@')
 
+
     @tatsumasu('Override')
     def _override_single_(self):
         self._token('@:')
@@ -623,6 +586,7 @@ def _override_single_(self):
         self._term_()
         self.name_last_node('@')
 
+
     @tatsumasu('Override')
     def _override_single_deprecated_(self):
         self._token('@')
@@ -630,6 +594,7 @@ def _override_single_deprecated_(self):
         self._term_()
         self.name_last_node('@')
 
+
     @tatsumasu()
     def _term_(self):
         with self._choice():
@@ -673,9 +638,10 @@ def _term_(self):
                 '<negative_lookahead> <optional>'
                 '<pattern> <positive_closure>'
                 '<right_join> <separator> <skip_to>'
-                '<special> <token> <void>'  # noqa: COM812
+                '<special> <token> <void>'
             )
 
+
     @tatsumasu('Group')
     def _group_(self):
         self._token('(')
@@ -684,11 +650,9 @@ def _group_(self):
         self.name_last_node('exp')
         self._token(')')
         self._cut()
+        self._define(['exp'], [])
 
-        self._define(
-            ['exp'],
-            [],
-        )
+        self._define(['exp'], [])
 
     @tatsumasu()
     def _gather_(self):
@@ -705,9 +669,10 @@ def _gather_(self):
                     self._normal_gather_()
                 self._error(
                     'expecting one of: '
-                    '<normal_gather> <positive_gather>'  # noqa: COM812
+                    '<normal_gather> <positive_gather>'
                 )
 
+
     @tatsumasu('PositiveGather')
     def _positive_gather_(self):
         self._separator_()
@@ -724,14 +689,12 @@ def _positive_gather_(self):
                     self._token('-')
                 self._error(
                     'expecting one of: '
-                    "'+' '-'"  # noqa: COM812
+                    "'+' '-'"
                 )
         self._cut()
+        self._define(['exp', 'sep'], [])
 
-        self._define(
-            ['exp', 'sep'],
-            [],
-        )
+        self._define(['exp', 'sep'], [])
 
     @tatsumasu('Gather')
     def _normal_gather_(self):
@@ -746,11 +709,9 @@ def _normal_gather_(self):
             self._token('*')
             self._cut()
         self._cut()
+        self._define(['exp', 'sep'], [])
 
-        self._define(
-            ['exp', 'sep'],
-            [],
-        )
+        self._define(['exp', 'sep'], [])
 
     @tatsumasu()
     def _join_(self):
@@ -767,9 +728,10 @@ def _join_(self):
                     self._normal_join_()
                 self._error(
                     'expecting one of: '
-                    '<normal_join> <positive_join>'  # noqa: COM812
+                    '<normal_join> <positive_join>'
                 )
 
+
     @tatsumasu('PositiveJoin')
     def _positive_join_(self):
         self._separator_()
@@ -786,14 +748,12 @@ def _positive_join_(self):
                     self._token('-')
                 self._error(
                     'expecting one of: '
-                    "'+' '-'"  # noqa: COM812
+                    "'+' '-'"
                 )
         self._cut()
+        self._define(['exp', 'sep'], [])
 
-        self._define(
-            ['exp', 'sep'],
-            [],
-        )
+        self._define(['exp', 'sep'], [])
 
     @tatsumasu('Join')
     def _normal_join_(self):
@@ -808,11 +768,9 @@ def _normal_join_(self):
             self._token('*')
             self._cut()
         self._cut()
+        self._define(['exp', 'sep'], [])
 
-        self._define(
-            ['exp', 'sep'],
-            [],
-        )
+        self._define(['exp', 'sep'], [])
 
     @tatsumasu('LeftJoin')
     def _left_join_(self):
@@ -831,14 +789,12 @@ def _left_join_(self):
                     self._token('-')
                 self._error(
                     'expecting one of: '
-                    "'+' '-'"  # noqa: COM812
+                    "'+' '-'"
                 )
         self._cut()
+        self._define(['exp', 'sep'], [])
 
-        self._define(
-            ['exp', 'sep'],
-            [],
-        )
+        self._define(['exp', 'sep'], [])
 
     @tatsumasu('RightJoin')
     def _right_join_(self):
@@ -857,14 +813,12 @@ def _right_join_(self):
                     self._token('-')
                 self._error(
                     'expecting one of: '
-                    "'+' '-'"  # noqa: COM812
+                    "'+' '-'"
                 )
         self._cut()
+        self._define(['exp', 'sep'], [])
 
-        self._define(
-            ['exp', 'sep'],
-            [],
-        )
+        self._define(['exp', 'sep'], [])
 
     @tatsumasu()
     def _separator_(self):
@@ -883,9 +837,10 @@ def _separator_(self):
                 'expecting one of: '
                 "'(' '/./' '`' <any> <constant> <group>"
                 '<pattern> <raw_string> <regexes>'
-                '<string> <token>'  # noqa: COM812
+                '<string> <token>'
             )
 
+
     @tatsumasu('PositiveClosure')
     def _positive_closure_(self):
         self._token('{')
@@ -900,10 +855,11 @@ def _positive_closure_(self):
                     self._token('+')
                 self._error(
                     'expecting one of: '
-                    "'+' '-'"  # noqa: COM812
+                    "'+' '-'"
                 )
         self._cut()
 
+
     @tatsumasu('Closure')
     def _closure_(self):
         self._token('{')
@@ -914,6 +870,7 @@ def _closure_(self):
             self._token('*')
         self._cut()
 
+
     @tatsumasu('EmptyClosure')
     def _empty_closure_(self):
         self._token('{')
@@ -921,6 +878,7 @@ def _empty_closure_(self):
         self.name_last_node('@')
         self._token('}')
 
+
     @tatsumasu('Optional')
     def _optional_(self):
         self._token('[')
@@ -930,6 +888,7 @@ def _optional_(self):
         self._token(']')
         self._cut()
 
+
     @tatsumasu('Special')
     def _special_(self):
         self._token('?(')
@@ -939,6 +898,7 @@ def _special_(self):
         self._token(')?')
         self._cut()
 
+
     @tatsumasu('Lookahead')
     def _lookahead_(self):
         self._token('&')
@@ -946,6 +906,7 @@ def _lookahead_(self):
         self._term_()
         self.name_last_node('@')
 
+
     @tatsumasu('NegativeLookahead')
     def _negative_lookahead_(self):
         self._token('!')
@@ -953,6 +914,7 @@ def _negative_lookahead_(self):
         self._term_()
         self.name_last_node('@')
 
+
     @tatsumasu('SkipTo')
     def _skip_to_(self):
         self._token('->')
@@ -960,6 +922,7 @@ def _skip_to_(self):
         self._term_()
         self.name_last_node('@')
 
+
     @tatsumasu()
     def _atom_(self):
         with self._choice():
@@ -984,37 +947,44 @@ def _atom_(self):
                 "'$' '>>' '`' '~' <alert> <call>"
                 '<constant> <cut> <cut_deprecated> <eof>'
                 '<pattern> <raw_string> <regexes>'
-                '<string> <token> <word> \\^+'  # noqa: COM812
+                '<string> <token> <word> \\^+'
             )
 
+
     @tatsumasu('RuleRef')
     def _call_(self):
         self._word_()
 
+
     @tatsumasu('Void')
     def _void_(self):
         self._token('()')
         self._cut()
 
+
     @tatsumasu('Cut')
     def _cut_(self):
         self._token('~')
         self._cut()
 
+
     @tatsumasu('Cut')
     def _cut_deprecated_(self):
         self._token('>>')
         self._cut()
 
+
     @tatsumasu()
     def _known_name_(self):
         self._name_()
         self._cut()
 
+
     @tatsumasu()
     def _name_(self):
         self._word_()
 
+
     @tatsumasu('Constant')
     def _constant_(self):
         with self._if():
@@ -1032,20 +1002,19 @@ def _constant_(self):
                     self._pattern('`(.*?)`')
                 self._error(
                     'expecting one of: '
-                    "'`' (?ms)```((?:.|\\n)*?)``` `(.*?)`"  # noqa: COM812
+                    "'`' (?ms)```((?:.|\\n)*?)``` `(.*?)`"
                 )
 
+
     @tatsumasu('Alert')
     def _alert_(self):
         self._pattern('\\^+')
         self.name_last_node('level')
         self._constant_()
         self.name_last_node('message')
+        self._define(['level', 'message'], [])
 
-        self._define(
-            ['level', 'message'],
-            [],
-        )
+        self._define(['level', 'message'], [])
 
     @tatsumasu('Token')
     def _token_(self):
@@ -1056,9 +1025,10 @@ def _token_(self):
                 self._raw_string_()
             self._error(
                 'expecting one of: '
-                '<STRING> <raw_string> <string> r'  # noqa: COM812
+                '<STRING> <raw_string> <string> r'
             )
 
+
     @tatsumasu()
     def _literal_(self):
         with self._choice():
@@ -1085,19 +1055,22 @@ def _literal_(self):
                 '<float> <hex> <int> <null> <raw_string>'
                 '<string> <word> [-'
                 '+]?(?:\\d+\\.\\d*|\\d*\\.\\d+)(?:[Ee][-'
-                '+]?\\d+)? [-+]?\\d+ r'  # noqa: COM812
+                '+]?\\d+)? [-+]?\\d+ r'
             )
 
+
     @tatsumasu()
     def _string_(self):
         self._STRING_()
 
+
     @tatsumasu()
     def _raw_string_(self):
         self._pattern('r')
         self._STRING_()
         self.name_last_node('@')
 
+
     @tatsumasu()
     def _STRING_(self):
         with self._choice():
@@ -1112,46 +1085,55 @@ def _STRING_(self):
             self._error(
                 'expecting one of: '
                 '"((?:[^"\\n]|\\"|\\\\)*?)"'
-                "'((?:[^'\\n]|\\'|\\\\)*?)'"  # noqa: COM812
+                "'((?:[^'\\n]|\\'|\\\\)*?)'"
             )
 
+
     @tatsumasu()
     def _hex_(self):
         self._pattern('0[xX](?:\\d|[a-fA-F])+')
 
+
     @tatsumasu()
     def _float_(self):
         self._pattern('[-+]?(?:\\d+\\.\\d*|\\d*\\.\\d+)(?:[Ee][-+]?\\d+)?')
 
+
     @tatsumasu()
     def _int_(self):
         self._pattern('[-+]?\\d+')
 
+
     @tatsumasu()
     def _path_(self):
         self._pattern('(?!\\d)\\w+(?:::(?!\\d)\\w+)+')
 
+
     @tatsumasu()
     def _word_(self):
         self._pattern('(?!\\d)\\w+')
 
+
     @tatsumasu('Any')
     def _any_(self):
         self._token('/./')
 
+
     @tatsumasu('Pattern')
     def _pattern_(self):
         self._regexes_()
 
+
     @tatsumasu()
     def _regexes_(self):
 
         def sep0():
             self._token('+')
 
-        def block0():
+        def block1():
             self._regex_()
-        self._positive_gather(block0, sep0)
+        self._positive_gather(block1, sep0)
+
 
     @tatsumasu()
     def _regex_(self):
@@ -1176,9 +1158,10 @@ def _regex_(self):
                 self.name_last_node('@')
             self._error(
                 'expecting one of: '
-                "'/' '?' '?/'"  # noqa: COM812
+                "'/' '?' '?/'"
             )
 
+
     @tatsumasu()
     def _boolean_(self):
         with self._choice():
@@ -1188,231 +1171,21 @@ def _boolean_(self):
                 self._token('False')
             self._error(
                 'expecting one of: '
-                "'False' 'True'"  # noqa: COM812
+                "'False' 'True'"
             )
 
+
     @tatsumasu()
     def _null_(self):
         self._token('None')
 
+
     @tatsumasu('EOF')
     def _eof_(self):
         self._token('$')
         self._cut()
 
 
-class EBNFBootstrapSemantics:
-    def start(self, ast):
-        return ast
-
-    def grammar(self, ast):
-        return ast
-
-    def directive(self, ast):
-        return ast
-
-    def keywords(self, ast):
-        return ast
-
-    def keyword(self, ast):
-        return ast
-
-    def paramdef(self, ast):
-        return ast
-
-    def rule(self, ast):
-        return ast
-
-    def decorator(self, ast):
-        return ast
-
-    def params(self, ast):
-        return ast
-
-    def first_param(self, ast):
-        return ast
-
-    def kwparams(self, ast):
-        return ast
-
-    def pair(self, ast):
-        return ast
-
-    def expre(self, ast):
-        return ast
-
-    def choice(self, ast):
-        return ast
-
-    def option(self, ast):
-        return ast
-
-    def sequence(self, ast):
-        return ast
-
-    def element(self, ast):
-        return ast
-
-    def rule_include(self, ast):
-        return ast
-
-    def named(self, ast):
-        return ast
-
-    def named_list(self, ast):
-        return ast
-
-    def named_single(self, ast):
-        return ast
-
-    def override(self, ast):
-        return ast
-
-    def override_list(self, ast):
-        return ast
-
-    def override_single(self, ast):
-        return ast
-
-    def override_single_deprecated(self, ast):
-        return ast
-
-    def term(self, ast):
-        return ast
-
-    def group(self, ast):
-        return ast
-
-    def gather(self, ast):
-        return ast
-
-    def positive_gather(self, ast):
-        return ast
-
-    def normal_gather(self, ast):
-        return ast
-
-    def join(self, ast):
-        return ast
-
-    def positive_join(self, ast):
-        return ast
-
-    def normal_join(self, ast):
-        return ast
-
-    def left_join(self, ast):
-        return ast
-
-    def right_join(self, ast):
-        return ast
-
-    def separator(self, ast):
-        return ast
-
-    def positive_closure(self, ast):
-        return ast
-
-    def closure(self, ast):
-        return ast
-
-    def empty_closure(self, ast):
-        return ast
-
-    def optional(self, ast):
-        return ast
-
-    def special(self, ast):
-        return ast
-
-    def lookahead(self, ast):
-        return ast
-
-    def negative_lookahead(self, ast):
-        return ast
-
-    def skip_to(self, ast):
-        return ast
-
-    def atom(self, ast):
-        return ast
-
-    def call(self, ast):
-        return ast
-
-    def void(self, ast):
-        return ast
-
-    def cut(self, ast):
-        return ast
-
-    def cut_deprecated(self, ast):
-        return ast
-
-    def known_name(self, ast):
-        return ast
-
-    def name(self, ast):
-        return ast
-
-    def constant(self, ast):
-        return ast
-
-    def alert(self, ast):
-        return ast
-
-    def token(self, ast):
-        return ast
-
-    def literal(self, ast):
-        return ast
-
-    def string(self, ast):
-        return ast
-
-    def raw_string(self, ast):
-        return ast
-
-    def STRING(self, ast):
-        return ast
-
-    def hex(self, ast):
-        return ast
-
-    def float(self, ast):
-        return ast
-
-    def int(self, ast):
-        return ast
-
-    def path(self, ast):
-        return ast
-
-    def word(self, ast):
-        return ast
-
-    def any(self, ast):
-        return ast
-
-    def pattern(self, ast):
-        return ast
-
-    def regexes(self, ast):
-        return ast
-
-    def regex(self, ast):
-        return ast
-
-    def boolean(self, ast):
-        return ast
-
-    def null(self, ast):
-        return ast
-
-    def eof(self, ast):
-        return ast
-
-
 def main(filename, **kwargs):
     if not filename or filename == '-':
         text = sys.stdin.read()
diff --git a/tatsu/codegen/python.py b/tatsu/codegen/python.py
index ec831c1b..0b3f766f 100755
--- a/tatsu/codegen/python.py
+++ b/tatsu/codegen/python.py
@@ -498,9 +498,9 @@ def {name}(self, ast):
             """
 
     template = """\
-                #!/usr/bin/env python
+                #!/usr/bin/env python3
 
-                # CAVEAT UTILITOR
+                # WARNING: CAVEAT UTILITOR
                 #
                 # This file was automatically generated by TatSu.
                 #
diff --git a/tatsu/mixins/indent.py b/tatsu/mixins/indent.py
index 78aee689..e1026a7f 100644
--- a/tatsu/mixins/indent.py
+++ b/tatsu/mixins/indent.py
@@ -5,17 +5,18 @@
 
 
 class IndentPrintMixin:
-    def __init__(self, indent=4):
-        self.indent_amount = indent
-        self.indent_level = 0
+    def __init__(self, default_indent: int = 4):
+        self.default_indent = default_indent
+        self.indent_stack: list[int] = [0]
         self.output_stream = io.StringIO()
 
     def printed_text(self):
         return self.output_stream.getvalue()
 
     def print(self, *args, **kwargs):
+        args = [trim(str(arg)) for arg in args if arg is not None]
         lines = self.as_printed_lines(*args, **kwargs)
-        self._do_print_lines(lines)
+        self._do_print_lines(lines, **kwargs)
 
     def as_printed(self, *args, **kwargs):
         lines = self.as_printed_lines(*args, **kwargs)
@@ -26,16 +27,20 @@ def as_printed_lines(self, *args, **kwargs):
         return self.indented_lines(text)
 
     @contextmanager
-    def indent(self):
-        self.indent_level += 1
+    def indent(self, amount: int | None = None):
+        assert amount is None or amount >= 0
+        if amount is None:
+            amount = self.default_indent
+
+        self.indent_stack.append(amount + self.indent_stack[-1])
         try:
             yield
         finally:
-            self.indent_level -= 1
+            self.indent_stack.pop()
 
     @property
     def current_indentation(self):
-        return ' ' * self.indent_amount * self.indent_level
+        return ' ' * self.indent_stack[-1]
 
     @staticmethod
     def io_print(*args, **kwargs):
@@ -44,13 +49,13 @@ def io_print(*args, **kwargs):
             print(*args, file=output, **kwargs)
             return output.getvalue()
 
-    def _do_print_lines(self, lines: list[str] | None = None):
+    def _do_print_lines(self, lines: list[str] | None = None, **kwargs):
         if not lines:
-            print(file=self.output_stream)
+            print(file=self.output_stream, **kwargs)
             return
 
         for line in lines:
-            print(line, file=self.output_stream)
+            print(line, file=self.output_stream, **kwargs)
 
     def indented_lines(self, text):
         text = trim(text)
diff --git a/tatsu/ngcodegen/__init__.py b/tatsu/ngcodegen/__init__.py
new file mode 100644
index 00000000..01d5264d
--- /dev/null
+++ b/tatsu/ngcodegen/__init__.py
@@ -0,0 +1,8 @@
+from ..objectmodel import ParseModel
+from .python import PythonCodeGenerator
+
+
+def codegen(model: ParseModel, parser_name: str = '') -> str:
+    generator = PythonCodeGenerator(parser_name=parser_name)
+    generator.walk(model)
+    return generator.printed_text()
diff --git a/tatsu/ngcodegen/objectmodel.py b/tatsu/ngcodegen/objectmodel.py
new file mode 100644
index 00000000..f8e9b784
--- /dev/null
+++ b/tatsu/ngcodegen/objectmodel.py
@@ -0,0 +1,147 @@
+import builtins
+from collections import namedtuple
+
+from .. import grammars, objectmodel
+from ..mixins.indent import IndentPrintMixin
+from ..util import compress_seq, safe_name
+from ..util.misc import topsort
+
+HEADER = """\
+    #!/usr/bin/env python3
+
+    # WARNING: CAVEAT UTILITOR
+    #
+    # This file was automatically generated by TatSu.
+    #
+    #    https://pypi.python.org/pypi/tatsu/
+    #
+    # Any changes you make to it will be overwritten the next time
+    # the file is generated.
+
+    from __future__ import annotations
+
+    from typing import Any
+    from dataclasses import dataclass
+
+    from tatsu.semantics import ModelBuilderSemantics
+    {base_type_import}
+
+
+    class {name}ModelBuilderSemantics(ModelBuilderSemantics):
+        def __init__(self, context=None, types=None):
+            types = [
+                t for t in globals().values()
+                if type(t) is type and issubclass(t, ModelBase)
+            ] + (types or [])
+            super().__init__(context=context, types=types)
+"""
+
+
+BaseClassSpec = namedtuple('BaseClassSpec', ['class_name', 'base'])
+
+
+def modelgen(model: grammars.Grammar, name: str = '', base_type: type | None = objectmodel.Node) -> str:
+    base_type = base_type or objectmodel.Node
+    generator = PythonModelGenerator(name=name, base_type=base_type)
+    return generator.generate_model(model)
+
+
+class PythonModelGenerator(IndentPrintMixin):
+
+    def __init__(self, name: str = '', base_type: type = objectmodel.Node):
+        super().__init__()
+        self.base_type = base_type
+        self.name = name or None
+
+    def generate_model(self, grammar: grammars.Grammar):
+        base_type = self.base_type
+        base_type_name = base_type.__name__.split('.')[-1]
+        base_type_import = f"from {base_type.__module__} import {base_type_name}"
+
+        self.name = self.name or grammar.name
+        self.print(
+            HEADER.format(
+                name=self.name,
+                base_type=self.base_type.__name__,
+                base_type_import=base_type_import,
+            ),
+        )
+
+        rule_index = {rule.name: rule for rule in grammar.rules}
+        rule_specs = {
+            rule.name: self._base_class_specs(rule)
+            for rule in grammar.rules
+        }
+        rule_specs = {name: specs for name, specs in rule_specs.items() if specs}
+
+        specs_by_name = {
+            s.class_name: s.base
+            for specs in rule_specs.values()
+            for s in specs
+        }
+        base = self._model_base_name()
+        specs_by_name[base] = base_type_name
+
+        all_specs = {
+            (s.class_name, s.base)
+            for specs in rule_specs.values()
+            for s in specs
+        }
+        model_names = topsort(reversed(specs_by_name), all_specs)
+
+        model_to_rule = {
+            rule_specs[name][0].class_name: rule
+            for name, rule in rule_index.items()
+            if name in rule_specs
+        }
+
+        for model_name in model_names:
+            if model_name in vars(builtins):
+                continue
+            if rule := model_to_rule.get(model_name):
+                self._gen_rule_class(rule, rule_specs[rule.name])
+            else:
+                self._gen_base_class(model_name, specs_by_name.get(model_name))
+
+        return self.printed_text()
+
+    @staticmethod
+    def _model_base_name():
+        return 'ModelBase'
+
+    def _gen_base_class(self, class_name: str, base: str | None):
+        self.print()
+        self.print()
+        self.print('@dataclass(eq=False)')
+        if base:
+            self.print(f'class {class_name}({base}):')
+        else:
+            # FIXME: this cannot happen as base_type is the final base
+            self.print(f'class {class_name}:')
+        with self.indent():
+            self.print('pass')
+
+    def _gen_rule_class(self, rule: grammars.Rule, specs: list[BaseClassSpec]):
+        if not specs:
+            return
+        spec = specs[0]
+        arguments = sorted({safe_name(d) for d, _ in compress_seq(rule.defines())})
+
+        self.print()
+        self.print()
+        self.print('@dataclass(eq=False)')
+        self.print(f'class {spec.class_name}({spec.base}):')
+        with self.indent():
+            if not arguments:
+                self.print('pass')
+            for arg in arguments:
+                self.print(f'{arg}: Any = None')
+
+    def _base_class_specs(self, rule: grammars.Rule) -> list[BaseClassSpec]:
+        spec = rule.params[0].split('::') if rule.params else []
+        base = [self._model_base_name()]
+        class_names = [safe_name(n) for n in spec] + base
+        return [
+            BaseClassSpec(class_name, class_names[i + 1])
+            for i, class_name in enumerate(class_names[:-1])
+        ]
diff --git a/tatsu/ngcodegen/python.py b/tatsu/ngcodegen/python.py
new file mode 100644
index 00000000..791a7b86
--- /dev/null
+++ b/tatsu/ngcodegen/python.py
@@ -0,0 +1,391 @@
+from __future__ import annotations
+
+import itertools
+import textwrap
+from collections.abc import Iterator
+from typing import Any
+
+from .. import grammars
+from ..collections import OrderedSet as oset
+from ..exceptions import CodegenError
+from ..mixins.indent import IndentPrintMixin
+from ..util import compress_seq, safe_name
+from ..walkers import NodeWalker
+
+HEADER = """\
+    #!/usr/bin/env python3
+
+    # WARNING: CAVEAT UTILITOR
+    #
+    #  This file was automatically generated by TatSu.
+    #
+    #     https://pypi.python.org/pypi/tatsu/
+    #
+    #  Any changes you make to it will be overwritten the next time
+    #  the file is generated.
+
+    # ruff: noqa: C405, COM812, I001, F401, SIM117
+
+    import sys
+    from pathlib import Path
+
+    from tatsu.buffering import Buffer
+    from tatsu.parsing import Parser
+    from tatsu.parsing import tatsumasu
+    from tatsu.parsing import leftrec, nomemo, isname
+    from tatsu.infos import ParserConfig
+    from tatsu.util import re, generic_main
+"""
+
+FOOTER = """\
+def main(filename, **kwargs):
+    if not filename or filename == '-':
+        text = sys.stdin.read()
+    else:
+        text = Path(filename).read_text()
+    parser = {name}Parser()
+    return parser.parse(
+        text,
+        filename=filename,
+        **kwargs,
+    )
+
+
+if __name__ == '__main__':
+    import json
+    from tatsu.util import asjson
+
+    ast = generic_main(main, {name}Parser, name='{name}')
+    data = asjson(ast)
+    print(json.dumps(data, indent=2))
+"""
+
+
+class PythonCodeGenerator(IndentPrintMixin, NodeWalker):
+    _counter: Iterator[int] = itertools.count()
+
+    def __init__(self, parser_name: str = ''):
+        super().__init__()
+        self.parser_name = parser_name
+
+    @classmethod
+    def _next_n(cls):
+        return next(cls._counter)
+
+    @classmethod
+    def _reset_counter(cls):
+        cls._counter = itertools.count()
+
+    def walk_default(self, node: Any):
+        return node
+
+    def walk_Grammar(self, grammar: grammars.Grammar):
+        parser_name = self.parser_name or grammar.name
+        self.print(HEADER)
+        self.print()
+        self.print()
+
+        self._gen_keywords(grammar)
+        self._gen_buffering(grammar, parser_name)
+        self._gen_parsing(grammar, parser_name)
+
+        self.print()
+        self.print(FOOTER.format(name=parser_name))
+
+    def walk_Rule(self, rule: grammars.Rule):
+        def param_repr(p):
+            if isinstance(p, int | float):
+                return str(p)
+            else:
+                return repr(p.split('::')[0])
+
+        self._reset_counter()
+        params = kwparams = ''
+        if rule.params:
+            params = ', '.join(
+                param_repr(self.walk(p)) for p in rule.params
+            )
+        if rule.kwparams:
+            kwparams = ', '.join(
+                f'{k}={param_repr(self.walk(v))}'
+                for k, v in rule.kwparams.items()
+            )
+
+        if params and kwparams:
+            params = params + ', ' + kwparams
+        elif kwparams:
+            params = kwparams
+
+        leftrec = '\n@leftrec' if rule.is_leftrec else ''
+        nomemo = (
+            '\n@nomemo'
+            if not rule.is_memoizable and not leftrec
+            else ''
+        )
+        isname = '\n@isname' if rule.is_name else ''
+
+        self.print()
+        self.print(
+            f"""
+                @tatsumasu({params})\
+                {leftrec}\
+                {nomemo}\
+                {isname}\
+                \ndef _{rule.name}_(self):
+            """,
+        )
+        with self.indent():
+            self.print(self.walk(rule.exp))
+            if not isinstance(rule.exp, grammars.Choice):
+                self._gen_defines_declaration(rule)
+
+    def walk_BasedRule(self, rule: grammars.BasedRule):
+        # FIXME: the following override is to not alter the previous codegen
+        rule.exp = rule.rhs
+        self.walk_Rule(rule)
+
+    def walk_RuleRef(self, ref: grammars.RuleRef):
+        self.print(f'self._{ref.name}_()')
+
+    def walk_RuleInclude(self, include: grammars.RuleInclude):
+        self.walk(include.rule.exp)
+
+    def walk_Void(self, void: grammars.Void):
+        self.print('self._void()')
+
+    def walk_Any(self, any: grammars.Any):
+        self.print('self._any()')
+
+    def walk_Fail(self, fail: grammars.Fail):
+        self.print('self._fail()')
+
+    def walk_Cut(self, cut: grammars.Cut):
+        self.print('self._cut()')
+
+    def walk_Comment(self, comment: grammars.Comment):
+        lines = '\n'.join(f'# {c!s}' for c in comment.comment.splitlines())
+        self.print(f'\n{lines}\n')
+
+    def walk_EOLComment(self, comment: grammars.EOLComment):
+        self.walk_Comment(comment)
+
+    def walk_EOF(self, eof: grammars.EOF):
+        self.print('self._check_eof()')
+
+    def walk_Group(self, group: grammars.Group):
+        self.print('with self._group():')
+        with self.indent():
+            self.walk(group.exp)
+
+    def walk_Token(self, token: grammars.Token):
+        self.print(f'self._token({token.token!r})')
+
+    def walk_Constant(self, constant: grammars.Constant):
+        self.print(f'self._constant({constant.literal!r})')
+
+    def walk_Alert(self, alert: grammars.Alert):
+        self.print(f'self._alert({alert.literal!r}, {alert.level})')
+
+    def walk_Pattern(self, pattern: grammars.Pattern):
+        self.print(f'self._pattern({pattern.pattern!r})')
+
+    def walk_Lookahead(self, lookahead: grammars.Lookahead):
+        self.print('with self._if():')
+        with self.indent():
+            self.walk(lookahead.exp)
+
+    def walk_NegativeLookahead(self, lookahead: grammars.NegativeLookahead):
+        self.print('with self._ifnot():')
+        with self.indent():
+            self.walk(lookahead.exp)
+
+    def walk_Sequence(self, seq: grammars.Sequence):
+        self.walk(seq.sequence)
+        self._gen_defines_declaration(seq)
+
+    def walk_Choice(self, choice: grammars.Choice):
+        if len(choice.options) == 1:
+            self.walk(choice.options[0])
+            return
+
+        firstset = choice.lookahead_str()
+        if firstset:
+            msglines = textwrap.wrap(firstset, width=40)
+            error = ['expecting one of: ', *msglines]
+        else:
+            error = ['no available options']
+        errors = '\n'.join(repr(e) for e in error)
+
+        self.print('with self._choice():')
+        with self.indent():
+            self.walk(choice.options)
+            self.print('self._error(')
+            with self.indent():
+                self.print(errors)
+            self.print(')')
+
+    def walk_Option(self, option: grammars.Option):
+        self.print('with self._option():')
+        with self.indent():
+            self.walk(option.exp)
+
+    def walk_Optional(self, optional: grammars.Optional):
+        self.print('with self._optional():')
+        with self.indent():
+            self.walk(optional.exp)
+
+    def walk_EmptyClosure(self, closure: grammars.EmptyClosure):
+        self.print('self._empty_closure()')
+
+    def walk_Closure(self, closure: grammars.Closure):
+        n = self._gen_block(closure.exp)
+        self.print(f'self._closure(block{n})')
+
+    def walk_PositiveClosure(self, closure: grammars.PositiveClosure):
+        n = self._gen_block(closure.exp)
+        self.print(f'self._positive_closure(block{n})')
+
+    def walk_Join(self, join: grammars.Join):
+        n = self._gen_block(join.sep, name='sep')
+        n = self._gen_block(join.exp)
+        self.print(f'self._join(block{n}, sep{n})')
+
+    def walk_PositiveJoin(self, join: grammars.PositiveJoin):
+        n = self._gen_block(join.sep, name='sep')
+        n = self._gen_block(join.exp)
+        self.print(f'self._positive_join(block{n}, sep{n})')
+
+    def walk_LeftJoin(self, join: grammars.LeftJoin):
+        n = self._gen_block(join.sep, name='sep')
+        n = self._gen_block(join.exp)
+        self.print(f'self._left_join(block{n}, sep{n})')
+
+    def walk_RightJoin(self, join: grammars.RightJoin):
+        n = self._gen_block(join.sep, name='sep')
+        n = self._gen_block(join.exp)
+        self.print(f'self._right_join(block{n}, sep{n})')
+
+    def walk_Gather(self, gather: grammars.Gather):
+        m = self._gen_block(gather.sep, name='sep')
+        n = self._gen_block(gather.exp)
+        self.print(f'self._gather(block{n}, sep{m})')
+
+    def walk_PositiveGather(self, gather: grammars.PositiveGather):
+        m = self._gen_block(gather.sep, name='sep')
+        n = self._gen_block(gather.exp)
+        self.print(f'self._positive_gather(block{n}, sep{m})')
+
+    def walk_SkipTo(self, skipto: grammars.SkipTo):
+        n = self._gen_block(skipto.exp)
+        self.print(f'self._skip_to(block{n})')
+
+
+    def walk_Named(self, named: grammars.Named):
+        self.walk(named.exp)
+        self.print(f"self.name_last_node('{named.name}')")
+
+    def walk_NamedList(self, named: grammars.Named):
+        self.walk(named.exp)
+        self.print(f"self.add_last_node_to_name('{named.name}')")
+
+    def walk_Override(self, override: grammars.Override):
+        self.walk_Named(override)
+
+    def walk_OverrideList(self, override: grammars.OverrideList):
+        self.walk_NamedList(override)
+
+    def walk_Special(self, special: grammars.Special):
+        pass
+
+    def _gen_keywords(self, grammar: grammars.Grammar):
+        keywords = [str(k) for k in grammar.keywords if k is not None]
+        if not keywords:
+            self.print('KEYWORDS: set[str] = set()')
+        else:
+            keywords_str = '\n'.join(f'    {k!r},' for k in keywords)
+            keywords_str = '{\n%s\n}' % keywords_str
+            self.print(f'KEYWORDS: set[str] = {keywords_str}')
+
+        self.print()
+        self.print()
+
+    def _gen_init(self, grammar: grammars.Grammar):
+        start = grammar.config.start or grammar.rules[0].name
+
+        whitespace = grammar.config.whitespace
+        whitespace = repr(whitespace) if whitespace else None
+
+        self.print(
+            f'''
+                config = ParserConfig.new(
+                    config,
+                    owner=self,
+                    whitespace={whitespace},
+                    nameguard={grammar.config.nameguard},
+                    ignorecase={grammar.config.ignorecase},
+                    namechars={grammar.config.namechars!r},
+                    parseinfo={grammar.config.parseinfo},
+                    comments_re={grammar.config.comments_re!r},
+                    eol_comments_re={grammar.config.eol_comments_re!r},
+                    keywords=KEYWORDS,
+                    start={start!r},
+                )
+                config = config.replace(**settings)
+            ''',
+        )
+        self.print()
+
+    def _gen_buffering(self, grammar: grammars.Grammar, parser_name: str):
+        self.print(f'class {parser_name}Buffer(Buffer):')
+
+        with self.indent():
+            self.print('def __init__(self, text, /, config: ParserConfig | None = None, **settings):')
+            with self.indent():
+                self._gen_init(grammar)
+                self.print('super().__init__(text, config=config)')
+        self.print()
+
+    def _gen_parsing(self, grammar: grammars.Grammar, parser_name: str):
+        self.print(f'class {parser_name}Parser(Parser):')
+        with self.indent():
+            self.print('def __init__(self, /, config: ParserConfig | None = None, **settings):')
+            with self.indent():
+                self._gen_init(grammar)
+                self.print('super().__init__(config=config)')
+            self.walk(grammar.rules)
+
+    def _gen_defines_declaration(self, node: grammars.Model):
+        defines = compress_seq(node.defines())
+        ldefs = oset(safe_name(d) for d, value in defines if value)
+        sdefs = oset(
+            safe_name(d)
+            for d, value in defines
+            if not value and d not in ldefs
+        )
+
+        if not (sdefs or ldefs):
+            return
+
+        sdefs_str = ', '.join(sorted(repr(d) for d in sdefs))
+        ldefs_str = ', '.join(sorted(repr(d) for d in ldefs))
+
+        if not ldefs:
+            self.print(f'self._define([{sdefs_str}], [{ldefs_str}])')
+        else:
+            self.print('self._define(')
+            with self.indent():
+                self.print(f'[{sdefs_str}],')
+                self.print(f'[{ldefs_str}],')
+            self.print(')')
+
+    def _gen_block(self, exp: grammars.Model, name='block'):
+        if () in exp.lookahead():
+            raise CodegenError(f'{exp} may repeat empty sequence')
+
+        n = self._next_n()
+        self.print()
+        self.print(f'def {name}{n}():')
+        with self.indent():
+            self.walk(exp)
+
+        return n
diff --git a/tatsu/parser_semantics.py b/tatsu/parser_semantics.py
index a5ebba90..c61a6e55 100644
--- a/tatsu/parser_semantics.py
+++ b/tatsu/parser_semantics.py
@@ -142,7 +142,7 @@ def grammar(self, ast, *args):
         name = (
             self.grammar_name
             if self.grammar_name
-            else directives.get('grammar', None)
+            else directives.get('grammar')
         )
         return grammars.Grammar(
             name,
diff --git a/tatsu/semantics.py b/tatsu/semantics.py
index 36cb6a62..01a75775 100644
--- a/tatsu/semantics.py
+++ b/tatsu/semantics.py
@@ -60,7 +60,7 @@ def _find_existing_constructor(self, typename):
         return constructor
 
     def _get_constructor(self, typename, base):
-        typename = str(typename)  # cannot be unicode in Python 2.7
+        typename = str(typename)
 
         if typename in self.constructors:
             return self.constructors[typename]
diff --git a/tatsu/tool.py b/tatsu/tool.py
index 96fb7b8d..c830facd 100644
--- a/tatsu/tool.py
+++ b/tatsu/tool.py
@@ -2,6 +2,7 @@
 Parse and translate an EBNF grammar into a Python parser for
 the described language.
 """
+# ruff: noqa: PLR0912
 from __future__ import annotations
 
 import argparse
@@ -11,12 +12,10 @@
 from pathlib import Path
 
 from ._version import __version__
-from .codegen import objectmodel
-
-# we hook the tool to the Python code generator as the default
-from .codegen.python import codegen as pythoncg
 from .exceptions import ParseException
 from .infos import ParserConfig
+from .ngcodegen import codegen as ngpythoncg
+from .ngcodegen import objectmodel as ngobjectmodel
 from .parser import GrammarGenerator
 from .semantics import ModelBuilderSemantics
 from .util import eval_escapes
@@ -224,7 +223,7 @@ def to_python_sourcecode(
     model = compile(
         grammar, name=name, filename=filename, config=config, **settings,
     )
-    return pythoncg(model)
+    return ngpythoncg(model)
 
 
 def to_python_model(
@@ -238,7 +237,7 @@ def to_python_model(
     model = compile(
         grammar, name=name, filename=filename, config=config, **settings,
     )
-    return objectmodel.codegen(model, base_type=base_type)
+    return ngobjectmodel.modelgen(model, base_type=base_type)
 
 
 # for backwards compatibility. Use `compile()` instead
@@ -262,7 +261,7 @@ def gencode(
     grammar=None,
     trace=False,
     filename=None,
-    codegen=pythoncg,
+    codegen=ngpythoncg,
     config: ParserConfig | None = None,
     **settings,
 ):
@@ -292,7 +291,7 @@ def save(filename, content):
         f.write(content)
 
 
-def main(codegen=pythoncg):
+def main():
     args = parse_args()
 
     if args.whitespace:
@@ -326,9 +325,9 @@ def main(codegen=pythoncg):
             elif args.pretty_lean:
                 result = model.pretty_lean()
             elif args.object_model:
-                result = objectmodel.codegen(model, base_type=args.base_type)
+                result = ngobjectmodel.modelgen(model, base_type=args.base_type)
             else:
-                result = codegen(model)
+                result = ngpythoncg(model)
 
             if outfile:
                 save(outfile, result)
@@ -339,7 +338,7 @@ def main(codegen=pythoncg):
         if args.object_model_outfile:
             save(
                 args.object_model_outfile,
-                objectmodel.codegen(model, base_type=args.base_type),
+                ngobjectmodel.modelgen(model, base_type=args.base_type),
             )
 
         print('-' * 72, file=sys.stderr)
diff --git a/tatsu/util/misc.py b/tatsu/util/misc.py
index 0acc89ab..5cb5bd3c 100644
--- a/tatsu/util/misc.py
+++ b/tatsu/util/misc.py
@@ -1,9 +1,13 @@
 from __future__ import annotations
 
 import re
+from collections.abc import Iterable
+from typing import TypeVar
 
 from ._common import RETYPE
 
+_T = TypeVar('_T')
+
 _undefined = object()  # unique object for when None is not a good default
 
 
@@ -71,9 +75,7 @@ def findalliter(pattern, string, pos=None, endpos=None, flags=0):
         yield match_to_find(m)
 
 
-def findfirst(
-    pattern, string, pos=None, endpos=None, flags=0, default=_undefined,
-):
+def findfirst(pattern, string, pos=None, endpos=None, flags=0, default=_undefined):
     """
     Avoids using the inefficient findall(...)[0], or first(findall(...))
     """
@@ -81,3 +83,30 @@ def findfirst(
         findalliter(pattern, string, pos=pos, endpos=endpos, flags=flags),
         default=default,
     )
+
+
+def topsort(nodes: Iterable[_T], order: Iterable[tuple[_T, _T]]) -> list[_T]:
+    # https://en.wikipedia.org/wiki/Topological_sorting
+
+    order = set(order)
+    result: list[_T] = []  # Empty list that will contain the sorted elements
+
+    def with_incoming():
+        return {m for (_, m) in order}
+
+    pending = [  # Set of all nodes with no incoming edges
+        n for n in nodes if n not in with_incoming()
+    ]
+    while pending:
+        n = pending.pop()
+        result.insert(0, n)
+
+        # nodes m with an edge from n to m
+        outgoing = {m for (x, m) in order if x == n}
+        order -= {(n, m) for m in outgoing}
+        pending.extend(outgoing - with_incoming())
+
+    if order:
+        raise ValueError('There are cycles in the topological order')
+
+    return result  # a topologically sorted list
diff --git a/tatsu/walkers.py b/tatsu/walkers.py
index 0406092e..88867d06 100644
--- a/tatsu/walkers.py
+++ b/tatsu/walkers.py
@@ -40,14 +40,14 @@ def walk(self, node: Node | list[Node], *args, **kwargs) -> Any:
         else:
             return node
 
-    def _walk_children(self, node: Node, *args, **kwargs):
+    def walk_children(self, node: Node, *args, **kwargs):
         if not isinstance(node, Node):
-            return ()
+            return []
 
-        for child in node.children():
-            return self.walk(child, *args, **kwargs)
-
-        return None
+        return [
+            self.walk(child, *args, **kwargs)
+            for child in node.children()
+        ]
 
     def _find_walker(self, node: Node, prefix='walk_'):
         def pythonize_match(m):
@@ -57,8 +57,8 @@ def pythonize_match(m):
         node_cls = node.__class__
         node_cls_qualname = node_cls.__qualname__
 
-        if node_cls_qualname in self._walker_cache:
-            return self._walker_cache[node_cls_qualname]
+        if walker := self._walker_cache.get(node_cls_qualname):
+            return walker
 
         node_classes = [node.__class__]
         while node_classes:
@@ -78,13 +78,12 @@ def pythonize_match(m):
                 if callable(walker):
                     break
 
-            # walk_pythonic_name with single underscore after walk
-
-            # pythonic_name = pythonic_name.lstrip('_')
-            # if pythonic_name != cammelcase_name:
-            #     walker = getattr(cls, prefix + pythonic_name, None)
-            #     if callable(walker):
-            #         break
+            # walk_pythonic_name with single underscore after prefix
+            pythonic_name = pythonic_name.lstrip('_')
+            if pythonic_name != cammelcase_name:
+                walker = getattr(cls, prefix + pythonic_name, None)
+                if callable(walker):
+                    break
 
             for b in node_cls.__bases__:
                 if b not in node_classes:
@@ -106,7 +105,7 @@ class PreOrderWalker(NodeWalker):
     def walk(self, node, *args, **kwargs):
         result = super().walk(node, *args, **kwargs)
         if result is not None:
-            self._walk_children(node, *args, **kwargs)
+            self.walk_children(node, *args, **kwargs)
         return result
 
 
diff --git a/test/grammar/directive_test.py b/test/grammar/directive_test.py
index 604d0cea..fe555955 100644
--- a/test/grammar/directive_test.py
+++ b/test/grammar/directive_test.py
@@ -1,8 +1,8 @@
 import pytest
 
 import tatsu
-from tatsu.codegen import codegen
 from tatsu.exceptions import FailedParse
+from tatsu.ngcodegen import codegen
 from tatsu.util import trim
 
 EXEC = 'exec'
diff --git a/test/grammar/join_test.py b/test/grammar/join_test.py
index bd851028..f9430b9c 100644
--- a/test/grammar/join_test.py
+++ b/test/grammar/join_test.py
@@ -1,8 +1,8 @@
 import unittest
 from ast import parse
 
-from tatsu.codegen import codegen
 from tatsu.exceptions import FailedParse
+from tatsu.ngcodegen import codegen
 from tatsu.tool import compile
 from tatsu.util import trim
 
diff --git a/test/grammar/keyword_test.py b/test/grammar/keyword_test.py
index 43452d07..4380354f 100644
--- a/test/grammar/keyword_test.py
+++ b/test/grammar/keyword_test.py
@@ -1,8 +1,8 @@
 import unittest
 from ast import parse
 
-from tatsu.codegen import codegen
 from tatsu.exceptions import FailedParse
+from tatsu.ngcodegen import codegen
 from tatsu.tool import compile
 
 
@@ -72,6 +72,7 @@ def test_check_keywords(self):
         """
         model = compile(grammar, 'test')
         c = codegen(model)
+        print(c)
         parse(c)
 
         ast = model.parse('hello world')
diff --git a/test/grammar/parameter_test.py b/test/grammar/parameter_test.py
index cbef4b1a..50dc2f6b 100644
--- a/test/grammar/parameter_test.py
+++ b/test/grammar/parameter_test.py
@@ -1,7 +1,7 @@
 import contextlib
 import unittest
 
-from tatsu.codegen import codegen
+from tatsu.ngcodegen import codegen
 from tatsu.parser import GrammarGenerator
 from tatsu.tool import compile
 from tatsu.util import trim
@@ -18,7 +18,7 @@ def test_keyword_params(self):
         g = GrammarGenerator('Keywords')
         model = g.parse(grammar)
         code = codegen(model)
-        self.assertEqual('#!/usr/bin/env python', code.splitlines()[0])
+        self.assertEqual('#!/usr/bin/env python3', code.splitlines()[0])
 
     def test_35_only_keyword_params(self):
         grammar = """
diff --git a/test/grammar/pattern_test.py b/test/grammar/pattern_test.py
index 009ba9f5..91094fad 100644
--- a/test/grammar/pattern_test.py
+++ b/test/grammar/pattern_test.py
@@ -1,7 +1,7 @@
 import unittest
 
-from tatsu.codegen import codegen
 from tatsu.exceptions import FailedParse
+from tatsu.ngcodegen import codegen
 from tatsu.tool import compile
 from tatsu.util import trim
 
@@ -112,7 +112,7 @@ def test_multiline_pattern(self):
         model = compile(grammar=trim(grammar))
         print(codegen(model.rules[0].exp.sequence[0]))
         self.assertEqual(
-            codegen(model.rules[0].exp.sequence[0]),
+            codegen(model.rules[0].exp.sequence[0]).strip(),
             repr("self._pattern('(?x)\nfoo\nbar\n')").strip('"\''),
         )
 
diff --git a/test/grammar/semantics_test.py b/test/grammar/semantics_test.py
index d299a1c0..51deebd7 100644
--- a/test/grammar/semantics_test.py
+++ b/test/grammar/semantics_test.py
@@ -81,6 +81,7 @@ def test_builder_basetype_codegen(self):
         from tatsu.tool import to_python_model
 
         src = to_python_model(grammar, base_type=MyNode)
+        print(src)
 
         globals = {}
         exec(src, globals)  # pylint: disable=W0122
diff --git a/test/grammar/syntax_test.py b/test/grammar/syntax_test.py
index 50b04f40..e647d964 100644
--- a/test/grammar/syntax_test.py
+++ b/test/grammar/syntax_test.py
@@ -3,8 +3,8 @@
 import pytest
 
 from tatsu import tool
-from tatsu.codegen import codegen
 from tatsu.exceptions import FailedParse, FailedToken
+from tatsu.ngcodegen import codegen
 from tatsu.parser import EBNFBuffer
 from tatsu.tool import compile
 from tatsu.util import trim
diff --git a/test/zzz_bootstrap/bootstrap_test.py b/test/zzz_bootstrap/bootstrap_test.py
index 1f1ae95b..cf359f01 100644
--- a/test/zzz_bootstrap/bootstrap_test.py
+++ b/test/zzz_bootstrap/bootstrap_test.py
@@ -9,7 +9,7 @@
 from pathlib import Path
 
 from tatsu import util
-from tatsu.codegen import codegen
+from tatsu.ngcodegen import codegen
 from tatsu.parser import EBNFParser, GrammarGenerator
 from tatsu.parser_semantics import EBNFGrammarSemantics
 from tatsu.util import asjson