diff --git a/core/modules/path/path.post_update.php b/core/modules/path/path.post_update.php
new file mode 100644
index 0000000..9b09890
--- /dev/null
+++ b/core/modules/path/path.post_update.php
@@ -0,0 +1,68 @@
+<?php
+
+/**
+ * Post update functions for path.
+ */
+
+use Drupal\Core\Language\LanguageInterface;
+
+/**
+ * @addtogroup updates-8.1.x-to-8.2.x
+ * @{
+ */
+
+/**
+ * Update langcodes of untranslatable path alias fields.
+ */
+function path_post_update_fix_path_alias_langcodes() {
+  $entity_manager = \Drupal::service('entity_type.bundle.info');
+  $alias_storage = \Drupal::service('path.alias_storage');
+  $connection = \Drupal::service('database');
+
+  $entity_types = [
+    'node' => [
+      'bundle_column' => 'type',
+      'source_path' => '/node/',
+    ],
+    'taxonomy_term' => [
+      'bundle_column' => 'vid',
+      'source_path' => '/taxonomy/term/',
+    ],
+  ];
+
+  foreach ($entity_types as $entity_type_id => $info) {
+    foreach ($entity_manager->getBundleInfo($entity_type_id) as $bundle_id => $bundle) {
+      // Update path alias langcodes only if the bundle or the path field are not translatable.
+      if (isset($bundle['translatable']) && $bundle['translatable'] === FALSE || \Drupal::config("core.base_field_override.$entity_type_id.$bundle_id.path")
+                                                                                   ->get('translatable') === FALSE) {
+        $ids = \Drupal::entityQuery($entity_type_id)
+          ->condition($info['bundle_column'], $bundle_id)
+          ->execute();
+        foreach ($ids as $id) {
+          // Get all path aliases associated with this ID.
+          $aliases = $connection->select('url_alias', 'a')
+            ->fields('a', ['source', 'alias', 'langcode', 'pid'])
+            ->condition('source', $info['source_path'] . $id)
+            ->condition('langcode', LanguageInterface::LANGCODE_NOT_SPECIFIED,
+              '!=')
+            ->execute()
+            ->fetchAll(\PDO::FETCH_ASSOC);
+          foreach ($aliases as $alias) {
+            // Make sure we don't create duplicated path aliases.
+            if (!$alias_storage->load([
+              'alias' => $alias['alias'],
+              'langcode' => LanguageInterface::LANGCODE_NOT_SPECIFIED,
+            ])) {
+              $alias_storage->save($alias['source'], $alias['alias'],
+                LanguageInterface::LANGCODE_NOT_SPECIFIED, $alias['pid']);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * @} End of "addtogroup updates-8.1.x-to-8.2.x".
+ */
diff --git a/core/modules/path/src/Plugin/Field/FieldType/PathFieldItemList.php b/core/modules/path/src/Plugin/Field/FieldType/PathFieldItemList.php
index 1a5fbe0..fd70336 100644
--- a/core/modules/path/src/Plugin/Field/FieldType/PathFieldItemList.php
+++ b/core/modules/path/src/Plugin/Field/FieldType/PathFieldItemList.php
@@ -57,10 +57,24 @@ public function defaultAccess($operation = 'view', AccountInterface $account = N
   public function delete() {
     // Delete all aliases associated with this entity in the current language.
     $entity = $this->getEntity();
+    $entityTypeId = $entity->getEntityTypeId();
+    $bundleId = $entity->bundle();
     $conditions = [
       'source' => '/' . $entity->toUrl()->getInternalPath(),
-      'langcode' => $entity->language()->getId(),
     ];
+    $entity_langcode = $entity->language()->getId();
+    $original_entity_langcode = $entity->getUntranslated()->language()->getId();
+    // If the path field is not translatable  and compare langauge code to check
+    // entity being deleted is a source entity not translated entity then
+    // delete the path alias with the langcode 'und'.
+    if ($entity_langcode == $original_entity_langcode &&
+        \Drupal::config("core.base_field_override" . $entityTypeId . $bundleId . "path")
+          ->get('translatable') === FALSE) {
+      $conditions['langcode'] = 'und';
+    }
+    else {
+      $conditions['langcode'] = $entity->language()->getId();
+    }
     \Drupal::service('path.alias_storage')->delete($conditions);
   }
 
diff --git a/core/modules/path/src/Plugin/Field/FieldType/PathItem.php b/core/modules/path/src/Plugin/Field/FieldType/PathItem.php
index cd62bea..971af60 100644
--- a/core/modules/path/src/Plugin/Field/FieldType/PathItem.php
+++ b/core/modules/path/src/Plugin/Field/FieldType/PathItem.php
@@ -6,6 +6,7 @@
 use Drupal\Core\Field\FieldDefinitionInterface;
 use Drupal\Core\Field\FieldStorageDefinitionInterface;
 use Drupal\Core\Field\FieldItemBase;
+use Drupal\Core\Language\LanguageInterface;
 use Drupal\Core\TypedData\DataDefinition;
 
 /**
@@ -63,9 +64,19 @@ public function preSave() {
    * {@inheritdoc}
    */
   public function postSave($update) {
+    $entity = $this->getEntity();
+
+    // If the entity and the path field are translatable, use the entity's
+    // langcode to save the alias, otherwise use 'und'.
+    if ($entity->isTranslatable() && $this->getFieldDefinition()->isTranslatable()) {
+      $this->getParent()->setLangcode($entity->language()->getId());
+    }
+    else {
+      $this->getParent()->setLangcode(LanguageInterface::LANGCODE_NOT_SPECIFIED);
+    }
+
     if (!$update) {
       if ($this->alias) {
-        $entity = $this->getEntity();
         if ($path = \Drupal::service('path.alias_storage')->save('/' . $entity->urlInfo()->getInternalPath(), $this->alias, $this->getLangcode())) {
           $this->pid = $path['pid'];
         }
@@ -78,7 +89,6 @@ public function postSave($update) {
       }
       // Only save a non-empty alias.
       elseif ($this->alias) {
-        $entity = $this->getEntity();
         \Drupal::service('path.alias_storage')->save('/' . $entity->urlInfo()->getInternalPath(), $this->alias, $this->getLangcode(), $this->pid);
       }
     }
diff --git a/core/modules/path/src/Plugin/Field/FieldWidget/PathWidget.php b/core/modules/path/src/Plugin/Field/FieldWidget/PathWidget.php
index 13ab1f1..ac6a780 100644
--- a/core/modules/path/src/Plugin/Field/FieldWidget/PathWidget.php
+++ b/core/modules/path/src/Plugin/Field/FieldWidget/PathWidget.php
@@ -5,6 +5,7 @@
 use Drupal\Core\Field\FieldItemListInterface;
 use Drupal\Core\Field\WidgetBase;
 use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\Language\LanguageInterface;
 use Symfony\Component\Validator\ConstraintViolationInterface;
 
 /**
@@ -26,6 +27,15 @@ class PathWidget extends WidgetBase {
   public function formElement(FieldItemListInterface $items, $delta, array $element, array &$form, FormStateInterface $form_state) {
     $entity = $items->getEntity();
 
+    // If the entity and the path field are translatable, use the entity's
+    // langcode to load the alias, otherwise use 'und'.
+    if ($entity->isTranslatable() && $entity->getFieldDefinition('path')->isTranslatable()) {
+      $langcode = $items[$delta]->langcode;
+    }
+    else {
+      $langcode = LanguageInterface::LANGCODE_NOT_SPECIFIED;
+    }
+
     $element += [
       '#element_validate' => [[get_class($this), 'validateFormElement']],
     ];
@@ -44,10 +54,10 @@ public function formElement(FieldItemListInterface $items, $delta, array $elemen
     $element['source'] = [
       '#type' => 'value',
       '#value' => !$entity->isNew() ? '/' . $entity->toUrl()->getInternalPath() : NULL,
-     ];
+    ];
     $element['langcode'] = [
       '#type' => 'value',
-      '#value' => $items[$delta]->langcode,
+      '#value' => $langcode,
     ];
     return $element;
   }
diff --git a/core/modules/path/src/Tests/PathTranslationTest.php b/core/modules/path/src/Tests/PathTranslationTest.php
new file mode 100644
index 0000000..f62988d
--- /dev/null
+++ b/core/modules/path/src/Tests/PathTranslationTest.php
@@ -0,0 +1,191 @@
+<?php
+
+namespace Drupal\path\Tests;
+
+use Drupal\Core\Language\LanguageInterface;
+
+/**
+ * Tests alias langcode for multilingual nodes.
+ *
+ * @group path
+ */
+class PathTranslationTest extends PathTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = [
+    'path',
+    'locale',
+    'content_translation',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    // Create and log in user.
+    $permissions = [
+      'access administration pages',
+      'administer content translation',
+      'administer content types',
+      'administer languages',
+      'administer url aliases',
+      'create content translations',
+      'create page content',
+      'create url aliases',
+      'edit any page content',
+      'translate any entity',
+    ];
+    $user        = $this->drupalCreateUser($permissions);
+    $this->drupalLogin($user);
+
+    // Enable French language.
+    $edit = [
+      'predefined_langcode' => 'fr',
+    ];
+    $this->drupalPostForm('admin/config/regional/language/add', $edit,
+      t('Add language'));
+  }
+
+  /**
+   * Tests the alias langcode for untranslatable node.
+   */
+  public function testAliasUntranslatableNode() {
+    // Create a node.
+    $node_storage = $this->container->get('entity.manager')->getStorage('node');
+    $node         = $this->drupalCreateNode([
+      'type' => 'page',
+      'langcode' => 'en',
+    ]);
+    $alias        = $this->randomMachineName();
+
+    // Edit the node to set the alias.
+    $edit = [
+      'path[0][alias]' => '/' . $alias,
+    ];
+    $this->drupalPostForm('node/' . $node->id() . '/edit', $edit, t('Save'));
+
+    // Tests that the alias works.
+    $this->drupalGet($alias);
+    $this->assertText($node->body->value);
+
+    // Tests that the alias was saved with 'und' langcode.
+    $conditions = [
+      'source' => '/node/' . $node->id(),
+      'alias' => '/' . $alias,
+    ];
+    $path       = $this->container->get('path.alias_storage')
+      ->load($conditions);
+    $this->assertEqual($path['langcode'],
+      LanguageInterface::LANGCODE_NOT_SPECIFIED);
+  }
+
+  /**
+   * Tests the alias langcode for translatable node.
+   */
+  public function testAliasLangcode() {
+    // Tests the langcode for translatable path.
+    // It should be set to the node's langcode.
+    $english_alias = $this->randomMachineName();
+    $french_alias  = $this->randomMachineName();
+    $this->doTestAliasLangcode(TRUE, $english_alias, $french_alias, 'en', 'fr');
+
+    // Tests the langcode for untranslatable path.
+    // It should be set to not specified.
+    $english_alias = $this->randomMachineName();
+    $not_specified = LanguageInterface::LANGCODE_NOT_SPECIFIED;
+    $this->doTestAliasLangcode(FALSE, $english_alias, $english_alias,
+      $not_specified, $not_specified);
+  }
+
+  /**
+   * Helper method to test aliases' langcode.
+   */
+  protected function doTestAliasLangcode(
+    $translate_path,
+    $english_alias,
+    $french_alias,
+    $expected_en,
+    $expected_fr
+  ) {
+    // Enable translation for page nodes.
+    $edit = [
+      'entity_types[node]' => 1,
+      'settings[node][page][translatable]' => 1,
+      'settings[node][page][fields][path]' => $translate_path,
+      'settings[node][page][fields][body]' => 1,
+      'settings[node][page][settings][language][language_alterable]' => 1,
+    ];
+    $this->drupalPostForm('admin/config/regional/content-language', $edit,
+      t('Save configuration'));
+
+    // Clear caches.
+    \Drupal::entityManager()->clearCachedDefinitions();
+
+    // Create a node.
+    $node_storage = $this->container->get('entity.manager')->getStorage('node');
+    $english_node = $this->drupalCreateNode([
+      'type' => 'page',
+      'langcode' => 'en',
+    ]);
+
+    // Edit the node to set the alias.
+    $edit_en = [
+      'path[0][alias]' => '/' . $english_alias,
+    ];
+    $this->drupalPostForm('node/' . $english_node->id() . '/edit', $edit_en,
+      t('Save'));
+
+    // Translate the node into French.
+    $edit_fr = [
+      'title[0][value]' => $this->randomMachineName(),
+      'body[0][value]' => $this->randomMachineName(),
+      'path[0][alias]' => '/' . $french_alias,
+    ];
+    $this->drupalPostForm('node/' . $english_node->id() . '/translations/add/en/fr',
+      $edit_fr, t('Save (this translation)'));
+
+    // Clear the path lookup cache.
+    $this->container->get('path.alias_manager')->cacheClear();
+
+    // Languages are cached on many levels, and we need to clear those caches.
+    $this->container->get('language_manager')->reset();
+    $this->rebuildContainer();
+
+    // Ensure the node was created.
+    $node_storage->resetCache([$english_node->id()]);
+    $english_node = $node_storage->load($english_node->id());
+    $this->assertTrue($english_node->hasTranslation('fr'));
+    $french_translation = $english_node->getTranslation('fr');
+
+    // Tests that both aliases work.
+    $this->drupalGet($edit_en['path[0][alias]']);
+    $this->assertText($english_node->body->value);
+    $this->drupalGet('fr' . $edit_fr['path[0][alias]']);
+    $this->assertText($french_translation->body->value);
+
+    // Tests that the English alias was saved with the expected langcode.
+    $conditions = [
+      'source' => '/node/' . $english_node->id(),
+      'alias' => $edit_en['path[0][alias]'],
+    ];
+    $path_en = $this->container->get('path.alias_storage')
+      ->load($conditions);
+    $this->assertEqual($path_en['langcode'], $expected_en);
+
+    // Tests that the French alias was saved with the expected langcode.
+    $conditions = [
+      'source' => '/node/' . $french_translation->id(),
+      'alias' => $edit_fr['path[0][alias]'],
+    ];
+    $path_fr = $this->container->get('path.alias_storage')
+      ->load($conditions);
+    $this->assertEqual($path_fr['langcode'], $expected_fr);
+  }
+
+}