diff --git a/panelizer.module b/panelizer.module
index 91238ab..749111a 100644
--- a/panelizer.module
+++ b/panelizer.module
@@ -88,6 +88,11 @@ function panelizer_entity_type_alter(array &$entity_types) {
       $entity_types[$entity_type_id]->setHandlerClass('view_builder', '\Drupal\panelizer\PanelizerEntityViewBuilder');
     }
   }
+
+  // Can't clone this because the EntityType annotation tracks the original
+  // class name and throws errors when the multiple entities have the same
+  // original class, so we instead override the entity_view_display entity.
+  $entity_types['entity_view_display']->setClass('\Drupal\panelizer\PanelizerEntityViewDisplay');
 }
 
 /**
diff --git a/src/Form/PanelizerDefaultDelete.php b/src/Form/PanelizerDefaultDelete.php
index 9fbedf4..63aaedc 100644
--- a/src/Form/PanelizerDefaultDelete.php
+++ b/src/Form/PanelizerDefaultDelete.php
@@ -157,7 +157,7 @@ public function buildForm(array $form, FormStateInterface $form_state, $machine_
    */
   public function submitForm(array &$form, FormStateInterface $form_state) {
     $display = $this->panelizer->getEntityViewDisplay($this->entityTypeId, $this->bundle, $this->viewMode);
-    $displays = $this->panelizer->getDefaultPanelsDisplays($this->entityTypeId, $this->bundle, $this->viewMode, $display);
+    $displays = $this->panelizer->getDefaultPanelsDisplays($this->entityTypeId, $this->bundle, $this->viewMode);
     unset($displays[$this->displayId]);
     foreach ($displays as $key => $value) {
       $displays[$key] = $this->panelsDisplayManager->exportDisplay($value);
diff --git a/src/Panelizer.php b/src/Panelizer.php
index 9715634..1f5e87f 100644
--- a/src/Panelizer.php
+++ b/src/Panelizer.php
@@ -9,6 +9,7 @@
 
 use Drupal\Component\Plugin\Exception\PluginNotFoundException;
 use Drupal\Core\Entity\Display\EntityViewDisplayInterface;
+use Drupal\Core\Entity\Entity\EntityViewDisplay;
 use Drupal\Core\Entity\EntityFieldManagerInterface;
 use Drupal\Core\Entity\EntityInterface;
 use Drupal\Core\Entity\EntityTypeBundleInfoInterface;
@@ -97,6 +98,8 @@ class Panelizer implements PanelizerInterface {
    */
   protected $contextMapper;
 
+  protected $viewDisplayStorage;
+
   /**
    * Constructs a Panelizer.
    *
@@ -132,6 +135,7 @@ public function __construct(EntityTypeManagerInterface $entity_type_manager, Ent
     $this->panelsManager = $panels_manager;
     $this->stringTranslation = $string_translation;
     $this->contextMapper = $context_mapper;
+    $this->viewDisplayStorage = $entity_type_manager->getStorage('entity_view_display');
   }
 
   /**
@@ -164,41 +168,26 @@ public function getDefaultPanelsDisplayByMachineName($full_machine_name) {
    * {@inheritdoc}
    */
   public function getEntityViewDisplay($entity_type_id, $bundle, $view_mode) {
-    // Check the existence and status of:
-    // - the display for the view mode,
-    // - the 'default' display.
-    $candidate_ids = array();
-    if ($view_mode != 'default') {
-      $candidate_ids[] = $entity_type_id . '.' . $bundle . '.' . $view_mode;
-    }
-    $candidate_ids[] = $entity_type_id . '.' . $bundle . '.default';
-    $results = \Drupal::entityQuery('entity_view_display')
-      ->condition('id', $candidate_ids)
-      ->condition('status', TRUE)
-      ->execute();
+    $displays = $this->viewDisplayStorage
+      ->loadMultiple([
+        "{$entity_type_id}.{$bundle}.{$view_mode}",
+        "{$entity_type_id}.{$bundle}.default",
+      ]);
 
-    // Select the first valid candidate display, if any.
-    $load_id = FALSE;
-    foreach ($candidate_ids as $candidate_id) {
-      if (isset($results[$candidate_id])) {
-        $load_id = $candidate_id;
-        break;
+    $displays = array_filter(
+      $displays,
+      function (EntityViewDisplayInterface $display) {
+        return $display->status();
       }
-    }
+    );
 
-    // Use the selected display if any, or create a fresh runtime object.
-    $storage = $this->entityTypeManager->getStorage('entity_view_display');
-    if ($load_id) {
-      $display = $storage->load($load_id);
-    }
-    else {
-      $display = $storage->create(array(
+    $display = reset($displays) ?: $this->viewDisplayStorage
+      ->create([
         'targetEntityType' => $entity_type_id,
         'bundle' => $bundle,
         'mode' => $view_mode,
         'status' => TRUE,
-      ));
-    }
+      ]);
 
     // Let modules alter the display.
     $display_context = array(
@@ -212,11 +201,21 @@ public function getEntityViewDisplay($entity_type_id, $bundle, $view_mode) {
   }
 
   /**
+   * @param \Drupal\Core\Entity\FieldableEntityInterface $entity
+   * @param $view_mode
+   *
+   * @return \Drupal\panelizer\PanelizerEntityViewDisplay
+   */
+  public function getRenderDisplay(FieldableEntityInterface $entity, $view_mode) {
+    return $this->getEntityViewDisplay($entity->getEntityTypeId(), $entity->bundle(), $view_mode);
+  }
+
+  /**
    * {@inheritdoc}
    */
-  public function getPanelsDisplay(FieldableEntityInterface $entity, $view_mode, EntityViewDisplayInterface $display = NULL) {
-    $settings = $this->getPanelizerSettings($entity->getEntityTypeId(), $entity->bundle(), $view_mode, $display);
-    if (($settings['custom'] || $settings['allow']) && isset($entity->panelizer) && $entity->panelizer->first()) {
+  public function getPanelsDisplay(FieldableEntityInterface $entity, $view_mode) {
+    $display = $this->getRenderDisplay($entity, $view_mode);
+    if (($display->isCustomizable() || $display->isChooseable()) && $entity->hasField('panelizer') && $entity->panelizer->first()) {
       /** @var \Drupal\Core\Field\FieldItemInterface[] $values */
       $values = [];
       foreach ($entity->panelizer as $item) {
@@ -227,31 +226,34 @@ public function getPanelsDisplay(FieldableEntityInterface $entity, $view_mode, E
         // Check for a customized display first and use that if present.
         if (!empty($panelizer_item->panels_display)) {
           // @todo: validate schema after https://www.drupal.org/node/2392057 is fixed.
-          return $this->panelsManager->importDisplay($panelizer_item->panels_display, FALSE);
+          $panels_display = $this->panelsManager->importDisplay($panelizer_item->panels_display, FALSE);
+          $panels_display->setContexts($this->getDisplayStaticContexts($display->getDefault(), $entity->getEntityTypeId(), $entity->bundle(), $view_mode, $display));
+          return $panels_display;
         }
         // If not customized, use the specified default.
         if (!empty($panelizer_item->default)) {
           // If we're using this magic key use the settings default.
           if ($panelizer_item->default == '__bundle_default__') {
-            $default = $settings['default'];
+            $default = $display->getDefault();
           }
           else {
             $default = $panelizer_item->default;
             // Ensure the default still exists and if not fallback sanely.
             $displays = $this->getDefaultPanelsDisplays($entity->getEntityTypeId(), $entity->bundle(), $view_mode);
             if (!isset($displays[$default])) {
-              $default = $settings['default'];
+              $default = $display->getDefault();
             }
           }
-          $panels_display = $this->getDefaultPanelsDisplay($default, $entity->getEntityTypeId(), $entity->bundle(), $view_mode, $display);
-          $this->setCacheTags($panels_display, $entity->getEntityTypeId(), $entity->bundle(), $view_mode, $display, $default, $settings);
+          $panels_display = $this->getDefaultPanelsDisplay($default, $entity->getEntityTypeId(), $entity->bundle(), $view_mode);
+          $panels_display->setContexts($this->getDisplayStaticContexts($display->getDefault(), $entity->getEntityTypeId(), $entity->bundle(), $view_mode, $display));
+          $this->setCacheTags($panels_display, $display, $default);
           return $panels_display;
         }
       }
     }
     // If the field has no input to give us, use the settings default.
-    $panels_display = $this->getDefaultPanelsDisplay($settings['default'], $entity->getEntityTypeId(), $entity->bundle(), $view_mode, $display);
-    $this->setCacheTags($panels_display, $entity->getEntityTypeId(), $entity->bundle(), $view_mode, $display, $settings['default'], $settings);
+    $panels_display = $this->getDefaultPanelsDisplay($display->getDefault(), $entity->getEntityTypeId(), $entity->bundle(), $view_mode);
+    $this->setCacheTags($panels_display, $display, $display->getDefault());
     return $panels_display;
   }
 
@@ -260,31 +262,19 @@ public function getPanelsDisplay(FieldableEntityInterface $entity, $view_mode, E
    *
    * @param \Drupal\panels\Plugin\DisplayVariant\PanelsDisplayVariant $panels_display
    *   The panels display variant.
-   * @param string $entity_type_id
-   *   The entity type id.
-   * @param string $bundle
-   *   The bundle.
-   * @param string $view_mode
-   *   The view mode.
-   * @param \Drupal\Core\Entity\Display\EntityViewDisplayInterface|NULL $display
+   * @param \Drupal\panelizer\PanelizerEntityViewDisplay $display
    *   If the caller already has the correct display, it can optionally be
    *   passed in here so the Panelizer service doesn't have to look it up;
    *   otherwise, this argument can be omitted.
    * @param $default
    *   The name of the panels display we are about to render.
-   * @param array $settings
-   *   The default panelizer settings for this EntityViewDisplay.
    */
-  protected function setCacheTags(PanelsDisplayVariant $panels_display, $entity_type_id, $bundle, $view_mode, EntityViewDisplayInterface $display = NULL, $default, array $settings) {
-    if (!$display) {
-      $display = $this->getEntityViewDisplay($entity_type_id, $bundle, $view_mode);
+  protected function setCacheTags(PanelsDisplayVariant $panels_display, PanelizerEntityViewDisplay $display, $default) {
+    $tag = "{$panels_display->getStorageType()}:{$display->getEntityTypeId()}:{$display->getTargetBundle()}:{$display->getMode()}";
+    if ($default == $display->getDefault()) {
+      $tags = [$tag];
     }
-    $display_mode = $display ? $display->getMode() : '';
-
-    if ($default == $settings['default']) {
-      $tags = ["{$panels_display->getStorageType()}:{$entity_type_id}:{$bundle}:{$display_mode}"];
-    }
-    $tags[] = "{$panels_display->getStorageType()}:{$entity_type_id}:{$bundle}:{$display_mode}:$default";
+    $tags[] = "$tag:$default";
     $panels_display->addCacheTags($tags);
   }
 
@@ -333,14 +323,11 @@ public function setPanelsDisplay(FieldableEntityInterface $entity, $view_mode, $
   /**
    * {@inheritdoc}
    */
-  public function getDefaultPanelsDisplays($entity_type_id, $bundle, $view_mode, EntityViewDisplayInterface $display = NULL) {
-    if (!$display) {
-      $display = $this->getEntityViewDisplay($entity_type_id, $bundle, $view_mode);
-    }
+  public function getDefaultPanelsDisplays($entity_type_id, $bundle, $view_mode) {
+    $display = $this->getEntityViewDisplay($entity_type_id, $bundle, $view_mode);
 
     // Get a list of all the defaults.
-    $display_config = $display->getThirdPartySetting('panelizer', 'displays', []);
-    $display_names = array_keys($display_config);
+    $display_names = array_keys($display->getDisplays());
     if (empty($display_names)) {
       $display_names = ['default'];
     }
@@ -348,7 +335,7 @@ public function getDefaultPanelsDisplays($entity_type_id, $bundle, $view_mode, E
     // Get each one individually.
     $panels_displays = [];
     foreach ($display_names as $name) {
-      if ($panels_display = $this->getDefaultPanelsDisplay($name, $entity_type_id, $bundle, $view_mode, $display)) {
+      if ($panels_display = $this->getDefaultPanelsDisplay($name, $entity_type_id, $bundle, $view_mode)) {
         $panels_displays[$name] = $panels_display;
       }
     }
@@ -359,22 +346,13 @@ public function getDefaultPanelsDisplays($entity_type_id, $bundle, $view_mode, E
   /**
    * {@inheritdoc}
    */
-  public function getDefaultPanelsDisplay($name, $entity_type_id, $bundle, $view_mode, EntityViewDisplayInterface $display = NULL) {
-    if (!$display) {
-      $display = $this->getEntityViewDisplay($entity_type_id, $bundle, $view_mode);
-      // If we still don't find a display, then we won't find a Panelizer
-      // default for sure.
-      if (!$display) {
-        return NULL;
-      }
-    }
-
-    $config = $display->getThirdPartySetting('panelizer', 'displays', []);
-    if (!empty($config[$name])) {
-      // Set a default just in case.
-      $config[$name]['builder'] = empty($config[$name]['builder']) ? 'standard' : $config[$name]['builder'];
+  public function getDefaultPanelsDisplay($name, $entity_type_id, $bundle, $view_mode) {
+    $display = $this->getEntityViewDisplay($entity_type_id, $bundle, $view_mode);
+    if ($display->hasDisplay($name)) {
+      $config = $display->getDisplay($name);
+      $config['builder'] = empty($config['builder']) ? 'standard' : $config['builder'];
       // @todo: validate schema after https://www.drupal.org/node/2392057 is fixed.
-      $panels_display = $this->panelsManager->importDisplay($config[$name], FALSE);
+      $panels_display = $this->panelsManager->importDisplay($config, FALSE);
     }
     else {
       return NULL;
diff --git a/src/PanelizerEntityViewBuilder.php b/src/PanelizerEntityViewBuilder.php
index 3e9257f..55e41bc 100644
--- a/src/PanelizerEntityViewBuilder.php
+++ b/src/PanelizerEntityViewBuilder.php
@@ -9,7 +9,6 @@
 
 use Drupal\Core\Cache\CacheableMetadata;
 use Drupal\Core\Entity\Display\EntityViewDisplayInterface;
-use Drupal\Core\Entity\Entity\EntityViewDisplay;
 use Drupal\Core\Entity\EntityHandlerInterface;
 use Drupal\Core\Entity\EntityInterface;
 use Drupal\Core\Entity\EntityTypeInterface;
@@ -183,27 +182,6 @@ protected function getPanelsDisplay(EntityInterface $entity, EntityViewDisplayIn
   }
 
   /**
-   * Returns the display objects used to render a set of entities.
-   *
-   * Wraps EntityViewDisplay::collectRenderDisplays() so we can mock it in
-   * tests.
-   *
-   * @param \Drupal\Core\Entity\FieldableEntityInterface[] $entities
-   *   The entities being rendered. They should all be of the same entity type.
-   * @param string $view_mode
-   *   The view mode being rendered.
-   *
-   * @return \Drupal\Core\Entity\Display\EntityViewDisplayInterface[]
-   *   The display objects to use to render the entities, keyed by entity
-   *   bundle.
-   *
-   * @see EntityViewDisplay::collectRenderDisplays()
-   */
-  protected function collectRenderDisplays($entities, $view_mode) {
-    return EntityViewDisplay::collectRenderDisplays($entities, $view_mode);
-  }
-
-  /**
    * Returns the entity context.
    *
    * Wraps creating new Context objects to avoid typed data in tests.
@@ -265,14 +243,13 @@ public function buildComponents(array &$build, array $entities, array $displays,
    * {@inheritdoc}
    */
   public function view(EntityInterface $entity, $view_mode = 'full', $langcode = NULL) {
-    $displays = $this->collectRenderDisplays([$entity], $view_mode);
-    $display = $displays[$entity->bundle()];
+    $display = $this->panelizer->getRenderDisplay($entity, $view_mode);
 
-    if (!$this->isPanelizerEnabled($display)) {
+    if (!$display->isPanelized()) {
       return $this->getFallbackViewBuilder()->view($entity, $view_mode, $langcode);
     }
 
-    $build = $this->buildMultiplePanelized([$entity->id() => $entity], $displays, $view_mode, $langcode);
+    $build = $this->buildMultiplePanelized([$entity->id() => $entity], $view_mode, $langcode);
     return $build[$entity->id()];
   }
 
@@ -280,13 +257,11 @@ public function view(EntityInterface $entity, $view_mode = 'full', $langcode = N
    * {@inheritdoc}
    */
   public function viewMultiple(array $entities = array(), $view_mode = 'full', $langcode = NULL) {
-    $displays = $this->collectRenderDisplays($entities, $view_mode);
-
     $panelized_entities = [];
     $fallback_entities = [];
     foreach ($entities as $id => $entity) {
-      $display = $displays[$entity->bundle()];
-      if ($this->isPanelizerEnabled($display)) {
+      $display = $this->panelizer->getRenderDisplay($entity, $view_mode);
+      if ($display->isPanelized()) {
         $panelized_entities[$id] = $entity;
       }
       else {
@@ -299,7 +274,7 @@ public function viewMultiple(array $entities = array(), $view_mode = 'full', $la
       $result += $this->getFallbackViewBuilder()->viewMultiple($fallback_entities, $view_mode, $langcode);
     }
     if (!empty($panelized_entities)) {
-      $result += $this->buildMultiplePanelized($panelized_entities, $displays, $view_mode, $langcode);
+      $result += $this->buildMultiplePanelized($panelized_entities, $view_mode, $langcode);
     }
 
     return $result;
@@ -341,19 +316,16 @@ public function getCacheTags() {
    * Build the render array for a list of panelized entities.
    *
    * @param \Drupal\Core\Entity\EntityInterface[] $entities
-   * @param \Drupal\Core\Entity\Display\EntityViewDisplayInterface[] $displays
    * @param string $view_mode
    * @param string|NULL $langcode
    *
    * @return array
    */
-  protected function buildMultiplePanelized(array $entities, array $displays, $view_mode, $langcode) {
+  protected function buildMultiplePanelized(array $entities, $view_mode, $langcode) {
     $build = [];
 
     foreach ($entities as $id => $entity) {
-      $panels_display = $this->panelizer->getPanelsDisplay($entity, $view_mode, $displays[$entity->bundle()]);
-      $settings = $this->panelizer->getPanelizerSettings($entity->getEntityTypeId(), $entity->bundle(), $view_mode, $displays[$entity->bundle()]);
-      $panels_display->setContexts($this->panelizer->getDisplayStaticContexts($settings['default'], $entity->getEntityTypeId(), $entity->bundle(), $view_mode, $displays[$entity->bundle()]));
+      $panels_display = $this->panelizer->getPanelsDisplay($entity, $view_mode);
       $build[$id] = $this->buildPanelized($entity, $panels_display, $view_mode, $langcode);
 
       // Allow modules to modify the render array.
@@ -361,7 +333,8 @@ protected function buildMultiplePanelized(array $entities, array $displays, $vie
         "{$this->entityTypeId}_view",
         'entity_view',
       );
-      $this->moduleHandler->alter($alter_types, $build[$id], $entity, $displays[$entity->bundle()]);
+      $display = $this->panelizer->getRenderDisplay($entity, $view_mode);
+      $this->moduleHandler->alter($alter_types, $build[$id], $entity, $display);
     }
 
     return $build;
diff --git a/src/PanelizerEntityViewDisplay.php b/src/PanelizerEntityViewDisplay.php
new file mode 100644
index 0000000..b37d5e2
--- /dev/null
+++ b/src/PanelizerEntityViewDisplay.php
@@ -0,0 +1,162 @@
+<?php
+
+namespace Drupal\panelizer;
+
+use Drupal\Core\Entity\Entity\EntityViewDisplay;
+use Drupal\Core\Entity\EntityStorageInterface;
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+
+class PanelizerEntityViewDisplay extends EntityViewDisplay implements PanelizerEntityViewDisplayInterface {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isPanelized() {
+    return $this->getThirdPartySetting('panelizer', 'enable', FALSE);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setPanelized($status = TRUE) {
+    return $this->setThirdPartySetting('panelizer', 'enable', (bool) $status);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isCustomizable() {
+    return $this->getThirdPartySetting('panelizer', 'custom', FALSE);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setCustomizable($status = TRUE) {
+    return $this->setThirdPartySetting('panelizer', 'custom', (bool) $status);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isChooseable() {
+    return $this->getThirdPartySetting('panelizer', 'allow', FALSE);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setChooseable($status = TRUE) {
+    return $this->setThirdPartySetting('panelizer', 'allow', (bool) $status);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getDefault() {
+    return $this->getThirdPartySetting('panelizer', 'default', 'default');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setDefault($default) {
+    return $this->setThirdPartySetting('panelizer', 'default', $default);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function hasDisplay($id = NULL) {
+    $displays = $this->getDisplays();
+    if ($id) {
+      return !empty($displays[$id]);
+    }
+    return !empty($displays);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getDisplays() {
+    return $this->getThirdPartySetting('panelizer', 'displays', []);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getDisplay($id = NULL) {
+    if (empty($id) || !$this->hasDisplay($id)) {
+      $id = $this->getDefault();
+    }
+    return $this->getDisplays()[$id];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setDisplay($id, array $display) {
+    $displays = $this->getDisplays();
+    $displays[$id] = $display;
+    return $this->setThirdPartySetting('panelizer', 'displays', $displays);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function destroyDisplay($id) {
+    $displays = $this->getDisplays();
+    unset($displays[$id]);
+    return $this->setThirdPartySetting('panelizer', 'displays', $displays);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function preSave(EntityStorageInterface $storage, $update = TRUE) {
+    parent::preSave($storage, $update);
+
+    if ($this->isPanelized() && ($this->isCustomizable() || $this->isChooseable())) {
+      $this->ensurePanelizerField();
+    }
+  }
+
+  protected function ensurePanelizerField() {
+    $storage = $this->entityTypeManager()->getStorage('field_config');
+
+    $entity = $storage->load(
+      $this->getTargetEntityTypeId() . '.' . $this->getTargetBundle() . '.panelizer'
+    );
+    if (empty($entity)) {
+      $entity = $storage->create([
+        'field_storage' => $this->ensurePanelizerFieldStorage(),
+        'bundle' => $this->getTargetBundle(),
+        'label' => t('Panelizer'),
+        'settings' => [],
+      ]);
+      $entity->save();
+    }
+    return $entity;
+  }
+
+  protected function ensurePanelizerFieldStorage() {
+    $storage = $this->entityTypeManager()->getStorage('field_storage_config');
+
+    $entity = $storage->load(
+      $this->getTargetEntityTypeId() . '.panelizer'
+    );
+    if (empty($entity)) {
+      $entity = $storage->create([
+        'entity_type' => $this->getTargetEntityTypeId(),
+        'field_name' => 'panelizer',
+        'type' => 'panelizer',
+        'cardinality' => FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED,
+        'settings' => [],
+        'status' => TRUE,
+      ]);
+      $entity->save();
+    }
+    return $entity;
+  }
+
+}
diff --git a/src/PanelizerEntityViewDisplayInterface.php b/src/PanelizerEntityViewDisplayInterface.php
new file mode 100644
index 0000000..7ebb103
--- /dev/null
+++ b/src/PanelizerEntityViewDisplayInterface.php
@@ -0,0 +1,33 @@
+<?php
+
+namespace Drupal\panelizer;
+
+interface PanelizerEntityViewDisplayInterface {
+
+  public function isPanelized();
+
+  public function setPanelized($status = TRUE);
+
+  public function isCustomizable();
+
+  public function setCustomizable($status = TRUE);
+
+  public function isChooseable();
+
+  public function setChooseable($status = TRUE);
+
+  public function getDefault();
+
+  public function setDefault($default);
+
+  public function hasDisplay($id = NULL);
+
+  public function getDisplays();
+
+  public function getDisplay($id = NULL);
+
+  public function setDisplay($id, array $display);
+
+  public function destroyDisplay($id);
+
+}
diff --git a/src/PanelizerInterface.php b/src/PanelizerInterface.php
index a793984..77e9442 100644
--- a/src/PanelizerInterface.php
+++ b/src/PanelizerInterface.php
@@ -29,27 +29,32 @@
    * @param $view_mode
    *   The view mode.
    *
-   * @return \Drupal\Core\Entity\Display\EntityViewDisplayInterface|NULL
-   *   The entity view display if one exists; NULL otherwise.
+   * @return \Drupal\panelizer\PanelizerEntityViewDisplayInterface
+   *   A panelizer entity view display.
    */
   public function getEntityViewDisplay($entity_type_id, $bundle, $view_mode);
 
   /**
+   * @param \Drupal\Core\Entity\FieldableEntityInterface $entity
+   * @param $view_mode
+   *
+   * @return \Drupal\panelizer\PanelizerEntityViewDisplayInterface
+   *   The entity view display if one exists; NULL otherwise.
+   */
+  public function getRenderDisplay(FieldableEntityInterface $entity, $view_mode);
+
+  /**
    * Gets the Panels display for a given entity and view mode.
    *
-   * @param \Drupal\Core\Entity\EntityInterface $entity
+   * @param \Drupal\Core\Entity\FieldableEntityInterface $entity
    *   The entity.
    * @param string $view_mode
    *   The entity view mode.
-   * @param \Drupal\Core\Entity\Display\EntityViewDisplayInterface|NULL $display
-   *   If the caller already has the correct display, it can optionally be
-   *   passed in here so the Panelizer service doesn't have to look it up;
-   *   otherwise, this argument can bo omitted.
    *
    * @return \Drupal\panels\Plugin\DisplayVariant\PanelsDisplayVariant|NULL
    *   The Panels display if panelized; NULL otherwise.
    */
-  public function getPanelsDisplay(FieldableEntityInterface $entity, $view_mode, EntityViewDisplayInterface $display = NULL);
+  public function getPanelsDisplay(FieldableEntityInterface $entity, $view_mode);
 
   /**
    * Sets the Panels display for a given entity and view mode.
@@ -78,17 +83,13 @@ public function setPanelsDisplay(FieldableEntityInterface $entity, $view_mode, $
    *   The bundle.
    * @param string $view_mode
    *   The view mode.
-   * @param \Drupal\Core\Entity\Display\EntityViewDisplayInterface|NULL $display
-   *   If the caller already has the correct display, it can optionally be
-   *   passed in here so the Panelizer service doesn't have to look it up;
-   *   otherwise, this argument can bo omitted.
    *
    * @return \Drupal\panels\Plugin\DisplayVariant\PanelsDisplayVariant[]
    *   An associative array of Panels displays, keyed by the machine name of
    *   the default if panelized; NULL otherwise. All panelized view modes will
    *   have at least one named 'default'.
    */
-  public function getDefaultPanelsDisplays($entity_type_id, $bundle, $view_mode, EntityViewDisplayInterface $display = NULL);
+  public function getDefaultPanelsDisplays($entity_type_id, $bundle, $view_mode);
 
   /**
    * Gets one default Panels display for an entity type, bundle and view mode.
@@ -101,16 +102,12 @@ public function getDefaultPanelsDisplays($entity_type_id, $bundle, $view_mode, E
    *   The bundle.
    * @param string $view_mode
    *   The view mode.
-   * @param \Drupal\Core\Entity\Display\EntityViewDisplayInterface|NULL $display
-   *   If the caller already has the correct display, it can optionally be
-   *   passed in here so the Panelizer service doesn't have to look it up;
-   *   otherwise, this argument can bo omitted.
    *
    * @return \Drupal\panels\Plugin\DisplayVariant\PanelsDisplayVariant|NULL
    *   The default Panels display with the given name if it exists; otherwise
    *   NULL.
    */
-  public function getDefaultPanelsDisplay($name, $entity_type_id, $bundle, $view_mode, EntityViewDisplayInterface $display = NULL);
+  public function getDefaultPanelsDisplay($name, $entity_type_id, $bundle, $view_mode);
 
   /**
    * @param $name
diff --git a/tests/src/Unit/PanelizerEntityViewBuilderTest.php b/tests/src/Unit/PanelizerEntityViewBuilderTest.php
index 26954c8..13184c9 100644
--- a/tests/src/Unit/PanelizerEntityViewBuilderTest.php
+++ b/tests/src/Unit/PanelizerEntityViewBuilderTest.php
@@ -18,6 +18,7 @@
 use Drupal\Core\Field\FieldItemListInterface;
 use Drupal\Core\Plugin\Context\ContextInterface;
 use Drupal\panelizer\PanelizerEntityViewBuilder;
+use Drupal\panelizer\PanelizerEntityViewDisplayInterface;
 use Drupal\panelizer\PanelizerInterface;
 use Drupal\panelizer\Plugin\PanelizerEntityInterface;
 use Drupal\panelizer\Plugin\PanelizerEntityManagerInterface;
@@ -201,24 +202,19 @@ protected function setupView() {
     $entity1->getCacheTags()->willReturn(['tag']);
     $entity1->getCacheMaxAge()->willReturn(123);
 
-    $display1 = $this->prophesize(EntityViewDisplayInterface::class);
-    $display1->getThirdPartySetting('panelizer', 'enable', FALSE)
-      ->willReturn(TRUE);
+    $display1 = $this->prophesize(PanelizerEntityViewDisplayInterface::class);
+    $display1->isPanelized()->willReturn(TRUE);
+    $this->panelizer->getRenderDisplay($entity1->reveal(), 'full')
+      ->willReturn($display1->reveal());
 
     $entity2 = $this->prophesize(FieldableEntityInterface::class);
     $entity2->bundle()->willReturn('xyz');
     $entity2->getEntityTypeId()->willReturn('entity_type_id');
 
-    $display2 = $this->prophesize(EntityViewDisplayInterface::class);
-    $display2->getThirdPartySetting('panelizer', 'enable', FALSE)
-      ->willReturn(FALSE);
-
-    $this->entityViewBuilder
-      ->method('collectRenderDisplays')
-      ->willReturn([
-        'abc' => $display1->reveal(),
-        'xyz' => $display2->reveal()
-      ]);
+    $display2 = $this->prophesize(PanelizerEntityViewDisplayInterface::class);
+    $display2->isPanelized()->willReturn(FALSE);
+    $this->panelizer->getRenderDisplay($entity2->reveal(), 'full')
+      ->willReturn($display2->reveal());
 
     $entity_context = $this->prophesize(ContextInterface::class);
     $this->entityViewBuilder->method('getEntityContext')
@@ -247,7 +243,10 @@ protected function setupView() {
         '@panelizer.entity_context:entity' => $entity_context->reveal(),
       ]);
 
-    $this->panelizer->getPanelsDisplay($entity1->reveal(), 'full', $display1->reveal())
+    $this->panelizer->getPanelsDisplay($entity1->reveal(), 'full')
+      ->willReturn($panels_display->reveal());
+
+    $this->panelizer->getPanelsDisplay($entity2->reveal(), 'full')
       ->willReturn($panels_display->reveal());
 
     $panels_display->getCacheContexts()->willReturn([]);