diff --git a/core/modules/content_moderation/tests/src/Kernel/ContentModerationStateTest.php b/core/modules/content_moderation/tests/src/Kernel/ContentModerationStateTest.php
index e52bf96137..5b3ecd30b5 100644
--- a/core/modules/content_moderation/tests/src/Kernel/ContentModerationStateTest.php
+++ b/core/modules/content_moderation/tests/src/Kernel/ContentModerationStateTest.php
@@ -33,6 +33,7 @@ class ContentModerationStateTest extends KernelTestBase {
     'media_test_source',
     'image',
     'file',
+    'taxonomy',
     'field',
     'content_moderation',
     'user',
@@ -63,6 +64,7 @@ protected function setUp() {
     $this->installEntitySchema('block_content');
     $this->installEntitySchema('media');
     $this->installEntitySchema('file');
+    $this->installEntitySchema('taxonomy_term');
     $this->installEntitySchema('content_moderation_state');
     $this->installConfig('content_moderation');
     $this->installSchema('file', 'file_usage');
@@ -122,7 +124,7 @@ public function testBasicModeration($entity_type_id) {
     /** @var \Drupal\Core\Entity\ContentEntityInterface $entity */
     $entity_storage = $this->entityTypeManager->getStorage($entity_type_id);
     $entity = $entity_storage->create([
-      'title' => 'Test title',
+      $this->entityTypeManager->getDefinition($entity_type_id)->getKey('label') => 'Test title',
       $this->entityTypeManager->getDefinition($entity_type_id)->getKey('bundle') => $bundle_id,
     ]);
     if ($entity instanceof EntityPublishedInterface) {
@@ -207,6 +209,9 @@ public function basicModerationTestCases() {
       'Media' => [
         'media',
       ],
+      'Taxonomy term' => [
+        'taxonomy_term',
+      ],
       'Test entity - revisions, data table, and published interface' => [
         'entity_test_mulrevpub',
       ],
diff --git a/core/modules/forum/src/Form/Overview.php b/core/modules/forum/src/Form/Overview.php
index df6f94725a..24e4a92049 100644
--- a/core/modules/forum/src/Form/Overview.php
+++ b/core/modules/forum/src/Form/Overview.php
@@ -2,6 +2,7 @@
 
 namespace Drupal\forum\Form;
 
+use Drupal\Core\Database\Connection;
 use Drupal\Core\Entity\EntityManagerInterface;
 use Drupal\Core\Form\FormStateInterface;
 use Drupal\Core\Render\Element;
@@ -29,9 +30,11 @@ class Overview extends OverviewTerms {
    *   The module handler service.
    * @param \Drupal\Core\Entity\EntityManagerInterface $entity_manager
    *   The entity manager service.
+   * @param \Drupal\Core\DatabaseConnection
+   *   The database connection.
    */
-  public function __construct(ModuleHandlerInterface $module_handler, EntityManagerInterface $entity_manager) {
-    parent::__construct($module_handler, $entity_manager);
+  public function __construct(ModuleHandlerInterface $module_handler, EntityManagerInterface $entity_manager, Connection $database) {
+    parent::__construct($module_handler, $entity_manager, $database);
     $this->entityManager = $entity_manager;
   }
 
diff --git a/core/modules/rest/tests/src/Functional/EntityResource/Term/TermResourceTestBase.php b/core/modules/rest/tests/src/Functional/EntityResource/Term/TermResourceTestBase.php
index 44a4e83033..d93b9db1e9 100644
--- a/core/modules/rest/tests/src/Functional/EntityResource/Term/TermResourceTestBase.php
+++ b/core/modules/rest/tests/src/Functional/EntityResource/Term/TermResourceTestBase.php
@@ -86,6 +86,9 @@ protected function getExpectedNormalizedEntity() {
       'tid' => [
         ['value' => 1],
       ],
+      'revision_id' => [
+        ['value' => 1],
+      ],
       'uuid' => [
         ['value' => $this->entity->uuid()],
       ],
@@ -129,6 +132,16 @@ protected function getExpectedNormalizedEntity() {
           'langcode' => 'en',
         ],
       ],
+      'status' => [
+        [
+          'value' => TRUE,
+        ]
+      ],
+      'revision_created' => [
+        $this->formatExpectedTimestampItemValues((int) $this->entity->getRevisionCreationTime()),
+      ],
+      'revision_user' => [],
+      'revision_log_message' => [],
     ];
   }
 
diff --git a/core/modules/system/css/components/tabledrag.module.css b/core/modules/system/css/components/tabledrag.module.css
index a4f0f2008b..40a7eed349 100644
--- a/core/modules/system/css/components/tabledrag.module.css
+++ b/core/modules/system/css/components/tabledrag.module.css
@@ -43,6 +43,9 @@ a.tabledrag-handle .handle {
   padding: 0.42em 0.5em;
   width: 14px;
 }
+tr.pending-revision a.tabledrag-handle .handle {
+  background: url(../../../../misc/icons/e29700/warning.svg) no-repeat 6px 7px;
+}
 a.tabledrag-handle:hover .handle,
 a.tabledrag-handle:focus .handle {
   background-image: url(../../../../misc/icons/000000/move.svg);
diff --git a/core/modules/taxonomy/src/Entity/Term.php b/core/modules/taxonomy/src/Entity/Term.php
index 03491ab962..6c05e86d9a 100644
--- a/core/modules/taxonomy/src/Entity/Term.php
+++ b/core/modules/taxonomy/src/Entity/Term.php
@@ -2,8 +2,7 @@
 
 namespace Drupal\taxonomy\Entity;
 
-use Drupal\Core\Entity\ContentEntityBase;
-use Drupal\Core\Entity\EntityChangedTrait;
+use Drupal\Core\Entity\EditorialContentEntityBase;
 use Drupal\Core\Entity\EntityStorageInterface;
 use Drupal\Core\Entity\EntityTypeInterface;
 use Drupal\Core\Field\BaseFieldDefinition;
@@ -30,14 +29,23 @@
  *   },
  *   base_table = "taxonomy_term_data",
  *   data_table = "taxonomy_term_field_data",
+ *   revision_table = "taxonomy_term_revision",
+ *   revision_data_table = "taxonomy_term_field_revision",
  *   uri_callback = "taxonomy_term_uri",
  *   translatable = TRUE,
  *   entity_keys = {
  *     "id" = "tid",
+ *     "revision" = "revision_id",
  *     "bundle" = "vid",
  *     "label" = "name",
  *     "langcode" = "langcode",
- *     "uuid" = "uuid"
+ *     "uuid" = "uuid",
+ *     "published" = "status",
+ *   },
+ *   revision_metadata_keys = {
+ *     "revision_user" = "revision_user",
+ *     "revision_created" = "revision_created",
+ *     "revision_log_message" = "revision_log_message",
  *   },
  *   bundle_entity_type = "taxonomy_vocabulary",
  *   field_ui_base_route = "entity.taxonomy_vocabulary.overview_form",
@@ -48,12 +56,13 @@
  *     "edit-form" = "/taxonomy/term/{taxonomy_term}/edit",
  *     "create" = "/taxonomy/term",
  *   },
- *   permission_granularity = "bundle"
+ *   permission_granularity = "bundle",
+ *   constraints = {
+ *     "TaxonomyHierarchy" = {}
+ *   }
  * )
  */
-class Term extends ContentEntityBase implements TermInterface {
-
-  use EntityChangedTrait;
+class Term extends EditorialContentEntityBase implements TermInterface {
 
   /**
    * {@inheritdoc}
@@ -118,6 +127,7 @@ public static function baseFieldDefinitions(EntityTypeInterface $entity_type) {
     $fields['name'] = BaseFieldDefinition::create('string')
       ->setLabel(t('Name'))
       ->setTranslatable(TRUE)
+      ->setRevisionable(TRUE)
       ->setRequired(TRUE)
       ->setSetting('max_length', 255)
       ->setDisplayOptions('view', [
@@ -134,6 +144,7 @@ public static function baseFieldDefinitions(EntityTypeInterface $entity_type) {
     $fields['description'] = BaseFieldDefinition::create('text_long')
       ->setLabel(t('Description'))
       ->setTranslatable(TRUE)
+      ->setRevisionable(TRUE)
       ->setDisplayOptions('view', [
         'label' => 'hidden',
         'type' => 'text_default',
@@ -161,7 +172,8 @@ public static function baseFieldDefinitions(EntityTypeInterface $entity_type) {
     $fields['changed'] = BaseFieldDefinition::create('changed')
       ->setLabel(t('Changed'))
       ->setDescription(t('The time that the term was last edited.'))
-      ->setTranslatable(TRUE);
+      ->setTranslatable(TRUE)
+      ->setRevisionable(TRUE);
 
     return $fields;
   }
diff --git a/core/modules/taxonomy/src/Form/OverviewTerms.php b/core/modules/taxonomy/src/Form/OverviewTerms.php
index 3811ee5fd8..53a06842c9 100644
--- a/core/modules/taxonomy/src/Form/OverviewTerms.php
+++ b/core/modules/taxonomy/src/Form/OverviewTerms.php
@@ -2,6 +2,7 @@
 
 namespace Drupal\taxonomy\Form;
 
+use Drupal\Core\Database\Connection;
 use Drupal\Core\Entity\EntityManagerInterface;
 use Drupal\Core\Form\FormBase;
 use Drupal\Core\Extension\ModuleHandlerInterface;
@@ -29,6 +30,13 @@ class OverviewTerms extends FormBase {
   protected $entityManager;
 
   /**
+   * The database connection.
+   *
+   * @var \Drupal\Core\Database\Connection
+   */
+  protected $database;
+
+  /**
    * The term storage handler.
    *
    * @var \Drupal\taxonomy\TermStorageInterface
@@ -42,10 +50,13 @@ class OverviewTerms extends FormBase {
    *   The module handler service.
    * @param \Drupal\Core\Entity\EntityManagerInterface $entity_manager
    *   The entity manager service.
+   * @param \Drupal\Core\Database\Connection
+   *   The database connection.
    */
-  public function __construct(ModuleHandlerInterface $module_handler, EntityManagerInterface $entity_manager) {
+  public function __construct(ModuleHandlerInterface $module_handler, EntityManagerInterface $entity_manager, Connection $database) {
     $this->moduleHandler = $module_handler;
     $this->entityManager = $entity_manager;
+    $this->database = $database;
     $this->storageController = $entity_manager->getStorage('taxonomy_term');
   }
 
@@ -55,7 +66,8 @@ public function __construct(ModuleHandlerInterface $module_handler, EntityManage
   public static function create(ContainerInterface $container) {
     return new static(
       $container->get('module_handler'),
-      $container->get('entity.manager')
+      $container->get('entity.manager'),
+      $container->get('database')
     );
   }
 
@@ -203,6 +215,15 @@ public function buildForm(array $form, FormStateInterface $form_state, Vocabular
       }
     }
 
+    // Get IDs of terms which have pending revisions.
+    $pending_term_ids = $this->getTermsWithPendingRevisions($taxonomy_vocabulary);
+    if (!empty($pending_term_ids)) {
+      $warning = $this->formatPlural(count($pending_term_ids),
+        'There is 1 term with pending revisions. Publish this term before reorganising.',
+        'There is @count terms with pending revisions. Publish these terms before reorganising.');
+      drupal_set_message($warning, 'warning');
+    }
+
     $errors = $form_state->getErrors();
     $destination = $this->getDestinationArray();
     $row_position = 0;
@@ -226,6 +247,9 @@ public function buildForm(array $form, FormStateInterface $form_state, Vocabular
           '#size' => $term->depth,
         ];
       }
+      if (in_array($term->id(), $pending_term_ids)) {
+        $form['terms'][$key]['#attributes']['class'][] = 'pending-revision';
+      }
       $form['terms'][$key]['term'] = [
         '#prefix' => !empty($indentation) ? \Drupal::service('renderer')->render($indentation) : '',
         '#type' => 'link',
@@ -294,7 +318,6 @@ public function buildForm(array $form, FormStateInterface $form_state, Vocabular
         '#links' => $operations,
       ];
 
-      $form['terms'][$key]['#attributes']['class'] = [];
       if ($parent_fields) {
         $form['terms'][$key]['#attributes']['class'][] = 'draggable';
       }
@@ -349,7 +372,7 @@ public function buildForm(array $form, FormStateInterface $form_state, Vocabular
       'group' => 'term-weight',
     ];
 
-    if ($taxonomy_vocabulary->getHierarchy() != VocabularyInterface::HIERARCHY_MULTIPLE && count($tree) > 1) {
+    if ($taxonomy_vocabulary->getHierarchy() != VocabularyInterface::HIERARCHY_MULTIPLE && count($tree) > 1 && empty($pending_term_ids)) {
       $form['actions'] = ['#type' => 'actions', '#tree' => FALSE];
       $form['actions']['submit'] = [
         '#type' => 'submit',
@@ -474,4 +497,27 @@ public function submitReset(array &$form, FormStateInterface $form_state) {
     $form_state->setRedirectUrl($vocabulary->urlInfo('reset-form'));
   }
 
+  /**
+   * Finds all terms which have a newer revision than the default.
+   *
+   * @param \Drupal\taxonomy\VocabularyInterface $taxonomy_vocabulary
+   *
+   * @return array
+   */
+  protected function getTermsWithPendingRevisions(VocabularyInterface $taxonomy_vocabulary) {
+    $term_definition = $this->entityManager->getDefinition('taxonomy_term');
+    $id_key = $term_definition->getKey('id');
+    $revision_key = $term_definition->getKey('revision');
+    $base_table = $term_definition->getBaseTable();
+    $revision_table = $term_definition->getRevisionTable();
+    $query = $this->database
+      ->select($revision_table, 'ttr')
+      ->fields('ttr', [$id_key]);
+    $query->join($base_table, 'ttd', 'ttr.' . $id_key . ' = ttd.' . $id_key);
+    return $query->where('ttr.' . $revision_key . ' > ttd.' . $revision_key)
+      ->groupBy($id_key)
+      ->execute()
+      ->fetchCol();
+  }
+
 }
diff --git a/core/modules/taxonomy/src/Plugin/Validation/Constraint/TaxonomyHierarchyConstraint.php b/core/modules/taxonomy/src/Plugin/Validation/Constraint/TaxonomyHierarchyConstraint.php
new file mode 100644
index 0000000000..e09bedd2b2
--- /dev/null
+++ b/core/modules/taxonomy/src/Plugin/Validation/Constraint/TaxonomyHierarchyConstraint.php
@@ -0,0 +1,26 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\Validation\Constraint;
+
+use Drupal\Core\Entity\Plugin\Validation\Constraint\CompositeConstraintBase;
+
+/**
+ * Validation constraint for changing the term hierarchy in pending revisions.
+ *
+ * @Constraint(
+ *   id = "TaxonomyHierarchy",
+ *   label = @Translation("Taxonomy hierarchy.", context = "Validation"),
+ * )
+ */
+class TaxonomyHierarchyConstraint extends CompositeConstraintBase {
+
+  public $message = 'You can only change the taxonomy hierarchy for the <em>published</em> version of this term.';
+
+  /**
+   * {@inheritdoc}
+   */
+  public function coversFields() {
+    return ['parent', 'weight'];
+  }
+
+}
diff --git a/core/modules/taxonomy/src/Plugin/Validation/Constraint/TaxonomyHierarchyConstraintValidator.php b/core/modules/taxonomy/src/Plugin/Validation/Constraint/TaxonomyHierarchyConstraintValidator.php
new file mode 100644
index 0000000000..36e4d80a8a
--- /dev/null
+++ b/core/modules/taxonomy/src/Plugin/Validation/Constraint/TaxonomyHierarchyConstraintValidator.php
@@ -0,0 +1,68 @@
+<?php
+
+namespace Drupal\taxonomy\Plugin\Validation\Constraint;
+
+use Drupal\Core\DependencyInjection\ContainerInjectionInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\Validator\Constraint;
+use Symfony\Component\Validator\ConstraintValidator;
+
+/**
+ * Constraint validator for changing term parents in pending revisions.
+ */
+class TaxonomyHierarchyConstraintValidator extends ConstraintValidator implements ContainerInjectionInterface {
+
+  /**
+   * The entity type manager.
+   *
+   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
+   */
+  private $entityTypeManager;
+
+  /**
+   * Creates a new TaxonomyHierarchyConstraintValidator instance.
+   *
+   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
+   *   The entity type manager.
+   */
+  public function __construct(EntityTypeManagerInterface $entity_type_manager) {
+    $this->entityTypeManager = $entity_type_manager;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container) {
+    return new static(
+      $container->get('entity_type.manager')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function validate($entity, Constraint $constraint) {
+    if ($entity && !$entity->isNew() && !$entity->isDefaultRevision()) {
+      /** @var \Drupal\taxonomy\TermStorageInterface $term_storage */
+      $term_storage = $this->entityTypeManager->getStorage($entity->getEntityTypeId());
+
+      $new_parents = array_column($entity->parent->getValue(), 'target_id');
+      $original_parents = array_keys($term_storage->loadParents($entity->id())) ?: [0];
+      if ($new_parents != $original_parents) {
+        $this->context->buildViolation($constraint->message)
+          ->atPath('parent')
+          ->addViolation();
+      }
+
+      /** @var \Drupal\Core\Entity\ContentEntityInterface $original */
+      $original = $term_storage->loadUnchanged($entity->id());
+      if (!$entity->weight->equals($original->weight)) {
+        $this->context->buildViolation($constraint->message)
+          ->atPath('weight')
+          ->addViolation();
+      }
+    }
+  }
+
+}
diff --git a/core/modules/taxonomy/src/TermForm.php b/core/modules/taxonomy/src/TermForm.php
index 1eae95a0d4..7b6c7c99fc 100644
--- a/core/modules/taxonomy/src/TermForm.php
+++ b/core/modules/taxonomy/src/TermForm.php
@@ -3,6 +3,7 @@
 namespace Drupal\taxonomy;
 
 use Drupal\Core\Entity\ContentEntityForm;
+use Drupal\Core\Entity\EntityConstraintViolationListInterface;
 use Drupal\Core\Form\FormStateInterface;
 
 /**
@@ -118,6 +119,28 @@ public function buildEntity(array $form, FormStateInterface $form_state) {
   /**
    * {@inheritdoc}
    */
+  protected function getEditedFieldNames(FormStateInterface $form_state) {
+    return array_merge(['parent', 'weight'], parent::getEditedFieldNames($form_state));
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function flagViolations(EntityConstraintViolationListInterface $violations, array $form, FormStateInterface $form_state) {
+    // Manually flag violations of fields not handled by the form display.
+    foreach ($violations->getByField('parent') as $violation) {
+      $form_state->setErrorByName('parent', $violation->getMessage());
+    }
+    foreach ($violations->getByField('weight') as $violation) {
+      $form_state->setErrorByName('weight', $violation->getMessage());
+    }
+
+    parent::flagViolations($violations, $form, $form_state);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
   public function save(array $form, FormStateInterface $form_state) {
     $term = $this->entity;
 
diff --git a/core/modules/taxonomy/src/TermStorageSchema.php b/core/modules/taxonomy/src/TermStorageSchema.php
index 5bcb088db4..822d1f4e02 100644
--- a/core/modules/taxonomy/src/TermStorageSchema.php
+++ b/core/modules/taxonomy/src/TermStorageSchema.php
@@ -17,7 +17,7 @@ class TermStorageSchema extends SqlContentEntityStorageSchema {
   protected function getEntitySchema(ContentEntityTypeInterface $entity_type, $reset = FALSE) {
     $schema = parent::getEntitySchema($entity_type, $reset = FALSE);
 
-    $schema['taxonomy_term_field_data']['indexes'] += [
+    $schema[$entity_type->getDataTable()]['indexes'] += [
       'taxonomy_term__tree' => ['vid', 'weight', 'name'],
       'taxonomy_term__vid_name' => ['vid', 'name'],
     ];
diff --git a/core/modules/taxonomy/src/Tests/Update/TaxonomyUpdateTest.php b/core/modules/taxonomy/src/Tests/Update/TaxonomyUpdateTest.php
new file mode 100644
index 0000000000..53680bef8f
--- /dev/null
+++ b/core/modules/taxonomy/src/Tests/Update/TaxonomyUpdateTest.php
@@ -0,0 +1,75 @@
+<?php
+
+namespace Drupal\taxonomy\Tests\Update;
+
+use Drupal\system\Tests\Update\UpdatePathTestBase;
+use Drupal\user\Entity\User;
+
+/**
+ * Tests the upgrade path for taxonomy terms.
+ *
+ * @group Update
+ */
+class TaxonomyUpdateTest extends UpdatePathTestBase  {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setDatabaseDumpFiles() {
+    $this->databaseDumpFiles = [
+      __DIR__ . '/../../../../system/tests/fixtures/update/drupal-8.filled.standard.php.gz',
+    ];
+  }
+
+  /**
+   * Tests the conversion of taxonomy terms to be revisionable and publishable.
+   *
+   * @see taxonomy_update_8400()
+   * @see taxonomy_post_update_make_taxonomy_term_revisionable()
+   */
+  public function testConversionToRevisionableAndPublishable() {
+    $this->runUpdates();
+
+    // Log in as user 1.
+    $account = User::load(1);
+    $account->pass_raw = 'drupal';
+    $this->drupalLogin($account);
+
+    // Make sure our vocabulary exists.
+    $this->drupalGet('admin/structure/taxonomy/manage/test_vocabulary/overview');
+
+    // Make sure our terms exist.
+    $this->assertText('Test root term');
+    $this->assertText('Test child term');
+    $this->drupalGet('taxonomy/term/3');
+    $this->assertResponse('200');
+
+    // Make sure the terms are still translated.
+    $this->drupalGet('taxonomy/term/2/translations');
+    $this->assertLink('Test root term - Spanish');
+
+    // Check that taxonomy terms can be created, saved and then loaded.
+    $storage = \Drupal::entityTypeManager()->getStorage('taxonomy_term');
+    /** @var \Drupal\taxonomy\Entity\Term $term */
+    $term = $storage->create([
+      'name' => 'Test term',
+      'vid' => 'article',
+    ]);
+    $term->save();
+
+    $storage->resetCache();
+    $term = $storage->loadRevision($term->getRevisionId());
+
+    $this->assertEqual('Test term', $term->label());
+    $this->assertEqual('article', $term->bundle());
+    $this->assertTrue($term->isPublished());
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function replaceUser1() {
+    // Do not replace the user from our dump.
+  }
+
+}
diff --git a/core/modules/taxonomy/taxonomy.install b/core/modules/taxonomy/taxonomy.install
new file mode 100644
index 0000000000..991f40b098
--- /dev/null
+++ b/core/modules/taxonomy/taxonomy.install
@@ -0,0 +1,114 @@
+<?php
+
+/**
+ * @file
+ * Install, update and uninstall functions for the Taxonomy module.
+ */
+
+use Drupal\Core\Field\BaseFieldDefinition;
+
+/**
+ * Implements hook_update_dependencies().
+ */
+function taxonomy_update_dependencies() {
+  // The update function that adds the status field must run after
+  // content_translation_update_8400() which fixes NULL values for the
+  // 'content_translation_status' field.
+  if (\Drupal::moduleHandler()->moduleExists('content_translation')) {
+    $dependencies['taxonomy'][8400] = [
+      'content_translation' => 8400,
+    ];
+
+    return $dependencies;
+  }
+}
+
+/**
+ * Add the 'published' and revisionable metadata fields to taxonomy terms.
+ */
+function taxonomy_update_8400() {
+  $definition_update_manager = \Drupal::entityDefinitionUpdateManager();
+
+  // Add the published entity key and revisionable metadata fields to the
+  // taxonomy_term entity type.
+  $entity_type = $definition_update_manager->getEntityType('taxonomy_term');
+
+  $entity_keys = $entity_type->getKeys();
+  $entity_keys['published'] = 'status';
+  $entity_type->set('entity_keys', $entity_keys);
+
+  $revision_metadata_keys = [
+    'revision_user' => 'revision_user',
+    'revision_created' => 'revision_created',
+    'revision_log_message' => 'revision_log_message'
+  ];
+  $entity_type->set('revision_metadata_keys', $revision_metadata_keys);
+
+  $definition_update_manager->updateEntityType($entity_type);
+
+  // Add the status field.
+  $status = BaseFieldDefinition::create('boolean')
+    ->setLabel(t('Publishing status'))
+    ->setDescription(t('A boolean indicating the published state.'))
+    ->setRevisionable(TRUE)
+    ->setTranslatable(TRUE)
+    ->setDefaultValue(TRUE);
+
+  $has_content_translation_status_field = \Drupal::moduleHandler()->moduleExists('content_translation') && $definition_update_manager->getFieldStorageDefinition('content_translation_status', 'taxonomy_term');
+  if ($has_content_translation_status_field) {
+    $status->setInitialValueFromField('content_translation_status');
+  }
+  else {
+    $status->setInitialValue(TRUE);
+  }
+  $definition_update_manager->installFieldStorageDefinition('status', 'taxonomy_term', 'taxonomy_term', $status);
+
+  // Add the revision metadata fields.
+  $revision_created = BaseFieldDefinition::create('created')
+    ->setLabel(t('Revision create time'))
+    ->setDescription(t('The time that the current revision was created.'))
+    ->setRevisionable(TRUE);
+  $definition_update_manager->installFieldStorageDefinition('revision_created', 'taxonomy_term', 'taxonomy_term', $revision_created);
+
+  $revision_user = BaseFieldDefinition::create('entity_reference')
+    ->setLabel(t('Revision user'))
+    ->setDescription(t('The user ID of the author of the current revision.'))
+    ->setSetting('target_type', 'user')
+    ->setRevisionable(TRUE);
+  $definition_update_manager->installFieldStorageDefinition('revision_user', 'taxonomy_term', 'taxonomy_term', $revision_user);
+
+  $revision_log_message = BaseFieldDefinition::create('string_long')
+    ->setLabel(t('Revision log message'))
+    ->setDescription(t('Briefly describe the changes you have made.'))
+    ->setRevisionable(TRUE)
+    ->setDefaultValue('')
+    ->setDisplayOptions('form', [
+      'type' => 'string_textarea',
+      'weight' => 25,
+      'settings' => [
+        'rows' => 4,
+      ],
+    ]);
+  $definition_update_manager->installFieldStorageDefinition('revision_log_message', 'taxonomy_term', 'taxonomy_term', $revision_log_message);
+
+  // Uninstall the 'content_translation_status' field if needed.
+  $database = \Drupal::database();
+  if ($has_content_translation_status_field) {
+    // First we have to remove the field data.
+    $database->update($entity_type->getDataTable())
+      ->fields(['content_translation_status' => NULL])
+      ->execute();
+
+    // A site may have disabled revisionability for this entity type.
+    if ($entity_type->isRevisionable()) {
+      $database->update($entity_type->getRevisionDataTable())
+        ->fields(['content_translation_status' => NULL])
+        ->execute();
+    }
+
+    $content_translation_status = $definition_update_manager->getFieldStorageDefinition('content_translation_status', 'taxonomy_term');
+    $definition_update_manager->uninstallFieldStorageDefinition($content_translation_status);
+  }
+
+  return t('Taxonomy terms have been converted to revisionable and publishable.');
+}
diff --git a/core/modules/taxonomy/taxonomy.post_update.php b/core/modules/taxonomy/taxonomy.post_update.php
new file mode 100644
index 0000000000..993d260aa6
--- /dev/null
+++ b/core/modules/taxonomy/taxonomy.post_update.php
@@ -0,0 +1,31 @@
+<?php
+
+/**
+ * @file
+ * Post update functions for the Taxonomy module.
+ */
+
+use \Drupal\Core\Entity\Sql\SqlContentEntityStorageSchemaConverter;
+
+/**
+ * Update taxonomy terms to be revisionable.
+ */
+function taxonomy_post_update_make_taxonomy_term_revisionable(&$sandbox) {
+  $schema_converter = new SqlContentEntityStorageSchemaConverter(
+    'taxonomy_term',
+    \Drupal::entityTypeManager(),
+    \Drupal::entityDefinitionUpdateManager(),
+    \Drupal::service('entity.last_installed_schema.repository'),
+    \Drupal::keyValue('entity.storage_schema.sql'),
+    \Drupal::database()
+  );
+
+  $schema_converter->convertToRevisionable(
+    $sandbox,
+    [
+      'name',
+      'description',
+      'changed',
+    ]
+  );
+}
diff --git a/core/modules/taxonomy/tests/src/Functional/TaxonomyTermContentModerationTest.php b/core/modules/taxonomy/tests/src/Functional/TaxonomyTermContentModerationTest.php
new file mode 100644
index 0000000000..7ffe6a4211
--- /dev/null
+++ b/core/modules/taxonomy/tests/src/Functional/TaxonomyTermContentModerationTest.php
@@ -0,0 +1,145 @@
+<?php
+
+namespace Drupal\Tests\taxonomy\Functional;
+
+use Drupal\workflows\Entity\Workflow;
+
+/**
+ * Tests taxonomy terms with Content Moderation.
+ *
+ * @group content_moderation
+ * @group taxonomy
+ */
+class TaxonomyTermContentModerationTest extends TaxonomyTestBase {
+
+  /**
+   * The vocabulary used for creating terms.
+   *
+   * @var \Drupal\taxonomy\VocabularyInterface
+   */
+  protected $vocabulary;
+
+  /**
+   * Modules to install.
+   *
+   * @var array
+   */
+  public static $modules = ['taxonomy', 'content_moderation'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    $this->drupalLogin($this->drupalCreateUser(['administer taxonomy', 'use editorial transition create_new_draft', 'use editorial transition publish']));
+
+    // Create a vocabulary.
+    $this->vocabulary = $this->createVocabulary();
+
+    // Set the vocabulary as moderated.
+    $workflow = Workflow::load('editorial');
+    $workflow->getTypePlugin()->addEntityTypeAndBundle('taxonomy_term', $this->vocabulary->id());
+    $workflow->save();
+  }
+
+  /**
+   * Tests taxonomy term parents on a moderated vocabulary.
+   */
+  public function testTaxonomyTermParents() {
+    // Create a simple hierarchy in the vocabulary, a root term and three parent
+    // terms.
+    $root = $this->createTerm($this->vocabulary, ['langcode' => 'en', 'moderation_state' => 'published']);
+    $parent_1 = $this->createTerm($this->vocabulary, ['langcode' => 'en', 'moderation_state' => 'published', 'parent' => $root->id()]);
+    $parent_2 = $this->createTerm($this->vocabulary, ['langcode' => 'en', 'moderation_state' => 'published', 'parent' => $root->id()]);
+    $parent_3 = $this->createTerm($this->vocabulary, ['langcode' => 'en', 'moderation_state' => 'published', 'parent' => $root->id()]);
+
+    // Create a child term and assign one of the parents above.
+    $child = $this->createTerm($this->vocabulary, ['langcode' => 'en', 'moderation_state' => 'published', 'parent' => $parent_1->id()]);
+
+    $taxonomy_storage = \Drupal::entityTypeManager()->getStorage('taxonomy_term');
+    $validation_message = 'You can only change the taxonomy hierarchy for the published version of this term.';
+
+    // Add a pending revision without changing the term parent.
+    $this->drupalGet('taxonomy/term/' . $child->id() . '/edit');
+    $this->drupalPostForm(NULL, [], 'Save and Create New Draft');
+
+    $this->assertSession()->pageTextNotContains($validation_message);
+
+    // Add a pending revision and change the parent.
+    $this->drupalGet('taxonomy/term/' . $child->id() . '/edit');
+    $this->drupalPostForm(NULL, [
+      'parent[]' => [$parent_2->id()],
+    ], 'Save and Create New Draft');
+
+    // Check that parents were not changed.
+    $this->assertSession()->pageTextContains($validation_message);
+    $taxonomy_storage->resetCache();
+    $this->assertEquals([$parent_1->id()], array_keys($taxonomy_storage->loadParents($child->id())));
+
+    // Add a pending revision and add a new parent.
+    $this->drupalGet('taxonomy/term/' . $child->id() . '/edit');
+    $this->drupalPostForm(NULL, [
+      'parent[]' => [$parent_1->id(), $parent_3->id()],
+    ], 'Save and Create New Draft');
+
+    // Check that parents were not changed.
+    $this->assertSession()->pageTextContains($validation_message);
+    $taxonomy_storage->resetCache();
+    $this->assertEquals([$parent_1->id()], array_keys($taxonomy_storage->loadParents($child->id())));
+
+    // Add a pending revision and use the root term as a parent.
+    $this->drupalGet('taxonomy/term/' . $child->id() . '/edit');
+    $this->drupalPostForm(NULL, [
+      'parent[]' => [$root->id()],
+    ], 'Save and Create New Draft');
+
+    // Check that parents were not changed.
+    $this->assertSession()->pageTextContains($validation_message);
+    $taxonomy_storage->resetCache();
+    $this->assertEquals([$parent_1->id()], array_keys($taxonomy_storage->loadParents($child->id())));
+
+    // Add a pending revision and remove the parent.
+    $this->drupalGet('taxonomy/term/' . $child->id() . '/edit');
+    $this->drupalPostForm(NULL, [
+      'parent[]' => [],
+    ], 'Save and Create New Draft');
+
+    // Check that parents were not changed.
+    $this->assertSession()->pageTextContains($validation_message);
+    $taxonomy_storage->resetCache();
+    $this->assertEquals([$parent_1->id()], array_keys($taxonomy_storage->loadParents($child->id())));
+
+    // Add a published revision and change the parent.
+    $this->drupalGet('taxonomy/term/' . $child->id() . '/edit');
+    $this->drupalPostForm(NULL, [
+      'parent[]' => [$parent_2->id()],
+    ], 'Save and Publish');
+
+    // Check that parents were changed.
+    $this->assertSession()->pageTextNotContains($validation_message);
+    $taxonomy_storage->resetCache();
+    $this->assertEquals([$parent_2->id()], array_keys($taxonomy_storage->loadParents($child->id())));
+
+    // Add a pending revision and change the weight.
+    $this->drupalGet('taxonomy/term/' . $child->id() . '/edit');
+    $this->drupalPostForm(NULL, [
+      'weight' => 10,
+    ], 'Save and Create New Draft');
+
+    // Check that weight was not changed.
+    $this->assertSession()->pageTextContains($validation_message);
+
+    // Add a new term without any parent and publish it.
+    $edit = [
+      'name[0][value]' => $this->randomMachineName(),
+    ];
+    $this->drupalPostForm("admin/structure/taxonomy/manage/{$this->vocabulary->id()}/add", $edit, 'Save and Publish');
+    // Add a pending revision without any changes.
+    $terms = taxonomy_term_load_multiple_by_name($edit['name[0][value]']);
+    $term = reset($terms);
+    $this->drupalPostForm('taxonomy/term/' . $term->id() . '/edit', [], 'Save and Create New Draft');
+    $this->assertSession()->pageTextNotContains($validation_message);
+  }
+
+}
diff --git a/core/themes/stable/css/system/components/tabledrag.module.css b/core/themes/stable/css/system/components/tabledrag.module.css
index 687bdc2ddd..af5197940d 100644
--- a/core/themes/stable/css/system/components/tabledrag.module.css
+++ b/core/themes/stable/css/system/components/tabledrag.module.css
@@ -43,6 +43,9 @@ a.tabledrag-handle .handle {
   padding: 0.42em 0.5em;
   width: 14px;
 }
+tr.pending-revision a.tabledrag-handle .handle {
+  background: url(../../../images/core/icons/e29700/warning.svg) no-repeat 6px 7px;
+}
 a.tabledrag-handle:hover .handle,
 a.tabledrag-handle:focus .handle {
   background-image: url(../../../images/core/icons/000000/move.svg);