@@ -20,7 +20,7 @@
 from matplotlib import _api
 import matplotlib.transforms as mtransforms
 import matplotlib._layoutgrid as layoutgrid
-
+from matplotlib.backend_bases import _get_renderer
 
 _log = logging.getLogger(__name__)
 
@@ -62,7 +62,7 @@
 
 
 ######################################################
-def do_constrained_layout(fig, renderer, h_pad, w_pad,
+def do_constrained_layout(fig, h_pad, w_pad,
                           hspace=None, wspace=None):
     """
     Do the constrained_layout.  Called at draw time in
@@ -92,6 +92,7 @@ def do_constrained_layout(fig, renderer, h_pad, w_pad,
         layoutgrid: useful for debugging.
     """
 
+    renderer = _get_renderer(fig)
     # make layoutgrid tree...
     _layoutgrids = _make_layoutgrids(fig, None)
     if not _layoutgrids['hasgrids']:
 
@@ -513,7 +513,7 @@ def plot_children(fig, lg=None, level=0, printit=False):
     import matplotlib.patches as mpatches
 
     if lg is None:
-        _layoutgrids = fig.execute_constrained_layout()
+        _layoutgrids = fig.layout_engine.execute()
         lg = _layoutgrids[fig]
     colors = plt.rcParams["axes.prop_cycle"].by_key()["color"]
     col = colors[level]
 
@@ -2259,7 +2259,7 @@ def print_figure(
             if bbox_inches is None:
                 bbox_inches = rcParams['savefig.bbox']
 
-            if (self.figure.get_constrained_layout() or
+            if (self.figure.layout_engine is not None or
                     bbox_inches == "tight"):
                 # we need to trigger a draw before printing to make sure
                 # CL works.  "tight" also needs a draw to get the right
@@ -2288,8 +2288,8 @@ def print_figure(
             else:
                 _bbox_inches_restore = None
 
-            # we have already done CL above, so turn it off:
-            stack.enter_context(self.figure._cm_set(constrained_layout=False))
+            # we have already layout above, so turn it off:
+            stack.enter_context(self.figure._cm_set(layout_engine=None))
             try:
                 # _get_renderer may change the figure dpi (as vector formats
                 # force the figure dpi to 72), so we need to set it again here.
 
@@ -39,6 +39,8 @@
 from matplotlib.text import Text
 from matplotlib.transforms import (Affine2D, Bbox, BboxTransformTo,
                                    TransformedBbox)
+from matplotlib.layout_engine import (constrained_layout_engine, 
+                                      tight_layout_engine, LayoutEngine)
 
 _log = logging.getLogger(__name__)
 
@@ -1144,12 +1146,15 @@ def colorbar(self, mappable, cax=None, ax=None, use_gridspec=True, **kw):
                     "silence this warning, explicitly pass the 'ax' argument "
                     "to colorbar().")
 
+        if use_gridspec:
+            if (self.layout_engine is not None and
+                    not self.layout_engine.colorbar_gridspec):
+                use_gridspec = False
         # Store the value of gca so that we can set it back later on.
         if cax is None:
             current_ax = self.gca()
             kw['userax'] = False
-            if (use_gridspec and isinstance(ax, SubplotBase)
-                    and not self.get_constrained_layout()):
+            if (use_gridspec and isinstance(ax, SubplotBase)):
                 cax, kw = cbar.make_axes_gridspec(ax, **kw)
             else:
                 cax, kw = cbar.make_axes(ax, **kw)
@@ -1197,12 +1202,13 @@ def subplots_adjust(self, left=None, bottom=None, right=None, top=None,
             The height of the padding between subplots,
             as a fraction of the average Axes height.
         """
-        if self.get_constrained_layout():
-            self.set_constrained_layout(False)
+        if (self.layout_engine and
+                not self.layout_engine.adjust_compatible):
             _api.warn_external(
-                "This figure was using constrained_layout, but that is "
+                "This figure was using a layout engine that is "
                 "incompatible with subplots_adjust and/or tight_layout; "
-                "disabling constrained_layout.")
+                "not calling subplots_adjust")
+            return
         self.subplotpars.update(left, bottom, right, top, wspace, hspace)
         for ax in self.axes:
             if isinstance(ax, SubplotBase):
@@ -2207,6 +2213,7 @@ def __init__(self,
         """
         super().__init__()
 
+        self.layout_engine = None
         if layout is not None:
             if tight_layout is not None:
                 _api.warn_external(
@@ -2216,14 +2223,15 @@ def __init__(self,
                 _api.warn_external(
                     "The Figure parameters 'layout' and 'constrained_layout' "
                     "cannot be used together. Please use 'layout' only.")
-            if layout == 'constrained':
-                tight_layout = False
-                constrained_layout = True
-            elif layout == 'tight':
-                tight_layout = True
-                constrained_layout = False
-            else:
-                raise ValueError(f"Invalid value for 'layout': {layout!r}")
+            self.set_layout_engine(layout)
+        elif tight_layout is not None:
+            self.set_layout_engine(layout='tight')
+            if isinstance(tight_layout, dict):
+                self.get_layout_engine().set_info(tight_layout)
+        elif constrained_layout is not None:
+            self.set_layout_engine(layout='constrained')
+            if isinstance(constrained_layout, dict):
+                self.get_layout_engine().set_info(constrained_layout)
 
         self.callbacks = cbook.CallbackRegistry()
         # Callbacks traditionally associated with the canvas (and exposed with
@@ -2274,20 +2282,37 @@ def __init__(self,
 
         self.subplotpars = subplotpars
 
-        # constrained_layout:
-        self._constrained = False
-
-        self.set_tight_layout(tight_layout)
-
         self._axstack = _AxesStack()  # track all figure axes and current axes
         self.clf()
         self._cachedRenderer = None
 
-        self.set_constrained_layout(constrained_layout)
-
         # list of child gridspecs for this figure
         self._gridspecs = []
 
+    def set_layout_engine(self, layout=None, **kwargs):
+        """
+        Set the layout engine...  FIXME
+        """
+        if layout is None:
+            if mpl.rcParams['figure.autolayout']:
+                layout = 'tight'
+            elif mpl.rcParams['figure.constrained_layout.use']:
+                layout = 'constrained'
+            else:
+                self.layout_engine = None
+                return
+        if layout == 'tight':
+            self.layout_engine = tight_layout_engine(self, **kwargs)
+        elif layout == 'constrained':
+            self.layout_engine = constrained_layout_engine(self, **kwargs)
+        elif isinstance(layout, LayoutEngine):
+            self.layout_engine = layout
+        else:
+            raise ValueError(f"Invalid value for 'layout': {layout!r}")
+
+    def get_layout_engine(self):
+        return self.layout_engine
+    
     # TODO: I'd like to dynamically add the _repr_html_ method
     # to the figure in the right context, but then IPython doesn't
     # use it, for some reason.
@@ -2377,8 +2402,10 @@ def _set_dpi(self, dpi, forward=True):
 
     def get_tight_layout(self):
         """Return whether `.tight_layout` is called when drawing."""
-        return self._tight
+        return isinstance(self.layout_engine, tight_layout_engine)
 
+    @_api.deprecated(
+        "3.5", alternative="set_layout_engine")
     def set_tight_layout(self, tight):
         """
         Set whether and how `.tight_layout` is called when drawing.
@@ -2393,8 +2420,9 @@ def set_tight_layout(self, tight):
         """
         if tight is None:
             tight = mpl.rcParams['figure.autolayout']
-        self._tight = bool(tight)
-        self._tight_parameters = tight if isinstance(tight, dict) else {}
+        _tight_parameters = tight if isinstance(tight, dict) else {}
+        if bool(tight):
+            self.layout_engine = tight_layout_engine(self, _tight_parameters)
         self.stale = True
 
     def get_constrained_layout(self):
@@ -2403,8 +2431,10 @@ def get_constrained_layout(self):
 
         See :doc:`/tutorials/intermediate/constrainedlayout_guide`.
         """
-        return self._constrained
+        return isinstance(self.layout_engine, constrained_layout_engine)
 
+    @_api.deprecated(
+        "3.5", alternative="set_layout_engine('constrained')")
     def set_constrained_layout(self, constrained):
         """
         Set whether ``constrained_layout`` is used upon drawing. If None,
@@ -2421,20 +2451,16 @@ def set_constrained_layout(self, constrained):
         ----------
         constrained : bool or dict or None
         """
-        self._constrained_layout_pads = dict()
-        self._constrained_layout_pads['w_pad'] = None
-        self._constrained_layout_pads['h_pad'] = None
-        self._constrained_layout_pads['wspace'] = None
-        self._constrained_layout_pads['hspace'] = None
         if constrained is None:
             constrained = mpl.rcParams['figure.constrained_layout.use']
-        self._constrained = bool(constrained)
-        if isinstance(constrained, dict):
-            self.set_constrained_layout_pads(**constrained)
-        else:
-            self.set_constrained_layout_pads()
+        _constrained = bool(constrained)
+        _parameters = constrained if isinstance(constrained, dict) else {}
+        if _constrained:
+            self.layout_engine = constrained_layout_engine(self, _parameters)
         self.stale = True
 
+    @_api.deprecated(
+        "3.5", alternative="figure.layout_engine.set_info()")
     def set_constrained_layout_pads(self, **kwargs):
         """
         Set padding for ``constrained_layout``.  Note the kwargs can be passed
@@ -2461,18 +2487,15 @@ def set_constrained_layout_pads(self, **kwargs):
             subplot width. The total padding ends up being h_pad + hspace.
 
         """
+        if isinstance(self.layout_engine, constrained_layout_engine):
+            self.layout_engine.set_info(**kwargs)
 
-        todo = ['w_pad', 'h_pad', 'wspace', 'hspace']
-        for td in todo:
-            if td in kwargs and kwargs[td] is not None:
-                self._constrained_layout_pads[td] = kwargs[td]
-            else:
-                self._constrained_layout_pads[td] = (
-                    mpl.rcParams['figure.constrained_layout.' + td])
-
+    @_api.deprecated(
+        "3.5", alternative="fig.layout_engine.get_info()")
     def get_constrained_layout_pads(self, relative=False):
         """
-        Get padding for ``constrained_layout``.
+        Get padding for ``constrained_layout`` if it is the 
+        ``layout_engine``. 
 
         Returns a list of ``w_pad, h_pad`` in inches and
         ``wspace`` and ``hspace`` as fractions of the subplot.
@@ -2484,10 +2507,14 @@ def get_constrained_layout_pads(self, relative=False):
         relative : bool
             If `True`, then convert from inches to figure relative.
         """
-        w_pad = self._constrained_layout_pads['w_pad']
-        h_pad = self._constrained_layout_pads['h_pad']
-        wspace = self._constrained_layout_pads['wspace']
-        hspace = self._constrained_layout_pads['hspace']
+
+        if not isinstance(self.layout_engine, constrained_layout_engine):
+            return None, None, None, None
+        info = self.layout_engine.get_info()
+        w_pad = info['w_pad']
+        h_pad = info['h_pad']
+        wspace = info['wspace']
+        hspace = info['hspace']
 
         if relative and (w_pad is not None or h_pad is not None):
             renderer = _get_renderer(self)
@@ -2765,14 +2792,12 @@ def draw(self, renderer):
 
         try:
             renderer.open_group('figure', gid=self.get_gid())
-            if self.get_constrained_layout() and self.axes:
-                self.execute_constrained_layout(renderer)
-            if self.get_tight_layout() and self.axes:
+            if self.axes and self.layout_engine is not None:
                 try:
-                    self.tight_layout(**self._tight_parameters)
+                    pass
+                    self.layout_engine.execute()
                 except ValueError:
                     pass
-                    # ValueError can occur when resizing a window.
 
             self.patch.draw(renderer)
             mimage._draw_list_compositing_images(
@@ -3102,6 +3127,8 @@ def handler(ev):
 
         return None if event is None else event.name == "key_press_event"
 
+    @_api.deprecated(
+        "3.5", alternative="figure.layout_engine.execute()")
     def execute_constrained_layout(self, renderer=None):
         """
         Use ``layoutgrid`` to determine pos positions within Axes.
@@ -3112,22 +3139,12 @@ def execute_constrained_layout(self, renderer=None):
         -------
         layoutgrid : private debugging object
         """
+        if not isinstance(self.layout_engine, constrained_layout_engine):
+            return None
 
-        from matplotlib._constrained_layout import do_constrained_layout
-
-        _log.debug('Executing constrainedlayout')
-        w_pad, h_pad, wspace, hspace = self.get_constrained_layout_pads()
-        # convert to unit-relative lengths
-        fig = self
-        width, height = fig.get_size_inches()
-        w_pad = w_pad / width
-        h_pad = h_pad / height
-        if renderer is None:
-            renderer = _get_renderer(fig)
-        return do_constrained_layout(fig, renderer, h_pad, w_pad,
-                                     hspace, wspace)
+        return self.layout_engine.execute()
 
-    def tight_layout(self, *, pad=1.08, h_pad=None, w_pad=None, rect=None):
+    def tight_layout(self, **kwargs):
         """
         Adjust the padding between and around subplots.
 
@@ -3149,25 +3166,20 @@ def tight_layout(self, *, pad=1.08, h_pad=None, w_pad=None, rect=None):
 
         See Also
         --------
-        .Figure.set_tight_layout
+        .Figure.set_layout_engine
         .pyplot.tight_layout
         """
-        from contextlib import nullcontext
-        from .tight_layout import (
-            get_subplotspec_list, get_tight_layout_figure)
+        from .tight_layout import get_subplotspec_list
+        
         subplotspec_list = get_subplotspec_list(self.axes)
         if None in subplotspec_list:
             _api.warn_external("This figure includes Axes that are not "
                                "compatible with tight_layout, so results "
                                "might be incorrect.")
-        renderer = _get_renderer(self)
-        with getattr(renderer, "_draw_disabled", nullcontext)():
-            kwargs = get_tight_layout_figure(
-                self, self.axes, subplotspec_list, renderer,
-                pad=pad, h_pad=h_pad, w_pad=w_pad, rect=rect)
-        if kwargs:
-            self.subplots_adjust(**kwargs)
-
+        # note that here we do not _set_ the figures engine to tight_layout
+        # but rather just perform the layout in place for back compatibility.
+        engine = tight_layout_engine(fig=self, **kwargs)
+        engine.execute()
 
 def figaspect(arg):
     """