@@ -493,6 +493,7 @@ def __init__(self, fig, rect,
         self.set_figure(fig)
         self.set_box_aspect(box_aspect)
         self._axes_locator = None  # Optionally set via update(kwargs).
+        self._colorbars = []
 
         self.spines = self._gen_axes_spines()
 
@@ -565,15 +566,10 @@ def __init__(self, fig, rect,
                         rcParams['ytick.major.right']),
             which='major')
 
-        self._layoutbox = None
-        self._poslayoutbox = None
-
     def __getstate__(self):
         # The renderer should be re-created by the figure, and then cached at
         # that point.
         state = super().__getstate__()
-        for key in ['_layoutbox', '_poslayoutbox']:
-            state[key] = None
         # Prune the sharing & twinning info to only contain the current group.
         for grouper_name in [
                 '_shared_x_axes', '_shared_y_axes', '_twinned_axes']:
@@ -907,8 +903,6 @@ def set_position(self, pos, which='both'):
         self._set_position(pos, which=which)
         # because this is being called externally to the library we
         # zero the constrained layout parts.
-        self._layoutbox = None
-        self._poslayoutbox = None
 
     def _set_position(self, pos, which='both'):
         """
 
@@ -63,8 +63,6 @@ def __init__(self, parent, orientation, location, functions, **kwargs):
             self._otherstrings = ['top', 'bottom']
         self._parentscale = None
         # this gets positioned w/o constrained_layout so exclude:
-        self._layoutbox = None
-        self._poslayoutbox = None
 
         self.set_location(location)
         self.set_functions(functions)
 
@@ -5,7 +5,6 @@
 import matplotlib.artist as martist
 from matplotlib.axes._axes import Axes
 from matplotlib.gridspec import GridSpec, SubplotSpec
-import matplotlib._layoutbox as layoutbox
 
 
 class SubplotBase:
@@ -37,23 +36,6 @@ def __init__(self, fig, *args, **kwargs):
         self.update_params()
         # _axes_class is set in the subplot_class_factory
         self._axes_class.__init__(self, fig, self.figbox, **kwargs)
-        # add a layout box to this, for both the full axis, and the poss
-        # of the axis.  We need both because the axes may become smaller
-        # due to parasitic axes and hence no longer fill the subplotspec.
-        if self._subplotspec._layoutbox is None:
-            self._layoutbox = None
-            self._poslayoutbox = None
-        else:
-            name = self._subplotspec._layoutbox.name + '.ax'
-            name = name + layoutbox.seq_id()
-            self._layoutbox = layoutbox.LayoutBox(
-                    parent=self._subplotspec._layoutbox,
-                    name=name,
-                    artist=self)
-            self._poslayoutbox = layoutbox.LayoutBox(
-                    parent=self._layoutbox,
-                    name=self._layoutbox.name+'.pos',
-                    pos=True, subplot=True, artist=self)
 
     def __reduce__(self):
         # get the first axes class which does not inherit from a subplotbase
@@ -156,10 +138,6 @@ def _make_twin_axes(self, *args, **kwargs):
             twin.set_label(real_label)
         self.set_adjustable('datalim')
         twin.set_adjustable('datalim')
-        if self._layoutbox is not None and twin._layoutbox is not None:
-            # make the layout boxes be explicitly the same
-            twin._layoutbox.constrain_same(self._layoutbox)
-            twin._poslayoutbox.constrain_same(self._poslayoutbox)
         self._twinned_axes.join(self, twin)
         return twin
 
 
@@ -48,8 +48,6 @@
 import matplotlib.path as mpath
 import matplotlib.ticker as ticker
 import matplotlib.transforms as mtransforms
-import matplotlib._layoutbox as layoutbox
-import matplotlib._constrained_layout as constrained_layout
 from matplotlib import docstring
 
 _log = logging.getLogger(__name__)
@@ -1433,17 +1431,7 @@ def make_axes(parents, location=None, orientation=None, fraction=0.15,
     # pass to `colorbar`.
     parents = np.atleast_1d(parents).ravel()
 
-    # check if using constrained_layout:
-    try:
-        gs = parents[0].get_subplotspec().get_gridspec()
-        using_constrained_layout = (gs._layoutbox is not None)
-    except AttributeError:
-        using_constrained_layout = False
-
-    # defaults are not appropriate for constrained_layout:
     pad0 = loc_settings['pad']
-    if using_constrained_layout:
-        pad0 = 0.02
     pad = kw.pop('pad', pad0)
 
     fig = parents[0].get_figure()
@@ -1485,31 +1473,20 @@ def make_axes(parents, location=None, orientation=None, fraction=0.15,
             ax.set_anchor(parent_anchor)
 
     cax = fig.add_axes(pbcb, label="<colorbar>")
-
-    # OK, now make a layoutbox for the cb axis.  Later, we will use this
-    # to make the colorbar fit nicely.
-    if not using_constrained_layout:
-        # no layout boxes:
-        lb = None
-        lbpos = None
-        # and we need to set the aspect ratio by hand...
-        cax.set_aspect(aspect, anchor=anchor, adjustable='box')
-    else:
-        if not parents_iterable:
-            # this is a single axis...
-            ax = parents[0]
-            lb, lbpos = constrained_layout.layoutcolorbarsingle(
-                    ax, cax, shrink, aspect, location, pad=pad)
-        else:  # there is more than one parent, so lets use gridspec
-            # the colorbar will be a sibling of this gridspec, so the
-            # parent is the same parent as the gridspec.  Either the figure,
-            # or a subplotspec.
-
-            lb, lbpos = constrained_layout.layoutcolorbargridspec(
-                    parents, cax, shrink, aspect, location, pad)
-
-    cax._layoutbox = lb
-    cax._poslayoutbox = lbpos
+    for a in parents:
+        # tell the parent it has a colorbar
+        a._colorbars += [cax]
+    cax._colorbar_info = {}
+    cax._colorbar_info['location'] = location
+    cax._colorbar_info['parents'] = parents
+    cax._colorbar_info['shrink'] = shrink
+    cax._colorbar_info['anchor'] = anchor
+    cax._colorbar_info['panchor'] = parent_anchor
+    cax._colorbar_info['fraction'] = fraction
+    cax._colorbar_info['aspect'] = aspect
+    cax._colorbar_info['pad'] = pad
+    # and we need to set the aspect ratio by hand...
+    cax.set_aspect(aspect, anchor=anchor, adjustable='box')
 
     return cax, kw
 
@@ -1560,11 +1537,7 @@ def make_axes_gridspec(parent, *, fraction=0.15, shrink=1.0, aspect=20, **kw):
     pad_s = (1 - shrink) * 0.5
     wh_ratios = [pad_s, shrink, pad_s]
 
-    # we need to none the tree of layoutboxes because
-    # constrained_layout can't remove and replace the tree
-    # hierarchy w/o a seg fault.
     gs = parent.get_subplotspec().get_gridspec()
-    layoutbox.nonetree(gs._layoutbox)
     gs_from_subplotspec = gridspec.GridSpecFromSubplotSpec
     if orientation == 'vertical':
         pad = kw.pop('pad', 0.05)
 
@@ -27,13 +27,13 @@
 
 from matplotlib.axes import Axes, SubplotBase, subplot_class_factory
 from matplotlib.blocking_input import BlockingMouseInput, BlockingKeyMouseInput
-from matplotlib.gridspec import GridSpec, SubplotSpec
+from matplotlib.gridspec import GridSpec
 import matplotlib.legend as mlegend
 from matplotlib.patches import Rectangle
 from matplotlib.text import Text
 from matplotlib.transforms import (Affine2D, Bbox, BboxTransformTo,
                                    TransformedBbox)
-import matplotlib._layoutbox as layoutbox
+import matplotlib._layoutgrid as layoutgrid
 
 _log = logging.getLogger(__name__)
 
@@ -344,9 +344,9 @@ def __init__(self,
             subplotpars = SubplotParams()
 
         self.subplotpars = subplotpars
+
         # constrained_layout:
-        self._layoutbox = None
-        # set in set_constrained_layout_pads()
+        self._layoutgrid = None
         self.set_constrained_layout(constrained_layout)
 
         self.set_tight_layout(tight_layout)
@@ -355,6 +355,13 @@ def __init__(self,
         self.clf()
         self._cachedRenderer = None
 
+        if self.get_constrained_layout():
+            # must be done *after* clf!
+            self.init_layoutgrid()
+        # stub for subpanels:
+        self.panels = []
+        self.transPanel = self.transFigure
+
         # groupers to keep track of x and y labels we want to align.
         # see self.align_xlabels and self.align_ylabels and
         # axis._get_tick_boxes_siblings
@@ -570,7 +577,7 @@ def get_constrained_layout_pads(self, relative=False):
         hspace = self._constrained_layout_pads['hspace']
 
         if relative and (w_pad is not None or h_pad is not None):
-            renderer0 = layoutbox.get_renderer(self)
+            renderer0 = layoutgrid.get_renderer(self)
             dpi = renderer0.dpi
             w_pad = w_pad * dpi / renderer0.width
             h_pad = h_pad * dpi / renderer0.height
@@ -729,22 +736,8 @@ def suptitle(self, t, **kwargs):
             sup.remove()
         else:
             self._suptitle = sup
-            self._suptitle._layoutbox = None
-            if self._layoutbox is not None and not manual_position:
-                w_pad, h_pad, wspace, hspace =  \
-                        self.get_constrained_layout_pads(relative=True)
-                figlb = self._layoutbox
-                self._suptitle._layoutbox = layoutbox.LayoutBox(
-                        parent=figlb, artist=self._suptitle,
-                        name=figlb.name+'.suptitle')
-                # stack the suptitle on top of all the children.
-                # Some day this should be on top of all the children in the
-                # gridspec only.
-                for child in figlb.children:
-                    if child is not self._suptitle._layoutbox:
-                        layoutbox.vstack([self._suptitle._layoutbox,
-                                          child],
-                                         padding=h_pad*2., strength='required')
+        if manual_position:
+            self._suptitle.set_in_layout(False)
         self.stale = True
         return self._suptitle
 
@@ -1405,6 +1398,7 @@ def add_subplot(self, *args, **kwargs):
 
     def _add_axes_internal(self, key, ax):
         """Private helper for `add_axes` and `add_subplot`."""
+        #self._localaxes += [ax]
         self._axstack.add(key, ax)
         self.sca(ax)
         ax._remove_method = self.delaxes
@@ -1570,6 +1564,7 @@ def _break_share_link(ax, grouper):
             return None
 
         self._axstack.remove(ax)
+        # self._localaxes.remove(ax)
         self._axobservers.process("_axes_change_event", self)
         self.stale = True
 
@@ -1609,7 +1604,7 @@ def clf(self, keep_observers=False):
             self._axobservers = cbook.CallbackRegistry()
         self._suptitle = None
         if self.get_constrained_layout():
-            layoutbox.nonetree(self._layoutbox)
+            layoutgrid.nonetree(self._layoutgrid)
         self.stale = True
 
     def clear(self, keep_observers=False):
@@ -1919,12 +1914,9 @@ def __getstate__(self):
                 in _pylab_helpers.Gcf.figs.values():
             state['_restore_to_pylab'] = True
 
-        # set all the layoutbox information to None.  kiwisolver objects can't
+        # set all the layoutgrid information to None.  kiwisolver objects can't
         # be pickled, so we lose the layout options at this point.
-        state.pop('_layoutbox', None)
-        # suptitle:
-        if self._suptitle is not None:
-            self._suptitle._layoutbox = None
+        state.pop('_layoutgrid', None)
 
         return state
 
@@ -1941,7 +1933,7 @@ def __setstate__(self, state):
 
         # re-initialise some of the unstored state information
         FigureCanvasBase(self)  # Set self.canvas.
-        self._layoutbox = None
+        self._layoutgrid = None
 
         if restore_to_pylab:
             # lazy import to avoid circularity
@@ -2323,24 +2315,22 @@ def get_tightbbox(self, renderer, bbox_extra_artists=None):
 
         return bbox_inches
 
-    def init_layoutbox(self):
-        """Initialize the layoutbox for use in constrained_layout."""
-        if self._layoutbox is None:
-            self._layoutbox = layoutbox.LayoutBox(
-                parent=None, name='figlb', artist=self)
-            self._layoutbox.constrain_geometry(0., 0., 1., 1.)
+    def init_layoutgrid(self):
+        """Initialize the layoutgrid for use in constrained_layout."""
+        self._layoutgrid = layoutgrid.LayoutGrid(
+            parent=None, name='figlb')
 
     def execute_constrained_layout(self, renderer=None):
         """
-        Use ``layoutbox`` to determine pos positions within axes.
+        Use ``layoutgrid`` to determine pos positions within axes.
 
         See also `.set_constrained_layout_pads`.
         """
 
         from matplotlib._constrained_layout import do_constrained_layout
 
         _log.debug('Executing constrainedlayout')
-        if self._layoutbox is None:
+        if self._layoutgrid is None:
             cbook._warn_external("Calling figure.constrained_layout, but "
                                  "figure not setup to do constrained layout. "
                                  " You either called GridSpec without the "
@@ -2355,7 +2345,7 @@ def execute_constrained_layout(self, renderer=None):
         w_pad = w_pad / width
         h_pad = h_pad / height
         if renderer is None:
-            renderer = layoutbox.get_renderer(fig)
+            renderer = layoutgrid.get_renderer(fig)
         do_constrained_layout(fig, renderer, h_pad, w_pad, hspace, wspace)
 
     @cbook._delete_parameter("3.2", "renderer")