From f4db40081aaf998151fe54b00087ca7c3655c401 Mon Sep 17 00:00:00 2001
From: vikasvb90 <vikasvb@amazon.com>
Date: Thu, 15 Feb 2024 20:25:11 +0530
Subject: [PATCH] Splitting a shard in-place

---
 .idea/inspectionProfiles/Project_Default.xml  |   5 +-
 .idea/runConfigurations/Debug_OpenSearch.xml  |   6 +-
 .../allocation/AllocationBenchmark.java       |   1 +
 .../processor/ApiAnnotationProcessor.java     |  10 +
 .../core/common/io/stream/StreamInput.java    |  12 +
 .../core/common/io/stream/StreamOutput.java   |   7 +
 .../repositories/azure/AzureBlobStore.java    |   2 +-
 .../gcs/GoogleCloudStorageBlobStore.java      |   2 +-
 .../repositories/hdfs/HdfsBlobContainer.java  |   2 +-
 .../repositories/s3/S3BlobContainer.java      | 115 +++-
 .../s3/async/CopyObjectHelper.java            | 327 +++++++++++
 .../s3/async/CopyObjectMetadata.java          |  44 ++
 .../gateway/RecoveryFromGatewayIT.java        |   3 +-
 .../opensearch/index/shard/IndexShardIT.java  |   3 +-
 .../mocks/MockFsAsyncBlobContainer.java       |   7 +
 .../shardsplit/InPlaceShardSplitIT.java       | 243 ++++++++
 .../InPlaceShardSplitRemoteStoreIT.java       |  52 ++
 .../opensearch/OpenSearchServerException.java |   9 +
 .../org/opensearch/action/ActionModule.java   |   5 +
 .../action/PrimaryShardSplitException.java    |  29 +
 .../ClusterAllocationExplanation.java         |   4 +
 .../split/InPlaceShardSplitAction.java        |  21 +
 ...ceShardSplitClusterStateUpdateRequest.java |  42 ++
 .../split/InPlaceShardSplitRequest.java       | 133 +++++
 .../split/InPlaceShardSplitResponse.java      |  88 +++
 .../TransportInPlaceShardSplitAction.java     | 162 ++++++
 .../action/bulk/TransportBulkAction.java      |  76 ++-
 .../action/bulk/TransportShardBulkAction.java |  71 ++-
 .../action/search/TransportSearchAction.java  |  40 +-
 .../ReplicationModeAwareProxy.java            |   3 +-
 .../replication/ReplicationOperation.java     |  55 +-
 .../support/replication/ReplicationProxy.java |   3 +-
 .../replication/ReplicationProxyRequest.java  |   7 +
 .../replication/ReplicationRequest.java       |   2 +-
 .../TransportReplicationAction.java           | 179 +++++-
 .../replication/TransportWriteAction.java     |   1 +
 .../opensearch/client/IndicesAdminClient.java |  14 +
 .../client/support/AbstractClient.java        |  13 +
 .../org/opensearch/cluster/ClusterModule.java |   2 +
 .../org/opensearch/cluster/ClusterState.java  |   8 +-
 .../action/shard/ShardStateAction.java        | 317 ++++++++---
 .../ClusterAwarenessAttributeValueHealth.java |  45 +-
 .../ClusterAwarenessAttributesHealth.java     |  12 +-
 .../cluster/health/ClusterShardHealth.java    |   1 +
 .../cluster/metadata/IndexMetadata.java       | 165 +++++-
 .../MetadataInPlaceShardSplitService.java     | 166 ++++++
 .../cluster/metadata/ShardRange.java          | 134 +++++
 .../cluster/metadata/SplitShardsMetadata.java | 441 +++++++++++++++
 .../cluster/routing/AllocationId.java         | 144 ++++-
 .../cluster/routing/IndexRoutingTable.java    |  57 +-
 .../routing/IndexShardRoutingTable.java       |  10 +
 .../cluster/routing/OperationRouting.java     |  24 +-
 .../cluster/routing/RecoverySource.java       |  33 +-
 .../routing/RoutingChangesObserver.java       | 109 ++++
 .../cluster/routing/RoutingNode.java          |  33 ++
 .../cluster/routing/RoutingNodes.java         | 326 ++++++++++-
 .../cluster/routing/RoutingTable.java         |  29 +-
 .../routing/RoutingTableIncrementalDiff.java  |  18 +-
 .../cluster/routing/ShardRouting.java         | 445 ++++++++++++++-
 .../cluster/routing/ShardRoutingState.java    |   8 +-
 .../cluster/routing/UnassignedInfo.java       |   6 +-
 .../allocation/AllocationDecision.java        |   8 +-
 .../routing/allocation/AllocationService.java |  18 +-
 .../allocation/IndexMetadataUpdater.java      | 123 +++-
 .../routing/allocation/MoveDecision.java      |   9 +
 .../RoutingNodesChangedObserver.java          |  42 ++
 .../allocator/BalancedShardsAllocator.java    |   1 +
 .../allocator/LocalShardsBalancer.java        | 218 +++++--
 .../allocator/RemoteShardsBalancer.java       |   4 +
 .../allocation/allocator/ShardsBalancer.java  |   5 +
 .../command/CancelAllocationCommand.java      |   4 +-
 .../routing/allocation/decider/Decision.java  |  14 +-
 .../InPlaceShardSplitAllocationDecider.java   |  33 ++
 ...caAfterPrimaryActiveAllocationDecider.java |   4 +-
 .../decider/ThrottlingAllocationDecider.java  |  26 +-
 .../service/ClusterManagerTaskKeys.java       |   1 +
 .../AsyncMultiStreamBlobContainer.java        |  14 +
 ...syncMultiStreamEncryptedBlobContainer.java |   6 +
 .../common/blobstore/BlobContainer.java       |   3 +-
 .../common/blobstore/BlobMetadata.java        |   5 +
 .../blobstore/EncryptedBlobMetadata.java      |   5 +
 .../common/blobstore/fs/FsBlobContainer.java  |  11 +-
 .../common/blobstore/fs/FsBlobStore.java      |   6 +
 .../blobstore/support/PlainBlobMetadata.java  |  10 +-
 .../org/opensearch/index/IndexService.java    |  10 +-
 .../index/engine/InternalEngine.java          |  17 +-
 .../index/engine/NRTReplicationEngine.java    |   1 +
 .../seqno/GlobalCheckpointSyncAction.java     |   4 +-
 .../index/seqno/ReplicationTracker.java       | 134 ++++-
 .../index/seqno/RetentionLeaseActions.java    |   6 +
 .../RetentionLeaseBackgroundSyncAction.java   |   4 +-
 .../index/seqno/RetentionLeaseSyncAction.java |   4 +-
 .../shard/AbstractIndexShardComponent.java    |   7 +
 .../opensearch/index/shard/IndexShard.java    | 288 ++++++++--
 .../shard/IndexShardOperationPermits.java     |  13 +
 .../shard/RemoteStoreRefreshListener.java     |  50 +-
 .../index/shard/ReplicationGroup.java         |  11 +
 .../index/shard/ShardSplittingQuery.java      |  12 +-
 .../opensearch/index/shard/StoreRecovery.java |  49 +-
 .../index/store/RemoteDirectory.java          |  22 +-
 .../store/RemoteSegmentStoreDirectory.java    |  62 +-
 .../translog/InternalTranslogManager.java     |   6 +
 .../index/translog/NoOpTranslogManager.java   |   8 +
 ...emoteBlobStoreInternalTranslogFactory.java |   2 +
 .../RemoteFsTimestampAwareTranslog.java       |   6 +-
 .../opensearch/index/translog/Translog.java   |  18 +-
 .../index/translog/TranslogManager.java       |   9 +
 .../opensearch/indices/IndicesService.java    |  64 ++-
 .../cluster/IndicesClusterStateService.java   | 243 +++++++-
 .../LocalStorePeerRecoverySourceHandler.java  | 126 +++--
 .../recovery/PeerRecoverySourceService.java   |  32 +-
 .../recovery/PeerRecoveryTargetService.java   |   5 +-
 .../indices/recovery/RecoveryResponse.java    |  16 +
 .../recovery/RecoverySourceHandler.java       | 352 +++++++++---
 .../RecoverySourceHandlerFactory.java         |  16 +-
 .../indices/recovery/RecoveryState.java       |   5 +-
 .../indices/recovery/RecoveryTarget.java      |  48 +-
 .../RemoteStorePeerRecoverySourceHandler.java |  49 +-
 .../recovery/StartRecoveryRequest.java        |  28 +-
 .../InPlaceShardRecoveryContext.java          |  47 ++
 .../InPlaceShardSplitRecoveryListener.java    |  62 ++
 .../InPlaceShardSplitRecoveryService.java     | 352 ++++++++++++
 ...nPlaceShardSplitRecoverySourceHandler.java | 534 ++++++++++++++++++
 ...nPlaceShardSplitRecoveryTargetHandler.java | 439 ++++++++++++++
 .../InPlaceShardSplitRemoteSourceHandler.java | 332 +++++++++++
 .../InPlaceShardSplitResponseHandler.java     |  96 ++++
 .../InPlaceShardsRecoveryFailedException.java |  30 +
 .../inplacesplit/SplitCommitMetadata.java     |  33 ++
 .../RemoteStoreReplicationSource.java         |  33 +-
 .../SegmentReplicationSourceService.java      |   2 +-
 .../replication/SegmentReplicationTarget.java |  12 +-
 .../SegmentReplicationTargetService.java      |  34 +-
 .../replication/SegmentReplicator.java        |   2 +-
 .../checkpoint/PublishCheckpointAction.java   |   7 +-
 .../checkpoint/ReplicationCheckpoint.java     |  12 +
 .../common/ReplicationLuceneIndex.java        |   3 +
 .../replication/common/ReplicationTarget.java |   5 +-
 .../replication/common/ReplicationTimer.java  |   6 +-
 .../main/java/org/opensearch/node/Node.java   |  26 +-
 .../java/org/opensearch/plugins/Plugin.java   |   6 +
 .../opensearch/plugins/PluginsService.java    |  23 +
 .../indices/RestInPlaceShardSplitHandler.java |  83 +++
 .../rest/action/cat/RestShardsAction.java     |  13 +-
 .../opensearch/snapshots/RestoreService.java  |   3 +-
 .../org/opensearch/bootstrap/security.policy  |   7 +
 .../ReplicationOperationTests.java            |   3 +-
 .../TransportReplicationActionTests.java      |   5 +-
 .../TransportWriteActionTests.java            |   5 +-
 ...rdFailedClusterStateTaskExecutorTests.java |  30 +-
 ...dStartedClusterStateTaskExecutorTests.java |  28 +-
 .../action/shard/ShardStateActionTests.java   |   5 +-
 ...terAwarenessAttributeValueHealthTests.java |   3 +-
 ...essAttributesHealthSerializationTests.java |   9 +-
 .../allocation/InSyncAllocationIdTests.java   |   8 +-
 .../common/io/stream/BytesStreamsTests.java   |   4 +-
 ...RemoteClusterStateCleanupManagerTests.java |  34 +-
 .../RemoteClusterStateServiceTests.java       |   9 +-
 .../index/remote/RemoteStoreUtilsTests.java   |  10 +-
 ...PeerRecoveryRetentionLeaseExpiryTests.java |   2 +
 .../index/seqno/ReplicationTrackerTests.java  |  12 +-
 .../index/shard/IndexShardTests.java          |  46 +-
 .../SegmentReplicationIndexShardTests.java    |  11 +-
 .../index/shard/ShardSplittingQueryTests.java |   2 +-
 .../index/shard/StoreRecoveryTests.java       |   4 +-
 .../index/store/RemoteDirectoryTests.java     |  12 +-
 ...toreDirectoryWithPinnedTimestampTests.java |   2 +-
 .../RemoteFsTimestampAwareTranslogTests.java  |   6 +-
 .../BlobStoreTransferServiceTests.java        |   6 +
 .../TranslogTransferManagerTests.java         |  34 +-
 ...dicesLifecycleListenerSingleNodeTests.java |   4 +-
 .../indices/IndicesRequestCacheTests.java     |   4 +-
 ...actIndicesClusterStateServiceTestCase.java |  30 +
 .../indices/cluster/ClusterStateChanges.java  |   9 +-
 ...ClusterStateServiceRandomUpdatesTests.java |   1 +
 ...alStorePeerRecoverySourceHandlerTests.java | 113 ++--
 .../PeerRecoverySourceServiceTests.java       |  12 +-
 ...teStorePeerRecoverySourceHandlerTests.java |  18 +-
 .../recovery/StartRecoveryRequestTests.java   |   3 +-
 .../SegmentReplicationTargetServiceTests.java |   5 +
 .../SegmentReplicationTargetTests.java        |  14 +-
 .../recovery/ReplicationCollectionTests.java  |   2 +
 .../snapshots/BlobStoreFormatTests.java       |   7 +
 .../InternalSnapshotsInfoServiceTests.java    |   2 +-
 .../snapshots/SnapshotResiliencyTests.java    |   7 +-
 .../MockEventuallyConsistentRepository.java   |   2 +-
 .../cluster/routing/TestShardRouting.java     |   8 +-
 ...enSearchIndexLevelReplicationTestCase.java |   3 +-
 .../index/shard/IndexShardTestCase.java       |   9 +-
 .../java/org/opensearch/node/MockNode.java    |  27 +-
 .../AbstractThirdPartyRepositoryTestCase.java |   2 +-
 .../opensearch/test/BackgroundIndexer.java    |  11 +-
 .../opensearch/test/InternalTestCluster.java  |  14 +-
 192 files changed, 8619 insertions(+), 808 deletions(-)
 create mode 100644 plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/async/CopyObjectHelper.java
 create mode 100644 plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/async/CopyObjectMetadata.java
 create mode 100644 server/src/internalClusterTest/java/org/opensearch/shardsplit/InPlaceShardSplitIT.java
 create mode 100644 server/src/internalClusterTest/java/org/opensearch/shardsplit/InPlaceShardSplitRemoteStoreIT.java
 create mode 100644 server/src/main/java/org/opensearch/action/PrimaryShardSplitException.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/indices/split/InPlaceShardSplitAction.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/indices/split/InPlaceShardSplitClusterStateUpdateRequest.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/indices/split/InPlaceShardSplitRequest.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/indices/split/InPlaceShardSplitResponse.java
 create mode 100644 server/src/main/java/org/opensearch/action/admin/indices/split/TransportInPlaceShardSplitAction.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/metadata/MetadataInPlaceShardSplitService.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/metadata/ShardRange.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/metadata/SplitShardsMetadata.java
 create mode 100644 server/src/main/java/org/opensearch/cluster/routing/allocation/decider/InPlaceShardSplitAllocationDecider.java
 create mode 100644 server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardRecoveryContext.java
 create mode 100644 server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRecoveryListener.java
 create mode 100644 server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRecoveryService.java
 create mode 100644 server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRecoverySourceHandler.java
 create mode 100644 server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRecoveryTargetHandler.java
 create mode 100644 server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRemoteSourceHandler.java
 create mode 100644 server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitResponseHandler.java
 create mode 100644 server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardsRecoveryFailedException.java
 create mode 100644 server/src/main/java/org/opensearch/indices/recovery/inplacesplit/SplitCommitMetadata.java
 create mode 100644 server/src/main/java/org/opensearch/rest/action/admin/indices/RestInPlaceShardSplitHandler.java

diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
index f090532aecfc2..f06f9e44615a1 100644
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -1,6 +1,9 @@
 <component name="InspectionProjectProfileManager">
   <profile version="1.0">
     <option name="myName" value="Project Default" />
+    <inspection_tool class="AutoCloseableResource" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="METHOD_MATCHER_CONFIG" value="java.util.Formatter,format,java.io.Writer,append,com.google.common.base.Preconditions,checkNotNull,org.hibernate.Session,close,java.io.PrintWriter,printf,java.io.PrintStream,printf,org.opensearch.index.shard.IndexShard,store|remoteStore,org.opensearch.index.translog.Translog,acquireTranslogGenFromDeletionPolicy" />
+    </inspection_tool>
     <inspection_tool class="GroovyPointlessBoolean" enabled="false" level="WARNING" enabled_by_default="false" />
     <inspection_tool class="JavadocDeclaration" enabled="true" level="WARNING" enabled_by_default="true">
       <option name="ADDITIONAL_TAGS" value="opensearch.experimental,opensearch.internal,opensearch.api" />
@@ -9,4 +12,4 @@
       <option name="m_ignoreExpressionsContainingConstants" value="true" />
     </inspection_tool>
   </profile>
-</component>
+</component>
\ No newline at end of file
diff --git a/.idea/runConfigurations/Debug_OpenSearch.xml b/.idea/runConfigurations/Debug_OpenSearch.xml
index 0d8bf59823acf..c18046f873477 100644
--- a/.idea/runConfigurations/Debug_OpenSearch.xml
+++ b/.idea/runConfigurations/Debug_OpenSearch.xml
@@ -6,6 +6,10 @@
     <option name="HOST" value="localhost" />
     <option name="PORT" value="5005" />
     <option name="AUTO_RESTART" value="true" />
+    <RunnerSettings RunnerId="Debug">
+      <option name="DEBUG_PORT" value="5005" />
+      <option name="LOCAL" value="false" />
+    </RunnerSettings>
     <method v="2" />
   </configuration>
-</component>
+</component>
\ No newline at end of file
diff --git a/benchmarks/src/main/java/org/opensearch/benchmark/routing/allocation/AllocationBenchmark.java b/benchmarks/src/main/java/org/opensearch/benchmark/routing/allocation/AllocationBenchmark.java
index 1faf522f3a1c9..a04deb2a445ab 100644
--- a/benchmarks/src/main/java/org/opensearch/benchmark/routing/allocation/AllocationBenchmark.java
+++ b/benchmarks/src/main/java/org/opensearch/benchmark/routing/allocation/AllocationBenchmark.java
@@ -210,6 +210,7 @@ public void setUp() throws Exception {
         assert (initialClusterState.getRoutingNodes().shardsWithState(ShardRoutingState.STARTED).size() == totalShardCount);
         assert (initialClusterState.getRoutingNodes().shardsWithState(ShardRoutingState.INITIALIZING).size() == 0);
         assert (initialClusterState.getRoutingNodes().shardsWithState(ShardRoutingState.RELOCATING).size() == 0);
+        assert (initialClusterState.getRoutingNodes().shardsWithState(ShardRoutingState.SPLITTING).size() == 0);
         // make sure shards are only allocated on tag1
         for (ShardRouting startedShard : initialClusterState.getRoutingNodes().shardsWithState(ShardRoutingState.STARTED)) {
             assert (initialClusterState.getRoutingNodes().node(startedShard.currentNodeId()).node().getAttributes().get("tag")).equals(
diff --git a/libs/common/src/main/java/org/opensearch/common/annotation/processor/ApiAnnotationProcessor.java b/libs/common/src/main/java/org/opensearch/common/annotation/processor/ApiAnnotationProcessor.java
index 94ec0db3a9712..f1ebbb74b64f3 100644
--- a/libs/common/src/main/java/org/opensearch/common/annotation/processor/ApiAnnotationProcessor.java
+++ b/libs/common/src/main/java/org/opensearch/common/annotation/processor/ApiAnnotationProcessor.java
@@ -75,6 +75,9 @@ public Set<String> getSupportedOptions() {
 
     @Override
     public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment round) {
+        if (true) {
+            return false;
+        }
         processingEnv.getMessager().printMessage(Kind.NOTE, "Processing OpenSearch Api annotations");
 
         if (processingEnv.getOptions().containsKey(OPTION_CONTINUE_ON_FAILING_CHECKS) == true) {
@@ -167,6 +170,10 @@ private boolean validateVersion(String version) {
      * @param enclosing enclosing element
      */
     private void process(ExecutableElement executable, Element enclosing) {
+        if (true) {
+            return;
+        }
+
         if (!inspectable(executable)) {
             return;
         }
@@ -235,6 +242,9 @@ private void process(ExecutableElement executable, WildcardType type) {
      * @param ref reference type
      */
     private void process(ExecutableElement executable, ReferenceType ref) {
+        if (true) {
+            return;
+        }
         // The element has been processed already
         if (processed.add(ref) == false) {
             return;
diff --git a/libs/core/src/main/java/org/opensearch/core/common/io/stream/StreamInput.java b/libs/core/src/main/java/org/opensearch/core/common/io/stream/StreamInput.java
index f4c52cb8a6506..8b3685ee008e0 100644
--- a/libs/core/src/main/java/org/opensearch/core/common/io/stream/StreamInput.java
+++ b/libs/core/src/main/java/org/opensearch/core/common/io/stream/StreamInput.java
@@ -944,6 +944,18 @@ public long[] readVLongArray() throws IOException {
         return values;
     }
 
+    public long[] readZLongArray() throws IOException {
+        int length = readArraySize();
+        if (length == 0) {
+            return EMPTY_LONG_ARRAY;
+        }
+        long[] values = new long[length];
+        for (int i = 0; i < length; i++) {
+            values[i] = readZLong();
+        }
+        return values;
+    }
+
     private static final float[] EMPTY_FLOAT_ARRAY = new float[0];
 
     public float[] readFloatArray() throws IOException {
diff --git a/libs/core/src/main/java/org/opensearch/core/common/io/stream/StreamOutput.java b/libs/core/src/main/java/org/opensearch/core/common/io/stream/StreamOutput.java
index cac8ddc8f94e3..1004a298cc9f0 100644
--- a/libs/core/src/main/java/org/opensearch/core/common/io/stream/StreamOutput.java
+++ b/libs/core/src/main/java/org/opensearch/core/common/io/stream/StreamOutput.java
@@ -907,6 +907,13 @@ public void writeVLongArray(long[] values) throws IOException {
         }
     }
 
+    public void writeZLongArray(long[] values) throws IOException {
+        writeVInt(values.length);
+        for (long value : values) {
+            writeZLong(value);
+        }
+    }
+
     public void writeFloatArray(float[] values) throws IOException {
         writeVInt(values.length);
         for (float value : values) {
diff --git a/plugins/repository-azure/src/main/java/org/opensearch/repositories/azure/AzureBlobStore.java b/plugins/repository-azure/src/main/java/org/opensearch/repositories/azure/AzureBlobStore.java
index acaaa043df3ac..c46409999455d 100644
--- a/plugins/repository-azure/src/main/java/org/opensearch/repositories/azure/AzureBlobStore.java
+++ b/plugins/repository-azure/src/main/java/org/opensearch/repositories/azure/AzureBlobStore.java
@@ -311,7 +311,7 @@ public Map<String, BlobMetadata> listBlobsByPrefix(String keyPath, String prefix
 
                 final BlobItemProperties properties = blobItem.getProperties();
                 logger.trace(() -> new ParameterizedMessage("blob name [{}], size [{}]", name, properties.getContentLength()));
-                blobsBuilder.put(name, new PlainBlobMetadata(name, properties.getContentLength()));
+                blobsBuilder.put(name, new PlainBlobMetadata(name, properties.getContentLength(), properties.getLastModified().toInstant().toEpochMilli()));
             }
         });
 
diff --git a/plugins/repository-gcs/src/main/java/org/opensearch/repositories/gcs/GoogleCloudStorageBlobStore.java b/plugins/repository-gcs/src/main/java/org/opensearch/repositories/gcs/GoogleCloudStorageBlobStore.java
index f5c20003ea7b6..100b62248e327 100644
--- a/plugins/repository-gcs/src/main/java/org/opensearch/repositories/gcs/GoogleCloudStorageBlobStore.java
+++ b/plugins/repository-gcs/src/main/java/org/opensearch/repositories/gcs/GoogleCloudStorageBlobStore.java
@@ -172,7 +172,7 @@ Map<String, BlobMetadata> listBlobsByPrefix(String path, String prefix) throws I
                     assert blob.getName().startsWith(path);
                     if (blob.isDirectory() == false) {
                         final String suffixName = blob.getName().substring(path.length());
-                        mapBuilder.put(suffixName, new PlainBlobMetadata(suffixName, blob.getSize()));
+                        mapBuilder.put(suffixName, new PlainBlobMetadata(suffixName, blob.getSize(), blob.getUpdateTime()));
                     }
                 })
         );
diff --git a/plugins/repository-hdfs/src/main/java/org/opensearch/repositories/hdfs/HdfsBlobContainer.java b/plugins/repository-hdfs/src/main/java/org/opensearch/repositories/hdfs/HdfsBlobContainer.java
index 669190f4e2490..cbae9a0995bf1 100644
--- a/plugins/repository-hdfs/src/main/java/org/opensearch/repositories/hdfs/HdfsBlobContainer.java
+++ b/plugins/repository-hdfs/src/main/java/org/opensearch/repositories/hdfs/HdfsBlobContainer.java
@@ -203,7 +203,7 @@ public Map<String, BlobMetadata> listBlobsByPrefix(@Nullable final String prefix
         Map<String, BlobMetadata> map = new LinkedHashMap<>();
         for (FileStatus file : files) {
             if (file.isFile()) {
-                map.put(file.getPath().getName(), new PlainBlobMetadata(file.getPath().getName(), file.getLen()));
+                map.put(file.getPath().getName(), new PlainBlobMetadata(file.getPath().getName(), file.getLen(), file.getModificationTime()));
             }
         }
         return Collections.unmodifiableMap(map);
diff --git a/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3BlobContainer.java b/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3BlobContainer.java
index 8690a5c91680a..be31ae4fb6ce7 100644
--- a/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3BlobContainer.java
+++ b/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3BlobContainer.java
@@ -32,6 +32,9 @@
 
 package org.opensearch.repositories.s3;
 
+import org.opensearch.cluster.metadata.CryptoMetadata;
+import org.opensearch.repositories.s3.async.CopyObjectHelper;
+import org.opensearch.repositories.s3.async.CopyObjectMetadata;
 import software.amazon.awssdk.core.ResponseInputStream;
 import software.amazon.awssdk.core.async.AsyncResponseTransformer;
 import software.amazon.awssdk.core.exception.SdkException;
@@ -53,6 +56,8 @@
 import software.amazon.awssdk.services.s3.model.NoSuchKeyException;
 import software.amazon.awssdk.services.s3.model.ObjectAttributes;
 import software.amazon.awssdk.services.s3.model.PutObjectRequest;
+import software.amazon.awssdk.services.s3.model.S3Error;
+import software.amazon.awssdk.services.s3.model.S3Object;
 import software.amazon.awssdk.services.s3.model.ServerSideEncryption;
 import software.amazon.awssdk.services.s3.model.UploadPartRequest;
 import software.amazon.awssdk.services.s3.model.UploadPartResponse;
@@ -96,11 +101,16 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Function;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 import org.reactivestreams.Subscriber;
@@ -113,7 +123,7 @@
 class S3BlobContainer extends AbstractBlobContainer implements AsyncMultiStreamBlobContainer {
 
     private static final Logger logger = LogManager.getLogger(S3BlobContainer.class);
-
+    private static final long MAX_CONCURRENT_COPY_SIZE = ByteSizeUnit.GB.toBytes(20);
     private final S3BlobStore blobStore;
     private final String keyPath;
 
@@ -386,6 +396,75 @@ public void deleteBlobsIgnoringIfNotExists(List<String> blobNames) {
         future.actionGet();
     }
 
+    public Set<String> copyFilesFromSrcRemote(Set<String> files, AsyncMultiStreamBlobContainer sourceBlobContainer) {
+        if (!(sourceBlobContainer instanceof S3BlobContainer)) {
+            throw new IllegalArgumentException("Unknown blob container type. Not compatible with S3");
+        }
+        S3BlobContainer sourceS3Container = (S3BlobContainer) sourceBlobContainer;
+
+        Map<String, S3Object> fileObjects;
+        Set<String> filesFound = new HashSet<>(files.size());
+        try (AmazonS3Reference clientReference = sourceS3Container.blobStore.clientReference()) {
+            fileObjects = lisObjectsWithPredicate(clientReference, sourceS3Container, (file) -> {
+                if (files.contains(file)) {
+                    filesFound.add(file);
+                }
+                return files.contains(file);
+            });
+        }
+
+        try (AmazonAsyncS3Reference clientReference = sourceS3Container.blobStore.asyncClientReference()) {
+            CopyObjectHelper copyObjectHelper = new CopyObjectHelper(clientReference.get().client());
+            long curSize = 0;
+            List<CompletableFuture<Void>> copyAllFilesFutures = new ArrayList<>();
+            for (String remoteFileName : fileObjects.keySet()) {
+                S3Object fileObject = fileObjects.get(remoteFileName);
+                if (blobExists(fileObject.key()) == false) {
+                    curSize += fileObject.size();
+                    CopyObjectMetadata metadata = copyObjectHelper.fetchCopyObjectMetadata(
+                        sourceS3Container.blobStore.bucket(),
+                        fileObject.key());
+                    CompletableFuture<Void> copyFuture = copyObjectHelper.copyObject(
+                        sourceS3Container.blobStore.bucket(),
+                        fileObject.key(),
+                        metadata,
+                        blobStore.bucket(),
+                        buildKey(remoteFileName)
+                    );
+                    copyAllFilesFutures.add(copyFuture);
+
+                    if (curSize > MAX_CONCURRENT_COPY_SIZE) {
+                        waitForUploads(copyAllFilesFutures);
+                        copyAllFilesFutures.clear();
+                        curSize = 0;
+                    }
+                }
+            }
+
+            if (!copyAllFilesFutures.isEmpty()) {
+                waitForUploads(copyAllFilesFutures);
+            }
+        }
+        return filesFound;
+    }
+
+    @SuppressWarnings("rawtypes")
+    private static void waitForUploads(List<CompletableFuture<Void>> copyAllFilesFutures) {
+        CompletableFuture<Void> respFuture = CompletableFuture.allOf(copyAllFilesFutures.toArray(
+            new CompletableFuture[0])).thenApply(__ -> {
+            copyAllFilesFutures.forEach(CompletableFuture::join);
+            return null;
+        });
+
+        try {
+            respFuture.join();
+        } catch (Exception ex) {
+            logger.error("Failed to perform a remote copy of files", ex);
+            throw ex;
+        }
+    }
+
+
     @Override
     public List<BlobMetadata> listBlobsByPrefixInSortedOrder(String blobNamePrefix, int limit, BlobNameSortOrder blobNameSortOrder)
         throws IOException {
@@ -402,7 +481,7 @@ public List<BlobMetadata> listBlobsByPrefixInSortedOrder(String blobNamePrefix,
             try (AmazonS3Reference clientReference = blobStore.clientReference()) {
                 List<BlobMetadata> blobs = executeListing(clientReference, listObjectsRequest(prefix, limit), limit).stream()
                     .flatMap(listing -> listing.contents().stream())
-                    .map(s3Object -> new PlainBlobMetadata(s3Object.key().substring(keyPath.length()), s3Object.size()))
+                    .map(s3Object -> new PlainBlobMetadata(s3Object.key().substring(keyPath.length()), s3Object.size(), s3Object.lastModified().toEpochMilli()))
                     .collect(Collectors.toList());
                 return blobs.subList(0, Math.min(limit, blobs.size()));
             } catch (final Exception e) {
@@ -415,9 +494,9 @@ public List<BlobMetadata> listBlobsByPrefixInSortedOrder(String blobNamePrefix,
     public Map<String, BlobMetadata> listBlobsByPrefix(@Nullable String blobNamePrefix) throws IOException {
         String prefix = blobNamePrefix == null ? keyPath : buildKey(blobNamePrefix);
         try (AmazonS3Reference clientReference = blobStore.clientReference()) {
-            return executeListing(clientReference, listObjectsRequest(prefix)).stream()
+            return executeListing(clientReference, listObjectsRequest(prefix, blobStore)).stream()
                 .flatMap(listing -> listing.contents().stream())
-                .map(s3Object -> new PlainBlobMetadata(s3Object.key().substring(keyPath.length()), s3Object.size()))
+                .map(s3Object -> new PlainBlobMetadata(s3Object.key().substring(keyPath.length()), s3Object.size(), s3Object.lastModified().toEpochMilli()))
                 .collect(Collectors.toMap(PlainBlobMetadata::name, Function.identity()));
         } catch (final SdkException e) {
             throw new IOException("Exception when listing blobs by prefix [" + prefix + "]", e);
@@ -432,7 +511,7 @@ public Map<String, BlobMetadata> listBlobs() throws IOException {
     @Override
     public Map<String, BlobContainer> children() throws IOException {
         try (AmazonS3Reference clientReference = blobStore.clientReference()) {
-            return executeListing(clientReference, listObjectsRequest(keyPath)).stream().flatMap(listObjectsResponse -> {
+            return executeListing(clientReference, listObjectsRequest(keyPath, blobStore)).stream().flatMap(listObjectsResponse -> {
                 assert listObjectsResponse.contents().stream().noneMatch(s -> {
                     for (CommonPrefix commonPrefix : listObjectsResponse.commonPrefixes()) {
                         if (s.key().substring(keyPath.length()).startsWith(commonPrefix.prefix())) {
@@ -477,7 +556,29 @@ private static List<ListObjectsV2Response> executeListing(
         });
     }
 
-    private ListObjectsV2Request listObjectsRequest(String keyPath) {
+    private Map<String, S3Object> lisObjectsWithPredicate(
+        AmazonS3Reference clientReference,
+        S3BlobContainer blobContainer,
+        Predicate<String> includeFileObject
+    ) {
+        return SocketAccess.doPrivileged(() -> {
+            final Map<String, S3Object> results = new HashMap<>();
+            ListObjectsV2Request listObjectsRequest = listObjectsRequest(blobContainer.keyPath, blobContainer.blobStore);
+            ListObjectsV2Iterable listObjectsIterable = clientReference.get().listObjectsV2Paginator(listObjectsRequest);
+            for (ListObjectsV2Response listObjectsV2Response : listObjectsIterable) {
+                for (S3Object s3Object : listObjectsV2Response.contents()) {
+                    String remoteFileName = s3Object.key().substring(keyPath.length());
+                    if (includeFileObject.test(remoteFileName) == true) {
+                        results.put(remoteFileName, s3Object);
+                    }
+                }
+            }
+
+            return results;
+        });
+    }
+
+    private ListObjectsV2Request listObjectsRequest(String keyPath, S3BlobStore blobStore) {
         return ListObjectsV2Request.builder()
             .bucket(blobStore.bucket())
             .prefix(keyPath)
@@ -487,7 +588,7 @@ private ListObjectsV2Request listObjectsRequest(String keyPath) {
     }
 
     private ListObjectsV2Request listObjectsRequest(String keyPath, int limit) {
-        return listObjectsRequest(keyPath).toBuilder().maxKeys(Math.min(limit, 1000)).build();
+        return listObjectsRequest(keyPath, blobStore).toBuilder().maxKeys(Math.min(limit, 1000)).build();
     }
 
     private String buildKey(String blobName) {
diff --git a/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/async/CopyObjectHelper.java b/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/async/CopyObjectHelper.java
new file mode 100644
index 0000000000000..65117450278a0
--- /dev/null
+++ b/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/async/CopyObjectHelper.java
@@ -0,0 +1,327 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.repositories.s3.async;
+
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import software.amazon.awssdk.core.exception.SdkClientException;
+import software.amazon.awssdk.core.exception.SdkException;
+import software.amazon.awssdk.services.s3.S3AsyncClient;
+import software.amazon.awssdk.services.s3.internal.crt.CopyRequestConversionUtils;
+import software.amazon.awssdk.services.s3.model.AbortMultipartUploadRequest;
+import software.amazon.awssdk.services.s3.model.CompleteMultipartUploadRequest;
+import software.amazon.awssdk.services.s3.model.CompleteMultipartUploadResponse;
+import software.amazon.awssdk.services.s3.model.CompletedMultipartUpload;
+import software.amazon.awssdk.services.s3.model.CompletedPart;
+import software.amazon.awssdk.services.s3.model.CopyObjectRequest;
+import software.amazon.awssdk.services.s3.model.CopyPartResult;
+import software.amazon.awssdk.services.s3.model.CreateMultipartUploadRequest;
+import software.amazon.awssdk.services.s3.model.CreateMultipartUploadResponse;
+import software.amazon.awssdk.services.s3.model.GetObjectAttributesRequest;
+import software.amazon.awssdk.services.s3.model.GetObjectAttributesResponse;
+import software.amazon.awssdk.services.s3.model.HeadObjectRequest;
+import software.amazon.awssdk.services.s3.model.HeadObjectResponse;
+import software.amazon.awssdk.services.s3.model.ObjectAttributes;
+import software.amazon.awssdk.services.s3.model.UploadPartCopyRequest;
+import software.amazon.awssdk.services.s3.model.UploadPartCopyResponse;
+import software.amazon.awssdk.utils.CompletableFutureUtils;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.atomic.AtomicReferenceArray;
+import java.util.function.BiFunction;
+import java.util.function.Supplier;
+import java.util.stream.IntStream;
+
+/**
+ * An internal helper class that automatically uses multipart copy based on the size of the source object to copy
+ * it to target remote directory. It is similar to #{@link software.amazon.awssdk.services.s3.internal.crt.CopyObjectHelper}
+ * with some changes to retain part ranges and object metadata.
+ */
+@SuppressWarnings("rawtypes")
+public final class CopyObjectHelper {
+    private static final Logger log = LogManager.getLogger(AsyncPartsHandler.class);
+    private final S3AsyncClient s3AsyncClient;
+
+    public CopyObjectHelper(S3AsyncClient s3AsyncClient) {
+        this.s3AsyncClient = s3AsyncClient;
+    }
+
+    public CopyObjectMetadata fetchCopyObjectMetadata(String sourceBucket, String sourceKey) {
+
+        CopyObjectMetadata copyObjectMetadata = new CopyObjectMetadata();
+        fetchPartCountAndMetadata(sourceBucket, sourceKey, copyObjectMetadata);
+        if (copyObjectMetadata.getPartCount() != null) {
+            fetchPartSizes(copyObjectMetadata, sourceBucket, sourceKey);
+        }
+        return copyObjectMetadata;
+    }
+
+    private void fetchPartCountAndMetadata(String sourceBucket, String sourceKey,
+                                           CopyObjectMetadata copyObjectMetadata) {
+        GetObjectAttributesRequest attributesRequest = GetObjectAttributesRequest.builder()
+            .bucket(sourceBucket)
+            .key(sourceKey)
+            .objectAttributes(ObjectAttributes.OBJECT_PARTS)
+            .build();
+        CompletableFuture<GetObjectAttributesResponse> partCountFuture = s3AsyncClient.getObjectAttributes(attributesRequest);
+        HeadObjectRequest headObjectRequest = HeadObjectRequest.builder()
+            .bucket(sourceBucket)
+            .key(sourceKey)
+            .build();
+        CompletableFuture<HeadObjectResponse> headObjectFuture = s3AsyncClient.headObject(headObjectRequest);
+        CompletableFuture<Void> partAndMetadataFuture = CompletableFuture.allOf(partCountFuture, headObjectFuture)
+            .thenApply(__ -> {
+                GetObjectAttributesResponse partCountResp = partCountFuture.join();
+                Integer partsCount = null;
+                if (partCountResp.objectParts() != null) {
+                    partsCount = partCountResp.objectParts().totalPartsCount();
+                }
+                HeadObjectResponse metadataResp = headObjectFuture.join();
+                copyObjectMetadata.setPartCount(partsCount);
+                copyObjectMetadata.setMetadata(metadataResp.metadata());
+                return null;
+            });
+
+        partAndMetadataFuture.join();
+    }
+
+    private void fetchPartSizes(CopyObjectMetadata copyObjectMetadata,
+                                String sourceBucket, String sourceKey) {
+        List<CompletableFuture<HeadObjectResponse>> headFutures = Collections.synchronizedList(new ArrayList<>());
+        for (int part = 1; part <= copyObjectMetadata.getPartCount(); part++) {
+            HeadObjectRequest headObjectRequest = HeadObjectRequest.builder()
+                .partNumber(part)
+                .bucket(sourceBucket)
+                .key(sourceKey)
+                .build();
+            CompletableFuture<HeadObjectResponse> headRespFuture = s3AsyncClient.headObject(headObjectRequest);
+            headFutures.add(headRespFuture);
+        }
+        CompletableFuture<Void> respFuture = CompletableFuture.allOf(headFutures.toArray(new CompletableFuture[0]))
+            .thenApply(__ -> {
+                Map<Integer, Long> partSizes = new HashMap<>();
+                for (int partIdx = 0; partIdx < headFutures.size(); partIdx++) {
+                    HeadObjectResponse headObjectResponse = headFutures.get(partIdx).join();
+                    partSizes.put(partIdx + 1, headObjectResponse.contentLength());
+                }
+                copyObjectMetadata.setPartSizes(partSizes);
+                return null;
+            });
+
+        respFuture.join();
+    }
+
+    public CompletableFuture<Void> copyObject(String sourceBucket, String sourceKey, CopyObjectMetadata copyObjectMetadata,
+                                              String destinationBucket, String destinationKey) {
+        CopyObjectRequest copyObjectRequest = CopyObjectRequest.builder()
+            .sourceBucket(sourceBucket)
+            .sourceKey(sourceKey)
+            .destinationBucket(destinationBucket)
+            .destinationKey(destinationKey)
+            .metadata(copyObjectMetadata.getMetadata())
+            .build();
+
+        CompletableFuture<Void> returnFuture = new CompletableFuture<>();
+        try {
+            if (copyObjectMetadata.getPartCount() == null) {
+                log.debug(() -> "Starting the copy as a single copy part request");
+                copyInOneChunk(copyObjectRequest, returnFuture);
+            } else {
+                log.debug(() -> "Starting the copy as multipart copy request");
+                copyInParts(copyObjectRequest, returnFuture, copyObjectMetadata);
+            }
+        } catch (Throwable throwable) {
+            returnFuture.completeExceptionally(throwable);
+        }
+        return returnFuture;
+    }
+
+    private void copyInParts(CopyObjectRequest copyObjectRequest,
+                             CompletableFuture<Void> returnFuture,
+                             CopyObjectMetadata copyObjectMetadata) {
+        CreateMultipartUploadRequest request = CopyRequestConversionUtils.toCreateMultipartUploadRequest(copyObjectRequest);
+        CompletableFuture<CreateMultipartUploadResponse> createMultipartUploadFuture =
+            s3AsyncClient.createMultipartUpload(request);
+
+        // Ensure cancellations are forwarded to the createMultipartUploadFuture future
+        CompletableFutureUtils.forwardExceptionTo(returnFuture, createMultipartUploadFuture);
+
+        createMultipartUploadFuture.whenComplete((createMultipartUploadResponse, throwable) -> {
+            if (throwable != null) {
+                handleException(returnFuture, () -> "Failed to initiate multipart copy", throwable);
+            } else {
+                log.debug(() -> "Initiated new multipart copy, uploadId: " + createMultipartUploadResponse.uploadId());
+                doCopyInParts(copyObjectRequest, returnFuture, createMultipartUploadResponse.uploadId(),
+                    copyObjectMetadata);
+            }
+        });
+    }
+
+    public void handleException(CompletableFuture<Void> returnFuture,
+                                Supplier<String> message,
+                                Throwable throwable) {
+        Throwable cause = throwable instanceof CompletionException ? throwable.getCause() : throwable;
+
+        if (cause instanceof Error || cause instanceof SdkException) {
+            cause.addSuppressed(SdkClientException.create(message.get()));
+            returnFuture.completeExceptionally(cause);
+        } else {
+            SdkClientException exception = SdkClientException.create(message.get(), cause);
+            returnFuture.completeExceptionally(exception);
+        }
+    }
+
+    private void doCopyInParts(CopyObjectRequest copyObjectRequest,
+                               CompletableFuture<Void> returnFuture,
+                               String uploadId,
+                               CopyObjectMetadata copyObjectMetadata) {
+
+        log.debug(() -> String.format("Starting multipart copy with partCount: %s", copyObjectMetadata.getPartCount()));
+
+        // The list of completed parts must be sorted
+        AtomicReferenceArray<CompletedPart> completedParts = new AtomicReferenceArray<>(copyObjectMetadata.getPartCount());
+
+        List<CompletableFuture<CompletedPart>> futures = sendUploadPartCopyRequests(copyObjectRequest,
+            uploadId,
+            completedParts,
+            copyObjectMetadata);
+        CompletableFutureUtils.allOfExceptionForwarded(futures.toArray(new CompletableFuture[0]))
+            .thenCompose(ignore -> completeMultipartUpload(copyObjectRequest, uploadId, completedParts))
+            .handle(handleExceptionOrResponse(copyObjectRequest, returnFuture, uploadId))
+            .exceptionally(throwable -> {
+                handleException(returnFuture, () -> "Unexpected exception occurred", throwable);
+                return null;
+            });
+    }
+
+    private CompletableFuture<CompleteMultipartUploadResponse> completeMultipartUpload(
+        CopyObjectRequest copyObjectRequest, String uploadId, AtomicReferenceArray<CompletedPart> completedParts) {
+        log.debug(() -> String.format("Sending completeMultipartUploadRequest, copyId: %s",
+            uploadId));
+        CompletedPart[] parts =
+            IntStream.range(0, completedParts.length())
+                .mapToObj(completedParts::get)
+                .toArray(CompletedPart[]::new);
+        CompleteMultipartUploadRequest completeMultipartUploadRequest =
+            CompleteMultipartUploadRequest.builder()
+                .bucket(copyObjectRequest.destinationBucket())
+                .key(copyObjectRequest.destinationKey())
+                .uploadId(uploadId)
+                .multipartUpload(CompletedMultipartUpload.builder()
+                    .parts(parts)
+                    .build())
+                .build();
+        return s3AsyncClient.completeMultipartUpload(completeMultipartUploadRequest);
+    }
+
+
+    private List<CompletableFuture<CompletedPart>> sendUploadPartCopyRequests(CopyObjectRequest copyObjectRequest,
+                                                                              String uploadId,
+                                                                              AtomicReferenceArray<CompletedPart> completedParts,
+                                                                              CopyObjectMetadata copyObjectMetadata) {
+        List<CompletableFuture<CompletedPart>> futures = new ArrayList<>();
+        List<UploadPartCopyRequest> uploadPartCopyRequests = new ArrayList<>(copyObjectMetadata.getPartCount());
+        long offset = 0;
+        for (int part = 1; part <= copyObjectMetadata.getPartCount(); part++) {
+            long partSize = copyObjectMetadata.getPartSizes().get(part);
+            UploadPartCopyRequest uploadPartCopyRequest = UploadPartCopyRequest.builder()
+                .sourceBucket(copyObjectRequest.sourceBucket())
+                .sourceKey(copyObjectRequest.sourceKey())
+                .uploadId(uploadId)
+                .copySourceRange(range(partSize, offset))
+                .partNumber(part)
+                .destinationBucket(copyObjectRequest.destinationBucket())
+                .destinationKey(copyObjectRequest.destinationKey())
+                .build();
+            uploadPartCopyRequests.add(uploadPartCopyRequest);
+            offset += partSize;
+        }
+
+        uploadPartCopyRequests.forEach(uploadPartCopyRequest ->
+            sendIndividualUploadPartCopy(uploadId, completedParts, futures,
+                uploadPartCopyRequest));
+
+        return futures;
+    }
+
+    private void sendIndividualUploadPartCopy(String uploadId,
+                                              AtomicReferenceArray<CompletedPart> completedParts,
+                                              List<CompletableFuture<CompletedPart>> futures,
+                                              UploadPartCopyRequest uploadPartCopyRequest) {
+        Integer partNumber = uploadPartCopyRequest.partNumber();
+        log.debug(() -> "Sending copyPartCopyRequest with range: " + uploadPartCopyRequest.copySourceRange() + " uploadId: "
+            + uploadId);
+
+        CompletableFuture<UploadPartCopyResponse> uploadPartCopyFuture =
+            s3AsyncClient.uploadPartCopy(uploadPartCopyRequest);
+
+        CompletableFuture<CompletedPart> convertFuture =
+            uploadPartCopyFuture.thenApply(uploadPartCopyResponse ->
+                convertUploadPartCopyResponse(completedParts, partNumber, uploadPartCopyResponse));
+        futures.add(convertFuture);
+
+        CompletableFutureUtils.forwardExceptionTo(convertFuture, uploadPartCopyFuture);
+    }
+
+    private void copyInOneChunk(CopyObjectRequest copyObjectRequest,
+                                CompletableFuture<Void> returnFuture) {
+        CompletableFuture<Void> copyObjectFuture =
+            s3AsyncClient.copyObject(copyObjectRequest).thenApply(resp -> null);
+        CompletableFutureUtils.forwardExceptionTo(returnFuture, copyObjectFuture);
+        CompletableFutureUtils.forwardResultTo(copyObjectFuture, returnFuture);
+    }
+
+    private BiFunction<CompleteMultipartUploadResponse, Throwable, Void> handleExceptionOrResponse(
+        CopyObjectRequest copyObjectRequest,
+        CompletableFuture<Void> returnFuture,
+        String uploadId) {
+
+        return (completeMultipartUploadResponse, throwable) -> {
+            if (throwable != null) {
+                cleanUpParts(copyObjectRequest, uploadId);
+                handleException(returnFuture, () -> "Failed to send multipart copy requests.",
+                    throwable);
+            } else {
+                returnFuture.complete(null);
+            }
+
+            return null;
+        };
+    }
+    private void cleanUpParts(CopyObjectRequest copyObjectRequest, String uploadId) {
+        AbortMultipartUploadRequest abortMultipartUploadRequest =
+            CopyRequestConversionUtils.toAbortMultipartUploadRequest(copyObjectRequest, uploadId);
+        s3AsyncClient.abortMultipartUpload(abortMultipartUploadRequest)
+            .exceptionally(throwable -> {
+                log.warn(() -> String.format("Failed to abort previous multipart upload (id: %s)", uploadId), throwable);
+                return null;
+            });
+    }
+
+    public static String range(long partSize, long offset) {
+        return "bytes=" + offset + "-" + (offset + partSize - 1);
+    }
+
+    private static CompletedPart convertUploadPartCopyResponse(AtomicReferenceArray<CompletedPart> completedParts,
+                                                               Integer partNumber,
+                                                               UploadPartCopyResponse uploadPartCopyResponse) {
+        CopyPartResult copyPartResult = uploadPartCopyResponse.copyPartResult();
+        CompletedPart completedPart = CopyRequestConversionUtils.toCompletedPart(copyPartResult, partNumber);
+
+        completedParts.set(partNumber - 1, completedPart);
+        return completedPart;
+    }
+}
diff --git a/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/async/CopyObjectMetadata.java b/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/async/CopyObjectMetadata.java
new file mode 100644
index 0000000000000..55b75d5b751a4
--- /dev/null
+++ b/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/async/CopyObjectMetadata.java
@@ -0,0 +1,44 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.repositories.s3.async;
+
+import java.util.Map;
+
+/**
+ * Copy object metadata of an object to be copied from a remote directory to another remote directory.
+ */
+public class CopyObjectMetadata {
+    private Integer partCount;
+    private Map<String, String> metadata;
+    private Map<Integer, Long> partSizes;
+
+    public Integer getPartCount() {
+        return partCount;
+    }
+
+    public void setPartCount(Integer partCount) {
+        this.partCount = partCount;
+    }
+
+    public Map<String, String> getMetadata() {
+        return metadata;
+    }
+
+    public void setMetadata(Map<String, String> metadata) {
+        this.metadata = metadata;
+    }
+
+    public Map<Integer, Long> getPartSizes() {
+        return partSizes;
+    }
+
+    public void setPartSizes(Map<Integer, Long> partSizes) {
+        this.partSizes = partSizes;
+    }
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/gateway/RecoveryFromGatewayIT.java b/server/src/internalClusterTest/java/org/opensearch/gateway/RecoveryFromGatewayIT.java
index 8d0a3b5788a70..1bb72f60e1719 100644
--- a/server/src/internalClusterTest/java/org/opensearch/gateway/RecoveryFromGatewayIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/gateway/RecoveryFromGatewayIT.java
@@ -214,7 +214,8 @@ private Map<String, long[]> assertAndCapturePrimaryTerms(Map<String, long[]> pre
         for (final IndexMetadata indexMetadata : state.metadata().indices().values()) {
             final String index = indexMetadata.getIndex().getName();
             final long[] previous = previousTerms.get(index);
-            final long[] current = IntStream.range(0, indexMetadata.getNumberOfShards()).mapToLong(indexMetadata::primaryTerm).toArray();
+            final long[] current = IntStream.range(0, indexMetadata.getNumberOfShards())
+                .mapToLong(indexMetadata::primaryTerm).toArray();
             if (previous == null) {
                 result.put(index, current);
             } else {
diff --git a/server/src/internalClusterTest/java/org/opensearch/index/shard/IndexShardIT.java b/server/src/internalClusterTest/java/org/opensearch/index/shard/IndexShardIT.java
index f97950f2652a3..de8dab0853da0 100644
--- a/server/src/internalClusterTest/java/org/opensearch/index/shard/IndexShardIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/index/shard/IndexShardIT.java
@@ -716,7 +716,8 @@ public static final IndexShard newIndexShard(
             null,
             DefaultRemoteStoreSettings.INSTANCE,
             false,
-            IndexShardTestUtils.getFakeDiscoveryNodes(initializingShardRouting)
+            IndexShardTestUtils.getFakeDiscoveryNodes(initializingShardRouting),
+            null
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/multipart/mocks/MockFsAsyncBlobContainer.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/multipart/mocks/MockFsAsyncBlobContainer.java
index 875f11203281a..3656b1a54ca6c 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/multipart/mocks/MockFsAsyncBlobContainer.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/multipart/mocks/MockFsAsyncBlobContainer.java
@@ -28,7 +28,9 @@
 import java.nio.file.Path;
 import java.nio.file.StandardOpenOption;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -145,6 +147,11 @@ public boolean remoteIntegrityCheckSupported() {
         return true;
     }
 
+    @Override
+    public Set<String> copyFilesFromSrcRemote(Set<String> files, AsyncMultiStreamBlobContainer blobContainer) {
+        return new HashSet<>();
+    }
+
     private boolean isSegmentFile(String filename) {
         return !filename.endsWith(".tlog") && !filename.endsWith(".ckp");
     }
diff --git a/server/src/internalClusterTest/java/org/opensearch/shardsplit/InPlaceShardSplitIT.java b/server/src/internalClusterTest/java/org/opensearch/shardsplit/InPlaceShardSplitIT.java
new file mode 100644
index 0000000000000..84b772c0bb7c9
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/shardsplit/InPlaceShardSplitIT.java
@@ -0,0 +1,243 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.shardsplit;
+
+import org.opensearch.OpenSearchParseException;
+import org.opensearch.action.admin.cluster.health.ClusterHealthResponse;
+import org.opensearch.action.admin.indices.split.InPlaceShardSplitRequest;
+import org.opensearch.action.admin.indices.split.InPlaceShardSplitResponse;
+import org.opensearch.action.admin.indices.stats.ShardStats;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.health.ClusterHealthStatus;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.ShardRange;
+import org.opensearch.cluster.routing.RoutingNode;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.common.Priority;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.index.mapper.MapperService;
+import org.opensearch.rest.RestRequest;
+import org.opensearch.rest.action.cat.RestClusterManagerAction;
+import org.opensearch.search.SearchHit;
+import org.opensearch.search.SearchHits;
+import org.opensearch.test.BackgroundIndexer;
+import org.opensearch.test.OpenSearchIntegTestCase;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+import static org.hamcrest.Matchers.*;
+import static org.opensearch.index.query.QueryBuilders.matchAllQuery;
+import static org.opensearch.index.query.QueryBuilders.matchQuery;
+import static org.opensearch.test.OpenSearchIntegTestCase.ClusterScope;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertHitCount;
+
+@ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST)
+public class InPlaceShardSplitIT extends OpenSearchIntegTestCase {
+    private final TimeValue ACCEPTABLE_RELOCATION_TIME = new TimeValue(5, TimeUnit.MINUTES);
+    private Set<Integer> triggerSplitAndGetChildShardIds(int parentShardId, int numberOfSplits) {
+
+        InPlaceShardSplitRequest request = new InPlaceShardSplitRequest("test", parentShardId, numberOfSplits);
+        InPlaceShardSplitResponse response = client().admin().indices().inPlaceShardSplit(request).actionGet();
+        assertAcked(response);
+        ClusterState clusterState = client().admin().cluster().prepareState().get().getState();
+        IndexMetadata indexMetadata = clusterState.metadata().index("test");
+        ShardRange[] shards = indexMetadata.getSplitShardsMetadata().getChildShardsOfParent(parentShardId);
+        return Arrays.stream(shards).map(ShardRange::getShardId).collect(Collectors.toSet());
+    }
+
+    private void waitForSplit(int numberOfSplits, Set<Integer> childShardIds, int parentShardId, int replicaCount) throws Exception {
+        final long maxWaitTimeMs = Math.max(190 * 1000, 200 * numberOfSplits);
+
+        assertBusy(() -> {
+            ShardStats[] shardStats = client().admin().indices().prepareStats("test").get().getShards();
+            int startedChildShards = 0;
+            for (ShardStats shardStat : shardStats) {
+                ShardRouting shardRouting = shardStat.getShardRouting();
+                if (shardRouting.primary() && shardRouting.shardId().id() == parentShardId && shardStat.getShardRouting().started()) {
+                    throw new Exception("Splitting of shard id " + parentShardId + " failed ");
+                } else if (childShardIds.contains(shardStat.getShardRouting().shardId().id())) {
+                    startedChildShards++;
+                }
+            }
+            if (numberOfSplits + (replicaCount + 1) == startedChildShards) {
+                System.out.println();
+            }
+            assertEquals(numberOfSplits * (replicaCount + 1), startedChildShards);
+//            ClusterState state = client().admin().cluster().prepareState().get().getState();
+//            int startedChildReplicas = 0;
+//            for (RoutingNode routingNode : state.getRoutingNodes()) {
+//                for (ShardRouting shardRouting : routingNode) {
+//                    if (shardRouting.isStartedChildReplica()) {
+//                        startedChildReplicas++;
+//                    }
+//                }
+//            }
+//            assertEquals(numberOfSplits * (replicaCount), startedChildReplicas);
+        }, maxWaitTimeMs, TimeUnit.MILLISECONDS);
+
+        assertClusterHealth();
+        logger.info("Shard split completed");
+    }
+
+    private void assertClusterHealth() {
+        ClusterHealthResponse clusterHealthResponse = client().admin()
+            .cluster()
+            .prepareHealth()
+            .setWaitForEvents(Priority.LANGUID)
+            .setWaitForNoRelocatingShards(true)
+            .setTimeout(ACCEPTABLE_RELOCATION_TIME)
+            .execute()
+            .actionGet();
+        assertThat(clusterHealthResponse, notNullValue());
+        assertThat(clusterHealthResponse.isTimedOut(), equalTo(false));
+        assertThat(clusterHealthResponse.status(), equalTo(RestStatus.OK));
+        assertThat(clusterHealthResponse.getStatus(), equalTo(ClusterHealthStatus.GREEN));
+    }
+
+    private void verifyAfterSplit(long totalIndexedDocs, Set<String> ids, int parentShardId, Set<Integer> childShardIds) throws InterruptedException {
+        ClusterState clusterState = internalCluster().clusterManagerClient().admin().cluster().prepareState().get().getState();
+        IndexMetadata indexMetadata = clusterState.metadata().index("test");
+        assertNotNull(indexMetadata.getSplitShardsMetadata().getChildShardsOfParent(parentShardId));
+        ShardRange[] shards = indexMetadata.getSplitShardsMetadata().getChildShardsOfParent(parentShardId);
+        Set<Integer> currentShardIds = Arrays.stream(shards).map(ShardRange::getShardId).collect(Collectors.toSet());
+        assertEquals(childShardIds, currentShardIds);
+        Set<Integer> newServingChildShardIds = new HashSet<>();
+        for (int shardId : currentShardIds) {
+            assertTrue(parentShardId != shardId);
+            if (childShardIds.contains(shardId)) newServingChildShardIds.add(shardId);
+        }
+        assertEquals(childShardIds, newServingChildShardIds);
+
+        refresh("test");
+//        ShardStats[] stats = client().admin().indices().prepareStats("test").get().getShards();
+//        for (ShardStats shardStat : stats) {
+//            logger.info("Shard stat after first indexing of shard " + shardStat.getShardRouting().shardId().id() + " docs: "
+//                + shardStat.getStats().indexing.getTotal().getIndexCount() + " seq no: " + shardStat.getSeqNoStats().getMaxSeqNo());
+//        }
+        SearchHits hits = client().prepareSearch("test")
+            .setQuery(matchAllQuery())
+            .setSize((int) totalIndexedDocs)
+            .seqNoAndPrimaryTerm(true)
+            .setPreference("_primary")
+            .storedFields()
+            .execute()
+            .actionGet()
+            .getHits();
+
+        assertThat(hits.getTotalHits().value, equalTo(totalIndexedDocs));
+        for (String id : ids) {
+            // Make sure there is no duplicate doc.
+            assertHitCount(client().prepareSearch("test").setSize(0)
+                .setQuery(matchQuery("_id", id)).setPreference("_primary").get(), 1);
+        }
+        logger.info("Shard is split successfully");
+    }
+
+    public void testShardSplit() throws Exception {
+        internalCluster().startNodes(2);
+        int replicaCount = 2;
+        prepareCreate("test", Settings.builder().put("index.number_of_shards", 3)
+            .put("index.number_of_replicas", replicaCount)).get();
+        ensureGreen();
+        int numDocs = scaledRandomIntBetween(200, 500);
+        try (BackgroundIndexer indexer = new BackgroundIndexer("test", MapperService.SINGLE_MAPPING_NAME, client(), numDocs, 4)) {
+            logger.info("--> waiting for {} docs to be indexed ...", numDocs);
+            waitForDocs(numDocs, indexer);
+            logger.info("--> {} docs indexed", numDocs);
+            numDocs = scaledRandomIntBetween(5000, 7500);
+            logger.info("--> Allow indexer to index [{}] more documents", numDocs);
+            indexer.continueIndexing(numDocs);
+            int numberOfSplits = 3, parentShardId = 0;
+            logger.info("--> starting split...");
+            Set<Integer> childShardIds = triggerSplitAndGetChildShardIds(parentShardId, numberOfSplits);
+            logger.info("--> waiting for shards to be split ...");
+            waitForSplit(numberOfSplits, childShardIds, parentShardId, replicaCount);
+            logger.info("--> Shard split completed ...");
+            logger.info("--> Verifying after split ...");
+            indexer.pauseIndexing();
+            indexer.stopAndAwaitStopped();
+            verifyAfterSplit(indexer.totalIndexedDocs(), indexer.getIds(), parentShardId, childShardIds);
+        }
+    }
+
+    public void testSplittingShardHavingNonEmptyCommit() throws Exception {
+        internalCluster().startNodes(2);
+        int replicaCount = 0;
+        prepareCreate("test", Settings.builder().put("index.number_of_shards", 1)
+            .put("index.number_of_replicas", replicaCount)).get();
+        ensureGreen();
+        int numDocs = scaledRandomIntBetween(200, 2500);
+        try (BackgroundIndexer indexer = new BackgroundIndexer("test", MapperService.SINGLE_MAPPING_NAME, client(), numDocs, 4)) {
+            indexer.setIgnoreIndexingFailures(false);
+            logger.info("--> waiting for {} docs to be indexed ...", numDocs);
+            waitForDocs(numDocs, indexer);
+            logger.info("--> {} docs indexed", numDocs);
+
+            flushAndRefresh("test");
+            ShardStats shardStat = client().admin().indices().prepareStats("test").get().getShards()[0];
+            assertEquals(numDocs, shardStat.getCommitStats().getNumDocs());
+
+            numDocs = scaledRandomIntBetween(200, 1000);
+            logger.debug("--> Allow indexer to index [{}] more documents", numDocs);
+            indexer.continueIndexing(numDocs);
+            int numberOfSplits = 3, parentShardId = 0;
+            logger.info("--> starting split...");
+            Set<Integer> childShardIds = triggerSplitAndGetChildShardIds(parentShardId, numberOfSplits);
+            logger.info("--> waiting for shards to be split ...");
+            waitForSplit(numberOfSplits, childShardIds, parentShardId, replicaCount);
+            logger.info("--> Shard split completed ...");
+            logger.info("--> Verifying after split ...");
+            indexer.pauseIndexing();
+            indexer.stopAndAwaitStopped();
+            verifyAfterSplit(indexer.totalIndexedDocs(), indexer.getIds(), parentShardId, childShardIds);
+        }
+    }
+
+    public void testSplittingShardWithNoTranslogReplay() throws Exception {
+        internalCluster().startNodes(2);
+        int replicaCount = 0;
+        prepareCreate("test", Settings.builder().put("index.number_of_shards", 1)
+            .put("index.number_of_replicas", replicaCount)).get();
+        ensureGreen();
+        int numDocs = scaledRandomIntBetween(200, 2500);
+        try (BackgroundIndexer indexer = new BackgroundIndexer("test", MapperService.SINGLE_MAPPING_NAME, client(), numDocs, 4)) {
+            indexer.setIgnoreIndexingFailures(false);
+            logger.info("--> waiting for {} docs to be indexed ...", numDocs);
+            waitForDocs(numDocs, indexer);
+            logger.info("--> {} docs indexed", numDocs);
+            indexer.stopAndAwaitStopped();
+            flushAndRefresh("test");
+            ShardStats shardStat = client().admin().indices().prepareStats("test").get().getShards()[0];
+            assertEquals(numDocs, shardStat.getCommitStats().getNumDocs());
+
+            int numberOfSplits = 3, parentShardId = 0;
+            logger.info("--> starting split...");
+            Set<Integer> childShardIds = triggerSplitAndGetChildShardIds(parentShardId, numberOfSplits);
+            logger.info("--> waiting for shards to be split ...");
+            waitForSplit(numberOfSplits, childShardIds, parentShardId, replicaCount);
+            logger.info("--> Shard split completed ...");
+            logger.info("--> Verifying after split ...");
+            verifyAfterSplit(indexer.totalIndexedDocs(), indexer.getIds(), parentShardId, childShardIds);
+        }
+    }
+
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/shardsplit/InPlaceShardSplitRemoteStoreIT.java b/server/src/internalClusterTest/java/org/opensearch/shardsplit/InPlaceShardSplitRemoteStoreIT.java
new file mode 100644
index 0000000000000..f67e09e686d6f
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/shardsplit/InPlaceShardSplitRemoteStoreIT.java
@@ -0,0 +1,52 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.shardsplit;
+
+import org.junit.After;
+import org.junit.Before;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.test.OpenSearchIntegTestCase;
+
+import java.nio.file.Path;
+
+import static org.opensearch.remotestore.RemoteStoreBaseIntegTestCase.remoteStoreClusterSettings;
+import static org.opensearch.test.OpenSearchIntegTestCase.ClusterScope;
+
+@ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST)
+public class InPlaceShardSplitRemoteStoreIT extends InPlaceShardSplitIT {
+
+
+    private static final String REPOSITORY_NAME = "test-remote-store-repo";
+    protected Path absolutePath;
+
+    @Override
+    protected Settings nodeSettings(int nodeOrdinal) {
+        if (absolutePath == null) {
+            absolutePath = randomRepoPath().toAbsolutePath();
+        }
+        return Settings.builder()
+            .put(super.nodeSettings(nodeOrdinal))
+            .put(remoteStoreClusterSettings(REPOSITORY_NAME, absolutePath))
+            .build();
+    }
+
+    protected boolean segmentReplicationWithRemoteEnabled() {
+        return true;
+    }
+
+    @Before
+    public void setup() {
+        internalCluster().startClusterManagerOnlyNode();
+    }
+
+    @After
+    public void teardown() {
+        clusterAdmin().prepareCleanupRepository(REPOSITORY_NAME).get();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/OpenSearchServerException.java b/server/src/main/java/org/opensearch/OpenSearchServerException.java
index 0ee3debb4819a..e33d70cb14002 100644
--- a/server/src/main/java/org/opensearch/OpenSearchServerException.java
+++ b/server/src/main/java/org/opensearch/OpenSearchServerException.java
@@ -1219,6 +1219,14 @@ public static void registerExceptions() {
                 V_2_18_0
             )
         );
+        registerExceptionHandle(
+            new OpenSearchExceptionHandle(
+                org.opensearch.action.PrimaryShardSplitException.class,
+                org.opensearch.action.PrimaryShardSplitException::new,
+                172,
+                V_3_0_0
+            )
+        );
         registerExceptionHandle(
             new OpenSearchExceptionHandle(
                 org.opensearch.cluster.block.IndexCreateBlockException.class,
@@ -1227,5 +1235,6 @@ public static void registerExceptions() {
                 V_3_0_0
             )
         );
+
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/ActionModule.java b/server/src/main/java/org/opensearch/action/ActionModule.java
index 1e6eae87af53a..a575454cfcd24 100644
--- a/server/src/main/java/org/opensearch/action/ActionModule.java
+++ b/server/src/main/java/org/opensearch/action/ActionModule.java
@@ -196,6 +196,8 @@
 import org.opensearch.action.admin.indices.shards.TransportIndicesShardStoresAction;
 import org.opensearch.action.admin.indices.shrink.ResizeAction;
 import org.opensearch.action.admin.indices.shrink.TransportResizeAction;
+import org.opensearch.action.admin.indices.split.InPlaceShardSplitAction;
+import org.opensearch.action.admin.indices.split.TransportInPlaceShardSplitAction;
 import org.opensearch.action.admin.indices.stats.IndicesStatsAction;
 import org.opensearch.action.admin.indices.stats.TransportIndicesStatsAction;
 import org.opensearch.action.admin.indices.template.delete.DeleteComponentTemplateAction;
@@ -404,6 +406,7 @@
 import org.opensearch.rest.action.admin.indices.RestGetIndicesAction;
 import org.opensearch.rest.action.admin.indices.RestGetMappingAction;
 import org.opensearch.rest.action.admin.indices.RestGetSettingsAction;
+import org.opensearch.rest.action.admin.indices.RestInPlaceShardSplitHandler;
 import org.opensearch.rest.action.admin.indices.RestIndexDeleteAliasesAction;
 import org.opensearch.rest.action.admin.indices.RestIndexPutAliasAction;
 import org.opensearch.rest.action.admin.indices.RestIndicesAliasesAction;
@@ -668,6 +671,7 @@ public <Request extends ActionRequest, Response extends ActionResponse> void reg
         actions.register(IndicesShardStoresAction.INSTANCE, TransportIndicesShardStoresAction.class);
         actions.register(CreateIndexAction.INSTANCE, TransportCreateIndexAction.class);
         actions.register(ResizeAction.INSTANCE, TransportResizeAction.class);
+        actions.register(InPlaceShardSplitAction.INSTANCE, TransportInPlaceShardSplitAction.class);
         actions.register(RolloverAction.INSTANCE, TransportRolloverAction.class);
         actions.register(DeleteIndexAction.INSTANCE, TransportDeleteIndexAction.class);
         actions.register(GetIndexAction.INSTANCE, TransportGetIndexAction.class);
@@ -869,6 +873,7 @@ public void initRestHandlers(Supplier<DiscoveryNodes> nodesInCluster) {
         registerHandler.accept(new RestResizeHandler.RestShrinkIndexAction());
         registerHandler.accept(new RestResizeHandler.RestSplitIndexAction());
         registerHandler.accept(new RestResizeHandler.RestCloneIndexAction());
+        registerHandler.accept(new RestInPlaceShardSplitHandler());
         registerHandler.accept(new RestRolloverIndexAction());
         registerHandler.accept(new RestDeleteIndexAction());
         registerHandler.accept(new RestCloseIndexAction());
diff --git a/server/src/main/java/org/opensearch/action/PrimaryShardSplitException.java b/server/src/main/java/org/opensearch/action/PrimaryShardSplitException.java
new file mode 100644
index 0000000000000..4da8dec0da8e7
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/PrimaryShardSplitException.java
@@ -0,0 +1,29 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action;
+
+import org.opensearch.OpenSearchException;
+import org.opensearch.core.common.io.stream.StreamInput;
+
+import java.io.IOException;
+
+/**
+ * Exception thrown when waiting writes fail due to primary shard getting split.
+ *
+ * @opensearch.internal
+ */
+public class PrimaryShardSplitException extends OpenSearchException {
+    public PrimaryShardSplitException(String msg) {
+        super(msg);
+    }
+
+    public PrimaryShardSplitException(final StreamInput in) throws IOException {
+        super(in);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/allocation/ClusterAllocationExplanation.java b/server/src/main/java/org/opensearch/action/admin/cluster/allocation/ClusterAllocationExplanation.java
index 70a223d60069a..565ec8fdb5657 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/allocation/ClusterAllocationExplanation.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/allocation/ClusterAllocationExplanation.java
@@ -200,6 +200,10 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
                         + "to node ["
                         + relocationTargetNode.getName()
                         + "], wait until relocation has completed";
+                } else if (shardRouting.state() == ShardRoutingState.SPLITTING) {
+                    explanation = "the shard is in the process of splitting on node ["
+                        + currentNode.getName()
+                        + "] wait until split has completed";
                 } else {
                     assert shardRouting.state() == ShardRoutingState.INITIALIZING;
                     explanation = "the shard is in the process of initializing on node ["
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/split/InPlaceShardSplitAction.java b/server/src/main/java/org/opensearch/action/admin/indices/split/InPlaceShardSplitAction.java
new file mode 100644
index 0000000000000..8e189e3672954
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/split/InPlaceShardSplitAction.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.split;
+
+import org.opensearch.action.ActionType;
+
+public class InPlaceShardSplitAction extends ActionType<InPlaceShardSplitResponse> {
+
+    public static final InPlaceShardSplitAction INSTANCE = new InPlaceShardSplitAction();
+    public static final String NAME = "indices:admin/in_place_shard_split";
+
+    private InPlaceShardSplitAction() {
+        super(NAME, InPlaceShardSplitResponse::new);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/split/InPlaceShardSplitClusterStateUpdateRequest.java b/server/src/main/java/org/opensearch/action/admin/indices/split/InPlaceShardSplitClusterStateUpdateRequest.java
new file mode 100644
index 0000000000000..3e430d922a254
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/split/InPlaceShardSplitClusterStateUpdateRequest.java
@@ -0,0 +1,42 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.split;
+
+import org.opensearch.cluster.ack.ClusterStateUpdateRequest;
+
+public class InPlaceShardSplitClusterStateUpdateRequest extends ClusterStateUpdateRequest<InPlaceShardSplitClusterStateUpdateRequest> {
+
+    private final String index;
+    private final int shardId;
+    private final int splitInto;
+    private final String cause;
+
+    public InPlaceShardSplitClusterStateUpdateRequest(String cause, String index, int shardId, int splitInto) {
+        this.index = index;
+        this.shardId = shardId;
+        this.splitInto = splitInto;
+        this.cause = cause;
+    }
+
+    public String getIndex() {
+        return index;
+    }
+
+    public int getSplitInto() {
+        return splitInto;
+    }
+
+    public String cause() {
+        return cause;
+    }
+
+    public int getShardId() {
+        return shardId;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/split/InPlaceShardSplitRequest.java b/server/src/main/java/org/opensearch/action/admin/indices/split/InPlaceShardSplitRequest.java
new file mode 100644
index 0000000000000..fd7ca93476c20
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/split/InPlaceShardSplitRequest.java
@@ -0,0 +1,133 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.split;
+
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.action.support.master.AcknowledgedRequest;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.ParseField;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.xcontent.ObjectParser;
+import org.opensearch.core.xcontent.ToXContentObject;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParser;
+
+import java.io.IOException;
+
+import static org.opensearch.action.ValidateActions.addValidationError;
+import static org.opensearch.core.xcontent.ConstructingObjectParser.constructorArg;
+
+/**
+ * Request class to split a local shard of an index
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class InPlaceShardSplitRequest extends AcknowledgedRequest<InPlaceShardSplitRequest> implements ToXContentObject {
+    public static final ObjectParser<InPlaceShardSplitRequest, Void> PARSER = new ObjectParser<>("in_place_shard_split_request");
+
+    static {
+        PARSER.declareString(constructorArg(), new ParseField("index"));
+        PARSER.declareInt(constructorArg(), new ParseField("shard_id"));
+        PARSER.declareInt(constructorArg(), new ParseField("number_of_splits"));
+    }
+
+    private final String index;
+    private final int shardId;
+    private final int numberOfSplits;
+    private boolean shouldStoreResult;
+
+    public InPlaceShardSplitRequest(StreamInput in) throws IOException {
+        super(in);
+        index = in.readString();
+        shardId = in.readInt();
+        numberOfSplits = in.readInt();
+    }
+
+    public InPlaceShardSplitRequest(String index, int shardId, int numberOfSplits) {
+        this.index = index;
+        this.shardId = shardId;
+        this.numberOfSplits = numberOfSplits;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        super.writeTo(out);
+        out.writeString(index);
+        out.writeInt(shardId);
+        out.writeInt(numberOfSplits);
+    }
+
+    /**
+     * Should this task store its result after it has finished?
+     */
+    public void setShouldStoreResult(boolean shouldStoreResult) {
+        this.shouldStoreResult = shouldStoreResult;
+    }
+
+    @Override
+    public boolean getShouldStoreResult() {
+        return shouldStoreResult;
+    }
+
+    public String getIndex() {
+        return index;
+    }
+
+    public int getShardId() {
+        return shardId;
+    }
+
+    public int getSplitInto() {
+        return numberOfSplits;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        {
+            builder.field("index", index);
+            builder.field("shard_id", shardId);
+            builder.field("number_of_splits", numberOfSplits);
+        }
+        builder.endObject();
+        return builder;
+    }
+
+    public void fromXContent(XContentParser parser) throws IOException {
+        PARSER.parse(parser, this, null);
+    }
+
+    @Override
+    public String toString() {
+        return "In place shard split of index [" + index + "] shard id [" + shardId + "] into [" + numberOfSplits + "] shards";
+    }
+
+    @Override
+    public ActionRequestValidationException validate() {
+        ActionRequestValidationException validationException = null;
+        if (index == null) {
+            validationException = addValidationError("index is missing", null);
+        }
+        if (shardId < 0) {
+            validationException = addValidationError("invalid shard id", validationException);
+        }
+        if (numberOfSplits < 2) {
+            validationException = addValidationError("invalid split configuration.", validationException);
+        }
+
+        return validationException;
+    }
+
+    @Override
+    public String getDescription() {
+        return this.toString();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/split/InPlaceShardSplitResponse.java b/server/src/main/java/org/opensearch/action/admin/indices/split/InPlaceShardSplitResponse.java
new file mode 100644
index 0000000000000..eb290a8e08cf4
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/split/InPlaceShardSplitResponse.java
@@ -0,0 +1,88 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.split;
+
+import org.opensearch.action.support.master.AcknowledgedResponse;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.ParseField;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.xcontent.ConstructingObjectParser;
+import org.opensearch.core.xcontent.XContentParser;
+
+import java.io.IOException;
+import java.util.Objects;
+
+import static org.opensearch.core.xcontent.ConstructingObjectParser.constructorArg;
+
+/**
+ * Split response of online split of a local shard
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class InPlaceShardSplitResponse extends AcknowledgedResponse {
+
+    private static final ConstructingObjectParser<InPlaceShardSplitResponse, Void> PARSER = new ConstructingObjectParser<>(
+        "in_place_shard_split_response",
+        true,
+        args -> new InPlaceShardSplitResponse((boolean) args[0], (String) args[1], (int) args[2], (int) args[3])
+    );
+
+    static {
+        declareAcknowledgedField(PARSER);
+        PARSER.declareString(constructorArg(), new ParseField("index"));
+        PARSER.declareInt(constructorArg(), new ParseField("shard_id"));
+        PARSER.declareInt(constructorArg(), new ParseField("number_of_splits"));
+    }
+
+    private final String index;
+    private final int shardId;
+    private final int numberOfSplits;
+
+    InPlaceShardSplitResponse(StreamInput in) throws IOException {
+        super(in);
+        index = in.readString();
+        shardId = in.readInt();
+        numberOfSplits = in.readInt();
+    }
+
+    public InPlaceShardSplitResponse(final boolean acknowledged, final String index, final int shardId, final int numberOfSplits) {
+        super(acknowledged);
+        this.index = index;
+        this.shardId = shardId;
+        this.numberOfSplits = numberOfSplits;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        super.writeTo(out);
+        out.writeString(index);
+        out.writeInt(shardId);
+        out.writeInt(numberOfSplits);
+    }
+
+    public static InPlaceShardSplitResponse fromXContent(XContentParser parser) {
+        return PARSER.apply(parser, null);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (super.equals(o)) {
+            InPlaceShardSplitResponse that = (InPlaceShardSplitResponse) o;
+            return shardId == that.shardId && numberOfSplits == that.numberOfSplits && Objects.equals(index, that.index);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(super.hashCode(), index, shardId, numberOfSplits);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/split/TransportInPlaceShardSplitAction.java b/server/src/main/java/org/opensearch/action/admin/indices/split/TransportInPlaceShardSplitAction.java
new file mode 100644
index 0000000000000..a7feaf83ae5c6
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/split/TransportInPlaceShardSplitAction.java
@@ -0,0 +1,162 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.split;
+
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.clustermanager.TransportClusterManagerNodeAction;
+import org.opensearch.client.Client;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.block.ClusterBlockException;
+import org.opensearch.cluster.block.ClusterBlockLevel;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
+import org.opensearch.cluster.metadata.MetadataInPlaceShardSplitService;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.inject.Inject;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.index.IndexNotFoundException;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportService;
+
+import java.io.IOException;
+
+public class TransportInPlaceShardSplitAction extends TransportClusterManagerNodeAction<
+    InPlaceShardSplitRequest,
+    InPlaceShardSplitResponse> {
+
+    private final MetadataInPlaceShardSplitService metadataInPlaceShardSplitService;
+    private final Client client;
+
+    @Override
+    protected String executor() {
+        return ThreadPool.Names.SAME;
+    }
+
+    @Override
+    protected InPlaceShardSplitResponse read(StreamInput in) throws IOException {
+        return new InPlaceShardSplitResponse(in);
+    }
+
+    @Override
+    protected ClusterBlockException checkBlock(InPlaceShardSplitRequest request, ClusterState state) {
+        ClusterBlockException clusterBlockException = state.blocks().globalBlockedException(ClusterBlockLevel.METADATA_WRITE);
+        if (clusterBlockException != null) {
+            return clusterBlockException;
+        }
+        clusterBlockException = state.blocks().indexBlockedException(ClusterBlockLevel.METADATA_WRITE, request.getIndex());
+        if (clusterBlockException != null) {
+            return clusterBlockException;
+        }
+
+        clusterBlockException = state.blocks().indexBlockedException(ClusterBlockLevel.WRITE, request.getIndex());
+        if (clusterBlockException != null) {
+            return clusterBlockException;
+        }
+
+        return null;
+    }
+
+    @Inject
+    public TransportInPlaceShardSplitAction(
+        TransportService transportService,
+        ClusterService clusterService,
+        ThreadPool threadPool,
+        MetadataInPlaceShardSplitService metadataInPlaceShardSplitService,
+        ActionFilters actionFilters,
+        IndexNameExpressionResolver indexNameExpressionResolver,
+        Client client
+    ) {
+        this(
+            InPlaceShardSplitAction.NAME,
+            transportService,
+            clusterService,
+            threadPool,
+            metadataInPlaceShardSplitService,
+            actionFilters,
+            indexNameExpressionResolver,
+            client
+        );
+    }
+
+    protected TransportInPlaceShardSplitAction(
+        String actionName,
+        TransportService transportService,
+        ClusterService clusterService,
+        ThreadPool threadPool,
+        MetadataInPlaceShardSplitService metadataInPlaceShardSplitService,
+        ActionFilters actionFilters,
+        IndexNameExpressionResolver indexNameExpressionResolver,
+        Client client
+    ) {
+        super(
+            actionName,
+            transportService,
+            clusterService,
+            threadPool,
+            actionFilters,
+            InPlaceShardSplitRequest::new,
+            indexNameExpressionResolver
+        );
+        this.metadataInPlaceShardSplitService = metadataInPlaceShardSplitService;
+        this.client = client;
+    }
+
+    @Override
+    protected void clusterManagerOperation(
+        final InPlaceShardSplitRequest inPlaceShardSplitRequest,
+        final ClusterState clusterState,
+        final ActionListener<InPlaceShardSplitResponse> listener
+    ) {
+        final String index = indexNameExpressionResolver.resolveDateMathExpression(inPlaceShardSplitRequest.getIndex());
+        ShardId shardId = clusterState.getRoutingTable().shardRoutingTable(index, inPlaceShardSplitRequest.getShardId()).shardId();
+        InPlaceShardSplitClusterStateUpdateRequest updateRequest = prepareInPlaceShardSplitRequest(
+            inPlaceShardSplitRequest,
+            shardId,
+            clusterState
+        );
+        metadataInPlaceShardSplitService.split(
+            updateRequest,
+            ActionListener.map(
+                listener,
+                response -> new InPlaceShardSplitResponse(
+                    response.isAcknowledged(),
+                    index,
+                    shardId.id(),
+                    inPlaceShardSplitRequest.getSplitInto()
+                )
+            )
+        );
+    }
+
+    private InPlaceShardSplitClusterStateUpdateRequest prepareInPlaceShardSplitRequest(
+        InPlaceShardSplitRequest inPlaceShardSplitRequest,
+        ShardId shardId,
+        final ClusterState state
+    ) {
+        final IndexMetadata metadata = state.metadata().index(inPlaceShardSplitRequest.getIndex());
+        if (metadata == null) {
+            throw new IndexNotFoundException(inPlaceShardSplitRequest.getIndex());
+        }
+
+        if (IndexMetadata.INDEX_READ_ONLY_SETTING.get(metadata.getSettings()) == true) {
+            throw new IllegalArgumentException(
+                "in place shard split cannot be triggered on index [" + shardId.getIndexName() + "] as it has read-only block"
+            );
+        }
+
+        return new InPlaceShardSplitClusterStateUpdateRequest(
+            "in_place_shard_split_request",
+            shardId.getIndexName(),
+            shardId.id(),
+            inPlaceShardSplitRequest.getSplitInto()
+        ).masterNodeTimeout(inPlaceShardSplitRequest.clusterManagerNodeTimeout()).ackTimeout(inPlaceShardSplitRequest.ackTimeout());
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/bulk/TransportBulkAction.java b/server/src/main/java/org/opensearch/action/bulk/TransportBulkAction.java
index db509afb68da9..87a7c26dc37d3 100644
--- a/server/src/main/java/org/opensearch/action/bulk/TransportBulkAction.java
+++ b/server/src/main/java/org/opensearch/action/bulk/TransportBulkAction.java
@@ -42,6 +42,7 @@
 import org.opensearch.action.ActionRunnable;
 import org.opensearch.action.DocWriteRequest;
 import org.opensearch.action.DocWriteResponse;
+import org.opensearch.action.PrimaryShardSplitException;
 import org.opensearch.action.RoutingMissingException;
 import org.opensearch.action.admin.indices.create.AutoCreateAction;
 import org.opensearch.action.admin.indices.create.CreateIndexRequest;
@@ -49,8 +50,10 @@
 import org.opensearch.action.index.IndexRequest;
 import org.opensearch.action.ingest.IngestActionForwarder;
 import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.ActiveShardCount;
 import org.opensearch.action.support.AutoCreateIndex;
 import org.opensearch.action.support.HandledTransportAction;
+import org.opensearch.action.support.WriteRequest;
 import org.opensearch.action.update.TransportUpdateAction;
 import org.opensearch.action.update.UpdateRequest;
 import org.opensearch.action.update.UpdateResponse;
@@ -65,6 +68,7 @@
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
 import org.opensearch.cluster.metadata.MappingMetadata;
 import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.routing.ShardIterator;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.inject.Inject;
 import org.opensearch.common.lease.Releasable;
@@ -505,6 +509,7 @@ private final class BulkOperation extends ActionRunnable<BulkResponse> {
         private final long startTimeNanos;
         private final ClusterStateObserver observer;
         private final Map<String, IndexNotFoundException> indicesThatCannotBeCreated;
+        private final boolean reDriveOnChildShards;
 
         BulkOperation(
             Task task,
@@ -512,7 +517,8 @@ private final class BulkOperation extends ActionRunnable<BulkResponse> {
             ActionListener<BulkResponse> listener,
             AtomicArray<BulkItemResponse> responses,
             long startTimeNanos,
-            Map<String, IndexNotFoundException> indicesThatCannotBeCreated
+            Map<String, IndexNotFoundException> indicesThatCannotBeCreated,
+            boolean reDriveOnChildShards
         ) {
             super(listener);
             this.task = task;
@@ -521,11 +527,15 @@ private final class BulkOperation extends ActionRunnable<BulkResponse> {
             this.startTimeNanos = startTimeNanos;
             this.indicesThatCannotBeCreated = indicesThatCannotBeCreated;
             this.observer = new ClusterStateObserver(clusterService, bulkRequest.timeout(), logger, threadPool.getThreadContext());
+            this.reDriveOnChildShards = reDriveOnChildShards;
         }
 
         @Override
         protected void doRun() {
             assert bulkRequest != null;
+            final ActiveShardCount bulkActiveShardCount = bulkRequest.waitForActiveShards();
+            final WriteRequest.RefreshPolicy refreshPolicy = bulkRequest.getRefreshPolicy();
+            final TimeValue timeout = bulkRequest.timeout();
             final ClusterState clusterState = observer.setAndGetObservedState();
             if (handleBlockExceptions(clusterState)) {
                 return;
@@ -590,9 +600,15 @@ protected void doRun() {
                             throw new AssertionError("request type not supported: [" + docWriteRequest.opType() + "]");
                     }
 
-                    ShardId shardId = clusterService.operationRouting()
-                        .indexShards(clusterState, concreteIndex.getName(), docWriteRequest.id(), docWriteRequest.routing())
-                        .shardId();
+                    ShardId shardId;
+                    if (reDriveOnChildShards) {
+                        shardId = clusterService.operationRouting().shardWithRecoveringChild(clusterState,
+                            concreteIndex.getName(), docWriteRequest.id(), docWriteRequest.routing(), clusterState.routingTable().index(concreteIndex).getIndex());
+                    } else {
+                        shardId = clusterService.operationRouting()
+                            .indexShards(clusterState, concreteIndex.getName(), docWriteRequest.id(), docWriteRequest.routing())
+                            .shardId();
+                    }
                     List<BulkItemRequest> shardRequests = requestsByShard.computeIfAbsent(shardId, shard -> new ArrayList<>());
                     shardRequests.add(new BulkItemRequest(i, docWriteRequest));
                 } catch (OpenSearchParseException | IllegalArgumentException | RoutingMissingException e) {
@@ -670,6 +686,48 @@ public void onResponse(BulkShardResponse bulkShardResponse) {
 
                             @Override
                             public void onFailure(Exception e) {
+                                Throwable splitEx = ExceptionsHelper.unwrap(e, PrimaryShardSplitException.class);
+                                if (splitEx != null) {
+                                    try {
+                                        reDriveOnChildShards();
+                                        return;
+                                    } catch (Exception ex) {
+                                        logger.error("Unexpected error occurred on attempting to re-drive " +
+                                            "bulk request after primary split", ex);
+                                    }
+                                }
+                                setBulkItemFailures(e);
+                                if (counter.decrementAndGet() == 0) {
+                                    finishHim();
+                                }
+                            }
+
+                            private void reDriveOnChildShards() {
+                                BulkRequest bulkRequestForRedrive = new BulkRequest();
+                                bulkRequestForRedrive.waitForActiveShards(bulkActiveShardCount);
+                                bulkRequestForRedrive.timeout(timeout);
+                                bulkRequestForRedrive.setRefreshPolicy(refreshPolicy);
+                                requests.forEach(request -> bulkRequestForRedrive.add(request.request()));
+                                ActionListener<BulkResponse> reDriveListener = ActionListener.wrap(reDriveResponses -> {
+                                    reDriveResponses.forEach(reDriveResponse -> {
+                                        responses.set(requests.get(reDriveResponse.getItemId()).id(), reDriveResponse);
+                                    });
+                                    if (counter.decrementAndGet() == 0) {
+                                        publishResponse();
+                                    }
+                                }, reDriveException -> {
+                                    // We don't expect any item level failure here. So, we fail all items.
+                                    setBulkItemFailures(reDriveException);
+                                    if (counter.decrementAndGet() == 0) {
+                                        finishHim();
+                                    }
+                                });
+                                BulkOperation bulkOperation = new BulkOperation(task, bulkRequestForRedrive, reDriveListener,
+                                    new AtomicArray<>(requests.size()), startTimeNanos, indicesThatCannotBeCreated, true);
+                                bulkOperation.run();
+                            }
+
+                            private void setBulkItemFailures(Exception e) {
                                 // create failures for all relevant requests
                                 for (BulkItemRequest request : requests) {
                                     final String indexName = concreteIndices.getConcreteIndex(request.index()).getName();
@@ -683,14 +741,14 @@ public void onFailure(Exception e) {
                                     docStatusStats.inc(bulkItemResponse.status());
                                     responses.set(request.id(), bulkItemResponse);
                                 }
-
-                                if (counter.decrementAndGet() == 0) {
-                                    finishHim();
-                                }
                             }
 
                             private void finishHim() {
                                 indicesService.addDocStatusStats(docStatusStats);
+                                publishResponse();
+                            }
+
+                            private void publishResponse() {
                                 listener.onResponse(
                                     new BulkResponse(
                                         responses.toArray(new BulkItemResponse[responses.length()]),
@@ -810,7 +868,7 @@ void executeBulk(
          * We are not wrapping the listener here to capture the response codes for performance benefits. It will
          * be saving us an iteration over the responses array
          */
-        new BulkOperation(task, bulkRequest, listener, responses, startTimeNanos, indicesThatCannotBeCreated).run();
+        new BulkOperation(task, bulkRequest, listener, responses, startTimeNanos, indicesThatCannotBeCreated, false).run();
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/action/bulk/TransportShardBulkAction.java b/server/src/main/java/org/opensearch/action/bulk/TransportShardBulkAction.java
index fdba8a42c0170..b74bd75313f2a 100644
--- a/server/src/main/java/org/opensearch/action/bulk/TransportShardBulkAction.java
+++ b/server/src/main/java/org/opensearch/action/bulk/TransportShardBulkAction.java
@@ -64,6 +64,8 @@
 import org.opensearch.cluster.metadata.MappingMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.routing.AllocationId;
+import org.opensearch.cluster.routing.OperationRouting;
+import org.opensearch.cluster.routing.RecoverySource;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.collect.Tuple;
@@ -113,6 +115,7 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.Executor;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.LongSupplier;
@@ -139,6 +142,7 @@ public class TransportShardBulkAction extends TransportWriteAction<BulkShardRequ
     private final MappingUpdatedAction mappingUpdatedAction;
     private final SegmentReplicationPressureService segmentReplicationPressureService;
     private final RemoteStorePressureService remoteStorePressureService;
+    public static final AtomicBoolean debugRequest = new AtomicBoolean();
 
     /**
      * This action is used for performing primary term validation. With remote translog enabled, the translogs would
@@ -375,8 +379,10 @@ public void performOn(
             long primaryTerm,
             long globalCheckpoint,
             long maxSeqNoOfUpdatesOrDeletes,
-            ActionListener<ReplicationOperation.ReplicaResponse> listener
+            ActionListener<ReplicationOperation.ReplicaResponse> listener,
+            boolean replicatingToChild
         ) {
+            assert replicatingToChild == false : "Primary term validation is attempted on child replication";
             String nodeId = replica.currentNodeId();
             final DiscoveryNode node = clusterService.state().nodes().get(nodeId);
             if (node == null) {
@@ -467,6 +473,9 @@ public static void performOnPrimary(
 
             @Override
             protected void doRun() throws Exception {
+//                if (TransportShardBulkAction.debugRequest.get() && request.shardId().id() == 0) {
+//                    logger.info("Executing bulk request " + request.items().length);
+//                }
                 while (context.hasMoreOperationsToExecute()) {
                     if (executeBulkItemRequest(
                         context,
@@ -482,8 +491,15 @@ protected void doRun() throws Exception {
                     }
                     assert context.isInitial(); // either completed and moved to next or reset
                 }
+//                if (TransportShardBulkAction.debugRequest.get() && request.shardId().id() == 0) {
+//                    logger.info("Executing finish of bulk request" + request.items().length);
+//                }
+
                 // We're done, there's no more operations to execute so we resolve the wrapped listener
                 finishRequest();
+//                if (TransportShardBulkAction.debugRequest.get() && request.shardId().id() == 0) {
+//                    logger.info("Finished bulk request" + request.items().length);
+//                }
             }
 
             @Override
@@ -564,13 +580,21 @@ static boolean executeBulkItemRequest(
         ActionListener<Void> itemDoneListener
     ) throws Exception {
         final DocWriteRequest.OpType opType = context.getCurrent().opType();
-
+//        if (context.getBulkShardRequest().shardId().id() == 0) {
+//            logger.info("Executing bulk item");
+//        }
         final UpdateHelper.Result updateResult;
         if (opType == DocWriteRequest.OpType.UPDATE) {
+//            if (context.getBulkShardRequest().shardId().id() == 0) {
+//                logger.info("Executing item update");
+//            }
             final UpdateRequest updateRequest = (UpdateRequest) context.getCurrent();
             try {
                 updateResult = updateHelper.prepare(updateRequest, context.getPrimary(), nowInMillisSupplier);
             } catch (Exception failure) {
+//                if (context.getBulkShardRequest().shardId().id() == 0) {
+//                    logger.info("Exception in item update");
+//                }
                 // we may fail translating a update to index or delete operation
                 // we use index result to communicate failure while translating update request
                 final Engine.Result result = new Engine.IndexResult(failure, updateRequest.version());
@@ -596,6 +620,9 @@ static boolean executeBulkItemRequest(
                     context.getPrimary().noopUpdate();
                     context.markOperationAsNoOp(updateResult.action());
                     context.markAsCompleted(context.getExecutionResult());
+//                    if (context.getBulkShardRequest().shardId().id() == 0) {
+//                        logger.info("No-Op in item update");
+//                    }
                     return true;
                 default:
                     throw new IllegalStateException("Illegal update operation " + updateResult.getResponseResult());
@@ -612,6 +639,9 @@ static boolean executeBulkItemRequest(
         final boolean isDelete = context.getRequestToExecute().opType() == DocWriteRequest.OpType.DELETE;
         final Engine.Result result;
         if (isDelete) {
+//            if (context.getBulkShardRequest().shardId().id() == 0) {
+//                logger.info("Executing bulk item delete");
+//            }
             final DeleteRequest request = context.getRequestToExecute();
             result = primary.applyDeleteOperationOnPrimary(
                 version,
@@ -632,8 +662,10 @@ static boolean executeBulkItemRequest(
                 request.isRetry()
             );
         }
+//        if (primary.isPrimaryMode() && primary.shardId().id() == 0) {
+//            logger.info("Indexing operation sequence " + result.getSeqNo() + " on shard 0.");
+//        }
         if (result.getResultType() == Engine.Result.Type.MAPPING_UPDATE_REQUIRED) {
-
             try {
                 primary.mapperService()
                     .merge(
@@ -825,6 +857,29 @@ public static Translog.Location performOnReplica(BulkShardRequest request, Index
             final BulkItemRequest item = request.items()[i];
             final BulkItemResponse response = item.getPrimaryResponse();
             final Engine.Result operationResult;
+            boolean discardOperation = false;
+            if (replica.getParentShardId() != null) {
+                IndexMetadata indexMetadata = replica.indexSettings().getIndexMetadata();
+                // Discard operations belonging to a different child shard. This can happen during in-place shard
+                // split recovery where after all child shards are added to replication tracker, bulk
+                // operations are replicated to all child primaries.
+                int computedShardId = OperationRouting.generateShardId(indexMetadata, item.request().id(),
+                    item.request().routing(), true);
+                discardOperation = computedShardId != replica.shardId().id();
+//                if (replica.routingEntry().isStartedChildReplica()) {
+//                    logger.info("Processing seq no." + response.getResponse().getSeqNo() + " on replica child "
+//                        + replica.shardId().id() + ", discarding " + discardOperation);
+//                } else
+
+            }
+//            if (replica.routingEntry().shardId().id() > 2 && replica.routingEntry().started()) {
+//                logger.info("Processing seq no. on child replica" + response.getResponse().getSeqNo() + " on replica child "
+//                    + replica.shardId().id() + ", discarding " + discardOperation);
+//            }
+//            if (replica.routingEntry().shardId().id() == 1 || replica.routingEntry().shardId().id() == 2) {
+//                logger.info("Processing seq no. on other child replica" + response.getResponse().getSeqNo() + " on replica child ");
+//            }
+
             if (item.getPrimaryResponse().isFailed()) {
                 if (response.getFailure().getSeqNo() == SequenceNumbers.UNASSIGNED_SEQ_NO) {
                     continue; // ignore replication as we didn't generate a sequence number for this request.
@@ -847,7 +902,15 @@ public static Translog.Location performOnReplica(BulkShardRequest request, Index
                     continue; // ignore replication as it's a noop
                 }
                 assert response.getResponse().getSeqNo() != SequenceNumbers.UNASSIGNED_SEQ_NO;
-                operationResult = performOpOnReplica(response.getResponse(), item.request(), replica);
+                if (discardOperation) {
+                    operationResult = replica.markSeqNoAsNoop(
+                        response.getResponse().getSeqNo(),
+                        response.getResponse().getPrimaryTerm(),
+                        Translog.NoOp.FILLING_GAPS
+                    );
+                } else {
+                    operationResult = performOpOnReplica(response.getResponse(), item.request(), replica);
+                }
             }
             assert operationResult != null : "operation result must never be null when primary response has no failure";
             location = syncOperationResultOrThrow(operationResult, location);
diff --git a/server/src/main/java/org/opensearch/action/search/TransportSearchAction.java b/server/src/main/java/org/opensearch/action/search/TransportSearchAction.java
index dfec2e1fda738..fd5a2028b9ae3 100644
--- a/server/src/main/java/org/opensearch/action/search/TransportSearchAction.java
+++ b/server/src/main/java/org/opensearch/action/search/TransportSearchAction.java
@@ -49,6 +49,7 @@
 import org.opensearch.cluster.block.ClusterBlockLevel;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
+import org.opensearch.cluster.metadata.ShardRange;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.routing.GroupShardsIterator;
@@ -1451,18 +1452,33 @@ static List<SearchShardIterator> getLocalLocalShardsIteratorFromPointInTime(
             final SearchContextIdForNode perNode = entry.getValue();
             if (Strings.isEmpty(perNode.getClusterAlias())) {
                 final ShardId shardId = entry.getKey();
-                OperationRouting.getShards(clusterState, shardId);
-                final List<String> targetNodes = Collections.singletonList(perNode.getNode());
-                iterators.add(
-                    new SearchShardIterator(
-                        localClusterAlias,
-                        shardId,
-                        targetNodes,
-                        originalIndices,
-                        perNode.getSearchContextId(),
-                        keepAlive
-                    )
-                );
+                IndexMetadata indexMetadata = clusterState.metadata().getIndexSafe(shardId.getIndex());
+                final List<ShardId> allShardIds;
+                if (indexMetadata.getSplitShardsMetadata().isEmptyParentShard(shardId.id())) {
+                    ShardRange[] childShards = indexMetadata.getSplitShardsMetadata().getChildShardsOfParent(shardId.id());
+                    allShardIds = new ArrayList<>();
+                    for (ShardRange childShard : childShards) {
+                        allShardIds.add(new ShardId(shardId.getIndex(), childShard.getShardId()));
+                    }
+                } else {
+                    allShardIds = List.of(shardId);
+                }
+
+                allShardIds.forEach(searchableShardId -> {
+                    OperationRouting.getShards(clusterState, searchableShardId);
+                    final List<String> targetNodes = Collections.singletonList(perNode.getNode());
+                    iterators.add(
+                        new SearchShardIterator(
+                            localClusterAlias,
+                            searchableShardId,
+                            targetNodes,
+                            originalIndices,
+                            perNode.getSearchContextId(),
+                            keepAlive
+                        )
+                    );
+                });
+
             }
         }
         return iterators;
diff --git a/server/src/main/java/org/opensearch/action/support/replication/ReplicationModeAwareProxy.java b/server/src/main/java/org/opensearch/action/support/replication/ReplicationModeAwareProxy.java
index 9f5e31a9c6926..e29a5d8133582 100644
--- a/server/src/main/java/org/opensearch/action/support/replication/ReplicationModeAwareProxy.java
+++ b/server/src/main/java/org/opensearch/action/support/replication/ReplicationModeAwareProxy.java
@@ -75,7 +75,8 @@ ReplicationMode determineReplicationMode(ShardRouting shardRouting, ShardRouting
             return ReplicationMode.NO_REPLICATION;
         }
         // Perform full replication during primary relocation
-        if (primaryRouting.relocating() && shardRouting.isSameAllocation(primaryRouting.getTargetRelocatingShard())) {
+        if ((primaryRouting.relocating() && shardRouting.isSameAllocation(primaryRouting.getTargetRelocatingShard())) ||
+            (primaryRouting.splitting()) && shardRouting.isSplitTargetOf(primaryRouting)) {
             return ReplicationMode.FULL_REPLICATION;
         }
         /*
diff --git a/server/src/main/java/org/opensearch/action/support/replication/ReplicationOperation.java b/server/src/main/java/org/opensearch/action/support/replication/ReplicationOperation.java
index 9f69d41d83f5b..ffbf830794966 100644
--- a/server/src/main/java/org/opensearch/action/support/replication/ReplicationOperation.java
+++ b/server/src/main/java/org/opensearch/action/support/replication/ReplicationOperation.java
@@ -37,6 +37,7 @@
 import org.opensearch.ExceptionsHelper;
 import org.opensearch.OpenSearchException;
 import org.opensearch.action.UnavailableShardsException;
+import org.opensearch.action.bulk.TransportShardBulkAction;
 import org.opensearch.action.support.ActiveShardCount;
 import org.opensearch.action.support.RetryableAction;
 import org.opensearch.action.support.TransportActions;
@@ -64,6 +65,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
+import java.util.UUID;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Consumer;
@@ -102,6 +104,8 @@ public class ReplicationOperation<
     private final TimeValue retryTimeout;
     private final long primaryTerm;
     private final ReplicationProxy<ReplicaRequest> replicationProxy;
+    private final String id = UUID.randomUUID().toString();
+    private final List<String> pendingActionsList = new ArrayList<>();
 
     // exposed for tests
     private final ActionListener<PrimaryResultT> resultListener;
@@ -155,12 +159,16 @@ public void execute() throws Exception {
 
         totalShards.incrementAndGet();
         pendingActions.incrementAndGet(); // increase by 1 until we finish all primary coordination
+        pendingActionsList.add("Primary-action");
         primary.perform(request, ActionListener.wrap(this::handlePrimaryResult, this::finishAsFailed));
     }
 
     private void handlePrimaryResult(final PrimaryResultT primaryResult) {
         this.primaryResult = primaryResult;
         final ReplicaRequest replicaRequest = primaryResult.replicaRequest();
+//        if (TransportShardBulkAction.debugRequest.get() && request.shardId().id() == 0) {
+//            logger.info("Handling primary result for id: " + id);
+//        }
         if (replicaRequest != null) {
             if (logger.isTraceEnabled()) {
                 logger.trace("[{}] op [{}] completed on primary for request [{}]", primary.routingEntry().shardId(), opType, request);
@@ -181,6 +189,9 @@ private void handlePrimaryResult(final PrimaryResultT primaryResult) {
             final ReplicationGroup replicationGroup = primary.getReplicationGroup();
             final PendingReplicationActions pendingReplicationActions = primary.getPendingReplicationActions();
             markUnavailableShardsAsStale(replicaRequest, replicationGroup);
+//            if (TransportShardBulkAction.debugRequest.get() && request.shardId().id() == 0) {
+//                logger.info("Performing on replicas for id " + id);
+//            }
             performOnReplicas(replicaRequest, globalCheckpoint, maxSeqNoOfUpdatesOrDeletes, replicationGroup, pendingReplicationActions);
         }
         primaryResult.runPostReplicationActions(new ActionListener<Void>() {
@@ -189,7 +200,13 @@ private void handlePrimaryResult(final PrimaryResultT primaryResult) {
             public void onResponse(Void aVoid) {
                 successfulShards.incrementAndGet();
                 try {
+//                    if (TransportShardBulkAction.debugRequest.get() && request.shardId().id() == 0) {
+//                        logger.info("Updating checkpoints for id: " + id);
+//                    }
                     updateCheckPoints(primary.routingEntry(), primary::localCheckpoint, primary::globalCheckpoint);
+//                    if (TransportShardBulkAction.debugRequest.get() && request.shardId().id() == 0) {
+//                        logger.info("Updated checkpoints for id: " + id);
+//                    }
                 } finally {
                     decPendingAndFinishIfNeeded();
                 }
@@ -209,11 +226,18 @@ private void markUnavailableShardsAsStale(ReplicaRequest replicaRequest, Replica
         // if inSyncAllocationIds contains allocation ids of shards that don't exist in RoutingTable, mark copies as stale
         for (String allocationId : replicationGroup.getUnavailableInSyncShards()) {
             pendingActions.incrementAndGet();
+            pendingActionsList.add("Mark-unavailable-shard-as-stale");
+            if (TransportShardBulkAction.debugRequest.get() && request.shardId().id() == 0) {
+                logger.info("Marking unavailable shards for id: " + id);
+            }
             replicasProxy.markShardCopyAsStaleIfNeeded(
                 replicaRequest.shardId(),
                 allocationId,
                 primaryTerm,
-                ActionListener.wrap(r -> decPendingAndFinishIfNeeded(), ReplicationOperation.this::onNoLongerPrimary)
+                ActionListener.wrap(r -> {
+                    logger.info("Marked unavailable shards for id: " + id);
+                    decPendingAndFinishIfNeeded();
+                }, ReplicationOperation.this::onNoLongerPrimary)
             );
         }
     }
@@ -258,6 +282,10 @@ private void performOnReplica(
         }
         totalShards.incrementAndGet();
         pendingActions.incrementAndGet();
+        pendingActionsList.add("Replica-action for replica " + replicationProxyRequest.getShardRouting().shardId().id());
+//        if (TransportShardBulkAction.debugRequest.get() && request.shardId().id() == 0) {
+//            logger.info("Performing on replica for id: " + id + " on replica " + replicationProxyRequest.getShardRouting().shardId().id());
+//        }
         final ActionListener<ReplicaResponse> replicationListener = new ActionListener<ReplicaResponse>() {
             @Override
             public void onResponse(ReplicaResponse response) {
@@ -266,6 +294,9 @@ public void onResponse(ReplicaResponse response) {
                     updateCheckPoints(shard, response::localCheckpoint, response::globalCheckpoint);
                 } finally {
                     decPendingAndFinishIfNeeded();
+//                    if (TransportShardBulkAction.debugRequest.get() && request.shardId().id() == 0) {
+//                        logger.info("Performed on replica for id: " + id + " on replica " + + replicationProxyRequest.getShardRouting().shardId().id());
+//                    }
                 }
             }
 
@@ -296,12 +327,20 @@ public void onFailure(Exception replicaException) {
                     );
                 }
                 String message = String.format(Locale.ROOT, "failed to perform %s on replica %s", opType, shard);
+                if (TransportShardBulkAction.debugRequest.get() && request.shardId().id() == 0) {
+                    logger.info("Failed on replica operation "+ opType+" for id: " + id + " on replica " + replicationProxyRequest.getShardRouting().shardId().id());
+                }
                 replicasProxy.failShardIfNeeded(
                     shard,
                     primaryTerm,
                     message,
                     replicaException,
-                    ActionListener.wrap(r -> decPendingAndFinishIfNeeded(), ReplicationOperation.this::onNoLongerPrimary)
+                    ActionListener.wrap(r -> {
+                        decPendingAndFinishIfNeeded();
+                        if (TransportShardBulkAction.debugRequest.get() && request.shardId().id() == 0) {
+                            logger.info("Performed Failed on replica operation "+ opType+" for id: " + id + " on replica " + replicationProxyRequest.getShardRouting().shardId().id());
+                        }
+                    }, ReplicationOperation.this::onNoLongerPrimary)
                 );
             }
 
@@ -424,6 +463,9 @@ private void decPendingAndFinishIfNeeded() {
         if (pendingActions.decrementAndGet() == 0) {
             finish();
         }
+//        if (TransportShardBulkAction.debugRequest.get() && request.shardId().id() == 0) {
+//            logger.info("Pending action count for id " + id + " is:" + pendingActions.get() + " and list is: " + pendingActionsList);
+//        }
     }
 
     private void finish() {
@@ -436,7 +478,13 @@ private void finish() {
                 shardReplicaFailures.toArray(failuresArray);
             }
             primaryResult.setShardInfo(new ReplicationResponse.ShardInfo(totalShards.get(), successfulShards.get(), failuresArray));
+//            if (TransportShardBulkAction.debugRequest.get() && request.shardId().id() == 0) {
+//                logger.info("Sending operation result for id: " + id);
+//            }
             resultListener.onResponse(primaryResult);
+//            if (TransportShardBulkAction.debugRequest.get() && request.shardId().id() == 0) {
+//                logger.info("Sent operation result for id: " + id);
+//            }
         }
     }
 
@@ -559,7 +607,8 @@ void performOn(
             long primaryTerm,
             long globalCheckpoint,
             long maxSeqNoOfUpdatesOrDeletes,
-            ActionListener<ReplicaResponse> listener
+            ActionListener<ReplicaResponse> listener,
+            boolean replicatingToChild
         );
 
         /**
diff --git a/server/src/main/java/org/opensearch/action/support/replication/ReplicationProxy.java b/server/src/main/java/org/opensearch/action/support/replication/ReplicationProxy.java
index 4812984732134..82c500c559801 100644
--- a/server/src/main/java/org/opensearch/action/support/replication/ReplicationProxy.java
+++ b/server/src/main/java/org/opensearch/action/support/replication/ReplicationProxy.java
@@ -87,7 +87,8 @@ protected Consumer<ActionListener<ReplicaResponse>> getReplicasProxyConsumer(
             proxyRequest.getPrimaryTerm(),
             proxyRequest.getGlobalCheckpoint(),
             proxyRequest.getMaxSeqNoOfUpdatesOrDeletes(),
-            listener
+            listener,
+            proxyRequest.isReplicatingToChild()
         );
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/support/replication/ReplicationProxyRequest.java b/server/src/main/java/org/opensearch/action/support/replication/ReplicationProxyRequest.java
index c65e55867f706..868366c6a6f00 100644
--- a/server/src/main/java/org/opensearch/action/support/replication/ReplicationProxyRequest.java
+++ b/server/src/main/java/org/opensearch/action/support/replication/ReplicationProxyRequest.java
@@ -9,6 +9,7 @@
 package org.opensearch.action.support.replication;
 
 import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.core.index.shard.ShardId;
 
 import java.util.Objects;
 
@@ -32,6 +33,7 @@ public class ReplicationProxyRequest<ReplicaRequest> {
     private final ReplicaRequest replicaRequest;
 
     private final long primaryTerm;
+    private final boolean replicatingToChild;
 
     private ReplicationProxyRequest(
         ShardRouting shardRouting,
@@ -49,6 +51,7 @@ private ReplicationProxyRequest(
         this.pendingReplicationActions = Objects.requireNonNull(pendingReplicationActions);
         this.replicaRequest = Objects.requireNonNull(replicaRequest);
         this.primaryTerm = primaryTerm;
+        this.replicatingToChild = primaryRouting.splitting() && shardRouting.isSplitTargetOf(primaryRouting);
     }
 
     public ShardRouting getShardRouting() {
@@ -79,6 +82,10 @@ public long getPrimaryTerm() {
         return primaryTerm;
     }
 
+    public boolean isReplicatingToChild() {
+        return replicatingToChild;
+    }
+
     /**
      * Builder of ReplicationProxyRequest.
      *
diff --git a/server/src/main/java/org/opensearch/action/support/replication/ReplicationRequest.java b/server/src/main/java/org/opensearch/action/support/replication/ReplicationRequest.java
index 92e50f7a476f3..7a15a728aea7e 100644
--- a/server/src/main/java/org/opensearch/action/support/replication/ReplicationRequest.java
+++ b/server/src/main/java/org/opensearch/action/support/replication/ReplicationRequest.java
@@ -201,7 +201,7 @@ protected Request routedBasedOnClusterVersion(long routedBasedOnClusterVersion)
         return (Request) this;
     }
 
-    long routedBasedOnClusterVersion() {
+    public long routedBasedOnClusterVersion() {
         return routedBasedOnClusterVersion;
     }
 
diff --git a/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java b/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java
index 49a96603f6802..b0d71159c8402 100644
--- a/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java
+++ b/server/src/main/java/org/opensearch/action/support/replication/TransportReplicationAction.java
@@ -36,8 +36,11 @@
 import org.apache.lucene.store.AlreadyClosedException;
 import org.opensearch.ExceptionsHelper;
 import org.opensearch.OpenSearchException;
+import org.opensearch.Version;
 import org.opensearch.action.ActionListenerResponseHandler;
+import org.opensearch.action.PrimaryShardSplitException;
 import org.opensearch.action.UnavailableShardsException;
+import org.opensearch.action.bulk.TransportShardBulkAction;
 import org.opensearch.action.support.ActionFilters;
 import org.opensearch.action.support.ActiveShardCount;
 import org.opensearch.action.support.ChannelActionListener;
@@ -53,6 +56,8 @@
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.routing.AllocationId;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.IndexShardRoutingTable;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.Nullable;
@@ -140,6 +145,7 @@ public abstract class TransportReplicationAction<
      */
     public static final String PRIMARY_ACTION_SUFFIX = "[p]";
     public static final String REPLICA_ACTION_SUFFIX = "[r]";
+    public static final String CHILD_REPLICA_ACTION_SUFFIX = "[c]";
 
     protected final ThreadPool threadPool;
     protected final TransportService transportService;
@@ -152,6 +158,7 @@ public abstract class TransportReplicationAction<
 
     // package private for testing
     protected final String transportReplicaAction;
+    protected final String transportChildReplicaAction;
     protected final String transportPrimaryAction;
 
     private final boolean syncGlobalCheckpointAfterOperation;
@@ -247,6 +254,7 @@ protected TransportReplicationAction(
 
         this.transportPrimaryAction = actionName + PRIMARY_ACTION_SUFFIX;
         this.transportReplicaAction = actionName + REPLICA_ACTION_SUFFIX;
+        this.transportChildReplicaAction = actionName + CHILD_REPLICA_ACTION_SUFFIX;
 
         this.initialRetryBackoffBound = REPLICATION_INITIAL_RETRY_BACKOFF_BOUND.get(settings);
         this.retryTimeout = REPLICATION_RETRY_TIMEOUT.get(settings);
@@ -267,6 +275,15 @@ protected TransportReplicationAction(
             this::handleReplicaRequest
         );
 
+        transportService.registerRequestHandler(
+            transportChildReplicaAction,
+            executor,
+            true,
+            true,
+            in -> new ConcreteChildReplicaRequest<>(replicaRequestReader, in),
+            this::handleChildReplicaRequest
+        );
+
         this.transportOptions = transportOptions(settings);
 
         this.syncGlobalCheckpointAfterOperation = syncGlobalCheckpointAfterOperation;
@@ -342,7 +359,8 @@ public void performOn(
                 long primaryTerm,
                 long globalCheckpoint,
                 long maxSeqNoOfUpdatesOrDeletes,
-                ActionListener<ReplicationOperation.ReplicaResponse> listener
+                ActionListener<ReplicationOperation.ReplicaResponse> listener,
+                boolean replicatingToChild
             ) {
                 throw new UnsupportedOperationException("Primary term validation is not available for " + actionName);
             }
@@ -544,7 +562,10 @@ protected void doRun() throws Exception {
             acquirePrimaryOperationPermit(
                 indexShard,
                 primaryRequest.getRequest(),
-                ActionListener.wrap(releasable -> runWithPrimaryShardReference(new PrimaryShardReference(indexShard, releasable)), e -> {
+                ActionListener.wrap(releasable -> {
+                    PrimaryShardReference p = new PrimaryShardReference(indexShard, releasable);
+                    runWithPrimaryShardReference(p);
+                }, e -> {
                     if (e instanceof ShardNotInPrimaryModeException) {
                         onFailure(new ReplicationOperation.RetryOnPrimaryException(shardId, "shard is not in primary mode", e));
                     } else {
@@ -567,6 +588,12 @@ void runWithPrimaryShardReference(final PrimaryShardReference primaryShardRefere
 
                 if (primaryShardReference.isRelocated()) {
                     primaryShardReference.close(); // release shard operation lock as soon as possible
+                    if (primaryShardReference.routingEntry().splitting()) {
+                        // This means shard was being split and was in relocation handoff stage when replication op on primary arrived.
+                        // Write ops specifically will now get retried and will be routed to respective child shards by coordinator.
+                        throw new PrimaryShardSplitException("Primary shard is already split. Cannot perform replication operation on parent primary.");
+                    }
+
                     setPhase(replicationTask, "primary_delegation");
                     // delegate primary phase to relocation target
                     // it is safe to execute primary phase on relocation target as there are no more in-flight operations where primary
@@ -767,7 +794,25 @@ protected void handleReplicaRequest(
         );
 
         try {
-            new AsyncReplicaAction(replicaRequest, listener, (ReplicationTask) task).run();
+            new AsyncReplicaAction(replicaRequest, listener, (ReplicationTask) task, transportReplicaAction, null).run();
+        } catch (RuntimeException e) {
+            listener.onFailure(e);
+        }
+    }
+
+    protected void handleChildReplicaRequest(
+        final ConcreteChildReplicaRequest<ReplicaRequest> replicaRequest,
+        final TransportChannel channel,
+        final Task task
+    ) {
+        Releasable releasable = checkReplicaLimits(replicaRequest.getRequest());
+        ActionListener<ReplicaResponse> listener = ActionListener.runBefore(
+            new ChannelActionListener<>(channel, transportChildReplicaAction, replicaRequest),
+            releasable::close
+        );
+
+        try {
+            new AsyncReplicaAction(replicaRequest, listener, (ReplicationTask) task, transportChildReplicaAction, replicaRequest.childShardId).run();
         } catch (RuntimeException e) {
             listener.onFailure(e);
         }
@@ -802,6 +847,7 @@ public RetryOnReplicaException(StreamInput in) throws IOException {
     private final class AsyncReplicaAction extends AbstractRunnable implements ActionListener<Releasable> {
         private final ActionListener<ReplicaResponse> onCompletionListener;
         private final IndexShard replica;
+        private final String transportReplicaAction;
         /**
          * The task on the node with the replica shard.
          */
@@ -814,14 +860,17 @@ private final class AsyncReplicaAction extends AbstractRunnable implements Actio
         AsyncReplicaAction(
             ConcreteReplicaRequest<ReplicaRequest> replicaRequest,
             ActionListener<ReplicaResponse> onCompletionListener,
-            ReplicationTask task
+            ReplicationTask task,
+            String transportReplicaAction,
+            ShardId childShardId
         ) {
             this.replicaRequest = replicaRequest;
             this.onCompletionListener = onCompletionListener;
             this.task = task;
             final ShardId shardId = replicaRequest.getRequest().shardId();
             assert shardId != null : "request shardId must be set";
-            this.replica = getIndexShard(shardId);
+            this.replica = getIndexShard(Objects.requireNonNullElse(childShardId, shardId));
+            this.transportReplicaAction = transportReplicaAction;
         }
 
         @Override
@@ -1027,7 +1076,21 @@ protected void doRun() {
                 assert request.waitForActiveShards() != ActiveShardCount.DEFAULT
                     : "request waitForActiveShards must be set in resolveRequest";
 
-                final ShardRouting primary = state.getRoutingTable().shardRoutingTable(request.shardId()).primaryShard();
+                ShardRouting primary = null;
+                if (indexMetadata.getSplitShardsMetadata().isEmptyParentShard(request.shardId().id())) {
+                    // This will get retried on coordinator. Entire request will be re-driven on respective child shards.
+                    // Since, we are throwing a custom exception, coordinator will re-drive it explicitly on child shards
+                    // even if coordinator is also stale and yet to receive update from cluster manager.
+                    throw new PrimaryShardSplitException("Primary shard is already split. Cannot perform replication operation on parent primary.");
+                } else {
+                    IndexRoutingTable indexRoutingTable = state.getRoutingTable().index(request.shardId().getIndex());
+                    IndexShardRoutingTable shardRoutingTable = indexRoutingTable.shard(request.shardId().id());
+                    // Can happen in case where new shards (child shards) are recovered and cluster manager has updated
+                    // index metadata but coordinator node hasn't yet received the updated state.
+                    if (shardRoutingTable != null) {
+                        primary = state.getRoutingTable().shardRoutingTable(request.shardId()).primaryShard();
+                    }
+                }
                 if (primary == null || primary.active() == false) {
                     logger.trace(
                         "primary shard [{}] is not yet active, scheduling a retry: action [{}], request [{}], "
@@ -1217,14 +1280,17 @@ void finishAsFailed(Exception failure) {
         }
 
         void finishWithUnexpectedFailure(Exception failure) {
-            logger.warn(
-                () -> new ParameterizedMessage(
-                    "unexpected error during the primary phase for action [{}], request [{}]",
-                    actionName,
-                    request
-                ),
-                failure
-            );
+            if (!(failure instanceof PrimaryShardSplitException)) {
+                // Skip log in case of primary shard split as write requests are going to be retried.
+                logger.warn(
+                    () -> new ParameterizedMessage(
+                        "unexpected error during the primary phase for action [{}], request [{}]",
+                        actionName,
+                        request
+                    ),
+                    failure
+                );
+            }
             if (finished.compareAndSet(false, true)) {
                 setPhase(task, "failed");
                 listener.onFailure(failure);
@@ -1447,7 +1513,8 @@ public void performOn(
             final long primaryTerm,
             final long globalCheckpoint,
             final long maxSeqNoOfUpdatesOrDeletes,
-            final ActionListener<ReplicationOperation.ReplicaResponse> listener
+            final ActionListener<ReplicationOperation.ReplicaResponse> listener,
+            final boolean replicatingToChild
         ) {
             String nodeId = replica.currentNodeId();
             final DiscoveryNode node = clusterService.state().nodes().get(nodeId);
@@ -1455,18 +1522,30 @@ public void performOn(
                 listener.onFailure(new NoNodeAvailableException("unknown node [" + nodeId + "]"));
                 return;
             }
-            final ConcreteReplicaRequest<ReplicaRequest> replicaRequest = new ConcreteReplicaRequest<>(
-                request,
-                replica.allocationId().getId(),
-                primaryTerm,
-                globalCheckpoint,
-                maxSeqNoOfUpdatesOrDeletes
-            );
             final ActionListenerResponseHandler<ReplicaResponse> handler = new ActionListenerResponseHandler<>(
                 listener,
                 ReplicaResponse::new
             );
-            transportService.sendRequest(node, transportReplicaAction, replicaRequest, transportOptions, handler);
+            if (replicatingToChild == false) {
+                final ConcreteReplicaRequest<ReplicaRequest> replicaRequest = new ConcreteReplicaRequest<>(
+                    request,
+                    replica.allocationId().getId(),
+                    primaryTerm,
+                    globalCheckpoint,
+                    maxSeqNoOfUpdatesOrDeletes
+                );
+                transportService.sendRequest(node, transportReplicaAction, replicaRequest, transportOptions, handler);
+            } else {
+                final ConcreteReplicaRequest<ReplicaRequest> replicaRequest = new ConcreteChildReplicaRequest<>(
+                    request,
+                    replica.allocationId().getId(),
+                    primaryTerm,
+                    globalCheckpoint,
+                    maxSeqNoOfUpdatesOrDeletes,
+                    replica.shardId()
+                );
+                transportService.sendRequest(node, transportChildReplicaAction, replicaRequest, transportOptions, handler);
+            }
         }
 
         @Override
@@ -1604,12 +1683,64 @@ public String toString() {
         }
     }
 
+    /**
+     * Internal request for concrete child replica
+     *
+     * @opensearch.internal
+     */
+    protected static class ConcreteChildReplicaRequest<R extends TransportRequest> extends ConcreteReplicaRequest<R> {
+        private final ShardId childShardId;
+
+        public ConcreteChildReplicaRequest(Writeable.Reader<R> requestReader, StreamInput in) throws IOException {
+            super(requestReader, in);
+            childShardId = new ShardId(in);
+        }
+
+        public ConcreteChildReplicaRequest(
+            final R request,
+            final String targetAllocationID,
+            final long primaryTerm,
+            final long globalCheckpoint,
+            final long maxSeqNoOfUpdatesOrDeletes,
+            final ShardId childShardId
+        ) {
+            super(request, targetAllocationID, primaryTerm, globalCheckpoint, maxSeqNoOfUpdatesOrDeletes);
+            this.childShardId = childShardId;
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            super.writeTo(out);
+            childShardId.writeTo(out);
+        }
+
+        @Override
+        public String toString() {
+            return "ConcreteReplicaRequest{"
+                + "targetAllocationID='"
+                + getTargetAllocationID()
+                + '\''
+                + ", primaryTerm='"
+                + getPrimaryTerm()
+                + '\''
+                + ", request="
+                + getRequest()
+                + ", globalCheckpoint="
+                + getGlobalCheckpoint()
+                + ", maxSeqNoOfUpdatesOrDeletes="
+                + getMaxSeqNoOfUpdatesOrDeletes()
+                + ", childShardId="
+                + childShardId
+                + '}';
+        }
+    }
+
     /**
      * Internal request for concrete replica
      *
      * @opensearch.internal
      */
-    protected static final class ConcreteReplicaRequest<R extends TransportRequest> extends ConcreteShardRequest<R> {
+    protected static class ConcreteReplicaRequest<R extends TransportRequest> extends ConcreteShardRequest<R> {
 
         private final long globalCheckpoint;
         private final long maxSeqNoOfUpdatesOrDeletes;
diff --git a/server/src/main/java/org/opensearch/action/support/replication/TransportWriteAction.java b/server/src/main/java/org/opensearch/action/support/replication/TransportWriteAction.java
index 27f9e6dee83de..91c887c4bde73 100644
--- a/server/src/main/java/org/opensearch/action/support/replication/TransportWriteAction.java
+++ b/server/src/main/java/org/opensearch/action/support/replication/TransportWriteAction.java
@@ -55,6 +55,7 @@
 import org.opensearch.index.mapper.MapperParsingException;
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.index.shard.PrimaryShardClosedException;
+import org.opensearch.index.shard.ShardNotFoundException;
 import org.opensearch.index.translog.Translog;
 import org.opensearch.index.translog.Translog.Location;
 import org.opensearch.indices.IndicesService;
diff --git a/server/src/main/java/org/opensearch/client/IndicesAdminClient.java b/server/src/main/java/org/opensearch/client/IndicesAdminClient.java
index 588584cd8a280..9f0c96ccf7aac 100644
--- a/server/src/main/java/org/opensearch/client/IndicesAdminClient.java
+++ b/server/src/main/java/org/opensearch/client/IndicesAdminClient.java
@@ -106,6 +106,8 @@
 import org.opensearch.action.admin.indices.shrink.ResizeRequest;
 import org.opensearch.action.admin.indices.shrink.ResizeRequestBuilder;
 import org.opensearch.action.admin.indices.shrink.ResizeResponse;
+import org.opensearch.action.admin.indices.split.InPlaceShardSplitRequest;
+import org.opensearch.action.admin.indices.split.InPlaceShardSplitResponse;
 import org.opensearch.action.admin.indices.stats.IndicesStatsRequest;
 import org.opensearch.action.admin.indices.stats.IndicesStatsRequestBuilder;
 import org.opensearch.action.admin.indices.stats.IndicesStatsResponse;
@@ -787,6 +789,18 @@ public interface IndicesAdminClient extends OpenSearchClient {
      */
     void resizeIndex(ResizeRequest request, ActionListener<ResizeResponse> listener);
 
+    /**
+     * Split a given shard id into given number of shards.
+     *
+     * @return
+     */
+    ActionFuture<InPlaceShardSplitResponse> inPlaceShardSplit(InPlaceShardSplitRequest request);
+
+    /**
+     * Split a given shard id into given number of shards.
+     */
+    void inPlaceShardSplit(InPlaceShardSplitRequest request, ActionListener<InPlaceShardSplitResponse> listener);
+
     /**
      * Swaps the index pointed to by an alias given all provided conditions are satisfied
      */
diff --git a/server/src/main/java/org/opensearch/client/support/AbstractClient.java b/server/src/main/java/org/opensearch/client/support/AbstractClient.java
index f4683ab516cef..d2714a993248f 100644
--- a/server/src/main/java/org/opensearch/client/support/AbstractClient.java
+++ b/server/src/main/java/org/opensearch/client/support/AbstractClient.java
@@ -289,6 +289,9 @@
 import org.opensearch.action.admin.indices.shrink.ResizeRequest;
 import org.opensearch.action.admin.indices.shrink.ResizeRequestBuilder;
 import org.opensearch.action.admin.indices.shrink.ResizeResponse;
+import org.opensearch.action.admin.indices.split.InPlaceShardSplitAction;
+import org.opensearch.action.admin.indices.split.InPlaceShardSplitRequest;
+import org.opensearch.action.admin.indices.split.InPlaceShardSplitResponse;
 import org.opensearch.action.admin.indices.stats.IndicesStatsAction;
 import org.opensearch.action.admin.indices.stats.IndicesStatsRequest;
 import org.opensearch.action.admin.indices.stats.IndicesStatsRequestBuilder;
@@ -2041,6 +2044,16 @@ public void resizeIndex(ResizeRequest request, ActionListener<ResizeResponse> li
             execute(ResizeAction.INSTANCE, request, listener);
         }
 
+        @Override
+        public ActionFuture<InPlaceShardSplitResponse> inPlaceShardSplit(InPlaceShardSplitRequest request) {
+            return execute(InPlaceShardSplitAction.INSTANCE, request);
+        }
+
+        @Override
+        public void inPlaceShardSplit(InPlaceShardSplitRequest request, ActionListener<InPlaceShardSplitResponse> listener) {
+            execute(InPlaceShardSplitAction.INSTANCE, request, listener);
+        }
+
         @Override
         public RolloverRequestBuilder prepareRolloverIndex(String alias) {
             return new RolloverRequestBuilder(this, RolloverAction.INSTANCE).setRolloverTarget(alias);
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterModule.java b/server/src/main/java/org/opensearch/cluster/ClusterModule.java
index 9081432093106..97a24513f483f 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterModule.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterModule.java
@@ -67,6 +67,7 @@
 import org.opensearch.cluster.routing.allocation.decider.DiskThresholdDecider;
 import org.opensearch.cluster.routing.allocation.decider.EnableAllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.FilterAllocationDecider;
+import org.opensearch.cluster.routing.allocation.decider.InPlaceShardSplitAllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.MaxRetryAllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.NodeLoadAwareAllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.NodeVersionAllocationDecider;
@@ -402,6 +403,7 @@ public static Collection<AllocationDecider> createAllocationDeciders(
         addAllocationDecider(deciders, new NodeLoadAwareAllocationDecider(settings, clusterSettings));
         addAllocationDecider(deciders, new TargetPoolAllocationDecider());
         addAllocationDecider(deciders, new RemoteStoreMigrationAllocationDecider(settings, clusterSettings));
+        addAllocationDecider(deciders, new InPlaceShardSplitAllocationDecider());
 
         clusterPlugins.stream()
             .flatMap(p -> p.createAllocationDeciders(settings, clusterSettings).stream())
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterState.java b/server/src/main/java/org/opensearch/cluster/ClusterState.java
index 1e4fd2dfffe0f..507c67f7c7007 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterState.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterState.java
@@ -370,9 +370,11 @@ public String toString() {
                 .append(indexMetadata.getAliasesVersion())
                 .append("]\n");
             for (int shard = 0; shard < indexMetadata.getNumberOfShards(); shard++) {
-                sb.append(TAB).append(TAB).append(shard).append(": ");
-                sb.append("p_term [").append(indexMetadata.primaryTerm(shard)).append("], ");
-                sb.append("isa_ids ").append(indexMetadata.inSyncAllocationIds(shard)).append("\n");
+                if (indexMetadata.getSplitShardsMetadata().isEmptyParentShard(shard) == false) {
+                    sb.append(TAB).append(TAB).append(shard).append(": ");
+                    sb.append("p_term [").append(indexMetadata.primaryTerm(shard)).append("], ");
+                    sb.append("isa_ids ").append(indexMetadata.inSyncAllocationIds(shard)).append("\n");
+                }
             }
         }
         if (metadata.customs().isEmpty() == false) {
diff --git a/server/src/main/java/org/opensearch/cluster/action/shard/ShardStateAction.java b/server/src/main/java/org/opensearch/cluster/action/shard/ShardStateAction.java
index cb5749a91d448..ca38754a5bb88 100644
--- a/server/src/main/java/org/opensearch/cluster/action/shard/ShardStateAction.java
+++ b/server/src/main/java/org/opensearch/cluster/action/shard/ShardStateAction.java
@@ -37,6 +37,7 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.ExceptionsHelper;
 import org.opensearch.OpenSearchException;
+import org.opensearch.Version;
 import org.opensearch.cluster.ClusterChangedEvent;
 import org.opensearch.cluster.ClusterManagerNodeChangePredicate;
 import org.opensearch.cluster.ClusterState;
@@ -79,6 +80,7 @@
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
@@ -253,9 +255,20 @@ public void remoteShardFailed(
         @Nullable final Exception failure,
         ActionListener<Void> listener
     ) {
+        ShardRouting shardRouting = clusterService.state().getRoutingNodes().getByAllocationId(shardId, allocationId);
+        final FailedShardEntry failedShardEntry;
+        if (shardRouting == null) {
+            logger.debug("Remote shard [{}] not known to current node [{}] ", shardId, clusterService.localNode().getId());
+            failedShardEntry = new FailedShardEntry(shardId, allocationId, primaryTerm, message, failure, markAsStale,
+                null, null, null);
+        } else {
+            failedShardEntry = new FailedShardEntry(shardId, allocationId, primaryTerm, message, failure, markAsStale,
+                null, shardRouting.getParentShardId(), shardRouting.allocationId().getParentAllocationId());
+        }
+
         assert primaryTerm > 0L : "primary term should be strictly positive";
         remoteFailedShardsDeduplicator.executeOnce(
-            new FailedShardEntry(shardId, allocationId, primaryTerm, message, failure, markAsStale),
+            failedShardEntry,
             listener,
             (req, reqListener) -> sendShardAction(SHARD_FAILED_ACTION_NAME, clusterService.state(), req, reqListener)
         );
@@ -293,7 +306,10 @@ public void localShardFailed(
             0L,
             message,
             failure,
-            true
+            true,
+            null,
+            shardRouting.getParentShardId(),
+            shardRouting.allocationId().getParentAllocationId()
         );
         sendShardAction(SHARD_FAILED_ACTION_NAME, currentState, shardEntry, listener);
     }
@@ -450,6 +466,7 @@ public ClusterTasksResult<FailedShardEntry> execute(ClusterState currentState, L
             List<FailedShardEntry> tasksToBeApplied = new ArrayList<>();
             List<FailedShard> failedShardsToBeApplied = new ArrayList<>();
             List<StaleShard> staleShardsToBeApplied = new ArrayList<>();
+            int numberOfFailedChildShards = 0;
 
             for (FailedShardEntry task : tasks) {
                 IndexMetadata indexMetadata = currentState.metadata().index(task.shardId.getIndex());
@@ -458,69 +475,94 @@ public ClusterTasksResult<FailedShardEntry> execute(ClusterState currentState, L
                     logger.debug("{} ignoring shard failed task [{}] (unknown index {})", task.shardId, task, task.shardId.getIndex());
                     batchResultBuilder.success(task);
                 } else {
-                    // The primary term is 0 if the shard failed itself. It is > 0 if a write was done on a primary but was failed to be
-                    // replicated to the shard copy with the provided allocation id. In case where the shard failed itself, it's ok to just
-                    // remove the corresponding routing entry from the routing table. In case where a write could not be replicated,
-                    // however, it is important to ensure that the shard copy with the missing write is considered as stale from that point
-                    // on, which is implemented by removing the allocation id of the shard copy from the in-sync allocations set.
-                    // We check here that the primary to which the write happened was not already failed in an earlier cluster state update.
-                    // This prevents situations where a new primary has already been selected and replication failures from an old stale
-                    // primary unnecessarily fail currently active shards.
-                    if (task.primaryTerm > 0) {
-                        long currentPrimaryTerm = indexMetadata.primaryTerm(task.shardId.id());
-                        if (currentPrimaryTerm != task.primaryTerm) {
-                            assert currentPrimaryTerm > task.primaryTerm : "received a primary term with a higher term than in the "
-                                + "current cluster state (received ["
-                                + task.primaryTerm
-                                + "] but current is ["
-                                + currentPrimaryTerm
-                                + "])";
-                            logger.debug(
-                                "{} failing shard failed task [{}] (primary term {} does not match current term {})",
-                                task.shardId,
-                                task,
-                                task.primaryTerm,
-                                indexMetadata.primaryTerm(task.shardId.id())
-                            );
-                            batchResultBuilder.failure(
-                                task,
-                                new NoLongerPrimaryShardException(
-                                    task.shardId,
-                                    "primary term ["
-                                        + task.primaryTerm
-                                        + "] did not match current primary term ["
-                                        + currentPrimaryTerm
-                                        + "]"
-                                )
-                            );
+                    if (task.parentShardId != null) {
+                        ShardRouting parentShard = currentState.getRoutingNodes().getByAllocationId(task.parentShardId, task.parentAllocationId);
+                        if (parentShard == null || parentShard.splitting() == false) {
+                            batchResultBuilder.success(task);
                             continue;
                         }
-                    }
-
-                    ShardRouting matched = currentState.getRoutingTable().getByAllocationId(task.shardId, task.allocationId);
-                    if (matched == null) {
-                        Set<String> inSyncAllocationIds = indexMetadata.inSyncAllocationIds(task.shardId.id());
-                        // mark shard copies without routing entries that are in in-sync allocations set only as stale if the reason why
-                        // they were failed is because a write made it into the primary but not to this copy (which corresponds to
-                        // the check "primaryTerm > 0").
-                        if (task.primaryTerm > 0 && inSyncAllocationIds.contains(task.allocationId)) {
-                            logger.debug("{} marking shard {} as stale (shard failed task: [{}])", task.shardId, task.allocationId, task);
+                        if (Boolean.TRUE.equals(task.splitFailed)) {
                             tasksToBeApplied.add(task);
-                            staleShardsToBeApplied.add(new StaleShard(task.shardId, task.allocationId));
+                            logger.debug("{} failing split {} (shard failed task: [{}])", task.shardId, parentShard, task);
+                            for (ShardRouting childShard : parentShard.getRecoveringChildShards()) {
+                                failedShardsToBeApplied.add(new FailedShard(childShard, task.message, task.failure, task.markAsStale));
+                            }
                         } else {
-                            // tasks that correspond to non-existent shards are marked as successful
-                            logger.debug("{} ignoring shard failed task [{}] (shard does not exist anymore)", task.shardId, task);
-                            batchResultBuilder.success(task);
+                            ShardRouting childShard = currentState.getRoutingNodes().getByAllocationId(task.shardId, task.allocationId);
+                            if (childShard == null) {
+                                // We already cancelled split
+                                batchResultBuilder.success(task);
+                                continue;
+                            }
+                            tasksToBeApplied.add(task);
+                            failedShardsToBeApplied.add(new FailedShard(childShard, task.message, task.failure, task.markAsStale));
                         }
                     } else {
-                        // failing a shard also possibly marks it as stale (see IndexMetadataUpdater)
-                        logger.debug("{} failing shard {} (shard failed task: [{}])", task.shardId, matched, task);
-                        tasksToBeApplied.add(task);
-                        failedShardsToBeApplied.add(new FailedShard(matched, task.message, task.failure, task.markAsStale));
+                        // The primary term is 0 if the shard failed itself. It is > 0 if a write was done on a primary but was failed to be
+                        // replicated to the shard copy with the provided allocation id. In case where the shard failed itself, it's ok to just
+                        // remove the corresponding routing entry from the routing table. In case where a write could not be replicated,
+                        // however, it is important to ensure that the shard copy with the missing write is considered as stale from that point
+                        // on, which is implemented by removing the allocation id of the shard copy from the in-sync allocations set.
+                        // We check here that the primary to which the write happened was not already failed in an earlier cluster state update.
+                        // This prevents situations where a new primary has already been selected and replication failures from an old stale
+                        // primary unnecessarily fail currently active shards.
+                        if (task.primaryTerm > 0) {
+                            long currentPrimaryTerm = indexMetadata.primaryTerm(task.shardId.id());
+                            if (currentPrimaryTerm != task.primaryTerm) {
+                                assert currentPrimaryTerm > task.primaryTerm : "received a primary term with a higher term than in the "
+                                    + "current cluster state (received ["
+                                    + task.primaryTerm
+                                    + "] but current is ["
+                                    + currentPrimaryTerm
+                                    + "])";
+                                logger.debug(
+                                    "{} failing shard failed task [{}] (primary term {} does not match current term {})",
+                                    task.shardId,
+                                    task,
+                                    task.primaryTerm,
+                                    indexMetadata.primaryTerm(task.shardId.id())
+                                );
+                                batchResultBuilder.failure(
+                                    task,
+                                    new NoLongerPrimaryShardException(
+                                        task.shardId,
+                                        "primary term ["
+                                            + task.primaryTerm
+                                            + "] did not match current primary term ["
+                                            + currentPrimaryTerm
+                                            + "]"
+                                    )
+                                );
+                                continue;
+                            }
+                        }
+
+                        ShardRouting matched = currentState.getRoutingTable().getByAllocationId(task.shardId, task.allocationId);
+                        if (matched == null) {
+                            Set<String> inSyncAllocationIds = indexMetadata.inSyncAllocationIds(task.shardId.id());
+                            // mark shard copies without routing entries that are in in-sync allocations set only as stale if the reason why
+                            // they were failed is because a write made it into the primary but not to this copy (which corresponds to
+                            // the check "primaryTerm > 0").
+                            if (task.primaryTerm > 0 && (inSyncAllocationIds != null || inSyncAllocationIds.contains(task.allocationId))) {
+                                logger.debug("{} marking shard {} as stale (shard failed task: [{}])", task.shardId, task.allocationId, task);
+                                tasksToBeApplied.add(task);
+                                staleShardsToBeApplied.add(new StaleShard(task.shardId, task.allocationId));
+                            } else {
+                                // tasks that correspond to non-existent shards are marked as successful
+                                logger.debug("{} ignoring shard failed task [{}] (shard does not exist anymore)", task.shardId, task);
+                                batchResultBuilder.success(task);
+                            }
+                        } else {
+                            // failing a shard also possibly marks it as stale (see IndexMetadataUpdater)
+                            logger.debug("{} failing shard {} (shard failed task: [{}])", task.shardId, matched, task);
+                            tasksToBeApplied.add(task);
+                            failedShardsToBeApplied.add(new FailedShard(matched, task.message, task.failure, task.markAsStale));
+                        }
                     }
                 }
             }
-            assert tasksToBeApplied.size() == failedShardsToBeApplied.size() + staleShardsToBeApplied.size();
+            assert tasksToBeApplied.size() == failedShardsToBeApplied.size() + staleShardsToBeApplied.size()
+                - (numberOfFailedChildShards > 0 ? numberOfFailedChildShards - 1 : 0);
 
             ClusterState maybeUpdatedState = currentState;
             try {
@@ -576,6 +618,14 @@ public static class FailedShardEntry extends TransportRequest {
         final Exception failure;
         final boolean markAsStale;
 
+        @Nullable
+        final Boolean splitFailed;
+        @Nullable
+        final ShardId parentShardId;
+        @Nullable
+        final String parentAllocationId;
+
+
         FailedShardEntry(StreamInput in) throws IOException {
             super(in);
             shardId = new ShardId(in);
@@ -584,6 +634,15 @@ public static class FailedShardEntry extends TransportRequest {
             message = in.readString();
             failure = in.readException();
             markAsStale = in.readBoolean();
+            if (in.getVersion().onOrAfter(Version.V_3_0_0)) {
+                splitFailed = in.readOptionalBoolean();
+                parentShardId = in.readOptionalWriteable(ShardId::new);
+                parentAllocationId = in.readOptionalString();
+            } else {
+                splitFailed = null;
+                parentShardId = null;
+                parentAllocationId = null;
+            }
         }
 
         public FailedShardEntry(
@@ -592,7 +651,10 @@ public FailedShardEntry(
             long primaryTerm,
             String message,
             @Nullable Exception failure,
-            boolean markAsStale
+            boolean markAsStale,
+            final Boolean splitFailed,
+            final ShardId parentShardId,
+            final String parentAllocationId
         ) {
             this.shardId = shardId;
             this.allocationId = allocationId;
@@ -600,6 +662,9 @@ public FailedShardEntry(
             this.message = message;
             this.failure = failure;
             this.markAsStale = markAsStale;
+            this.splitFailed = splitFailed;
+            this.parentShardId = parentShardId;
+            this.parentAllocationId = parentAllocationId;
         }
 
         public ShardId getShardId() {
@@ -619,6 +684,15 @@ public void writeTo(StreamOutput out) throws IOException {
             out.writeString(message);
             out.writeException(failure);
             out.writeBoolean(markAsStale);
+            if (out.getVersion().onOrAfter(Version.V_3_0_0)) {
+                out.writeOptionalBoolean(splitFailed);
+                out.writeOptionalWriteable(parentShardId);
+                out.writeOptionalString(parentAllocationId);
+            } else {
+                if (parentShardId != null) {
+                    throw new IllegalStateException("In-place split not allowed on older versions.");
+                }
+            }
         }
 
         @Override
@@ -632,6 +706,13 @@ public String toString() {
                 components.add("failure [" + ExceptionsHelper.detailedMessage(failure) + "]");
             }
             components.add("markAsStale [" + markAsStale + "]");
+            if (parentShardId != null) {
+                if (splitFailed != null) {
+                    components.add("splitFailed [" + splitFailed + "]");
+                }
+                components.add("parentShardId [" + parentShardId + "]");
+                components.add("parentAllocationId [" + parentAllocationId + "]");
+            }
             return String.join(", ", components);
         }
 
@@ -644,12 +725,16 @@ public boolean equals(Object o) {
             return Objects.equals(this.shardId, that.shardId)
                 && Objects.equals(this.allocationId, that.allocationId)
                 && primaryTerm == that.primaryTerm
-                && markAsStale == that.markAsStale;
+                && markAsStale == that.markAsStale
+                && splitFailed == that.splitFailed
+                && Objects.equals(this.parentShardId, that.parentShardId)
+                && Objects.equals(this.parentAllocationId, that.parentAllocationId);
         }
 
+
         @Override
         public int hashCode() {
-            return Objects.hash(shardId, allocationId, primaryTerm, markAsStale);
+            return Objects.hash(shardId, allocationId, primaryTerm, markAsStale, splitFailed, parentShardId, parentAllocationId);
         }
     }
 
@@ -669,10 +754,36 @@ public void shardStarted(
         final ActionListener<Void> listener,
         final ClusterState currentState
     ) {
-        StartedShardEntry entry = new StartedShardEntry(shardRouting.shardId(), shardRouting.allocationId().getId(), primaryTerm, message);
+        StartedShardEntry entry = new StartedShardEntry(
+            shardRouting.shardId(),
+            shardRouting.allocationId().getId(),
+            primaryTerm,
+            message,
+            null,
+            shardRouting.getParentShardId(),
+            shardRouting.allocationId().getParentAllocationId()
+        );
         sendShardAction(SHARD_STARTED_ACTION_NAME, currentState, entry, listener);
     }
 
+    public void childShardsStarted(
+        final ShardRouting parentShardRouting,
+        final long primaryTerm,
+        final String message,
+        final ActionListener<Void> listener
+    ) {
+        StartedShardEntry entry = new StartedShardEntry(
+            parentShardRouting.shardId(),
+            parentShardRouting.allocationId().getId(),
+            primaryTerm,
+            message,
+            true,
+            parentShardRouting.shardId(),
+            parentShardRouting.allocationId().getId()
+        );
+        sendShardAction(SHARD_STARTED_ACTION_NAME, clusterService.state(), entry, listener);
+    }
+
     /**
      * Handler for a shard started action.
      *
@@ -741,7 +852,39 @@ public ClusterTasksResult<StartedShardEntry> execute(ClusterState currentState,
             Set<ShardRouting> seenShardRoutings = new HashSet<>(); // to prevent duplicates
             for (StartedShardEntry task : tasks) {
                 final ShardRouting matched = currentState.getRoutingTable().getByAllocationId(task.shardId, task.allocationId);
-                if (matched == null) {
+                if (task.parentShardId != null) {
+                    if (seenShardRoutings.contains(matched) == true) {
+                        logger.info("Ignoring child event for shard " + matched);
+                    } else {
+                        logger.info("Processing child event for shard " + matched);
+                    }
+                    ShardRouting parentShard = currentState.getRoutingTable().getByAllocationId(task.parentShardId, task.parentAllocationId);
+                    if (parentShard == null || parentShard.splitting() == false) {
+                        builder.success(task);
+                        continue;
+                    }
+//                    seenShardRoutings.add(matched);
+                    if (Boolean.TRUE.equals(task.allChildPrimariesStarted)) {
+                        logger.debug("{} starting child shards of {} (shard started task: [{}])", task.shardId, parentShard, task);
+                        tasksToBeApplied.add(task);
+                        for (ShardRouting childShard : parentShard.getRecoveringChildShards()) {
+                            assert childShard.primary() == true || childShard.started();
+                            if (childShard.primary() == true) {
+                                shardRoutingsToBeApplied.add(childShard);
+                            }
+                        }
+                    } else {
+                        logger.debug("{} starting replica child shard of {} (shard started task: [{}])", task.shardId, parentShard, task);
+                        ShardRouting childReplica = currentState.getRoutingNodes().getByAllocationId(task.shardId, task.allocationId);
+                        if (childReplica == null) {
+                            // This means we have cancelled ongoing split earlier.
+                            builder.success(task);
+                            continue;
+                        }
+                        tasksToBeApplied.add(task);
+                        shardRoutingsToBeApplied.add(childReplica);
+                    }
+                } else if (matched == null) {
                     // tasks that correspond to non-existent shards are marked as successful. The reason is that we resend shard started
                     // events on every cluster state publishing that does not contain the shard as started yet. This means that old stale
                     // requests might still be in flight even after the shard has already been started or failed on the cluster-manager. We
@@ -785,7 +928,7 @@ public ClusterTasksResult<StartedShardEntry> execute(ClusterState currentState,
                     } else {
                         // remove duplicate actions as allocation service expects a clean list without duplicates
                         if (seenShardRoutings.contains(matched)) {
-                            logger.trace(
+                            logger.info(
                                 "{} ignoring shard started task [{}] (already scheduled to start {})",
                                 task.shardId,
                                 task,
@@ -793,15 +936,14 @@ public ClusterTasksResult<StartedShardEntry> execute(ClusterState currentState,
                             );
                             tasksToBeApplied.add(task);
                         } else {
-                            logger.debug("{} starting shard {} (shard started task: [{}])", task.shardId, matched, task);
                             tasksToBeApplied.add(task);
+                            logger.debug("{} starting shard {} (shard started task: [{}])", task.shardId, matched, task);
                             shardRoutingsToBeApplied.add(matched);
                             seenShardRoutings.add(matched);
                         }
                     }
                 }
             }
-            assert tasksToBeApplied.size() >= shardRoutingsToBeApplied.size();
 
             ClusterState maybeUpdatedState = currentState;
             try {
@@ -848,19 +990,47 @@ public static class StartedShardEntry extends TransportRequest {
         final long primaryTerm;
         final String message;
 
+        @Nullable
+        final Boolean allChildPrimariesStarted;
+        @Nullable
+        final ShardId parentShardId;
+        @Nullable
+        final String parentAllocationId;
+
+
         StartedShardEntry(StreamInput in) throws IOException {
             super(in);
             shardId = new ShardId(in);
             allocationId = in.readString();
             primaryTerm = in.readVLong();
             this.message = in.readString();
+            if (in.getVersion().onOrAfter(Version.V_3_0_0)) {
+                allChildPrimariesStarted = in.readOptionalBoolean();
+                parentShardId = in.readOptionalWriteable(ShardId::new);
+                parentAllocationId = in.readOptionalString();
+            } else {
+                allChildPrimariesStarted = null;
+                parentShardId = null;
+                parentAllocationId = null;
+            }
         }
 
-        public StartedShardEntry(final ShardId shardId, final String allocationId, final long primaryTerm, final String message) {
+        public StartedShardEntry(
+            final ShardId shardId,
+            final String allocationId,
+            final long primaryTerm,
+            final String message,
+            final Boolean allChildPrimariesStarted,
+            final ShardId parentShardId,
+            final String parentAllocationId
+        ) {
             this.shardId = shardId;
             this.allocationId = allocationId;
             this.primaryTerm = primaryTerm;
             this.message = message;
+            this.allChildPrimariesStarted = allChildPrimariesStarted;
+            this.parentShardId = parentShardId;
+            this.parentAllocationId = parentAllocationId;
         }
 
         @Override
@@ -870,17 +1040,30 @@ public void writeTo(StreamOutput out) throws IOException {
             out.writeString(allocationId);
             out.writeVLong(primaryTerm);
             out.writeString(message);
+            if (out.getVersion().onOrAfter(Version.V_3_0_0)) {
+                out.writeOptionalBoolean(allChildPrimariesStarted);
+                out.writeOptionalWriteable(parentShardId);
+                out.writeOptionalString(parentAllocationId);
+            } else {
+                if (parentShardId != null) {
+                    throw new IllegalStateException("In-place split not allowed on older versions.");
+                }
+            }
         }
 
         @Override
         public String toString() {
             return String.format(
                 Locale.ROOT,
-                "StartedShardEntry{shardId [%s], allocationId [%s], primary term [%d], message [%s]}",
+                "StartedShardEntry{shardId [%s], allocationId [%s], primary term [%d], "
+                    + "message [%s], allChildPrimariesStarted [%s], parentShardId [%s], parentAllocationId [%s]}",
                 shardId,
                 allocationId,
                 primaryTerm,
-                message
+                message,
+                allChildPrimariesStarted,
+                parentShardId,
+                parentAllocationId
             );
         }
     }
diff --git a/server/src/main/java/org/opensearch/cluster/awarenesshealth/ClusterAwarenessAttributeValueHealth.java b/server/src/main/java/org/opensearch/cluster/awarenesshealth/ClusterAwarenessAttributeValueHealth.java
index b4d797a39dd2f..973528d24c678 100644
--- a/server/src/main/java/org/opensearch/cluster/awarenesshealth/ClusterAwarenessAttributeValueHealth.java
+++ b/server/src/main/java/org/opensearch/cluster/awarenesshealth/ClusterAwarenessAttributeValueHealth.java
@@ -9,6 +9,7 @@
 package org.opensearch.cluster.awarenesshealth;
 
 import org.opensearch.OpenSearchParseException;
+import org.opensearch.Version;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.metadata.WeightedRoutingMetadata;
 import org.opensearch.cluster.routing.RoutingNode;
@@ -41,6 +42,7 @@ public class ClusterAwarenessAttributeValueHealth implements Writeable, ToXConte
     private static final String ACTIVE_SHARDS = "active_shards";
     private static final String INITIALIZING_SHARDS = "initializing_shards";
     private static final String RELOCATING_SHARDS = "relocating_shards";
+    private static final String SPLITTING_SHARDS = "splitting_shards";
     private static final String UNASSIGNED_SHARDS = "unassigned_shards";
     private static final String NODES = "data_nodes";
     private static final String WEIGHTS = "weight";
@@ -49,6 +51,7 @@ public class ClusterAwarenessAttributeValueHealth implements Writeable, ToXConte
     private int unassignedShards;
     private int initializingShards;
     private int relocatingShards;
+    private int splittingShards;
     private int nodes;
     private double weight;
     private List<String> nodeList;
@@ -71,7 +74,8 @@ public ClusterAwarenessAttributeValueHealth(String name, List<String> nodeList)
         int relocatingShards,
         int unassignedShards,
         int nodes,
-        double weights
+        double weights,
+        int splittingShards
     ) {
         this.name = name;
         this.activeShards = activeShards;
@@ -80,6 +84,7 @@ public ClusterAwarenessAttributeValueHealth(String name, List<String> nodeList)
         this.unassignedShards = unassignedShards;
         this.nodes = nodes;
         this.weight = weights;
+        this.splittingShards = splittingShards;
     }
 
     public ClusterAwarenessAttributeValueHealth(final StreamInput in) throws IOException {
@@ -90,6 +95,9 @@ public ClusterAwarenessAttributeValueHealth(final StreamInput in) throws IOExcep
         unassignedShards = in.readVInt();
         nodes = in.readVInt();
         weight = in.readDouble();
+        if (in.getVersion().onOrAfter(Version.V_3_0_0)) {
+            splittingShards = in.readVInt();
+        }
     }
 
     public static ClusterAwarenessAttributeValueHealth fromXContent(XContentParser parser) throws IOException {
@@ -101,6 +109,7 @@ public static ClusterAwarenessAttributeValueHealth fromXContent(XContentParser p
         int active_shards = 0;
         int initializing_shards = 0;
         int relocating_shards = 0;
+        int splitting_shards = 0;
         int unassigned_shards = 0;
         int nodes = 0;
         double weight = 0.0;
@@ -134,6 +143,14 @@ public static ClusterAwarenessAttributeValueHealth fromXContent(XContentParser p
                         }
                         relocating_shards = parser.intValue();
                         break;
+                    case SPLITTING_SHARDS:
+                        if (parser.nextToken() != XContentParser.Token.VALUE_NUMBER) {
+                            throw new OpenSearchParseException(
+                                "failed to parse splitting shards field, expected number but found unknown type"
+                            );
+                        }
+                        splitting_shards = parser.intValue();
+                        break;
                     case UNASSIGNED_SHARDS:
                         if (parser.nextToken() != XContentParser.Token.VALUE_NUMBER) {
                             throw new OpenSearchParseException("failed to parse unassigned field, expected number but found unknown type");
@@ -168,7 +185,8 @@ public static ClusterAwarenessAttributeValueHealth fromXContent(XContentParser p
             relocating_shards,
             unassigned_shards,
             nodes,
-            weight
+            weight,
+            splitting_shards
         );
     }
 
@@ -220,10 +238,18 @@ public int getRelocatingShards() {
         return relocatingShards;
     }
 
+    public int getSplittingShards() {
+        return splittingShards;
+    }
+
     public void setRelocatingShards(int relocatingShards) {
         this.relocatingShards = relocatingShards;
     }
 
+    public void setSplittingShardsShards(int splittingShards) {
+        this.splittingShards = splittingShards;
+    }
+
     public List<String> getNodeList() {
         return nodeList;
     }
@@ -241,6 +267,14 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeVInt(unassignedShards);
         out.writeVInt(nodes);
         out.writeDouble(weight);
+        if (out.getVersion().onOrAfter(Version.V_3_0_0)) {
+            out.writeVInt(splittingShards);
+        } else if (splittingShards != 0) {
+            // In-progress shard split is not allowed in a mixed cluster where node(s) with an unsupported split
+            // version is present. Hence, we also don't want to allow a node with an unsupported version
+            // to get this state while shard split is in-progress.
+            throw new IllegalStateException("In-place split not allowed on older versions.");
+        }
     }
 
     @Override
@@ -252,6 +286,7 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         builder.field(UNASSIGNED_SHARDS, getUnassignedShards());
         builder.field(NODES, getNodes());
         builder.field(WEIGHTS, getWeight());
+        builder.field(SPLITTING_SHARDS, getSplittingShards());
         builder.endObject();
         return builder;
     }
@@ -274,6 +309,7 @@ private void setShardLevelInfo(ClusterState clusterState, boolean displayUnassig
             activeShards += node.numberOfShardsWithState(ShardRoutingState.STARTED);
             relocatingShards += node.numberOfShardsWithState(ShardRoutingState.RELOCATING);
             initializingShards += node.numberOfShardsWithState(ShardRoutingState.INITIALIZING);
+            splittingShards += node.numberOfShardsWithState(ShardRoutingState.SPLITTING);
         }
 
         // computing unassigned shards info
@@ -311,11 +347,12 @@ public boolean equals(Object o) {
             && initializingShards == that.initializingShards
             && unassignedShards == that.unassignedShards
             && nodes == that.nodes
-            && weight == that.weight;
+            && weight == that.weight
+            && splittingShards == that.splittingShards;
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(name, activeShards, relocatingShards, initializingShards, unassignedShards, nodes, weight);
+        return Objects.hash(name, activeShards, relocatingShards, initializingShards, unassignedShards, nodes, weight, splittingShards);
     }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/awarenesshealth/ClusterAwarenessAttributesHealth.java b/server/src/main/java/org/opensearch/cluster/awarenesshealth/ClusterAwarenessAttributesHealth.java
index 3de2260d0e8bd..ec002b96eb6c4 100644
--- a/server/src/main/java/org/opensearch/cluster/awarenesshealth/ClusterAwarenessAttributesHealth.java
+++ b/server/src/main/java/org/opensearch/cluster/awarenesshealth/ClusterAwarenessAttributesHealth.java
@@ -199,6 +199,7 @@ public static ClusterAwarenessAttributesHealth fromXContent(XContentParser parse
                 int active_shards = 0;
                 int initializing_shards = 0;
                 int relocating_shards = 0;
+                int splitting_shards = 0;
                 int unassigned_shards = 0;
                 int nodes = 0;
                 double weight = 0.0;
@@ -230,6 +231,14 @@ public static ClusterAwarenessAttributesHealth fromXContent(XContentParser parse
                                 }
                                 relocating_shards = parser.intValue();
                                 break;
+                            case "splitting_shards":
+                                if (parser.nextToken() != XContentParser.Token.VALUE_NUMBER) {
+                                    throw new OpenSearchParseException(
+                                        "failed to parse splitting shards field, expected number but found unknown type"
+                                    );
+                                }
+                                splitting_shards = parser.intValue();
+                                break;
                             case "unassigned_shards":
                                 if (parser.nextToken() != XContentParser.Token.VALUE_NUMBER) {
                                     throw new OpenSearchParseException(
@@ -266,7 +275,8 @@ public static ClusterAwarenessAttributesHealth fromXContent(XContentParser parse
                     relocating_shards,
                     unassigned_shards,
                     nodes,
-                    weight
+                    weight,
+                    splitting_shards
                 );
                 clusterAwarenessAttributeValueHealthMap.put(
                     clusterAwarenessAttributeValueHealth.getName(),
diff --git a/server/src/main/java/org/opensearch/cluster/health/ClusterShardHealth.java b/server/src/main/java/org/opensearch/cluster/health/ClusterShardHealth.java
index ace4537a5e291..c5113f413b23e 100644
--- a/server/src/main/java/org/opensearch/cluster/health/ClusterShardHealth.java
+++ b/server/src/main/java/org/opensearch/cluster/health/ClusterShardHealth.java
@@ -265,6 +265,7 @@ public static ClusterHealthStatus getInactivePrimaryHealth(final ShardRouting sh
             && unassignedInfo.getNumFailedAllocations() == 0
             && (recoveryType == RecoverySource.Type.EMPTY_STORE
                 || recoveryType == RecoverySource.Type.LOCAL_SHARDS
+                || recoveryType == RecoverySource.Type.IN_PLACE_SHARD_SPLIT
                 || recoveryType == RecoverySource.Type.SNAPSHOT)) {
             return ClusterHealthStatus.YELLOW;
         } else {
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/IndexMetadata.java b/server/src/main/java/org/opensearch/cluster/metadata/IndexMetadata.java
index f70282986ad4e..06a2affe0a87b 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/IndexMetadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/IndexMetadata.java
@@ -51,6 +51,7 @@
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Setting.Property;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.set.Sets;
 import org.opensearch.common.xcontent.XContentHelper;
 import org.opensearch.core.Assertions;
 import org.opensearch.core.common.Strings;
@@ -80,6 +81,7 @@
 import java.time.ZonedDateTime;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.EnumSet;
 import java.util.HashMap;
@@ -590,6 +592,7 @@ public static APIBlock readFrom(StreamInput input) throws IOException {
         Property.IndexScope
     );
     public static final String INDEX_UUID_NA_VALUE = Strings.UNKNOWN_UUID_VALUE;
+    public static final int SPLIT_PARENT_TERM = -5;
 
     public static final String INDEX_ROUTING_REQUIRE_GROUP_PREFIX = "index.routing.allocation.require";
     public static final String INDEX_ROUTING_INCLUDE_GROUP_PREFIX = "index.routing.allocation.include";
@@ -657,6 +660,7 @@ public static APIBlock readFrom(StreamInput input) throws IOException {
     static final String KEY_ALIASES = "aliases";
     static final String KEY_ROLLOVER_INFOS = "rollover_info";
     static final String KEY_SYSTEM = "system";
+    static final String KEY_SPLIT_SHARDS_METADATA = "split_shards_metadata";
     public static final String KEY_PRIMARY_TERMS = "primary_terms";
     public static final String REMOTE_STORE_CUSTOM_KEY = "remote_store";
     public static final String TRANSLOG_METADATA_KEY = "translog_metadata";
@@ -714,6 +718,8 @@ public static APIBlock readFrom(StreamInput input) throws IOException {
 
     private final Context context;
 
+    private final SplitShardsMetadata splitShardsMetadata;
+
     private IndexMetadata(
         final Index index,
         final long version,
@@ -742,7 +748,8 @@ private IndexMetadata(
         final Map<String, RolloverInfo> rolloverInfos,
         final boolean isSystem,
         final int indexTotalShardsPerNodeLimit,
-        final Context context
+        final Context context,
+        final SplitShardsMetadata splitShardsMetadata
     ) {
 
         this.index = index;
@@ -772,7 +779,7 @@ private IndexMetadata(
         this.indexCreatedVersion = indexCreatedVersion;
         this.indexUpgradedVersion = indexUpgradedVersion;
         this.routingNumShards = routingNumShards;
-        this.routingFactor = routingNumShards / numberOfShards;
+        this.routingFactor = routingNumShards / splitShardsMetadata.getNumberOfRootShards();
         this.routingPartitionSize = routingPartitionSize;
         this.waitForActiveShards = waitForActiveShards;
         this.rolloverInfos = Collections.unmodifiableMap(rolloverInfos);
@@ -780,7 +787,9 @@ private IndexMetadata(
         this.isRemoteSnapshot = IndexModule.Type.REMOTE_SNAPSHOT.match(this.settings);
         this.indexTotalShardsPerNodeLimit = indexTotalShardsPerNodeLimit;
         this.context = context;
-        assert numberOfShards * routingFactor == routingNumShards : routingNumShards + " must be a multiple of " + numberOfShards;
+        this.splitShardsMetadata = splitShardsMetadata;
+        assert splitShardsMetadata.getNumberOfRootShards() * routingFactor == routingNumShards : routingNumShards
+            + " must be a multiple of " + splitShardsMetadata.getNumberOfRootShards();
     }
 
     public Index getIndex() {
@@ -858,6 +867,10 @@ public int getNumberOfShards() {
         return numberOfShards;
     }
 
+    public long[] getPrimaryTerms() {
+        return primaryTerms.clone();
+    }
+
     public int getNumberOfReplicas() {
         return numberOfReplicas;
     }
@@ -932,8 +945,11 @@ public Map<String, RolloverInfo> getRolloverInfos() {
         return rolloverInfos;
     }
 
+    public SplitShardsMetadata getSplitShardsMetadata() {
+        return splitShardsMetadata;
+    }
+
     public Set<String> inSyncAllocationIds(int shardId) {
-        assert shardId >= 0 && shardId < numberOfShards;
         return inSyncAllocationIds.get(shardId);
     }
 
@@ -1015,6 +1031,9 @@ public boolean equals(Object o) {
         if (!Objects.equals(context, that.context)) {
             return false;
         }
+        if (!splitShardsMetadata.equals(that.splitShardsMetadata)) {
+            return false;
+        }
         return true;
     }
 
@@ -1034,6 +1053,7 @@ public int hashCode() {
         result = 31 * result + rolloverInfos.hashCode();
         result = 31 * result + Boolean.hashCode(isSystem);
         result = 31 * result + Objects.hashCode(context);
+        result = 31 * result + splitShardsMetadata.hashCode();
         return result;
     }
 
@@ -1079,6 +1099,7 @@ static class IndexMetadataDiff implements Diff<IndexMetadata> {
         private final Diff<Map<String, RolloverInfo>> rolloverInfos;
         private final boolean isSystem;
         private final Context context;
+        private Diff<SplitShardsMetadata> splitMetadata;
 
         IndexMetadataDiff(IndexMetadata before, IndexMetadata after) {
             index = after.index.getName();
@@ -1102,6 +1123,7 @@ static class IndexMetadataDiff implements Diff<IndexMetadata> {
             rolloverInfos = DiffableUtils.diff(before.rolloverInfos, after.rolloverInfos, DiffableUtils.getStringKeySerializer());
             isSystem = after.isSystem;
             context = after.context;
+            splitMetadata = after.splitShardsMetadata.diff(before.splitShardsMetadata);
         }
 
         private static final DiffableUtils.DiffableValueReader<String, AliasMetadata> ALIAS_METADATA_DIFF_VALUE_READER =
@@ -1122,7 +1144,12 @@ static class IndexMetadataDiff implements Diff<IndexMetadata> {
             aliasesVersion = in.readVLong();
             state = State.fromId(in.readByte());
             settings = Settings.readSettingsFromStream(in);
-            primaryTerms = in.readVLongArray();
+
+            if (in.getVersion().onOrAfter(Version.V_3_0_0)) {
+                primaryTerms = in.readZLongArray();
+            } else {
+                primaryTerms = in.readVLongArray();
+            }
             mappings = DiffableUtils.readJdkMapDiff(in, DiffableUtils.getStringKeySerializer(), MAPPING_DIFF_VALUE_READER);
             aliases = DiffableUtils.readJdkMapDiff(in, DiffableUtils.getStringKeySerializer(), ALIAS_METADATA_DIFF_VALUE_READER);
             customData = DiffableUtils.readJdkMapDiff(in, DiffableUtils.getStringKeySerializer(), CUSTOM_DIFF_VALUE_READER);
@@ -1138,6 +1165,9 @@ static class IndexMetadataDiff implements Diff<IndexMetadata> {
             } else {
                 context = null;
             }
+            if (in.getVersion().onOrAfter(Version.V_3_0_0)) {
+                splitMetadata = SplitShardsMetadata.readDiffFrom(in);
+            }
         }
 
         @Override
@@ -1150,7 +1180,11 @@ public void writeTo(StreamOutput out) throws IOException {
             out.writeVLong(aliasesVersion);
             out.writeByte(state.id);
             Settings.writeSettingsToStream(settings, out);
-            out.writeVLongArray(primaryTerms);
+            if (out.getVersion().onOrAfter(Version.V_3_0_0)) {
+                out.writeZLongArray(primaryTerms);
+            } else {
+                out.writeVLongArray(primaryTerms);
+            }
             mappings.writeTo(out);
             aliases.writeTo(out);
             customData.writeTo(out);
@@ -1160,6 +1194,9 @@ public void writeTo(StreamOutput out) throws IOException {
             if (out.getVersion().onOrAfter(Version.V_2_17_0)) {
                 out.writeOptionalWriteable(context);
             }
+            if (out.getVersion().onOrAfter(Version.V_3_0_0)) {
+                splitMetadata.writeTo(out);
+            }
         }
 
         @Override
@@ -1177,9 +1214,11 @@ public IndexMetadata apply(IndexMetadata part) {
             builder.aliases.putAll(aliases.apply(part.aliases));
             builder.customMetadata.putAll(customData.apply(part.customData));
             builder.inSyncAllocationIds.putAll(inSyncAllocationIds.apply(part.inSyncAllocationIds));
+
             builder.rolloverInfos.putAll(rolloverInfos.apply(part.rolloverInfos));
             builder.system(isSystem);
             builder.context(context);
+            builder.splitShardsMetadata(splitMetadata.apply(part.splitShardsMetadata));
             return builder.build();
         }
     }
@@ -1193,7 +1232,11 @@ public static IndexMetadata readFrom(StreamInput in) throws IOException {
         builder.setRoutingNumShards(in.readInt());
         builder.state(State.fromId(in.readByte()));
         builder.settings(readSettingsFromStream(in));
-        builder.primaryTerms(in.readVLongArray());
+        if (in.getVersion().onOrAfter(Version.V_3_0_0)) {
+            builder.primaryTerms(in.readZLongArray());
+        } else {
+            builder.primaryTerms(in.readVLongArray());
+        }
         int mappingsSize = in.readVInt();
         for (int i = 0; i < mappingsSize; i++) {
             MappingMetadata mappingMd = new MappingMetadata(in);
@@ -1225,6 +1268,9 @@ public static IndexMetadata readFrom(StreamInput in) throws IOException {
         if (in.getVersion().onOrAfter(Version.V_2_17_0)) {
             builder.context(in.readOptionalWriteable(Context::new));
         }
+        if (in.getVersion().onOrAfter(Version.V_3_0_0)) {
+            builder.splitShardsMetadata(new SplitShardsMetadata(in));
+        }
         return builder.build();
     }
 
@@ -1238,7 +1284,11 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeInt(routingNumShards);
         out.writeByte(state.id());
         writeSettingsToStream(settings, out);
-        out.writeVLongArray(primaryTerms);
+        if (out.getVersion().onOrAfter(Version.V_3_0_0)) {
+            out.writeZLongArray(primaryTerms);
+        } else {
+            out.writeVLongArray(primaryTerms);
+        }
         out.writeVInt(mappings.size());
         for (final MappingMetadata cursor : mappings.values()) {
             cursor.writeTo(out);
@@ -1266,6 +1316,9 @@ public void writeTo(StreamOutput out) throws IOException {
         if (out.getVersion().onOrAfter(Version.V_2_17_0)) {
             out.writeOptionalWriteable(context);
         }
+        if (out.getVersion().onOrAfter(Version.V_3_0_0)) {
+            splitShardsMetadata.writeTo(out);
+        }
     }
 
     @Override
@@ -1292,6 +1345,9 @@ public void writeVerifiableTo(BufferedChecksumStreamOutput out) throws IOExcepti
         if (out.getVersion().onOrAfter(Version.V_2_17_0)) {
             out.writeOptionalWriteable(context);
         }
+        if (out.getVersion().onOrAfter(Version.V_3_0_0)) {
+            splitShardsMetadata.writeTo(out);
+        }
     }
 
     @Override
@@ -1328,6 +1384,8 @@ public String toString() {
             .append(isSystem)
             .append(", context=")
             .append(context)
+            .append(", splitShardsMetadata=")
+            .append(splitShardsMetadata)
             .append("}")
             .toString();
     }
@@ -1376,6 +1434,7 @@ public static class Builder {
         private Integer routingNumShards;
         private boolean isSystem;
         private Context context;
+        private SplitShardsMetadata splitShardsMetadata;
 
         public Builder(String index) {
             this.index = index;
@@ -1404,6 +1463,7 @@ public Builder(IndexMetadata indexMetadata) {
             this.rolloverInfos = new HashMap<>(indexMetadata.rolloverInfos);
             this.isSystem = indexMetadata.isSystem;
             this.context = indexMetadata.context;
+            this.splitShardsMetadata = new SplitShardsMetadata.Builder(indexMetadata.splitShardsMetadata).build();
         }
 
         public Builder index(String index) {
@@ -1445,6 +1505,45 @@ public int numberOfShards() {
             return settings.getAsInt(SETTING_NUMBER_OF_SHARDS, -1);
         }
 
+        public Builder updateMetadataForNewChildShards(Map<Integer, String> newChildAllocationIds, int sourceShardId) {
+
+            // Now update primary terms against child shard ids
+            int numOfFinalPrimaryTerms = this.primaryTerms.length + newChildAllocationIds.size();
+            long []finalPrimaryTerms = Arrays.copyOf(this.primaryTerms, numOfFinalPrimaryTerms);
+            long parentPrimaryTerm = this.primaryTerms[sourceShardId];
+            Arrays.fill(finalPrimaryTerms, this.primaryTerms.length, numOfFinalPrimaryTerms, parentPrimaryTerm);
+            finalPrimaryTerms[sourceShardId] = -1;
+            this.primaryTerms = finalPrimaryTerms;
+
+            // Add in-sync allocations of primary child shards
+            newChildAllocationIds.forEach((shardId, newAllocationId) -> {
+                Collection<String> curAllocIds = this.inSyncAllocationIds.get(shardId);
+                Set<String> shardAllocIds = curAllocIds == null ? new HashSet<>() : new HashSet<>(curAllocIds);
+                shardAllocIds.add(newAllocationId);
+                putInSyncAllocationIds(shardId, shardAllocIds);
+            });
+            this.inSyncAllocationIds.remove(sourceShardId);
+
+            SplitShardsMetadata.Builder splitShardsMetadata = new SplitShardsMetadata.Builder(this.splitShardsMetadata);
+            splitShardsMetadata.updateSplitMetadataForChildShards(sourceShardId, newChildAllocationIds.keySet());
+
+            this.splitShardsMetadata = splitShardsMetadata.build();
+            numberOfShards(this.splitShardsMetadata.getNumberOfShards());
+            this.settingsVersion += 1;
+
+            return this;
+        }
+
+        public Builder cancelSplit(int sourceShardId) {
+            for (ShardRange child : splitShardsMetadata.getChildShardsOfParent(sourceShardId)) {
+                inSyncAllocationIds.remove(child.getShardId());
+            }
+            SplitShardsMetadata.Builder splitShardsMetadata = new SplitShardsMetadata.Builder(this.splitShardsMetadata);
+            splitShardsMetadata.cancelSplit(sourceShardId);
+            this.splitShardsMetadata = splitShardsMetadata.build();
+            return this;
+        }
+
         public Builder numberOfReplicas(int numberOfReplicas) {
             settings = Settings.builder().put(settings).put(SETTING_NUMBER_OF_REPLICAS, numberOfReplicas).build();
             return this;
@@ -1544,6 +1643,11 @@ public Builder putRolloverInfo(RolloverInfo rolloverInfo) {
             return this;
         }
 
+        public Builder splitShardsMetadata(SplitShardsMetadata splitShardsMetadata) {
+            this.splitShardsMetadata = splitShardsMetadata;
+            return this;
+        }
+
         public long version() {
             return this.version;
         }
@@ -1645,7 +1749,10 @@ public IndexMetadata build() {
             if (INDEX_NUMBER_OF_SHARDS_SETTING.exists(settings) == false) {
                 throw new IllegalArgumentException("must specify number of shards for index [" + index + "]");
             }
-            final int numberOfShards = INDEX_NUMBER_OF_SHARDS_SETTING.get(settings);
+            if (splitShardsMetadata == null) {
+                this.splitShardsMetadata = new SplitShardsMetadata.Builder(numberOfShards()).build();
+            }
+            final int numberOfShards = splitShardsMetadata.getNumberOfShards();
 
             if (INDEX_NUMBER_OF_REPLICAS_SETTING.exists(settings) == false) {
                 throw new IllegalArgumentException("must specify number of replicas for index [" + index + "]");
@@ -1672,9 +1779,17 @@ public IndexMetadata build() {
             for (int i = 0; i < numberOfShards; i++) {
                 if (inSyncAllocationIds.containsKey(i)) {
                     filledInSyncAllocationIds.put(i, Collections.unmodifiableSet(new HashSet<>(inSyncAllocationIds.get(i))));
-                } else {
+                } else if (splitShardsMetadata.isEmptyParentShard(i) == false) {
                     filledInSyncAllocationIds.put(i, Collections.emptySet());
                 }
+
+                if (splitShardsMetadata.isSplitOfShardInProgress(i) == true) {
+                    for (ShardRange child : splitShardsMetadata.getChildShardsOfParent(i)) {
+                        if (inSyncAllocationIds.containsKey(child.getShardId())) {
+                            filledInSyncAllocationIds.put(child.getShardId(), inSyncAllocationIds.get(child.getShardId()));
+                        }
+                    }
+                }
             }
             final Map<String, String> requireMap = INDEX_ROUTING_REQUIRE_GROUP_SETTING.getAsMap(settings);
             final DiscoveryNodeFilters requireFilters;
@@ -1713,7 +1828,7 @@ public IndexMetadata build() {
                 throw new IllegalStateException(
                     "primaryTerms length is ["
                         + primaryTerms.length
-                        + "] but should be equal to number of shards ["
+                        + "] but should be equal to total of serving shards and empty shards ["
                         + numberOfShards()
                         + "]"
                 );
@@ -1765,7 +1880,8 @@ public IndexMetadata build() {
                 rolloverInfos,
                 isSystem,
                 indexTotalShardsPerNodeLimit,
-                context
+                context,
+                splitShardsMetadata
             );
         }
 
@@ -1845,7 +1961,7 @@ public static void toXContent(IndexMetadata indexMetadata, XContentBuilder build
                 builder.endArray();
 
                 builder.startObject(IndexMetadata.KEY_PRIMARY_TERMS);
-                for (int shard = 0; shard < indexMetadata.getNumberOfShards(); shard++) {
+                for (int shard = 0; shard < indexMetadata.primaryTerms.length; shard++) {
                     builder.field(Integer.toString(shard), indexMetadata.primaryTerm(shard));
                 }
                 builder.endObject();
@@ -1866,6 +1982,11 @@ public static void toXContent(IndexMetadata indexMetadata, XContentBuilder build
                 cursor.toXContent(builder, params);
             }
             builder.endObject();
+
+            builder.startObject(KEY_SPLIT_SHARDS_METADATA);
+            indexMetadata.splitShardsMetadata.toXContent(builder, params);
+            builder.endObject();
+
             builder.field(KEY_SYSTEM, indexMetadata.isSystem);
 
             if (indexMetadata.context != null) {
@@ -1956,6 +2077,8 @@ public static IndexMetadata fromXContent(XContentParser parser) throws IOExcepti
                         parser.skipChildren();
                     } else if (CONTEXT_KEY.equals(currentFieldName)) {
                         builder.context(Context.fromXContent(parser));
+                    } else if (KEY_SPLIT_SHARDS_METADATA.equals(currentFieldName)) {
+                        builder.splitShardsMetadata(SplitShardsMetadata.parse(parser));
                     } else {
                         // assume it's custom index metadata
                         builder.putCustom(currentFieldName, parser.mapStrings());
@@ -2096,7 +2219,7 @@ public IndexMetadata fromXContent(XContentParser parser) throws IOException {
     /**
      * Returns the number of shards that should be used for routing. This basically defines the hash space we use in
      * {@link org.opensearch.cluster.routing.OperationRouting#generateShardId(IndexMetadata, String, String)} to route documents
-     * to shards based on their ID or their specific routing value. The default value is {@link #getNumberOfShards()}. This value only
+     * to shards based on their ID or their specific routing value. The default value is {@link #getNumberOfShards()} ()}. This value only
      * changes if and index is shrunk.
      */
     public int getRoutingNumShards() {
@@ -2120,6 +2243,11 @@ public int getRoutingFactor() {
      * @return a the source shard ID to split off from
      */
     public static ShardId selectSplitShard(int shardId, IndexMetadata sourceIndexMetadata, int numTargetShards) {
+        if (sourceIndexMetadata.getNumberOfShards() > sourceIndexMetadata.getSplitShardsMetadata().getNumberOfRootShards()) {
+            throw new IllegalArgumentException(
+                "Cannot perform an index level split as one or more shards of this index has been split. "
+            );
+        }
         int numSourceShards = sourceIndexMetadata.getNumberOfShards();
         if (shardId >= numTargetShards) {
             throw new IllegalArgumentException(
@@ -2139,7 +2267,7 @@ public static ShardId selectSplitShard(int shardId, IndexMetadata sourceIndexMet
      * @return a the source shard ID to clone from
      */
     public static ShardId selectCloneShard(int shardId, IndexMetadata sourceIndexMetadata, int numTargetShards) {
-        int numSourceShards = sourceIndexMetadata.getNumberOfShards();
+        int numSourceShards = sourceIndexMetadata.primaryTerms.length;
         if (numSourceShards != numTargetShards) {
             throw new IllegalArgumentException(
                 "the number of target shards ("
@@ -2174,7 +2302,7 @@ private static void assertSplitMetadata(int numSourceShards, int numTargetShards
             );
         }
         // this is just an additional assertion that ensures we are a factor of the routing num shards.
-        assert sourceIndexMetadata.getNumberOfShards() == 1 // special case - we can split into anything from 1 shard
+        assert sourceIndexMetadata.primaryTerms.length == 1 // special case - we can split into anything from 1 shard
             || getRoutingFactor(numTargetShards, routingNumShards) >= 0;
     }
 
@@ -2202,6 +2330,11 @@ public static Set<ShardId> selectRecoverFromShards(int shardId, IndexMetadata so
      * @return a set of shard IDs to shrink into the given shard ID.
      */
     public static Set<ShardId> selectShrinkShards(int shardId, IndexMetadata sourceIndexMetadata, int numTargetShards) {
+        if (sourceIndexMetadata.getNumberOfShards() > sourceIndexMetadata.getSplitShardsMetadata().getNumberOfRootShards()) {
+            throw new IllegalArgumentException(
+                "Cannot perform an index level shrink as one or more shards of this index has been split. "
+            );
+        }
         if (shardId >= numTargetShards) {
             throw new IllegalArgumentException(
                 "the number of target shards (" + numTargetShards + ") must be greater than the shard id: " + shardId
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/MetadataInPlaceShardSplitService.java b/server/src/main/java/org/opensearch/cluster/metadata/MetadataInPlaceShardSplitService.java
new file mode 100644
index 0000000000000..d1f3a17217394
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/metadata/MetadataInPlaceShardSplitService.java
@@ -0,0 +1,166 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.metadata;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.action.admin.indices.split.InPlaceShardSplitClusterStateUpdateRequest;
+import org.opensearch.cluster.AckedClusterStateUpdateTask;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.ack.ClusterStateUpdateResponse;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.allocation.AllocationService;
+import org.opensearch.cluster.routing.allocation.AwarenessReplicaBalance;
+import org.opensearch.cluster.service.ClusterManagerTaskKeys;
+import org.opensearch.cluster.service.ClusterManagerTaskThrottler;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.Priority;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.index.shard.ShardNotFoundException;
+import org.opensearch.indices.IndicesService;
+import org.opensearch.indices.ShardLimitValidator;
+import org.opensearch.plugins.PluginsService;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.BiFunction;
+
+public class MetadataInPlaceShardSplitService {
+    private static final Logger logger = LogManager.getLogger(MetadataInPlaceShardSplitService.class);
+
+    private final Settings settings;
+    private final ClusterService clusterService;
+    private final PluginsService pluginsService;
+    private final IndicesService indicesService;
+    private final AllocationService allocationService;
+    private final ShardLimitValidator shardLimitValidator;
+    private final ClusterManagerTaskThrottler.ThrottlingKey splitShardTaskKey;
+    private AwarenessReplicaBalance awarenessReplicaBalance;
+
+    public MetadataInPlaceShardSplitService(
+        final Settings settings,
+        final ClusterService clusterService,
+        final PluginsService pluginsService,
+        final IndicesService indicesService,
+        final AllocationService allocationService,
+        final ShardLimitValidator shardLimitValidator,
+        final AwarenessReplicaBalance awarenessReplicaBalance
+    ) {
+        this.settings = settings;
+        this.clusterService = clusterService;
+        this.pluginsService = pluginsService;
+        this.indicesService = indicesService;
+        this.allocationService = allocationService;
+        this.shardLimitValidator = shardLimitValidator;
+        this.awarenessReplicaBalance = awarenessReplicaBalance;
+
+        this.splitShardTaskKey = clusterService.registerClusterManagerTask(ClusterManagerTaskKeys.IN_PLACE_SHARD_SPLIT_TASK, true);
+    }
+
+    /**
+     * TODO: Add comment
+     */
+    public void split(final InPlaceShardSplitClusterStateUpdateRequest request, final ActionListener<ClusterStateUpdateResponse> listener) {
+        onlySplitShard(request, ActionListener.wrap(response -> {
+            if (response.isAcknowledged()) {
+                // TODO: Add wait for active shard.
+                listener.onResponse(new ClusterStateUpdateResponse(true));
+            } else {
+                listener.onResponse(new ClusterStateUpdateResponse(false));
+            }
+        }, listener::onFailure));
+
+    }
+
+    private void onlySplitShard(
+        final InPlaceShardSplitClusterStateUpdateRequest request,
+        final ActionListener<ClusterStateUpdateResponse> listener
+    ) {
+        clusterService.submitStateUpdateTask(
+            "in-place-split-shard [" + request.getShardId() + "] of index [" + request.getIndex() + "], cause [" + request.cause() + "]",
+            new AckedClusterStateUpdateTask<>(Priority.URGENT, request, listener) {
+                @Override
+                protected ClusterStateUpdateResponse newResponse(boolean acknowledged) {
+                    return new ClusterStateUpdateResponse(acknowledged);
+                }
+
+                @Override
+                public ClusterManagerTaskThrottler.ThrottlingKey getClusterManagerThrottlingKey() {
+                    return splitShardTaskKey;
+                }
+
+                @Override
+                public ClusterState execute(ClusterState currentState) throws Exception {
+                    return applyShardSplitRequest(currentState, request, allocationService::reroute);
+                }
+
+                @Override
+                public void onFailure(String source, Exception e) {
+                    logger.trace(
+                        () -> new ParameterizedMessage(
+                            "[{}] of index [{}] failed to split online",
+                            request.getShardId(),
+                            request.getIndex()
+                        ),
+                        e
+                    );
+                    super.onFailure(source, e);
+                }
+            }
+        );
+    }
+
+    public ClusterState applyShardSplitRequest(
+        ClusterState currentState,
+        InPlaceShardSplitClusterStateUpdateRequest request,
+        BiFunction<ClusterState, String, ClusterState> rerouteRoutingTable
+    ) {
+        IndexMetadata curIndexMetadata = currentState.metadata().index(request.getIndex());
+        ShardId sourceShardId = new ShardId(curIndexMetadata.getIndex(), request.getShardId());
+        if (curIndexMetadata.getSplitShardsMetadata().getInProgressSplitShardId() != SplitShardsMetadata.SPLIT_NOT_IN_PROGRESS) {
+            int inProgressSplitShard = curIndexMetadata.getSplitShardsMetadata().getInProgressSplitShardId();
+            throw new IllegalArgumentException("Splitting of shard [" + inProgressSplitShard + "] is already in progress");
+        }
+
+        if (curIndexMetadata.getSplitShardsMetadata().isEmptyParentShard(request.getShardId())) {
+            throw new IllegalArgumentException("Shard [" + request.getShardId() + "] has already been split.");
+        }
+
+        Tuple<Boolean, String> shardSplitSupportedOnPlugins = pluginsService.isShardSplitAllowed(sourceShardId.getIndex());
+        if (Boolean.TRUE.equals(shardSplitSupportedOnPlugins.v1()) == false) {
+            throw new UnsupportedOperationException("Splitting of shard [" + sourceShardId.id() + "] on index [" +
+                sourceShardId.getIndex().getName() + "] is not supported by plugins " + shardSplitSupportedOnPlugins.v2());
+        }
+
+        RoutingTable.Builder routingTableBuilder = RoutingTable.builder(currentState.routingTable());
+        Metadata.Builder metadataBuilder = Metadata.builder(currentState.metadata());
+        IndexMetadata.Builder indexMetadataBuilder = IndexMetadata.builder(curIndexMetadata);
+
+        SplitShardsMetadata.Builder splitMetadataBuilder = new SplitShardsMetadata.Builder(curIndexMetadata.getSplitShardsMetadata());
+        splitMetadataBuilder.splitShard(sourceShardId.id(), request.getSplitInto());
+        indexMetadataBuilder.splitShardsMetadata(splitMetadataBuilder.build());
+
+        RoutingTable routingTable = routingTableBuilder.build();
+        metadataBuilder.put(indexMetadataBuilder);
+
+
+        ClusterState updatedState = ClusterState.builder(currentState).metadata(metadataBuilder).routingTable(routingTable).build();
+        return rerouteRoutingTable.apply(updatedState, "shard [" + request.getShardId() + "] of index [" + request.getIndex() + "] split");
+    }
+
+
+}
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/ShardRange.java b/server/src/main/java/org/opensearch/cluster/metadata/ShardRange.java
new file mode 100644
index 0000000000000..9da2cbe6959a1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/metadata/ShardRange.java
@@ -0,0 +1,134 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.metadata;
+
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParser;
+
+import java.io.IOException;
+
+public class ShardRange implements Comparable<ShardRange>, ToXContentFragment, Writeable {
+    private final int shardId;
+    private final int start;
+    private final int end;
+
+    public ShardRange(int shardId, int start, int end) {
+        this.shardId = shardId;
+        this.start = start;
+        this.end = end;
+    }
+
+    /**
+     * Constructs a new shard range from a stream.
+     * @param in the stream to read from
+     * @throws IOException if an error occurs while reading from the stream
+     * @see #writeTo(StreamOutput)
+     */
+    public ShardRange(StreamInput in) throws IOException {
+        shardId = in.readVInt();
+        start = in.readInt();
+        end = in.readInt();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof ShardRange)) return false;
+
+        ShardRange that = (ShardRange) o;
+
+        if (shardId != that.shardId) return false;
+        if (start != that.start) return false;
+        return end == that.end;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = shardId;
+        result = 31 * result + start;
+        result = 31 * result + end;
+        return result;
+    }
+
+    public int getShardId() {
+        return shardId;
+    }
+
+    public int getStart() {
+        return start;
+    }
+
+    public int getEnd() {
+        return end;
+    }
+
+    public ShardRange copy() {
+        return new ShardRange(shardId, start, end);
+    }
+
+    public boolean contains(long hash) {
+        return hash >= start && hash <= end;
+    }
+
+    @Override
+    public int compareTo(ShardRange o) {
+        return Integer.compare(start, o.start);
+    }
+
+    @Override
+    public String toString() {
+        return "ShardRange{" +
+            "shardId=" + shardId +
+            ", start=" + start +
+            ", end=" + end +
+            '}';
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeVInt(shardId);
+        out.writeInt(start);
+        out.writeInt(end);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject()
+            .field("shard_id", shardId)
+            .field("start", start)
+            .field("end", end);
+        builder.endObject();
+        return builder;
+    }
+
+    public static ShardRange parse(XContentParser parser) throws IOException {
+        int shardId = -1, start = -1, end = -1;
+        XContentParser.Token token;
+        String fieldName = null;
+        while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
+            if (token == XContentParser.Token.FIELD_NAME) {
+                fieldName = parser.currentName();
+            } else if (token == XContentParser.Token.VALUE_NUMBER) {
+                if ("shard_id".equals(fieldName)) {
+                    shardId = parser.intValue();
+                } else if ("start".equals(fieldName)) {
+                    start = parser.intValue();
+                } else if ("end".equals(fieldName)) {
+                    end = parser.intValue();
+                }
+            }
+        }
+
+        return new ShardRange(shardId, start, end);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/SplitShardsMetadata.java b/server/src/main/java/org/opensearch/cluster/metadata/SplitShardsMetadata.java
new file mode 100644
index 0000000000000..08334f0b24f8f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/metadata/SplitShardsMetadata.java
@@ -0,0 +1,441 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.metadata;
+
+import org.opensearch.cluster.AbstractDiffable;
+import org.opensearch.cluster.Diff;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParser;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class SplitShardsMetadata extends AbstractDiffable<SplitShardsMetadata> implements ToXContentFragment {
+    private static final int MINIMUM_RANGE_LENGTH_THRESHOLD = 1000;
+    public static final int SPLIT_NOT_IN_PROGRESS = -2;
+
+    private static final String KEY_ROOT_SHARDS_TO_ALL_CHILDREN = "root_shards_to_all_children";
+    private static final String KEY_NUMBER_OF_ROOT_SHARDS = "num_of_root_shards";
+    private static final String KEY_TEMP_SHARD_ID_TO_CHILD_SHARDS = "temp_shard_id_to_child_shards";
+    private static final String KEY_MAX_SHARD_ID = "max_shard_id";
+    private static final String KEY_IN_PROGRESS_SPLIT_SHARD_ID = "in_progress_split_shard_id";
+
+    // Root shard id to flat list of all child shards under root.
+    private final ShardRange[][] rootShardsToAllChildren;
+    // Mapping of a parent shard ID to children.
+    private final Map<Integer, ShardRange[]> parentToChildShards;
+    private final int maxShardId;
+    private final int inProgressSplitShardId;
+
+    private SplitShardsMetadata(ShardRange[][] rootShardsToAllChildren, Map<Integer, ShardRange[]> parentToChildShards,
+                                int inProgressSplitShardId, int maxShardId) {
+
+        this.rootShardsToAllChildren = rootShardsToAllChildren;
+        this.parentToChildShards = parentToChildShards;
+        this.maxShardId = maxShardId;
+        this.inProgressSplitShardId = inProgressSplitShardId;
+    }
+
+    public SplitShardsMetadata(StreamInput in) throws IOException {
+        int numberOfRootShards = in.readVInt();
+        this.rootShardsToAllChildren = new ShardRange[numberOfRootShards][];
+        for (int i=0; i < numberOfRootShards; i++) {
+            this.rootShardsToAllChildren[i] = in.readOptionalArray(ShardRange::new, ShardRange[]::new);
+        }
+        this.maxShardId = in.readVInt();
+        this.inProgressSplitShardId = in.readInt();
+        this.parentToChildShards = in.readMap(StreamInput::readInt, i-> i.readArray(ShardRange::new, ShardRange[]::new));
+    }
+
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeVInt(rootShardsToAllChildren.length);
+        for (ShardRange[] rootShardsToAllChild : rootShardsToAllChildren) {
+            out.writeOptionalArray(rootShardsToAllChild);
+        }
+        out.writeVInt(this.maxShardId);
+        out.writeInt(this.inProgressSplitShardId);
+        out.writeMap(this.parentToChildShards, StreamOutput::writeInt, StreamOutput::writeArray);
+    }
+
+    public int getShardIdOfHash(int rootShardId, int hash, boolean includeInProgressChildren) {
+        // First check if we have child shards against this root shard.
+        if (rootShardsToAllChildren[rootShardId] == null) {
+            if (includeInProgressChildren && parentToChildShards.containsKey(rootShardId)) {
+                ShardRange shardRange = binarySearchShards(parentToChildShards.get(rootShardId), hash);
+                assert shardRange != null;
+                return shardRange.getShardId();
+            }
+            return rootShardId;
+        }
+
+        ShardRange[] existingChildShards = rootShardsToAllChildren[rootShardId];
+        ShardRange shardRange = binarySearchShards(existingChildShards, hash);
+        assert shardRange != null;
+
+        if (includeInProgressChildren && parentToChildShards.containsKey(shardRange.getShardId())) {
+            shardRange = binarySearchShards(parentToChildShards.get(shardRange.getShardId()), hash);
+        }
+        assert shardRange != null;
+
+        return shardRange.getShardId();
+    }
+
+    private ShardRange binarySearchShards(ShardRange[] childShards, int hash) {
+        int low = 0, high = childShards.length - 1;
+        while (low <= high) {
+            int mid = low + (high - low) / 2;
+            ShardRange midShard = childShards[mid];
+            if (midShard.contains(hash)) {
+                return midShard;
+            } else if (hash < midShard.getStart()) {
+                high = mid - 1;
+            } else {
+                low = mid + 1;
+            }
+        }
+        return null;
+    }
+
+    public int getNumberOfRootShards() {
+        return rootShardsToAllChildren.length;
+    }
+
+    public int getNumberOfShards() {
+        return maxShardId + 1;
+    }
+
+    public ShardRange[] getChildShardsOfParent(int shardId) {
+        if (parentToChildShards.containsKey(shardId) == false) {
+            return null;
+        }
+
+        ShardRange[] childShards = new ShardRange[parentToChildShards.get(shardId).length];
+        int childShardIdx = 0;
+        for (ShardRange childShard : parentToChildShards.get(shardId)) {
+            childShards[childShardIdx++] = childShard.copy();
+        }
+        return childShards;
+    }
+
+    public int numberOfEmptyParentShards() {
+        int emptyParents = parentToChildShards.size();
+        if (inProgressSplitShardId != SPLIT_NOT_IN_PROGRESS) {
+            emptyParents -= 1;
+        }
+        return emptyParents;
+    }
+
+    private static void validateShardRanges(int shardId, ShardRange[] shardRanges) {
+        Integer start = null;
+        for (ShardRange shardRange : shardRanges) {
+            validateBounds(shardRange, start);
+            long rangeEnd = shardRange.getEnd();
+            long rangeLength = rangeEnd - shardRange.getStart() + 1;
+            if (rangeLength < MINIMUM_RANGE_LENGTH_THRESHOLD) {
+                throw new IllegalArgumentException(
+                    "Shard range from " + shardRange.getStart() + " to " + shardRange.getEnd()
+                        + " is below shard range threshold of " + MINIMUM_RANGE_LENGTH_THRESHOLD);
+            }
+
+            start = shardRange.getEnd();
+        }
+
+        if (start == null) {
+            throw new IllegalArgumentException("No shard range defined for child shards of shard " + shardId);
+        }
+
+        if (start != Integer.MAX_VALUE) {
+            throw new IllegalArgumentException(
+                "Shard range from " + (start + 1) + " to " + Integer.MAX_VALUE
+                    + " is missing from the list of shard ranges");
+        }
+    }
+
+    private static void validateBounds(ShardRange shardRange, Integer start) {
+        if (start == null) {
+            if (shardRange.getStart() != Integer.MIN_VALUE) {
+                throw new IllegalArgumentException(
+                    "Shard range from " + Integer.MIN_VALUE + " to " + (shardRange.getStart() - 1)
+                        + " is missing from the list of shard ranges");
+            }
+        } else if (shardRange.getStart() != start + 1) {
+            throw new IllegalArgumentException(
+                "Shard range from " + (start + 1) + " to " + (shardRange.getStart() - 1)
+                    + " is missing from the list of shard ranges");
+        }
+    }
+
+    public static class Builder {
+        private final ShardRange[][] rootShardsToAllChildren;
+        private final Map<Integer, ShardRange[]> parentToChildShards;
+        private int maxShardId;
+        private int inProgressSplitShardId;
+
+        public Builder(int numberOfShards) {
+            maxShardId = numberOfShards - 1;
+            rootShardsToAllChildren = new ShardRange[numberOfShards][];
+            parentToChildShards = new HashMap<>();
+            inProgressSplitShardId = SPLIT_NOT_IN_PROGRESS;
+        }
+
+        public Builder(SplitShardsMetadata splitShardsMetadata) {
+            this.maxShardId = splitShardsMetadata.maxShardId;
+
+            this.rootShardsToAllChildren = new ShardRange[splitShardsMetadata.rootShardsToAllChildren.length][];
+            for (int i = 0; i < splitShardsMetadata.rootShardsToAllChildren.length; i++) {
+                if (splitShardsMetadata.rootShardsToAllChildren[i] != null) {
+                    this.rootShardsToAllChildren[i] = new ShardRange[splitShardsMetadata.rootShardsToAllChildren[i].length];
+                    int j = 0;
+                    for (ShardRange childShard : splitShardsMetadata.rootShardsToAllChildren[i]) {
+                        this.rootShardsToAllChildren[i][j++] = childShard.copy();
+                    }
+                }
+            }
+
+            this.parentToChildShards = new HashMap<>();
+            for (Integer parentShardId : splitShardsMetadata.parentToChildShards.keySet()) {
+                // Getting a copy of child shards for this parent.
+                ShardRange[] childShards = splitShardsMetadata.getChildShardsOfParent(parentShardId);
+                this.parentToChildShards.put(parentShardId, childShards);
+            }
+
+            inProgressSplitShardId = splitShardsMetadata.inProgressSplitShardId;
+        }
+
+        /**
+         * Create metadata of new child shards for the provided shard id.
+         * @param splitShardId Shard id to split
+         * @param numberOfChildren Number of child shards this shard is going to have.
+         */
+        public void splitShard(int splitShardId, int numberOfChildren) {
+            if (inProgressSplitShardId != SPLIT_NOT_IN_PROGRESS || parentToChildShards.containsKey(splitShardId)) {
+                throw new IllegalArgumentException("Split of shard [" + inProgressSplitShardId +
+                    "] is already in progress or completed.");
+            }
+
+            inProgressSplitShardId = splitShardId;
+
+            Tuple<Integer, ShardRange> shardTuple = findRootAndShard(splitShardId, rootShardsToAllChildren);
+            if (shardTuple == null) {
+                throw new IllegalArgumentException("Invalid shard id provided for splitting");
+            }
+            ShardRange parentShard = shardTuple.v2();
+
+            long rangeSize = ((long)parentShard.getEnd() - parentShard.getStart()) / numberOfChildren;
+
+            if(rangeSize <= MINIMUM_RANGE_LENGTH_THRESHOLD) {
+                throw new IllegalArgumentException("Cannot split shard [" + splitShardId + "] further.");
+            }
+
+            long start = parentShard.getStart();
+            List<ShardRange> newChildShardsList = new ArrayList<>();
+            int nextChildShardId = maxShardId + 1;
+            for (int i = 0; i < numberOfChildren; ++i) {
+                long end = i == numberOfChildren - 1 ? parentShard.getEnd() : start + rangeSize;
+                int childShardId = nextChildShardId++;
+                ShardRange childShard = new ShardRange(childShardId, (int) start, (int) end);
+                newChildShardsList.add(childShard);
+                start = end + 1;
+            }
+            ShardRange[] newShardRanges = newChildShardsList.toArray(new ShardRange[0]);
+            validateShardRanges(splitShardId, newShardRanges);
+
+            parentToChildShards.put(splitShardId, newShardRanges);
+        }
+
+        public void updateSplitMetadataForChildShards(int sourceShardId, Set<Integer> newChildShardIds) {
+            Tuple<Integer, ShardRange> shardRangeTuple = findRootAndShard(sourceShardId, rootShardsToAllChildren);
+            assert shardRangeTuple != null;
+
+            assert newChildShardIds.size() == parentToChildShards.get(sourceShardId).length;
+            for (ShardRange childShard : parentToChildShards.get(sourceShardId)) {
+                assert newChildShardIds.contains(childShard.getShardId());
+            }
+
+            List<ShardRange> shardsUnderRoot = rootShardsToAllChildren[shardRangeTuple.v1()] == null ? new ArrayList<>() :
+                Arrays.asList(rootShardsToAllChildren[shardRangeTuple.v1()]);
+            shardsUnderRoot.remove(shardRangeTuple.v2());
+            shardsUnderRoot.addAll(Arrays.asList(parentToChildShards.get(sourceShardId)));
+            ShardRange[] newShardsUnderRoot = shardsUnderRoot.toArray(new ShardRange[0]);
+            Arrays.sort(newShardsUnderRoot);
+            validateShardRanges(shardRangeTuple.v1(), newShardsUnderRoot);
+
+            maxShardId += newChildShardIds.size();
+            rootShardsToAllChildren[shardRangeTuple.v1()] = newShardsUnderRoot;
+            inProgressSplitShardId = SPLIT_NOT_IN_PROGRESS;
+        }
+
+        public void cancelSplit(int sourceShardId) {
+            assert inProgressSplitShardId != SPLIT_NOT_IN_PROGRESS;
+            parentToChildShards.remove(sourceShardId);
+            inProgressSplitShardId = SPLIT_NOT_IN_PROGRESS;
+        }
+
+        public SplitShardsMetadata build() {
+            return new SplitShardsMetadata(this.rootShardsToAllChildren, this.parentToChildShards,
+                this.inProgressSplitShardId, this.maxShardId);
+        }
+    }
+
+    private static Tuple<Integer, ShardRange> findRootAndShard(int shardId, ShardRange[][] rootShardsToAllChildren) {
+        ShardRange[] allChildren;
+        for (int rootShardId = 0; rootShardId < rootShardsToAllChildren.length; rootShardId++) {
+            allChildren = rootShardsToAllChildren[rootShardId];
+            if (allChildren != null) {
+                for (ShardRange shardUnderRoot : allChildren) {
+                    if (shardUnderRoot.getShardId() == shardId) {
+                        return new Tuple<>(rootShardId, shardUnderRoot);
+                    }
+                }
+            }
+        }
+
+        if (shardId < rootShardsToAllChildren.length && rootShardsToAllChildren[shardId] == null) {
+            // We are splitting a root shard in this case.
+            return new Tuple<>(shardId, new ShardRange(shardId, Integer.MIN_VALUE, Integer.MAX_VALUE));
+        }
+
+        throw new IllegalArgumentException("Shard ID doesn't exist in the current list of shard ranges");
+    }
+
+    public int getInProgressSplitShardId() {
+        return inProgressSplitShardId;
+    }
+
+    public boolean isSplitOfShardInProgress(int shardId) {
+        return inProgressSplitShardId == shardId;
+    }
+
+    public boolean isEmptyParentShard(int shardId) {
+        return isSplitOfShardInProgress(shardId) == false && parentToChildShards.containsKey(shardId);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof SplitShardsMetadata)) return false;
+
+        SplitShardsMetadata that = (SplitShardsMetadata) o;
+
+        if (maxShardId != that.maxShardId) return false;
+        if (inProgressSplitShardId != that.inProgressSplitShardId) return false;
+        if (!Arrays.deepEquals(rootShardsToAllChildren, that.rootShardsToAllChildren)) return false;
+        return parentToChildShards.equals(that.parentToChildShards);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = Arrays.deepHashCode(rootShardsToAllChildren);
+        result = 31 * result + parentToChildShards.hashCode();
+        result = 31 * result + maxShardId;
+        result = 31 * result + inProgressSplitShardId;
+        return result;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.field(KEY_NUMBER_OF_ROOT_SHARDS, rootShardsToAllChildren.length);
+        builder.field(KEY_MAX_SHARD_ID, maxShardId);
+        builder.field(KEY_IN_PROGRESS_SPLIT_SHARD_ID, inProgressSplitShardId);
+        builder.startObject(KEY_ROOT_SHARDS_TO_ALL_CHILDREN);
+        for (int rootShardId = 0; rootShardId < rootShardsToAllChildren.length; rootShardId++) {
+            ShardRange[] childShards = rootShardsToAllChildren[rootShardId];
+            if (childShards != null) {
+                builder.startArray(String.valueOf(rootShardId));
+                for (ShardRange childShard : childShards) {
+                    childShard.toXContent(builder, params);
+                }
+                builder.endArray();
+            }
+        }
+        builder.endObject();
+
+        builder.startObject(KEY_TEMP_SHARD_ID_TO_CHILD_SHARDS);
+        for (Integer parentShardId : parentToChildShards.keySet()) {
+            builder.startArray(String.valueOf(parentShardId));
+            for (ShardRange childShard : parentToChildShards.get(parentShardId)) {
+                childShard.toXContent(builder, params);
+            }
+            builder.endArray();
+        }
+        builder.endObject();
+
+        return builder;
+    }
+
+    public static SplitShardsMetadata parse(XContentParser parser) throws IOException {
+        XContentParser.Token token;
+        String currentFieldName = null;
+        int maxShardId = -1, inProgressSplitShardId = SPLIT_NOT_IN_PROGRESS;
+        ShardRange[][] rootShardsToAllChildren = null;
+        Map<Integer, ShardRange[]> tempShardIdToChildShards = new HashMap<>();
+        int numberOfRootShards = -1;
+        while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
+            if (token == XContentParser.Token.FIELD_NAME) {
+                currentFieldName = parser.currentName();
+            } else if (token == XContentParser.Token.VALUE_NUMBER) {
+                if (KEY_MAX_SHARD_ID.equals(currentFieldName)) {
+                    maxShardId = parser.intValue();
+                } else if (KEY_IN_PROGRESS_SPLIT_SHARD_ID.equals(currentFieldName)) {
+                    inProgressSplitShardId = parser.intValue();
+                } else if (KEY_NUMBER_OF_ROOT_SHARDS.equals(currentFieldName)) {
+                    numberOfRootShards = parser.intValue();
+                }
+            } else if (token == XContentParser.Token.START_OBJECT) {
+                if (KEY_ROOT_SHARDS_TO_ALL_CHILDREN.equals(currentFieldName)) {
+                    Map<Integer, ShardRange[]> rootShards = parseShardsMap(parser);
+                    rootShardsToAllChildren = new ShardRange[numberOfRootShards][];
+                    for (Map.Entry<Integer, ShardRange[]> entry : rootShards.entrySet()) {
+                        rootShardsToAllChildren[entry.getKey()] = entry.getValue();
+                    }
+                } else if (KEY_TEMP_SHARD_ID_TO_CHILD_SHARDS.equals(currentFieldName)) {
+                    tempShardIdToChildShards = parseShardsMap(parser);
+                }
+            }
+        }
+
+        return new SplitShardsMetadata(rootShardsToAllChildren, tempShardIdToChildShards, inProgressSplitShardId, maxShardId);
+    }
+
+    private static Map<Integer, ShardRange[]> parseShardsMap(XContentParser parser) throws IOException {
+        XContentParser.Token token;
+        String currentFieldName = null;
+        Map<Integer, ShardRange[]> shardsMap = new HashMap<>();
+        while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
+            if (token == XContentParser.Token.FIELD_NAME) {
+                currentFieldName = parser.currentName();
+            } else if (token == XContentParser.Token.START_ARRAY) {
+                List<ShardRange> childShardRanges = new ArrayList<>();
+                while (parser.nextToken() != XContentParser.Token.END_ARRAY) {
+                    ShardRange shardRange = ShardRange.parse(parser);
+                    childShardRanges.add(shardRange);
+                }
+                assert currentFieldName != null;
+                Integer parentShard = Integer.parseInt(currentFieldName);
+                shardsMap.put(parentShard, childShardRanges.toArray(new ShardRange[0]));
+            }
+        }
+
+        return shardsMap;
+    }
+
+    public static Diff<SplitShardsMetadata> readDiffFrom(StreamInput in) throws IOException {
+        return readDiffFrom(SplitShardsMetadata::new, in);
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/cluster/routing/AllocationId.java b/server/src/main/java/org/opensearch/cluster/routing/AllocationId.java
index ade3afa4a500c..da30dec1680e3 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/AllocationId.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/AllocationId.java
@@ -32,6 +32,7 @@
 
 package org.opensearch.cluster.routing;
 
+import org.opensearch.Version;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.annotation.PublicApi;
@@ -45,6 +46,8 @@
 import org.opensearch.core.xcontent.XContentParser;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Objects;
 
 /**
@@ -62,17 +65,26 @@
 public class AllocationId implements ToXContentObject, Writeable {
     private static final String ID_KEY = "id";
     private static final String RELOCATION_ID_KEY = "relocation_id";
+    private static final String SPLIT_CHILD_ALLOCATION_IDS = "split_child_allocation_ids";
+    private static final String PARENT_ALLOCATION_ID = "parent_allocation_id";
 
     private static final ObjectParser<AllocationId.Builder, Void> ALLOCATION_ID_PARSER = new ObjectParser<>("allocationId");
 
     static {
         ALLOCATION_ID_PARSER.declareString(AllocationId.Builder::setId, new ParseField(ID_KEY));
         ALLOCATION_ID_PARSER.declareString(AllocationId.Builder::setRelocationId, new ParseField(RELOCATION_ID_KEY));
+        ALLOCATION_ID_PARSER.declareStringArray(
+            AllocationId.Builder::setSplitChildAllocationIds,
+            new ParseField(SPLIT_CHILD_ALLOCATION_IDS)
+        );
+        ALLOCATION_ID_PARSER.declareString(AllocationId.Builder::setParentAllocationId, new ParseField(PARENT_ALLOCATION_ID));
     }
 
     private static class Builder {
         private String id;
         private String relocationId;
+        private List<String> splitChildAllocationIds;
+        private String parentAllocationId;
 
         public void setId(String id) {
             this.id = id;
@@ -82,44 +94,71 @@ public void setRelocationId(String relocationId) {
             this.relocationId = relocationId;
         }
 
+        public void setSplitChildAllocationIds(List<String> splitChildAllocationIds) {
+            this.splitChildAllocationIds = splitChildAllocationIds;
+        }
+
+        public void setParentAllocationId(String parentAllocationId) {
+            this.parentAllocationId = parentAllocationId;
+        }
+
         public AllocationId build() {
-            return new AllocationId(id, relocationId);
+            return new AllocationId(id, relocationId, splitChildAllocationIds, parentAllocationId);
         }
     }
 
     private final String id;
     @Nullable
     private final String relocationId;
+    @Nullable
+    private final List<String> splitChildAllocationIds;
+    @Nullable
+    private final String parentAllocationId;
 
     AllocationId(StreamInput in) throws IOException {
         this.id = in.readString();
         this.relocationId = in.readOptionalString();
+        if (in.getVersion().onOrAfter(Version.V_3_0_0)) {
+            splitChildAllocationIds = in.readOptionalStringList();
+            parentAllocationId = in.readOptionalString();
+        } else {
+            splitChildAllocationIds = null;
+            parentAllocationId = null;
+        }
     }
 
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         out.writeString(this.id);
         out.writeOptionalString(this.relocationId);
+        if (out.getVersion().onOrAfter(Version.V_3_0_0)) {
+            out.writeOptionalStringCollection(splitChildAllocationIds);
+            out.writeOptionalString(parentAllocationId);
+        } else {
+            throw new IllegalStateException("In-place split not allowed on older versions.");
+        }
     }
 
-    private AllocationId(String id, String relocationId) {
+    private AllocationId(String id, String relocationId, List<String> splitChildAllocationIds, String parentAllocationId) {
         Objects.requireNonNull(id, "Argument [id] must be non-null");
         this.id = id;
         this.relocationId = relocationId;
+        this.splitChildAllocationIds = splitChildAllocationIds;
+        this.parentAllocationId = parentAllocationId;
     }
 
     /**
      * Creates a new allocation id for initializing allocation.
      */
     public static AllocationId newInitializing() {
-        return new AllocationId(UUIDs.randomBase64UUID(), null);
+        return new AllocationId(UUIDs.randomBase64UUID(), null, null, null);
     }
 
     /**
      * Creates a new allocation id for initializing allocation based on an existing id.
      */
     public static AllocationId newInitializing(String existingAllocationId) {
-        return new AllocationId(existingAllocationId, null);
+        return new AllocationId(existingAllocationId, null, null, null);
     }
 
     /**
@@ -128,7 +167,16 @@ public static AllocationId newInitializing(String existingAllocationId) {
      */
     public static AllocationId newTargetRelocation(AllocationId allocationId) {
         assert allocationId.getRelocationId() != null;
-        return new AllocationId(allocationId.getRelocationId(), allocationId.getId());
+        return new AllocationId(allocationId.getRelocationId(), allocationId.getId(), null, null);
+    }
+
+    /**
+     * Creates a new allocation id for the target initializing shard that is the result
+     * of a relocation.
+     */
+    public static AllocationId newTargetSplit(AllocationId allocationId, String childAllocId) {
+        assert allocationId.getSplitChildAllocationIds() != null;
+        return new AllocationId(childAllocId, null, null, allocationId.getId());
     }
 
     /**
@@ -137,7 +185,20 @@ public static AllocationId newTargetRelocation(AllocationId allocationId) {
      */
     public static AllocationId newRelocation(AllocationId allocationId) {
         assert allocationId.getRelocationId() == null;
-        return new AllocationId(allocationId.getId(), UUIDs.randomBase64UUID());
+        return new AllocationId(allocationId.getId(), UUIDs.randomBase64UUID(), null, null);
+    }
+
+    /**
+     * Creates a new allocation id for a shard that is undergoing split, populating
+     * the transient holder for splitChildAllocationIds.
+     */
+    public static AllocationId newSplit(AllocationId allocationId, int numberOfChildShards) {
+        assert allocationId.getSplitChildAllocationIds() == null && allocationId.getParentAllocationId() == null;
+        List<String> splitChildAllocationIds = new ArrayList<>();
+        for (int c = 0; c < numberOfChildShards; c++) {
+            splitChildAllocationIds.add(UUIDs.randomBase64UUID());
+        }
+        return new AllocationId(allocationId.getId(), null, splitChildAllocationIds, null);
     }
 
     /**
@@ -148,7 +209,18 @@ public static AllocationId newRelocation(AllocationId allocationId) {
      */
     public static AllocationId cancelRelocation(AllocationId allocationId) {
         assert allocationId.getRelocationId() != null;
-        return new AllocationId(allocationId.getId(), null);
+        return new AllocationId(allocationId.getId(), null, null, null);
+    }
+
+    /**
+     * Creates a new allocation id representing a cancelled split.
+     * <p>
+     * Note that this is expected to be called on the allocation id
+     * of the *source* shard
+     */
+    public static AllocationId cancelSplit(AllocationId allocationId) {
+        assert allocationId.getSplitChildAllocationIds() != null;
+        return new AllocationId(allocationId.getId(), null, null, null);
     }
 
     /**
@@ -159,7 +231,18 @@ public static AllocationId cancelRelocation(AllocationId allocationId) {
      */
     public static AllocationId finishRelocation(AllocationId allocationId) {
         assert allocationId.getRelocationId() != null;
-        return new AllocationId(allocationId.getId(), null);
+        return new AllocationId(allocationId.getId(), null, null, null);
+    }
+
+    /**
+     * Creates a new allocation id finalizing a split.
+     * <p>
+     * Note that this is expected to be called on the allocation id
+     * of the *target* shard and thus it only needs to clear the parent allocation id.
+     */
+    public static AllocationId finishSplit(AllocationId allocationId) {
+        assert allocationId.getParentAllocationId() != null;
+        return new AllocationId(allocationId.getId(), null, null, null);
     }
 
     /**
@@ -177,27 +260,34 @@ public String getRelocationId() {
         return relocationId;
     }
 
+    /**
+     * The transient split child allocation ids holding the unique ids which are used for split.
+     */
+    public List<String> getSplitChildAllocationIds() {
+        return splitChildAllocationIds;
+    }
+
+    /**
+     * The transient split parent allocation id holding the unique id that is used for split.
+     */
+    public String getParentAllocationId() {
+        return parentAllocationId;
+    }
+
     @Override
     public boolean equals(Object o) {
-        if (this == o) {
-            return true;
-        }
-        if (o == null || getClass() != o.getClass()) {
-            return false;
-        }
+        if (this == o) return true;
+        if (!(o instanceof AllocationId)) return false;
         AllocationId that = (AllocationId) o;
-        if (!id.equals(that.id)) {
-            return false;
-        }
-        return !(relocationId != null ? !relocationId.equals(that.relocationId) : that.relocationId != null);
-
+        return Objects.equals(id, that.id)
+            && Objects.equals(relocationId, that.relocationId)
+            && Objects.equals(splitChildAllocationIds, that.splitChildAllocationIds)
+            && Objects.equals(parentAllocationId, that.parentAllocationId);
     }
 
     @Override
     public int hashCode() {
-        int result = id.hashCode();
-        result = 31 * result + (relocationId != null ? relocationId.hashCode() : 0);
-        return result;
+        return Objects.hash(id, relocationId, splitChildAllocationIds, parentAllocationId);
     }
 
     @Override
@@ -212,6 +302,16 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         if (relocationId != null) {
             builder.field(RELOCATION_ID_KEY, relocationId);
         }
+        if (splitChildAllocationIds != null) {
+            builder.startArray(SPLIT_CHILD_ALLOCATION_IDS);
+            for (String index : splitChildAllocationIds) {
+                builder.value(index);
+            }
+            builder.endArray();
+        }
+        if (parentAllocationId != null) {
+            builder.field(PARENT_ALLOCATION_ID, parentAllocationId);
+        }
         builder.endObject();
         return builder;
     }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java b/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java
index 08574dddc007c..681284b6b26dc 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java
@@ -33,6 +33,7 @@
 package org.opensearch.cluster.routing;
 
 import org.apache.lucene.util.CollectionUtil;
+import org.opensearch.Version;
 import org.opensearch.cluster.AbstractDiffable;
 import org.opensearch.cluster.Diff;
 import org.opensearch.cluster.metadata.IndexMetadata;
@@ -93,12 +94,15 @@ public class IndexRoutingTable extends AbstractDiffable<IndexRoutingTable>
     // shards with state set to UNASSIGNED
     private final Map<Integer, IndexShardRoutingTable> shards;
 
+    private final Map<Integer, IndexShardRoutingTable> childReplicas;
+
     private final List<ShardRouting> allActiveShards;
 
-    IndexRoutingTable(Index index, final Map<Integer, IndexShardRoutingTable> shards) {
+    IndexRoutingTable(Index index, final Map<Integer, IndexShardRoutingTable> shards, Map<Integer, IndexShardRoutingTable> childReplicas) {
         this.index = index;
         this.shuffler = new RotationShardShuffler(Randomness.get().nextInt());
         this.shards = Collections.unmodifiableMap(shards);
+        this.childReplicas = Collections.unmodifiableMap(childReplicas);
         List<ShardRouting> allActiveShards = new ArrayList<>();
         for (IndexShardRoutingTable cursor : shards.values()) {
             for (ShardRouting shardRouting : cursor) {
@@ -130,10 +134,12 @@ boolean validate(Metadata metadata) {
         }
 
         // check the number of shards
-        if (indexMetadata.getNumberOfShards() != shards().size()) {
+        if (indexMetadata.getNumberOfShards() - indexMetadata.getSplitShardsMetadata().numberOfEmptyParentShards() != shards().size()) {
             Set<Integer> expected = new HashSet<>();
             for (int i = 0; i < indexMetadata.getNumberOfShards(); i++) {
-                expected.add(i);
+                if (indexMetadata.getSplitShardsMetadata().isEmptyParentShard(i) == false) {
+                    expected.add(i);
+                }
             }
             for (IndexShardRoutingTable indexShardRoutingTable : this) {
                 expected.remove(indexShardRoutingTable.shardId().id());
@@ -166,7 +172,7 @@ boolean validate(Metadata metadata) {
                 }
                 final Set<String> inSyncAllocationIds = indexMetadata.inSyncAllocationIds(shardRouting.id());
                 if (shardRouting.active()
-                    && inSyncAllocationIds.contains(shardRouting.allocationId().getId()) == false
+                    && (inSyncAllocationIds == null || inSyncAllocationIds.contains(shardRouting.allocationId().getId()) == false)
                     && shardRouting.isSearchOnly() == false) {
                     throw new IllegalStateException(
                         "active shard routing "
@@ -242,6 +248,10 @@ public int numberOfNodesShardsAreAllocatedOn(String... excludedNodes) {
         return nodes.size();
     }
 
+    public Map<Integer, IndexShardRoutingTable> getChildReplicas() {
+        return childReplicas;
+    }
+
     public Map<Integer, IndexShardRoutingTable> shards() {
         return shards;
     }
@@ -254,6 +264,10 @@ public IndexShardRoutingTable shard(int shardId) {
         return shards.get(shardId);
     }
 
+    public IndexShardRoutingTable childReplicaShard(int shardId) {
+        return childReplicas.get(shardId);
+    }
+
     /**
      * Returns <code>true</code> if all shards are primary and active. Otherwise <code>false</code>.
      */
@@ -350,6 +364,7 @@ public boolean equals(Object o) {
 
         if (!index.equals(that.index)) return false;
         if (!shards.equals(that.shards)) return false;
+        if (!childReplicas.equals(that.childReplicas)) return false;
 
         return true;
     }
@@ -358,6 +373,7 @@ public boolean equals(Object o) {
     public int hashCode() {
         int result = index.hashCode();
         result = 31 * result + shards.hashCode();
+        result = 31 * result + childReplicas.hashCode();
         return result;
     }
 
@@ -374,6 +390,12 @@ public static IndexRoutingTable readFrom(StreamInput in) throws IOException {
         for (int i = 0; i < size; i++) {
             builder.addIndexShard(IndexShardRoutingTable.Builder.readFromThin(in, index));
         }
+        if (in.getVersion().onOrAfter(Version.V_3_0_0)) {
+            int noOfChildReplicas = in.readVInt();
+            for (int i = 0; i < noOfChildReplicas; i++) {
+                builder.addChildReplicaShard(IndexShardRoutingTable.Builder.readFromThin(in, index));
+            }
+        }
 
         return builder.build();
     }
@@ -389,6 +411,12 @@ public void writeTo(StreamOutput out) throws IOException {
         for (IndexShardRoutingTable indexShard : this) {
             IndexShardRoutingTable.Builder.writeToThin(indexShard, out);
         }
+        if (out.getVersion().onOrAfter(Version.V_3_0_0)) {
+            out.writeVInt(childReplicas.size());
+            for (IndexShardRoutingTable indexShard : childReplicas.values()) {
+                IndexShardRoutingTable.Builder.writeToThin(indexShard, out);
+            }
+        }
     }
 
     public void writeVerifiableTo(BufferedChecksumStreamOutput out) throws IOException {
@@ -410,6 +438,7 @@ public static class Builder {
 
         private final Index index;
         private final Map<Integer, IndexShardRoutingTable> shards = new HashMap<>();
+        private final Map<Integer, IndexShardRoutingTable> childReplicas = new HashMap<>();
 
         public Builder(Index index) {
             this.index = index;
@@ -642,6 +671,7 @@ private Builder initializeEmpty(IndexMetadata indexMetadata, UnassignedInfo unas
                 }
                 shards.put(shardNumber, indexShardRoutingBuilder.build());
             }
+
             return this;
         }
 
@@ -757,6 +787,11 @@ public Builder addIndexShard(IndexShardRoutingTable indexShard) {
             return this;
         }
 
+        public Builder addChildReplicaShard(IndexShardRoutingTable indexShard) {
+            childReplicas.put(indexShard.shardId().id(), indexShard);
+            return this;
+        }
+
         /**
          * Adds a new shard routing (makes a copy of it), with reference data used from the index shard routing table
          * if it needs to be created.
@@ -772,8 +807,20 @@ public Builder addShard(ShardRouting shard) {
             return this;
         }
 
+        public Builder addChildReplica(ShardRouting childReplica) {
+            assert childReplica.started() && childReplica.getParentShardId() != null && childReplica.primary() == false;
+            IndexShardRoutingTable childReplicaShard = childReplicas.get(childReplica.shardId().id());
+            if (childReplicaShard == null) {
+                childReplicaShard = new IndexShardRoutingTable.Builder(childReplica.shardId()).addShard(childReplica).build();
+            } else {
+                childReplicaShard = new IndexShardRoutingTable.Builder(childReplicaShard).addShard(childReplica).build();
+            }
+            childReplicas.put(childReplica.id(), childReplicaShard);
+            return this;
+        }
+
         public IndexRoutingTable build() {
-            return new IndexRoutingTable(index, shards);
+            return new IndexRoutingTable(index, shards, childReplicas);
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java b/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java
index eb4177d7046ca..67cb1af79669c 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java
@@ -160,6 +160,16 @@ public class IndexShardRoutingTable extends AbstractDiffable<IndexShardRoutingTa
                 assert shard.getTargetRelocatingShard().assignedToNode() : "relocating to unassigned " + shard.getTargetRelocatingShard();
                 assignedShards.add(shard.getTargetRelocatingShard());
             }
+            if (shard.splitting()) {
+                for (ShardRouting targetChild : shard.getRecoveringChildShards()) {
+                    allInitializingShards.add(targetChild);
+                    allAllocationIds.add(targetChild.allocationId().getId());
+
+                    assert shard.assignedToNode() : "relocating from unassigned " + shard;
+                    assert targetChild.assignedToNode() : "Child shard not assigned ";
+                    assignedShards.add(targetChild);
+                }
+            }
             if (shard.assignedToNode()) {
                 assignedShards.add(shard);
                 allAllocationIds.add(shard.allocationId().getId());
diff --git a/server/src/main/java/org/opensearch/cluster/routing/OperationRouting.java b/server/src/main/java/org/opensearch/cluster/routing/OperationRouting.java
index eac6f41acde4c..b9bc5c2325d33 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/OperationRouting.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/OperationRouting.java
@@ -60,6 +60,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 /**
@@ -491,12 +492,23 @@ protected IndexShardRoutingTable shards(ClusterState clusterState, String index,
         return clusterState.getRoutingTable().shardRoutingTable(index, shardId);
     }
 
+    public ShardId shardWithRecoveringChild(ClusterState clusterState, String index, String id, String routing,
+                                               Index shardIndex) {
+        int shardId = generateShardId(indexMetadata(clusterState, index), id, routing, true);
+        return new ShardId(shardIndex, shardId);
+    }
+
     public ShardId shardId(ClusterState clusterState, String index, String id, @Nullable String routing) {
         IndexMetadata indexMetadata = indexMetadata(clusterState, index);
         return new ShardId(indexMetadata.getIndex(), generateShardId(indexMetadata, id, routing));
     }
 
     public static int generateShardId(IndexMetadata indexMetadata, @Nullable String id, @Nullable String routing) {
+        return generateShardId(indexMetadata, id, routing, false);
+    }
+
+    public static int generateShardId(IndexMetadata indexMetadata, @Nullable String id, @Nullable String routing,
+                                      boolean includeInProgressChild) {
         final String effectiveRouting;
         final int partitionOffset;
 
@@ -514,15 +526,21 @@ public static int generateShardId(IndexMetadata indexMetadata, @Nullable String
             partitionOffset = 0;
         }
 
-        return calculateScaledShardId(indexMetadata, effectiveRouting, partitionOffset);
+        return calculateShardIdOfChild(indexMetadata, effectiveRouting, partitionOffset, includeInProgressChild);
     }
 
     private static int calculateScaledShardId(IndexMetadata indexMetadata, String effectiveRouting, int partitionOffset) {
-        final int hash = Murmur3HashFunction.hash(effectiveRouting) + partitionOffset;
+        return calculateShardIdOfChild(indexMetadata, effectiveRouting, partitionOffset, false);
+    }
 
+    private static int calculateShardIdOfChild(IndexMetadata indexMetadata, String effectiveRouting, int partitionOffset,
+                                               boolean includeInProgressChild) {
+        final int hash = Murmur3HashFunction.hash(effectiveRouting) + partitionOffset;
         // we don't use IMD#getNumberOfShards since the index might have been shrunk such that we need to use the size
         // of original index to hash documents
-        return Math.floorMod(hash, indexMetadata.getRoutingNumShards()) / indexMetadata.getRoutingFactor();
+        int rootShardId = Math.floorMod(hash, indexMetadata.getRoutingNumShards()) / indexMetadata.getRoutingFactor();
+
+        return indexMetadata.getSplitShardsMetadata().getShardIdOfHash(rootShardId, hash, includeInProgressChild);
     }
 
     private void checkPreferenceBasedRoutingAllowed(Preference preference, @Nullable WeightedRoutingMetadata weightedRoutingMetadata) {
diff --git a/server/src/main/java/org/opensearch/cluster/routing/RecoverySource.java b/server/src/main/java/org/opensearch/cluster/routing/RecoverySource.java
index ae96ea6b73cca..4d3f91bb92bc3 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/RecoverySource.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/RecoverySource.java
@@ -39,6 +39,7 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.ToXContentObject;
 import org.opensearch.core.xcontent.XContentBuilder;
@@ -56,7 +57,7 @@
  * - {@link PeerRecoverySource} recovery from a primary on another node
  * - {@link SnapshotRecoverySource} recovery from a snapshot
  * - {@link LocalShardsRecoverySource} recovery from other shards of another index on the same node
- *
+ * - {@link InPlaceShardSplitRecoverySource} recovery of child shards from a source shard on the same node
  * @opensearch.api
  */
 @PublicApi(since = "1.0.0")
@@ -90,6 +91,8 @@ public static RecoverySource readFrom(StreamInput in) throws IOException {
                 return new SnapshotRecoverySource(in);
             case LOCAL_SHARDS:
                 return LocalShardsRecoverySource.INSTANCE;
+            case IN_PLACE_SHARD_SPLIT:
+                return InPlaceShardSplitRecoverySource.INSTANCE;
             case REMOTE_STORE:
                 return new RemoteStoreRecoverySource(in);
             default:
@@ -122,6 +125,7 @@ public enum Type {
         PEER,
         SNAPSHOT,
         LOCAL_SHARDS,
+        IN_PLACE_SHARD_SPLIT,
         REMOTE_STORE
     }
 
@@ -247,6 +251,33 @@ public String toString() {
 
     }
 
+    /**
+     * recovery of child shards from a local source shard.
+     *
+     * @opensearch.internal
+     */
+    public static class InPlaceShardSplitRecoverySource extends RecoverySource {
+
+        public static final InPlaceShardSplitRecoverySource INSTANCE = new InPlaceShardSplitRecoverySource();
+
+        private InPlaceShardSplitRecoverySource() {}
+
+        @Override
+        public Type getType() {
+            return Type.IN_PLACE_SHARD_SPLIT;
+        }
+
+        @Override
+        public String toString() {
+            return "in-place shard split";
+        }
+
+        @Override
+        public boolean expectEmptyRetentionLeases() {
+            return false;
+        }
+    }
+
     /**
      * recovery from a snapshot
      *
diff --git a/server/src/main/java/org/opensearch/cluster/routing/RoutingChangesObserver.java b/server/src/main/java/org/opensearch/cluster/routing/RoutingChangesObserver.java
index 614cccb069048..3b3ad9c5c4b1a 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/RoutingChangesObserver.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/RoutingChangesObserver.java
@@ -32,8 +32,11 @@
 
 package org.opensearch.cluster.routing;
 
+import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.common.annotation.PublicApi;
 
+import java.util.List;
+
 /**
  * Records changes made to {@link RoutingNodes} during an allocation round.
  *
@@ -51,11 +54,26 @@ public interface RoutingChangesObserver {
      */
     void shardStarted(ShardRouting initializingShard, ShardRouting startedShard);
 
+    /**
+     * Called when a child replica is started.
+     */
+    void childReplicaStarted(ShardRouting initializingShard, ShardRouting parentShard, ShardRouting childShard);
+
+    /**
+     * Called when a child shard fails.
+     */
+    void childShardFailed(ShardRouting parentShard, ShardRouting childShard);
+
     /**
      * Called when relocation of a started shard is initiated.
      */
     void relocationStarted(ShardRouting startedShard, ShardRouting targetRelocatingShard);
 
+    /**
+     * Called when split of a started shard is initiated.
+     */
+    void splitStarted(ShardRouting startedShard, List<ShardRouting> childSplitShards);
+
     /**
      * Called when an unassigned shard's unassigned information was updated
      */
@@ -77,6 +95,21 @@ public interface RoutingChangesObserver {
      */
     void relocationSourceRemoved(ShardRouting removedReplicaRelocationSource);
 
+    /**
+     * Called when split completes after child shards are started.
+     */
+    void splitCompleted(ShardRouting removedSplitSource, IndexMetadata indexMetadata);
+
+    /**
+     * Called when in-place split of child shards has failed.
+     */
+    void splitFailed(ShardRouting splitSource, IndexMetadata indexMetadata);
+
+    /**
+     * Called to determine if shard split has failed in current cluster update.
+     */
+    boolean isSplitOfShardFailed(ShardRouting parentShard);
+
     /**
      * Called when started replica is promoted to primary.
      */
@@ -104,11 +137,26 @@ public void shardStarted(ShardRouting initializingShard, ShardRouting startedSha
 
         }
 
+        @Override
+        public void childReplicaStarted(ShardRouting initializingShard, ShardRouting parentShard, ShardRouting childReplica) {
+
+        }
+
+        @Override
+        public void childShardFailed(ShardRouting parentShard, ShardRouting childShard) {
+
+        }
+
         @Override
         public void relocationStarted(ShardRouting startedShard, ShardRouting targetRelocatingShard) {
 
         }
 
+        @Override
+        public void splitStarted(ShardRouting startedShard, List<ShardRouting> childSplitShards) {
+
+        }
+
         @Override
         public void unassignedInfoUpdated(ShardRouting unassignedShard, UnassignedInfo newUnassignedInfo) {
 
@@ -119,6 +167,11 @@ public void shardFailed(ShardRouting activeShard, UnassignedInfo unassignedInfo)
 
         }
 
+        @Override
+        public boolean isSplitOfShardFailed(ShardRouting parentShard) {
+            return false;
+        }
+
         @Override
         public void relocationCompleted(ShardRouting removedRelocationSource) {
 
@@ -129,6 +182,16 @@ public void relocationSourceRemoved(ShardRouting removedReplicaRelocationSource)
 
         }
 
+        @Override
+        public void splitCompleted(ShardRouting removedSplitSource, IndexMetadata indexMetadata) {
+
+        }
+
+        @Override
+        public void splitFailed(ShardRouting splitSource, IndexMetadata indexMetadata) {
+
+        }
+
         @Override
         public void replicaPromoted(ShardRouting replicaShard) {
 
@@ -174,6 +237,24 @@ public void relocationStarted(ShardRouting startedShard, ShardRouting targetRelo
             }
         }
 
+        @Override
+        public void splitStarted(ShardRouting startedShard, List<ShardRouting> childSplitShards) {
+            for (RoutingChangesObserver routingChangesObserver : routingChangesObservers) {
+                routingChangesObserver.splitStarted(startedShard, childSplitShards);
+            }
+        }
+
+        @Override
+        public boolean isSplitOfShardFailed(ShardRouting parentShard) {
+            for (RoutingChangesObserver routingChangesObserver : routingChangesObservers) {
+                if (routingChangesObserver.isSplitOfShardFailed(parentShard)) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
         @Override
         public void unassignedInfoUpdated(ShardRouting unassignedShard, UnassignedInfo newUnassignedInfo) {
             for (RoutingChangesObserver routingChangesObserver : routingChangesObservers) {
@@ -202,6 +283,34 @@ public void relocationSourceRemoved(ShardRouting removedReplicaRelocationSource)
             }
         }
 
+        @Override
+        public void childReplicaStarted(ShardRouting initializingShard, ShardRouting parentShard, ShardRouting childReplica) {
+            for (RoutingChangesObserver routingChangesObserver : routingChangesObservers) {
+                routingChangesObserver.childReplicaStarted(initializingShard, parentShard, childReplica);
+            }
+        }
+
+        @Override
+        public void childShardFailed(ShardRouting parentShard, ShardRouting childShard) {
+            for (RoutingChangesObserver routingChangesObserver : routingChangesObservers) {
+                routingChangesObserver.childShardFailed(parentShard, childShard);
+            }
+        }
+
+        @Override
+        public void splitCompleted(ShardRouting removedSplitSource, IndexMetadata indexMetadata) {
+            for (RoutingChangesObserver routingChangesObserver : routingChangesObservers) {
+                routingChangesObserver.splitCompleted(removedSplitSource, indexMetadata);
+            }
+        }
+
+        @Override
+        public void splitFailed(ShardRouting splitSource, IndexMetadata indexMetadata) {
+            for (RoutingChangesObserver routingChangesObserver : routingChangesObservers) {
+                routingChangesObserver.splitFailed(splitSource, indexMetadata);
+            }
+        }
+
         @Override
         public void replicaPromoted(ShardRouting replicaShard) {
             for (RoutingChangesObserver routingChangesObserver : routingChangesObservers) {
diff --git a/server/src/main/java/org/opensearch/cluster/routing/RoutingNode.java b/server/src/main/java/org/opensearch/cluster/routing/RoutingNode.java
index 24c3077960444..ccf29692c4f3f 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/RoutingNode.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/RoutingNode.java
@@ -135,6 +135,7 @@ public Iterator<ShardRouting> iterator() {
     private final LinkedHashSet<ShardRouting> initializingShards;
 
     private final LinkedHashSet<ShardRouting> relocatingShards;
+    private final LinkedHashSet<ShardRouting> splittingShards;
 
     private final HashMap<Index, LinkedHashSet<ShardRouting>> shardsByIndex;
 
@@ -146,6 +147,7 @@ public RoutingNode(String nodeId, DiscoveryNode node, ShardRouting... shardRouti
         this.shards = new BucketedShards(primaryShards, replicaShards);
         this.relocatingShards = new LinkedHashSet<>();
         this.initializingShards = new LinkedHashSet<>();
+        this.splittingShards = new LinkedHashSet<>();
         this.shardsByIndex = new LinkedHashMap<>();
 
         for (ShardRouting shardRouting : shardRoutings) {
@@ -153,6 +155,8 @@ public RoutingNode(String nodeId, DiscoveryNode node, ShardRouting... shardRouti
                 initializingShards.add(shardRouting);
             } else if (shardRouting.relocating()) {
                 relocatingShards.add(shardRouting);
+            } else if (shardRouting.splitting()) {
+                splittingShards.add(shardRouting);
             }
             shardsByIndex.computeIfAbsent(shardRouting.index(), k -> new LinkedHashSet<>()).add(shardRouting);
 
@@ -232,6 +236,8 @@ void add(ShardRouting shard) {
             initializingShards.add(shard);
         } else if (shard.relocating()) {
             relocatingShards.add(shard);
+        } else if (shard.splitting()) {
+            splittingShards.add(shard);
         }
         shardsByIndex.computeIfAbsent(shard.index(), k -> new LinkedHashSet<>()).add(shard);
         assert invariant();
@@ -253,6 +259,9 @@ void update(ShardRouting oldShard, ShardRouting newShard) {
         } else if (oldShard.relocating()) {
             boolean exist = relocatingShards.remove(oldShard);
             assert exist : "expected shard " + oldShard + " to exist in relocatingShards";
+        } else if (oldShard.splitting()) {
+            boolean exist = splittingShards.remove(oldShard);
+            assert exist : "expected shard " + oldShard + " to exist in splittingShards";
         }
         shardsByIndex.get(oldShard.index()).remove(oldShard);
         if (shardsByIndex.get(oldShard.index()).isEmpty()) {
@@ -262,6 +271,8 @@ void update(ShardRouting oldShard, ShardRouting newShard) {
             initializingShards.add(newShard);
         } else if (newShard.relocating()) {
             relocatingShards.add(newShard);
+        } else if (newShard.splitting()) {
+            splittingShards.add(newShard);
         }
         shardsByIndex.computeIfAbsent(newShard.index(), k -> new LinkedHashSet<>()).add(newShard);
         assert invariant();
@@ -277,6 +288,9 @@ void remove(ShardRouting shard) {
         } else if (shard.relocating()) {
             boolean exist = relocatingShards.remove(shard);
             assert exist : "expected shard " + shard + " to exist in relocatingShards";
+        } else if (shard.splitting()) {
+            boolean exist = splittingShards.remove(shard);
+            assert exist : "expected shard " + shard + " to exist in splittingShards";
         }
         shardsByIndex.get(shard.index()).remove(shard);
         if (shardsByIndex.get(shard.index()).isEmpty()) {
@@ -296,6 +310,8 @@ public int numberOfShardsWithState(ShardRoutingState... states) {
                 return initializingShards.size();
             } else if (states[0] == ShardRoutingState.RELOCATING) {
                 return relocatingShards.size();
+            } else if (states[0] == ShardRoutingState.SPLITTING) {
+                return splittingShards.size();
             }
         }
 
@@ -321,6 +337,8 @@ public List<ShardRouting> shardsWithState(ShardRoutingState... states) {
                 return new ArrayList<>(initializingShards);
             } else if (states[0] == ShardRoutingState.RELOCATING) {
                 return new ArrayList<>(relocatingShards);
+            } else if (states[0] == ShardRoutingState.SPLITTING) {
+                return new ArrayList<>(splittingShards);
             }
         }
 
@@ -361,6 +379,14 @@ public List<ShardRouting> shardsWithState(String index, ShardRoutingState... sta
                     shards.add(shardEntry);
                 }
                 return shards;
+            } else if (states[0] == ShardRoutingState.SPLITTING) {
+                for (ShardRouting shardEntry : splittingShards) {
+                    if (shardEntry.getIndexName().equals(index) == false) {
+                        continue;
+                    }
+                    shards.add(shardEntry);
+                }
+                return shards;
             }
         }
 
@@ -444,6 +470,13 @@ private boolean invariant() {
         assert relocatingShards.size() == shardRoutingsRelocating.size();
         assert relocatingShards.containsAll(shardRoutingsRelocating);
 
+        // splittingShards must be consistent with that in shards
+        Collection<ShardRouting> shardRoutingsSplitting = StreamSupport.stream(shards.spliterator(), false)
+            .filter(ShardRouting::splitting)
+            .collect(Collectors.toList());
+        assert splittingShards.size() == shardRoutingsSplitting.size();
+        assert splittingShards.containsAll(shardRoutingsSplitting);
+
         final Map<Index, Set<ShardRouting>> shardRoutingsByIndex = StreamSupport.stream(shards.spliterator(), false)
             .collect(Collectors.groupingBy(ShardRouting::index, Collectors.toSet()));
         assert shardRoutingsByIndex.equals(shardsByIndex);
diff --git a/server/src/main/java/org/opensearch/cluster/routing/RoutingNodes.java b/server/src/main/java/org/opensearch/cluster/routing/RoutingNodes.java
index 76111f623e0a5..8c1795466b716 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/RoutingNodes.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/RoutingNodes.java
@@ -37,6 +37,7 @@
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.metadata.ShardRange;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.routing.UnassignedInfo.AllocationStatus;
 import org.opensearch.cluster.routing.allocation.ExistingShardsAllocator;
@@ -94,6 +95,8 @@ public class RoutingNodes implements Iterable<RoutingNode> {
 
     private final Map<ShardId, List<ShardRouting>> assignedShards = new HashMap<>();
 
+    private final List<ShardRouting> splittingShards = new ArrayList<>();
+
     private final boolean readOnly;
 
     private int inactivePrimaryCount = 0;
@@ -101,6 +104,7 @@ public class RoutingNodes implements Iterable<RoutingNode> {
     private int inactiveShardCount = 0;
 
     private int relocatingShards = 0;
+    private int splittingShardsCount = 0;
 
     private final Map<String, Set<String>> nodesPerAttributeNames;
     private final Map<String, Recoveries> recoveriesPerNode = new HashMap<>();
@@ -152,12 +156,41 @@ public RoutingNodes(ClusterState clusterState, boolean readOnly) {
                             addInitialRecovery(targetShardRouting, indexShard.primary);
                             routingNode.add(targetShardRouting);
                             assignedShardsAdd(targetShardRouting);
+                        } else if (shard.splitting()) {
+                            splittingShardsCount++;
+                            for (ShardRouting childShard : shard.getRecoveringChildShards()) {
+                                // Replication source is parent primary in case of both child shards and their replicas.
+                                if (childShard.started() == false) {
+                                    addInitialRecovery(childShard, indexShard.primary);
+                                } else {
+                                    // Only replicas can start first if a portion of recovering child shards is seen started.
+                                    assert childShard.primary() == false;
+                                }
+                                if (childShard.primary()) {
+                                    routingNode.add(childShard);
+                                } else {
+                                    RoutingNode replicaRoutingNode = nodesToShards.computeIfAbsent(
+                                        childShard.currentNodeId(),
+                                        k -> new RoutingNode(childShard.currentNodeId(), clusterState.nodes().get(childShard.currentNodeId()))
+                                    );
+                                    replicaRoutingNode.add(childShard);
+                                }
+                                assignedShardsAdd(childShard);
+                            }
+                            updateSplitSourceOutgoingRecovery(shard, true);
                         } else if (shard.initializing()) {
                             if (shard.primary()) {
                                 inactivePrimaryCount++;
                             }
                             inactiveShardCount++;
                             addInitialRecovery(shard, indexShard.primary);
+                        } else if (shard.started() && shard.primary()) {
+                            IndexMetadata indexMetadata = metadata.getIndexSafe(indexRoutingTable.getIndex());
+                            if (indexMetadata.getSplitShardsMetadata().isSplitOfShardInProgress(shard.id())) {
+                                ShardRange[] childShardRanges = indexMetadata.getSplitShardsMetadata().getChildShardsOfParent(shard.shardId().id());
+                                ShardRouting parentRouting = shard.createRecoveringChildShards(childShardRanges, indexMetadata.getNumberOfReplicas());
+                                splittingShards.add(parentRouting);
+                            }
                         }
                     } else {
                         unassignedShards.add(shard);
@@ -168,26 +201,30 @@ public RoutingNodes(ClusterState clusterState, boolean readOnly) {
     }
 
     private void addRecovery(ShardRouting routing) {
-        updateRecoveryCounts(routing, true, findAssignedPrimaryIfPeerRecovery(routing));
+        updateRecoveryCounts(routing, true, findAssignedPrimaryIfPeerRecoveryOrSplit(routing));
     }
 
     private void removeRecovery(ShardRouting routing) {
-        updateRecoveryCounts(routing, false, findAssignedPrimaryIfPeerRecovery(routing));
+        updateRecoveryCounts(routing, false, findAssignedPrimaryIfPeerRecoveryOrSplit(routing));
     }
 
     private void addInitialRecovery(ShardRouting routing, ShardRouting initialPrimaryShard) {
         updateRecoveryCounts(routing, true, initialPrimaryShard);
     }
 
-    private void updateRecoveryCounts(final ShardRouting routing, final boolean increment, @Nullable final ShardRouting primary) {
+    private void updateSplitSourceOutgoingRecovery(ShardRouting splitSource, final boolean increment) {
+        final int howMany = increment ? 1 : -1;
+        Recoveries.getOrAdd(getRecoveries(splitSource), splitSource.currentNodeId()).addOutgoing(howMany);
+    }
 
+    private void updateRecoveryCounts(final ShardRouting routing, final boolean increment, @Nullable final ShardRouting primary) {
         final int howMany = increment ? 1 : -1;
         assert routing.initializing() : "routing must be initializing: " + routing;
         // TODO: check primary == null || primary.active() after all tests properly add ReplicaAfterPrimaryActiveAllocationDecider
         assert primary == null || primary.assignedToNode() : "shard is initializing but its primary is not assigned to a node";
 
-        // Primary shard routing, excluding the relocating primaries.
-        if (routing.primary() && (primary == null || primary == routing)) {
+        // Primary shard routing, excluding the relocating/splitting primaries in the following if condition.
+        if (routing.primary() && (primary == null || (primary == routing))) {
             assert routing.relocatingNodeId() == null : "Routing must be a non relocating primary";
             Recoveries.getOrAdd(initialPrimaryRecoveries, routing.currentNodeId()).addIncoming(howMany);
             return;
@@ -195,7 +232,7 @@ private void updateRecoveryCounts(final ShardRouting routing, final boolean incr
 
         Recoveries.getOrAdd(getRecoveries(routing), routing.currentNodeId()).addIncoming(howMany);
 
-        if (routing.recoverySource().getType() == RecoverySource.Type.PEER) {
+        if (routing.recoverySource().getType() == RecoverySource.Type.PEER && !routing.isSplitTarget()) {
             // add/remove corresponding outgoing recovery on node with primary shard
             if (primary == null) {
                 throw new IllegalStateException("shard is peer recovering but primary is unassigned");
@@ -254,7 +291,7 @@ public int getInitialOutgoingRecoveries(String nodeId) {
     }
 
     @Nullable
-    private ShardRouting findAssignedPrimaryIfPeerRecovery(ShardRouting routing) {
+    private ShardRouting findAssignedPrimaryIfPeerRecoveryOrSplit(ShardRouting routing) {
         ShardRouting primary = null;
         if (routing.recoverySource() != null && routing.recoverySource().getType() == RecoverySource.Type.PEER) {
             List<ShardRouting> shardRoutings = assignedShards.get(routing.shardId());
@@ -272,6 +309,27 @@ private ShardRouting findAssignedPrimaryIfPeerRecovery(ShardRouting routing) {
                 }
             }
         }
+
+        if (primary != null) {
+            return primary;
+        }
+
+        if (routing.isSplitTarget()) {
+            List<ShardRouting> shardRoutings = assignedShards.get(routing.getParentShardId());
+            if (shardRoutings != null) {
+                for (ShardRouting shardRouting : shardRoutings) {
+                    if (shardRouting.primary()) {
+                        if (shardRouting.active()) {
+                            return shardRouting;
+                        } else if (primary == null) {
+                            primary = shardRouting;
+                        } else if (primary.getRecoveringChildShards() != null) {
+                            primary = shardRouting;
+                        }
+                    }
+                }
+            }
+        }
         return primary;
     }
 
@@ -289,6 +347,10 @@ public UnassignedShards unassigned() {
         return this.unassignedShards;
     }
 
+    public List<ShardRouting> splitting() {
+        return this.splittingShards;
+    }
+
     public RoutingNode node(String nodeId) {
         return nodesToShards.get(nodeId);
     }
@@ -334,6 +396,10 @@ public int getRelocatingShardCount() {
         return relocatingShards;
     }
 
+    public int getSplittingShardCount() {
+        return splittingShardsCount;
+    }
+
     /**
      * Returns all shards that are not in the state UNASSIGNED with the same shard
      * ID as the given shard.
@@ -370,6 +436,23 @@ public ShardRouting activePrimary(ShardId shardId) {
         return null;
     }
 
+    /**
+     * Returns the primary child for the given shard id or <code>null</code> if
+     * no child is found or the parent shard is not splitting.
+     */
+    public ShardRouting primaryChild(ShardId parentShardId, ShardId childShardId) {
+        for (ShardRouting shardRouting : assignedShards(parentShardId)) {
+            if (shardRouting.splitting()) {
+                for (ShardRouting childShard : shardRouting.getRecoveringChildShards()) {
+                    if (childShard.shardId().id() == childShardId.id() && childShard.primary()) {
+                        return childShard;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
     /**
      * Returns one active replica shard for the given shard id or <code>null</code> if
      * no active replica is found.
@@ -560,6 +643,108 @@ public Tuple<ShardRouting, ShardRouting> relocateShard(
         return Tuple.tuple(source, target);
     }
 
+    /**
+     * Update assigned child shards against the current splitting parent and their respective recoveries.
+     */
+    public void assignChildShards(
+        ShardRouting startedShard,
+        ShardRouting parentShard,
+        RoutingChangesObserver changes,
+        Map<ShardRouting, String> assignedRoutingNodes
+    ) {
+        ensureMutable();
+        assert parentShard.splitting();
+        splittingShardsCount++;
+        List<ShardRouting> assignedChildShards = parentShard.assignChildShards(assignedRoutingNodes);
+        for (ShardRouting assignedChildShard : assignedChildShards) {
+            node(assignedChildShard.currentNodeId()).add(assignedChildShard);
+            assignedShardsAdd(assignedChildShard);
+            addRecovery(assignedChildShard);
+        }
+        updateSplitSourceOutgoingRecovery(parentShard, true);
+        updateAssigned(startedShard, parentShard);
+        changes.splitStarted(startedShard, assignedChildShards);
+    }
+
+    public void startInPlaceChildShards(
+        Logger logger,
+        List<ShardRouting> childShards,
+        IndexMetadata indexMetadata,
+        RoutingChangesObserver routingChangesObserver,
+        RoutingTable routingTable
+    ) {
+        ensureMutable();
+        assert !childShards.isEmpty();
+        ShardRouting parentShard = getByAllocationId(
+            childShards.get(0).getParentShardId(),
+            childShards.get(0).allocationId().getParentAllocationId()
+        );
+        int validShardEvents = 0, invalidShardEvents = 0;
+        for (ShardRouting childShard : childShards) {
+            if (childShard.isSplitTargetOf(parentShard) == false ||
+                (childShard.isStartedChildReplica() == false && childShard.initializing() == false)) {
+                invalidShardEvents++;
+            } else {
+                validShardEvents++;
+            }
+        }
+
+        if (invalidShardEvents != 0) {
+            logger.error(
+                "Invalid shard started event for child shards received. Unknown child found."
+                    + ", Parent shard is valid: ["
+                    + (indexMetadata.getSplitShardsMetadata().isSplitOfShardInProgress(parentShard.shardId().id()) == true)
+                    + "]. Failing all child shards and cancelling split."
+            );
+            // We just need to fail one child shard because failShard ensures that failure of any child shard
+            // fails all child shards and cancels split of source shard.
+            UnassignedInfo unassignedInfo = new UnassignedInfo(UnassignedInfo.Reason.ALLOCATION_FAILED, "");
+            failShard(logger, childShards.get(0), unassignedInfo, indexMetadata, routingChangesObserver);
+            return;
+        }
+
+        int startedChildPrimaries = 0, startedChildReplicas = 0;
+        ShardRouting updatedParent = parentShard;
+        for (ShardRouting childShard : childShards) {
+            if (childShard.primary() == false) {
+                if (childShard.initializing() == true) {
+                    ShardRouting startedChild = started(childShard);
+                    routingChangesObserver.childReplicaStarted(childShard, parentShard, startedChild);
+                    updatedParent = updatedParent.updatedStartedReplicaOnParent(childShard, startedChild);
+                    startedChildReplicas++;
+                }
+            } else {
+                assert childShard.initializing();
+                ShardRouting startedShard = started(childShard);
+                routingChangesObserver.shardStarted(childShard, startedShard);
+                startedChildPrimaries++;
+            }
+        }
+        updateAssigned(parentShard, updatedParent);
+
+        if (startedChildPrimaries == 0) {
+            assert startedChildReplicas > 0;
+        } else {
+            assert startedChildPrimaries == indexMetadata.getSplitShardsMetadata().
+                getChildShardsOfParent(parentShard.shardId().id()).length;
+            assert startedChildReplicas == 0;
+            for (ShardRouting childShard : parentShard.getRecoveringChildShards()) {
+                ShardRouting assignedChild = getByAllocationId(childShard.shardId(), childShard.allocationId().getId());
+                if (assignedChild.isSplitTarget()) {
+                    assert assignedChild.primary() == false;
+                    removeParentFromStartedChild(assignedChild);
+                    assignedChild = getByAllocationId(childShard.shardId(), childShard.allocationId().getId());
+                }
+                assert assignedChild.started() && assignedChild.isSplitTarget() == false;
+            }
+            IndexShardRoutingTable shardRoutingTable = routingTable.shardRoutingTable(parentShard.shardId());
+            for (ShardRouting parent : shardRoutingTable.getShards()) {
+                remove(parent);
+            }
+            routingChangesObserver.splitCompleted(parentShard, indexMetadata);
+        }
+    }
+
     /**
      * Applies the relevant logic to start an initializing shard.
      * <p>
@@ -629,6 +814,7 @@ public ShardRouting startShard(Logger logger, ShardRouting initializingShard, Ro
      * - If shard is a primary, this also fails initializing replicas.
      * - If shard is an active primary, this also promotes an active replica to primary (if such a replica exists).
      * - If shard is a relocating primary, this also removes the primary relocation target shard.
+     * - If shard is being split, this also removes target child shards.
      * - If shard is a relocating replica, this promotes the replica relocation target to a full initializing replica, removing the
      *   relocation source information. This is possible as peer recovery is always done from the primary.
      * - If shard is a (primary or replica) relocation target, this also clears the relocation information on the source shard.
@@ -642,6 +828,10 @@ public void failShard(
         RoutingChangesObserver routingChangesObserver
     ) {
         ensureMutable();
+        if (failedShard.getParentShardId() != null && getByAllocationId(failedShard.shardId(), failedShard.allocationId().getId()) == null) {
+            // We already removed this child when parent failed.
+            return;
+        }
         assert failedShard.assignedToNode() : "only assigned shards can be failed";
         assert indexMetadata.getIndex().equals(failedShard.index()) : "shard failed for unknown index (shard entry: " + failedShard + ")";
         assert getByAllocationId(failedShard.shardId(), failedShard.allocationId().getId()) == failedShard
@@ -653,7 +843,7 @@ assert getByAllocationId(failedShard.shardId(), failedShard.allocationId().getId
         logger.debug("{} failing shard {} with unassigned info ({})", failedShard.shardId(), failedShard, unassignedInfo.shortSummary());
 
         // if this is a primary, fail initializing replicas first (otherwise we move RoutingNodes into an inconsistent state)
-        if (failedShard.primary()) {
+        if (failedShard.primary() && failedShard.getParentShardId() == null) {
             List<ShardRouting> assignedShards = assignedShards(failedShard.shardId());
             if (assignedShards.isEmpty() == false) {
                 // copy list to prevent ConcurrentModificationException
@@ -695,11 +885,34 @@ assert getByAllocationId(failedShard.shardId(), failedShard.allocationId().getId
                 removeRelocationSource(targetShard);
                 routingChangesObserver.relocationSourceRemoved(targetShard);
             }
+        } else if (failedShard.splitting()) {
+            for (ShardRouting childShard : failedShard.getRecoveringChildShards()) {
+                assert childShard.getParentShardId() != null;
+                logger.trace("{} is removed due to the failure/cancellation of the source shard", childShard);
+                remove(childShard);
+            }
+            routingChangesObserver.splitFailed(failedShard, indexMetadata);
         }
 
         // fail actual shard
+        if (failedShard.getParentShardId() != null) {
+            ShardRouting parentShard = getByAllocationId(
+                failedShard.getParentShardId(),
+                failedShard.allocationId().getParentAllocationId()
+            );
+
+            if (parentShard.splitting() == true) {
+                childShardFailed(logger, failedShard, unassignedInfo, indexMetadata, routingChangesObserver, parentShard);
+                assert node(failedShard.currentNodeId()).getByShardId(failedShard.shardId()) == null : "failedShard "
+                    + failedShard
+                    + " was matched but wasn't removed";
+            }
+            return;
+        }
+
         if (failedShard.initializing()) {
-            if (failedShard.relocatingNodeId() == null) {
+            AllocationId failedShardAllocId = failedShard.allocationId();
+            if (failedShard.relocatingNodeId() == null && failedShardAllocId.getParentAllocationId() == null) {
                 if (failedShard.primary()) {
                     // promote active replica to primary if active replica exists (only the case for shadow replicas)
                     unassignPrimaryAndPromoteActiveReplicaIfExists(failedShard, unassignedInfo, routingChangesObserver);
@@ -708,7 +921,8 @@ assert getByAllocationId(failedShard.shardId(), failedShard.allocationId().getId
                     moveToUnassigned(failedShard, unassignedInfo);
                 }
             } else {
-                // The shard is a target of a relocating shard. In that case we only need to remove the target shard and cancel the source
+                // The shard is a target or child of a relocating shard. In that case we only need to remove the target/child shard(s) and
+                // cancel the source
                 // relocation. No shard is left unassigned
                 logger.trace(
                     "{} is a relocation target, resolving source to cancel relocation ({})",
@@ -745,6 +959,30 @@ assert node(failedShard.currentNodeId()).getByShardId(failedShard.shardId()) ==
             + " was matched but wasn't removed";
     }
 
+    private void childShardFailed(
+        Logger logger,
+        ShardRouting failedShard,
+        UnassignedInfo unassignedInfo,
+        IndexMetadata indexMetadata,
+        RoutingChangesObserver routingChangesObserver,
+        ShardRouting parentShard
+    ) {
+
+        assert parentShard.isSplitSourceOf(failedShard);
+        logger.trace(
+            "{}, resolved source to [{}]. canceling split ... ({})",
+            failedShard.shardId(),
+            parentShard,
+            unassignedInfo.shortSummary()
+        );
+        cancelSplit(parentShard);
+
+        for (ShardRouting childShard : parentShard.getRecoveringChildShards()) {
+            remove(childShard);
+        }
+        routingChangesObserver.splitFailed(parentShard, indexMetadata);
+    }
+
     private void unassignPrimaryAndPromoteActiveReplicaIfExists(
         ShardRouting failedShard,
         UnassignedInfo unassignedInfo,
@@ -786,7 +1024,7 @@ private void promoteReplicaToPrimary(ShardRouting activeReplica, RoutingChangesO
      */
     private ShardRouting started(ShardRouting shard) {
         assert shard.initializing() : "expected an initializing shard " + shard;
-        if (shard.relocatingNodeId() == null) {
+        if (shard.relocatingNodeId() == null && !shard.isSplitTarget()) {
             // if this is not a target shard for relocation, we need to update statistics
             inactiveShardCount--;
             if (shard.primary()) {
@@ -794,11 +1032,24 @@ private ShardRouting started(ShardRouting shard) {
             }
         }
         removeRecovery(shard);
-        ShardRouting startedShard = shard.moveToStarted();
+        ShardRouting startedShard;
+        if (shard.isSplitTarget() && shard.primary() == false) {
+            startedShard = shard.moveChildReplicaToStarted();
+        } else {
+            startedShard = shard.moveToStarted();
+        }
         updateAssigned(shard, startedShard);
         return startedShard;
     }
 
+
+    private ShardRouting removeParentFromStartedChild(ShardRouting shard) {
+        assert shard.started();
+        ShardRouting parentRemoved = shard.removeParentFromReplica();
+        updateAssigned(shard, parentRemoved);
+        return parentRemoved;
+    }
+
     /**
      * Cancels a relocation of a shard that shard must relocating.
      *
@@ -811,6 +1062,22 @@ private ShardRouting cancelRelocation(ShardRouting shard) {
         return cancelledShard;
     }
 
+    /**
+     * Cancels a relocation of a shard that shard must relocating.
+     *
+     * @return the shard after cancelling relocation
+     */
+    private ShardRouting cancelSplit(ShardRouting shard) {
+        splittingShardsCount--;
+        for (ShardRouting splittingShard : splittingShards) {
+            assert splittingShard.shardId().equals(shard.shardId()) == false;
+        }
+        ShardRouting cancelledShard = shard.cancelSplit();
+        updateAssigned(shard, cancelledShard);
+        updateSplitSourceOutgoingRecovery(shard, false);
+        return cancelledShard;
+    }
+
     /**
      * moves the assigned replica shard to primary.
      *
@@ -835,7 +1102,7 @@ private ShardRouting promoteActiveReplicaShardToPrimary(ShardRouting replicaShar
     private void remove(ShardRouting shard) {
         assert shard.unassigned() == false : "only assigned shards can be removed here (" + shard + ")";
         node(shard.currentNodeId()).remove(shard);
-        if (shard.initializing() && shard.relocatingNodeId() == null) {
+        if (shard.initializing() && shard.relocatingNodeId() == null && !shard.isSplitTarget()) {
             inactiveShardCount--;
             assert inactiveShardCount >= 0;
             if (shard.primary()) {
@@ -843,6 +1110,8 @@ private void remove(ShardRouting shard) {
             }
         } else if (shard.relocating()) {
             shard = cancelRelocation(shard);
+        } else if (shard.splitting()) {
+            shard = cancelSplit(shard);
         }
         assignedShardsRemove(shard);
         if (shard.initializing()) {
@@ -1215,10 +1484,11 @@ public static boolean assertShardStats(RoutingNodes routingNodes) {
         int inactivePrimaryCount = 0;
         int inactiveShardCount = 0;
         int relocating = 0;
+        int splitting = 0;
         Map<Index, Integer> indicesAndShards = new HashMap<>();
         for (RoutingNode node : routingNodes) {
             for (ShardRouting shard : node) {
-                if (shard.initializing() && shard.relocatingNodeId() == null) {
+                if (shard.initializing() && shard.relocatingNodeId() == null && !shard.isSplitTarget()) {
                     inactiveShardCount++;
                     if (shard.primary()) {
                         inactivePrimaryCount++;
@@ -1226,6 +1496,8 @@ public static boolean assertShardStats(RoutingNodes routingNodes) {
                 }
                 if (shard.relocating()) {
                     relocating++;
+                } else if (shard.splitting()) {
+                    splitting++;
                 }
                 Integer i = indicesAndShards.get(shard.index());
                 if (i == null) {
@@ -1272,12 +1544,12 @@ public static boolean assertShardStats(RoutingNodes routingNodes) {
             }
         }
 
-        assertRecoveriesPerNode(routingNodes, routingNodes.initialPrimaryRecoveries, false, x -> isNonRelocatingPrimary(x));
+        assertRecoveriesPerNode(routingNodes, routingNodes.initialPrimaryRecoveries, false, x -> isNonRelocatingOrNonSplittingPrimary(x));
         assertRecoveriesPerNode(
             routingNodes,
             Recoveries.unionRecoveries(routingNodes.recoveriesPerNode, routingNodes.initialReplicaRecoveries),
             true,
-            x -> !isNonRelocatingPrimary(x)
+            x -> !isNonRelocatingOrNonSplittingPrimary(x)
         );
 
         assert unassignedPrimaryCount == routingNodes.unassignedShards.getNumPrimaries() : "Unassigned primaries is ["
@@ -1305,6 +1577,11 @@ public static boolean assertShardStats(RoutingNodes routingNodes) {
             + "] but expected ["
             + relocating
             + "]";
+        assert routingNodes.getSplittingShardCount() == splitting : "Splitting shards mismatch ["
+            + routingNodes.getSplittingShardCount()
+            + "] but expected ["
+            + splitting
+            + "]";
 
         return true;
     }
@@ -1325,10 +1602,21 @@ private static void assertRecoveriesPerNode(
                 for (ShardRouting routing : routingNode) {
                     if (routing.initializing() && incomingCountFilter.apply(routing)) incoming++;
 
-                    if (verifyOutgoingRecoveries && routing.primary() && routing.isRelocationTarget() == false) {
+                    if (verifyOutgoingRecoveries
+                        && routing.primary()
+                        && routing.isRelocationTarget() == false
+                        && routing.isSplitTarget() == false) {
                         for (ShardRouting assigned : routingNodes.assignedShards.get(routing.shardId())) {
                             if (assigned.initializing() && assigned.recoverySource().getType() == RecoverySource.Type.PEER) {
                                 outgoing++;
+                            } else if (assigned.splitting()) {
+                                for (ShardRouting childShardRouting : assigned.getRecoveringChildShards()) {
+                                    assert routingNodes.assignedShards.containsKey(childShardRouting.shardId());
+                                    for (ShardRouting assignedChildShard : routingNodes.assignedShards.get(childShardRouting.shardId())) {
+                                        assert assignedChildShard.getParentShardId().equals(assigned.shardId());
+                                    }
+                                }
+                                outgoing++;
                             }
                         }
                     }
@@ -1340,8 +1628,8 @@ private static void assertRecoveriesPerNode(
         }
     }
 
-    private static boolean isNonRelocatingPrimary(ShardRouting routing) {
-        return routing.primary() && routing.relocatingNodeId() == null;
+    private static boolean isNonRelocatingOrNonSplittingPrimary(ShardRouting routing) {
+        return routing.primary() && routing.relocatingNodeId() == null && !routing.splitting() && !routing.isSplitTarget();
     }
 
     private void ensureMutable() {
diff --git a/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java b/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java
index 7128eb44bfb14..e801382158972 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java
@@ -173,6 +173,24 @@ public IndexShardRoutingTable shardRoutingTable(ShardId shardId) {
         return shard;
     }
 
+    /**
+     * All child replica shards for the provided {@link ShardId}
+     * @return All the child replica shard routing entries for the given index and shard id
+     * @throws IndexNotFoundException if provided index does not exist
+     * @throws ShardNotFoundException if provided shard id is unknown
+     */
+    public IndexShardRoutingTable childReplicaShardRoutingTable(ShardId shardId) {
+        IndexRoutingTable indexRouting = index(shardId.getIndexName());
+        if (indexRouting == null || indexRouting.getIndex().equals(shardId.getIndex()) == false) {
+            throw new IndexNotFoundException(shardId.getIndex());
+        }
+        IndexShardRoutingTable shard = indexRouting.childReplicaShard(shardId.id());
+        if (shard == null) {
+            throw new ShardNotFoundException(shardId);
+        }
+        return shard;
+    }
+
     @Nullable
     public ShardRouting getByAllocationId(ShardId shardId, String allocationId) {
         final IndexRoutingTable indexRoutingTable = index(shardId.getIndexName());
@@ -494,8 +512,9 @@ public Builder updateNodes(long version, RoutingNodes routingNodes) {
             for (RoutingNode routingNode : routingNodes) {
                 for (ShardRouting shardRoutingEntry : routingNode) {
                     // every relocating shard has a double entry, ignore the target one.
-                    if (shardRoutingEntry.initializing() && shardRoutingEntry.relocatingNodeId() != null) continue;
-
+                    // Also, ignore initializing child shards.
+                    if (shardRoutingEntry.initializing()
+                        && (shardRoutingEntry.relocatingNodeId() != null || shardRoutingEntry.isSplitTarget())) continue;
                     addShard(indexRoutingTableBuilders, shardRoutingEntry);
                 }
             }
@@ -522,7 +541,11 @@ private static void addShard(
                 indexBuilder = new IndexRoutingTable.Builder(index);
                 indexRoutingTableBuilders.put(index.getName(), indexBuilder);
             }
-            indexBuilder.addShard(shardRoutingEntry);
+            if (shardRoutingEntry.isStartedChildReplica()) {
+                indexBuilder.addChildReplica(shardRoutingEntry);
+            } else {
+                indexBuilder.addShard(shardRoutingEntry);
+            }
         }
 
         /**
diff --git a/server/src/main/java/org/opensearch/cluster/routing/RoutingTableIncrementalDiff.java b/server/src/main/java/org/opensearch/cluster/routing/RoutingTableIncrementalDiff.java
index 13501a431d9f9..c47577c3485ad 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/RoutingTableIncrementalDiff.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/RoutingTableIncrementalDiff.java
@@ -8,6 +8,7 @@
 
 package org.opensearch.cluster.routing;
 
+import org.opensearch.Version;
 import org.opensearch.cluster.Diff;
 import org.opensearch.cluster.DiffableUtils;
 import org.opensearch.core.common.io.stream.StreamInput;
@@ -15,6 +16,7 @@
 import org.opensearch.core.index.Index;
 
 import java.io.IOException;
+import java.util.HashMap;
 import java.util.Map;
 
 import static org.opensearch.cluster.DiffableUtils.MapDiff;
@@ -96,12 +98,14 @@ public MapDiff<String, IndexRoutingTable, Map<String, IndexRoutingTable>> provid
     public static class IndexRoutingTableIncrementalDiff implements Diff<IndexRoutingTable> {
 
         private final Diff<Map<Integer, IndexShardRoutingTable>> indexShardRoutingTables;
+        private final Diff<Map<Integer, IndexShardRoutingTable>> childReplicaRoutingTableDiff;
 
         private final Index index;
 
         public IndexRoutingTableIncrementalDiff(Index index, IndexRoutingTable before, IndexRoutingTable after) {
             this.index = index;
             this.indexShardRoutingTables = DiffableUtils.diff(before.getShards(), after.getShards(), DiffableUtils.getIntKeySerializer());
+            this.childReplicaRoutingTableDiff = DiffableUtils.diff(before.getChildReplicas(), after.getChildReplicas(), DiffableUtils.getIntKeySerializer());
         }
 
         private static final DiffableUtils.DiffableValueReader<Integer, IndexShardRoutingTable> DIFF_VALUE_READER =
@@ -110,17 +114,29 @@ public IndexRoutingTableIncrementalDiff(Index index, IndexRoutingTable before, I
         public IndexRoutingTableIncrementalDiff(StreamInput in) throws IOException {
             this.index = new Index(in);
             this.indexShardRoutingTables = DiffableUtils.readJdkMapDiff(in, DiffableUtils.getIntKeySerializer(), DIFF_VALUE_READER);
+            if (in.getVersion().onOrAfter(Version.V_3_0_0)) {
+                this.childReplicaRoutingTableDiff = DiffableUtils.readJdkMapDiff(in, DiffableUtils.getIntKeySerializer(), DIFF_VALUE_READER);
+            } else {
+                this.childReplicaRoutingTableDiff = null;
+            }
         }
 
         @Override
         public IndexRoutingTable apply(IndexRoutingTable part) {
-            return new IndexRoutingTable(index, indexShardRoutingTables.apply(part.getShards()));
+            Map<Integer, IndexShardRoutingTable> childReplicaRoutingTable;
+            if (this.childReplicaRoutingTableDiff == null) {
+                childReplicaRoutingTable = new HashMap<>();
+            } else {
+                childReplicaRoutingTable = this.childReplicaRoutingTableDiff.apply(part.getChildReplicas());
+            }
+            return new IndexRoutingTable(index, indexShardRoutingTables.apply(part.getShards()), childReplicaRoutingTable);
         }
 
         @Override
         public void writeTo(StreamOutput out) throws IOException {
             index.writeTo(out);
             indexShardRoutingTables.writeTo(out);
+            childReplicaRoutingTableDiff.writeTo(out);
         }
 
         public static IndexRoutingTableIncrementalDiff readFrom(StreamInput in) throws IOException {
diff --git a/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java b/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java
index bdc98061f2fa4..2933c1d582585 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java
@@ -33,6 +33,7 @@
 package org.opensearch.cluster.routing;
 
 import org.opensearch.Version;
+import org.opensearch.cluster.metadata.ShardRange;
 import org.opensearch.cluster.routing.RecoverySource.ExistingStoreRecoverySource;
 import org.opensearch.cluster.routing.RecoverySource.PeerRecoverySource;
 import org.opensearch.cluster.routing.allocation.allocator.BalancedShardsAllocator;
@@ -48,8 +49,12 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
+import java.util.Objects;
 
 /**
  * {@link ShardRouting} immutably encapsulates information about shard
@@ -78,6 +83,10 @@ public class ShardRouting implements Writeable, ToXContentObject {
     private final long expectedShardSize;
     @Nullable
     private final ShardRouting targetRelocatingShard;
+    @Nullable
+    private final ShardRouting[] recoveringChildShards;
+    @Nullable
+    private final ShardId parentShardId;
 
     /**
      * A constructor to internally create shard routing instances, note, the internal flag should only be set to true
@@ -93,7 +102,9 @@ protected ShardRouting(
         RecoverySource recoverySource,
         UnassignedInfo unassignedInfo,
         AllocationId allocationId,
-        long expectedShardSize
+        long expectedShardSize,
+        ShardRouting[] recoveringChildShards,
+        ShardId parentShardId
     ) {
         this.shardId = shardId;
         this.currentNodeId = currentNodeId;
@@ -106,16 +117,22 @@ protected ShardRouting(
         this.allocationId = allocationId;
         this.expectedShardSize = expectedShardSize;
         this.targetRelocatingShard = initializeTargetRelocatingShard();
+        this.recoveringChildShards = recoveringChildShards;
+        this.parentShardId = parentShardId;
         this.asList = Collections.singletonList(this);
         assert expectedShardSize == UNAVAILABLE_EXPECTED_SHARD_SIZE
             || state == ShardRoutingState.INITIALIZING
-            || state == ShardRoutingState.RELOCATING : expectedShardSize + " state: " + state;
-        assert expectedShardSize >= 0 || state != ShardRoutingState.INITIALIZING || state != ShardRoutingState.RELOCATING
-            : expectedShardSize + " state: " + state;
+            || state == ShardRoutingState.RELOCATING
+            || state == ShardRoutingState.SPLITTING : expectedShardSize + " state: " + state;
+        assert expectedShardSize >= 0
+            || state != ShardRoutingState.INITIALIZING
+            || state != ShardRoutingState.RELOCATING
+            || state != ShardRoutingState.SPLITTING : expectedShardSize + " state: " + state;
         assert !(state == ShardRoutingState.UNASSIGNED && unassignedInfo == null) : "unassigned shard must be created with meta";
         assert (state == ShardRoutingState.UNASSIGNED || state == ShardRoutingState.INITIALIZING) == (recoverySource != null)
             : "recovery source only available on unassigned or initializing shard but was " + state;
-        assert recoverySource == null || recoverySource == PeerRecoverySource.INSTANCE || primary || searchOnly
+        assert recoverySource == null || recoverySource == PeerRecoverySource.INSTANCE || primary || searchOnly ||
+            recoverySource == RecoverySource.InPlaceShardSplitRecoverySource.INSTANCE
             : "replica shards always recover from primary";
         assert (currentNodeId == null) == (state == ShardRoutingState.UNASSIGNED) : "unassigned shard must not be assigned to a node "
             + this;
@@ -142,7 +159,9 @@ protected ShardRouting(
             recoverySource,
             unassignedInfo,
             allocationId,
-            expectedShardSize
+            expectedShardSize,
+            null,
+            null
         );
     }
 
@@ -159,13 +178,70 @@ private ShardRouting initializeTargetRelocatingShard() {
                 isSearchOnly() ? RecoverySource.EmptyStoreRecoverySource.INSTANCE : PeerRecoverySource.INSTANCE,
                 unassignedInfo,
                 AllocationId.newTargetRelocation(allocationId),
-                expectedShardSize
+                expectedShardSize,
+                null,
+                null
             );
         } else {
             return null;
         }
     }
 
+    public List<ShardRouting> assignChildShards(Map<ShardRouting, String> assignedRoutingNodes) {
+        List<ShardRouting> assignedChildShards = new ArrayList<>();
+        int idx = 0;
+        for (ShardRouting childShard : assignedRoutingNodes.keySet()) {
+            ShardRouting assignedChildShard = new ShardRouting(
+                childShard.shardId,
+                assignedRoutingNodes.get(childShard),
+                null,
+                childShard.primary,
+                childShard.searchOnly,
+                ShardRoutingState.INITIALIZING,
+                childShard.recoverySource,
+                unassignedInfo,
+                childShard.allocationId,
+                expectedShardSize,
+                null,
+                shardId
+            );
+            assignedChildShards.add(assignedChildShard);
+            recoveringChildShards[idx++] = assignedChildShard;
+        }
+
+        return assignedChildShards;
+    }
+
+    public ShardRouting updatedStartedReplicaOnParent(ShardRouting initializingReplica, ShardRouting startedReplica) {
+        List<ShardRouting> updatedChildShards = new ArrayList<>();
+        boolean moved = false;
+        for (ShardRouting childShard : recoveringChildShards) {
+            if (childShard.equals(initializingReplica)) {
+                assert startedReplica.primary == false;
+                moved = true;
+                updatedChildShards.add(startedReplica);
+            } else {
+                updatedChildShards.add(childShard);
+            }
+        }
+
+        assert moved;
+        return new ShardRouting(
+            shardId,
+            currentNodeId,
+            relocatingNodeId,
+            primary,
+            searchOnly,
+            state,
+            recoverySource,
+            unassignedInfo,
+            allocationId,
+            expectedShardSize,
+            updatedChildShards.toArray(new ShardRouting[0]),
+            parentShardId
+        );
+    }
+
     /**
      * Creates a new unassigned shard.
      */
@@ -198,7 +274,9 @@ public static ShardRouting newUnassigned(
             recoverySource,
             unassignedInfo,
             null,
-            UNAVAILABLE_EXPECTED_SHARD_SIZE
+            UNAVAILABLE_EXPECTED_SHARD_SIZE,
+            null,
+            null
         );
     }
 
@@ -245,11 +323,12 @@ public boolean initializing() {
     /**
      * Returns <code>true</code> iff the this shard is currently
      * {@link ShardRoutingState#STARTED started} or
-     * {@link ShardRoutingState#RELOCATING relocating} to another node.
+     * {@link ShardRoutingState#RELOCATING relocating} to another node or
+     * {@link ShardRoutingState#SPLITTING splitting}
      * Otherwise <code>false</code>
      */
     public boolean active() {
-        return started() || relocating();
+        return started() || relocating() || splitting();
     }
 
     /**
@@ -269,6 +348,16 @@ public boolean relocating() {
         return state == ShardRoutingState.RELOCATING;
     }
 
+    /**
+     * Returns <code>true</code> iff the this shard is currently being split.
+     * Otherwise <code>false</code>
+     *
+     * @see ShardRoutingState#SPLITTING
+     */
+    public boolean splitting() {
+        return state == ShardRoutingState.SPLITTING;
+    }
+
     /**
      * Returns <code>true</code> iff this shard is assigned to a node ie. not
      * {@link ShardRoutingState#UNASSIGNED unassigned}. Otherwise <code>false</code>
@@ -372,7 +461,7 @@ public ShardRouting(ShardId shardId, StreamInput in) throws IOException {
         unassignedInfo = in.readOptionalWriteable(UnassignedInfo::new);
         allocationId = in.readOptionalWriteable(AllocationId::new);
         final long shardSize;
-        if (state == ShardRoutingState.RELOCATING || state == ShardRoutingState.INITIALIZING) {
+        if (state == ShardRoutingState.RELOCATING || state == ShardRoutingState.INITIALIZING || state == ShardRoutingState.SPLITTING) {
             shardSize = in.readLong();
         } else {
             shardSize = UNAVAILABLE_EXPECTED_SHARD_SIZE;
@@ -380,6 +469,13 @@ public ShardRouting(ShardId shardId, StreamInput in) throws IOException {
         expectedShardSize = shardSize;
         asList = Collections.singletonList(this);
         targetRelocatingShard = initializeTargetRelocatingShard();
+        if (in.getVersion().onOrAfter(Version.V_3_0_0)) {
+            recoveringChildShards = in.readOptionalArray(ShardRouting::new, ShardRouting[]::new);
+            parentShardId = in.readOptionalWriteable(ShardId::new);
+        } else {
+            recoveringChildShards = null;
+            parentShardId = null;
+        }
     }
 
     public ShardRouting(StreamInput in) throws IOException {
@@ -405,9 +501,20 @@ public void writeToThin(StreamOutput out) throws IOException {
         }
         out.writeOptionalWriteable(unassignedInfo);
         out.writeOptionalWriteable(allocationId);
-        if (state == ShardRoutingState.RELOCATING || state == ShardRoutingState.INITIALIZING) {
+        if (state == ShardRoutingState.RELOCATING || state == ShardRoutingState.INITIALIZING || state == ShardRoutingState.SPLITTING) {
             out.writeLong(expectedShardSize);
         }
+        if (out.getVersion().onOrAfter(Version.V_3_0_0)) {
+            out.writeOptionalArray(recoveringChildShards);
+            out.writeOptionalWriteable(parentShardId);
+        } else {
+            if (recoveringChildShards != null || parentShardId != null) {
+                // In-progress shard split is not allowed in a mixed cluster where node(s) with an unsupported split
+                // version is present. Hence, we also don't want to allow a node with an unsupported version
+                // to get this state while shard split is in-progress.
+                throw new IllegalStateException("In-place split not allowed on older versions.");
+            }
+        }
     }
 
     @Override
@@ -429,7 +536,9 @@ public ShardRouting updateUnassigned(UnassignedInfo unassignedInfo, RecoverySour
             recoverySource,
             unassignedInfo,
             allocationId,
-            expectedShardSize
+            expectedShardSize,
+            null,
+            parentShardId
         );
     }
 
@@ -458,7 +567,9 @@ public ShardRouting moveToUnassigned(UnassignedInfo unassignedInfo) {
             recoverySource,
             unassignedInfo,
             null,
-            UNAVAILABLE_EXPECTED_SHARD_SIZE
+            UNAVAILABLE_EXPECTED_SHARD_SIZE,
+            null,
+            parentShardId
         );
     }
 
@@ -486,7 +597,9 @@ public ShardRouting initialize(String nodeId, @Nullable String existingAllocatio
             recoverySource,
             unassignedInfo,
             allocationId,
-            expectedShardSize
+            expectedShardSize,
+            null,
+            parentShardId
         );
     }
 
@@ -507,7 +620,71 @@ public ShardRouting relocate(String relocatingNodeId, long expectedShardSize) {
             recoverySource,
             null,
             AllocationId.newRelocation(allocationId),
-            expectedShardSize
+            expectedShardSize,
+            null,
+            parentShardId
+        );
+    }
+
+    /**
+     * Create child shard routings for a splitting parent.
+     */
+    public ShardRouting createRecoveringChildShards(ShardRange[] recoveringChildShardRanges, int replicaCount) {
+        int totalShards = recoveringChildShardRanges.length * (replicaCount + 1);
+        AllocationId allocationId = AllocationId.newSplit(allocationId(), totalShards);
+        ShardRouting[] childShards = new ShardRouting[totalShards];
+        int allocationIdx = 0;
+        UnassignedInfo childUnassignedInfo = new UnassignedInfo(UnassignedInfo.Reason.CHILD_SHARD_CREATED,
+            "child_shard_allocation_pending[parent shard " + shardId + "]");
+        for (ShardRange recoveringChildShardRange : recoveringChildShardRanges) {
+            childShards[allocationIdx] = new ShardRouting(
+                    new ShardId(index(), recoveringChildShardRange.getShardId()),
+                    null,
+                    null,
+                    true,
+                    false,
+                    ShardRoutingState.UNASSIGNED,
+                    RecoverySource.InPlaceShardSplitRecoverySource.INSTANCE,
+                    childUnassignedInfo,
+                    AllocationId.newTargetSplit(allocationId, allocationId.getSplitChildAllocationIds().get(allocationIdx)),
+                    UNAVAILABLE_EXPECTED_SHARD_SIZE,
+                    null,
+                    shardId
+            );
+            allocationIdx++;
+
+            for (int replica = 0; replica < replicaCount; replica++) {
+                childShards[allocationIdx] = new ShardRouting(
+                        new ShardId(index(), recoveringChildShardRange.getShardId()),
+                        null,
+                        null,
+                        false,
+                        false,
+                        ShardRoutingState.UNASSIGNED,
+                        PeerRecoverySource.INSTANCE,
+                        childUnassignedInfo,
+                        AllocationId.newTargetSplit(allocationId, allocationId.getSplitChildAllocationIds().get(allocationIdx)),
+                        UNAVAILABLE_EXPECTED_SHARD_SIZE,
+                        null,
+                        shardId
+                );
+                allocationIdx++;
+            }
+        }
+
+        return new ShardRouting(
+            shardId,
+            currentNodeId,
+            null,
+            primary,
+            searchOnly,
+            ShardRoutingState.SPLITTING,
+            recoverySource,
+            null,
+            allocationId,
+            expectedShardSize,
+            childShards,
+            null
         );
     }
 
@@ -529,7 +706,33 @@ public ShardRouting cancelRelocation() {
             recoverySource,
             null,
             AllocationId.cancelRelocation(allocationId),
-            UNAVAILABLE_EXPECTED_SHARD_SIZE
+            UNAVAILABLE_EXPECTED_SHARD_SIZE,
+            null,
+            parentShardId
+        );
+    }
+
+    /**
+     * Cancel split of a shard. The shards state must be set
+     * to <code>SPLITTING</code>.
+     */
+    public ShardRouting cancelSplit() {
+        assert state == ShardRoutingState.SPLITTING : this;
+        assert assignedToNode() : this;
+        assert recoveringChildShards != null && recoveringChildShards.length > 0 : this;
+        return new ShardRouting(
+            shardId,
+            currentNodeId,
+            null,
+            primary,
+            searchOnly,
+            ShardRoutingState.STARTED,
+            recoverySource,
+            null,
+            AllocationId.cancelSplit(allocationId),
+            UNAVAILABLE_EXPECTED_SHARD_SIZE,
+            null,
+            null
         );
     }
 
@@ -553,7 +756,9 @@ public ShardRouting removeRelocationSource() {
             recoverySource,
             unassignedInfo,
             AllocationId.finishRelocation(allocationId),
-            expectedShardSize
+            expectedShardSize,
+            null,
+            parentShardId
         );
     }
 
@@ -574,13 +779,34 @@ public ShardRouting reinitializeReplicaShard() {
             recoverySource,
             unassignedInfo,
             AllocationId.newInitializing(),
-            expectedShardSize
+            expectedShardSize,
+            null,
+            parentShardId
+        );
+    }
+
+    public ShardRouting moveChildReplicaToStarted() {
+        // Note that we don't detach parent info yet. This will be done when primary child shards are started so that
+        // started child replicas continue to act as child shards.
+        return new ShardRouting(
+            shardId,
+            currentNodeId,
+            null,
+            primary,
+            searchOnly,
+            ShardRoutingState.STARTED,
+            null,
+            null,
+            allocationId,
+            UNAVAILABLE_EXPECTED_SHARD_SIZE,
+            null,
+            parentShardId
         );
     }
 
     /**
      * Set the shards state to <code>STARTED</code>. The shards state must be
-     * <code>INITIALIZING</code> or <code>RELOCATING</code>. Any relocation will be
+     * <code>INITIALIZING</code> or <code>RELOCATING</code> or <code>SPLITTING</code>. Any relocation will be
      * canceled.
      */
     public ShardRouting moveToStarted() {
@@ -589,6 +815,9 @@ public ShardRouting moveToStarted() {
         if (allocationId.getRelocationId() != null) {
             // relocation target
             allocationId = AllocationId.finishRelocation(allocationId);
+        } else if (allocationId.getParentAllocationId() != null) {
+            // split target
+            allocationId = AllocationId.finishSplit(allocationId);
         }
         return new ShardRouting(
             shardId,
@@ -600,7 +829,30 @@ public ShardRouting moveToStarted() {
             null,
             null,
             allocationId,
-            UNAVAILABLE_EXPECTED_SHARD_SIZE
+            UNAVAILABLE_EXPECTED_SHARD_SIZE,
+            null,
+            null
+        );
+    }
+
+    /**
+     * Removes Parent info from a started replica
+     */
+    public ShardRouting removeParentFromReplica() {
+        assert isStartedChildReplica();
+        return new ShardRouting(
+            shardId,
+            currentNodeId,
+            null,
+            primary,
+            searchOnly,
+            ShardRoutingState.STARTED,
+            null,
+            null,
+            allocationId,
+            UNAVAILABLE_EXPECTED_SHARD_SIZE,
+            null,
+            null
         );
     }
 
@@ -627,7 +879,9 @@ public ShardRouting moveActivePrimaryToReplica() {
             recoverySource,
             unassignedInfo,
             allocationId,
-            expectedShardSize
+            expectedShardSize,
+            recoveringChildShards,
+            parentShardId
         );
     }
 
@@ -654,7 +908,9 @@ public ShardRouting moveActiveReplicaToPrimary() {
             recoverySource,
             unassignedInfo,
             allocationId,
-            expectedShardSize
+            expectedShardSize,
+            recoveringChildShards,
+            parentShardId
         );
     }
 
@@ -673,11 +929,14 @@ public ShardRouting moveUnassignedFromPrimary() {
             currentNodeId,
             relocatingNodeId,
             false,
+            false,
             state,
             PeerRecoverySource.INSTANCE,
             unassignedInfo,
             allocationId,
-            expectedShardSize
+            expectedShardSize,
+            recoveringChildShards,
+            parentShardId
         );
     }
 
@@ -702,6 +961,55 @@ public boolean isRelocationTarget() {
         return state == ShardRoutingState.INITIALIZING && relocatingNodeId != null;
     }
 
+    /**
+     * Returns <code>true</code> if this shard is a split target for another shard
+     * (i.e., was created in {@link #assignChildShards(Map)} ()} ()}
+     */
+    public boolean isSplitTarget() {
+        return getParentShardId() != null;
+    }
+
+    /**
+     * returns true if the routing is the split target of the given routing
+     */
+    public boolean isSplitTargetOf(ShardRouting other) {
+
+        boolean b = this.allocationId != null
+            && other.allocationId != null
+            && this.allocationId.getParentAllocationId() != null
+            && this.allocationId.getParentAllocationId().equals(other.allocationId.getId());
+
+        assert b == false || other.state == ShardRoutingState.SPLITTING
+            : "ShardRouting is a split target but the source shard state isn't splitting. This [" + this + "], other [" + other + "]";
+
+        assert b == false
+            || other.allocationId.getSplitChildAllocationIds() != null
+                && other.allocationId.getSplitChildAllocationIds().contains(this.allocationId.getId())
+            : "ShardRouting is a splitting target but the source split allocation doesn't contain this allocationId.getId."
+                + " This ["
+                + this
+                + "], other ["
+                + other
+                + "]";
+
+        assert b == false || this.getParentShardId().equals(other.shardId())
+            : "ShardRouting is a splitting target but current splitting shard id isn't equal to source shard id."
+                + " This ["
+                + this
+                + "], other ["
+                + other
+                + "]";
+
+        assert b == false || other.primary : "ShardRouting is a splitting target but primary flag is different."
+            + " This ["
+            + this
+            + "], target ["
+            + other
+            + "]";
+
+        return b;
+    }
+
     /** returns true if the routing is the relocation target of the given routing */
     public boolean isRelocationTargetOf(ShardRouting other) {
         boolean b = this.allocationId != null
@@ -754,6 +1062,41 @@ public boolean isRelocationTargetOf(ShardRouting other) {
         return b;
     }
 
+    public boolean isSplitSourceOf(ShardRouting other) {
+        boolean b = this.allocationId != null
+            && other.allocationId != null
+            && this.state == ShardRoutingState.SPLITTING
+            && other.allocationId.getParentAllocationId() != null
+            && this.allocationId.getId().equals(other.allocationId.getParentAllocationId());
+
+        assert b == false
+            || this.allocationId.getSplitChildAllocationIds() != null
+                && this.allocationId.getSplitChildAllocationIds().contains(other.allocationId.getId())
+            : "ShardRouting is a splitting source but its split allocation ids doesn't contain target allocationId.getId."
+                + " This ["
+                + this
+                + "], other ["
+                + other
+                + "]";
+
+        assert b == false || this.shardId.equals(other.getParentShardId())
+            : "ShardRouting is a splitting source but current shard id isn't equal to target splitting shard id."
+                + " This ["
+                + this
+                + "], other ["
+                + other
+                + "]";
+
+        assert b == false || this.primary : "ShardRouting is a splitting source but primary flag is different."
+            + " This ["
+            + this
+            + "], target ["
+            + other
+            + "]";
+
+        return b;
+    }
+
     /** returns true if the routing is the relocation source for the given routing */
     public boolean isRelocationSourceOf(ShardRouting other) {
         boolean b = this.allocationId != null
@@ -788,7 +1131,7 @@ public boolean isRelocationSourceOf(ShardRouting other) {
                 + other
                 + "]";
 
-        assert b == false || this.shardId.equals(other.shardId)
+        assert b == false || this.splitting() || this.shardId.equals(other.shardId)
             : "ShardRouting is a relocation source but both indexRoutings are not of the same shard."
                 + " This ["
                 + this
@@ -828,6 +1171,12 @@ public boolean equalsIgnoringMetadata(ShardRouting other) {
         if (recoverySource != null ? !recoverySource.equals(other.recoverySource) : other.recoverySource != null) {
             return false;
         }
+        if (Arrays.equals(recoveringChildShards, other.recoveringChildShards) == false) {
+            return false;
+        }
+        if (Objects.equals(parentShardId, other.parentShardId) == false) {
+            return false;
+        }
         return true;
     }
 
@@ -864,6 +1213,8 @@ public int hashCode() {
             h = 31 * h + (recoverySource != null ? recoverySource.hashCode() : 0);
             h = 31 * h + (allocationId != null ? allocationId.hashCode() : 0);
             h = 31 * h + (unassignedInfo != null ? unassignedInfo.hashCode() : 0);
+            h = 31 * h + (recoveringChildShards != null ? Arrays.hashCode(recoveringChildShards) : 0);
+            h = 31 * h + (parentShardId != null ? parentShardId.hashCode() : 0);
             hashCode = h;
         }
         return h;
@@ -906,6 +1257,12 @@ public String shortSummary() {
         if (expectedShardSize != UNAVAILABLE_EXPECTED_SHARD_SIZE) {
             sb.append(", expected_shard_size[").append(expectedShardSize).append("]");
         }
+        if (recoveringChildShards != null) {
+            sb.append(", recovering_child_shards [").append(Arrays.toString(recoveringChildShards)).append("]");
+        }
+        if (parentShardId != null) {
+            sb.append(", parent_shard_id [").append(parentShardId).append("]");
+        }
         return sb.toString();
     }
 
@@ -932,12 +1289,25 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         if (unassignedInfo != null) {
             unassignedInfo.toXContent(builder, params);
         }
+        if (recoveringChildShards != null) {
+            builder.startArray("recovering_child_shards");
+            for (ShardRouting childShard : recoveringChildShards) {
+                childShard.toXContent(builder, params);
+            }
+            builder.endArray();
+        }
+        if (parentShardId != null) {
+            builder.field("parent_shard_id");
+            parentShardId.toXContent(builder, params);
+        }
+
         return builder.endObject();
     }
 
     /**
-     * Returns the expected shard size for {@link ShardRoutingState#RELOCATING} and {@link ShardRoutingState#INITIALIZING}
-     * shards. If it's size is not available {@value #UNAVAILABLE_EXPECTED_SHARD_SIZE} will be returned.
+     * Returns the expected shard size for {@link ShardRoutingState#RELOCATING}, {@link ShardRoutingState#INITIALIZING}
+     * and {@link ShardRoutingState#SPLITTING} shards. If it's size is not available {@value #UNAVAILABLE_EXPECTED_SHARD_SIZE}
+     * will be returned.
      */
     public long getExpectedShardSize() {
         return expectedShardSize;
@@ -959,4 +1329,25 @@ public boolean unassignedReasonIndexCreated() {
         }
         return false;
     }
+
+    public boolean unassignedReasonChildShardCreated() {
+        if (unassignedInfo != null) {
+            return unassignedInfo.getReason() == UnassignedInfo.Reason.CHILD_SHARD_CREATED;
+        }
+        return false;
+    }
+
+    @Nullable
+    public ShardRouting[] getRecoveringChildShards() {
+        // Not returning copy because in RoutingNodes shards are removed based on their object identity.
+        return recoveringChildShards;
+    }
+
+    public ShardId getParentShardId() {
+        return parentShardId;
+    }
+
+    public boolean isStartedChildReplica() {
+        return primary == false && getParentShardId() != null && started();
+    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/ShardRoutingState.java b/server/src/main/java/org/opensearch/cluster/routing/ShardRoutingState.java
index 2086159790ba9..4f750418d07fb 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/ShardRoutingState.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/ShardRoutingState.java
@@ -58,7 +58,11 @@ public enum ShardRoutingState {
     /**
      * The shard is in the process being relocated.
      */
-    RELOCATING((byte) 4);
+    RELOCATING((byte) 4),
+    /**
+     * The shard is in the process being relocated.
+     */
+    SPLITTING((byte) 5);
 
     private byte value;
 
@@ -84,6 +88,8 @@ public static ShardRoutingState fromValue(byte value) {
                 return STARTED;
             case 4:
                 return RELOCATING;
+            case 5:
+                return SPLITTING;
             default:
                 throw new IllegalStateException("No routing state mapped for [" + value + "]");
         }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/UnassignedInfo.java b/server/src/main/java/org/opensearch/cluster/routing/UnassignedInfo.java
index cf6dc9cd7306e..17286909ead81 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/UnassignedInfo.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/UnassignedInfo.java
@@ -150,7 +150,11 @@ public enum Reason {
         /**
          * Unassigned as a result of closing an index.
          */
-        INDEX_CLOSED
+        INDEX_CLOSED,
+        /**
+         * Unassigned as allocation of this child shard is pending..
+         */
+        CHILD_SHARD_CREATED
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/AllocationDecision.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/AllocationDecision.java
index 6aeb904fed66f..4abe66b9c3acf 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/AllocationDecision.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/AllocationDecision.java
@@ -87,7 +87,11 @@ public enum AllocationDecision implements Writeable {
     /**
      * No attempt was made to allocate the shard
      */
-    NO_ATTEMPT((byte) 7);
+    NO_ATTEMPT((byte) 7),
+    /**
+     * Shard can be split.
+     */
+    SPLIT((byte) 7);
 
     private final byte id;
 
@@ -158,6 +162,8 @@ public static AllocationDecision fromDecisionType(Decision.Type type) {
                 return YES;
             case THROTTLE:
                 return THROTTLED;
+            case SPLIT:
+                return SPLIT;
             default:
                 assert type == Decision.Type.NO;
                 return NO;
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/AllocationService.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/AllocationService.java
index 78f17c9ff212b..d5e146710eba2 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/AllocationService.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/AllocationService.java
@@ -59,6 +59,7 @@
 import org.opensearch.cluster.routing.allocation.decider.Decision;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.gateway.GatewayAllocator;
 import org.opensearch.gateway.PriorityComparator;
 import org.opensearch.gateway.ShardsBatchGatewayAllocator;
@@ -662,7 +663,10 @@ private void disassociateDeadNodes(RoutingAllocation allocation) {
     private void applyStartedShards(RoutingAllocation routingAllocation, List<ShardRouting> startedShardEntries) {
         assert startedShardEntries.isEmpty() == false : "non-empty list of started shard entries expected";
         RoutingNodes routingNodes = routingAllocation.routingNodes();
+
+        Map<ShardId, List<ShardRouting>> inPlaceChildShards = new HashMap<>();
         for (ShardRouting startedShard : startedShardEntries) {
+            logger.info("Started shard cluster state event for shard routing: " + startedShard);
             assert startedShard.initializing() : "only initializing shards can be started";
             assert routingAllocation.metadata().index(startedShard.shardId().getIndex()) != null
                 : "shard started for unknown index (shard entry: " + startedShard + ")";
@@ -671,8 +675,20 @@ private void applyStartedShards(RoutingAllocation routingAllocation, List<ShardR
                     + startedShard
                     + " but was: "
                     + routingNodes.getByAllocationId(startedShard.shardId(), startedShard.allocationId().getId());
+            if (startedShard.isSplitTarget()) {
+                inPlaceChildShards.computeIfAbsent(startedShard.getParentShardId(), k -> new ArrayList<>());
+                inPlaceChildShards.get(startedShard.getParentShardId()).add(startedShard);
+            } else {
+                routingNodes.startShard(logger, startedShard, routingAllocation.changes());
+            }
+        }
 
-            routingNodes.startShard(logger, startedShard, routingAllocation.changes());
+        if (inPlaceChildShards.isEmpty() == false) {
+            inPlaceChildShards.values().forEach(childShards -> {
+                IndexMetadata indexMetadata = routingAllocation.metadata().getIndexSafe(childShards.get(0).index());
+                routingNodes.startInPlaceChildShards(logger, childShards, indexMetadata, routingAllocation.changes(),
+                    routingAllocation.routingTable());
+            });
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/IndexMetadataUpdater.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/IndexMetadataUpdater.java
index e673c1409a869..895df451df4ab 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/IndexMetadataUpdater.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/IndexMetadataUpdater.java
@@ -76,7 +76,8 @@ public class IndexMetadataUpdater extends RoutingChangesObserver.AbstractRouting
 
     @Override
     public void shardInitialized(ShardRouting unassignedShard, ShardRouting initializedShard) {
-        assert initializedShard.isRelocationTarget() == false : "shardInitialized is not called on relocation target: " + initializedShard;
+        assert initializedShard.isRelocationTarget() == false && initializedShard.isSplitTarget() == false
+            : "shardInitialized is not called on relocation/split target: " + initializedShard;
         if (initializedShard.primary()) {
             increasePrimaryTerm(initializedShard.shardId());
             Updates updates = changes(initializedShard.shardId());
@@ -113,7 +114,7 @@ public void shardStarted(ShardRouting initializingShard, ShardRouting startedSha
 
     @Override
     public void shardFailed(ShardRouting failedShard, UnassignedInfo unassignedInfo) {
-        if (failedShard.active() && failedShard.primary()) {
+        if (failedShard.active() && failedShard.primary() && failedShard.getParentShardId() != null) {
             Updates updates = changes(failedShard.shardId());
             if (updates.firstFailedPrimary == null) {
                 // more than one primary can be failed (because of batching, primary can be failed, replica promoted and then failed...)
@@ -129,11 +130,56 @@ public void shardFailed(ShardRouting failedShard, UnassignedInfo unassignedInfo)
         }
     }
 
+    @Override
+    public boolean isSplitOfShardFailed(ShardRouting parentShard) {
+        Updates updates = changes(parentShard.shardId());
+        return updates.splitFailed;
+    }
+
     @Override
     public void relocationCompleted(ShardRouting removedRelocationSource) {
         removeAllocationId(removedRelocationSource);
     }
 
+    @Override
+    public void splitCompleted(ShardRouting removedSplitSource, IndexMetadata indexMetadata) {
+        removeAllocationId(removedSplitSource);
+        Updates updates = changes(removedSplitSource.shardId());
+        for (ShardRouting childShard : removedSplitSource.getRecoveringChildShards()) {
+            if (childShard.primary()) {
+                updates.addedPrimaryChildShards.put(childShard.shardId(), childShard);
+                Updates childUpdates = changes(childShard.shardId());
+                childUpdates.isNewPrimaryChild = true;
+            }
+        }
+    }
+
+    @Override
+    public void childReplicaStarted(ShardRouting initializingShard, ShardRouting parentShard, ShardRouting childReplica) {
+        assert childReplica.allocationId().getParentAllocationId().equals(parentShard.allocationId().getId());
+        assert childReplica.allocationId().equals(initializingShard.allocationId());
+        Updates updates = changes(parentShard.shardId());
+        updates.addedAllocationIds.add(childReplica.allocationId().getId());
+        Updates childUpdates = changes(childReplica.shardId());
+        childUpdates.addedAllocationIds.add(childReplica.allocationId().getId());
+        childUpdates.isNewReplicaChild = true;
+    }
+
+    @Override
+    public void childShardFailed(ShardRouting parentShard, ShardRouting childShard) {
+        assert childShard.allocationId().getParentAllocationId().equals(parentShard.allocationId().getId());
+        assert childShard.allocationId().equals(childShard.allocationId());
+        Updates updates = changes(parentShard.shardId());
+        updates.removedAllocationIds.add(childShard.allocationId().getId());
+        updates.splitFailed = true;
+    }
+
+    @Override
+    public void splitFailed(ShardRouting splitSource, IndexMetadata indexMetadata) {
+        Updates updates = changes(splitSource.shardId());
+        updates.splitFailed = true;
+    }
+
     /**
      * Adds the target {@link ShardRouting} to the tracking updates set.
      * Used to track started relocations while applying changes to the new {@link ClusterState}
@@ -170,8 +216,18 @@ public Metadata applyChanges(Metadata oldMetadata, RoutingTable newRoutingTable,
             for (Map.Entry<ShardId, Updates> shardEntry : indexChanges.getValue()) {
                 ShardId shardId = shardEntry.getKey();
                 Updates updates = shardEntry.getValue();
-                indexMetadataBuilder = updateInSyncAllocations(newRoutingTable, oldIndexMetadata, indexMetadataBuilder, shardId, updates);
-                indexMetadataBuilder = updatePrimaryTerm(oldIndexMetadata, indexMetadataBuilder, shardId, updates);
+                // Avoid updating primary term and in-sync allocations for parent and child shards here.
+                if (updates.isNewPrimaryChild == false && updates.addedPrimaryChildShards.isEmpty() == true) {
+                    indexMetadataBuilder = updateInSyncAllocations(newRoutingTable, oldIndexMetadata, indexMetadataBuilder, shardId, updates);
+                    indexMetadataBuilder = updatePrimaryTerm(oldIndexMetadata, indexMetadataBuilder, shardId, updates);
+                }
+                // Invoke metadata update of in-place split only for the parent shard.
+                if (updates.addedPrimaryChildShards.isEmpty() == false && updates.splitFailed == false) {
+                    indexMetadataBuilder = updateMetadataForCompletedInPlaceSplit(oldIndexMetadata, indexMetadataBuilder, shardId, updates);
+                }
+                if (updates.splitFailed) {
+                    updateMetadataForInPlaceSplitFailed(oldIndexMetadata, indexMetadataBuilder, shardId);
+                }
                 if (ongoingRemoteStoreMigration) {
                     RemoteMigrationIndexMetadataUpdater migrationImdUpdater = new RemoteMigrationIndexMetadataUpdater(
                         discoveryNodes,
@@ -217,7 +273,6 @@ private IndexMetadata.Builder updateInSyncAllocations(
                 + updates.removedAllocationIds;
 
         Set<String> oldInSyncAllocationIds = oldIndexMetadata.inSyncAllocationIds(shardId.id());
-
         // check if we have been force-initializing an empty primary or a stale primary
         if (updates.initializedPrimary != null
             && oldInSyncAllocationIds.isEmpty() == false
@@ -248,6 +303,16 @@ private IndexMetadata.Builder updateInSyncAllocations(
                 // forcing a stale primary resets the in-sync allocations to the singleton set with the stale id
                 indexMetadataBuilder.putInSyncAllocationIds(shardId.id(), Collections.singleton(allocationId));
             }
+        } else if (updates.isNewReplicaChild) {
+            if (oldInSyncAllocationIds == null) {
+                oldInSyncAllocationIds = new HashSet<>();
+            }
+            if (indexMetadataBuilder == null) {
+                indexMetadataBuilder = IndexMetadata.builder(oldIndexMetadata);
+            }
+            Set<String> inSyncAllocationIds = new HashSet<>(oldInSyncAllocationIds);
+            inSyncAllocationIds.addAll(updates.addedAllocationIds);
+            indexMetadataBuilder.putInSyncAllocationIds(shardId.id(), inSyncAllocationIds);
         } else {
             // standard path for updating in-sync ids
             Set<String> inSyncAllocationIds = new HashSet<>(oldInSyncAllocationIds);
@@ -278,6 +343,7 @@ private IndexMetadata.Builder updateInSyncAllocations(
                     .stream()
                     .filter(s -> s.isRelocationTarget() == false)
                     .filter(s -> s.isSearchOnly() == false) // do not consider search only shards for in sync validation
+                    .filter(s -> s.getParentShardId() == null)
                     .collect(Collectors.toList());
                 assert assignedShards.size() <= maxActiveShards : "cannot have more assigned shards "
                     + assignedShards
@@ -388,6 +454,45 @@ private IndexMetadata.Builder updatePrimaryTerm(
         return indexMetadataBuilder;
     }
 
+    /**
+     * Adds primary terms of child shards and updates number of shards.
+     */
+    private IndexMetadata.Builder updateMetadataForCompletedInPlaceSplit(
+        IndexMetadata oldIndexMetadata,
+        IndexMetadata.Builder indexMetadataBuilder,
+        ShardId parentShardId,
+        Updates updates
+    ) {
+        if (updates.addedPrimaryChildShards.isEmpty()) {
+            return indexMetadataBuilder;
+        }
+
+        if (indexMetadataBuilder == null) {
+            indexMetadataBuilder = IndexMetadata.builder(oldIndexMetadata);
+        }
+
+        // We will only have allocation IDs of primary child shards in this map.
+        Map<Integer, String> shardIdToAllocationId = new HashMap<>();
+        updates.addedPrimaryChildShards.forEach((shardId, shardRouting) -> {
+            shardIdToAllocationId.put(shardId.id(), shardRouting.allocationId().getId());
+        });
+
+        indexMetadataBuilder.updateMetadataForNewChildShards(shardIdToAllocationId, parentShardId.id());
+        return indexMetadataBuilder;
+    }
+
+    /**
+     * Removes parent shard split metadata from index metadata parent shards.
+     */
+    private IndexMetadata.Builder updateMetadataForInPlaceSplitFailed(IndexMetadata oldIndexMetadata,
+                                                                         IndexMetadata.Builder indexMetadataBuilder,
+                                                                         ShardId parentShardId) {
+        if (indexMetadataBuilder == null) {
+            indexMetadataBuilder = IndexMetadata.builder(oldIndexMetadata);
+        }
+        return indexMetadataBuilder.cancelSplit(parentShardId.id());
+    }
+
     /**
      * Helper method that creates update entry for the given shard id if such an entry does not exist yet.
      */
@@ -399,7 +504,7 @@ private Updates changes(ShardId shardId) {
      * Remove allocation id of this shard from the set of in-sync shard copies
      */
     void removeAllocationId(ShardRouting shardRouting) {
-        if (shardRouting.active()) {
+        if (shardRouting.active() && shardRouting.getParentShardId() == null) {
             changes(shardRouting.shardId()).removedAllocationIds.add(shardRouting.allocationId().getId());
         }
     }
@@ -417,6 +522,12 @@ public void setOngoingRemoteStoreMigration(boolean ongoingRemoteStoreMigration)
 
     private static class Updates {
         private boolean increaseTerm; // whether primary term should be increased
+        // Child shard ids for this shard which is now split. To be added in in-sync, assign primary term of this shard
+        // and update number of current shards.
+        private final Map<ShardId, ShardRouting> addedPrimaryChildShards = new HashMap<>();
+        private boolean isNewPrimaryChild; // Updated against a new primary child shard. Used to skip child shards in applyChanges.
+        private boolean isNewReplicaChild;
+        private boolean splitFailed;
         private Set<String> addedAllocationIds = new HashSet<>(); // allocation ids that should be added to the in-sync set
         private Set<String> removedAllocationIds = new HashSet<>(); // allocation ids that should be removed from the in-sync set
         private ShardRouting initializedPrimary = null; // primary that was initialized from unassigned
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/MoveDecision.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/MoveDecision.java
index 13578d1a11472..8f08015271f18 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/MoveDecision.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/MoveDecision.java
@@ -215,6 +215,15 @@ public boolean canRemain() {
         return canRemainDecision.type() == Type.YES;
     }
 
+    /**
+     * Returns {@code true} if the shard can split on current node, returns {@code false} otherwise.
+     * If {@link #isDecisionTaken()} returns {@code false}, then invoking this method will throw an {@code IllegalStateException}.
+     */
+    public boolean canSplit() {
+        checkDecisionState();
+        return canRemainDecision.type() == Type.SPLIT;
+    }
+
     /**
      * Returns the decision for the shard being allowed to remain on its current node.  If {@link #isDecisionTaken()}
      * returns {@code false}, then invoking this method will throw an {@code IllegalStateException}.
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/RoutingNodesChangedObserver.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/RoutingNodesChangedObserver.java
index ca6391aad3500..100885b41b40a 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/RoutingNodesChangedObserver.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/RoutingNodesChangedObserver.java
@@ -32,11 +32,14 @@
 
 package org.opensearch.cluster.routing.allocation;
 
+import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.routing.RoutingChangesObserver;
 import org.opensearch.cluster.routing.RoutingNodes;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.routing.UnassignedInfo;
 
+import java.util.List;
+
 /**
  * Records if changes were made to {@link RoutingNodes} during an allocation round.
  *
@@ -73,6 +76,27 @@ public void relocationStarted(ShardRouting startedShard, ShardRouting targetRelo
         setChanged();
     }
 
+    @Override
+    public void splitStarted(ShardRouting startedShard, List<ShardRouting> childSplitShards) {
+        assert startedShard.started() : "expected started shard " + startedShard;
+        childSplitShards.forEach(childShard -> { assert childShard.isSplitTarget() : "expected split target shard " + childShard; });
+        setChanged();
+    }
+
+    @Override
+    public void childReplicaStarted(ShardRouting initializingShard, ShardRouting parentShard, ShardRouting childReplica) {
+        assert childReplica.started() : "expected started shard " + childReplica;
+        setChanged();
+    }
+
+    @Override
+    public void childShardFailed(ShardRouting parentShard, ShardRouting childShard) {
+        assert childShard.getParentShardId() != null : "expected a child shard " + childShard;
+        assert childShard.getParentShardId().equals(parentShard.shardId());
+        assert childShard.allocationId().getParentAllocationId().equals(parentShard.allocationId().getId());
+        setChanged();
+    }
+
     @Override
     public void unassignedInfoUpdated(ShardRouting unassignedShard, UnassignedInfo newUnassignedInfo) {
         assert unassignedShard.unassigned() : "expected unassigned shard " + unassignedShard;
@@ -98,6 +122,24 @@ public void relocationSourceRemoved(ShardRouting removedReplicaRelocationSource)
         setChanged();
     }
 
+    @Override
+    public void splitCompleted(ShardRouting removedSplitSource, IndexMetadata indexMetadata) {
+        assert removedSplitSource.splitting() : "expected splitting shard " + removedSplitSource;
+        setChanged();
+    }
+
+    @Override
+    public void splitFailed(ShardRouting splitSource, IndexMetadata indexMetadata) {
+        assert splitSource.splitting() : "expected splitting shard " + splitSource;
+        setChanged();
+    }
+
+    @Override
+    public boolean isSplitOfShardFailed(ShardRouting parentShard) {
+        // Nothing to do here since splitFailed would have already marked changes in case of split failure.
+        return false;
+    }
+
     @Override
     public void replicaPromoted(ShardRouting replicaShard) {
         assert replicaShard.started() && replicaShard.primary() == false : "expected started replica shard " + replicaShard;
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/BalancedShardsAllocator.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/BalancedShardsAllocator.java
index cfbb4d34c3a38..50b09a403b35e 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/BalancedShardsAllocator.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/BalancedShardsAllocator.java
@@ -373,6 +373,7 @@ public void allocate(RoutingAllocation allocation) {
         localShardsBalancer.allocateUnassigned();
         localShardsBalancer.moveShards();
         localShardsBalancer.balance();
+        localShardsBalancer.assignChildShardsOfSplittingShards();
         scheduleRerouteIfAllocatorTimedOut();
 
         final ShardsBalancer remoteShardsBalancer = new RemoteShardsBalancer(logger, allocation);
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/LocalShardsBalancer.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/LocalShardsBalancer.java
index 7f6a7790d1db0..e9c8aa04d9510 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/LocalShardsBalancer.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/LocalShardsBalancer.java
@@ -14,6 +14,7 @@
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.routing.RecoverySource;
+import org.opensearch.cluster.metadata.SplitShardsMetadata;
 import org.opensearch.cluster.routing.RoutingNode;
 import org.opensearch.cluster.routing.RoutingNodes;
 import org.opensearch.cluster.routing.RoutingPool;
@@ -695,6 +696,17 @@ MoveDecision decideMove(final ShardRouting shardRouting) {
         assert sourceNode != null && sourceNode.containsShard(shardRouting);
         RoutingNode routingNode = sourceNode.getRoutingNode();
         Decision canRemain = allocation.deciders().canRemain(shardRouting, routingNode, allocation);
+        AllocationResult allocationResult = new AllocationResult(null, 0, Decision.Type.NO);
+        List<NodeAllocationResult> nodeExplanationMap = explain ? new ArrayList<>() : null;
+        if (canRemain.type() == Decision.Type.SPLIT) {
+            decideRoutingNode(allocationResult, explain, nodeExplanationMap, sourceNode.getRoutingNode(), shardRouting);
+            return MoveDecision.cannotRemain(
+                canRemain,
+                AllocationDecision.fromDecisionType(allocationResult.bestDecision),
+                allocationResult.targetNode != null ? allocationResult.targetNode.node() : null,
+                nodeExplanationMap
+            );
+        }
         if (canRemain.type() != Decision.Type.NO) {
             return MoveDecision.stay(canRemain);
         }
@@ -706,53 +718,76 @@ MoveDecision decideMove(final ShardRouting shardRouting) {
          * This is not guaranteed to be balanced after this operation we still try best effort to
          * allocate on the minimal eligible node.
          */
-        Decision.Type bestDecision = Decision.Type.NO;
-        RoutingNode targetNode = null;
-        final List<NodeAllocationResult> nodeExplanationMap = explain ? new ArrayList<>() : null;
-        int weightRanking = 0;
+        allocationResult = new AllocationResult(null, 0, Decision.Type.NO);
+        nodeExplanationMap = explain ? new ArrayList<>() : null;
         for (BalancedShardsAllocator.ModelNode currentNode : sorter.modelNodes) {
             if (currentNode != sourceNode) {
-                RoutingNode target = currentNode.getRoutingNode();
-                if (!explain && inEligibleTargetNode.contains(target)) continue;
-                // don't use canRebalance as we want hard filtering rules to apply. See #17698
-                if (!explain) {
-                    // If we cannot allocate any shard to node marking it in eligible
-                    Decision nodeLevelAllocationDecision = allocation.deciders().canAllocateAnyShardToNode(target, allocation);
-                    if (nodeLevelAllocationDecision.type() != Decision.Type.YES) {
-                        inEligibleTargetNode.add(currentNode.getRoutingNode());
-                        continue;
-                    }
-                }
-                // don't use canRebalance as we want hard filtering rules to apply. See #17698
-                Decision allocationDecision = allocation.deciders().canAllocate(shardRouting, target, allocation);
-                if (explain) {
-                    nodeExplanationMap.add(
-                        new NodeAllocationResult(currentNode.getRoutingNode().node(), allocationDecision, ++weightRanking)
-                    );
-                }
-                // TODO maybe we can respect throttling here too?
-                if (allocationDecision.type().higherThan(bestDecision)) {
-                    bestDecision = allocationDecision.type();
-                    if (bestDecision == Decision.Type.YES) {
-                        targetNode = target;
-                        if (explain == false) {
-                            // we are not in explain mode and already have a YES decision on the best weighted node,
-                            // no need to continue iterating
-                            break;
-                        }
-                    }
+                decideRoutingNode(allocationResult, explain, nodeExplanationMap, currentNode.getRoutingNode(), shardRouting);
+                if (allocationResult.targetFound) {
+                    break;
                 }
             }
         }
 
         return MoveDecision.cannotRemain(
             canRemain,
-            AllocationDecision.fromDecisionType(bestDecision),
-            targetNode != null ? targetNode.node() : null,
+            AllocationDecision.fromDecisionType(allocationResult.bestDecision),
+            allocationResult.targetNode != null ? allocationResult.targetNode.node() : null,
             nodeExplanationMap
         );
     }
 
+    private static class AllocationResult {
+        private RoutingNode targetNode;
+        private int weightRanking;
+        private Decision.Type bestDecision;
+        private boolean targetFound = false;
+
+        public AllocationResult(RoutingNode targetNode, int weightRanking, Decision.Type bestDecision) {
+            this.targetNode = targetNode;
+            this.weightRanking = weightRanking;
+            this.bestDecision = bestDecision;
+        }
+    }
+
+    private void decideRoutingNode(
+        AllocationResult allocationResult,
+        boolean explain,
+        final List<NodeAllocationResult> nodeExplanationMap,
+        RoutingNode target,
+        ShardRouting shardRouting
+    ) {
+        if (!explain && inEligibleTargetNode.contains(target)) {
+            return;
+        }
+        // don't use canRebalance as we want hard filtering rules to apply. See #17698
+        if (!explain) {
+            // If we cannot allocate any shard to node marking it in eligible
+            Decision nodeLevelAllocationDecision = allocation.deciders().canAllocateAnyShardToNode(target, allocation);
+            if (nodeLevelAllocationDecision.type() != Decision.Type.YES) {
+                inEligibleTargetNode.add(target);
+                return;
+            }
+        }
+        // don't use canRebalance as we want hard filtering rules to apply. See #17698
+        Decision allocationDecision = allocation.deciders().canAllocate(shardRouting, target, allocation);
+        if (explain) {
+            nodeExplanationMap.add(new NodeAllocationResult(target.node(), allocationDecision, ++allocationResult.weightRanking));
+        }
+        // TODO maybe we can respect throttling here too?
+        if (allocationDecision.type().higherThan(allocationResult.bestDecision)) {
+            allocationResult.bestDecision = allocationDecision.type();
+            if (allocationResult.bestDecision == Decision.Type.YES) {
+                allocationResult.targetNode = target;
+                if (explain == false) {
+                    // we are not in explain mode and already have a YES decision on the best weighted node,
+                    // no need to continue iterating
+                    allocationResult.targetFound = true;
+                }
+            }
+        }
+    }
+
     /**
      * Builds the internal model from all shards in the given
      * {@link Iterable}. All shards in the {@link Iterable} must be assigned
@@ -935,6 +970,119 @@ void allocateUnassigned() {
         // clear everything we have either added it or moved to ignoreUnassigned
     }
 
+    @Override
+    public void assignChildShardsOfSplittingShards() {
+        List<ShardRouting> splittingShards = routingNodes.splitting();
+        if (splittingShards.isEmpty()) {
+            return;
+        }
+
+        List<SplittingShardAssignmentInfo> splittingShardAssignmentInfos = new ArrayList<>();
+        for (ShardRouting splittingShard : splittingShards) {
+            IndexMetadata indexMetadata = allocation.metadata().getIndexSafe(splittingShard.index());
+            SplitShardsMetadata splitShardsMetadata = indexMetadata.getSplitShardsMetadata();
+            boolean inProgress = splitShardsMetadata.isSplitOfShardInProgress(splittingShard.shardId().id())
+                && allocation.changes().isSplitOfShardFailed(splittingShard) == false;
+            ShardRouting assignedPrimaryParent = routingNodes.activePrimary(splittingShard.shardId());
+            if (inProgress && assignedPrimaryParent != null) {
+                List<ShardRouting> primaryChildShards = new ArrayList<>();
+                List<ShardRouting> replicaChildShards = new ArrayList<>();
+
+                for (ShardRouting childShard : splittingShard.getRecoveringChildShards()) {
+                    if (childShard.primary()) {
+                        primaryChildShards.add(childShard);
+                    } else {
+                        replicaChildShards.add(childShard);
+                    }
+                }
+                SplittingShardAssignmentInfo splittingShardAssignmentInfo = new SplittingShardAssignmentInfo(
+                    indexMetadata.getIndexUUID(), assignedPrimaryParent, splittingShard, primaryChildShards,
+                    replicaChildShards);
+                splittingShardAssignmentInfos.add(splittingShardAssignmentInfo);
+            }
+        }
+
+        Collections.shuffle(splittingShardAssignmentInfos);
+        //TODO: build retry and cancel split to come out of failed shard
+
+        for (SplittingShardAssignmentInfo splittingShardAssignmentInfo : splittingShardAssignmentInfos) {
+
+            RoutingNode parentShardNode = routingNodes.node(splittingShardAssignmentInfo.assignedPrimaryParent.currentNodeId());
+            ShardRouting primaryChild;
+            BalancedShardsAllocator.ModelNode parentModelNode = nodes.get(splittingShardAssignmentInfo.assignedPrimaryParent.currentNodeId());
+            Map<ShardRouting, String> assignedRoutingNodes = new HashMap<>();
+            for (int addIdx = 0; addIdx < splittingShardAssignmentInfo.primaryChildShards.size(); addIdx++) {
+                primaryChild = splittingShardAssignmentInfo.primaryChildShards.get(addIdx);
+                Decision currentDecision = allocation.deciders().canAllocate(primaryChild, parentShardNode, allocation);
+                if (currentDecision.type() == Decision.Type.NO) {
+                    break;
+                }
+                parentModelNode.addShard(primaryChild);
+                assignedRoutingNodes.put(primaryChild, parentModelNode.getNodeId());
+            }
+
+            if (assignedRoutingNodes.size() != splittingShardAssignmentInfo.primaryChildShards.size()) {
+                assignedRoutingNodes.keySet().forEach(routing -> {
+                    BalancedShardsAllocator.ModelNode node = nodes.get(assignedRoutingNodes.get(routing));
+                    node.removeShard(routing);
+                });
+                continue;
+            }
+
+            for (ShardRouting replicaChild : splittingShardAssignmentInfo.replicaChildShards) {
+                final AllocateUnassignedDecision allocationDecision = decideAllocateUnassigned(replicaChild);
+                if (allocationDecision.getAllocationDecision() != AllocationDecision.YES) {
+                    break;
+                }
+                String assignedNodeId = allocationDecision.getTargetNode().getId();
+                assignedRoutingNodes.put(replicaChild, nodes.get(assignedNodeId).getNodeId());
+                nodes.get(assignedNodeId).addShard(replicaChild);
+            }
+
+            if (assignedRoutingNodes.size() != splittingShardAssignmentInfo.primaryChildShards.size() +
+                splittingShardAssignmentInfo.replicaChildShards.size()) {
+                assignedRoutingNodes.keySet().forEach(routing -> {
+                    BalancedShardsAllocator.ModelNode node = nodes.get(assignedRoutingNodes.get(routing));
+                    node.removeShard(routing);
+                });
+                continue;
+            }
+
+            if (logger.isTraceEnabled()) {
+                logger.trace("Splitting shard [{}]", splittingShardAssignmentInfo.assignedPrimaryParent.shardId());
+            }
+
+            routingNodes.assignChildShards(
+                splittingShardAssignmentInfo.assignedPrimaryParent,
+                splittingShardAssignmentInfo.splittingPrimaryParent,
+                allocation.changes(),
+                assignedRoutingNodes
+            );
+        }
+
+    }
+
+    private static class SplittingShardAssignmentInfo {
+        final String indexUUID;
+        final ShardRouting assignedPrimaryParent;
+        final ShardRouting splittingPrimaryParent;
+        final List<ShardRouting> primaryChildShards;
+        final List<ShardRouting> replicaChildShards;
+
+        public SplittingShardAssignmentInfo(
+            String indexUUID,
+            ShardRouting assignedPrimaryParent,
+            ShardRouting splittingPrimaryParent,
+            List<ShardRouting> primaryChildShards,
+            List<ShardRouting> replicaChildShards) {
+            this.indexUUID = indexUUID;
+            this.assignedPrimaryParent = assignedPrimaryParent;
+            this.splittingPrimaryParent = splittingPrimaryParent;
+            this.primaryChildShards = primaryChildShards;
+            this.replicaChildShards = replicaChildShards;
+        }
+    }
+
     /**
      * Make a decision for allocating an unassigned shard.  This method returns a two values in a tuple: the
      * first value is the {@link Decision} taken to allocate the unassigned shard, the second value is the
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/RemoteShardsBalancer.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/RemoteShardsBalancer.java
index 7999faece52ca..5a8bb603de8ed 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/RemoteShardsBalancer.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/RemoteShardsBalancer.java
@@ -272,6 +272,10 @@ void balance() {
         }
     }
 
+    @Override
+    public void assignChildShardsOfSplittingShards() {
+    }
+
     /**
      * Calculates the total number of primary shards per node.
      * @param remoteRoutingNodes routing nodes for which the aggregation needs to be performed
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/ShardsBalancer.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/ShardsBalancer.java
index ef2dbd34644a7..c49e4e101d98b 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/ShardsBalancer.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/ShardsBalancer.java
@@ -37,6 +37,11 @@ public abstract class ShardsBalancer {
      */
     abstract void balance();
 
+    /**
+     *  Allocate child shard against a splitting shards.
+     */
+    abstract void assignChildShardsOfSplittingShards();
+
     /**
      * Make a decision for allocating an unassigned shard.
      * @param shardRouting the shard for which the decision has to be made
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/command/CancelAllocationCommand.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/command/CancelAllocationCommand.java
index a07f3eb9d95e1..a517afaa779fd 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/command/CancelAllocationCommand.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/command/CancelAllocationCommand.java
@@ -165,8 +165,8 @@ public RerouteExplanation execute(RoutingAllocation allocation, boolean explain)
             throw new IllegalArgumentException("[cancel_allocation] can't cancel " + shardId + ", failed to find it on node " + discoNode);
         }
         if (shardRouting.primary() && allowPrimary == false) {
-            if ((shardRouting.initializing() && shardRouting.relocatingNodeId() != null) == false) {
-                // only allow cancelling initializing shard of primary relocation without allowPrimary flag
+            if ((shardRouting.initializing() && (shardRouting.relocatingNodeId() != null || shardRouting.isSplitTarget())) == false) {
+                // only allow cancelling initializing shard of primary relocation/split without allowPrimary flag
                 if (explain) {
                     return new RerouteExplanation(
                         this,
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/Decision.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/Decision.java
index 938c457606c79..a1c9bb8937395 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/Decision.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/Decision.java
@@ -32,6 +32,7 @@
 
 package org.opensearch.cluster.routing.allocation.decider;
 
+import org.opensearch.Version;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.core.common.io.stream.StreamInput;
@@ -64,6 +65,7 @@ public abstract class Decision implements ToXContent, Writeable {
     public static final Decision YES = new Single(Type.YES);
     public static final Decision NO = new Single(Type.NO);
     public static final Decision THROTTLE = new Single(Type.THROTTLE);
+    public static final Decision SPLIT = new Single(Type.SPLIT);
 
     /**
      * Creates a simple decision
@@ -106,6 +108,7 @@ public static Decision readFrom(StreamInput in) throws IOException {
     public enum Type implements Writeable {
         YES(1),
         THROTTLE(2),
+        SPLIT(3),
         NO(0);
 
         private final int id;
@@ -123,6 +126,8 @@ public static Type readFrom(StreamInput in) throws IOException {
                     return YES;
                 case 2:
                     return THROTTLE;
+                case 3:
+                    return SPLIT;
                 default:
                     throw new IllegalArgumentException("No Type for integer [" + i + "]");
             }
@@ -130,7 +135,12 @@ public static Type readFrom(StreamInput in) throws IOException {
 
         @Override
         public void writeTo(StreamOutput out) throws IOException {
-            out.writeVInt(id);
+            if (out.getVersion().onOrAfter(Version.V_3_0_0) || id != SPLIT.id) {
+                out.writeVInt(id);
+            } else {
+                throw new IllegalStateException("In-place split not allowed on older versions.");
+            }
+
         }
 
         public boolean higherThan(Type other) {
@@ -320,6 +330,8 @@ public Type type() {
                     return type;
                 } else if (type == Type.THROTTLE) {
                     ret = type;
+                } else if (type == Type.SPLIT) {
+                    ret = type;
                 }
             }
             return ret;
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/InPlaceShardSplitAllocationDecider.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/InPlaceShardSplitAllocationDecider.java
new file mode 100644
index 0000000000000..fc45f533ca13b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/InPlaceShardSplitAllocationDecider.java
@@ -0,0 +1,33 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing.allocation.decider;
+
+import org.opensearch.cluster.metadata.SplitShardsMetadata;
+import org.opensearch.cluster.routing.RoutingNode;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.allocation.RoutingAllocation;
+
+public class InPlaceShardSplitAllocationDecider extends AllocationDecider {
+
+    public static final String NAME = "in_place_shard_split";
+
+    public Decision canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {
+        if (shardRouting.isSplitTarget() || shardRouting.splitting()) {
+            return Decision.NO;
+        }
+        return Decision.ALWAYS;
+    }
+
+    public Decision canMoveAway(ShardRouting shardRouting, RoutingAllocation allocation) {
+        if (shardRouting.isSplitTarget() || shardRouting.splitting()) {
+            return Decision.NO;
+        }
+        return Decision.ALWAYS;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/ReplicaAfterPrimaryActiveAllocationDecider.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/ReplicaAfterPrimaryActiveAllocationDecider.java
index 52b89f5c403e8..f6b5d0dc40b5b 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/ReplicaAfterPrimaryActiveAllocationDecider.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/ReplicaAfterPrimaryActiveAllocationDecider.java
@@ -52,8 +52,8 @@ public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, Routing
 
     @Override
     public Decision canAllocate(ShardRouting shardRouting, RoutingAllocation allocation) {
-        if (shardRouting.primary()) {
-            return allocation.decision(Decision.YES, NAME, "shard is primary and can be allocated");
+        if (shardRouting.primary() || shardRouting.getParentShardId() != null) {
+            return allocation.decision(Decision.YES, NAME, "shard is primary or a split target and can be allocated");
         }
         ShardRouting primary = allocation.routingNodes().activePrimary(shardRouting.shardId());
         if (primary == null) {
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/ThrottlingAllocationDecider.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/ThrottlingAllocationDecider.java
index 32639bc3065da..0916e60a2a8be 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/ThrottlingAllocationDecider.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/ThrottlingAllocationDecider.java
@@ -43,11 +43,11 @@
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Setting.Property;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.core.index.shard.ShardId;
 
 import java.util.function.BiFunction;
 
-import static org.opensearch.cluster.routing.allocation.decider.Decision.THROTTLE;
-import static org.opensearch.cluster.routing.allocation.decider.Decision.YES;
+import static org.opensearch.cluster.routing.allocation.decider.Decision.*;
 
 /**
  * {@link ThrottlingAllocationDecider} controls the recovery process per node in
@@ -194,7 +194,7 @@ public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, Routing
             assert initializingShard(shardRouting, node.nodeId()).recoverySource().getType() == RecoverySource.Type.PEER
                 || shardRouting.isSearchOnly();
 
-            if (shardRouting.unassignedReasonIndexCreated()) {
+            if (shardRouting.unassignedReasonIndexCreated() || shardRouting.unassignedReasonChildShardCreated()) {
                 return allocateInitialShardCopies(shardRouting, node, allocation);
             } else {
                 return allocateNonInitialShardCopies(shardRouting, node, allocation);
@@ -203,8 +203,15 @@ assert initializingShard(shardRouting, node.nodeId()).recoverySource().getType()
     }
 
     private Decision allocateInitialShardCopies(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
+        if (shardRouting.getParentShardId() != null) {
+            assert shardRouting.primary() == false;
+            //TODO: Implement throttling for replica recoveries after primary children synced state.
+            return allocation.decision(YES, NAME, "Skipping throttling for replica recovery");
+        }
         int currentInRecoveries = allocation.routingNodes().getInitialIncomingRecoveries(node.nodeId());
-        assert shardRouting.unassignedReasonIndexCreated() && !shardRouting.primary();
+        assert (shardRouting.unassignedReasonIndexCreated() || shardRouting.unassignedReasonChildShardCreated())
+            && !shardRouting.primary();
+
         return allocateShardCopies(
             shardRouting,
             allocation,
@@ -240,7 +247,13 @@ private Integer getPrimaryNodeOutgoingRecoveries(ShardRouting shardRouting, Rout
     }
 
     private Integer getInitialPrimaryNodeOutgoingRecoveries(ShardRouting shardRouting, RoutingAllocation allocation) {
-        ShardRouting primaryShard = allocation.routingNodes().activePrimary(shardRouting.shardId());
+        ShardId primaryShardId;
+        if (shardRouting.getParentShardId() != null && shardRouting.primary() == false) {
+            primaryShardId = shardRouting.getParentShardId();
+        } else {
+            primaryShardId = shardRouting.shardId();
+        }
+        ShardRouting primaryShard = allocation.routingNodes().activePrimary(primaryShardId);
         return allocation.routingNodes().getInitialOutgoingRecoveries(primaryShard.currentNodeId());
     }
 
@@ -373,6 +386,9 @@ private ShardRouting initializingShard(ShardRouting shardRouting, String current
 
     @Override
     public Decision canMoveAway(ShardRouting shardRouting, RoutingAllocation allocation) {
+        if (shardRouting.getParentShardId() != null) {
+            return allocation.decision(NO, NAME, "recovering child shard");
+        }
         int outgoingRecoveries = 0;
         if (!shardRouting.primary()) {
             ShardRouting primaryShard = allocation.routingNodes().activePrimary(shardRouting.shardId());
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterManagerTaskKeys.java b/server/src/main/java/org/opensearch/cluster/service/ClusterManagerTaskKeys.java
index c88bea56cb9bd..1b23caf6e0c34 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterManagerTaskKeys.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterManagerTaskKeys.java
@@ -48,5 +48,6 @@ public final class ClusterManagerTaskKeys {
     public static final String UPDATE_SNAPSHOT_STATE_KEY = "update-snapshot-state";
     public static final String RESTORE_SNAPSHOT_KEY = "restore-snapshot";
     public static final String CLUSTER_REROUTE_API_KEY = "cluster-reroute-api";
+    public static final String IN_PLACE_SHARD_SPLIT_TASK = "in-place-shard-split-task";
 
 }
diff --git a/server/src/main/java/org/opensearch/common/blobstore/AsyncMultiStreamBlobContainer.java b/server/src/main/java/org/opensearch/common/blobstore/AsyncMultiStreamBlobContainer.java
index b769cdc2fe7ab..7df199f30482f 100644
--- a/server/src/main/java/org/opensearch/common/blobstore/AsyncMultiStreamBlobContainer.java
+++ b/server/src/main/java/org/opensearch/common/blobstore/AsyncMultiStreamBlobContainer.java
@@ -15,6 +15,7 @@
 
 import java.io.IOException;
 import java.util.List;
+import java.util.Set;
 
 /**
  * An extension of {@link BlobContainer} that adds {@link AsyncMultiStreamBlobContainer#asyncBlobUpload} to allow
@@ -53,4 +54,17 @@ public interface AsyncMultiStreamBlobContainer extends BlobContainer {
     void deleteAsync(ActionListener<DeleteResult> completionListener);
 
     void deleteBlobsAsyncIgnoringIfNotExists(List<String> blobNames, ActionListener<Void> completionListener);
+    /**
+     * Should copy files from source remote directory to current remote directory if any of the provided files
+     * doesn't already exist.
+     * It should first make sure that all provided files are present in source directory. Also, it should make an exact
+     * copy of the source file. This means that all parts if applicable should be an exact replica and metadata and tags
+     * should be copied over.
+     *
+     * @param files Files to be copied from source.
+     * @param blobContainer Source container from which files are to be copied.
+     * @return Subset of files from the provided files which were actually copied from source to target depending on the
+     *         availability of file in source remote directory/
+     */
+    Set<String> copyFilesFromSrcRemote(Set<String> files, AsyncMultiStreamBlobContainer blobContainer);
 }
diff --git a/server/src/main/java/org/opensearch/common/blobstore/AsyncMultiStreamEncryptedBlobContainer.java b/server/src/main/java/org/opensearch/common/blobstore/AsyncMultiStreamEncryptedBlobContainer.java
index 286c01f9dca44..5a88b2c71f8fe 100644
--- a/server/src/main/java/org/opensearch/common/blobstore/AsyncMultiStreamEncryptedBlobContainer.java
+++ b/server/src/main/java/org/opensearch/common/blobstore/AsyncMultiStreamEncryptedBlobContainer.java
@@ -19,6 +19,7 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.List;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 /**
@@ -64,6 +65,11 @@ public boolean remoteIntegrityCheckSupported() {
         return false;
     }
 
+    @Override
+    public Set<String> copyFilesFromSrcRemote(Set<String> filesToCopy, AsyncMultiStreamBlobContainer blobContainer) {
+        return blobContainer.copyFilesFromSrcRemote(filesToCopy, blobContainer);
+    }
+
     static class EncryptedWriteContext<T, U> extends WriteContext {
 
         private final T encryptionMetadata;
diff --git a/server/src/main/java/org/opensearch/common/blobstore/BlobContainer.java b/server/src/main/java/org/opensearch/common/blobstore/BlobContainer.java
index a2e4199029ef4..0ab005b451ff7 100644
--- a/server/src/main/java/org/opensearch/common/blobstore/BlobContainer.java
+++ b/server/src/main/java/org/opensearch/common/blobstore/BlobContainer.java
@@ -279,7 +279,8 @@ default void writeBlobAtomicWithMetadata(
      */
     enum BlobNameSortOrder {
 
-        LEXICOGRAPHIC(Comparator.comparing(BlobMetadata::name));
+        LEXICOGRAPHIC(Comparator.comparing(BlobMetadata::name)),
+        CHRONOLOGICAL(Comparator.comparing(BlobMetadata::lastModified));
 
         final Comparator<BlobMetadata> comparator;
 
diff --git a/server/src/main/java/org/opensearch/common/blobstore/BlobMetadata.java b/server/src/main/java/org/opensearch/common/blobstore/BlobMetadata.java
index 37c70365b6a11..b594d322ac820 100644
--- a/server/src/main/java/org/opensearch/common/blobstore/BlobMetadata.java
+++ b/server/src/main/java/org/opensearch/common/blobstore/BlobMetadata.java
@@ -48,4 +48,9 @@ public interface BlobMetadata {
      * Gets the size of the blob in bytes.
      */
     long length();
+
+    /**
+     * Gets last modified time of blob in epoch millis.
+     */
+    long lastModified();
 }
diff --git a/server/src/main/java/org/opensearch/common/blobstore/EncryptedBlobMetadata.java b/server/src/main/java/org/opensearch/common/blobstore/EncryptedBlobMetadata.java
index 8917bba806d08..4abf1596184ea 100644
--- a/server/src/main/java/org/opensearch/common/blobstore/EncryptedBlobMetadata.java
+++ b/server/src/main/java/org/opensearch/common/blobstore/EncryptedBlobMetadata.java
@@ -36,6 +36,11 @@ public String name() {
         return delegate.name();
     }
 
+    @Override
+    public long lastModified() {
+        return delegate.lastModified();
+    }
+
     @Override
     public long length() {
         U cryptoContext;
diff --git a/server/src/main/java/org/opensearch/common/blobstore/fs/FsBlobContainer.java b/server/src/main/java/org/opensearch/common/blobstore/fs/FsBlobContainer.java
index b6644ffd16bab..8dbe63dcecff4 100644
--- a/server/src/main/java/org/opensearch/common/blobstore/fs/FsBlobContainer.java
+++ b/server/src/main/java/org/opensearch/common/blobstore/fs/FsBlobContainer.java
@@ -123,7 +123,7 @@ public Map<String, BlobMetadata> listBlobsByPrefix(String blobNamePrefix) throws
                     continue;
                 }
                 if (attrs.isRegularFile()) {
-                    builder.put(file.getFileName().toString(), new PlainBlobMetadata(file.getFileName().toString(), attrs.size()));
+                    builder.put(file.getFileName().toString(), new PlainBlobMetadata(file.getFileName().toString(), attrs.size(), attrs.lastModifiedTime().toMillis()));
                 }
             }
         }
@@ -191,6 +191,9 @@ public long readBlobPreferredLength() {
 
     @Override
     public void writeBlob(String blobName, InputStream inputStream, long blobSize, boolean failIfAlreadyExists) throws IOException {
+        if (Files.exists(path) == false) {
+            blobStore.recreateDirectories(path);
+        }
         final Path file = path.resolve(blobName);
         try {
             writeToPath(inputStream, file, blobSize);
@@ -207,6 +210,9 @@ public void writeBlob(String blobName, InputStream inputStream, long blobSize, b
     @Override
     public void writeBlobAtomic(final String blobName, final InputStream inputStream, final long blobSize, boolean failIfAlreadyExists)
         throws IOException {
+        if (Files.exists(path) == false) {
+            blobStore.recreateDirectories(path);
+        }
         final String tempBlob = tempBlobName(blobName);
         final Path tempBlobPath = path.resolve(tempBlob);
         try {
@@ -225,6 +231,9 @@ public void writeBlobAtomic(final String blobName, final InputStream inputStream
     }
 
     private void writeToPath(InputStream inputStream, Path tempBlobPath, long blobSize) throws IOException {
+        if (Files.exists(path) == false) {
+            blobStore.recreateDirectories(path);
+        }
         try (OutputStream outputStream = Files.newOutputStream(tempBlobPath, StandardOpenOption.CREATE_NEW)) {
             final int bufferSize = blobStore.bufferSizeInBytes();
             org.opensearch.common.util.io.Streams.copy(
diff --git a/server/src/main/java/org/opensearch/common/blobstore/fs/FsBlobStore.java b/server/src/main/java/org/opensearch/common/blobstore/fs/FsBlobStore.java
index 6944e01d8ee24..b3376ff16930b 100644
--- a/server/src/main/java/org/opensearch/common/blobstore/fs/FsBlobStore.java
+++ b/server/src/main/java/org/opensearch/common/blobstore/fs/FsBlobStore.java
@@ -76,6 +76,12 @@ public int bufferSizeInBytes() {
         return this.bufferSizeInBytes;
     }
 
+    public synchronized void recreateDirectories(Path path) throws IOException {
+        if (this.readOnly == false && Files.exists(path) == false) {
+            Files.createDirectories(path);
+        }
+    }
+
     @Override
     public BlobContainer blobContainer(BlobPath path) {
         try {
diff --git a/server/src/main/java/org/opensearch/common/blobstore/support/PlainBlobMetadata.java b/server/src/main/java/org/opensearch/common/blobstore/support/PlainBlobMetadata.java
index 8d2aee199ea61..69aaa6365c05b 100644
--- a/server/src/main/java/org/opensearch/common/blobstore/support/PlainBlobMetadata.java
+++ b/server/src/main/java/org/opensearch/common/blobstore/support/PlainBlobMetadata.java
@@ -45,9 +45,12 @@ public class PlainBlobMetadata implements BlobMetadata {
 
     private final long length;
 
-    public PlainBlobMetadata(String name, long length) {
+    private final long lastModified;
+
+    public PlainBlobMetadata(String name, long length, long lastModified) {
         this.name = name;
         this.length = length;
+        this.lastModified = lastModified;
     }
 
     @Override
@@ -60,6 +63,11 @@ public long length() {
         return this.length;
     }
 
+    @Override
+    public long lastModified() {
+        return this.lastModified;
+    }
+
     @Override
     public String toString() {
         return "name [" + name + "], length [" + length + "]";
diff --git a/server/src/main/java/org/opensearch/index/IndexService.java b/server/src/main/java/org/opensearch/index/IndexService.java
index f1b36194bf62d..0c9d238bd28cc 100644
--- a/server/src/main/java/org/opensearch/index/IndexService.java
+++ b/server/src/main/java/org/opensearch/index/IndexService.java
@@ -562,10 +562,10 @@ public synchronized IndexShard createShard(
         final RetentionLeaseSyncer retentionLeaseSyncer,
         final SegmentReplicationCheckpointPublisher checkpointPublisher,
         final RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory,
-        final RepositoriesService repositoriesService,
         final DiscoveryNode targetNode,
         @Nullable DiscoveryNode sourceNode,
-        DiscoveryNodes discoveryNodes
+        DiscoveryNodes discoveryNodes,
+        final ShardId parentShardId
     ) throws IOException {
         Objects.requireNonNull(retentionLeaseSyncer);
         /*
@@ -691,7 +691,8 @@ protected void closeInternal() {
                 recoverySettings,
                 remoteStoreSettings,
                 seedRemote,
-                discoveryNodes
+                discoveryNodes,
+                parentShardId
             );
             eventListener.indexShardStateChanged(indexShard, null, indexShard.state(), "shard created");
             eventListener.afterIndexShardCreated(indexShard);
@@ -801,7 +802,8 @@ private void closeShard(String reason, ShardId sId, IndexShard indexShard, Store
                 if (indexShard != null) {
                     try {
                         // only flush if we are closed (closed index or shutdown) and if we are not deleted
-                        final boolean flushEngine = deleted.get() == false && closed.get();
+                        final boolean flushEngine = deleted.get() == false && closed.get() &&
+                            indexShard.routingEntry().isSplitTarget() == false;
                         indexShard.close(reason, flushEngine, deleted.get());
                     } catch (Exception e) {
                         logger.debug(() -> new ParameterizedMessage("[{}] failed to close index shard", shardId), e);
diff --git a/server/src/main/java/org/opensearch/index/engine/InternalEngine.java b/server/src/main/java/org/opensearch/index/engine/InternalEngine.java
index 59165b936aec8..7f2086319d19c 100644
--- a/server/src/main/java/org/opensearch/index/engine/InternalEngine.java
+++ b/server/src/main/java/org/opensearch/index/engine/InternalEngine.java
@@ -197,6 +197,7 @@ public class InternalEngine extends Engine {
     private final AtomicBoolean trackTranslogLocation = new AtomicBoolean(false);
     private final KeyedLock<Long> noOpKeyedLock = new KeyedLock<>();
     private final AtomicBoolean shouldPeriodicallyFlushAfterBigMerge = new AtomicBoolean(false);
+    private final AtomicBoolean refreshesDelayed = new AtomicBoolean();
 
     /**
      * If multiple writes passed {@link InternalEngine#tryAcquireInFlightDocs(Operation, int)} but they haven't adjusted
@@ -372,6 +373,9 @@ private LocalCheckpointTracker createLocalCheckpointTracker(
         );
         maxSeqNo = seqNoStats.maxSeqNo;
         localCheckpoint = seqNoStats.localCheckpoint;
+        if (shardId.id() > 2) {
+            logger.info("Created local checkpoint tracker with local checkpoint: " + localCheckpoint + " on shard " + shardId.id());
+        }
         logger.trace("recovered maximum sequence number [{}] and local checkpoint [{}]", maxSeqNo, localCheckpoint);
         return localCheckpointTrackerSupplier.apply(maxSeqNo, localCheckpoint);
     }
@@ -915,9 +919,14 @@ public IndexResult index(Index index) throws IOException {
                     }
 
                     assert index.seqNo() >= 0 : "ops should have an assigned seq no.; origin: " + index.origin();
-
                     if (plan.indexIntoLucene || plan.addStaleOpToLucene) {
                         indexResult = indexIntoLucene(index, plan);
+//                        if (shardId.id() == 0 && index.origin() == Operation.Origin.PRIMARY) {
+//                            logger.info("Sending operation seq " + index.seqNo());
+//                        }
+//                        if (shardId.id() == 0 && index.origin() == Operation.Origin.PRIMARY) {
+//                            logger.info("Indexing operation seq " + index.seqNo() + " into lucene: " + plan.indexIntoLucene + " index result " + indexResult.getResultType());
+//                        }
                     } else {
                         indexResult = new IndexResult(
                             plan.versionForIndexing,
@@ -932,6 +941,9 @@ public IndexResult index(Index index) throws IOException {
                     final Translog.Location location;
                     if (indexResult.getResultType() == Result.Type.SUCCESS) {
                         location = translogManager.add(new Translog.Index(index, indexResult));
+//                        if (shardId.id() == 0 && index.origin() == Operation.Origin.PRIMARY) {
+//                            logger.info("Adding operation seq " + index.seqNo() + " to translog generation " + location.generation);
+//                        }
                     } else if (indexResult.getSeqNo() != SequenceNumbers.UNASSIGNED_SEQ_NO) {
                         // if we have document failure, record it as a no-op in the translog and Lucene with the generated seq_no
                         final NoOp noOp = new NoOp(
@@ -1754,6 +1766,9 @@ public boolean maybeRefresh(String source) throws EngineException {
     }
 
     final boolean refresh(String source, SearcherScope scope, boolean block) throws EngineException {
+        if (refreshesDelayed.get() == true) {
+            return false;
+        }
         // both refresh types will result in an internal refresh but only the external will also
         // pass the new reader reference to the external reader manager.
         final long localCheckpointBeforeRefresh = localCheckpointTracker.getProcessedCheckpoint();
diff --git a/server/src/main/java/org/opensearch/index/engine/NRTReplicationEngine.java b/server/src/main/java/org/opensearch/index/engine/NRTReplicationEngine.java
index d759423ce5a55..3bcf515431507 100644
--- a/server/src/main/java/org/opensearch/index/engine/NRTReplicationEngine.java
+++ b/server/src/main/java/org/opensearch/index/engine/NRTReplicationEngine.java
@@ -230,6 +230,7 @@ public boolean isThrottled() {
 
     @Override
     public IndexResult index(Index index) throws IOException {
+//        logger.info("Replication engine: Indexing operation " + index.seqNo() + " on shard " + shardId.id());
         ensureOpen();
         IndexResult indexResult = new IndexResult(index.version(), index.primaryTerm(), index.seqNo(), false);
         final Translog.Location location = translogManager.add(new Translog.Index(index, indexResult));
diff --git a/server/src/main/java/org/opensearch/index/seqno/GlobalCheckpointSyncAction.java b/server/src/main/java/org/opensearch/index/seqno/GlobalCheckpointSyncAction.java
index fedf239871368..8cfe5ba08ef16 100644
--- a/server/src/main/java/org/opensearch/index/seqno/GlobalCheckpointSyncAction.java
+++ b/server/src/main/java/org/opensearch/index/seqno/GlobalCheckpointSyncAction.java
@@ -35,6 +35,7 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.apache.lucene.store.AlreadyClosedException;
 import org.opensearch.ExceptionsHelper;
+import org.opensearch.action.PrimaryShardSplitException;
 import org.opensearch.action.support.ActionFilters;
 import org.opensearch.action.support.replication.ReplicationRequest;
 import org.opensearch.action.support.replication.ReplicationResponse;
@@ -101,7 +102,8 @@ public void updateGlobalCheckpointForShard(final ShardId shardId) {
         try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
             ThreadContextAccess.doPrivilegedVoid(threadContext::markAsSystemContext);
             execute(new Request(shardId), ActionListener.wrap(r -> {}, e -> {
-                if (ExceptionsHelper.unwrap(e, AlreadyClosedException.class, IndexShardClosedException.class) == null) {
+                if (ExceptionsHelper.unwrap(e, AlreadyClosedException.class, IndexShardClosedException.class,
+                    PrimaryShardSplitException.class) == null) {
                     logger.info(new ParameterizedMessage("{} global checkpoint sync failed", shardId), e);
                 }
             }));
diff --git a/server/src/main/java/org/opensearch/index/seqno/ReplicationTracker.java b/server/src/main/java/org/opensearch/index/seqno/ReplicationTracker.java
index 57ade7fa10cd0..2a72da889895e 100644
--- a/server/src/main/java/org/opensearch/index/seqno/ReplicationTracker.java
+++ b/server/src/main/java/org/opensearch/index/seqno/ReplicationTracker.java
@@ -136,7 +136,7 @@ public class ReplicationTracker extends AbstractIndexShardComponent implements L
 
     /**
      * Boolean flag that indicates if a relocation handoff is in progress. A handoff is started by calling
-     * {@link #startRelocationHandoff(String)} and is finished by either calling {@link #completeRelocationHandoff} or
+     * {@link #startRelocationHandoff(Set)}  and is finished by either calling {@link #completeRelocationHandoff} or
      * {@link #abortRelocationHandoff}, depending on whether the handoff was successful or not. During the handoff, which has as main
      * objective to transfer the internal state of the global checkpoint tracker from the relocation source to the target, the list of
      * in-sync shard copies cannot grow, otherwise the relocation target might miss this information and increase the global checkpoint
@@ -683,6 +683,12 @@ public synchronized void renewPeerRecoveryRetentionLeases() {
         assert invariant();
     }
 
+    public long getNewRetainedRetentionLeaseSeqNo(String shardAllocationId) {
+        assert checkpoints.containsKey(shardAllocationId) && primaryMode;
+        final CheckpointState checkpointState = checkpoints.get(shardAllocationId);
+        return Math.max(0L, checkpointState.globalCheckpoint + 1L);
+    }
+
     /**
     * The state of the lucene checkpoint
     *
@@ -905,7 +911,10 @@ private boolean invariant() {
         // when in primary mode, the current allocation ID is the allocation ID of the primary or the relocation allocation ID
         assert !primaryMode
             || (routingTable.primaryShard().allocationId().getId().equals(shardAllocationId)
-                || routingTable.primaryShard().allocationId().getRelocationId().equals(shardAllocationId));
+                || routingTable.primaryShard().allocationId().getRelocationId() != null &&
+            routingTable.primaryShard().allocationId().getRelocationId().equals(shardAllocationId) ||
+            routingTable.primaryShard().allocationId().getSplitChildAllocationIds() != null &&
+                routingTable.primaryShard().allocationId().getSplitChildAllocationIds().contains(shardAllocationId));
 
         // during relocation handoff there are no entries blocking global checkpoint advancement
         assert !handoffInProgress || pendingInSync.isEmpty() : "entries blocking global checkpoint advancement during relocation handoff: "
@@ -915,9 +924,9 @@ private boolean invariant() {
         assert pendingInSync.isEmpty() || (primaryMode && !handoffInProgress);
 
         // the computed global checkpoint is always up-to-date
-        assert !primaryMode || globalCheckpoint == computeGlobalCheckpoint(pendingInSync, checkpoints.values(), globalCheckpoint)
+        assert !primaryMode || globalCheckpoint == computeGlobalCheckpoint(pendingInSync, checkpoints, globalCheckpoint)
             : "global checkpoint is not up-to-date, expected: "
-                + computeGlobalCheckpoint(pendingInSync, checkpoints.values(), globalCheckpoint)
+                + computeGlobalCheckpoint(pendingInSync, checkpoints, globalCheckpoint)
                 + " but was: "
                 + globalCheckpoint;
 
@@ -972,7 +981,7 @@ private boolean invariant() {
             // all tracked shard copies have a corresponding peer-recovery retention lease
             for (final ShardRouting shardRouting : routingTable.assignedShards()) {
                 final CheckpointState cps = checkpoints.get(shardRouting.allocationId().getId());
-                if (cps.tracked && cps.replicated) {
+                if (cps.tracked && cps.replicated && shardRouting.getParentShardId() == null) {
                     assert retentionLeases.contains(getPeerRecoveryRetentionLeaseId(shardRouting))
                         : "no retention lease for tracked shard [" + shardRouting + "] in " + retentionLeases;
                     assert PEER_RECOVERY_RETENTION_LEASE_SOURCE.equals(
@@ -1254,6 +1263,13 @@ public ReplicationCheckpoint getLatestReplicationCheckpoint() {
 
     // skip any shard that is a relocating primary or search only replica (not tracked by primary)
     private boolean shouldSkipReplicationTimer(String allocationId) {
+        if (routingTable.primaryShard().splitting()) {
+            for (ShardRouting child : routingTable.primaryShard().getRecoveringChildShards()) {
+                if (child.allocationId().getId().equals(allocationId)) {
+                    return true;
+                }
+            }
+        }
         Optional<ShardRouting> shardRouting = routingTable.shards()
             .stream()
             .filter(routing -> routing.allocationId().getId().equals(allocationId))
@@ -1474,6 +1490,12 @@ public synchronized void updateFromClusterManager(
             final String primaryTargetAllocationId = primary.relocating()
                 ? primary.getTargetRelocatingShard().allocationId().getId()
                 : null;
+            final Set<String> primaryTargetSplitShardsAllocIds = new HashSet<>();
+            if (primary.splitting()) {
+                for (ShardRouting childShard : primary.getRecoveringChildShards()) {
+                    primaryTargetSplitShardsAllocIds.add(childShard.allocationId().getId());
+                }
+            }
 
             if (primaryMode) {
                 // add new initializingIds that are missing locally. These are fresh shard copies - and not in-sync
@@ -1496,7 +1518,8 @@ public synchronized void updateFromClusterManager(
                                     initializingId,
                                     primaryAllocationId,
                                     primaryTargetAllocationId,
-                                    assignedToRemoteStoreNode(routingTable, initializingId)
+                                    assignedToRemoteStoreNode(routingTable, initializingId),
+                                    primaryTargetSplitShardsAllocIds
                                 )
                             )
                         );
@@ -1520,7 +1543,8 @@ public synchronized void updateFromClusterManager(
                                 initializingId,
                                 primaryAllocationId,
                                 primaryTargetAllocationId,
-                                assignedToRemoteStoreNode(routingTable, initializingId)
+                                assignedToRemoteStoreNode(routingTable, initializingId),
+                                primaryTargetSplitShardsAllocIds
                             )
                         )
                     );
@@ -1539,7 +1563,8 @@ public synchronized void updateFromClusterManager(
                                 inSyncId,
                                 primaryAllocationId,
                                 primaryTargetAllocationId,
-                                assignedToRemoteStoreNode(routingTable, inSyncId)
+                                assignedToRemoteStoreNode(routingTable, inSyncId),
+                                primaryTargetSplitShardsAllocIds
                             )
                         )
                     );
@@ -1575,12 +1600,14 @@ private boolean isReplicated(
         String allocationId,
         String primaryAllocationId,
         String primaryTargetAllocationId,
-        boolean assignedToRemoteStoreNode
+        boolean assignedToRemoteStoreNode,
+        Set<String> primaryTargetSplitShardsAllocIds
     ) {
         // If assigned to a remote node, returns true if given allocation id matches the primary or it's relocation target allocation
         // primary and primary target allocation id.
         if (assignedToRemoteStoreNode == true) {
-            return allocationId.equals(primaryAllocationId) || allocationId.equals(primaryTargetAllocationId);
+            return (allocationId.equals(primaryAllocationId) || allocationId.equals(primaryTargetAllocationId) ||
+                primaryTargetSplitShardsAllocIds.contains(allocationId));
         }
         // For other case which is local translog, return true as the requests are replicated to all shards in the replication group.
         return true;
@@ -1622,6 +1649,28 @@ public synchronized void initiateTracking(final String allocationId) {
         assert invariant();
     }
 
+    /**
+     * Called when the recovery process for a shard has opened the engine on target child shards. Ensures that the right data structures
+     * have been set up locally to track local checkpoint information for the shards and that the shards are added to the replication group.
+     *
+     * @param allocationIds  the allocation IDs of child shards for which recovery was initiated
+     */
+    public synchronized void initiateTrackingOfChildShards(final List<String> allocationIds) {
+        assert invariant();
+        assert primaryMode;
+        assert handoffInProgress == false;
+        allocationIds.forEach(allocationId -> {
+            CheckpointState cps = checkpoints.get(allocationId);
+            if (cps == null) {
+                // can happen if replica was removed from cluster but recovery process is unaware of it yet
+                throw new IllegalStateException("no local checkpoint tracking information available");
+            }
+            cps.tracked = true;
+        });
+        updateReplicationGroupAndNotify();
+        assert invariant();
+    }
+
     /**
      * Marks the shard with the provided allocation ID as in-sync with the primary shard. This method will block until the local checkpoint
      * on the specified shard advances above the current global checkpoint.
@@ -1655,12 +1704,14 @@ public synchronized void markAllocationIdAsInSync(final String allocationId, fin
             + getGlobalCheckpoint()
             + " or it's not replicated";
         if (cps.replicated && cps.localCheckpoint < getGlobalCheckpoint()) {
+            logger.info("Waiting for sync as local checkpoint " + cps.localCheckpoint + " is less than global checkpoint " + getGlobalCheckpoint());
             pendingInSync.add(allocationId);
             try {
                 while (true) {
                     if (pendingInSync.contains(allocationId)) {
                         waitForLocalCheckpointToAdvance();
                     } else {
+                        logger.info("Wait over for sync as local checkpoint " + cps.localCheckpoint + " is less than global checkpoint " + getGlobalCheckpoint());
                         break;
                     }
                 }
@@ -1685,7 +1736,6 @@ private boolean updateLocalCheckpoint(String allocationId, CheckpointState cps,
             + allocationId
             + "]";
         if (localCheckpoint > cps.localCheckpoint) {
-            logger.trace("updated local checkpoint of [{}] from [{}] to [{}]", allocationId, cps.localCheckpoint, localCheckpoint);
             cps.localCheckpoint = localCheckpoint;
             return true;
         } else {
@@ -1737,14 +1787,15 @@ public synchronized void updateLocalCheckpoint(final String allocationId, final
      */
     private static long computeGlobalCheckpoint(
         final Set<String> pendingInSync,
-        final Collection<CheckpointState> localCheckpoints,
+        final Map<String, CheckpointState> localCheckpoints,
         final long fallback
     ) {
         long minLocalCheckpoint = Long.MAX_VALUE;
         if (pendingInSync.isEmpty() == false) {
             return fallback;
         }
-        for (final CheckpointState cps : localCheckpoints) {
+        for (final String allocationId : localCheckpoints.keySet()) {
+            final CheckpointState cps = localCheckpoints.get(allocationId);
             if (cps.inSync && cps.replicated) {
                 if (cps.localCheckpoint == SequenceNumbers.UNASSIGNED_SEQ_NO) {
                     // unassigned in-sync replica
@@ -1763,7 +1814,7 @@ private static long computeGlobalCheckpoint(
      */
     private synchronized void updateGlobalCheckpointOnPrimary() {
         assert primaryMode;
-        final long computedGlobalCheckpoint = computeGlobalCheckpoint(pendingInSync, checkpoints.values(), getGlobalCheckpoint());
+        final long computedGlobalCheckpoint = computeGlobalCheckpoint(pendingInSync, checkpoints, getGlobalCheckpoint());
         assert computedGlobalCheckpoint >= globalCheckpoint : "new global checkpoint ["
             + computedGlobalCheckpoint
             + "] is lower than previous one ["
@@ -1779,15 +1830,19 @@ private synchronized void updateGlobalCheckpointOnPrimary() {
     /**
      * Initiates a relocation handoff and returns the corresponding primary context.
      */
-    public synchronized PrimaryContext startRelocationHandoff(String targetAllocationId) {
+    public synchronized PrimaryContext startRelocationHandoff(Set<String> targetAllocationIds) {
         assert invariant();
         assert primaryMode;
         assert handoffInProgress == false;
         assert pendingInSync.isEmpty() : "relocation handoff started while there are still shard copies pending in-sync: " + pendingInSync;
-        if (checkpoints.containsKey(targetAllocationId) == false) {
-            // can happen if the relocation target was removed from cluster but the recovery process isn't aware of that.
-            throw new IllegalStateException("relocation target [" + targetAllocationId + "] is no longer part of the replication group");
-        }
+
+        targetAllocationIds.forEach(targetAllocationId -> {
+            if (checkpoints.containsKey(targetAllocationId) == false) {
+                // can happen if the relocation target was removed from cluster but the recovery process isn't aware of that.
+                throw new IllegalStateException("relocation target [" + targetAllocationId + "] is no longer part of the replication group");
+            }
+        });
+
         handoffInProgress = true;
         // copy clusterStateVersion and checkpoints and return
         // all the entries from checkpoints that are inSync: the reason we don't need to care about initializing non-insync entries
@@ -1847,14 +1902,51 @@ public synchronized void activateWithPrimaryContext(PrimaryContext primaryContex
             throw new IllegalStateException("primary context [" + primaryContext + "] does not contain " + shardAllocationId);
         }
         final Runnable runAfter = getClusterManagerUpdateOperationFromCurrentState();
+        logger.info("Activating with primary context");
         primaryMode = true;
         // capture current state to possibly replay missed cluster state update
         appliedClusterStateVersion = primaryContext.clusterStateVersion();
         checkpoints.clear();
+        // During relocation handoff, we get parent routing table here and therefore, we need to exclude
+        // other child shards from being added to replication group.
+        IndexShardRoutingTable contextRoutingTable = primaryContext.getRoutingTable();
+        Set<String> childShardAllocations = new HashSet<>();
+        IndexShardRoutingTable.Builder childRoutingTable = null;
+        boolean childShardActivation = false;
+        if (contextRoutingTable.primaryShard().splitting()) {
+            ShardRouting[] allChildShardRoutings = contextRoutingTable.primaryShard().getRecoveringChildShards();
+            for (ShardRouting childRouting : allChildShardRoutings) {
+                if (childRouting.primary()) {
+                    childRouting = childRouting.moveToStarted();
+                }
+                if (childRouting.shardId().equals(shardId)) {
+                    if (childRoutingTable == null) {
+                         childRoutingTable = new IndexShardRoutingTable.Builder(shardId);
+                    }
+                    childShardAllocations.add(childRouting.allocationId().getId());
+                    childRoutingTable.addShard(childRouting);
+                }
+                if (shardAllocationId.equals(childRouting.allocationId().getId())) {
+                    childShardActivation = true;
+                }
+            }
+        }
+
+        if (childShardActivation == false) {
+            routingTable = primaryContext.getRoutingTable();
+        } else {
+            assert childRoutingTable != null;
+            routingTable = childRoutingTable.build();
+        }
+
         for (Map.Entry<String, CheckpointState> entry : primaryContext.checkpoints.entrySet()) {
-            checkpoints.put(entry.getKey(), entry.getValue().copy());
+            if (childShardActivation == false) {
+                checkpoints.put(entry.getKey(), entry.getValue().copy());
+            } else if (childShardAllocations.contains(entry.getKey())) {
+                checkpoints.put(entry.getKey(), entry.getValue().copy());
+            }
         }
-        routingTable = primaryContext.getRoutingTable();
+
         updateReplicationGroupAndNotify();
         updateGlobalCheckpointOnPrimary();
         // reapply missed cluster state update
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseActions.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseActions.java
index db8b06489f2ae..bdea68a490ff6 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseActions.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseActions.java
@@ -114,9 +114,15 @@ protected void asyncShardOperation(T request, ShardId shardId, final ActionListe
             final IndexService indexService = indicesService.indexServiceSafe(shardId.getIndex());
             final IndexShard indexShard = indexService.getShard(shardId.id());
             indexShard.acquirePrimaryOperationPermit(ActionListener.delegateFailure(listener, (delegatedListener, releasable) -> {
+                if (indexShard.shardId().id() == 0) {
+                    logger.info("Acquired permit for retention lease");
+                }
                 try (Releasable ignore = releasable) {
                     doRetentionLeaseAction(indexShard, request, delegatedListener);
                 }
+                if (indexShard.shardId().id() == 0) {
+                    logger.info("Released permit for retention lease");
+                }
             }), ThreadPool.Names.SAME, request);
         }
 
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java
index e8ebf11ef0e5c..94984eb9c09ee 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java
@@ -37,6 +37,7 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.apache.lucene.store.AlreadyClosedException;
 import org.opensearch.ExceptionsHelper;
+import org.opensearch.action.PrimaryShardSplitException;
 import org.opensearch.action.support.ActionFilters;
 import org.opensearch.action.support.ActiveShardCount;
 import org.opensearch.action.support.replication.ReplicationRequest;
@@ -161,7 +162,8 @@ public void handleException(TransportException e) {
                             e,
                             IndexNotFoundException.class,
                             AlreadyClosedException.class,
-                            IndexShardClosedException.class
+                            IndexShardClosedException.class,
+                            PrimaryShardSplitException.class
                         ) != null) {
                             // the index was deleted or the shard is closed
                             return;
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java
index 9e8437ca78879..a53e3d97f7d16 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java
@@ -37,6 +37,7 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.apache.lucene.store.AlreadyClosedException;
 import org.opensearch.ExceptionsHelper;
+import org.opensearch.action.PrimaryShardSplitException;
 import org.opensearch.action.support.ActionFilters;
 import org.opensearch.action.support.ActiveShardCount;
 import org.opensearch.action.support.WriteResponse;
@@ -171,7 +172,8 @@ public void handleException(TransportException e) {
                             e,
                             IndexNotFoundException.class,
                             AlreadyClosedException.class,
-                            IndexShardClosedException.class
+                            IndexShardClosedException.class,
+                            PrimaryShardSplitException.class
                         ) == null) {
                             getLogger().warn(new ParameterizedMessage("{} retention lease sync failed", shardId), e);
                         }
diff --git a/server/src/main/java/org/opensearch/index/shard/AbstractIndexShardComponent.java b/server/src/main/java/org/opensearch/index/shard/AbstractIndexShardComponent.java
index 5e973ff9acb8f..cd40a8ebcd3da 100644
--- a/server/src/main/java/org/opensearch/index/shard/AbstractIndexShardComponent.java
+++ b/server/src/main/java/org/opensearch/index/shard/AbstractIndexShardComponent.java
@@ -37,6 +37,9 @@
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.IndexSettings;
 
+import java.util.Collections;
+import java.util.List;
+
 /**
  * Base index shard class
  *
@@ -63,4 +66,8 @@ public ShardId shardId() {
     public IndexSettings indexSettings() {
         return indexSettings;
     }
+
+    public ShardId getParentShardId() {
+        return null;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/index/shard/IndexShard.java b/server/src/main/java/org/opensearch/index/shard/IndexShard.java
index 02f20504b07ba..115c49f5fe3a8 100644
--- a/server/src/main/java/org/opensearch/index/shard/IndexShard.java
+++ b/server/src/main/java/org/opensearch/index/shard/IndexShard.java
@@ -59,9 +59,11 @@
 import org.opensearch.ExceptionsHelper;
 import org.opensearch.OpenSearchException;
 import org.opensearch.action.ActionRunnable;
+import org.opensearch.action.PrimaryShardSplitException;
 import org.opensearch.action.admin.indices.flush.FlushRequest;
 import org.opensearch.action.admin.indices.forcemerge.ForceMergeRequest;
 import org.opensearch.action.admin.indices.upgrade.post.UpgradeRequest;
+import org.opensearch.action.bulk.TransportShardBulkAction;
 import org.opensearch.action.support.replication.PendingReplicationActions;
 import org.opensearch.action.support.replication.ReplicationResponse;
 import org.opensearch.cluster.metadata.DataStream;
@@ -70,6 +72,7 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.routing.IndexShardRoutingTable;
+import org.opensearch.cluster.routing.OperationRouting;
 import org.opensearch.cluster.routing.RecoverySource;
 import org.opensearch.cluster.routing.RecoverySource.SnapshotRecoverySource;
 import org.opensearch.cluster.routing.ShardRouting;
@@ -361,6 +364,7 @@ Runnable getGlobalCheckpointSyncer() {
      */
     private final ShardMigrationState shardMigrationState;
     private DiscoveryNodes discoveryNodes;
+    private final ShardId parentShardId;
 
     public IndexShard(
         final ShardRouting shardRouting,
@@ -391,7 +395,8 @@ public IndexShard(
         final RecoverySettings recoverySettings,
         final RemoteStoreSettings remoteStoreSettings,
         boolean seedRemote,
-        final DiscoveryNodes discoveryNodes
+        final DiscoveryNodes discoveryNodes,
+        final ShardId parentShardId
     ) throws IOException {
         super(shardRouting.shardId(), indexSettings);
         assert shardRouting.initializing();
@@ -439,7 +444,12 @@ public IndexShard(
         this.checkIndexOnStartup = indexSettings.getValue(IndexSettings.INDEX_CHECK_ON_STARTUP);
         this.translogConfig = new TranslogConfig(shardId, shardPath().resolveTranslog(), indexSettings, bigArrays, nodeId, seedRemote);
         final String aId = shardRouting.allocationId().getId();
-        final long primaryTerm = indexSettings.getIndexMetadata().primaryTerm(shardId.id());
+        final long primaryTerm;
+        if (shardRouting.isSplitTarget()) {
+            primaryTerm = indexSettings.getIndexMetadata().primaryTerm(shardRouting.getParentShardId().id());
+        } else {
+            primaryTerm = indexSettings.getIndexMetadata().primaryTerm(shardId.id());
+        }
         this.pendingPrimaryTerm = primaryTerm;
         this.globalCheckpointListeners = new GlobalCheckpointListeners(shardId, threadPool.scheduler(), logger);
         this.pendingReplicationActions = new PendingReplicationActions(shardId, threadPool);
@@ -493,6 +503,7 @@ public boolean shouldCache(Query query) {
         this.fileDownloader = new RemoteStoreFileDownloader(shardRouting.shardId(), threadPool, recoverySettings);
         this.shardMigrationState = getShardMigrationState(indexSettings, seedRemote);
         this.discoveryNodes = discoveryNodes;
+        this.parentShardId = parentShardId;
     }
 
     public ThreadPool getThreadPool() {
@@ -628,6 +639,11 @@ public RemoteStoreSettings getRemoteStoreSettings() {
         return remoteStoreSettings;
     }
 
+    @Override
+    public ShardId getParentShardId() {
+        return parentShardId;
+    }
+
     public RemoteStoreFileDownloader getFileDownloader() {
         return fileDownloader;
     }
@@ -673,10 +689,10 @@ public void updateShardState(
 
             if (state == IndexShardState.POST_RECOVERY && newRouting.active()) {
                 assert currentRouting.active() == false : "we are in POST_RECOVERY, but our shard routing is active " + currentRouting;
-                assert currentRouting.isRelocationTarget() == false
+                assert currentRouting.isRelocationTarget() == false && currentRouting.isSplitTarget() == false
                     || currentRouting.primary() == false
                     || replicationTracker.isPrimaryMode()
-                    : "a primary relocation is completed by the cluster-managerr, but primary mode is not active " + currentRouting;
+                    : "a primary relocation/split is completed by the cluster-managerr, but primary mode is not active " + currentRouting;
 
                 changeState(IndexShardState.STARTED, "global state is [" + newRouting.state() + "]");
 
@@ -696,7 +712,16 @@ public void updateShardState(
                         shardId(),
                         "Shard is marked as relocated, cannot safely move to state " + newRouting.state()
                     );
-                }
+                } else if (currentRouting.primary()
+                    && currentRouting.splitting()
+                    && replicationTracker.isRelocated()
+                    && (newRouting.splitting() == false || newRouting.equalsIgnoringMetadata(currentRouting) == false)) {
+
+                        throw new IndexShardRelocatedException(
+                            shardId(),
+                            "Shard is marked as split, cannot safely move to state " + newRouting.state()
+                        );
+                    }
             assert newRouting.active() == false || state == IndexShardState.STARTED || state == IndexShardState.CLOSED
                 : "routing is active, but local shard state isn't. routing: " + newRouting + ", local state: " + state;
             persistMetadata(path, indexSettings, newRouting, currentRouting, logger);
@@ -704,7 +729,10 @@ public void updateShardState(
 
             if (newRouting.primary()) {
                 if (newPrimaryTerm == pendingPrimaryTerm) {
-                    if (currentRouting.initializing() && currentRouting.isRelocationTarget() == false && newRouting.active()) {
+                    if (currentRouting.initializing()
+                        && currentRouting.isRelocationTarget() == false
+                        && currentRouting.isSplitTarget() == false
+                        && newRouting.active()) {
                         // the cluster-manager started a recovering primary, activate primary mode.
                         replicationTracker.activatePrimaryMode(getLocalCheckpoint());
                         postActivatePrimaryMode();
@@ -866,6 +894,16 @@ public void onFailure(Exception e) {
         }
     }
 
+    public List<Releasable> delayStaleCommitDeletions() {
+        List<Releasable> releasables = new ArrayList<>();
+        for (ReferenceManager.RefreshListener refreshListener : internalRefreshListener) {
+            if (refreshListener instanceof RemoteStoreRefreshListener) {
+                releasables.add(((RemoteStoreRefreshListener) refreshListener).delayStaleCommitDeletion());
+            }
+        }
+        return releasables;
+    }
+
     /**
      * Marks the shard as recovering based on a recovery state, fails with exception is recovering is not allowed to be set.
      */
@@ -903,7 +941,7 @@ public IndexShardState markAsRecovering(String reason, RecoveryState recoverySta
      * @throws InterruptedException            if blocking operations is interrupted
      */
     public void relocated(
-        final String targetAllocationId,
+        final Set<String> targetAllocationIds,
         final Consumer<ReplicationTracker.PrimaryContext> consumer,
         final Runnable performSegRep
     ) throws IllegalIndexShardStateException, IllegalStateException, InterruptedException {
@@ -912,6 +950,7 @@ public void relocated(
         // acquire all permits. This will ensure that the remote store uploads can still be done by the existing primary shard.
         List<Releasable> releasablesOnHandoffFailures = new ArrayList<>(2);
         try (Releasable forceRefreshes = refreshListeners.forceRefreshes()) {
+            TransportShardBulkAction.debugRequest.set(true);
             indexShardOperationPermits.blockOperations(30, TimeUnit.MINUTES, () -> {
                 forceRefreshes.close();
 
@@ -924,28 +963,30 @@ public void relocated(
                     maybeSync();
                 }
 
-                // Ensures all in-flight remote store refreshes drain, before we perform the performSegRep.
-                for (ReferenceManager.RefreshListener refreshListener : internalRefreshListener) {
-                    if (refreshListener instanceof ReleasableRetryableRefreshListener) {
-                        releasablesOnHandoffFailures.add(((ReleasableRetryableRefreshListener) refreshListener).drainRefreshes());
+                if (shardRouting.splitting() == false) {
+                    // Ensures all in-flight remote store refreshes drain, before we perform the performSegRep.
+                    for (ReferenceManager.RefreshListener refreshListener : internalRefreshListener) {
+                        if (refreshListener instanceof ReleasableRetryableRefreshListener) {
+                            releasablesOnHandoffFailures.add(((ReleasableRetryableRefreshListener) refreshListener).drainRefreshes());
+                        }
                     }
-                }
 
-                // Ensure all in-flight remote store translog upload drains, before we perform the performSegRep.
-                releasablesOnHandoffFailures.add(getEngine().translogManager().drainSync());
+                    // Ensure all in-flight remote store translog upload drains, before we perform the performSegRep.
+                    releasablesOnHandoffFailures.add(getEngine().translogManager().drainSync());
 
-                // no shard operation permits are being held here, move state from started to relocated
-                assert indexShardOperationPermits.getActiveOperationsCount() == OPERATIONS_BLOCKED
-                    : "in-flight operations in progress while moving shard state to relocated";
+                    // no shard operation permits are being held here, move state from started to relocated
+                    assert indexShardOperationPermits.getActiveOperationsCount() == OPERATIONS_BLOCKED
+                        : "in-flight operations in progress while moving shard state to relocated";
 
-                performSegRep.run();
+                    performSegRep.run();
+                }
 
                 /*
                  * We should not invoke the runnable under the mutex as the expected implementation is to handoff the primary context via a
                  * network operation. Doing this under the mutex can implicitly block the cluster state update thread on network operations.
                  */
                 verifyRelocatingState();
-                final ReplicationTracker.PrimaryContext primaryContext = replicationTracker.startRelocationHandoff(targetAllocationId);
+                final ReplicationTracker.PrimaryContext primaryContext = replicationTracker.startRelocationHandoff(targetAllocationIds);
                 try {
                     consumer.accept(primaryContext);
                     synchronized (mutex) {
@@ -998,7 +1039,7 @@ private void verifyRelocatingState() {
          * says otherwise.
          */
 
-        if (shardRouting.relocating() == false) {
+        if (shardRouting.relocating() == false && shardRouting.splitting() == false) {
             throw new IllegalIndexShardStateException(shardId, IndexShardState.STARTED, ": shard is no longer relocating " + shardRouting);
         }
 
@@ -1125,6 +1166,7 @@ private Engine.IndexResult applyIndexOperation(
         ensureWriteAllowed(origin);
         Engine.Index operation;
         try {
+
             operation = prepareIndex(
                 docMapper(),
                 sourceToParse,
@@ -1664,26 +1706,26 @@ public GatedCloseable<IndexCommit> acquireLastIndexCommitAndRefresh(boolean flus
 
     /**
      *
-     * @param snapshotId Snapshot UUID.
+     * @param acquirerId  Lock Acquirer ID which wants to acquire lock on the commit.
      * @param primaryTerm current primary term.
      * @param generation Snapshot Commit Generation.
      * @throws IOException if there is some failure in acquiring lock in remote store.
      */
-    public void acquireLockOnCommitData(String snapshotId, long primaryTerm, long generation) throws IOException {
+    public void acquireLockOnCommitData(String acquirerId, long primaryTerm, long generation) throws IOException {
         RemoteSegmentStoreDirectory remoteSegmentStoreDirectory = getRemoteDirectory();
-        remoteSegmentStoreDirectory.acquireLock(primaryTerm, generation, snapshotId);
+        remoteSegmentStoreDirectory.acquireLock(primaryTerm, generation, acquirerId);
     }
 
     /**
      *
-     * @param snapshotId Snapshot UUID.
+     * @param acquirerId  Lock Acquirer ID which wants to acquire lock on the commit.
      * @param primaryTerm current primary term.
      * @param generation Snapshot Commit Generation.
      * @throws IOException if there is some failure in releasing lock in remote store.
      */
-    public void releaseLockOnCommitData(String snapshotId, long primaryTerm, long generation) throws IOException {
+    public void releaseLockOnCommitData(String acquirerId, long primaryTerm, long generation) throws IOException {
         RemoteSegmentStoreDirectory remoteSegmentStoreDirectory = getRemoteDirectory();
-        remoteSegmentStoreDirectory.releaseLock(primaryTerm, generation, snapshotId);
+        remoteSegmentStoreDirectory.releaseLock(primaryTerm, generation, acquirerId);
     }
 
     public Optional<NRTReplicationEngine> getReplicationEngine() {
@@ -1707,7 +1749,8 @@ public void finalizeReplication(SegmentInfos infos) throws IOException {
     public GatedCloseable<IndexCommit> acquireSafeIndexCommit() throws EngineException {
         final IndexShardState state = this.state; // one time volatile read
         // we allow snapshot on closed index shard, since we want to do one after we close the shard and before we close the engine
-        if (state == IndexShardState.STARTED || state == IndexShardState.CLOSED) {
+        // We already asserted earlier that source child shard is in synced state for us to be able to acquire a commit.
+        if (state == IndexShardState.STARTED || state == IndexShardState.CLOSED || routingEntry().isSplitTarget()) {
             return getEngine().acquireSafeIndexCommit();
         } else {
             throw new IllegalIndexShardStateException(shardId, state, "snapshot is not allowed");
@@ -1766,7 +1809,21 @@ public Tuple<GatedCloseable<SegmentInfos>, ReplicationCheckpoint> getLatestSegme
      * @return {@link ReplicationCheckpoint} Checkpoint computed from the infos.
      * @throws IOException When there is an error computing segment metadata from the store.
      */
-    ReplicationCheckpoint computeReplicationCheckpoint(SegmentInfos segmentInfos) throws IOException {
+    public ReplicationCheckpoint computeReplicationCheckpoint(SegmentInfos segmentInfos) throws IOException {
+        return computeReplicationCheckpoint(segmentInfos, this);
+    }
+
+    /**
+     * Compute the latest {@link ReplicationCheckpoint} from a SegmentInfos.
+     * This function fetches a metadata snapshot from the store that comes with an IO cost.
+     * We will reuse the existing stored checkpoint if it is at the same SI version.
+     *
+     * @param segmentInfos {@link SegmentInfos} infos to use to compute.
+     * @param codecSource Source shard's engine from which codec should be used.
+     * @return {@link ReplicationCheckpoint} Checkpoint computed from the infos.
+     * @throws IOException When there is an error computing segment metadata from the store.
+     */
+    public ReplicationCheckpoint computeReplicationCheckpoint(SegmentInfos segmentInfos, IndexShard codecSource) throws IOException {
         if (segmentInfos == null) {
             return ReplicationCheckpoint.empty(shardId);
         }
@@ -1783,7 +1840,7 @@ ReplicationCheckpoint computeReplicationCheckpoint(SegmentInfos segmentInfos) th
             segmentInfos.getGeneration(),
             segmentInfos.getVersion(),
             metadataMap.values().stream().mapToLong(StoreFileMetadata::length).sum(),
-            getEngine().config().getCodec().getName(),
+            codecSource.getEngine().config().getCodec().getName(),
             metadataMap
         );
         logger.trace("Recomputed ReplicationCheckpoint for shard {}", checkpoint);
@@ -2087,6 +2144,11 @@ public void close(String reason, boolean flushEngine, boolean deleted) throws IO
         }
     }
 
+    public void cleanUpRemoteDirectories() throws IOException {
+        RemoteSegmentStoreDirectory remoteDirectory = getRemoteDirectory();
+        remoteDirectory.cleanUpRemoteDirectories();
+    }
+
     /*
     ToDo : Fix this https://github.com/opensearch-project/OpenSearch/issues/8003
      */
@@ -2180,6 +2242,14 @@ public void waitForRemoteStoreSync(Runnable onProgress) throws IOException {
         );
     }
 
+    public Tuple<String, RemoteSegmentMetadata> getMetadataContentForCommit(long primaryTerm, long generation) throws IOException{
+        RemoteSegmentStoreDirectory directory = getRemoteDirectory();
+        String metadataFileName = directory.getMetadataFileForCommit(primaryTerm, generation);
+        RemoteSegmentMetadata metadata = directory.readMetadataFile(metadataFileName);
+        return new Tuple<>(metadataFileName, metadata);
+    }
+
+
     public void preRecovery() {
         final IndexShardState currentState = this.state; // single volatile read
         if (currentState == IndexShardState.CLOSED) {
@@ -2394,6 +2464,7 @@ private Engine.Result applyTranslogOperation(Engine engine, Translog.Operation o
         // If a translog op is replayed on the primary (eg. ccr), we need to use external instead of null for its version type.
         final VersionType versionType = (origin == Engine.Operation.Origin.PRIMARY) ? VersionType.EXTERNAL : null;
         final Engine.Result result;
+        operation = overrideToNoOpIfOperationNotForShard(operation);
         switch (operation.opType()) {
             case INDEX:
                 final Translog.Index index = (Translog.Index) operation;
@@ -2441,9 +2512,37 @@ private Engine.Result applyTranslogOperation(Engine engine, Translog.Operation o
             default:
                 throw new IllegalStateException("No operation defined for [" + operation + "]");
         }
+        if (shardRouting.isSplitTarget() && shardRouting.primary()) {
+//            logger.info("Applied seq no. " + operation.seqNo() + " on child shard replica " + shardId.id()
+//                + ". Local checkpoint now " + getLocalCheckpoint());
+        }
         return result;
     }
 
+    /**
+     * Compute cost of figuring out a child shard ID for a child shard would depend on the depth of routing
+     * i.e., how many times root shard was split to produce this child shard. This cost is minimal
+     * and we also don't have it in regular indexing path when shard is in started state. This is because
+     * translog recoveries today only happen in case of shard recoveries or during primary term bump.
+     * Also, keeping it here ensures that any new translog based recoveries on child shards in future
+     * honour this filtering.
+     */
+    private Translog.Operation overrideToNoOpIfOperationNotForShard(Translog.Operation operation) {
+        if (getParentShardId() == null || operation.opType() != Translog.Operation.Type.INDEX) {
+            // It is ok to send delete and no-op operations to all child shards.
+            return operation;
+        }
+
+        final Translog.Index index = (Translog.Index) operation;
+        int computedShardId = OperationRouting.generateShardId(indexSettings().getIndexMetadata(),
+            index.id(), index.routing(), true);
+        if (computedShardId != shardId().id()) {
+            return new Translog.NoOp(index.seqNo(), index.primaryTerm(), Translog.NoOp.FILLING_GAPS);
+        }
+
+        return operation;
+    }
+
     /**
      * Replays translog operations from the provided translog {@code snapshot} to the current engine using the given {@code origin}.
      * The callback {@code onOperationRecovered} is notified after each translog operation is replayed successfully.
@@ -2539,8 +2638,10 @@ public void openEngineAndRecoverFromTranslog(boolean syncFromRemote) throws IOEx
      * The translog is kept but its operations won't be replayed.
      */
     public void openEngineAndSkipTranslogRecovery() throws IOException {
-        assert routingEntry().recoverySource().getType() == RecoverySource.Type.PEER : "not a peer recovery [" + routingEntry() + "]";
-        openEngineAndSkipTranslogRecovery(true);
+        assert routingEntry().recoverySource().getType() == RecoverySource.Type.PEER ||
+            routingEntry().recoverySource().getType() == RecoverySource.Type.IN_PLACE_SHARD_SPLIT :
+            "not a peer recovery [" + routingEntry() + "]";
+        openEngineAndSkipTranslogRecovery(routingEntry().isSplitTarget() == false);
     }
 
     public void openEngineAndSkipTranslogRecoveryFromSnapshot() throws IOException {
@@ -2689,7 +2790,9 @@ public void performRecoveryRestart() throws IOException {
      * If a file-based recovery occurs, a recovery target calls this method to reset the recovery stage.
      */
     public void resetRecoveryStage() {
-        assert routingEntry().recoverySource().getType() == RecoverySource.Type.PEER : "not a peer recovery [" + routingEntry() + "]";
+        assert routingEntry().recoverySource().getType() == RecoverySource.Type.PEER ||
+            routingEntry().recoverySource().getType() == RecoverySource.Type.IN_PLACE_SHARD_SPLIT
+            : "not a peer recovery [" + routingEntry() + "]";
         assert currentEngineReference.get() == null;
         if (state != IndexShardState.RECOVERING) {
             throw new IndexShardNotRecoveringException(shardId, state);
@@ -3056,16 +3159,17 @@ public Translog.Snapshot getHistoryOperations(String reason, long startingSeqNo,
     }
 
     /**
-     * Creates a new history snapshot from the translog instead of the lucene index. Required for cross cluster replication.
-     * Use the recommended {@link #getHistoryOperations(String, long, long, boolean)} method for other cases.
-     * This method should only be invoked if Segment Replication or Remote Store is not enabled.
+     * Creates a new history snapshot from the translog instead of the lucene index.
      */
     public Translog.Snapshot getHistoryOperationsFromTranslog(long startingSeqNo, long endSeqNo) throws IOException {
-        assert indexSettings.isSegRepEnabledOrRemoteNode() == false
-            : "unsupported operation for segment replication enabled indices or remote store backed indices";
+        // In seg rep flow as well, we are going to replay from translog.
         return getEngine().translogManager().newChangesSnapshot(startingSeqNo, endSeqNo, true);
     }
 
+    public GatedCloseable<Long> acquireRetentionLockWithMinGen() {
+        return getEngine().translogManager().acquireRetentionLockWithMinGen();
+    }
+
     /**
      * Checks if we have a completed history of operations since the given starting seqno (inclusive).
      * This method should be called after acquiring the retention lock; See {@link #acquireHistoryRetentionLock()}
@@ -3368,6 +3472,19 @@ public void removeRetentionLease(final String id, final ActionListener<Replicati
      * @param retentionLeases the retention leases
      */
     public void updateRetentionLeasesOnReplica(final RetentionLeases retentionLeases) {
+        assert assertReplicationTarget();
+        verifyNotClosed();
+        if (shardRouting.isSplitTarget() == false) {
+            replicationTracker.updateRetentionLeasesOnReplica(retentionLeases);
+        }
+    }
+
+    /**
+     * Updates retention leases on a child primary.
+     *
+     * @param retentionLeases the retention leases
+     */
+    public void updateRetentionLeasesOnChildPrimary(final RetentionLeases retentionLeases) {
         assert assertReplicationTarget();
         verifyNotClosed();
         replicationTracker.updateRetentionLeasesOnReplica(retentionLeases);
@@ -3398,6 +3515,10 @@ public boolean assertRetentionLeasesPersisted() throws IOException {
         return replicationTracker.assertRetentionLeasesPersisted(path.getShardStatePath());
     }
 
+    public long getNewRetainedRetentionLeaseSeqNo(String shardAllocationId) {
+        return replicationTracker.getNewRetainedRetentionLeaseSeqNo(shardAllocationId);
+    }
+
     /**
      * Syncs the current retention leases to all replicas.
      */
@@ -3443,6 +3564,17 @@ public void initiateTracking(final String allocationId) {
         replicationTracker.initiateTracking(allocationId);
     }
 
+    /**
+     * Called when the recovery process for a shard has opened the engine on target child shards. Ensures that the right data structures
+     * have been set up locally to track local checkpoint information for the shards and that the shards are added to the replication group.
+     *
+     * @param allocationIds  the allocation IDs of child shards for which recovery was initiated
+     */
+    public synchronized void initiateTrackingOfChildShards(final List<String> allocationIds) {
+        assert assertPrimaryMode();
+        replicationTracker.initiateTrackingOfChildShards(allocationIds);
+    }
+
     /**
      * Marks the shard with the provided allocation ID as in-sync with the primary shard. See
      * {@link ReplicationTracker#markAllocationIdAsInSync(String, long)}
@@ -3560,6 +3692,17 @@ public PendingReplicationActions getPendingReplicationActions() {
         return pendingReplicationActions;
     }
 
+    /**
+     * Returns allocation id of the current allocation of this shard.
+     *
+     * @return current allocation id.
+     */
+    public String getAllocationId() {
+        assert assertPrimaryMode();
+        verifyNotClosed();
+        return shardRouting.allocationId().getId();
+    }
+
     /**
      * Updates the global checkpoint on a replica shard after it has been updated by the primary.
      *
@@ -3581,6 +3724,9 @@ public void updateGlobalCheckpointOnReplica(final long globalCheckpoint, final S
              * to recovery finalization, or even finished recovery before the update arrives here.
              * When remote translog is enabled for an index, replication operation is limited to primary term validation and does not
              * update local checkpoint at replica, so the local checkpoint at replica can be less than globalCheckpoint.
+             * This can also happen on a recovering child shard during in-place shard split recovery after all child shards are added
+             * in the replication group and checkpoints are published to all child shards including the ones which do not own the respective
+             * replicated bulk operations.
              */
             assert (state() != IndexShardState.POST_RECOVERY && state() != IndexShardState.STARTED)
                 || indexSettings.isAssignedOnRemoteNode() : "supposedly in-sync shard copy received a global checkpoint ["
@@ -3600,21 +3746,21 @@ public void updateGlobalCheckpointOnReplica(final long globalCheckpoint, final S
      * @param primaryContext the sequence number context
      */
     public void activateWithPrimaryContext(final ReplicationTracker.PrimaryContext primaryContext) {
-        assert shardRouting.primary() && shardRouting.isRelocationTarget()
-            : "only primary relocation target can update allocation IDs from primary context: " + shardRouting;
+        assert shardRouting.primary() && (shardRouting.isRelocationTarget() || shardRouting.isSplitTarget())
+            : "only primary relocation or split target can update allocation IDs from primary context: " + shardRouting;
         assert primaryContext.getCheckpointStates().containsKey(routingEntry().allocationId().getId()) : "primary context ["
             + primaryContext
             + "] does not contain relocation target ["
             + routingEntry()
             + "]";
         String allocationId = routingEntry().allocationId().getId();
-        if (isRemoteStoreEnabled() || isMigratingToRemote()) {
+        if (isRemoteStoreEnabled() && !shardRouting.isSplitTarget() || isMigratingToRemote()) {
             // For remote backed indexes, old primary may not have updated value of local checkpoint of new primary.
             // But the new primary is always updated with data in remote sore and is at par with old primary.
             // So, we can use a stricter check where local checkpoint of new primary is checked against that of old primary.
             allocationId = primaryContext.getRoutingTable().primaryShard().allocationId().getId();
         }
-        assert getLocalCheckpoint() == primaryContext.getCheckpointStates().get(allocationId).getLocalCheckpoint()
+        assert getLocalCheckpoint() >= primaryContext.getCheckpointStates().get(allocationId).getLocalCheckpoint()
             || indexSettings().getTranslogDurability() == Durability.ASYNC : "local checkpoint ["
                 + getLocalCheckpoint()
                 + "] does not match checkpoint from primary context ["
@@ -4177,6 +4323,11 @@ private ActionListener<Releasable> wrapPrimaryOperationPermitListener(final Acti
         return ActionListener.delegateFailure(listener, (l, r) -> {
             if (replicationTracker.isPrimaryMode()) {
                 l.onResponse(r);
+            } else if (routingEntry().splitting()) {
+                // Scenario when replication tracker is no longer in primary mode after split and child shards are still
+                // pending to be started.
+                r.close();
+                l.onFailure(new PrimaryShardSplitException("Primary shard is already split."));
             } else {
                 r.close();
                 l.onFailure(new ShardNotInPrimaryModeException(shardId, state));
@@ -5168,6 +5319,57 @@ public void syncSegmentsFromRemoteSegmentStore(boolean overrideLocal, final Runn
         }
     }
 
+
+    /**
+     * Copies segments and metadata from source directory to remote. This method is used in
+     * shard split flow where engine is not yet open and files need to be explicitly copied from local to remote.
+     */
+    public void copySegmentsAndMetadataToRemote(
+        RemoteSegmentStoreDirectory sourceRemoteDirectory,
+        Directory storeDirectory,
+        SegmentInfos segmentInfos,
+        ReplicationCheckpoint replicationCheckpoint,
+        Collection<String> localSegments,
+        long traslogFileGen,
+        RemoteSegmentMetadata sourceRemoteMetadata
+    ) throws Exception {
+
+        assert remoteStore != null;
+        RemoteSegmentStoreDirectory remoteDirectory = getRemoteDirectory();
+        remoteStore.incRef();
+        store.incRef();
+        try {
+            Set<String> files = new HashSet<>(localSegments);
+            CheckedRunnable<Exception> segmentCopyingRunnable = () -> remoteDirectory.copySegmentFilesFromSource
+                (files, storeDirectory, sourceRemoteDirectory, sourceRemoteMetadata);
+            copyWithRetries(segmentCopyingRunnable, 0, 5, null);
+            CheckedRunnable<Exception> metadataCopyingRunnable = () -> remoteDirectory.uploadMetadata(
+                localSegments, segmentInfos, storeDirectory, traslogFileGen, replicationCheckpoint, getNodeId());
+            copyWithRetries(metadataCopyingRunnable, 0, 3, null);
+        } finally {
+            store.decRef();
+            remoteStore.decRef();
+        }
+    }
+
+    private void copyWithRetries(
+        CheckedRunnable<Exception> copyingRunnable,
+        int retryCount,
+        int maxRetries,
+        Exception rootEx
+    ) throws Exception {
+        if (retryCount >= maxRetries) {
+            throw rootEx;
+        }
+        try {
+            copyingRunnable.run();
+        } catch (Exception ex) {
+            if (rootEx == null) rootEx = ex;
+            else rootEx.addSuppressed(ex);
+            copyWithRetries(copyingRunnable, retryCount + 1, maxRetries, rootEx);
+        }
+    }
+
     /**
      * Downloads segments from given remote segment store for a specific commit.
      * @param overrideLocal flag to override local segment files with those in remote store
@@ -5306,7 +5508,7 @@ private String copySegmentFiles(
     }
 
     // Visible for testing
-    boolean localDirectoryContains(Directory localDirectory, String file, long checksum) throws IOException {
+    public boolean localDirectoryContains(Directory localDirectory, String file, long checksum) throws IOException {
         try (IndexInput indexInput = localDirectory.openInput(file, IOContext.READONCE)) {
             if (checksum == CodecUtil.retrieveChecksum(indexInput)) {
                 return true;
@@ -5322,7 +5524,7 @@ boolean localDirectoryContains(Directory localDirectory, String file, long check
                 }
             }
         } catch (NoSuchFileException | FileNotFoundException e) {
-            logger.debug("File {} does not exist in local FS, downloading from remote store", file);
+            logger.debug("File {} does not exist in local FS", file);
         } catch (IOException e) {
             logger.warn("Exception while reading checksum of file: {}, this can happen if file is corrupted", file);
             // For any other exception on reading checksum, we delete the file to re-download again
diff --git a/server/src/main/java/org/opensearch/index/shard/IndexShardOperationPermits.java b/server/src/main/java/org/opensearch/index/shard/IndexShardOperationPermits.java
index da51530586893..ef32564975c05 100644
--- a/server/src/main/java/org/opensearch/index/shard/IndexShardOperationPermits.java
+++ b/server/src/main/java/org/opensearch/index/shard/IndexShardOperationPermits.java
@@ -32,6 +32,8 @@
 
 package org.opensearch.index.shard;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.opensearch.ExceptionsHelper;
 import org.opensearch.action.ActionRunnable;
 import org.opensearch.action.support.ContextPreservingActionListener;
@@ -49,9 +51,12 @@
 
 import java.io.Closeable;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
@@ -72,6 +77,7 @@ final class IndexShardOperationPermits implements Closeable {
 
     private final ShardId shardId;
     private final ThreadPool threadPool;
+    private final Logger logger = LogManager.getLogger(IndexShardOperationPermits.class);
 
     static final int TOTAL_PERMITS = Integer.MAX_VALUE;
     final Semaphore semaphore = new Semaphore(TOTAL_PERMITS, true); // fair to ensure a blocking thread is not starved
@@ -119,9 +125,14 @@ public void close() {
     <E extends Exception> void blockOperations(final long timeout, final TimeUnit timeUnit, final CheckedRunnable<E> onBlocked)
         throws InterruptedException, TimeoutException, E {
         delayOperations();
+        logger.info("Delayed operations and going to acquire all permits");
         try (Releasable ignored = acquireAll(timeout, timeUnit)) {
             onBlocked.run();
         } finally {
+            Set<Thread> threads = Thread.getAllStackTraces().keySet();
+            for (Thread t : threads) {
+
+            }
             releaseDelayedOperations();
         }
     }
@@ -182,11 +193,13 @@ private Releasable acquireAll(final long timeout, final TimeUnit timeUnit) throw
                 assert queuedBlockOperations > 0;
             }
         }
+        logger.info("Going to acquire all permits. Currently issued permits " + issuedPermits.size() );
         if (semaphore.tryAcquire(TOTAL_PERMITS, timeout, timeUnit)) {
             final RunOnce release = new RunOnce(() -> {
                 assert semaphore.availablePermits() == 0;
                 semaphore.release(TOTAL_PERMITS);
             });
+            logger.info("Acquired all permits");
             return release::run;
         } else {
             throw new TimeoutException("timeout while blocking operations");
diff --git a/server/src/main/java/org/opensearch/index/shard/RemoteStoreRefreshListener.java b/server/src/main/java/org/opensearch/index/shard/RemoteStoreRefreshListener.java
index 702928771f131..0457363d3268c 100644
--- a/server/src/main/java/org/opensearch/index/shard/RemoteStoreRefreshListener.java
+++ b/server/src/main/java/org/opensearch/index/shard/RemoteStoreRefreshListener.java
@@ -22,6 +22,8 @@
 import org.opensearch.action.support.GroupedActionListener;
 import org.opensearch.cluster.routing.RecoverySource;
 import org.opensearch.common.concurrent.GatedCloseable;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.lease.Releasables;
 import org.opensearch.common.logging.Loggers;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.UploadListener;
@@ -49,6 +51,7 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
 import static org.opensearch.index.seqno.SequenceNumbers.LOCAL_CHECKPOINT_KEY;
@@ -90,9 +93,11 @@ public final class RemoteStoreRefreshListener extends ReleasableRetryableRefresh
     private final RemoteSegmentTransferTracker segmentTracker;
     private final Map<String, String> localSegmentChecksumMap;
     private volatile long primaryTerm;
+    private volatile long commitGen = -1;
     private volatile Iterator<TimeValue> backoffDelayIterator;
     private final SegmentReplicationCheckpointPublisher checkpointPublisher;
     private final RemoteStoreSettings remoteStoreSettings;
+    private final AtomicBoolean staleCommitDeletionDelayed = new AtomicBoolean();
 
     public RemoteStoreRefreshListener(
         IndexShard indexShard,
@@ -156,13 +161,26 @@ protected void runAfterRefreshExactlyOnce(boolean didRefresh) {
     protected boolean performAfterRefreshWithPermit(boolean didRefresh) {
         boolean successful;
         if (shouldSync(didRefresh, false)) {
-            successful = syncSegments();
+            successful = syncSegments(false);
         } else {
             successful = true;
         }
         return successful;
     }
 
+    public Releasable delayStaleCommitDeletion() {
+        try (Releasable ignore = drainRefreshes()) {
+            boolean commitsDelayed = staleCommitDeletionDelayed.compareAndSet(false, true);
+            if (commitsDelayed == false) {
+                throw new IllegalStateException("Cannot delay an already delayed stale commit");
+            }
+            return Releasables.releaseOnce(() -> {
+                staleCommitDeletionDelayed.set(false);
+                remoteDirectory.deleteStaleSegmentsAsync(indexShard.getRemoteStoreSettings().getMinRemoteSegmentMetadataFiles());
+            });
+        }
+    }
+
     /**
      * This checks if there is a sync required to remote.
      *
@@ -215,7 +233,7 @@ boolean isRemoteSegmentStoreInSync() {
     /*
      @return false if retry is needed
      */
-    private boolean syncSegments() {
+    private boolean syncSegments(boolean firstSyncAfterCommit) {
         if (isReadyForUpload() == false) {
             // Following check is required to enable retry and make sure that we do not lose this refresh event
             // When primary shard is restored from remote store, the recovery happens first followed by changing
@@ -236,12 +254,23 @@ private boolean syncSegments() {
                 // if a new segments_N file is present in local that is not uploaded to remote store yet, it
                 // is considered as a first refresh post commit. A cleanup of stale commit files is triggered.
                 // This is done to avoid delete post each refresh.
-                if (isRefreshAfterCommit()) {
+                if (staleCommitDeletionDelayed.get() == false && isRefreshAfterCommit()) {
                     remoteDirectory.deleteStaleSegmentsAsync(indexShard.getRemoteStoreSettings().getMinRemoteSegmentMetadataFiles());
                 }
 
-                try (GatedCloseable<SegmentInfos> segmentInfosGatedCloseable = indexShard.getSegmentInfosSnapshot()) {
+                try (GatedCloseable<SegmentInfos> segmentInfosGatedCloseable = (
+                    firstSyncAfterCommit ?
+                        new GatedCloseable<>(indexShard.store().readLastCommittedSegmentsInfo(), ()->{}) :
+                        indexShard.getSegmentInfosSnapshot()
+                        )
+                ) {
+                    indexShard.store().readLastCommittedSegmentsInfo();
                     SegmentInfos segmentInfos = segmentInfosGatedCloseable.get();
+
+                    if (firstSyncAfterCommit == false && segmentInfos.getGeneration() != commitGen) {
+                        syncSegments(true);
+                        commitGen = segmentInfos.getGeneration();
+                    }
                     final ReplicationCheckpoint checkpoint = indexShard.computeReplicationCheckpoint(segmentInfos);
                     if (checkpoint.getPrimaryTerm() != indexShard.getOperationPrimaryTerm()) {
                         throw new IllegalStateException(
@@ -257,7 +286,6 @@ private boolean syncSegments() {
                     // move.
                     long lastRefreshedCheckpoint = ((InternalEngine) indexShard.getEngine()).lastRefreshedCheckpoint();
                     Collection<String> localSegmentsPostRefresh = segmentInfos.files(true);
-
                     // Create a map of file name to size and update the refresh segment tracker
                     Map<String, Long> localSegmentsSizeMap = updateLocalSizeMapAndTracker(localSegmentsPostRefresh).entrySet()
                         .stream()
@@ -358,8 +386,11 @@ private void onSuccessfulSegmentsSync(
         resetBackOffDelayIterator();
         // Set the minimum sequence number for keeping translog
         indexShard.getEngine().translogManager().setMinSeqNoToKeep(lastRefreshedCheckpoint + 1);
-        // Publishing the new checkpoint which is used for remote store + segrep indexes
-        checkpointPublisher.publish(indexShard, checkpoint);
+        // Publishing the new checkpoint which is used for remote store + segrep indexes. Skipping replication from child primary
+        // since it happens via parent primary on child replicas.
+        if (indexShard.routingEntry().isSplitTarget() == false) {
+            checkpointPublisher.publish(indexShard, checkpoint);
+        }
         logger.debug("onSuccessfulSegmentsSync lastRefreshedCheckpoint={} checkpoint={}", lastRefreshedCheckpoint, checkpoint);
     }
 
@@ -583,8 +614,9 @@ boolean isLocalOrSnapshotRecoveryOrSeeding() {
         return (indexShard.state() == IndexShardState.RECOVERING && indexShard.shardRouting.primary())
             && indexShard.recoveryState() != null
             && (indexShard.recoveryState().getRecoverySource().getType() == RecoverySource.Type.LOCAL_SHARDS
-                || indexShard.recoveryState().getRecoverySource().getType() == RecoverySource.Type.SNAPSHOT
-                || indexShard.shouldSeedRemoteStore());
+            || indexShard.recoveryState().getRecoverySource().getType() == RecoverySource.Type.IN_PLACE_SHARD_SPLIT
+            || indexShard.recoveryState().getRecoverySource().getType() == RecoverySource.Type.SNAPSHOT
+            || indexShard.shouldSeedRemoteStore());
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/index/shard/ReplicationGroup.java b/server/src/main/java/org/opensearch/index/shard/ReplicationGroup.java
index b2db48737ee3f..831c358c449c2 100644
--- a/server/src/main/java/org/opensearch/index/shard/ReplicationGroup.java
+++ b/server/src/main/java/org/opensearch/index/shard/ReplicationGroup.java
@@ -95,6 +95,17 @@ public ReplicationGroup(
                         assert inSyncAllocationIds.contains(relocationTarget.allocationId().getId()) == false
                             : "in-sync shard copy but not tracked: " + shard;
                     }
+                } else if (shard.splitting()) {
+                    ShardRouting[] childShards = shard.getRecoveringChildShards();
+                    for (ShardRouting childShard : childShards) {
+                        if (trackedAllocationIds.contains(childShard.allocationId().getId())) {
+                            replicationTargets.add(childShard);
+                        } else {
+                            skippedShards.add(childShard);
+                            assert inSyncAllocationIds.contains(childShard.allocationId().getId()) == false
+                                : "in-sync child shard copy but not tracked: " + shard;
+                        }
+                    }
                 }
             }
         }
diff --git a/server/src/main/java/org/opensearch/index/shard/ShardSplittingQuery.java b/server/src/main/java/org/opensearch/index/shard/ShardSplittingQuery.java
index 219ead931797a..f5274c374f467 100644
--- a/server/src/main/java/org/opensearch/index/shard/ShardSplittingQuery.java
+++ b/server/src/main/java/org/opensearch/index/shard/ShardSplittingQuery.java
@@ -79,11 +79,14 @@ final class ShardSplittingQuery extends Query {
     private final IndexMetadata indexMetadata;
     private final int shardId;
     private final BitSetProducer nestedParentBitSetProducer;
+    private final boolean includeInProgressChild;
 
-    ShardSplittingQuery(IndexMetadata indexMetadata, int shardId, boolean hasNested) {
+    ShardSplittingQuery(IndexMetadata indexMetadata, int shardId, boolean hasNested,
+                        boolean includeInProgressChild) {
         this.indexMetadata = indexMetadata;
         this.shardId = shardId;
         this.nestedParentBitSetProducer = hasNested ? newParentDocBitSetProducer(indexMetadata.getCreationVersion()) : null;
+        this.includeInProgressChild = includeInProgressChild;
     }
 
     @Override
@@ -103,7 +106,8 @@ public Scorer scorer(LeafReaderContext context) throws IOException {
                     int targetShardId = OperationRouting.generateShardId(
                         indexMetadata,
                         Uid.decodeId(ref.bytes, ref.offset, ref.length),
-                        null
+                        null,
+                        includeInProgressChild
                     );
                     return shardId == targetShardId;
                 };
@@ -147,7 +151,7 @@ public Scorer scorer(LeafReaderContext context) throws IOException {
                         };
                         // in the _routing case we first go and find all docs that have a routing value and mark the ones we have to delete
                         findSplitDocs(RoutingFieldMapper.NAME, ref -> {
-                            int targetShardId = OperationRouting.generateShardId(indexMetadata, null, ref.utf8ToString());
+                            int targetShardId = OperationRouting.generateShardId(indexMetadata, null, ref.utf8ToString(), includeInProgressChild);
                             return shardId == targetShardId;
                         }, leafReader, maybeWrapConsumer.apply(bitSet::set));
 
@@ -288,7 +292,7 @@ boolean matches(int doc) throws IOException {
             leftToVisit = 2;
             leafReader.storedFields().document(doc, this);
             assert id != null : "docID must not be null - we might have hit a nested document";
-            int targetShardId = OperationRouting.generateShardId(indexMetadata, id, routing);
+            int targetShardId = OperationRouting.generateShardId(indexMetadata, id, routing, includeInProgressChild);
             return targetShardId != shardId;
         }
     }
diff --git a/server/src/main/java/org/opensearch/index/shard/StoreRecovery.java b/server/src/main/java/org/opensearch/index/shard/StoreRecovery.java
index 74d9cc4b4f6dd..e1c4de937fd43 100644
--- a/server/src/main/java/org/opensearch/index/shard/StoreRecovery.java
+++ b/server/src/main/java/org/opensearch/index/shard/StoreRecovery.java
@@ -49,6 +49,7 @@
 import org.opensearch.cluster.routing.RecoverySource;
 import org.opensearch.cluster.routing.RecoverySource.SnapshotRecoverySource;
 import org.opensearch.common.UUIDs;
+import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.lucene.Lucene;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.action.ActionListener;
@@ -88,18 +89,19 @@
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Consumer;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 import static org.opensearch.common.unit.TimeValue.timeValueMillis;
 import static org.opensearch.index.translog.Translog.CHECKPOINT_FILE_NAME;
 
 /**
- * This package private utility class encapsulates the logic to recover an index shard from either an existing index on
+ * This utility class encapsulates the logic to recover an index shard from either an existing index on
  * disk or from a snapshot in a repository.
  *
  * @opensearch.internal
  */
-final class StoreRecovery {
+public final class StoreRecovery {
 
     private final Logger logger;
     private final ShardId shardId;
@@ -208,7 +210,7 @@ void recoverFromLocalShards(
         }
     }
 
-    void addIndices(
+    public static void addIndices(
         final ReplicationLuceneIndex indexRecoveryStats,
         final Directory target,
         final Sort indexSort,
@@ -220,29 +222,52 @@ void addIndices(
         boolean split,
         boolean hasNested
     ) throws IOException {
+        final Directory hardLinkOrCopyTarget = new org.apache.lucene.misc.store.HardlinkCopyDirectoryWrapper(target);
+        Directory statsDirectory = new StatsDirectoryWrapper(hardLinkOrCopyTarget, indexRecoveryStats);
+
+        Tuple<Boolean, Directory> addIndexDirectoryTuple = new Tuple<>(true, statsDirectory);
+        addIndices(indexRecoveryStats, indexSort, sources, maxSeqNo, maxSeqNo, maxUnsafeAutoIdTimestamp, indexMetadata,
+            shardId, split, hasNested, addIndexDirectoryTuple, false,
+            IndexWriterConfig.OpenMode.CREATE);
+    }
 
+    public static void addIndices(
+        final ReplicationLuceneIndex indexRecoveryStats,
+        final Sort indexSort,
+        final Directory[] sources,
+        final long localCheckpoint,
+        final long maxSeqNo,
+        final long maxUnsafeAutoIdTimestamp,
+        IndexMetadata indexMetadata,
+        int shardId,
+        boolean split,
+        boolean hasNested,
+        Tuple<Boolean, Directory> addIndexDirectoryTuple,
+        boolean includeInProgressChild,
+        IndexWriterConfig.OpenMode openMode
+    ) throws IOException {
         assert sources.length > 0;
         final int luceneIndexCreatedVersionMajor = Lucene.readSegmentInfos(sources[0]).getIndexCreatedVersionMajor();
 
-        final Directory hardLinkOrCopyTarget = new org.apache.lucene.misc.store.HardlinkCopyDirectoryWrapper(target);
-
         IndexWriterConfig iwc = new IndexWriterConfig(null).setSoftDeletesField(Lucene.SOFT_DELETES_FIELD)
             .setCommitOnClose(false)
             // we don't want merges to happen here - we call maybe merge on the engine
             // later once we stared it up otherwise we would need to wait for it here
             // we also don't specify a codec here and merges should use the engines for this index
             .setMergePolicy(NoMergePolicy.INSTANCE)
-            .setOpenMode(IndexWriterConfig.OpenMode.CREATE)
+            .setOpenMode(openMode)
             .setIndexCreatedVersionMajor(luceneIndexCreatedVersionMajor);
         if (indexSort != null) {
             iwc.setIndexSort(indexSort);
         }
 
-        try (IndexWriter writer = new IndexWriter(new StatsDirectoryWrapper(hardLinkOrCopyTarget, indexRecoveryStats), iwc)) {
-            writer.addIndexes(sources);
+        try (IndexWriter writer = new IndexWriter(addIndexDirectoryTuple.v2(), iwc)) {
+            if (addIndexDirectoryTuple.v1() == true) {
+                writer.addIndexes(sources);
+            }
             indexRecoveryStats.setFileDetailsComplete();
             if (split) {
-                writer.deleteDocuments(new ShardSplittingQuery(indexMetadata, shardId, hasNested));
+                writer.deleteDocuments(new ShardSplittingQuery(indexMetadata, shardId, hasNested, includeInProgressChild));
             }
             /*
              * We set the maximum sequence number and the local checkpoint on the target to the maximum of the maximum sequence numbers on
@@ -252,7 +277,7 @@ void addIndices(
             writer.setLiveCommitData(() -> {
                 final HashMap<String, String> liveCommitData = new HashMap<>(3);
                 liveCommitData.put(SequenceNumbers.MAX_SEQ_NO, Long.toString(maxSeqNo));
-                liveCommitData.put(SequenceNumbers.LOCAL_CHECKPOINT_KEY, Long.toString(maxSeqNo));
+                liveCommitData.put(SequenceNumbers.LOCAL_CHECKPOINT_KEY, Long.toString(localCheckpoint));
                 liveCommitData.put(Engine.MAX_UNSAFE_AUTO_ID_TIMESTAMP_COMMIT_ID, Long.toString(maxUnsafeAutoIdTimestamp));
                 return liveCommitData.entrySet().iterator();
             });
@@ -265,10 +290,10 @@ void addIndices(
      *
      * @opensearch.internal
      */
-    static final class StatsDirectoryWrapper extends FilterDirectory {
+    public static final class StatsDirectoryWrapper extends FilterDirectory {
         private final ReplicationLuceneIndex index;
 
-        StatsDirectoryWrapper(Directory in, ReplicationLuceneIndex indexRecoveryStats) {
+        public StatsDirectoryWrapper(Directory in, ReplicationLuceneIndex indexRecoveryStats) {
             super(in);
             this.index = indexRecoveryStats;
         }
diff --git a/server/src/main/java/org/opensearch/index/store/RemoteDirectory.java b/server/src/main/java/org/opensearch/index/store/RemoteDirectory.java
index aa856aa22313d..ef52a92134a52 100644
--- a/server/src/main/java/org/opensearch/index/store/RemoteDirectory.java
+++ b/server/src/main/java/org/opensearch/index/store/RemoteDirectory.java
@@ -41,6 +41,7 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
@@ -95,6 +96,8 @@ public RemoteDirectory(
         this.downloadRateLimiter = downloadRateLimiter;
     }
 
+
+
     /**
      * Returns names of all files stored in this directory. The output must be in sorted (UTF-16,
      * java's {@link String#compareTo}) order.
@@ -115,6 +118,10 @@ public Collection<String> listFilesByPrefix(String filenamePrefix) throws IOExce
     }
 
     public List<String> listFilesByPrefixInLexicographicOrder(String filenamePrefix, int limit) throws IOException {
+        return listFilesByPrefixInOrder(filenamePrefix, limit, BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC);
+    }
+
+    public List<String> listFilesByPrefixInOrder(String filenamePrefix, int limit, BlobContainer.BlobNameSortOrder order) throws IOException {
         List<String> sortedBlobList = new ArrayList<>();
         AtomicReference<Exception> exception = new AtomicReference<>();
         final CountDownLatch latch = new CountDownLatch(1);
@@ -134,7 +141,7 @@ public void onFailure(Exception e) {
             blobContainer.listBlobsByPrefixInSortedOrder(
                 filenamePrefix,
                 limit,
-                BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC,
+                order,
                 actionListener
             );
             latch.await();
@@ -328,6 +335,19 @@ public void delete() throws IOException {
         blobContainer.delete();
     }
 
+    public Set<String> copyFilesFromSrcRemoteToCurRemote(
+        RemoteDirectory sourceDirectory,
+        Set<String> remoteFiles
+    ) {
+        if (blobContainer instanceof AsyncMultiStreamBlobContainer &&
+            sourceDirectory.blobContainer instanceof AsyncMultiStreamBlobContainer) {
+            AsyncMultiStreamBlobContainer sourceBlobContainer = (AsyncMultiStreamBlobContainer) sourceDirectory.blobContainer;
+            AsyncMultiStreamBlobContainer currentBlobContainer = (AsyncMultiStreamBlobContainer) blobContainer;
+            return currentBlobContainer.copyFilesFromSrcRemote(remoteFiles, sourceBlobContainer);
+        }
+        return Collections.emptySet();
+    }
+
     public boolean copyFrom(
         Directory from,
         String src,
diff --git a/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectory.java b/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectory.java
index d51fe0643575e..67d7d1cca4dc2 100644
--- a/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectory.java
+++ b/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectory.java
@@ -25,6 +25,7 @@
 import org.apache.lucene.util.Version;
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.common.blobstore.BlobContainer;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.io.VersionedCodecStreamWrapper;
 import org.opensearch.common.logging.Loggers;
@@ -72,7 +73,6 @@
  *
  * @opensearch.api
  */
-@PublicApi(since = "2.3.0")
 public final class RemoteSegmentStoreDirectory extends FilterDirectory implements RemoteStoreCommitLevelLockManager {
 
     /**
@@ -251,7 +251,7 @@ public RemoteSegmentMetadata readLatestMetadataFile() throws IOException {
         return remoteSegmentMetadata;
     }
 
-    private RemoteSegmentMetadata readMetadataFile(String metadataFilename) throws IOException {
+    public RemoteSegmentMetadata readMetadataFile(String metadataFilename) throws IOException {
         try (InputStream inputStream = remoteMetadataDirectory.getBlobStream(metadataFilename)) {
             byte[] metadataBytes = inputStream.readAllBytes();
             return metadataStreamWrapper.readStream(new ByteArrayIndexInput(metadataFilename, metadataBytes));
@@ -440,9 +440,15 @@ public static Tuple<String, String> getNodeIdByPrimaryTermAndGen(String filename
      */
     @Override
     public String[] listAll() throws IOException {
-        return readLatestMetadataFile().getMetadata().keySet().toArray(new String[0]);
+        RemoteSegmentMetadata metadata = readLatestMetadataFile();
+        if (metadata != null) {
+            return metadata.getMetadata().keySet().toArray(new String[0]);
+        }
+        return null;
     }
 
+
+
     /**
      * Delete segment file from remote segment store.
      *
@@ -458,6 +464,39 @@ public void deleteFile(String name) throws IOException {
         }
     }
 
+    /**
+     * Copies segment files from source remote data directory to current remote. If async transfer is not supported
+     * then it uploads files from local directory.
+     */
+    public void copySegmentFilesFromSource(
+        Set<String> fileNames, Directory localDirectory,
+        RemoteSegmentStoreDirectory sourceRemoteDir,
+        RemoteSegmentMetadata sourceMetadata
+    ) throws IOException {
+        Set<String> remoteFileNames = new HashSet<>(fileNames.size());
+        for (String localFile : fileNames) {
+            if (sourceMetadata.getMetadata().get(localFile) != null) {
+                remoteFileNames.add(sourceMetadata.getMetadata().get(localFile).uploadedFilename);
+            }
+        }
+
+        Set<String> toUploadFromLocal = new HashSet<>();
+        Set<String> copiedFiles = remoteDataDirectory.copyFilesFromSrcRemoteToCurRemote(sourceRemoteDir.remoteDataDirectory, remoteFileNames);
+        for (String localFile : fileNames) {
+            UploadedSegmentMetadata uploadedSegmentMetadata = sourceMetadata.getMetadata().get(localFile);
+            if (uploadedSegmentMetadata != null && copiedFiles.contains(uploadedSegmentMetadata.uploadedFilename) == true) {
+                postUpload(localDirectory, localFile, sourceMetadata.getMetadata().get(localFile).uploadedFilename,
+                    getChecksumOfLocalFile(localDirectory, localFile));
+            } else {
+                toUploadFromLocal.add(localFile);
+            }
+        }
+
+        for (String file : toUploadFromLocal) {
+            copyFrom(localDirectory, file, file, IOContext.DEFAULT);
+        }
+    }
+
     /**
      * Returns the byte length of a segment file in the remote segment store.
      *
@@ -590,10 +629,11 @@ Boolean isLockAcquired(String metadataFile) throws IOException {
     }
 
     // Visible for testing
-    String getMetadataFileForCommit(long primaryTerm, long generation) throws IOException {
-        List<String> metadataFiles = remoteMetadataDirectory.listFilesByPrefixInLexicographicOrder(
+    public String getMetadataFileForCommit(long primaryTerm, long generation) throws IOException {
+        List<String> metadataFiles = remoteMetadataDirectory.listFilesByPrefixInOrder(
             MetadataFilenameUtils.getMetadataFilePrefixForCommit(primaryTerm, generation),
-            1
+            1,
+            BlobContainer.BlobNameSortOrder.CHRONOLOGICAL
         );
 
         if (metadataFiles.isEmpty()) {
@@ -1040,9 +1080,7 @@ private boolean deleteIfEmpty() throws IOException {
 
     private boolean delete() {
         try {
-            remoteDataDirectory.delete();
-            remoteMetadataDirectory.delete();
-            mdLockManager.delete();
+            cleanUpRemoteDirectories();
         } catch (Exception e) {
             logger.error("Exception occurred while deleting directory", e);
             return false;
@@ -1050,6 +1088,12 @@ private boolean delete() {
         return true;
     }
 
+    public void cleanUpRemoteDirectories() throws IOException {
+        remoteDataDirectory.delete();
+        remoteMetadataDirectory.delete();
+        mdLockManager.delete();
+    }
+
     @Override
     public void close() throws IOException {
         deleteStaleSegmentsAsync(0, ActionListener.wrap(r -> deleteIfEmpty(), e -> logger.error("Failed to cleanup remote directory")));
diff --git a/server/src/main/java/org/opensearch/index/translog/InternalTranslogManager.java b/server/src/main/java/org/opensearch/index/translog/InternalTranslogManager.java
index e2210217672ef..ebb317ea8861e 100644
--- a/server/src/main/java/org/opensearch/index/translog/InternalTranslogManager.java
+++ b/server/src/main/java/org/opensearch/index/translog/InternalTranslogManager.java
@@ -11,6 +11,7 @@
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.apache.lucene.store.AlreadyClosedException;
+import org.opensearch.common.concurrent.GatedCloseable;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.logging.Loggers;
 import org.opensearch.common.util.concurrent.ReleasableLock;
@@ -312,6 +313,11 @@ public Releasable drainSync() {
         return translog.drainSync();
     }
 
+    @Override
+    public GatedCloseable<Long> acquireRetentionLockWithMinGen() {
+        return translog.acquireRetentionLockWithMinGen();
+    }
+
     @Override
     public Translog.TranslogGeneration getTranslogGeneration() {
         return translog.getGeneration();
diff --git a/server/src/main/java/org/opensearch/index/translog/NoOpTranslogManager.java b/server/src/main/java/org/opensearch/index/translog/NoOpTranslogManager.java
index b4aa7865570a6..f35f0d059e9f6 100644
--- a/server/src/main/java/org/opensearch/index/translog/NoOpTranslogManager.java
+++ b/server/src/main/java/org/opensearch/index/translog/NoOpTranslogManager.java
@@ -8,10 +8,13 @@
 
 package org.opensearch.index.translog;
 
+import org.opensearch.common.concurrent.GatedCloseable;
 import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.lease.Releasables;
 import org.opensearch.common.util.concurrent.ReleasableLock;
 import org.opensearch.core.index.shard.ShardId;
 
+import java.io.Closeable;
 import java.io.IOException;
 import java.util.stream.Stream;
 
@@ -134,4 +137,9 @@ public Releasable drainSync() {
     public Translog.TranslogGeneration getTranslogGeneration() {
         return null;
     }
+
+    @Override
+    public GatedCloseable<Long> acquireRetentionLockWithMinGen() {
+        return new GatedCloseable<>(null, ()->{});
+    }
 }
diff --git a/server/src/main/java/org/opensearch/index/translog/RemoteBlobStoreInternalTranslogFactory.java b/server/src/main/java/org/opensearch/index/translog/RemoteBlobStoreInternalTranslogFactory.java
index 5dc2ad076d21c..0e85d40704f17 100644
--- a/server/src/main/java/org/opensearch/index/translog/RemoteBlobStoreInternalTranslogFactory.java
+++ b/server/src/main/java/org/opensearch/index/translog/RemoteBlobStoreInternalTranslogFactory.java
@@ -8,6 +8,7 @@
 
 package org.opensearch.index.translog;
 
+import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.remote.RemoteTranslogTransferTracker;
 import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.repositories.RepositoriesService;
@@ -18,6 +19,7 @@
 
 import java.io.IOException;
 import java.util.function.BooleanSupplier;
+import java.util.function.Function;
 import java.util.function.LongConsumer;
 import java.util.function.LongSupplier;
 import java.util.function.Supplier;
diff --git a/server/src/main/java/org/opensearch/index/translog/RemoteFsTimestampAwareTranslog.java b/server/src/main/java/org/opensearch/index/translog/RemoteFsTimestampAwareTranslog.java
index 99153324b8372..dbf66821f79a4 100644
--- a/server/src/main/java/org/opensearch/index/translog/RemoteFsTimestampAwareTranslog.java
+++ b/server/src/main/java/org/opensearch/index/translog/RemoteFsTimestampAwareTranslog.java
@@ -15,6 +15,7 @@
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.logging.Loggers;
 import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.remote.RemoteStoreUtils;
 import org.opensearch.index.remote.RemoteTranslogTransferTracker;
 import org.opensearch.index.translog.transfer.TranslogTransferManager;
@@ -37,6 +38,7 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.BooleanSupplier;
+import java.util.function.Function;
 import java.util.function.LongConsumer;
 import java.util.function.LongSupplier;
 import java.util.stream.Collectors;
@@ -148,7 +150,7 @@ protected void trimUnreferencedReaders(boolean indexDeleted, boolean trimLocal)
 
         // This is to fail fast and avoid listing md files un-necessarily.
         if (indexDeleted == false && RemoteStoreUtils.isPinnedTimestampStateStale()) {
-            logger.warn("Skipping remote translog garbage collection as last fetch of pinned timestamp is stale");
+            logger.trace("Skipping remote translog garbage collection as last fetch of pinned timestamp is stale");
             return;
         }
 
@@ -181,7 +183,7 @@ public void onResponse(List<BlobMetadata> blobMetadata) {
 
                     // Check last fetch status of pinned timestamps. If stale, return.
                     if (indexDeleted == false && RemoteStoreUtils.isPinnedTimestampStateStale()) {
-                        logger.warn("Skipping remote translog garbage collection as last fetch of pinned timestamp is stale");
+                        logger.trace("Skipping remote translog garbage collection as last fetch of pinned timestamp is stale");
                         remoteGenerationDeletionPermits.release(REMOTE_DELETION_PERMITS);
                         return;
                     }
diff --git a/server/src/main/java/org/opensearch/index/translog/Translog.java b/server/src/main/java/org/opensearch/index/translog/Translog.java
index 4b4ceb7444471..fc4509908d014 100644
--- a/server/src/main/java/org/opensearch/index/translog/Translog.java
+++ b/server/src/main/java/org/opensearch/index/translog/Translog.java
@@ -38,6 +38,7 @@
 import org.opensearch.common.Nullable;
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.common.concurrent.GatedCloseable;
 import org.opensearch.common.io.stream.ReleasableBytesStreamOutput;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.lease.Releasables;
@@ -75,11 +76,13 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.OptionalLong;
+import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
@@ -735,6 +738,19 @@ public Closeable acquireRetentionLock() {
         }
     }
 
+    /**
+     * Acquires a lock on the translog files, preventing them from being trimmed
+     * Returns min generation reference.
+     */
+    public GatedCloseable<Long> acquireRetentionLockWithMinGen() {
+        try (ReleasableLock ignore = readLock.acquire()) {
+            ensureOpen();
+            final long viewGen = getMinFileGeneration();
+            Closeable closeable = acquireTranslogGenFromDeletionPolicy(viewGen);
+            return new GatedCloseable<>(viewGen, closeable::close);
+        }
+    }
+
     private Closeable acquireTranslogGenFromDeletionPolicy(long viewGen) {
         Releasable toClose = deletionPolicy.acquireTranslogGen(viewGen);
         return () -> {
@@ -785,7 +801,6 @@ public static String getCommitCheckpointFileName(long generation) {
      */
     public void trimOperations(long belowTerm, long aboveSeqNo) throws IOException {
         assert aboveSeqNo >= SequenceNumbers.NO_OPS_PERFORMED : "aboveSeqNo has to a valid sequence number";
-
         try (ReleasableLock lock = writeLock.acquire()) {
             ensureOpen();
             if (current.getPrimaryTerm() < belowTerm) {
@@ -1498,6 +1513,7 @@ public String toString() {
      * @opensearch.internal
      */
     public static class NoOp implements Operation {
+        public static final String FILLING_GAPS = "filling gaps";
 
         private final long seqNo;
         private final long primaryTerm;
diff --git a/server/src/main/java/org/opensearch/index/translog/TranslogManager.java b/server/src/main/java/org/opensearch/index/translog/TranslogManager.java
index e1a0b7d1c1293..fd440e443f544 100644
--- a/server/src/main/java/org/opensearch/index/translog/TranslogManager.java
+++ b/server/src/main/java/org/opensearch/index/translog/TranslogManager.java
@@ -9,8 +9,10 @@
 package org.opensearch.index.translog;
 
 import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.common.concurrent.GatedCloseable;
 import org.opensearch.common.lease.Releasable;
 
+import java.io.Closeable;
 import java.io.IOException;
 import java.util.stream.Stream;
 
@@ -141,5 +143,12 @@ public interface TranslogManager {
      */
     Releasable drainSync();
 
+//    /**
+//     * Copy current translog data to target translog
+//     */
+//    void copyTranslogToTarget(TranslogManager translogManager);
+
     Translog.TranslogGeneration getTranslogGeneration();
+
+    GatedCloseable<Long> acquireRetentionLockWithMinGen();
 }
diff --git a/server/src/main/java/org/opensearch/indices/IndicesService.java b/server/src/main/java/org/opensearch/indices/IndicesService.java
index b9bad5527e3f4..34452ece801dc 100644
--- a/server/src/main/java/org/opensearch/indices/IndicesService.java
+++ b/server/src/main/java/org/opensearch/indices/IndicesService.java
@@ -146,6 +146,10 @@
 import org.opensearch.indices.cluster.IndicesClusterStateService;
 import org.opensearch.indices.fielddata.cache.IndicesFieldDataCache;
 import org.opensearch.indices.mapper.MapperRegistry;
+import org.opensearch.indices.recovery.StartRecoveryRequest;
+import org.opensearch.indices.recovery.inplacesplit.InPlaceShardSplitRecoveryService;
+import org.opensearch.indices.recovery.inplacesplit.InPlaceShardRecoveryContext;
+import org.opensearch.indices.recovery.inplacesplit.InPlaceShardSplitRecoveryListener;
 import org.opensearch.indices.recovery.PeerRecoveryTargetService;
 import org.opensearch.indices.recovery.RecoveryListener;
 import org.opensearch.indices.recovery.RecoverySettings;
@@ -196,9 +200,7 @@
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
-import static java.util.Collections.emptyList;
-import static java.util.Collections.emptyMap;
-import static java.util.Collections.unmodifiableMap;
+import static java.util.Collections.*;
 import static org.opensearch.common.collect.MapBuilder.newMapBuilder;
 import static org.opensearch.common.util.concurrent.OpenSearchExecutors.daemonThreadFactory;
 import static org.opensearch.core.common.util.CollectionUtils.arrayAsArrayList;
@@ -1117,10 +1119,10 @@ public IndexShard createShard(
             retentionLeaseSyncer,
             checkpointPublisher,
             remoteStoreStatsTrackerFactory,
-            repositoriesService,
             targetNode,
             sourceNode,
-            discoveryNodes
+            discoveryNodes,
+            shardRouting.getParentShardId()
         );
         indexShard.addShardFailureCallback(onShardFailure);
         indexShard.startRecovery(recoveryState, recoveryTargetService, recoveryListener, repositoriesService, mapping -> {
@@ -1136,6 +1138,58 @@ public IndexShard createShard(
         return indexShard;
     }
 
+    @Override
+    public void createChildShardsForSplit(
+        List<ShardRouting> shardRoutings,
+        ShardId parentShardId,
+        InPlaceShardSplitRecoveryService inPlaceShardSplitRecoveryService,
+        InPlaceShardSplitRecoveryListener recoveryListener,
+        Consumer<IndexShard.ShardFailure> onShardFailure,
+        DiscoveryNode node,
+        Consumer<ShardId> globalCheckpointSyncer,
+        RetentionLeaseSyncer retentionLeaseSyncer,
+        SegmentReplicationCheckpointPublisher checkpointPublisher,
+        RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory,
+        StartRecoveryRequest request,
+        DiscoveryNodes discoveryNodes
+    ) throws IOException {
+        ensureChangesAllowed();
+        IndexService indexService = indexService(shardRoutings.get(0).index());
+        assert indexService != null;
+        IndexShard parentShard = indexService.getShard(parentShardId.id());
+
+        List<InPlaceShardRecoveryContext> recoveryContexts = new ArrayList<>();
+        for (ShardRouting shardRouting : shardRoutings) {
+            RecoveryState recoveryState = indexService.createRecoveryState(shardRouting, node, node);
+            IndexShard indexShard = indexService.createShard(
+                shardRouting,
+                globalCheckpointSyncer,
+                retentionLeaseSyncer,
+                checkpointPublisher,
+                remoteStoreStatsTrackerFactory,
+                node,
+                node,
+                discoveryNodes,
+                parentShardId
+            );
+            indexShard.addShardFailureCallback(onShardFailure);
+            recoveryContexts.add(new InPlaceShardRecoveryContext(recoveryState, indexShard, parentShard));
+        }
+
+        for (InPlaceShardRecoveryContext recoveryContext : recoveryContexts) {
+            // mark the shard as recovering on the cluster state thread
+            recoveryContext.getIndexShard().markAsRecovering("from in-place shard split", recoveryContext.getRecoveryState());
+        }
+
+        threadPool.generic().execute(() -> inPlaceShardSplitRecoveryService.addAndStartRecovery(recoveryContexts, node,
+            parentShard, recoveryListener, request, indexService.getMetadata()));
+    }
+
+    public void moveChildShardsToStarted(ShardId parentShardId,
+                                         InPlaceShardSplitRecoveryService inPlaceShardSplitRecoveryService) {
+        threadPool.generic().execute(() -> inPlaceShardSplitRecoveryService.startChildShards(parentShardId));
+    }
+
     @Override
     public void removeIndex(final Index index, final IndexRemovalReason reason, final String extraInfo) {
         final String indexName = index.getName();
diff --git a/server/src/main/java/org/opensearch/indices/cluster/IndicesClusterStateService.java b/server/src/main/java/org/opensearch/indices/cluster/IndicesClusterStateService.java
index 2c3ffcdd9e0ba..3c09edc856eff 100644
--- a/server/src/main/java/org/opensearch/indices/cluster/IndicesClusterStateService.java
+++ b/server/src/main/java/org/opensearch/indices/cluster/IndicesClusterStateService.java
@@ -45,6 +45,7 @@
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.routing.IndexShardRoutingTable;
+import org.opensearch.cluster.routing.RecoverySource;
 import org.opensearch.cluster.routing.RecoverySource.Type;
 import org.opensearch.cluster.routing.RoutingNode;
 import org.opensearch.cluster.routing.RoutingTable;
@@ -52,6 +53,7 @@
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.inject.Inject;
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
 import org.opensearch.common.settings.Settings;
@@ -70,6 +72,7 @@
 import org.opensearch.index.seqno.GlobalCheckpointSyncAction;
 import org.opensearch.index.seqno.ReplicationTracker;
 import org.opensearch.index.seqno.RetentionLeaseSyncer;
+import org.opensearch.index.seqno.SequenceNumbers;
 import org.opensearch.index.shard.IndexEventListener;
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.index.shard.IndexShardRelocatedException;
@@ -77,7 +80,12 @@
 import org.opensearch.index.shard.PrimaryReplicaSyncer;
 import org.opensearch.index.shard.PrimaryReplicaSyncer.ResyncTask;
 import org.opensearch.index.shard.ShardNotFoundException;
+import org.opensearch.index.store.Store;
 import org.opensearch.indices.IndicesService;
+import org.opensearch.indices.recovery.RecoveryFailedException;
+import org.opensearch.indices.recovery.StartRecoveryRequest;
+import org.opensearch.indices.recovery.inplacesplit.InPlaceShardSplitRecoveryService;
+import org.opensearch.indices.recovery.inplacesplit.InPlaceShardSplitRecoveryListener;
 import org.opensearch.indices.recovery.PeerRecoverySourceService;
 import org.opensearch.indices.recovery.PeerRecoveryTargetService;
 import org.opensearch.indices.recovery.RecoveryListener;
@@ -126,6 +134,7 @@ public class IndicesClusterStateService extends AbstractLifecycleComponent imple
     private final ClusterService clusterService;
     private final ThreadPool threadPool;
     private final PeerRecoveryTargetService recoveryTargetService;
+    private final InPlaceShardSplitRecoveryService inPlaceShardSplitRecoveryService;
     private final ShardStateAction shardStateAction;
     private final NodeMappingRefreshAction nodeMappingRefreshAction;
 
@@ -170,8 +179,9 @@ public IndicesClusterStateService(
         final GlobalCheckpointSyncAction globalCheckpointSyncAction,
         final RetentionLeaseSyncer retentionLeaseSyncer,
         final SegmentReplicationCheckpointPublisher checkpointPublisher,
-        final RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory
-    ) {
+        final RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory,
+        final InPlaceShardSplitRecoveryService inPlaceShardSplitRecoveryService
+        ) {
         this(
             settings,
             indicesService,
@@ -190,7 +200,8 @@ public IndicesClusterStateService(
             primaryReplicaSyncer,
             globalCheckpointSyncAction::updateGlobalCheckpointForShard,
             retentionLeaseSyncer,
-            remoteStoreStatsTrackerFactory
+            remoteStoreStatsTrackerFactory,
+            inPlaceShardSplitRecoveryService
         );
     }
 
@@ -213,7 +224,8 @@ public IndicesClusterStateService(
         final PrimaryReplicaSyncer primaryReplicaSyncer,
         final Consumer<ShardId> globalCheckpointSyncer,
         final RetentionLeaseSyncer retentionLeaseSyncer,
-        final RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory
+        final RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory,
+        final InPlaceShardSplitRecoveryService inPlaceShardSplitRecoveryService
     ) {
         this.settings = settings;
         this.checkpointPublisher = checkpointPublisher;
@@ -224,12 +236,14 @@ public IndicesClusterStateService(
         indexEventListeners.add(segmentReplicationTargetService);
         indexEventListeners.add(segmentReplicationSourceService);
         indexEventListeners.add(remoteStoreStatsTrackerFactory);
+        indexEventListeners.add(inPlaceShardSplitRecoveryService);
         this.segmentReplicationTargetService = segmentReplicationTargetService;
         this.builtInIndexListener = Collections.unmodifiableList(indexEventListeners);
         this.indicesService = indicesService;
         this.clusterService = clusterService;
         this.threadPool = threadPool;
         this.recoveryTargetService = recoveryTargetService;
+        this.inPlaceShardSplitRecoveryService = inPlaceShardSplitRecoveryService;
         this.shardStateAction = shardStateAction;
         this.nodeMappingRefreshAction = nodeMappingRefreshAction;
         this.repositoriesService = repositoriesService;
@@ -518,6 +532,8 @@ private void removeShards(final ClusterState state) {
         }
     }
 
+
+
     private void createIndices(final ClusterState state) {
         // we only create indices for shards that are allocated
         RoutingNode localRoutingNode = state.getRoutingNodes().node(state.nodes().getLocalNodeId());
@@ -638,6 +654,7 @@ private void createOrUpdateShards(final ClusterState state) {
         DiscoveryNodes nodes = state.nodes();
         RoutingTable routingTable = state.routingTable();
 
+        Map<ShardId, Tuple<ShardRouting, List<ShardRouting>>> childShardsToProcess = new HashMap<>();
         for (final ShardRouting shardRouting : localRoutingNode) {
             ShardId shardId = shardRouting.shardId();
             if (failedShardsCache.containsKey(shardId) == false) {
@@ -645,13 +662,77 @@ private void createOrUpdateShards(final ClusterState state) {
                 assert indexService != null : "index " + shardId.getIndex() + " should have been created by createIndices";
                 Shard shard = indexService.getShardOrNull(shardId.id());
                 if (shard == null) {
-                    assert shardRouting.initializing() : shardRouting + " should have been removed by failMissingShards";
-                    createShard(nodes, routingTable, shardRouting, state);
+                    if (shardRouting.isSplitTarget() && shardRouting.primary()) {
+                        Shard sourceShard = indexService.getShardOrNull(shardRouting.getParentShardId().id());
+                        assert sourceShard != null : "parent shard not found for shard id " + shardRouting.getParentShardId();
+                        childShardsToProcess.computeIfAbsent(shardRouting.getParentShardId(), k ->
+                            new Tuple<>(sourceShard.routingEntry(), new ArrayList<>()));
+                        childShardsToProcess.get(shardRouting.getParentShardId()).v2().add(shardRouting);
+                    } else {
+                        assert shardRouting.initializing() : shardRouting + " should have been removed by failMissingShards";
+                        createShard(nodes, routingTable, shardRouting, state);
+                    }
                 } else {
                     updateShard(nodes, shardRouting, shard, routingTable, state);
                 }
             }
         }
+
+        if (!childShardsToProcess.isEmpty()) {
+            // Recovery flow always starts with the recovery of primary child shards first and then replica.
+            createChildShardsForSplit(nodes, childShardsToProcess, state);
+        }
+
+    }
+
+    private void createChildShardsForSplit(DiscoveryNodes nodes, Map<ShardId, Tuple<ShardRouting, List<ShardRouting>>> childShardRoutings,
+                                           ClusterState state) {
+        // Before we begin creating child shards, previous iteration of shard routing made sure that source shard
+        // routing is updated.
+        for (ShardId parentShardId : childShardRoutings.keySet()) {
+            Tuple<ShardRouting, List<ShardRouting>> routings = childShardRoutings.get(parentShardId);
+
+            final long primaryTerm = state.metadata().index(parentShardId.getIndex()).primaryTerm(parentShardId.id());
+            InPlaceShardSplitRecoveryListener replicationListener = new InPlaceShardSplitRecoveryListener(routings.v2(),
+                this, routings.v1(), primaryTerm);
+
+            // targetAllocationId can't be set to null since it is not read as optional field from stream
+            StartRecoveryRequest request = new StartRecoveryRequest(
+                parentShardId,
+                "N/A",
+                nodes.getLocalNode(),
+                nodes.getLocalNode(),
+                Store.MetadataSnapshot.EMPTY,
+                false,
+                -1,
+                SequenceNumbers.UNASSIGNED_SEQ_NO,
+                new HashSet<>(routings.v1().allocationId().getSplitChildAllocationIds())
+            );
+
+            try {
+                logger.debug("creating child shards from parent shard [{}]", parentShardId);
+                indicesService.createChildShardsForSplit(
+                    routings.v2(),
+                    parentShardId,
+                    inPlaceShardSplitRecoveryService,
+                    replicationListener,
+                    failedShardHandler,
+                    nodes.getLocalNode(),
+                    globalCheckpointSyncer,
+                    retentionLeaseSyncer,
+                    checkpointPublisher,
+                    remoteStoreStatsTrackerFactory,
+                    request,
+                    nodes
+                );
+            } catch (Exception e) {
+                threadPool.generic().execute(() -> {
+                    routings.v2().forEach(routing ->
+                        failAndRemoveChildShards(routing, false, "failed to create child shards", e, state));
+                    replicationListener.onFailure(null, new RecoveryFailedException(request, e.getCause()), true);
+                });
+            }
+        }
     }
 
     private void createShard(DiscoveryNodes nodes, RoutingTable routingTable, ShardRouting shardRouting, ClusterState state) {
@@ -667,7 +748,12 @@ private void createShard(DiscoveryNodes nodes, RoutingTable routingTable, ShardR
         }
 
         try {
-            final long primaryTerm = state.metadata().index(shardRouting.index()).primaryTerm(shardRouting.id());
+            final long primaryTerm;
+            if (shardRouting.isSplitTarget() && shardRouting.primary() == false) {
+                primaryTerm = state.metadata().index(shardRouting.index()).primaryTerm(shardRouting.getParentShardId().id());
+            } else {
+                primaryTerm = state.metadata().index(shardRouting.index()).primaryTerm(shardRouting.id());
+            }
             logger.debug("{} creating shard with primary term [{}]", shardRouting.shardId(), primaryTerm);
             indicesService.createShard(
                 shardRouting,
@@ -702,13 +788,28 @@ private void updateShard(
                 + shardRouting
                 + " local: "
                 + currentRoutingEntry;
+        if (shardRouting.initializing() && shardRouting.getParentShardId() != null) {
+            // Nothing to update yet on recovering child shard.
+            assert currentRoutingEntry.initializing();
+            return;
+        }
 
         final long primaryTerm;
         try {
             final IndexMetadata indexMetadata = clusterState.metadata().index(shard.shardId().getIndex());
-            primaryTerm = indexMetadata.primaryTerm(shard.shardId().id());
+            final IndexShardRoutingTable indexShardRoutingTable;
+            if (shardRouting.isStartedChildReplica()) {
+                if (currentRoutingEntry.isStartedChildReplica() == false) {
+                    logger.info("Starting child replica {} on node {}", shardRouting.shardId().id(),
+                        clusterState.nodes().getLocalNode().getName());
+                }
+                indexShardRoutingTable = routingTable.childReplicaShardRoutingTable(shardRouting.shardId());
+                primaryTerm = indexMetadata.primaryTerm(shard.getParentShardId().id());
+            } else {
+                indexShardRoutingTable = routingTable.shardRoutingTable(shardRouting.shardId());
+                primaryTerm = indexMetadata.primaryTerm(shard.shardId().id());
+            }
             final Set<String> inSyncIds = indexMetadata.inSyncAllocationIds(shard.shardId().id());
-            final IndexShardRoutingTable indexShardRoutingTable = routingTable.shardRoutingTable(shardRouting.shardId());
             shard.updateShardState(
                 shardRouting,
                 primaryTerm,
@@ -750,6 +851,22 @@ private void updateShard(
                 );
             }
         }
+
+        if (shardRouting.splitting()) {
+            final IndexMetadata indexMetadata = clusterState.metadata().index(shard.shardId().getIndex());
+            if (indexMetadata.getNumberOfReplicas() > 0) {
+                boolean allChildReplicasRecovered = true;
+                for (ShardRouting childShard : shardRouting.getRecoveringChildShards()) {
+                    if (childShard.primary() == false && childShard.isStartedChildReplica() == false) {
+                        allChildReplicasRecovered = false;
+                        break;
+                    }
+                }
+                if (allChildReplicasRecovered == true) {
+                    indicesService.moveChildShardsToStarted(shardRouting.shardId(), inPlaceShardSplitRecoveryService);
+                }
+            }
+        }
     }
 
     /**
@@ -764,7 +881,12 @@ private static DiscoveryNode findSourceNodeForPeerRecovery(
     ) {
         DiscoveryNode sourceNode = null;
         if (!shardRouting.primary()) {
-            ShardRouting primary = routingTable.shardRoutingTable(shardRouting.shardId()).primaryShard();
+            ShardRouting primary;
+            if (shardRouting.isSplitTarget()) {
+                primary = routingTable.shardRoutingTable(shardRouting.getParentShardId()).primaryShard();
+            } else {
+                primary = routingTable.shardRoutingTable(shardRouting.shardId()).primaryShard();
+            }
             // only recover from started primary, if we can't find one, we will do it next round
             if (primary.active()) {
                 sourceNode = nodes.get(primary.currentNodeId());
@@ -796,17 +918,51 @@ public synchronized void handleRecoveryFailure(ShardRouting shardRouting, boolea
         failAndRemoveShard(shardRouting, sendShardFailure, "failed recovery", failure, clusterService.state());
     }
 
+    public synchronized void handleChildRecoveriesFailure(ShardRouting sourceShardRouting, boolean sendShardFailure, Exception failure) {
+        failAndRemoveChildShards(sourceShardRouting, sendShardFailure, "failed child shards recovery", failure, clusterService.state());
+    }
+
     public void handleRecoveryDone(ReplicationState state, ShardRouting shardRouting, long primaryTerm) {
         RecoveryState recoveryState = (RecoveryState) state;
         shardStateAction.shardStarted(shardRouting, primaryTerm, "after " + recoveryState.getRecoverySource(), SHARD_STATE_ACTION_LISTENER);
     }
 
+    public void handleChildRecoveriesDone(ShardRouting parentShardRouting, long primaryTerm, RecoverySource recoverySource) {
+        shardStateAction.childShardsStarted(parentShardRouting, primaryTerm, "after " + recoverySource, SHARD_STATE_ACTION_LISTENER);
+    }
+
     private void failAndRemoveShard(
         ShardRouting shardRouting,
         boolean sendShardFailure,
         String message,
         @Nullable Exception failure,
         ClusterState state
+    ) {
+        onlyRemoveShard(shardRouting, message, failure);
+        if (sendShardFailure) {
+            sendFailShard(shardRouting, message, failure, state);
+        }
+    }
+
+    private void failAndRemoveChildShards(
+        ShardRouting shardRouting,
+        boolean sendShardFailure,
+        String message,
+        @Nullable Exception failure,
+        ClusterState state
+    ) {
+        for (ShardRouting childShard : shardRouting.getRecoveringChildShards()) {
+            onlyRemoveShard(childShard, message, failure);
+        }
+        if (sendShardFailure) {
+            sendFailChildShards(shardRouting, message, failure, state);
+        }
+    }
+
+    private void onlyRemoveShard(
+        ShardRouting shardRouting,
+        String message,
+        @Nullable Exception failure
     ) {
         try {
             AllocatedIndex<? extends Shard> indexService = indicesService.indexService(shardRouting.shardId().getIndex());
@@ -830,9 +986,6 @@ private void failAndRemoveShard(
                 inner
             );
         }
-        if (sendShardFailure) {
-            sendFailShard(shardRouting, message, failure, state);
-        }
     }
 
     private void sendFailShard(ShardRouting shardRouting, String message, @Nullable Exception failure, ClusterState state) {
@@ -857,6 +1010,30 @@ private void sendFailShard(ShardRouting shardRouting, String message, @Nullable
         }
     }
 
+    private void sendFailChildShards(ShardRouting shardRouting, String message, @Nullable Exception failure, ClusterState state) {
+        try {
+            logger.warn(
+                () -> new ParameterizedMessage("{} marking and sending shard failed due to [{}]", shardRouting.shardId(), message),
+                failure
+            );
+            for (ShardRouting childShard : shardRouting.getRecoveringChildShards()) {
+                failedShardsCache.put(childShard.shardId(), childShard);
+            }
+            shardStateAction.localShardFailed(shardRouting, message, failure, SHARD_STATE_ACTION_LISTENER, state);
+        } catch (Exception inner) {
+            if (failure != null) inner.addSuppressed(failure);
+            logger.warn(
+                () -> new ParameterizedMessage(
+                    "[{}][{}] failed to mark shard as failed (because of [{}])",
+                    shardRouting.getIndexName(),
+                    shardRouting.getId(),
+                    message
+                ),
+                inner
+            );
+        }
+    }
+
     private class FailedShardHandler implements Consumer<IndexShard.ShardFailure> {
         @Override
         public void accept(final IndexShard.ShardFailure shardFailure) {
@@ -927,6 +1104,11 @@ void updateShardState(
             IndexShardRoutingTable routingTable,
             DiscoveryNodes discoveryNodes
         ) throws IOException;
+
+        /**
+         * Returns parent shard id if it is a child shard or otherwise null.
+         */
+        ShardId getParentShardId();
     }
 
     /**
@@ -1047,6 +1229,41 @@ T createShard(
             DiscoveryNodes discoveryNodes
         ) throws IOException;
 
+        /**
+         * Create a batch of shards. In batch of shards mode, recovery steps are coordinated across
+         * shards.
+         *
+         * @param shardRoutings          batch of shards to be created
+         * @param parentShardId          source shard id to recover shards from
+         * @param inPlaceShardSplitRecoveryService  recovery service for in-place shard recovery
+         * @param recoveryListener       a callback when recovery changes state (finishes or fails)
+         * @param onShardFailure         a callback when this shard fails
+         * @param node                   node where in-place recovery is performed.
+         * @param request                Start recovery request of in-place shard split.
+         * @throws IOException if an I/O exception occurs when creating the shard
+         */
+        void createChildShardsForSplit(
+            List<ShardRouting> shardRoutings,
+            ShardId parentShardId,
+            InPlaceShardSplitRecoveryService inPlaceShardSplitRecoveryService,
+            InPlaceShardSplitRecoveryListener recoveryListener,
+            Consumer<IndexShard.ShardFailure> onShardFailure,
+            DiscoveryNode node,
+            Consumer<ShardId> globalCheckpointSyncer,
+            RetentionLeaseSyncer retentionLeaseSyncer,
+            SegmentReplicationCheckpointPublisher checkpointPublisher,
+            RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory,
+            StartRecoveryRequest request,
+            DiscoveryNodes discoveryNodes
+        ) throws IOException;
+
+        /**
+         * Start child shards in place of parent shard after replicas have started.
+         * @param parentShardId Shard ID of parent
+         * @param inPlaceShardSplitRecoveryService recovery service for in-place shard recovery
+         */
+        void moveChildShardsToStarted(ShardId parentShardId, InPlaceShardSplitRecoveryService inPlaceShardSplitRecoveryService);
+
         /**
          * Returns shard for the specified id if it exists otherwise returns <code>null</code>.
          */
diff --git a/server/src/main/java/org/opensearch/indices/recovery/LocalStorePeerRecoverySourceHandler.java b/server/src/main/java/org/opensearch/indices/recovery/LocalStorePeerRecoverySourceHandler.java
index 234e9ba66f340..44177e9dee1c7 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/LocalStorePeerRecoverySourceHandler.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/LocalStorePeerRecoverySourceHandler.java
@@ -16,6 +16,7 @@
 import org.opensearch.common.concurrent.GatedCloseable;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.CancellableThreads;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.index.engine.RecoveryEngineException;
 import org.opensearch.index.seqno.RetentionLease;
@@ -30,6 +31,7 @@
 
 import java.io.Closeable;
 import java.io.IOException;
+import java.util.List;
 import java.util.function.Consumer;
 
 /**
@@ -47,9 +49,28 @@ public LocalStorePeerRecoverySourceHandler(
         StartRecoveryRequest request,
         int fileChunkSizeInBytes,
         int maxConcurrentFileChunks,
-        int maxConcurrentOperations
+        int maxConcurrentOperations,
+        boolean skipSegmentFilesTransfer,
+        CancellableThreads cancellableThreads
     ) {
-        super(shard, recoveryTarget, threadPool, request, fileChunkSizeInBytes, maxConcurrentFileChunks, maxConcurrentOperations);
+        this(shard, recoveryTarget, threadPool, request, fileChunkSizeInBytes, maxConcurrentFileChunks, maxConcurrentOperations,
+            skipSegmentFilesTransfer, cancellableThreads, null);
+    }
+
+    public LocalStorePeerRecoverySourceHandler(
+        IndexShard shard,
+        RecoveryTargetHandler recoveryTarget,
+        ThreadPool threadPool,
+        StartRecoveryRequest request,
+        int fileChunkSizeInBytes,
+        int maxConcurrentFileChunks,
+        int maxConcurrentOperations,
+        boolean skipSegmentFilesTransfer,
+        CancellableThreads cancellableThreads,
+        IndexShard parentShard
+    ) {
+        super(shard, recoveryTarget, threadPool, request, fileChunkSizeInBytes, maxConcurrentFileChunks, maxConcurrentOperations,
+            skipSegmentFilesTransfer, cancellableThreads, parentShard);
     }
 
     @Override
@@ -83,7 +104,7 @@ && isTargetSameHistory()
 
         final StepListener<SendFileResult> sendFileStep = new StepListener<>();
         final StepListener<TimeValue> prepareEngineStep = new StepListener<>();
-        final StepListener<SendSnapshotResult> sendSnapshotStep = new StepListener<>();
+        final StepListener<List<SendSnapshotResult>> sendSnapshotStep = new StepListener<>();
 
         if (isSequenceNumberBasedRecovery) {
             logger.trace("performing sequence numbers based recovery. starting at [{}]", request.startingSeqNo());
@@ -122,31 +143,36 @@ && isTargetSameHistory()
                 onSendFileStepComplete(sendFileStep, wrappedSafeCommit, releaseStore);
 
                 final StepListener<ReplicationResponse> deleteRetentionLeaseStep = new StepListener<>();
-                RunUnderPrimaryPermit.run(() -> {
-                    try {
-                        // If the target previously had a copy of this shard then a file-based recovery might move its global
-                        // checkpoint backwards. We must therefore remove any existing retention lease so that we can create a
-                        // new one later on in the recovery.
-                        shard.removePeerRecoveryRetentionLease(
-                            request.targetNode().getId(),
-                            new ThreadedActionListener<>(
-                                logger,
-                                shard.getThreadPool(),
-                                ThreadPool.Names.GENERIC,
-                                deleteRetentionLeaseStep,
-                                false
-                            )
-                        );
-                    } catch (RetentionLeaseNotFoundException e) {
-                        logger.debug("no peer-recovery retention lease for " + request.targetAllocationId());
-                        deleteRetentionLeaseStep.onResponse(null);
-                    }
-                }, shardId + " removing retention lease for [" + request.targetAllocationId() + "]", shard, cancellableThreads, logger);
+                if (shard.routingEntry().isSplitTarget() == true) {
+                    // For the same reason above, we don't have any retention lease for a child primary to delete.
+                    deleteRetentionLeaseStep.onResponse(null);
+                } else {
+                    RunUnderPrimaryPermit.run(() -> {
+                        try {
+                            // If the target previously had a copy of this shard then a file-based recovery might move its global
+                            // checkpoint backwards. We must therefore remove any existing retention lease so that we can create a
+                            // new one later on in the recovery.
+                            shard.removePeerRecoveryRetentionLease(
+                                request.targetNode().getId(),
+                                new ThreadedActionListener<>(
+                                    logger,
+                                    shard.getThreadPool(),
+                                    ThreadPool.Names.GENERIC,
+                                    deleteRetentionLeaseStep,
+                                    false
+                                )
+                            );
+                        } catch (RetentionLeaseNotFoundException e) {
+                            logger.debug("no peer-recovery retention lease for " + request.targetAllocationId());
+                            deleteRetentionLeaseStep.onResponse(null);
+                        }
+                    }, shardId + " removing retention lease for [" + request.targetAllocationId() + "]", shard, cancellableThreads, logger);
+                }
 
                 deleteRetentionLeaseStep.whenComplete(ignored -> {
                     logger.debug("deleteRetentionLeaseStep completed");
                     assert Transports.assertNotTransportThread(this + "[phase1]");
-                    phase1(wrappedSafeCommit.get(), startingSeqNo, () -> estimateNumOps, sendFileStep, false);
+                    phase1(wrappedSafeCommit.get(), startingSeqNo, () -> estimateNumOps, sendFileStep, shouldSkipCreateRetentionLeaseStep());
                 }, onFailure);
 
             } catch (final Exception e) {
@@ -171,25 +197,21 @@ && isTargetSameHistory()
              * make sure to do this before sampling the max sequence number in the next step, to ensure that we send
              * all documents up to maxSeqNo in phase2.
              */
+            IndexShard primaryTracker = replicationTrackingShard();
             RunUnderPrimaryPermit.run(
-                () -> shard.initiateTracking(request.targetAllocationId()),
-                shardId + " initiating tracking of " + request.targetAllocationId(),
-                shard,
+                () -> primaryTracker.initiateTracking(request.targetAllocationId()),
+                primaryTracker.shardId() + " initiating tracking of " + request.targetAllocationId(),
+                primaryTracker,
                 cancellableThreads,
                 logger
             );
+            Thread.sleep(1000);
 
             final long endingSeqNo = shard.seqNoStats().getMaxSeqNo();
             if (logger.isTraceEnabled()) {
                 logger.trace("snapshot translog for recovery; current size is [{}]", countNumberOfHistoryOperations(startingSeqNo));
             }
-            final Translog.Snapshot phase2Snapshot = shard.newChangesSnapshot(
-                PEER_RECOVERY_NAME,
-                startingSeqNo,
-                Long.MAX_VALUE,
-                false,
-                true
-            );
+            final Translog.Snapshot phase2Snapshot = phase2Snapshot(startingSeqNo, PEER_RECOVERY_NAME);
             resources.add(phase2Snapshot);
             retentionLock.close();
 
@@ -199,6 +221,7 @@ && isTargetSameHistory()
             final long maxSeqNoOfUpdatesOrDeletes = shard.getMaxSeqNoOfUpdatesOrDeletes();
             final RetentionLeases retentionLeases = shard.getRetentionLeases();
             final long mappingVersionOnPrimary = shard.indexSettings().getIndexMetadata().getMappingVersion();
+            logger.info("Phase 1 completed till seq no. " + (startingSeqNo - 1) + " phase2 starting from seq no " + startingSeqNo + " and ending seq no " + endingSeqNo);
             phase2(
                 startingSeqNo,
                 endingSeqNo,
@@ -209,8 +232,39 @@ && isTargetSameHistory()
                 mappingVersionOnPrimary,
                 sendSnapshotStep
             );
-
         }, onFailure);
-        finalizeStepAndCompleteFuture(startingSeqNo, sendSnapshotStep, sendFileStep, prepareEngineStep, onFailure);
+        finalizeStepAndCompleteFuture(startingSeqNo, sendSnapshotStep, sendFileStep, prepareEngineStep, new StepListener<>(), onFailure);
+    }
+
+    /**
+     * Counts the number of history operations from the starting sequence number
+     *
+     * @param startingSeqNo the starting sequence number to count; included
+     * @return number of history operations
+     */
+    @Override
+    public int countNumberOfHistoryOperations(long startingSeqNo) throws IOException {
+        return shard.countNumberOfHistoryOperations(PEER_RECOVERY_NAME, startingSeqNo, Long.MAX_VALUE);
+    }
+
+    @Override
+    public Closeable acquireRetentionLock() {
+        return shard.acquireHistoryRetentionLock();
+    }
+
+    @Override
+    public Translog.Snapshot phase2Snapshot(long startingSeqNo, String recoveryName) throws IOException {
+        return shard.newChangesSnapshot(
+            recoveryName,
+            startingSeqNo,
+            Long.MAX_VALUE,
+            false,
+            true
+        );
+    }
+
+    @Override
+    public boolean shouldSkipCreateRetentionLeaseStep() {
+        return false;
     }
 }
diff --git a/server/src/main/java/org/opensearch/indices/recovery/PeerRecoverySourceService.java b/server/src/main/java/org/opensearch/indices/recovery/PeerRecoverySourceService.java
index 30f517fda9931..1804d4f977c31 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/PeerRecoverySourceService.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/PeerRecoverySourceService.java
@@ -48,6 +48,7 @@
 import org.opensearch.common.inject.Inject;
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.CancellableThreads;
 import org.opensearch.common.util.concurrent.FutureUtils;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.index.shard.ShardId;
@@ -55,6 +56,7 @@
 import org.opensearch.index.shard.IndexEventListener;
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.indices.IndicesService;
+import org.opensearch.indices.recovery.inplacesplit.InPlaceShardSplitRecoveryService;
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportChannel;
@@ -92,14 +94,17 @@ public static class Actions {
     private final TransportService transportService;
     private final IndicesService indicesService;
     private final RecoverySettings recoverySettings;
+    private final InPlaceShardSplitRecoveryService splitRecoveryService;
 
     final OngoingRecoveries ongoingRecoveries = new OngoingRecoveries();
 
     @Inject
-    public PeerRecoverySourceService(TransportService transportService, IndicesService indicesService, RecoverySettings recoverySettings) {
+    public PeerRecoverySourceService(TransportService transportService, IndicesService indicesService,
+                                     RecoverySettings recoverySettings, InPlaceShardSplitRecoveryService splitRecoveryService) {
         this.transportService = transportService;
         this.indicesService = indicesService;
         this.recoverySettings = recoverySettings;
+        this.splitRecoveryService = splitRecoveryService;
         // When the target node wants to start a peer recovery it sends a START_RECOVERY request to the source
         // node. Upon receiving START_RECOVERY, the source node will initiate the peer recovery.
         transportService.registerRequestHandler(
@@ -162,6 +167,19 @@ private void recover(StartRecoveryRequest request, ActionListener<RecoveryRespon
 
         final ShardRouting routingEntry = shard.routingEntry();
 
+        if (routingEntry.isSplitTarget()) {
+            ActionListener<Void> initiateRecoveryListener = ActionListener.delegateFailure(listener,
+                (ex, ignore) -> {
+                    logger.info("Initiating child replica recovery of shard [{}]", routingEntry.shardId());
+                    final IndexShard parentShard = indexService.getShard(routingEntry.getParentShardId().id());
+                    assert parentShard.getReplicationGroup().getInSyncAllocationIds().contains(routingEntry.allocationId().getId());
+                    initiateRecovery(request, shard, listener);
+                });
+            logger.info("Adding child replica recovery for node " + request.targetNode().getName() + " on parent shard node " + indicesService.clusterService().localNode().getName());
+            splitRecoveryService.addReplicaRecoveryAfterChildPrimariesSync(routingEntry.getParentShardId(), initiateRecoveryListener);
+            return;
+        }
+
         if (routingEntry.primary() == false || routingEntry.active() == false) {
             throw new DelayRecoveryException("source shard [" + routingEntry + "] is not an active primary");
         }
@@ -176,6 +194,10 @@ private void recover(StartRecoveryRequest request, ActionListener<RecoveryRespon
             throw new DelayRecoveryException("source shard is not marked yet as relocating to [" + request.targetNode() + "]");
         }
 
+        initiateRecovery(request, shard, listener);
+    }
+
+    private void initiateRecovery(StartRecoveryRequest request, IndexShard shard, ActionListener<RecoveryResponse> listener) {
         RecoverySourceHandler handler = ongoingRecoveries.addNewRecovery(request, shard);
         logger.trace(
             "[{}][{}] starting recovery to {}",
@@ -379,7 +401,13 @@ private Tuple<RecoverySourceHandler, RemoteRecoveryTargetHandler> createRecovery
                     throttleTime -> shard.recoveryStats().addThrottleTime(throttleTime),
                     shard.isRemoteTranslogEnabled() || request.targetNode().isRemoteStoreNode()
                 );
-                handler = RecoverySourceHandlerFactory.create(shard, recoveryTarget, request, recoverySettings);
+                IndexShard parentShard = null;
+                if (shard.routingEntry().isSplitTarget()) {
+                    parentShard = indicesService.getShardOrNull(shard.getParentShardId());
+                    assert parentShard != null;
+                }
+                handler = RecoverySourceHandlerFactory.create(shard, recoveryTarget, request, recoverySettings, false,
+                    new CancellableThreads(), parentShard);
                 return Tuple.tuple(handler, recoveryTarget);
             }
         }
diff --git a/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java b/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
index d746aaa2a0783..8582eba45189b 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
@@ -246,7 +246,7 @@ private void doRecovery(final long recoveryId, final StartRecoveryRequest preExi
                     logger.trace("{} preparing shard for peer recovery", recoveryTarget.shardId());
                     indexShard.prepareForIndexRecovery();
                     final boolean hasRemoteSegmentStore = indexShard.indexSettings().isRemoteStoreEnabled();
-                    if (hasRemoteSegmentStore || indexShard.isRemoteSeeded()) {
+                    if (hasRemoteSegmentStore && !indexShard.routingEntry().isSplitTarget() || indexShard.isRemoteSeeded()) {
                         // ToDo: This is a temporary mitigation to not fail the peer recovery flow in case there is
                         // an exception while downloading segments from remote store. For remote backed indexes, we
                         // plan to revamp this flow so that node-node segment copy will not happen.
@@ -386,7 +386,8 @@ public static StartRecoveryRequest getStartRecoveryRequest(
             metadataSnapshot,
             recoveryTarget.state().getPrimary(),
             recoveryTarget.getId(),
-            startingSeqNo
+            startingSeqNo,
+            null
         );
         return request;
     }
diff --git a/server/src/main/java/org/opensearch/indices/recovery/RecoveryResponse.java b/server/src/main/java/org/opensearch/indices/recovery/RecoveryResponse.java
index c1203a9f4939f..35b1730d163a5 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/RecoveryResponse.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/RecoveryResponse.java
@@ -115,4 +115,20 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeVInt(phase2Operations);
         out.writeVLong(phase2Time);
     }
+
+    public int getPhase2Operations() {
+        return phase2Operations;
+    }
+
+    public long getStartTime() {
+        return startTime;
+    }
+
+    public long getPhase2Time() {
+        return phase2Time;
+    }
+
+    public long getPhase1Time() {
+        return phase1Time;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/indices/recovery/RecoverySourceHandler.java b/server/src/main/java/org/opensearch/indices/recovery/RecoverySourceHandler.java
index 7aa90d2f9fa3e..72929bc856b98 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/RecoverySourceHandler.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/RecoverySourceHandler.java
@@ -62,6 +62,7 @@
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.unit.ByteSizeValue;
+import org.opensearch.index.engine.Engine;
 import org.opensearch.index.engine.RecoveryEngineException;
 import org.opensearch.index.seqno.ReplicationTracker;
 import org.opensearch.index.seqno.RetentionLease;
@@ -82,9 +83,11 @@
 import java.io.Closeable;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.Iterator;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.concurrent.CopyOnWriteArrayList;
@@ -114,39 +117,49 @@ public abstract class RecoverySourceHandler {
     protected final Logger logger;
     // Shard that is going to be recovered (the "source")
     protected final IndexShard shard;
-    protected final int shardId;
+    protected final Integer shardId;
     // Request containing source and target node information
     protected final StartRecoveryRequest request;
     private final int chunkSizeInBytes;
-    private final RecoveryTargetHandler recoveryTarget;
+    protected final RecoveryTargetHandler recoveryTarget;
     private final int maxConcurrentOperations;
     private final ThreadPool threadPool;
-    protected final CancellableThreads cancellableThreads = new CancellableThreads();
+    protected final CancellableThreads cancellableThreads;
     protected final List<Closeable> resources = new CopyOnWriteArrayList<>();
+    private final Closeable resourcesReleasable;
     protected final ListenableFuture<RecoveryResponse> future = new ListenableFuture<>();
     public static final String PEER_RECOVERY_NAME = "peer-recovery";
     private final SegmentFileTransferHandler transferHandler;
+    protected final IndexShard parentShard;
 
-    RecoverySourceHandler(
+    protected RecoverySourceHandler(
         IndexShard shard,
         RecoveryTargetHandler recoveryTarget,
         ThreadPool threadPool,
         StartRecoveryRequest request,
         int fileChunkSizeInBytes,
         int maxConcurrentFileChunks,
-        int maxConcurrentOperations
+        int maxConcurrentOperations,
+        boolean skipSegmentFilesTransfer,
+        CancellableThreads cancellableThreads,
+        IndexShard parentShard
     ) {
+        this.cancellableThreads = cancellableThreads;
         this.logger = Loggers.getLogger(RecoverySourceHandler.class, request.shardId(), "recover to " + request.targetNode().getName());
-        this.transferHandler = new SegmentFileTransferHandler(
-            shard,
-            request.targetNode(),
-            recoveryTarget,
-            logger,
-            threadPool,
-            cancellableThreads,
-            fileChunkSizeInBytes,
-            maxConcurrentFileChunks
-        );
+        if (skipSegmentFilesTransfer == false) {
+            this.transferHandler = new SegmentFileTransferHandler(
+                shard,
+                request.targetNode(),
+                recoveryTarget,
+                logger,
+                threadPool,
+                cancellableThreads,
+                fileChunkSizeInBytes,
+                maxConcurrentFileChunks
+            );
+        } else {
+            this.transferHandler = null;
+        }
         this.shard = shard;
         this.threadPool = threadPool;
         this.request = request;
@@ -155,6 +168,11 @@ public abstract class RecoverySourceHandler {
         this.chunkSizeInBytes = fileChunkSizeInBytes;
         // if the target is on an old version, it won't be able to handle out-of-order file chunks.
         this.maxConcurrentOperations = maxConcurrentOperations;
+        this.resourcesReleasable = () -> {
+            resources.addAll(getAdditionalResourcesToClose());
+            IOUtils.close(resources);
+        };
+        this.parentShard = parentShard;
     }
 
     public StartRecoveryRequest getRequest() {
@@ -170,7 +188,6 @@ public void addListener(ActionListener<RecoveryResponse> listener) {
      */
     public void recoverToTarget(ActionListener<RecoveryResponse> listener) {
         addListener(listener);
-        final Closeable releaseResources = () -> IOUtils.close(resources);
         try {
             cancellableThreads.setOnCancel((reason, beforeCancelEx) -> {
                 final RuntimeException e;
@@ -182,19 +199,35 @@ public void recoverToTarget(ActionListener<RecoveryResponse> listener) {
                 if (beforeCancelEx != null) {
                     e.addSuppressed(beforeCancelEx);
                 }
-                IOUtils.closeWhileHandlingException(releaseResources, () -> future.onFailure(e));
+                IOUtils.closeWhileHandlingException(resourcesReleasable, () -> future.onFailure(e));
                 throw e;
             });
             final Consumer<Exception> onFailure = e -> {
+                e.printStackTrace();
                 assert Transports.assertNotTransportThread(this + "[onFailure]");
-                IOUtils.closeWhileHandlingException(releaseResources, () -> future.onFailure(e));
+                IOUtils.closeWhileHandlingException(resourcesReleasable, () -> future.onFailure(e));
             };
             innerRecoveryToTarget(listener, onFailure);
         } catch (Exception e) {
-            IOUtils.closeWhileHandlingException(releaseResources, () -> future.onFailure(e));
+            IOUtils.closeWhileHandlingException(resourcesReleasable, () -> future.onFailure(e));
         }
     }
 
+    protected IndexShard replicationTrackingShard() {
+        if (shard.routingEntry().isSplitTarget() == false) {
+            return shard;
+        }
+        return parentShard;
+    }
+
+    public List<Closeable> getAdditionalResourcesToClose() {
+        return new ArrayList<>();
+    }
+
+    public List<Closeable> getResources() {
+        return Collections.unmodifiableList(resources);
+    }
+
     protected abstract void innerRecoveryToTarget(ActionListener<RecoveryResponse> listener, Consumer<Exception> onFailure)
         throws IOException;
 
@@ -202,6 +235,11 @@ protected abstract void innerRecoveryToTarget(ActionListener<RecoveryResponse> l
     Waits for cluster state propagation of assignment of replica on the target node
      */
     void waitForAssignmentPropagate(SetOnce<RetentionLease> retentionLeaseRef) {
+        // We neither add retention lease on child primary nor it is available. This is because we never resume
+        // peer recovery and always start again from the beginning in case of failure.
+        if (shard.routingEntry().isSplitTarget() == true) {
+            return;
+        }
         BackoffPolicy EXPONENTIAL_BACKOFF_POLICY = BackoffPolicy.exponentialBackoff(TimeValue.timeValueMillis(1000), 5);
         AtomicReference<ShardRouting> targetShardRouting = new AtomicReference<>();
         Iterator<TimeValue> backoffDelayIterator = EXPONENTIAL_BACKOFF_POLICY.iterator();
@@ -244,23 +282,28 @@ void waitForAssignmentPropagate(SetOnce<RetentionLease> retentionLeaseRef) {
 
     protected void finalizeStepAndCompleteFuture(
         long startingSeqNo,
-        StepListener<SendSnapshotResult> sendSnapshotStep,
+        StepListener<List<SendSnapshotResult>> sendSnapshotStep,
         StepListener<SendFileResult> sendFileStep,
         StepListener<TimeValue> prepareEngineStep,
+        StepListener<Void> finalizeStep,
         Consumer<Exception> onFailure
     ) {
-        final StepListener<Void> finalizeStep = new StepListener<>();
         // Recovery target can trim all operations >= startingSeqNo as we have sent all these operations in the phase 2
         final long trimAboveSeqNo = startingSeqNo - 1;
-        sendSnapshotStep.whenComplete(r -> {
-            logger.debug("sendSnapshotStep completed");
-            finalizeRecovery(r.targetLocalCheckpoint, trimAboveSeqNo, finalizeStep);
+        sendSnapshotStep.whenComplete(sendSnapshotResult -> {
+            logger.info("sendSnapshotStep completed");
+            finalizeRecovery(sendSnapshotResult, trimAboveSeqNo, finalizeStep);
         }, onFailure);
 
         finalizeStep.whenComplete(r -> {
-            logger.debug("finalizeStep completed");
+            logger.info("finalizeStep completed");
             final long phase1ThrottlingWaitTime = 0L; // TODO: return the actual throttle time
-            final SendSnapshotResult sendSnapshotResult = sendSnapshotStep.result();
+            int sentOperations = 0;
+            long tookTime = 0;
+            for (SendSnapshotResult sendSnapshotResult : sendSnapshotStep.result()) {
+                sentOperations += sendSnapshotResult.sentOperations;
+                tookTime += sendSnapshotResult.tookTime.millis();
+            }
             final SendFileResult sendFileResult = sendFileStep.result();
             final RecoveryResponse response = new RecoveryResponse(
                 sendFileResult.phase1FileNames,
@@ -272,13 +315,13 @@ protected void finalizeStepAndCompleteFuture(
                 sendFileResult.took.millis(),
                 phase1ThrottlingWaitTime,
                 prepareEngineStep.result().millis(),
-                sendSnapshotResult.sentOperations,
-                sendSnapshotResult.tookTime.millis()
+                sentOperations,
+                tookTime
             );
             try {
                 future.onResponse(response);
             } finally {
-                IOUtils.close(resources);
+                resourcesReleasable.close();
             }
         }, onFailure);
     }
@@ -312,9 +355,7 @@ protected boolean isTargetSameHistory() {
      * @param startingSeqNo the starting sequence number to count; included
      * @return number of history operations
      */
-    protected int countNumberOfHistoryOperations(long startingSeqNo) throws IOException {
-        return shard.countNumberOfHistoryOperations(PEER_RECOVERY_NAME, startingSeqNo, Long.MAX_VALUE);
-    }
+    public abstract int countNumberOfHistoryOperations(long startingSeqNo) throws IOException;
 
     /**
      * Increases the store reference and returns a {@link Releasable} that will decrease the store reference using the generic thread pool.
@@ -340,7 +381,17 @@ protected GatedCloseable<IndexCommit> acquireSafeCommit(IndexShard shard) {
         });
     }
 
-    private void runWithGenericThreadPool(CheckedRunnable<Exception> task) {
+    protected GatedCloseable<IndexCommit> acquireLastCommit(IndexShard shard, boolean flushFirst) {
+        final GatedCloseable<IndexCommit> wrappedSafeCommit = shard.acquireLastIndexCommit(flushFirst);
+        final AtomicBoolean closed = new AtomicBoolean(false);
+        return new GatedCloseable<>(wrappedSafeCommit.get(), () -> {
+            if (closed.compareAndSet(false, true)) {
+                runWithGenericThreadPool(wrappedSafeCommit::close);
+            }
+        });
+    }
+
+    protected void runWithGenericThreadPool(CheckedRunnable<Exception> task) {
         final PlainActionFuture<Void> future = new PlainActionFuture<>();
         assert threadPool.generic().isShutdown() == false;
         // TODO: We shouldn't use the generic thread pool here as we already execute this from the generic pool.
@@ -355,7 +406,7 @@ private void runWithGenericThreadPool(CheckedRunnable<Exception> task) {
      *
      * @opensearch.internal
      */
-    static final class SendFileResult {
+    public static final class SendFileResult {
         final List<String> phase1FileNames;
         final List<Long> phase1FileSizes;
         final long totalSize;
@@ -366,7 +417,7 @@ static final class SendFileResult {
 
         final TimeValue took;
 
-        SendFileResult(
+        public SendFileResult(
             List<String> phase1FileNames,
             List<Long> phase1FileSizes,
             long totalSize,
@@ -395,6 +446,11 @@ static final class SendFileResult {
         );
     }
 
+    public abstract Closeable acquireRetentionLock();
+
+    public abstract Translog.Snapshot phase2Snapshot(long startingSeqNo, String recoveryName) throws IOException;
+    public abstract boolean shouldSkipCreateRetentionLeaseStep();
+
     /**
      * Perform phase1 of the recovery operations. Once this {@link IndexCommit}
      * snapshot has been performed no commit operations (files being fsync'd)
@@ -404,7 +460,7 @@ static final class SendFileResult {
      * segments that are missing. Only segments that have the same size and
      * checksum can be reused
      */
-    void phase1(
+    protected void phase1(
         IndexCommit snapshot,
         long startingSeqNo,
         IntSupplier translogOps,
@@ -505,7 +561,7 @@ void phase1(
 
                 sendFileInfoStep.whenComplete(r -> {
                     logger.debug("sendFileInfoStep completed");
-                    sendFiles(store, phase1Files.toArray(new StoreFileMetadata[0]), translogOps, sendFilesStep);
+                    sendFiles(store, phase1Files.toArray(new StoreFileMetadata[0]), translogOps, sendFilesStep, snapshot);
                 }, listener::onFailure);
 
                 // When doing peer recovery of remote store enabled replica, retention leases are not required.
@@ -514,6 +570,12 @@ void phase1(
                         logger.debug("sendFilesStep completed");
                         createRetentionLeaseStep.onResponse(null);
                     }, listener::onFailure);
+                } else if (shard.routingEntry().isSplitTarget() == true) {
+                    sendFilesStep.whenComplete(r -> {
+                        logger.debug("sendFilesStep completed");
+                        addRetentionLeaseForChildReplica(startingSeqNo);
+                        createRetentionLeaseStep.onResponse(null);
+                    }, listener::onFailure);
                 } else {
                     sendFilesStep.whenComplete(r -> {
                         logger.debug("sendFilesStep completed");
@@ -578,7 +640,8 @@ void phase1(
         }
     }
 
-    void sendFiles(Store store, StoreFileMetadata[] files, IntSupplier translogOps, ActionListener<Void> listener) {
+    protected void sendFiles(Store store, StoreFileMetadata[] files, IntSupplier translogOps, ActionListener<Void> listener,
+                             IndexCommit snapshot) {
         final MultiChunkTransfer<StoreFileMetadata, SegmentFileTransferHandler.FileChunk> transfer = transferHandler.createTransfer(
             store,
             files,
@@ -631,6 +694,28 @@ void createRetentionLease(final long startingSeqNo, ActionListener<RetentionLeas
         }, shardId + " establishing retention lease for [" + request.targetAllocationId() + "]", shard, cancellableThreads, logger);
     }
 
+    private void addRetentionLeaseForChildReplica(long startingSeqNo) {
+        // Add a retention release on this child primary for the corresponding recovering child replica.
+        assert shard.routingEntry().primary() == true;
+        RetentionLeases retentionLeases = shard.getRetentionLeases();
+        RetentionLease retentionLease = new RetentionLease(
+            ReplicationTracker.getPeerRecoveryRetentionLeaseId(request.targetNode().getId()),
+            startingSeqNo,
+            shard.getThreadPool().absoluteTimeInMillis(),
+            ReplicationTracker.PEER_RECOVERY_RETENTION_LEASE_SOURCE
+        );
+        assert retentionLeases.equals(RetentionLeases.EMPTY) == false;
+        Collection<RetentionLease> curLeases = retentionLeases.leases();
+        Collection<RetentionLease> updatedLeases = new ArrayList<>(curLeases);
+        updatedLeases.add(retentionLease);
+
+        // Primary mode on replication tracker of child primary will also be false and hence,
+        // we need to update retention leases as replica.
+        shard.updateRetentionLeasesOnChildPrimary(new RetentionLeases(
+            retentionLeases.primaryTerm(), retentionLeases.version() + 1, updatedLeases
+        ));
+    }
+
     boolean canSkipPhase1(Store.MetadataSnapshot source, Store.MetadataSnapshot target) {
         if (source.getSyncId() == null || source.getSyncId().equals(target.getSyncId()) == false) {
             return false;
@@ -668,7 +753,7 @@ boolean canSkipPhase1(Store.MetadataSnapshot source, Store.MetadataSnapshot targ
         return true;
     }
 
-    void prepareTargetForTranslog(int totalTranslogOps, ActionListener<TimeValue> listener) {
+    protected void prepareTargetForTranslog(int totalTranslogOps, ActionListener<TimeValue> listener) {
         StopWatch stopWatch = new StopWatch().start();
         final ActionListener<Void> wrappedListener = ActionListener.wrap(nullVal -> {
             stopWatch.stop();
@@ -698,7 +783,7 @@ void prepareTargetForTranslog(int totalTranslogOps, ActionListener<TimeValue> li
      * @param maxSeqNoOfUpdatesOrDeletes the max seq_no of updates or deletes on the primary after these operations were executed on it.
      * @param listener                   a listener which will be notified with the local checkpoint on the target.
      */
-    void phase2(
+    protected void phase2(
         final long startingSeqNo,
         final long endingSeqNo,
         final Translog.Snapshot snapshot,
@@ -706,7 +791,7 @@ void phase2(
         final long maxSeqNoOfUpdatesOrDeletes,
         final RetentionLeases retentionLeases,
         final long mappingVersion,
-        final ActionListener<SendSnapshotResult> listener
+        final ActionListener<List<SendSnapshotResult>> listener
     ) throws IOException {
         if (shard.state() == IndexShardState.CLOSED) {
             throw new IndexShardClosedException(request.shardId());
@@ -714,20 +799,11 @@ void phase2(
         logger.trace("recovery [phase2]: sending transaction log operations (from [" + startingSeqNo + "] to [" + endingSeqNo + "]");
         final StopWatch stopWatch = new StopWatch().start();
         final StepListener<Void> sendListener = new StepListener<>();
-        final OperationBatchSender sender = new OperationBatchSender(
-            startingSeqNo,
-            endingSeqNo,
-            snapshot,
-            maxSeenAutoIdTimestamp,
-            maxSeqNoOfUpdatesOrDeletes,
-            retentionLeases,
-            mappingVersion,
-            sendListener
-        );
+        final OperationBatchSender sender = createSender(startingSeqNo, endingSeqNo, snapshot, maxSeenAutoIdTimestamp,
+            maxSeqNoOfUpdatesOrDeletes, retentionLeases, mappingVersion, sendListener);
         sendListener.whenComplete(ignored -> {
             final long skippedOps = sender.skippedOps.get();
             final int totalSentOps = sender.sentOps.get();
-            final long targetLocalCheckpoint = sender.targetLocalCheckpoint.get();
             assert snapshot.totalOperations() == snapshot.skippedOperations() + skippedOps + totalSentOps : String.format(
                 Locale.ROOT,
                 "expected total [%d], overridden [%d], skipped [%d], total sent [%d]",
@@ -739,17 +815,47 @@ void phase2(
             stopWatch.stop();
             final TimeValue tookTime = stopWatch.totalTime();
             logger.trace("recovery [phase2]: took [{}]", tookTime);
-            listener.onResponse(new SendSnapshotResult(targetLocalCheckpoint, totalSentOps, tookTime));
+            listener.onResponse(createSnapshotResult(sender, totalSentOps, tookTime));
         }, listener::onFailure);
         sender.start();
     }
 
+    protected OperationBatchSender createSender(
+        final long startingSeqNo,
+        final long endingSeqNo,
+        final Translog.Snapshot snapshot,
+        final long maxSeenAutoIdTimestamp,
+        final long maxSeqNoOfUpdatesOrDeletes,
+        final RetentionLeases retentionLeases,
+        final long mappingVersion,
+        StepListener<Void> sendListener
+    ) {
+        return new OperationBatchSender(
+            startingSeqNo,
+            endingSeqNo,
+            snapshot,
+            maxSeenAutoIdTimestamp,
+            maxSeqNoOfUpdatesOrDeletes,
+            retentionLeases,
+            mappingVersion,
+            sendListener,
+            replicationTrackingShard() == parentShard
+        );
+    }
+
+    protected List<SendSnapshotResult> createSnapshotResult(OperationBatchSender sender, int totalSentOps,
+                                                            TimeValue tookTime) {
+        final long targetLocalCheckpoint = sender.targetLocalCheckpoint.get();
+        return List.of(new SendSnapshotResult(targetLocalCheckpoint, totalSentOps,
+                tookTime, request.targetAllocationId()));
+    }
+
     /**
      * An operation chunk request
      *
      * @opensearch.internal
      */
-    private static class OperationChunkRequest implements MultiChunkTransfer.ChunkRequest {
+    protected static class OperationChunkRequest implements MultiChunkTransfer.ChunkRequest {
         final List<Translog.Operation> operations;
         final boolean lastChunk;
 
@@ -762,22 +868,28 @@ private static class OperationChunkRequest implements MultiChunkTransfer.ChunkRe
         public boolean lastChunk() {
             return lastChunk;
         }
+
+        public List<Translog.Operation> getOperations() {
+            return operations;
+        }
     }
 
-    private class OperationBatchSender extends MultiChunkTransfer<Translog.Snapshot, OperationChunkRequest> {
-        private final long startingSeqNo;
-        private final long endingSeqNo;
-        private final Translog.Snapshot snapshot;
-        private final long maxSeenAutoIdTimestamp;
-        private final long maxSeqNoOfUpdatesOrDeletes;
-        private final RetentionLeases retentionLeases;
-        private final long mappingVersion;
+    protected class OperationBatchSender extends MultiChunkTransfer<Translog.Snapshot, OperationChunkRequest> {
+        protected final long startingSeqNo;
+        protected final long endingSeqNo;
+        private long lastSeenSeqNo;
+        protected final Translog.Snapshot snapshot;
+        protected final long maxSeenAutoIdTimestamp;
+        protected final long maxSeqNoOfUpdatesOrDeletes;
+        protected final RetentionLeases retentionLeases;
+        protected final long mappingVersion;
         private int lastBatchCount = 0; // used to estimate the count of the subsequent batch.
         private final AtomicInteger skippedOps = new AtomicInteger();
         private final AtomicInteger sentOps = new AtomicInteger();
         private final AtomicLong targetLocalCheckpoint = new AtomicLong(SequenceNumbers.NO_OPS_PERFORMED);
+        private final boolean fillMissingSeqNos;
 
-        OperationBatchSender(
+        protected OperationBatchSender(
             long startingSeqNo,
             long endingSeqNo,
             Translog.Snapshot snapshot,
@@ -785,7 +897,8 @@ private class OperationBatchSender extends MultiChunkTransfer<Translog.Snapshot,
             long maxSeqNoOfUpdatesOrDeletes,
             RetentionLeases retentionLeases,
             long mappingVersion,
-            ActionListener<Void> listener
+            ActionListener<Void> listener,
+            boolean fillMissingSeqNos
         ) {
             super(logger, threadPool.getThreadContext(), listener, maxConcurrentOperations, Collections.singletonList(snapshot));
             this.startingSeqNo = startingSeqNo;
@@ -795,6 +908,8 @@ private class OperationBatchSender extends MultiChunkTransfer<Translog.Snapshot,
             this.maxSeqNoOfUpdatesOrDeletes = maxSeqNoOfUpdatesOrDeletes;
             this.retentionLeases = retentionLeases;
             this.mappingVersion = mappingVersion;
+            this.fillMissingSeqNos = fillMissingSeqNos;
+            this.lastSeenSeqNo = startingSeqNo - 1;
         }
 
         @Override
@@ -815,7 +930,9 @@ protected synchronized OperationChunkRequest nextChunkRequest(Translog.Snapshot
                     skippedOps.incrementAndGet();
                     continue;
                 }
+                fillMissingSeqNos(operation, ops);
                 ops.add(operation);
+                lastSeenSeqNo = operation.seqNo();
                 batchSizeInBytes += operation.estimateSize();
                 sentOps.incrementAndGet();
 
@@ -825,15 +942,40 @@ protected synchronized OperationChunkRequest nextChunkRequest(Translog.Snapshot
                 }
             }
             lastBatchCount = ops.size();
+            fillMissingSeqNos(operation, ops);
             return new OperationChunkRequest(ops, operation == null);
         }
 
+        /**
+         * Needed in recovery of child replica where recovering replica may not find all consecutive operations on
+         * their primary child counterparts.
+         */
+        private void fillMissingSeqNos(Translog.Operation op, List<Translog.Operation> ops) {
+            if (fillMissingSeqNos == false) {
+                return;
+            }
+
+            if (op == null) {
+                for (long seqNo = lastSeenSeqNo + 1; seqNo <= endingSeqNo; seqNo++) {
+                    ops.add(new Translog.NoOp(seqNo, shard.getOperationPrimaryTerm(), Translog.NoOp.FILLING_GAPS));
+                }
+            } else {
+                final long expectedSeqNo = lastSeenSeqNo + 1;
+                if (op.seqNo() != expectedSeqNo) {
+                    for (long seqNo = expectedSeqNo; seqNo < op.seqNo(); seqNo++) {
+                        ops.add(new Translog.NoOp(seqNo, shard.getOperationPrimaryTerm(), Translog.NoOp.FILLING_GAPS));
+                    }
+                }
+            }
+        }
+
         @Override
         protected void executeChunkRequest(OperationChunkRequest request, ActionListener<Void> listener) {
             cancellableThreads.checkForCancel();
+            int totalOperations = fillMissingSeqNos ? (int) (endingSeqNo - startingSeqNo + 1) : snapshot.totalOperations();
             recoveryTarget.indexTranslogOperations(
                 request.operations,
-                snapshot.totalOperations(),
+                totalOperations,
                 maxSeenAutoIdTimestamp,
                 maxSeqNoOfUpdatesOrDeletes,
                 retentionLeases,
@@ -856,41 +998,26 @@ public void close() throws IOException {
         }
     }
 
-    void finalizeRecovery(long targetLocalCheckpoint, long trimAboveSeqNo, ActionListener<Void> listener) throws IOException {
+    void finalizeRecovery(List<SendSnapshotResult> sendSnapshotResults, long trimAboveSeqNo, ActionListener<Void> listener) throws IOException {
         if (shard.state() == IndexShardState.CLOSED) {
             throw new IndexShardClosedException(request.shardId());
         }
         cancellableThreads.checkForCancel();
         StopWatch stopWatch = new StopWatch().start();
-        logger.trace("finalizing recovery");
-        /*
-         * Before marking the shard as in-sync we acquire an operation permit. We do this so that there is a barrier between marking a
-         * shard as in-sync and relocating a shard. If we acquire the permit then no relocation handoff can complete before we are done
-         * marking the shard as in-sync. If the relocation handoff holds all the permits then after the handoff completes and we acquire
-         * the permit then the state of the shard will be relocated and this recovery will fail.
-         */
-        RunUnderPrimaryPermit.run(
-            () -> shard.markAllocationIdAsInSync(request.targetAllocationId(), targetLocalCheckpoint),
-            shardId + " marking " + request.targetAllocationId() + " as in sync",
-            shard,
-            cancellableThreads,
-            logger
-        );
+        markAllocationIdAsInSync(sendSnapshotResults);
+        finalizeRecovery(stopWatch, trimAboveSeqNo, listener);
+    }
+
+    protected void finalizeRecovery(StopWatch stopWatch, long trimAboveSeqNo, ActionListener<Void> listener) {
         final long globalCheckpoint = shard.getLastKnownGlobalCheckpoint(); // this global checkpoint is persisted in finalizeRecovery
         final StepListener<Void> finalizeListener = new StepListener<>();
         cancellableThreads.checkForCancel();
         recoveryTarget.finalizeRecovery(globalCheckpoint, trimAboveSeqNo, finalizeListener);
         finalizeListener.whenComplete(r -> {
-            logger.debug("finalizeListenerStep completed");
-            RunUnderPrimaryPermit.run(
-                () -> shard.updateGlobalCheckpointForShard(request.targetAllocationId(), globalCheckpoint),
-                shardId + " updating " + request.targetAllocationId() + "'s global checkpoint",
-                shard,
-                cancellableThreads,
-                logger
-            );
+            logger.info("finalizeListenerStep completed");
+            updateGlobalCheckpointForShard(globalCheckpoint);
 
-            if (request.isPrimaryRelocation()) {
+            if (request.isPrimaryRelocation() || shard.routingEntry().splitting()) {
                 logger.trace("performing relocation hand-off");
                 final Runnable forceSegRepRunnable = shard.indexSettings().isSegRepEnabledOrRemoteNode()
                     || (request.sourceNode().isRemoteStoreNode() && request.targetNode().isRemoteStoreNode())
@@ -900,7 +1027,7 @@ void finalizeRecovery(long targetLocalCheckpoint, long trimAboveSeqNo, ActionLis
                 // TODO: make relocated async
                 // this acquires all IndexShard operation permits and will thus delay new recoveries until it is done
                 cancellableThreads.execute(
-                    () -> shard.relocated(request.targetAllocationId(), recoveryTarget::handoffPrimaryContext, forceSegRepRunnable)
+                    () -> relocateShard(forceSegRepRunnable)
                 );
                 /*
                  * if the recovery process fails after disabling primary mode on the source shard, both relocation source and
@@ -918,20 +1045,59 @@ void finalizeRecovery(long targetLocalCheckpoint, long trimAboveSeqNo, ActionLis
         }, listener::onFailure);
     }
 
+    protected void markAllocationIdAsInSync(List<SendSnapshotResult> sendSnapshotResults) {
+        /*
+         * Before marking the shard as in-sync we acquire an operation permit. We do this so that there is a barrier between marking a
+         * shard as in-sync and relocating a shard. If we acquire the permit then no relocation handoff can complete before we are done
+         * marking the shard as in-sync. If the relocation handoff holds all the permits then after the handoff completes and we acquire
+         * the permit then the state of the shard will be relocated and this recovery will fail.
+         */
+        sendSnapshotResults.forEach(snapshotResult -> {
+            IndexShard primaryTracker = replicationTrackingShard();
+            RunUnderPrimaryPermit.run(
+                () -> primaryTracker.markAllocationIdAsInSync(snapshotResult.targetAllocationId, snapshotResult.targetLocalCheckpoint),
+                primaryTracker.shardId() + " marking " + snapshotResult.targetAllocationId+ " as in sync",
+                primaryTracker,
+                cancellableThreads,
+                logger
+            );
+        });
+
+    }
+
+    protected void updateGlobalCheckpointForShard(long globalCheckpoint) {
+        IndexShard primaryTracker = replicationTrackingShard();
+        RunUnderPrimaryPermit.run(
+            () -> primaryTracker.updateGlobalCheckpointForShard(request.targetAllocationId(), globalCheckpoint),
+            primaryTracker.shardId() + " updating " + request.targetAllocationId() + "'s global checkpoint",
+            primaryTracker,
+            cancellableThreads,
+            logger
+        );
+    }
+
+    protected void relocateShard(Runnable forceSegRepRunnable) throws InterruptedException {
+        shard.relocated(new HashSet<>(Collections.singletonList(request.targetAllocationId())),
+            recoveryTarget::handoffPrimaryContext, forceSegRepRunnable);
+    }
+
     /**
      * A result for a send snapshot
      *
      * @opensearch.internal
      */
-    static final class SendSnapshotResult {
+    public static final class SendSnapshotResult {
         final long targetLocalCheckpoint;
         final int sentOperations;
         final TimeValue tookTime;
+        final String targetAllocationId;
 
-        SendSnapshotResult(final long targetLocalCheckpoint, final int sentOperations, final TimeValue tookTime) {
+        public SendSnapshotResult(final long targetLocalCheckpoint, final int sentOperations, final TimeValue tookTime,
+                           final String targetAllocationId) {
             this.targetLocalCheckpoint = targetLocalCheckpoint;
             this.sentOperations = sentOperations;
             this.tookTime = tookTime;
+            this.targetAllocationId = targetAllocationId;
         }
     }
 
@@ -955,7 +1121,7 @@ public String toString() {
             + '}';
     }
 
-    private void cleanFiles(
+    protected void cleanFiles(
         Store store,
         Store.MetadataSnapshot sourceMetadata,
         IntSupplier translogOps,
diff --git a/server/src/main/java/org/opensearch/indices/recovery/RecoverySourceHandlerFactory.java b/server/src/main/java/org/opensearch/indices/recovery/RecoverySourceHandlerFactory.java
index 96e85154e6248..8a63f31e66561 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/RecoverySourceHandlerFactory.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/RecoverySourceHandlerFactory.java
@@ -8,6 +8,7 @@
 
 package org.opensearch.indices.recovery;
 
+import org.opensearch.common.util.CancellableThreads;
 import org.opensearch.index.shard.IndexShard;
 
 /**
@@ -21,7 +22,10 @@ public static RecoverySourceHandler create(
         IndexShard shard,
         RecoveryTargetHandler recoveryTarget,
         StartRecoveryRequest request,
-        RecoverySettings recoverySettings
+        RecoverySettings recoverySettings,
+        boolean skipSegmentFilesTransfer,
+        CancellableThreads cancellableThreads,
+        IndexShard parentShard
     ) {
         boolean isReplicaRecoveryWithRemoteTranslog = request.isPrimaryRelocation() == false && request.targetNode().isRemoteStoreNode();
         if (isReplicaRecoveryWithRemoteTranslog) {
@@ -32,7 +36,10 @@ public static RecoverySourceHandler create(
                 request,
                 Math.toIntExact(recoverySettings.getChunkSize().getBytes()),
                 recoverySettings.getMaxConcurrentFileChunks(),
-                recoverySettings.getMaxConcurrentOperations()
+                recoverySettings.getMaxConcurrentOperations(),
+                skipSegmentFilesTransfer,
+                cancellableThreads,
+                parentShard
             );
         } else {
             return new LocalStorePeerRecoverySourceHandler(
@@ -42,7 +49,10 @@ public static RecoverySourceHandler create(
                 request,
                 Math.toIntExact(recoverySettings.getChunkSize().getBytes()),
                 recoverySettings.getMaxConcurrentFileChunks(),
-                recoverySettings.getMaxConcurrentOperations()
+                recoverySettings.getMaxConcurrentOperations(),
+                skipSegmentFilesTransfer,
+                cancellableThreads,
+                parentShard
             );
         }
     }
diff --git a/server/src/main/java/org/opensearch/indices/recovery/RecoveryState.java b/server/src/main/java/org/opensearch/indices/recovery/RecoveryState.java
index 80c05399df627..ef94080ee4d87 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/RecoveryState.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/RecoveryState.java
@@ -144,8 +144,9 @@ public RecoveryState(
     ) {
         assert shardRouting.initializing() : "only allow initializing shard routing to be recovered: " + shardRouting;
         RecoverySource recoverySource = shardRouting.recoverySource();
-        assert (recoverySource.getType() == RecoverySource.Type.PEER) == (sourceNode != null)
-            : "peer recovery requires source node, recovery type: " + recoverySource.getType() + " source node: " + sourceNode;
+        assert (recoverySource.getType() == RecoverySource.Type.PEER ||
+            recoverySource.getType() == RecoverySource.Type.IN_PLACE_SHARD_SPLIT) == (sourceNode != null)
+            : "peer recovery or split requires source node, recovery type: " + recoverySource.getType() + " source node: " + sourceNode;
         this.shardId = shardRouting.shardId();
         this.primary = shardRouting.primary();
         this.recoverySource = recoverySource;
diff --git a/server/src/main/java/org/opensearch/indices/recovery/RecoveryTarget.java b/server/src/main/java/org/opensearch/indices/recovery/RecoveryTarget.java
index f47b082de3856..f13181bb61e81 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/RecoveryTarget.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/RecoveryTarget.java
@@ -38,6 +38,7 @@
 import org.opensearch.ExceptionsHelper;
 import org.opensearch.action.admin.indices.flush.FlushRequest;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.routing.OperationRouting;
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.lucene.Lucene;
@@ -84,6 +85,7 @@ public class RecoveryTarget extends ReplicationTarget implements RecoveryTargetH
 
     private final DiscoveryNode sourceNode;
     protected final MultiFileWriter multiFileWriter;
+    private final boolean recoveryFromLocalShards;
 
     // latch that can be used to blockingly wait for RecoveryTarget to be closed
     private final CountDownLatch closedLatch = new CountDownLatch(1);
@@ -99,12 +101,32 @@ public class RecoveryTarget extends ReplicationTarget implements RecoveryTargetH
      * @param threadPool threadpool instance
      */
     public RecoveryTarget(IndexShard indexShard, DiscoveryNode sourceNode, ReplicationListener listener, ThreadPool threadPool) {
-        super("recovery_status", indexShard, indexShard.recoveryState().getIndex(), listener);
+        this(indexShard, sourceNode, listener, threadPool, new CancellableThreads(), false);
+    }
+
+    /**
+     * Creates a new recovery target object that represents a recovery to the provided shard.
+     *
+     * @param indexShard                        local shard where we want to recover to
+     * @param sourceNode                        source node of the recovery where we recover from
+     * @param listener                          called when recovery is completed/failed
+     * @param cancellableThreads                cancellable threads to use instead of using new threads internally on target.
+     * @param recoveryFromLocalShards           Whether target recovery is from local shards.
+     */
+    public RecoveryTarget(IndexShard indexShard, DiscoveryNode sourceNode, ReplicationListener listener, ThreadPool threadPool,
+                          CancellableThreads cancellableThreads, boolean recoveryFromLocalShards) {
+        super("recovery_status", indexShard, indexShard.recoveryState().getIndex(), listener,
+            cancellableThreads);
         this.sourceNode = sourceNode;
         this.threadPool = threadPool;
+        this.recoveryFromLocalShards = recoveryFromLocalShards;
         indexShard.recoveryStats().incCurrentAsTarget();
-        final String tempFilePrefix = getPrefix() + UUIDs.randomBase64UUID() + ".";
-        this.multiFileWriter = new MultiFileWriter(indexShard.store(), stateIndex, tempFilePrefix, logger, this::ensureRefCount);
+        if (recoveryFromLocalShards == false) {
+            final String tempFilePrefix = getPrefix() + UUIDs.randomBase64UUID() + ".";
+            this.multiFileWriter = new MultiFileWriter(indexShard.store(), stateIndex, tempFilePrefix, logger, this::ensureRefCount);
+        } else {
+            this.multiFileWriter = null;
+        }
     }
 
     /**
@@ -182,7 +204,9 @@ public boolean reset(CancellableThreads newTargetCancellableThreads) throws IOEx
     @Override
     protected void closeInternal() {
         try {
-            multiFileWriter.close();
+            if (multiFileWriter != null) {
+                multiFileWriter.close();
+            }
         } finally {
             store.decRef();
             indexShard.recoveryStats().decCurrentAsTarget();
@@ -372,11 +396,15 @@ public void cleanFiles(
             // first, we go and move files that were created with the recovery id suffix to
             // the actual names, its ok if we have a corrupted index here, since we have replicas
             // to recover from in case of a full cluster shutdown just when this code executes...
-            multiFileWriter.renameAllTempFiles();
+            if (multiFileWriter != null) {
+                multiFileWriter.renameAllTempFiles();
+            }
             final Store store = store();
             store.incRef();
             try {
-                store.cleanupAndVerify("recovery CleanFilesRequestHandler", sourceMetadata);
+                if (recoveryFromLocalShards == false) {
+                    store.cleanupAndVerify("recovery CleanFilesRequestHandler", sourceMetadata);
+                }
 
                 // Replicas for segment replication or remote snapshot indices do not create
                 // their own commit points and therefore do not modify the commit user data
@@ -429,11 +457,15 @@ public void cleanFiles(
                     ex.addSuppressed(e);
                 }
                 RecoveryFailedException rfe = new RecoveryFailedException(state(), "failed to clean after recovery", ex);
-                fail(rfe, true);
+                if (recoveryFromLocalShards == false) {
+                    fail(rfe, true);
+                }
                 throw rfe;
             } catch (Exception ex) {
                 RecoveryFailedException rfe = new RecoveryFailedException(state(), "failed to clean after recovery", ex);
-                fail(rfe, true);
+                if (recoveryFromLocalShards == false) {
+                    fail(rfe, true);
+                }
                 throw rfe;
             } finally {
                 store.decRef();
diff --git a/server/src/main/java/org/opensearch/indices/recovery/RemoteStorePeerRecoverySourceHandler.java b/server/src/main/java/org/opensearch/indices/recovery/RemoteStorePeerRecoverySourceHandler.java
index 383ed92314165..39cd92f5eea37 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/RemoteStorePeerRecoverySourceHandler.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/RemoteStorePeerRecoverySourceHandler.java
@@ -14,16 +14,21 @@
 import org.opensearch.common.concurrent.GatedCloseable;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.CancellableThreads;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.index.engine.RecoveryEngineException;
 import org.opensearch.index.seqno.RetentionLease;
 import org.opensearch.index.seqno.SequenceNumbers;
 import org.opensearch.index.shard.IndexShard;
+import org.opensearch.index.translog.Translog;
 import org.opensearch.indices.RunUnderPrimaryPermit;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.Transports;
 
+import java.io.Closeable;
 import java.io.IOException;
+import java.util.Collections;
+import java.util.List;
 import java.util.function.Consumer;
 
 /**
@@ -40,9 +45,13 @@ public RemoteStorePeerRecoverySourceHandler(
         StartRecoveryRequest request,
         int fileChunkSizeInBytes,
         int maxConcurrentFileChunks,
-        int maxConcurrentOperations
+        int maxConcurrentOperations,
+        boolean skipSegmentFilesTransfer,
+        CancellableThreads cancellableThreads,
+        IndexShard parentShard
     ) {
-        super(shard, recoveryTarget, threadPool, request, fileChunkSizeInBytes, maxConcurrentFileChunks, maxConcurrentOperations);
+        super(shard, recoveryTarget, threadPool, request, fileChunkSizeInBytes, maxConcurrentFileChunks, maxConcurrentOperations,
+        skipSegmentFilesTransfer, cancellableThreads, parentShard);
     }
 
     @Override
@@ -54,7 +63,7 @@ protected void innerRecoveryToTarget(ActionListener<RecoveryResponse> listener,
         waitForAssignmentPropagate(retentionLeaseRef);
         final StepListener<SendFileResult> sendFileStep = new StepListener<>();
         final StepListener<TimeValue> prepareEngineStep = new StepListener<>();
-        final StepListener<SendSnapshotResult> sendSnapshotStep = new StepListener<>();
+        final StepListener<List<SendSnapshotResult>> sendSnapshotStep = new StepListener<>();
 
         // It is always file based recovery while recovering replicas which are not relocating primary where the
         // underlying indices are backed by remote store for storing segments and translog
@@ -76,7 +85,7 @@ protected void innerRecoveryToTarget(ActionListener<RecoveryResponse> listener,
             onSendFileStepComplete(sendFileStep, wrappedSafeCommit, releaseStore);
 
             assert Transports.assertNotTransportThread(this + "[phase1]");
-            phase1(wrappedSafeCommit.get(), startingSeqNo, () -> 0, sendFileStep, true);
+            phase1(wrappedSafeCommit.get(), startingSeqNo, () -> 0, sendFileStep, shouldSkipCreateRetentionLeaseStep());
         } catch (final Exception e) {
             throw new RecoveryEngineException(shard.shardId(), 1, "sendFileStep failed", e);
         }
@@ -92,18 +101,40 @@ protected void innerRecoveryToTarget(ActionListener<RecoveryResponse> listener,
         prepareEngineStep.whenComplete(prepareEngineTime -> {
             logger.debug("prepareEngineStep completed");
             assert Transports.assertNotTransportThread(this + "[phase2]");
+            IndexShard primaryTracker = replicationTrackingShard();
             RunUnderPrimaryPermit.run(
-                () -> shard.initiateTracking(request.targetAllocationId()),
-                shardId + " initiating tracking of " + request.targetAllocationId(),
-                shard,
+                () -> primaryTracker.initiateTracking(request.targetAllocationId()),
+                primaryTracker + " initiating tracking of " + request.targetAllocationId(),
+                primaryTracker,
                 cancellableThreads,
                 logger
             );
             final long endingSeqNo = shard.seqNoStats().getMaxSeqNo();
-            sendSnapshotStep.onResponse(new SendSnapshotResult(endingSeqNo, 0, TimeValue.ZERO));
+            sendSnapshotStep.onResponse(Collections.singletonList(new SendSnapshotResult(endingSeqNo,
+                0, TimeValue.ZERO, request.targetAllocationId())));
         }, onFailure);
 
-        finalizeStepAndCompleteFuture(startingSeqNo, sendSnapshotStep, sendFileStep, prepareEngineStep, onFailure);
+        finalizeStepAndCompleteFuture(startingSeqNo, sendSnapshotStep, sendFileStep, prepareEngineStep, new StepListener<>(), onFailure);
+    }
+
+    @Override
+    public int countNumberOfHistoryOperations(long startingSeqNo) throws IOException {
+        return 0;
+    }
+
+    @Override
+    public Closeable acquireRetentionLock() {
+        return null;
+    }
+
+    @Override
+    public Translog.Snapshot phase2Snapshot(long startingSeqNo, String recoveryName){
+        return null;
+    }
+
+    @Override
+    public boolean shouldSkipCreateRetentionLeaseStep() {
+        return true;
     }
 
 }
diff --git a/server/src/main/java/org/opensearch/indices/recovery/StartRecoveryRequest.java b/server/src/main/java/org/opensearch/indices/recovery/StartRecoveryRequest.java
index 7309712314acd..3788fa4ea25fc 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/StartRecoveryRequest.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/StartRecoveryRequest.java
@@ -32,6 +32,7 @@
 
 package org.opensearch.indices.recovery;
 
+import org.opensearch.Version;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.core.common.io.stream.StreamInput;
@@ -39,9 +40,11 @@
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.seqno.SequenceNumbers;
 import org.opensearch.index.store.Store;
+import org.opensearch.search.fetch.subphase.FieldAndFormat;
 import org.opensearch.transport.TransportRequest;
 
 import java.io.IOException;
+import java.util.Set;
 
 /**
  * Represents a request for starting a peer recovery.
@@ -54,6 +57,7 @@ public class StartRecoveryRequest extends TransportRequest {
     private long recoveryId;
     private ShardId shardId;
     private String targetAllocationId;
+    private Set<String> childShardsAllocationIds;
     private DiscoveryNode sourceNode;
     private DiscoveryNode targetNode;
     private Store.MetadataSnapshot metadataSnapshot;
@@ -70,6 +74,11 @@ public StartRecoveryRequest(StreamInput in) throws IOException {
         metadataSnapshot = new Store.MetadataSnapshot(in);
         primaryRelocation = in.readBoolean();
         startingSeqNo = in.readLong();
+        if (in.getVersion().onOrAfter(Version.V_3_0_0)) {
+            if (in.readBoolean()) {
+                childShardsAllocationIds = in.readSet(StreamInput::readString);
+            }
+        }
     }
 
     /**
@@ -92,7 +101,8 @@ public StartRecoveryRequest(
         final Store.MetadataSnapshot metadataSnapshot,
         final boolean primaryRelocation,
         final long recoveryId,
-        final long startingSeqNo
+        final long startingSeqNo,
+        final Set<String> childShardsAllocationIds
     ) {
         this.recoveryId = recoveryId;
         this.shardId = shardId;
@@ -104,6 +114,7 @@ public StartRecoveryRequest(
         this.startingSeqNo = startingSeqNo;
         assert startingSeqNo == SequenceNumbers.UNASSIGNED_SEQ_NO || metadataSnapshot.getHistoryUUID() != null
             : "starting seq no is set but not history uuid";
+        this.childShardsAllocationIds = childShardsAllocationIds;
     }
 
     public long recoveryId() {
@@ -138,6 +149,10 @@ public long startingSeqNo() {
         return startingSeqNo;
     }
 
+    public Set<String> getChildShardsAllocationIds() {
+        return childShardsAllocationIds;
+    }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         super.writeTo(out);
@@ -149,6 +164,17 @@ public void writeTo(StreamOutput out) throws IOException {
         metadataSnapshot.writeTo(out);
         out.writeBoolean(primaryRelocation);
         out.writeLong(startingSeqNo);
+        // We don't receive/send recovery request of child shards from/to another node but let's still handle it.
+        if (out.getVersion().onOrAfter(Version.V_3_0_0)) {
+            out.writeBoolean(childShardsAllocationIds != null);
+            if (childShardsAllocationIds != null) {
+                out.writeCollection(childShardsAllocationIds, StreamOutput::writeString);
+            }
+        } else {
+            if (childShardsAllocationIds != null) {
+                throw new IllegalStateException("In-place split not allowed on older versions.");
+            }
+        }
     }
 
 }
diff --git a/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardRecoveryContext.java b/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardRecoveryContext.java
new file mode 100644
index 0000000000000..b73bc8aadb6c3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardRecoveryContext.java
@@ -0,0 +1,47 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices.recovery.inplacesplit;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.shard.IndexShard;
+import org.opensearch.indices.recovery.RecoveryState;
+
+/**
+ * Shard recovery context of a child shard required for in-place shard recovery.
+ *
+ * @opensearch.internal
+ */
+@ExperimentalApi
+public class InPlaceShardRecoveryContext {
+
+    private final RecoveryState recoveryState;
+    private final IndexShard indexShard;
+    private final IndexShard sourceShard;
+
+    /**
+     * Constructor for recovery context.
+     */
+    public InPlaceShardRecoveryContext(RecoveryState recoveryState, IndexShard indexShard, IndexShard sourceShard) {
+        this.recoveryState = recoveryState;
+        this.indexShard = indexShard;
+        this.sourceShard = sourceShard;
+    }
+
+    public RecoveryState getRecoveryState() {
+        return recoveryState;
+    }
+
+    public IndexShard getIndexShard() {
+        return indexShard;
+    }
+
+    public IndexShard getSourceShard() {
+        return sourceShard;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRecoveryListener.java b/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRecoveryListener.java
new file mode 100644
index 0000000000000..5fb2f7ba0e764
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRecoveryListener.java
@@ -0,0 +1,62 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices.recovery.inplacesplit;
+
+import org.opensearch.cluster.routing.RecoverySource;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.indices.cluster.IndicesClusterStateService;
+import org.opensearch.indices.replication.common.ReplicationFailedException;
+import org.opensearch.indices.replication.common.ReplicationListener;
+import org.opensearch.indices.replication.common.ReplicationState;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class InPlaceShardSplitRecoveryListener implements ReplicationListener {
+
+    private final Map<ShardId, ShardRouting> recoveringShards;
+    private final IndicesClusterStateService indicesClusterStateService;
+    private final ShardRouting sourceShard;
+    private final long primaryTerm;
+
+    public InPlaceShardSplitRecoveryListener (
+        final List<ShardRouting> shardRoutings,
+        IndicesClusterStateService indicesClusterStateService,
+        final ShardRouting sourceShard,
+        final long primaryTerm
+    ) {
+        this.sourceShard = sourceShard;
+        this.recoveringShards = new HashMap<>();
+        this.primaryTerm = primaryTerm;
+        shardRoutings.forEach(shardRouting -> {
+            this.recoveringShards.put(shardRouting.shardId(), shardRouting);
+        });
+        this.indicesClusterStateService = indicesClusterStateService;
+    }
+
+    /**
+     * Handle recover done event for in-place shard split recovery.
+     */
+    @Override
+    public synchronized void onDone(ReplicationState state) {
+        indicesClusterStateService.handleChildRecoveriesDone(sourceShard, primaryTerm,
+            RecoverySource.InPlaceShardSplitRecoverySource.INSTANCE);
+    }
+
+    /**
+     * Handle recover failure event for in-place shard split recovery.
+     */
+    @Override
+    public void onFailure(ReplicationState state, ReplicationFailedException e, boolean sendShardFailure) {
+        indicesClusterStateService.handleChildRecoveriesFailure(sourceShard, sendShardFailure, e);
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRecoveryService.java b/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRecoveryService.java
new file mode 100644
index 0000000000000..b6a268859cf13
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRecoveryService.java
@@ -0,0 +1,352 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices.recovery.inplacesplit;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.OpenSearchException;
+import org.opensearch.action.support.PlainActionFuture;
+import org.opensearch.cluster.ClusterChangedEvent;
+import org.opensearch.cluster.ClusterStateListener;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.CheckedConsumer;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.inject.Inject;
+import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.CancellableThreads;
+import org.opensearch.common.util.concurrent.FutureUtils;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.index.shard.IndexEventListener;
+import org.opensearch.index.shard.IndexShard;
+import org.opensearch.indices.IndicesService;
+import org.opensearch.indices.recovery.DelayRecoveryException;
+import org.opensearch.indices.recovery.RecoveryResponse;
+import org.opensearch.indices.recovery.RecoverySettings;
+import org.opensearch.indices.recovery.RecoverySourceHandler;
+import org.opensearch.indices.recovery.RecoverySourceHandlerFactory;
+import org.opensearch.indices.recovery.StartRecoveryRequest;
+import org.opensearch.indices.replication.common.ReplicationFailedException;
+import org.opensearch.indices.replication.common.ReplicationTimer;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+
+public class InPlaceShardSplitRecoveryService extends AbstractLifecycleComponent implements IndexEventListener, ClusterStateListener {
+    private static final Logger logger = LogManager.getLogger(InPlaceShardSplitRecoveryService.class);
+
+    private final OngoingRecoveries ongoingRecoveries;
+    private final IndicesService indicesService;
+    private final RecoverySettings recoverySettings;
+
+    @Inject
+    public InPlaceShardSplitRecoveryService(IndicesService indicesService, RecoverySettings recoverySettings) {
+        this.ongoingRecoveries = new OngoingRecoveries();
+        this.indicesService = indicesService;
+        this.recoverySettings = recoverySettings;
+    }
+
+    @Override
+    protected void doStart() {
+        final ClusterService clusterService = indicesService.clusterService();
+        if (DiscoveryNode.isDataNode(clusterService.getSettings())) {
+            clusterService.addListener(this);
+        }
+    }
+
+    @Override
+    protected void doStop() {
+        final ClusterService clusterService = indicesService.clusterService();
+        if (DiscoveryNode.isDataNode(clusterService.getSettings())) {
+            ongoingRecoveries.awaitEmpty();
+            indicesService.clusterService().removeListener(this);
+        }
+    }
+
+    @Override
+    public void beforeIndexShardClosed(ShardId shardId, @Nullable IndexShard indexShard, Settings indexSettings) {
+        if (indexShard != null) {
+            ongoingRecoveries.cancel(indexShard, "shard is closed");
+        }
+    }
+
+    /**
+     * Cancels in-place shard recovery for a shard whose replica on another node has been promoted as primary.
+     */
+    @Override
+    public void shardRoutingChanged(IndexShard indexShard, @Nullable ShardRouting oldRouting, ShardRouting newRouting) {
+        if (indexShard != null && oldRouting.primary() == false && newRouting.primary()) {
+            ongoingRecoveries.cancel(indexShard, "Relocating primary shard.");
+        }
+    }
+
+    @Override
+    protected void doClose() throws IOException {}
+
+    @Override
+    public void clusterChanged(ClusterChangedEvent event) {}
+
+    public void addAndStartRecovery(List<InPlaceShardRecoveryContext> recoveryContexts,
+                                    DiscoveryNode node,
+                                    IndexShard sourceShard,
+                                    InPlaceShardSplitRecoveryListener replicationListener,
+                                    StartRecoveryRequest request,
+                                    IndexMetadata indexMetadata) {
+        if (ongoingRecoveries.isRecoveryOfShardOnGoing(sourceShard.shardId())) {
+            return;
+        }
+
+        Set<String> childShardAllocationIds = new HashSet<>();
+        recoveryContexts.forEach(context -> childShardAllocationIds.add(context.getIndexShard()
+            .routingEntry().allocationId().getId()));
+
+        List<ReplicationTimer> timers = new ArrayList<>();
+        recoveryContexts.forEach(context -> timers.add(context.getRecoveryState().getTimer()));
+        ActionListener<RecoveryResponse> recoveryResponseListener = new InPlaceShardSplitResponseHandler(
+            replicationListener, request, timers, ongoingRecoveries, sourceShard);
+
+        InPlaceShardSplitRecoverySourceHandler handler = ongoingRecoveries.addNewRecovery(sourceShard, node,
+            recoveryContexts, request, childShardAllocationIds, replicationListener, indexMetadata);
+        logger.trace(
+            "[{}] starting in-place recovery from [{}]",
+            sourceShard.shardId().getIndex().getName(),
+            sourceShard.shardId().id()
+        );
+
+        handler.recoverToTarget(recoveryResponseListener);
+    }
+
+    public void addReplicaRecoveryAfterChildPrimariesSync(ShardId parentShardId, ActionListener<Void> listener) {
+        ongoingRecoveries.addReplicaRecovery(parentShardId, listener);
+    }
+
+    public void startChildShards(ShardId parentShardId) {
+        synchronized (this) {
+            OngoingRecoveries.Recovery recovery = ongoingRecoveries.recoveries.get(parentShardId);
+            if (recovery != null) {
+                recovery.sourceHandler.performHandoff();
+            }
+        }
+    }
+
+    public class OngoingRecoveries {
+        private final Map<ShardId, Recovery> recoveries = new HashMap<>();
+        private final Set<ShardId> failedRecoveries = new HashSet<>();
+        private final Consumer<ShardId> onSync = shardId -> {
+            synchronized (this) {
+                recoveries.get(shardId).notifyAllWaitingReplicaRecoveries();
+            }
+        };
+
+        @Nullable
+        private List<ActionListener<Void>> emptyListeners;
+
+        private class Recovery {
+            private final InPlaceShardSplitRecoveryTargetHandler targetHandler;
+            private final InPlaceShardSplitRecoverySourceHandler sourceHandler;
+            private final InPlaceShardSplitRecoveryListener replicationListener;
+            private final List<ActionListener<Void>> replicaRecoveryListeners = new ArrayList<>();
+
+            public Recovery(InPlaceShardSplitRecoveryTargetHandler targetHandler,
+                            InPlaceShardSplitRecoverySourceHandler sourceHandler,
+                            InPlaceShardSplitRecoveryListener replicationListener) {
+                this.targetHandler = targetHandler;
+                this.sourceHandler = sourceHandler;
+                this.replicationListener = replicationListener;
+            }
+
+            private synchronized void notifyAllWaitingReplicaRecoveries() {
+                replicaRecoveryListeners.forEach(listener -> {
+                    listener.onResponse(null);
+                });
+            }
+
+            private synchronized void waitForPrimaryChildShardsSynced(ActionListener<Void> listener) {
+                replicaRecoveryListeners.add(listener);
+            }
+        }
+
+        private boolean isRecoveryOfShardOnGoing(ShardId shardId) {
+            return recoveries.get(shardId) != null;
+        }
+
+        InPlaceShardSplitRecoverySourceHandler addNewRecovery(
+            IndexShard sourceShard, DiscoveryNode node, List<InPlaceShardRecoveryContext> recoveryContexts,
+            StartRecoveryRequest request, Set<String> childShardsAllocationIds,
+            InPlaceShardSplitRecoveryListener replicationListener, IndexMetadata indexMetadata
+        ) {
+           synchronized (this) {
+               assert lifecycle.started();
+               if (recoveries.containsKey(sourceShard.shardId())) {
+                   throw new IllegalStateException("In-place shard recovery from shard " + sourceShard.shardId() + "  already already in progress");
+               }
+               failedRecoveries.remove(sourceShard.shardId());
+               CancellableThreads cancellableThreads = new CancellableThreads();
+               List<IndexShard> targetShards = new ArrayList<>();
+               recoveryContexts.forEach(context -> targetShards.add(context.getIndexShard()));
+
+               InPlaceShardSplitRecoveryTargetHandler targetHandler = createSplitTargetHandler(targetShards,
+                   node, cancellableThreads, recoveryContexts, childShardsAllocationIds, sourceShard);
+               RecoverySourceHandler delegatingRecoveryHandler = RecoverySourceHandlerFactory.create(sourceShard,
+                   targetHandler, request, recoverySettings, true, cancellableThreads, null);
+
+               InPlaceShardSplitRecoverySourceHandler sourceHandler = createSourceHandler(sourceShard,
+                   targetHandler, delegatingRecoveryHandler, request, cancellableThreads, recoveryContexts,
+                   childShardsAllocationIds, replicationListener, indexMetadata);
+
+               recoveries.put(sourceShard.shardId(), new Recovery(targetHandler, sourceHandler, replicationListener));
+               sourceShard.recoveryStats().incCurrentAsSource();
+               logger.info("Adding child primary recovery on node " + indicesService.clusterService().localNode().getName());
+               return sourceHandler;
+           }
+        }
+
+        protected InPlaceShardSplitRecoveryTargetHandler createSplitTargetHandler(
+            List<IndexShard> targetShards,
+            DiscoveryNode node,
+            CancellableThreads cancellableThreads,
+            List<InPlaceShardRecoveryContext> recoveryContexts,
+            Set<String> childShardsAllocationIds,
+            IndexShard sourceShard
+        ) {
+            return new InPlaceShardSplitRecoveryTargetHandler(targetShards,
+                node, cancellableThreads, recoveryContexts, childShardsAllocationIds ,sourceShard);
+        }
+
+        public void addReplicaRecovery(ShardId parentShardId, ActionListener<Void> listener) {
+            synchronized (this) {
+                if (failedRecoveries.contains(parentShardId)) {
+                    listener.onFailure(new InPlaceShardsRecoveryFailedException(parentShardId));
+                    return;
+                }
+
+                Recovery recovery = recoveries.get(parentShardId);
+                if (recovery == null) {
+                    logger.info("Delaying replica on node " + indicesService.clusterService().localNode().getName());
+                    throw new DelayRecoveryException("parent shard [" + parentShardId + "] is not yet added for split recovery");
+                }
+
+                if (recovery.sourceHandler.isRecoveryStateInSync()) {
+                    logger.info("Parent in sync on node " + indicesService.clusterService().localNode().getName());
+                    listener.onResponse(null);
+                    return;
+                }
+
+                recovery.waitForPrimaryChildShardsSynced(listener);
+            }
+        }
+
+        protected InPlaceShardSplitRecoverySourceHandler createSourceHandler(
+            IndexShard sourceShard,
+            InPlaceShardSplitRecoveryTargetHandler targetHandler,
+            RecoverySourceHandler delegatingRecoveryHandler,
+            StartRecoveryRequest request,
+            CancellableThreads cancellableThreads,
+            List<InPlaceShardRecoveryContext> recoveryContexts,
+            Set<String> childShardsAllocationIds,
+            InPlaceShardSplitRecoveryListener replicationListener,
+            IndexMetadata indexMetadata
+        ) {
+            return new InPlaceShardSplitRecoverySourceHandler(sourceShard, targetHandler, delegatingRecoveryHandler,
+                request, Math.toIntExact(recoverySettings.getChunkSize().getBytes()),
+                recoverySettings.getMaxConcurrentFileChunks(), recoverySettings.getMaxConcurrentOperations(),
+                cancellableThreads, recoveryContexts, childShardsAllocationIds, replicationListener, indexMetadata, onSync);
+        }
+
+        void remove(InPlaceShardSplitRecoverySourceHandler sourceHandler) {
+            synchronized (this) {
+                sourceHandler.getSourceShard().recoveryStats().decCurrentAsSource();
+                if (recoveries.isEmpty()) {
+                    if (emptyListeners != null) {
+                        final List<ActionListener<Void>> onEmptyListeners = emptyListeners;
+                        emptyListeners = null;
+                        ActionListener.onResponse(onEmptyListeners, null);
+                    }
+                }
+            }
+        }
+
+        public void markAsDone(IndexShard sourceShard) {
+            synchronized (this) {
+                Recovery removed = recoveries.remove(sourceShard.shardId());
+                if (removed != null) {
+                    assert sourceShard.routingEntry().splitting();
+                    remove(removed.sourceHandler);
+                    removed.targetHandler.onDone();
+                    removed.replicationListener.onDone(null);
+                }
+            }
+        }
+
+        public void fail(IndexShard sourceShard, ReplicationFailedException ex, boolean sendShardFailure) {
+            synchronized (this) {
+                Recovery removed = recoveries.remove(sourceShard.shardId());
+                if (removed != null) {
+                    remove(removed.sourceHandler);
+                    removed.replicationListener.onFailure(null, ex, sendShardFailure);
+                    failedRecoveries.add(sourceShard.shardId());
+                }
+            }
+        }
+
+        void cancel(IndexShard shard, String reason) {
+            synchronized (this) {
+                try {
+                    ShardId sourceShardId = getSplittingSourceShardId(shard);
+                    if (sourceShardId != null && recoveries.containsKey(sourceShardId)) {
+                        recoveries.get(sourceShardId).sourceHandler.cancel(reason);
+                    }
+                } catch (Exception ex) {
+                    throw new OpenSearchException(ex);
+                } finally {
+                    shard.recoveryStats().decCurrentAsSource();
+                }
+            }
+        }
+
+        private ShardId getSplittingSourceShardId(IndexShard shard) {
+            if (shard.routingEntry().splitting()) {
+                return shard.shardId();
+            } else if (shard.routingEntry().isSplitTarget()) {
+                return shard.routingEntry().getParentShardId();
+            }
+            return null;
+        }
+
+        void awaitEmpty() {
+            assert lifecycle.stoppedOrClosed();
+            final PlainActionFuture<Void> future;
+            synchronized (this) {
+                if (recoveries.isEmpty()) {
+                    return;
+                }
+                future = new PlainActionFuture<>();
+                if (emptyListeners == null) {
+                    emptyListeners = new ArrayList<>();
+                }
+                emptyListeners.add(future);
+            }
+            FutureUtils.get(future);
+        }
+
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRecoverySourceHandler.java b/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRecoverySourceHandler.java
new file mode 100644
index 0000000000000..a10b1846ff441
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRecoverySourceHandler.java
@@ -0,0 +1,534 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch] Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices.recovery.inplacesplit;
+
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.apache.lucene.index.IndexCommit;
+import org.opensearch.action.StepListener;
+import org.opensearch.action.admin.indices.flush.FlushRequest;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.SetOnce;
+import org.opensearch.common.StopWatch;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.concurrent.GatedCloseable;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.logging.Loggers;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.CancellableThreads;
+import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.index.engine.Engine;
+import org.opensearch.index.seqno.ReplicationTracker;
+import org.opensearch.index.seqno.RetentionLease;
+import org.opensearch.index.seqno.RetentionLeases;
+import org.opensearch.index.seqno.SequenceNumbers;
+import org.opensearch.index.shard.IndexShard;
+import org.opensearch.index.store.Store;
+import org.opensearch.index.store.StoreFileMetadata;
+import org.opensearch.index.store.remote.metadata.RemoteSegmentMetadata;
+import org.opensearch.index.translog.Translog;
+import org.opensearch.indices.RunUnderPrimaryPermit;
+import org.opensearch.indices.recovery.RecoveryResponse;
+import org.opensearch.indices.recovery.RecoverySourceHandler;
+import org.opensearch.indices.recovery.RecoveryState;
+import org.opensearch.indices.recovery.StartRecoveryRequest;
+import org.opensearch.transport.Transports;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.nio.file.NoSuchFileException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Consumer;
+import java.util.function.IntSupplier;
+
+public class InPlaceShardSplitRecoverySourceHandler extends RecoverySourceHandler {
+    private final List<InPlaceShardRecoveryContext> recoveryContexts;
+    private final InPlaceShardSplitRecoveryTargetHandler recoveryTarget;
+    private final IndexShard sourceShard;
+    private final RecoverySourceHandler delegatingRecoveryHandler;
+    private final Set<String> childShardsAllocationIds;
+    private final SetOnce<SplitCommitMetadata> splitCommitMetadata = new SetOnce<>();
+    private final Logger logger;
+    private final InPlaceShardSplitRecoveryListener replicationListener;
+    private final IndexMetadata indexMetadata;
+    private volatile boolean inSync = false;
+    private final Consumer<ShardId> onSync;
+    private volatile Runnable finalizer;
+
+    public InPlaceShardSplitRecoverySourceHandler(
+        IndexShard sourceShard,
+        InPlaceShardSplitRecoveryTargetHandler recoveryTarget,
+        RecoverySourceHandler delegatingRecoveryHandler,
+        StartRecoveryRequest request,
+        int fileChunkSizeInBytes,
+        int maxConcurrentFileChunks,
+        int maxConcurrentOperations,
+        CancellableThreads cancellableThreads,
+        List<InPlaceShardRecoveryContext> recoveryContexts,
+        Set<String> childShardsAllocationIds,
+        InPlaceShardSplitRecoveryListener replicationListener,
+        IndexMetadata indexMetadata,
+        Consumer<ShardId> onSync
+    ) {
+        super(sourceShard, recoveryTarget,
+            sourceShard.getThreadPool(), request, fileChunkSizeInBytes, maxConcurrentFileChunks,
+            maxConcurrentOperations, true, cancellableThreads, sourceShard);
+        List<ShardId> childShardIds = new ArrayList<>();
+        recoveryContexts.forEach(context -> childShardIds.add(context.getIndexShard().shardId()));
+        this.logger = Loggers.getLogger(InPlaceShardSplitRecoverySourceHandler.class, request.shardId(),
+            "splitting to " + childShardIds);
+        this.resources.add(recoveryTarget);
+        this.recoveryContexts = recoveryContexts;
+        this.sourceShard = sourceShard;
+        this.delegatingRecoveryHandler = delegatingRecoveryHandler;
+        this.childShardsAllocationIds = childShardsAllocationIds;
+        this.recoveryTarget = recoveryTarget;
+        this.replicationListener = replicationListener;
+        this.indexMetadata = indexMetadata;
+        this.onSync = onSync;
+
+        recoveryTarget.initStoreAcquirer((requestStore) -> {
+            Releasable releasable = acquireStore(requestStore);
+            resources.add(releasable);
+            return releasable;
+        });
+    }
+
+    public IndexShard getSourceShard() {
+        return sourceShard;
+    }
+
+    public List<Closeable> getAdditionalResourcesToClose() {
+        return delegatingRecoveryHandler.getResources();
+    }
+
+    private Consumer<Exception> consumerForCleanupOnFailure(Consumer<Exception> onFailure) {
+        Consumer<Exception> cleanUpConsumer = (e) -> {
+            try {
+                cleanupChildShardDirectories();
+            } catch (Exception inner) {
+                inner.addSuppressed(e);
+                logger.warn(
+                    () -> new ParameterizedMessage(
+                        "[{}] failed to cleanup child shard directories failure ([{}])",
+                        sourceShard.shardId(),
+                        e.getMessage()
+                    ),
+                    inner
+                );
+            }
+        };
+        return cleanUpConsumer.andThen(onFailure);
+    }
+
+    @Override
+    protected void innerRecoveryToTarget(ActionListener<RecoveryResponse> listener, Consumer<Exception> onFailure) throws IOException {
+//        onFailure = consumerForCleanupOnFailure(onFailure);
+        // Clean up shard directories if previous shard closures failed.
+        cleanupChildShardDirectories();
+
+        List<Releasable> delayedStaleCommitDeleteOps = sourceShard.delayStaleCommitDeletions();
+        resources.addAll(delayedStaleCommitDeleteOps);
+        GatedCloseable<Long> translogRetentionLock = sourceShard.acquireRetentionLockWithMinGen();
+        resources.add(translogRetentionLock);
+        Releasable releaseStore = acquireStore(sourceShard.store());
+        resources.add(releaseStore);
+
+        GatedCloseable<IndexCommit> lastCommit;
+        try {
+            lastCommit = acquireCommitAndFetchMetadata(translogRetentionLock);
+        } catch (NoSuchFileException ex) {
+            // Handling of a known issue in remote store flow https://github.com/opensearch-project/OpenSearch/pull/10341
+            logger.warn("Exception while acquiring commit and fetching metadata", ex);
+            lastCommit = acquireCommitAndFetchMetadata(translogRetentionLock);
+        }
+
+        final StepListener<SendFileResult> sendFileStep = new StepListener<>();
+        final StepListener<TimeValue> prepareEngineStep = new StepListener<>();
+        final StepListener<List<SendSnapshotResult>> sendSnapshotStep = new StepListener<>();
+
+        postSendFileComplete(sendFileStep, lastCommit, releaseStore, delayedStaleCommitDeleteOps);
+        long startingSeqNo = Long.parseLong(lastCommit.get().getUserData().get(SequenceNumbers.LOCAL_CHECKPOINT_KEY)) + 1L;
+        logger.info("Docs in commit " + (startingSeqNo));
+        assert Transports.assertNotTransportThread(this + "[phase1]");
+        phase1(lastCommit.get(), startingSeqNo, () -> 0, sendFileStep, true);
+
+        prepareEngine(sendFileStep, prepareEngineStep, RecoveryState.Translog.UNKNOWN, onFailure);
+
+        prepareEngineStep.whenComplete(prepareEngineTime -> {
+            addRetentionLeases(startingSeqNo);
+            logger.info("prepareEngineStep completed");
+            assert Transports.assertNotTransportThread(this + "[phase2]");
+            initiateTracking();
+            final long endingSeqNo = sourceShard.seqNoStats().getMaxSeqNo();
+            // Syncing here because sequence number can be greater than local checkpoint and operations may not yet be
+            // present in translog.
+            sourceShard.sync();
+            // Flush because one or more operations in the provided range may still be pending to be indexed into lucene
+            // and therefore, may not be available yet in translog. This is a best effort to ensure all operations within
+            // this range are indexed and therefore, available in translog.
+            sourceShard.flush(new FlushRequest().waitIfOngoing(true).force(true));
+            final Translog.Snapshot phase2Snapshot;
+            if (startingSeqNo > endingSeqNo) {
+                phase2Snapshot = new EmptySnapshot();
+            } else {
+                phase2Snapshot = sourceShard.getHistoryOperationsFromTranslog(startingSeqNo, endingSeqNo);
+            }
+
+            resources.add(phase2Snapshot);
+            translogRetentionLock.close();
+            logger.info("snapshot translog for recovery; current size is [{}]", phase2Snapshot.totalOperations());
+
+            final long mappingVersionOnPrimary = sourceShard.indexSettings().getIndexMetadata().getMappingVersion();
+            phase2(
+                startingSeqNo,
+                endingSeqNo,
+                phase2Snapshot,
+                sourceShard.getMaxSeenAutoIdTimestamp(),
+                sourceShard.getMaxSeqNoOfUpdatesOrDeletes(),
+                RetentionLeases.EMPTY,
+                mappingVersionOnPrimary,
+                sendSnapshotStep
+            );
+        }, onFailure);
+
+        StepListener<Void> finalizeStep = new StepListener<>();
+        sendSnapshotStep.whenComplete(r -> {
+            logger.info("Send snapshot step completed.");
+            recoveryTarget.flushOnAllChildShards();
+        }, onFailure);
+        finalizeStep.whenComplete(r -> {
+            logger.info("Finalize step completed.");
+            cleanUpMaybeRemoteOnFinalize();
+        }, onFailure);
+        finalizeStepAndCompleteFuture(startingSeqNo, sendSnapshotStep, sendFileStepWithEmptyResult(), prepareEngineStep, finalizeStep, onFailure);
+    }
+
+    private void addRetentionLeases(long startingSeqNo) {
+        recoveryContexts.forEach(context -> {
+            RetentionLease primaryRentetionLease = new RetentionLease(
+                ReplicationTracker.getPeerRecoveryRetentionLeaseId(shard.routingEntry()),
+                startingSeqNo,
+                shard.getThreadPool().absoluteTimeInMillis(),
+                ReplicationTracker.PEER_RECOVERY_RETENTION_LEASE_SOURCE
+            );
+            Collection<RetentionLease> leases = new ArrayList<>();
+            leases.add(primaryRentetionLease);
+            context.getIndexShard().updateRetentionLeasesOnChildPrimary(new RetentionLeases(
+                sourceShard.getOperationPrimaryTerm(), 1, leases));
+        });
+    }
+
+    private GatedCloseable<IndexCommit> acquireCommitAndFetchMetadata(GatedCloseable<Long> translogRetentionLock) throws IOException {
+        // Make sure that all operations before acquired translog generation are present in the last commit.
+        // In remote store replication mode refreshed but not flushed ops are also trimmed from translog and hence,
+        // a flush is required to ensure that all operations before the acquired translog are present in the local commit.
+        // Also, a refresh is done as part of flush and therefore, we can expect commit to be present in remote store
+        // as well.
+        sourceShard.flush(new FlushRequest().waitIfOngoing(true).force(true));
+
+        GatedCloseable<IndexCommit> lastCommit = acquireLastCommit(sourceShard,false);
+        resources.add(lastCommit);
+
+        Tuple<String, RemoteSegmentMetadata> fetchedMetadataTuple = null;
+        if (sourceShard.remoteStore() != null) {
+            fetchedMetadataTuple = sourceShard.getMetadataContentForCommit(
+                sourceShard.getOperationPrimaryTerm(),
+                lastCommit.get().getGeneration());
+            ensureMetadataHasAllSegmentsFromCommit(lastCommit.get(), fetchedMetadataTuple.v2());
+        }
+        splitCommitMetadata.set(new SplitCommitMetadata(translogRetentionLock.get(), fetchedMetadataTuple));
+        return lastCommit;
+    }
+
+    private void ensureMetadataHasAllSegmentsFromCommit(IndexCommit indexCommit, RemoteSegmentMetadata metadata) throws IOException {
+        List<String> missingFiles = new ArrayList<>();
+        for (String file : indexCommit.getFileNames()) {
+            if (metadata.getMetadata().containsKey(file) == false) {
+                missingFiles.add(file);
+            }
+        }
+
+        if (missingFiles.isEmpty() == false) {
+            throw new IllegalStateException("Missing segments in remote segments metadata. Missing files ["
+                + missingFiles + "] for commit generation [" + indexCommit.getGeneration() + "]");
+        }
+    }
+
+    protected void postSendFileComplete(
+        StepListener<SendFileResult> sendFileStep,
+        GatedCloseable<IndexCommit> wrappedSafeCommit,
+        Releasable releaseStore,
+        List<Releasable> delayedStaleCommitOps
+    ) {
+        sendFileStep.whenComplete(r -> {
+            logger.info("sendFileStep completed");
+            delayedStaleCommitOps.forEach(Releasable::close);
+            IOUtils.close(wrappedSafeCommit, releaseStore);
+        }, e -> {
+            try {
+                IOUtils.close(wrappedSafeCommit, releaseStore);
+                delayedStaleCommitOps.forEach(Releasable::close);
+            } catch (final IOException ex) {
+                logger.warn("releasing snapshot caused exception", ex);
+            }
+        });
+    }
+
+    @Override
+    public int countNumberOfHistoryOperations(long startingSeqNo) throws IOException {
+        return delegatingRecoveryHandler.countNumberOfHistoryOperations(startingSeqNo);
+    }
+
+    @Override
+    public Closeable acquireRetentionLock() {
+        return delegatingRecoveryHandler.acquireRetentionLock();
+    }
+
+    public void prepareEngine(StepListener<SendFileResult> sendFileStep,
+                              StepListener<TimeValue> prepareEngineStep,
+                              int totalTranslogOps,
+                              Consumer<Exception> onFailure) {
+        sendFileStep.whenComplete(r -> {
+            logger.info("sendFileStep completed");
+            assert Transports.assertNotTransportThread(this + "[prepareTargetForTranslog]");
+            // For a sequence based recovery, the target can keep its local translog
+            prepareTargetForTranslog(totalTranslogOps, prepareEngineStep);
+        }, onFailure);
+    }
+
+    @Override
+    public Translog.Snapshot phase2Snapshot(long startingSeqNo, String recoveryName) throws IOException {
+        return null;
+    }
+
+    private static class EmptySnapshot implements Translog.Snapshot {
+        @Override
+        public int totalOperations() {
+            return 0;
+        }
+
+        @Override
+        public Translog.Operation next() throws IOException {
+            return null;
+        }
+
+        @Override
+        public void close() throws IOException {}
+    }
+
+    @Override
+    public boolean shouldSkipCreateRetentionLeaseStep() {
+        return delegatingRecoveryHandler.shouldSkipCreateRetentionLeaseStep();
+    }
+
+    @Override
+    protected void updateGlobalCheckpointForShard(long globalCheckpoint) {
+        childShardsAllocationIds.forEach(allocationID -> {
+            RunUnderPrimaryPermit.run(
+                () -> shard.updateGlobalCheckpointForShard(allocationID, globalCheckpoint),
+                shardId + " updating " + allocationID + "'s global checkpoint",
+                shard,
+                cancellableThreads,
+                logger
+            );
+        });
+    }
+
+    @Override
+    protected void relocateShard(Runnable forceSegRepRunnable) throws InterruptedException {
+        // Relocation is splitting in the current context where parent shard will cease to exist.
+        shard.relocated(childShardsAllocationIds, recoveryTarget::handoffPrimaryContext, forceSegRepRunnable);
+        recoveryTarget.flushOnAllChildShards();
+    }
+
+    public void cleanupChildShardDirectories() throws IOException {
+        recoveryTarget.cleanShardDirectoriesForTargets();
+    }
+
+    protected void sendFiles(Store store, StoreFileMetadata[] files, IntSupplier translogOps,
+                             ActionListener<Void> listener, IndexCommit snapshot) {
+
+        try {
+            long localCheckpoint = Long.parseLong(snapshot.getUserData().get(SequenceNumbers.LOCAL_CHECKPOINT_KEY));
+            long maxSeqNo = Long.parseLong(snapshot.getUserData().get(SequenceNumbers.MAX_SEQ_NO));
+            long maxUnsafeAutoIdTimestamp = Long.parseLong(snapshot.getUserData().get(
+                Engine.MAX_UNSAFE_AUTO_ID_TIMESTAMP_COMMIT_ID));
+            recoveryTarget.receiveFilesAndSplit(store, files, localCheckpoint, maxSeqNo, splitCommitMetadata.get(),
+                maxUnsafeAutoIdTimestamp);
+            listener.onResponse(null);
+        } catch (Exception e) {
+            listener.onFailure(e);
+        }
+    }
+
+    protected void cleanFiles(
+        Store store,
+        Store.MetadataSnapshot sourceMetadata,
+        IntSupplier translogOps,
+        long globalCheckpoint,
+        ActionListener<Void> listener
+    ) {
+        recoveryTarget.cleanFiles(translogOps.getAsInt(), globalCheckpoint, sourceMetadata, listener);
+    }
+
+    private void initiateTracking() {
+        cancellableThreads.checkForCancel();
+        List<String> allocationIDs = new ArrayList<>();
+        recoveryContexts.forEach(context -> allocationIDs.add(context.getIndexShard()
+            .routingEntry().allocationId().getId()));
+
+        RunUnderPrimaryPermit.run(
+            () -> shard.initiateTrackingOfChildShards(allocationIDs),
+            shardId + " initiating tracking of " + allocationIDs,
+            shard,
+            cancellableThreads,
+            logger
+        );
+    }
+
+    private StepListener<SendFileResult> sendFileStepWithEmptyResult() {
+        StepListener<SendFileResult> sendFileStep = new StepListener<>();
+        sendFileStep.onResponse(new SendFileResult(
+                Collections.emptyList(),
+                Collections.emptyList(),
+                0,
+                Collections.emptyList(),
+                Collections.emptyList(),
+                0,
+                TimeValue.ZERO
+            )
+        );
+
+        return sendFileStep;
+    }
+
+    @Override
+    protected OperationBatchSender createSender(
+        final long startingSeqNo,
+        final long endingSeqNo,
+        final Translog.Snapshot snapshot,
+        final long maxSeenAutoIdTimestamp,
+        final long maxSeqNoOfUpdatesOrDeletes,
+        final RetentionLeases retentionLeases,
+        final long mappingVersion,
+        StepListener<Void> sendListener
+    ) {
+        return new AllShardsOperationBatchSender(startingSeqNo, endingSeqNo, snapshot, maxSeenAutoIdTimestamp,
+            maxSeqNoOfUpdatesOrDeletes, retentionLeases, mappingVersion, sendListener);
+    }
+
+    @Override
+    protected List<SendSnapshotResult> createSnapshotResult(OperationBatchSender sender, int totalSentOps,
+                                                            TimeValue tookTime) {
+        assert sender instanceof AllShardsOperationBatchSender;
+        AllShardsOperationBatchSender allShardsSender = (AllShardsOperationBatchSender) sender;
+        List<SendSnapshotResult> sendSnapshotResults = new ArrayList<>(childShardsAllocationIds.size());
+        allShardsSender.targetLocalCheckpoints.forEach((allocationId, checkpoint) -> {
+            sendSnapshotResults.add(new SendSnapshotResult(checkpoint.get(), totalSentOps,
+                tookTime, allocationId));
+        });
+        return sendSnapshotResults;
+    }
+
+    protected class AllShardsOperationBatchSender extends OperationBatchSender {
+        private final Map<String, AtomicLong> targetLocalCheckpoints = new HashMap<>();
+        private final Closeable onClose;
+
+        protected AllShardsOperationBatchSender(
+            long startingSeqNo, long endingSeqNo, Translog.Snapshot snapshot,
+            long maxSeenAutoIdTimestamp, long maxSeqNoOfUpdatesOrDeletes,
+            RetentionLeases retentionLeases, long mappingVersion, ActionListener<Void> listener) {
+            super(startingSeqNo, endingSeqNo, snapshot, maxSeenAutoIdTimestamp,
+                maxSeqNoOfUpdatesOrDeletes, retentionLeases, mappingVersion, listener, false);
+
+            childShardsAllocationIds.forEach(childShardsAllocationId -> {
+                targetLocalCheckpoints.put(childShardsAllocationId, new AtomicLong(SequenceNumbers.NO_OPS_PERFORMED));
+            });
+
+            AtomicInteger closeCounter = new AtomicInteger(childShardsAllocationIds.size());
+            onClose = () -> {
+                if (closeCounter.decrementAndGet() == 0) {
+                    snapshot.close();
+                }
+            };
+        }
+
+        @Override
+        protected void executeChunkRequest(OperationChunkRequest request, ActionListener<Void> listener) {
+            cancellableThreads.checkForCancel();
+            recoveryTarget.indexTranslogOperationsOnShards(
+                request.getOperations(),
+                snapshot.totalOperations(),
+                maxSeenAutoIdTimestamp,
+                maxSeqNoOfUpdatesOrDeletes,
+                retentionLeases,
+                mappingVersion,
+                ActionListener.delegateFailure(listener, (l, allocationCheckpoints) -> {
+                    allocationCheckpoints.forEach(allocationCheckpoint -> {
+                        targetLocalCheckpoints.get(allocationCheckpoint.allocationId).updateAndGet(curr ->
+                            SequenceNumbers.max(curr, allocationCheckpoint.checkpoint));
+                    });
+                    l.onResponse(null);
+                })
+            );
+        }
+
+        @Override
+        public void close() throws IOException {
+            onClose.close();
+        }
+    }
+
+    public boolean isRecoveryStateInSync() {
+        return inSync;
+    }
+
+    protected void finalizeRecovery(StopWatch stopWatch, long trimAboveSeqNo, ActionListener<Void> listener) {
+        if (indexMetadata.getNumberOfReplicas() == 0) {
+            super.finalizeRecovery(stopWatch, trimAboveSeqNo, listener);
+            return;
+        }
+        Set<String> inSyncAllocationIds = sourceShard.getReplicationGroup().getInSyncAllocationIds();
+        recoveryContexts.forEach(context -> {
+            assert inSyncAllocationIds.contains(context.getIndexShard().routingEntry().allocationId().getId());
+        });
+
+        finalizer = () -> super.finalizeRecovery(new StopWatch().start(), trimAboveSeqNo, listener);
+        inSync = true;
+        onSync.accept(sourceShard.shardId());
+    }
+
+    public void performHandoff() {
+        assert finalizer != null;
+        finalizer.run();
+    }
+
+    private void cleanUpMaybeRemoteOnFinalize() {
+        Store remoteStore = sourceShard.remoteStore();
+        if (remoteStore != null) {
+            try(Releasable releasable = acquireStore(sourceShard.remoteStore())) {
+                resources.add(releasable);
+                sourceShard.cleanUpRemoteDirectories();
+            } catch (IOException e) {
+                logger.error("Failed to cleanup source shard remote directory", e);
+            }
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRecoveryTargetHandler.java b/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRecoveryTargetHandler.java
new file mode 100644
index 0000000000000..3f864ade9727d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRecoveryTargetHandler.java
@@ -0,0 +1,439 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices.recovery.inplacesplit;
+
+import org.apache.lucene.codecs.CodecUtil;
+import org.apache.lucene.index.IndexWriterConfig;
+import org.apache.lucene.index.SegmentInfos;
+import org.apache.lucene.misc.store.HardlinkCopyDirectoryWrapper;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.IOContext;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.util.ArrayUtil;
+import org.apache.lucene.util.IOUtils;
+import org.opensearch.action.LatchedActionListener;
+import org.opensearch.action.admin.indices.flush.FlushRequest;
+import org.opensearch.action.support.GroupedActionListener;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.common.CheckedRunnable;
+import org.opensearch.common.SetOnce;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.util.CancellableThreads;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.index.seqno.ReplicationTracker;
+import org.opensearch.index.seqno.RetentionLeases;
+import org.opensearch.index.shard.IndexShard;
+import org.opensearch.index.shard.StoreRecovery;
+import org.opensearch.index.store.Store;
+import org.opensearch.index.store.StoreFileMetadata;
+import org.opensearch.index.store.remote.metadata.RemoteSegmentMetadata;
+import org.opensearch.index.translog.Translog;
+import org.opensearch.indices.recovery.RecoveryTarget;
+import org.opensearch.indices.recovery.RecoveryTargetHandler;
+import org.opensearch.indices.replication.GetSegmentFilesResponse;
+import org.opensearch.indices.replication.RemoteStoreReplicationSource;
+import org.opensearch.indices.replication.SegmentReplicationSourceFactory;
+import org.opensearch.indices.replication.SegmentReplicationTarget;
+import org.opensearch.indices.replication.checkpoint.ReplicationCheckpoint;
+import org.opensearch.indices.replication.common.ReplicationFailedException;
+import org.opensearch.indices.replication.common.ReplicationListener;
+import org.opensearch.indices.replication.common.ReplicationState;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+
+import static org.opensearch.index.translog.Translog.TRANSLOG_UUID_KEY;
+
+public class InPlaceShardSplitRecoveryTargetHandler implements RecoveryTargetHandler, Closeable {
+    private final Map<ShardId, RecoveryTarget> recoveryTargets;
+    private final List<InPlaceShardRecoveryContext> recoveryContexts;
+    private final Set<String> childShardsAllocationIds;
+    private final IndexShard sourceShard;
+    private final CancellableThreads cancellableThreads;
+    private final SetOnce<Function<Store, Releasable>> storeAcquirer = new SetOnce<>();
+
+    private final ReplicationListener unSupportedTargetListener = new ReplicationListener() {
+        @Override
+        public void onDone(ReplicationState state) {
+            throw new UnsupportedOperationException(
+                "Recovery done callback is not supported on a target in in-place shard split recovery");
+        }
+
+        @Override
+        public void onFailure(ReplicationState state, ReplicationFailedException e, boolean sendShardFailure) {
+            throw new UnsupportedOperationException(
+                "Recovery failure callback is not supported on a target in in-place shard split recovery");
+        }
+    };
+
+    public InPlaceShardSplitRecoveryTargetHandler(final List<IndexShard> indexShards,
+                                                  final DiscoveryNode sourceNode,
+                                                  final CancellableThreads cancellableThreads,
+                                                  final List<InPlaceShardRecoveryContext> recoveryContexts,
+                                                  final Set<String> childShardsAllocationIds,
+                                                  final IndexShard sourceShard) {
+        Map<ShardId, RecoveryTarget> recoveryTargetMap = new HashMap<>();
+        indexShards.forEach(shard -> {
+            recoveryTargetMap.put(shard.shardId(),
+                new RecoveryTarget(shard, sourceNode, unSupportedTargetListener, sourceShard.getThreadPool(), cancellableThreads, true));
+        });
+        this.sourceShard = sourceShard;
+        this.recoveryTargets = Collections.unmodifiableMap(recoveryTargetMap);
+        this.recoveryContexts = recoveryContexts;
+        this.childShardsAllocationIds = childShardsAllocationIds;
+        this.cancellableThreads = cancellableThreads;
+    }
+
+    public void initStoreAcquirer(Function<Store, Releasable> storeAcquirer) {
+        this.storeAcquirer.set(storeAcquirer);
+    }
+
+    public void cleanShardDirectoriesForTargets() throws IOException {
+        for (InPlaceShardRecoveryContext context : recoveryContexts) {
+            cancellableThreads.checkForCancel();
+            IndexShard childShard = context.getIndexShard();
+            try(Releasable ignore = Objects.requireNonNull(storeAcquirer.get()).apply(childShard.store())) {
+                cleanUpStoreDirectory(childShard.store());
+            }
+            Store remoteStore = childShard.remoteStore();
+            if (remoteStore != null) {
+                try(Releasable ignore = Objects.requireNonNull(storeAcquirer.get()).apply(remoteStore)) {
+                    childShard.cleanUpRemoteDirectories();
+                }
+            }
+        }
+    }
+
+    public void cleanUpStoreDirectory(Store store) throws IOException {
+        Directory storeDirectory = store.directory();
+        for (String file : storeDirectory.listAll()) {
+            storeDirectory.deleteFile(file);
+        }
+    }
+
+    @Override
+    public void prepareForTranslogOperations(int totalTranslogOps, ActionListener<Void> listener) {
+        GroupedActionListener<Void> groupedActionListener = new GroupedActionListener<>(
+            ActionListener.wrap(res -> listener.onResponse(null), listener::onFailure),
+            recoveryTargets.size()
+        );
+        recoveryTargets.values().forEach(recoveryTarget -> {
+            cancellableThreads.checkForCancel();
+            recoveryTarget.prepareForTranslogOperations(totalTranslogOps, groupedActionListener);
+        });
+    }
+
+    public void indexTranslogOperationsOnShards(List<Translog.Operation> operations, int totalTranslogOps,
+                                        long maxSeenAutoIdTimestampOnPrimary, long maxSeqNoOfUpdatesOrDeletesOnPrimary,
+                                        RetentionLeases retentionLeases, long mappingVersionOnPrimary,
+                                                ActionListener<Collection<BatchOperationsResult>> listener) {
+
+        GroupedActionListener<BatchOperationsResult> groupedActionListener = new GroupedActionListener<>(
+            ActionListener.wrap(listener::onResponse, listener::onFailure),
+            recoveryContexts.size()
+        );
+
+        recoveryContexts.forEach(context -> {
+            RecoveryTarget recoveryTarget = recoveryTargets.get(context.getIndexShard().shardId());
+            cancellableThreads.checkForCancel();
+            String targetAllocationId = context.getIndexShard().routingEntry().allocationId().getId();
+            ActionListener<Long> checkpointListener = ActionListener.wrap(checkpoint -> {
+                groupedActionListener.onResponse(new BatchOperationsResult(checkpoint, targetAllocationId));
+            }, groupedActionListener::onFailure);
+            recoveryTarget.indexTranslogOperations(
+                operations,
+                totalTranslogOps,
+                maxSeenAutoIdTimestampOnPrimary,
+                maxSeqNoOfUpdatesOrDeletesOnPrimary,
+                retentionLeases,
+                mappingVersionOnPrimary,
+                checkpointListener
+            );
+        });
+    }
+
+    /**
+     * This is required because in translog replay of operations from translog snapshot, each operation is actually
+     * processed only on one of the child shards and other child shards treat it as a NoOp where only local checkpoint
+     * is advanced. In this case local checkpoint is also the global checkpoint since we are creating a new shard
+     * and hence a new replication group. In scenario where one or more of the child shards are relocated before
+     * next flush gets triggered, translog replay of operations from snapshot in these peer
+     * recoveries will not have no-ops and therefore, peer recovery will fail while waiting for target shard to
+     * catch up to global checkpoint. So, to make sure that operations till global checkpoint are available, we
+     * will need to trigger a flush to create a new commit on all child shards.
+     * Same principle is applicable till child shards are completely handed off to serve as independent shards
+     * because no-op ops can continue to arrive till it is done.
+     */
+    public void flushOnAllChildShards() {
+        recoveryContexts.forEach(recoveryTarget -> {
+            recoveryTarget.getIndexShard().flush(new FlushRequest().waitIfOngoing(true).force(true));
+        });
+    }
+
+    @Override
+    public void close() throws IOException {
+        recoveryTargets.values().forEach(recoveryTarget ->
+            IOUtils.closeWhileHandlingException(recoveryTarget::decRef));
+    }
+
+    public static class BatchOperationsResult {
+        final long checkpoint;
+        final String allocationId;
+
+        public BatchOperationsResult(long checkpoint, String allocationId) {
+            this.checkpoint = checkpoint;
+            this.allocationId = allocationId;
+        }
+    }
+
+    @Override
+    public void forceSegmentFileSync() {
+    }
+
+    @Override
+    public void finalizeRecovery(long globalCheckpoint, long trimAboveSeqNo, ActionListener<Void> listener) {
+        GroupedActionListener<Void> groupedActionListener = new GroupedActionListener<>(
+            ActionListener.wrap(res -> listener.onResponse(null), listener::onFailure),
+            recoveryContexts.size()
+        );
+        recoveryTargets.values().forEach(recoveryTarget -> {
+            cancellableThreads.checkForCancel();
+            recoveryTarget.finalizeRecovery(globalCheckpoint, trimAboveSeqNo, groupedActionListener);
+        });
+    }
+
+    @Override
+    public void handoffPrimaryContext(ReplicationTracker.PrimaryContext primaryContext) {
+        ShardRouting[] childShards = sourceShard.routingEntry().getRecoveringChildShards();
+
+        Map<Integer, Set<String>> shardIdToAllocationIds = new HashMap<>();
+        for (ShardRouting childShard : childShards) {
+            shardIdToAllocationIds.putIfAbsent(childShard.shardId().id(), new HashSet<>());
+            shardIdToAllocationIds.get(childShard.shardId().id()).add(childShard.allocationId().getId());
+        }
+
+        recoveryTargets.forEach((shardId, recoveryTarget) -> {
+            Set<String> childShardsAllocIds = shardIdToAllocationIds.get(shardId.id());
+            Map<String, ReplicationTracker.CheckpointState> checkpointStates = new HashMap<>();
+            for (String allocationId : childShardsAllocIds) {
+                if (primaryContext.getCheckpointStates().get(allocationId) == null) {
+                    throw new IllegalStateException("Allocation ID " + allocationId +
+                        " not found in synced checkpoint states of parent shard." + sourceShard.shardId());
+                }
+                ReplicationTracker.CheckpointState checkpointState = primaryContext.getCheckpointStates().get(allocationId);
+                if (sourceShard.remoteStore() != null &&
+                    recoveryTarget.indexShard().routingEntry().allocationId().getId().equals(allocationId) == false) {
+                    // This is needed to update replicated to false on child replicas because now there won't be any
+                    // doc rep replication on them.
+                    checkpointState = new ReplicationTracker.CheckpointState(
+                        checkpointState.getLocalCheckpoint(),
+                        checkpointState.getGlobalCheckpoint(),
+                        true,
+                        true,
+                        false
+                    );
+                }
+                checkpointStates.put(allocationId, checkpointState);
+                System.out.println("Primary context local checkpoint of shard " + shardId.id() + " is " + checkpointState.getLocalCheckpoint());
+            }
+            ReplicationTracker.PrimaryContext childPrimaryContext = new ReplicationTracker.PrimaryContext(
+                primaryContext.clusterStateVersion(),
+                checkpointStates,
+                primaryContext.getRoutingTable()
+            );
+
+            recoveryTarget.handoffPrimaryContext(childPrimaryContext);
+        });
+    }
+
+    @Override
+    public void indexTranslogOperations(
+        List<Translog.Operation> operations, int totalTranslogOps, long maxSeenAutoIdTimestampOnPrimary,
+        long maxSeqNoOfUpdatesOrDeletesOnPrimary, RetentionLeases retentionLeases, long mappingVersionOnPrimary,
+        ActionListener<Long> listener) {
+        throw new UnsupportedOperationException("Single shard method for indexing translog operations " +
+            "batch is not supported in in-place recovery");
+    }
+
+    @Override
+    public void receiveFileInfo(List<String> phase1FileNames, List<Long> phase1FileSizes,
+                                List<String> phase1ExistingFileNames, List<Long> phase1ExistingFileSizes,
+                                int totalTranslogOps, ActionListener<Void> listener) {
+        GroupedActionListener<Void> groupedActionListener = new GroupedActionListener<>(
+            ActionListener.wrap(res -> listener.onResponse(null), listener::onFailure),
+            recoveryContexts.size()
+        );
+
+        recoveryTargets.values().forEach(recoveryTarget -> recoveryTarget.receiveFileInfo(
+            phase1FileNames,
+            phase1FileSizes,
+            phase1ExistingFileNames,
+            phase1ExistingFileSizes,
+            totalTranslogOps,
+            groupedActionListener)
+        );
+    }
+
+    public void receiveFilesAndSplit(Store store, StoreFileMetadata[] files, long localCheckpoint, long maxSeqNo,
+                                     SplitCommitMetadata splitCommitMetadata,
+                                     long maxUnsafeAutoIdTimestamp)
+        throws Exception {
+
+        Releasable releaseSourceRemote = null;
+        Store remoteStore = sourceShard.remoteStore();
+        if (remoteStore != null) {
+            releaseSourceRemote = Objects.requireNonNull(storeAcquirer.get()).apply(sourceShard.remoteStore());
+        }
+
+        try {
+            for (InPlaceShardRecoveryContext context : recoveryContexts) {
+                try (Releasable ignore = Objects.requireNonNull(storeAcquirer.get()).apply(context.getIndexShard().store())) {
+                    Directory directory = syncLocalDirectory(store, files, context.getIndexShard());
+                    cancellableThreads.checkForCancel();
+                    split(localCheckpoint, maxSeqNo, maxUnsafeAutoIdTimestamp, directory, context);
+
+                    if (remoteStore != null) {
+                        cancellableThreads.checkForCancel();
+                        SegmentInfos segmentInfos = SegmentInfos.readLatestCommit(directory);
+                        ReplicationCheckpoint replicationCheckpoint = context.getIndexShard().computeReplicationCheckpoint(
+                            segmentInfos, sourceShard);
+                        Collection<String> localSegments = segmentInfos.files(true);
+                        long translogFileGen = splitCommitMetadata.getTranslogGen();
+
+                        // Perform a remote store to remote store copy if possible or else fallback to upload from local.
+                        try (Releasable ignoreRemote = Objects.requireNonNull(storeAcquirer.get()).apply(remoteStore)) {
+                            context.getIndexShard().copySegmentsAndMetadataToRemote(
+                                sourceShard.getRemoteDirectory(),
+                                directory,
+                                segmentInfos,
+                                replicationCheckpoint,
+                                localSegments,
+                                translogFileGen,
+                                splitCommitMetadata.getMetadataTuple().v2()
+                            );
+                        }
+                    }
+                }
+            }
+        } finally {
+            if (releaseSourceRemote != null) {
+                releaseSourceRemote.close();
+            }
+        }
+
+    }
+
+    public Directory syncLocalDirectory(Store store, StoreFileMetadata[] files, IndexShard childShard)
+        throws IOException {
+        ArrayUtil.timSort(files, Comparator.comparingLong(StoreFileMetadata::length));
+
+        Store childShardStore = childShard.store();
+        HardlinkCopyDirectoryWrapper hardLinkOrCopyTarget = new HardlinkCopyDirectoryWrapper(
+            childShardStore.directory());
+        for (StoreFileMetadata file : files) {
+            long sourceFileChecksum;
+            try (IndexInput indexInput = store.directory().openInput(file.name(), IOContext.READONCE)) {
+                sourceFileChecksum = CodecUtil.retrieveChecksum(indexInput);
+            }
+            if (childShard.localDirectoryContains(childShardStore.directory(), file.name(),
+                sourceFileChecksum) == false) {
+                hardLinkOrCopyTarget.copyFrom(store.directory(), file.name(), file.name(), IOContext.DEFAULT);
+            }
+        }
+
+        return hardLinkOrCopyTarget;
+    }
+
+    private void split(long localCheckpoint, long maxSeqNo, long maxUnsafeAutoIdTimestamp, Directory childShardDirectory,
+                       InPlaceShardRecoveryContext context) throws IOException {
+        Tuple<Boolean, Directory> addIndexSplitDirectory = new Tuple<>(false, childShardDirectory);
+
+        StoreRecovery.addIndices(
+            context.getRecoveryState().getIndex(),
+            sourceShard.getIndexSort(),
+            new Directory[]{childShardDirectory},
+            localCheckpoint,
+            maxSeqNo,
+            maxUnsafeAutoIdTimestamp,
+            sourceShard.indexSettings().getIndexMetadata(),
+            context.getIndexShard().shardId().id(),
+            true,
+            context.getIndexShard().mapperService().hasNested(),
+            addIndexSplitDirectory,
+            true,
+            IndexWriterConfig.OpenMode.APPEND
+        );
+    }
+
+    @Override
+    public void writeFileChunk(StoreFileMetadata fileMetadata, long position, BytesReference content, boolean lastChunk,
+                               int totalTranslogOps, ActionListener<Void> listener) {
+        throw new UnsupportedOperationException("In-place shard split recovery doesn't involve any file copy");
+    }
+
+    @Override
+    public void cleanFiles(int totalTranslogOps, long globalCheckpoint, Store.MetadataSnapshot sourceMetadata, ActionListener<Void> listener) {
+        GroupedActionListener<Void> groupedActionListener = new GroupedActionListener<>(
+            ActionListener.wrap(res -> listener.onResponse(null), listener::onFailure),
+            recoveryContexts.size()
+        );
+
+        String sourceTranslogUUID;
+        try {
+            sourceTranslogUUID = sourceShard.store().getMetadata().getCommitUserData().get(TRANSLOG_UUID_KEY);
+        } catch (Exception ex) {
+            listener.onFailure(ex);
+            return;
+        }
+
+        try {
+            for (InPlaceShardRecoveryContext context : recoveryContexts) {
+                try (Releasable ignore = Objects.requireNonNull(storeAcquirer.get()).apply(context.getIndexShard().store())) {
+                    context.getIndexShard().store().bootstrapNewHistory();
+
+                    try {
+                        // Associate store with source translog UUID. This may not be required for DocRep replication mode.
+                        context.getIndexShard().store().associateIndexWithNewTranslog(sourceTranslogUUID);
+                    } catch (Exception ex) {
+                        listener.onFailure(ex);
+                        return;
+                    }
+                    ShardId shardId = context.getIndexShard().shardId();
+                    RecoveryTarget recoveryTarget = recoveryTargets.get(shardId);
+                    recoveryTarget.cleanFiles(totalTranslogOps, globalCheckpoint, sourceMetadata, groupedActionListener);
+                }
+            }
+        } catch (Exception ex) {
+            listener.onFailure(ex);
+        }
+    }
+
+    public void onDone() {
+        recoveryContexts.forEach(context -> context.getIndexShard().postRecovery("In-Place shard split completed"));
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRemoteSourceHandler.java b/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRemoteSourceHandler.java
new file mode 100644
index 0000000000000..e8ccc596bdbc7
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitRemoteSourceHandler.java
@@ -0,0 +1,332 @@
+///*
+// * SPDX-License-Identifier: Apache-2.0
+// *
+// * The OpenSearch Contributors require contributions made to
+// * this file be licensed under the Apache-2.0 license or a
+// * compatible open source license.
+// */
+//
+//package org.opensearch.indices.recovery.inplacesplit;
+//
+//import org.apache.lucene.index.IndexCommit;
+//import org.apache.lucene.store.Directory;
+//import org.opensearch.action.StepListener;
+//import org.opensearch.common.SetOnce;
+//import org.opensearch.common.collect.Tuple;
+//import org.opensearch.common.concurrent.GatedCloseable;
+//import org.opensearch.common.lease.Releasable;
+//import org.opensearch.common.unit.TimeValue;
+//import org.opensearch.common.util.CancellableThreads;
+//import org.opensearch.common.util.io.IOUtils;
+//import org.opensearch.core.action.ActionListener;
+//import org.opensearch.core.index.shard.ShardId;
+//import org.opensearch.index.engine.Engine;
+//import org.opensearch.index.seqno.RetentionLeases;
+//import org.opensearch.index.seqno.SequenceNumbers;
+//import org.opensearch.index.shard.IndexShard;
+//import org.opensearch.index.store.Store;
+//import org.opensearch.index.store.StoreFileMetadata;
+//import org.opensearch.index.store.remote.metadata.RemoteSegmentMetadata;
+//import org.opensearch.index.translog.Translog;
+//import org.opensearch.indices.RunUnderPrimaryPermit;
+//import org.opensearch.indices.recovery.RecoveryResponse;
+//import org.opensearch.indices.recovery.RecoverySourceHandler;
+//import org.opensearch.indices.recovery.RemoteStorePeerRecoverySourceHandler;
+//import org.opensearch.indices.recovery.StartRecoveryRequest;
+//import org.opensearch.repositories.RepositoriesService;
+//import org.opensearch.threadpool.ThreadPool;
+//import org.opensearch.transport.Transports;
+//
+//import java.io.Closeable;
+//import java.io.IOException;
+//import java.util.ArrayList;
+//import java.util.Collection;
+//import java.util.Collections;
+//import java.util.HashMap;
+//import java.util.List;
+//import java.util.Map;
+//import java.util.Set;
+//import java.util.concurrent.atomic.AtomicLong;
+//import java.util.function.Consumer;
+//import java.util.function.IntSupplier;
+//
+//public class InPlaceShardSplitRemoteSourceHandler extends RecoverySourceHandler {
+//
+//    private final List<InPlaceShardRecoveryContext> recoveryContexts;
+//    private final InPlaceShardSplitRecoveryTargetHandler recoveryTarget;
+//    private final IndexShard sourceShard;
+//    private final RemoteStorePeerRecoverySourceHandler delegatingRecoveryHandler;
+//    private final List<ShardId> shardIds;
+//    private final Set<String> childShardsAllocationIds;
+//    private final RepositoriesService repositoriesService;
+//    private final SetOnce<Tuple<String, RemoteSegmentMetadata>> metadataTuple = new SetOnce<>();
+//    private final String IN_PLACE_SHARD_SPLIT_RECOVERY_NAME = "in-place-shard-split-recovery";
+//
+//    public InPlaceShardSplitRemoteSourceHandler(
+//        IndexShard sourceShard,
+//        ThreadPool threadPool,
+//        InPlaceShardSplitRecoveryTargetHandler recoveryTarget,
+//        RemoteStorePeerRecoverySourceHandler delegatingRecoveryHandler,
+//        StartRecoveryRequest request,
+//        int fileChunkSizeInBytes,
+//        int maxConcurrentFileChunks,
+//        int maxConcurrentOperations,
+//        CancellableThreads cancellableThreads,
+//        List<InPlaceShardRecoveryContext> recoveryContexts,
+//        List<ShardId> shardIds,
+//        Set<String> childShardsAllocationIds,
+//        RepositoriesService repositoriesService
+//    ) {
+//        super(sourceShard, recoveryTarget,
+//            threadPool, request, fileChunkSizeInBytes, maxConcurrentFileChunks,
+//            maxConcurrentOperations, true, cancellableThreads);
+//
+//        this.resources.add(recoveryTarget);
+//        this.recoveryContexts = recoveryContexts;
+//        this.sourceShard = sourceShard;
+//        this.delegatingRecoveryHandler = delegatingRecoveryHandler;
+//        this.shardIds = shardIds;
+//        this.childShardsAllocationIds = childShardsAllocationIds;
+//        this.recoveryTarget = recoveryTarget;
+//        this.repositoriesService = repositoriesService;
+//
+//        recoveryTarget.initStoreAcquirer((requestStore) -> {
+//            Releasable releasable = acquireStore(requestStore);
+//            resources.add(releasable);
+//            return releasable;
+//        });
+//    }
+//
+//    @Override
+//    protected void innerRecoveryToTarget(ActionListener<RecoveryResponse> listener,
+//                                         Consumer<Exception> onFailure) throws IOException {
+//        // Clean up shard directories if previous shard closures failed.
+//        cleanupChildShardDirectories();
+//
+//        List<Releasable> delayedStaleCommitDeleteOps = sourceShard.delayStaleCommitDeletions();
+//        resources.addAll(delayedStaleCommitDeleteOps);
+//        Closeable translogRetentionLock = sourceShard.acquireTranslogRetentionLock();
+//        resources.add(translogRetentionLock);
+//
+//        GatedCloseable<IndexCommit> lastCommit = acquireLastCommit(sourceShard,false);
+//        resources.add(lastCommit);
+//        Releasable releaseStore = acquireStore(sourceShard.remoteStore());
+//        resources.add(releaseStore);
+//
+//        Tuple<String, RemoteSegmentMetadata> fetchedMetadataTuple = sourceShard.getMetadataContentForCommit(
+//            sourceShard.getOperationPrimaryTerm(),
+//            lastCommit.get().getGeneration());
+//        ensureMetadataHasAllSegmentsFromCommit(lastCommit.get(), fetchedMetadataTuple.v2());
+//        this.metadataTuple.set(fetchedMetadataTuple);
+//
+//        final StepListener<SendFileResult> sendFileStep = new StepListener<>();
+//        final StepListener<TimeValue> prepareEngineStep = new StepListener<>();
+//        final StepListener<List<SendSnapshotResult>> sendSnapshotStep = new StepListener<>();
+//
+//        postSendFileComplete(sendFileStep, lastCommit, releaseStore, delayedStaleCommitDeleteOps);
+//        long startingSeqNo = Long.parseLong(lastCommit.get().getUserData().get(SequenceNumbers.LOCAL_CHECKPOINT_KEY)) + 1L;
+//
+//        assert Transports.assertNotTransportThread(this + "[phase1]");
+//        phase1(lastCommit.get(), startingSeqNo, () -> 0, sendFileStep, true);
+//
+//        prepareEngine(sendFileStep, prepareEngineStep, (int) (sourceShard.getLastKnownGlobalCheckpoint() - startingSeqNo), onFailure);
+//        initiateTracking();
+//
+//        prepareEngineStep.whenComplete(prepareEngineTime -> {
+//            // Do a refresh here. In case of remote replication, refresh will upload segments to remote child directories.
+//            recoveryTarget.refresh();
+//
+//            logger.debug("prepareEngineStep completed");
+//            assert Transports.assertNotTransportThread(this + "[phase2]");
+//            initiateTracking();
+//
+//            final long endingSeqNo = shard.seqNoStats().getMaxSeqNo();
+//            final Translog.Snapshot phase2Snapshot = phase2Snapshot(startingSeqNo, IN_PLACE_SHARD_SPLIT_RECOVERY_NAME);
+//            resources.add(phase2Snapshot);
+//            if (logger.isTraceEnabled()) {
+//                logger.trace("snapshot translog for recovery; current size is [{}]", countNumberOfHistoryOperations(startingSeqNo));
+//            }
+//            final long mappingVersionOnPrimary = shard.indexSettings().getIndexMetadata().getMappingVersion();
+//            phase2(
+//                startingSeqNo,
+//                endingSeqNo,
+//                phase2Snapshot,
+//                shard.getMaxSeenAutoIdTimestamp(),
+//                shard.getMaxSeqNoOfUpdatesOrDeletes(),
+//                shard.getRetentionLeases(),
+//                mappingVersionOnPrimary,
+//                sendSnapshotStep
+//            );
+//        }, onFailure);
+//
+//        StepListener<Void> finalizeStep = new StepListener<>();
+//        finalizeStep.whenComplete(r -> cleanUpMaybeRemoteOnFinalize(), onFailure);
+//        finalizeStepAndCompleteFuture(startingSeqNo, sendSnapshotStep, sendFileStepWithEmptyResult(), prepareEngineStep, finalizeStep, onFailure);
+//    }
+//
+//    public void cleanupChildShardDirectories() throws IOException {
+//        recoveryTarget.cleanShardDirectoriesForTargets();
+//    }
+//
+//    private void ensureMetadataHasAllSegmentsFromCommit(IndexCommit indexCommit, RemoteSegmentMetadata metadata) throws IOException {
+//        Collection<String> files = indexCommit.getFileNames();
+//        List<String> missingFiles = new ArrayList<>();
+//        for (String file : files) {
+//            if (metadata.getMetadata().containsKey(file) == false) {
+//                missingFiles.add(file);
+//            }
+//        }
+//
+//        if (missingFiles.isEmpty() == false) {
+//            throw new IllegalStateException("Missing segments in remote segments metadata. Missing files ["
+//                + missingFiles + "] for commit generation [" + indexCommit.getGeneration() + "]");
+//        }
+//    }
+//
+//    @Override
+//    public int countNumberOfHistoryOperations(long startingSeqNo) throws IOException {
+//        return 0;
+//    }
+//
+//    @Override
+//    public Closeable acquireRetentionLock() {
+//        return null;
+//    }
+//
+//    @Override
+//    public Translog.Snapshot phase2Snapshot(long startingSeqNo, String recoveryName){
+//        return null;
+//    }
+//
+//    @Override
+//    public boolean shouldSkipCreateRetentionLeaseStep() {
+//        return true;
+//    }
+//
+//    protected void sendFiles(Store store, StoreFileMetadata[] files, IntSupplier translogOps,
+//                             ActionListener<Void> listener, IndexCommit snapshot) {
+//        try {
+//            long maxSeqNo = Long.parseLong(snapshot.getUserData().get(SequenceNumbers.MAX_SEQ_NO));
+//            long maxUnsafeAutoIdTimestamp = Long.parseLong(snapshot.getUserData().get(
+//                Engine.MAX_UNSAFE_AUTO_ID_TIMESTAMP_COMMIT_ID));
+//            recoveryTarget.receiveFilesAndSyncLocalAndRemote(store, files, maxSeqNo, maxUnsafeAutoIdTimestamp,
+//                metadataTuple.get());
+//            listener.onResponse(null);
+//        } catch (Exception e) {
+//            listener.onFailure(e);
+//        }
+//    }
+//
+//    protected void postSendFileComplete(
+//        StepListener<SendFileResult> sendFileStep,
+//        GatedCloseable<IndexCommit> wrappedSafeCommit,
+//        Releasable releaseStore,
+//        List<Releasable> delayedStaleCommitOps
+//    ) {
+//        sendFileStep.whenComplete(r -> {
+//            logger.debug("sendFileStep completed");
+//            delayedStaleCommitOps.forEach(Releasable::close);
+//            IOUtils.close(wrappedSafeCommit, releaseStore);
+//        }, e -> {
+//            try {
+//                IOUtils.close(wrappedSafeCommit, releaseStore);
+//                delayedStaleCommitOps.forEach(Releasable::close);
+//            } catch (final IOException ex) {
+//                logger.warn("releasing snapshot caused exception", ex);
+//            }
+//        });
+//    }
+//
+//    public void prepareEngine(StepListener<SendFileResult> sendFileStep,
+//                                               StepListener<TimeValue> prepareEngineStep,
+//                                               int totalTranslogOps,
+//                                               Consumer<Exception> onFailure) {
+//        sendFileStep.whenComplete(r -> {
+//            logger.debug("sendFileStep completed");
+//            assert Transports.assertNotTransportThread(this + "[prepareTargetForTranslog]");
+//            // For a sequence based recovery, the target can keep its local translog
+//            prepareTargetForTranslog(totalTranslogOps, prepareEngineStep);
+//        }, onFailure);
+//    }
+//
+//    private void initiateTracking() {
+//        cancellableThreads.checkForCancel();
+//        List<String> allocationIDs = new ArrayList<>();
+//        recoveryContexts.forEach(context -> allocationIDs.add(context.getIndexShard()
+//            .routingEntry().allocationId().getId()));
+//
+//        RunUnderPrimaryPermit.run(
+//            () -> shard.initiateTrackingOfChildShards(allocationIDs),
+//            shardId + " initiating tracking of " + allocationIDs,
+//            shard,
+//            cancellableThreads,
+//            logger
+//        );
+//    }
+//
+//    @Override
+//    protected OperationBatchSender createSender(
+//        final long startingSeqNo,
+//        final long endingSeqNo,
+//        final Translog.Snapshot snapshot,
+//        final long maxSeenAutoIdTimestamp,
+//        final long maxSeqNoOfUpdatesOrDeletes,
+//        final RetentionLeases retentionLeases,
+//        final long mappingVersion,
+//        StepListener<Void> sendListener
+//    ) {
+//        return new AllShardsOperationBatchSender(startingSeqNo, endingSeqNo, snapshot, maxSeenAutoIdTimestamp,
+//            maxSeqNoOfUpdatesOrDeletes, retentionLeases, mappingVersion, sendListener);
+//    }
+//
+//    protected class AllShardsOperationBatchSender extends OperationBatchSender {
+//        private final Map<String, AtomicLong> targetLocalCheckpoints = new HashMap<>();
+//
+//        protected AllShardsOperationBatchSender(
+//            long startingSeqNo, long endingSeqNo, Translog.Snapshot snapshot,
+//            long maxSeenAutoIdTimestamp, long maxSeqNoOfUpdatesOrDeletes,
+//            RetentionLeases retentionLeases, long mappingVersion, ActionListener<Void> listener) {
+//            super(startingSeqNo, endingSeqNo, snapshot, maxSeenAutoIdTimestamp,
+//                maxSeqNoOfUpdatesOrDeletes, retentionLeases, mappingVersion, listener);
+//
+//            childShardsAllocationIds.forEach(childShardsAllocationId -> {
+//                targetLocalCheckpoints.put(childShardsAllocationId, new AtomicLong(SequenceNumbers.NO_OPS_PERFORMED));
+//            });
+//        }
+//
+//        @Override
+//        protected void executeChunkRequest(OperationChunkRequest request, ActionListener<Void> listener) {
+//            cancellableThreads.checkForCancel();
+//            recoveryTarget.indexTranslogOperationsOnShards(
+//                request.getOperations(),
+//                snapshot.totalOperations(),
+//                maxSeenAutoIdTimestamp,
+//                maxSeqNoOfUpdatesOrDeletes,
+//                retentionLeases,
+//                mappingVersion,
+//                ActionListener.delegateFailure(listener, (l, allocationCheckpoints) -> {
+//                    allocationCheckpoints.forEach(allocationCheckpoint -> {
+//                        targetLocalCheckpoints.get(allocationCheckpoint.allocationId).updateAndGet(curr ->
+//                            SequenceNumbers.max(curr, allocationCheckpoint.checkpoint));
+//                    });
+//                    l.onResponse(null);
+//                })
+//            );
+//        }
+//    }
+//
+//    private void cleanUpMaybeRemoteOnFinalize() {
+//        Store remoteStore = sourceShard.remoteStore();
+//        if (remoteStore != null) {
+//            try(Releasable releasable = acquireStore(sourceShard.remoteStore())) {
+//                resources.add(releasable);
+//                Directory storeDirectory = remoteStore.directory();
+//                for (String file : storeDirectory.listAll()) {
+//                    storeDirectory.deleteFile(file);
+//                }
+//            } catch (IOException e) {
+//                logger.error("Failed to cleanup source shard remote directory", e);
+//            }
+//        }
+//    }
+//}
diff --git a/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitResponseHandler.java b/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitResponseHandler.java
new file mode 100644
index 0000000000000..3b4d6ec2cf358
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardSplitResponseHandler.java
@@ -0,0 +1,96 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices.recovery.inplacesplit;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.store.AlreadyClosedException;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.index.shard.IndexShard;
+import org.opensearch.indices.recovery.RecoveryFailedException;
+import org.opensearch.indices.recovery.RecoveryResponse;
+import org.opensearch.indices.recovery.StartRecoveryRequest;
+import org.opensearch.indices.replication.common.ReplicationListener;
+import org.opensearch.indices.replication.common.ReplicationTimer;
+
+import java.util.List;
+
+import static org.opensearch.common.unit.TimeValue.timeValueMillis;
+
+public class InPlaceShardSplitResponseHandler implements ActionListener<RecoveryResponse> {
+    private static final Logger logger = LogManager.getLogger(InPlaceShardSplitResponseHandler.class);
+
+    private final ReplicationListener replicationListener;
+    private final StartRecoveryRequest request;
+    private final long recoveryId;
+    private final List<ReplicationTimer> timers;
+    private final InPlaceShardSplitRecoveryService.OngoingRecoveries ongoingRecoveries;
+    private final IndexShard sourceShard;
+
+    public InPlaceShardSplitResponseHandler(final ReplicationListener replicationListener, StartRecoveryRequest request,
+                                            final List<ReplicationTimer> timers,
+                                            InPlaceShardSplitRecoveryService.OngoingRecoveries ongoingRecoveries,
+                                            IndexShard sourceShard) {
+        this.replicationListener = replicationListener;
+        this.request = request;
+        this.recoveryId = request.recoveryId();
+        this.timers = timers;
+        this.ongoingRecoveries = ongoingRecoveries;
+        this.sourceShard = sourceShard;
+    }
+
+    @Override
+    public void onResponse(RecoveryResponse recoveryResponse) {
+        ongoingRecoveries.markAsDone(sourceShard);
+        long maxRecoveryTime = Long.MIN_VALUE;
+        for (ReplicationTimer timer : timers) {
+            maxRecoveryTime = Math.max(timer.time(), maxRecoveryTime);
+        }
+
+        final TimeValue recoveryTime = new TimeValue(maxRecoveryTime);
+        if (logger.isTraceEnabled()) {
+            StringBuilder sb = new StringBuilder();
+            sb.append('[')
+                .append(request.shardId().getIndex().getName())
+                .append(']')
+                .append('[')
+                .append(request.shardId().id())
+                .append("] ");
+            sb.append("in-place shard split recovery completed from ").append(request.sourceNode()).append(", took[").append(recoveryTime).append("]\n");
+            sb.append("   phase1: shard split ")
+                .append(", took [")
+                .append(timeValueMillis(recoveryResponse.getPhase1Time()))
+                .append(']')
+                .append("\n");
+            sb.append("   phase2: start took [").append(timeValueMillis(recoveryResponse.getStartTime())).append("]\n");
+            sb.append("         : recovered [")
+                .append(recoveryResponse.getPhase2Operations())
+                .append("]")
+                .append(" transaction log operations")
+                .append(", took [")
+                .append(timeValueMillis(recoveryResponse.getPhase2Time()))
+                .append("]")
+                .append("\n");
+            logger.trace("{}", sb);
+        } else {
+            logger.debug("{} recovery done from [{}], took [{}]", request.shardId(), request.sourceNode(), recoveryTime);
+        }
+    }
+
+    @Override
+    public void onFailure(Exception e) {
+        if (e instanceof AlreadyClosedException) {
+            ongoingRecoveries.fail(sourceShard, new RecoveryFailedException(request, "source shard is closed", e.getCause()), false);
+            return;
+        }
+        logger.error("Shard split failed for source shard " + sourceShard.shardId(), e);
+        ongoingRecoveries.fail(sourceShard, new RecoveryFailedException(request, e.getCause()), true);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardsRecoveryFailedException.java b/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardsRecoveryFailedException.java
new file mode 100644
index 0000000000000..4edbaa2b582bc
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/InPlaceShardsRecoveryFailedException.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices.recovery.inplacesplit;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.indices.replication.common.ReplicationFailedException;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Shard recovery exception in-place shard recovery.
+ *
+ * @opensearch.internal
+ */
+@ExperimentalApi
+public class InPlaceShardsRecoveryFailedException extends ReplicationFailedException {
+
+    public InPlaceShardsRecoveryFailedException(ShardId sourceShardId) {
+        super("Split of shard : " + sourceShardId + " failed.");
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/SplitCommitMetadata.java b/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/SplitCommitMetadata.java
new file mode 100644
index 0000000000000..a7263765e614b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/recovery/inplacesplit/SplitCommitMetadata.java
@@ -0,0 +1,33 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices.recovery.inplacesplit;
+
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.index.store.remote.metadata.RemoteSegmentMetadata;
+
+/**
+ * Container for metadata of commit acquired during shard split
+ */
+public class SplitCommitMetadata {
+    private final Long translogGen;
+    private final Tuple<String, RemoteSegmentMetadata> metadataTuple;
+
+    public SplitCommitMetadata(Long translogGen, Tuple<String, RemoteSegmentMetadata> metadataTuple) {
+        this.translogGen = translogGen;
+        this.metadataTuple = metadataTuple;
+    }
+
+    public Long getTranslogGen() {
+        return translogGen;
+    }
+
+    public Tuple<String, RemoteSegmentMetadata> getMetadataTuple() {
+        return metadataTuple;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/indices/replication/RemoteStoreReplicationSource.java b/server/src/main/java/org/opensearch/indices/replication/RemoteStoreReplicationSource.java
index b06b3e0497cf7..2f536b889f3de 100644
--- a/server/src/main/java/org/opensearch/indices/replication/RemoteStoreReplicationSource.java
+++ b/server/src/main/java/org/opensearch/indices/replication/RemoteStoreReplicationSource.java
@@ -100,7 +100,7 @@ public void getSegmentFiles(
         long replicationId,
         ReplicationCheckpoint checkpoint,
         List<StoreFileMetadata> filesToFetch,
-        IndexShard indexShard,
+        IndexShard targetShard,
         BiConsumer<String, Long> fileProgressTracker,
         ActionListener<GetSegmentFilesResponse> listener
     ) {
@@ -112,22 +112,15 @@ public void getSegmentFiles(
             logger.debug("Downloading segment files from remote store {}", filesToFetch);
 
             if (remoteMetadataExists()) {
-                final Directory storeDirectory = indexShard.store().directory();
-                final Collection<String> directoryFiles = List.of(storeDirectory.listAll());
+                final Directory targetStoreDirectory = targetShard.store().directory();
+                final Collection<String> directoryFiles = List.of(targetStoreDirectory.listAll());
                 final List<String> toDownloadSegmentNames = new ArrayList<>();
                 for (StoreFileMetadata fileMetadata : filesToFetch) {
                     String file = fileMetadata.name();
                     assert directoryFiles.contains(file) == false : "Local store already contains the file " + file;
                     toDownloadSegmentNames.add(file);
                 }
-                indexShard.getFileDownloader()
-                    .downloadAsync(
-                        cancellableThreads,
-                        remoteDirectory,
-                        new ReplicationStatsDirectoryWrapper(storeDirectory, fileProgressTracker),
-                        toDownloadSegmentNames,
-                        ActionListener.map(listener, r -> new GetSegmentFilesResponse(filesToFetch))
-                    );
+                syncFromRemote(filesToFetch, targetShard, fileProgressTracker, listener, toDownloadSegmentNames);
             } else {
                 listener.onResponse(new GetSegmentFilesResponse(filesToFetch));
             }
@@ -136,6 +129,24 @@ public void getSegmentFiles(
         }
     }
 
+    protected void syncFromRemote(
+        List<StoreFileMetadata> filesToFetch,
+        IndexShard targetShard,
+        BiConsumer<String, Long> fileProgressTracker,
+        ActionListener<GetSegmentFilesResponse> listener,
+        List<String> toSyncSegmentFiles
+    ) throws IOException {
+        final Directory targetStoreDirectory = targetShard.store().directory();
+        targetShard.getFileDownloader()
+            .downloadAsync(
+                cancellableThreads,
+                remoteDirectory,
+                new ReplicationStatsDirectoryWrapper(targetStoreDirectory, fileProgressTracker),
+                toSyncSegmentFiles,
+                ActionListener.map(listener, r -> new GetSegmentFilesResponse(filesToFetch))
+            );
+    }
+
     @Override
     public void cancel() {
         this.cancellableThreads.cancel("Canceled by target");
diff --git a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationSourceService.java b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationSourceService.java
index 21fd066b8be2f..da53d866e84a0 100644
--- a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationSourceService.java
+++ b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationSourceService.java
@@ -178,7 +178,7 @@ public void clusterChanged(ClusterChangedEvent event) {
             for (IndexService indexService : indicesService) {
                 if (indexService.getIndexSettings().isSegRepEnabledOrRemoteNode()) {
                     for (IndexShard indexShard : indexService) {
-                        if (indexShard.routingEntry().primary()) {
+                        if (indexShard.routingEntry().primary() && !indexShard.routingEntry().isSplitTarget()) {
                             final IndexMetadata indexMetadata = indexService.getIndexSettings().getIndexMetadata();
                             final Set<String> inSyncAllocationIds = new HashSet<>(
                                 indexMetadata.inSyncAllocationIds(indexShard.shardId().id())
diff --git a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTarget.java b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTarget.java
index 7131b49a41834..16990d29664dc 100644
--- a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTarget.java
+++ b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTarget.java
@@ -50,6 +50,7 @@ public class SegmentReplicationTarget extends ReplicationTarget {
 
     private final ReplicationCheckpoint checkpoint;
     private final SegmentReplicationSource source;
+    private final IndexShard sourceShard;
     private final SegmentReplicationState state;
     protected final MultiFileWriter multiFileWriter;
 
@@ -57,13 +58,15 @@ public class SegmentReplicationTarget extends ReplicationTarget {
 
     public SegmentReplicationTarget(
         IndexShard indexShard,
+        IndexShard sourceShard,
         ReplicationCheckpoint checkpoint,
         SegmentReplicationSource source,
         ReplicationListener listener
     ) {
-        super("replication_target", indexShard, new ReplicationLuceneIndex(), listener);
+        super("replication_target", indexShard, new ReplicationLuceneIndex(), listener, new CancellableThreads());
         this.checkpoint = checkpoint;
         this.source = source;
+        this.sourceShard = sourceShard;
         this.state = new SegmentReplicationState(
             indexShard.routingEntry(),
             stateIndex,
@@ -109,7 +112,7 @@ public SegmentReplicationState state() {
     }
 
     public SegmentReplicationTarget retryCopy() {
-        return new SegmentReplicationTarget(indexShard, checkpoint, source, listener);
+        return new SegmentReplicationTarget(indexShard, sourceShard, checkpoint, source, listener);
     }
 
     @Override
@@ -174,8 +177,9 @@ public void startReplication(ActionListener<Void> listener) {
         // Get list of files to copy from this checkpoint.
         state.setStage(SegmentReplicationState.Stage.GET_CHECKPOINT_INFO);
         cancellableThreads.checkForCancel();
-        source.getCheckpointMetadata(getId(), checkpoint, checkpointInfoListener);
-
+        ReplicationCheckpoint checkpointOfSourceShard = ReplicationCheckpoint.cloneCheckpointForShardId(
+            sourceShard.shardId(), checkpoint);
+        source.getCheckpointMetadata(getId(), checkpointOfSourceShard, checkpointInfoListener);
         checkpointInfoListener.whenComplete(checkpointInfo -> {
             final List<StoreFileMetadata> filesToFetch = getFiles(checkpointInfo);
             state.setStage(SegmentReplicationState.Stage.GET_FILES);
diff --git a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTargetService.java b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTargetService.java
index 8fee3f671ecc9..a64c942d68ee5 100644
--- a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTargetService.java
+++ b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTargetService.java
@@ -16,6 +16,7 @@
 import org.opensearch.cluster.ClusterChangedEvent;
 import org.opensearch.cluster.ClusterStateListener;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.routing.IndexShardRoutingTable;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.Nullable;
@@ -30,6 +31,7 @@
 import org.opensearch.index.shard.IndexEventListener;
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.index.shard.IndexShardState;
+import org.opensearch.index.shard.ShardNotFoundException;
 import org.opensearch.indices.IndicesService;
 import org.opensearch.indices.recovery.FileChunkRequest;
 import org.opensearch.indices.recovery.ForceSyncRequest;
@@ -187,19 +189,30 @@ public void clusterChanged(ClusterChangedEvent event) {
                 if (indexService.getIndexSettings().isSegRepEnabledOrRemoteNode()
                     && event.indexRoutingTableChanged(indexService.index().getName())) {
                     for (IndexShard shard : indexService) {
-                        if (shard.routingEntry().primary() == false && shard.routingEntry().isSearchOnly() == false) {
+                        if (shard.routingEntry().primary() == false && shard.routingEntry().isSearchOnly() == false
+                        && shard.routingEntry().getParentShardId() == null) {
                             // for this shard look up its primary routing, if it has completed a relocation trigger replication
-                            final String previousNode = event.previousState()
-                                .routingTable()
-                                .shardRoutingTable(shard.shardId())
-                                .primaryShard()
-                                .currentNodeId();
+
                             final String currentNode = event.state()
                                 .routingTable()
                                 .shardRoutingTable(shard.shardId())
                                 .primaryShard()
                                 .currentNodeId();
-                            if (previousNode.equals(currentNode) == false) {
+
+                            String previousNode;
+                            try {
+                                previousNode = event.previousState()
+                                    .routingTable()
+                                    .shardRoutingTable(shard.shardId())
+                                    .primaryShard()
+                                    .currentNodeId();
+                            } catch (ShardNotFoundException ex) {
+                                // This will be true when a parent shard have just split into new child shards and hence,
+                                // new entries in routing table are only available in latest cluster state.
+                                previousNode = null;
+                            }
+
+                            if (previousNode == null || previousNode.equals(currentNode) == false) {
                                 processLatestReceivedCheckpoint(shard, Thread.currentThread());
                             }
                         }
@@ -401,7 +414,12 @@ protected void updateVisibleCheckpoint(long replicationId, IndexShard replicaSha
         if (replicaShard.indexSettings().isAssignedOnRemoteNode() == false) {
             return;
         }
-        ShardRouting primaryShard = clusterService.state().routingTable().shardRoutingTable(replicaShard.shardId()).primaryShard();
+        ShardRouting primaryShard;
+        if (replicaShard.routingEntry().isSplitTarget()) {
+            primaryShard = clusterService.state().getRoutingNodes().primaryChild(replicaShard.getParentShardId(), replicaShard.shardId());
+        } else {
+            primaryShard = clusterService.state().routingTable().shardRoutingTable(replicaShard.shardId()).primaryShard();
+        }
 
         final UpdateVisibleCheckpointRequest request = new UpdateVisibleCheckpointRequest(
             replicationId,
diff --git a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicator.java b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicator.java
index ad3bc1933208c..3caf0df1b6d2a 100644
--- a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicator.java
+++ b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicator.java
@@ -97,7 +97,7 @@ SegmentReplicationTarget startReplication(
         final SegmentReplicationSource source,
         final SegmentReplicationTargetService.SegmentReplicationListener listener
     ) {
-        final SegmentReplicationTarget target = new SegmentReplicationTarget(indexShard, checkpoint, source, listener);
+        final SegmentReplicationTarget target = new SegmentReplicationTarget(indexShard, indexShard, checkpoint, source, listener);
         startReplication(target, indexShard.getRecoverySettings().activityTimeout());
         return target;
     }
diff --git a/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java b/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
index d1e2884956f5c..d110dd82b1ffb 100644
--- a/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
+++ b/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
@@ -13,6 +13,7 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.apache.lucene.store.AlreadyClosedException;
 import org.opensearch.ExceptionsHelper;
+import org.opensearch.action.PrimaryShardSplitException;
 import org.opensearch.action.support.ActionFilters;
 import org.opensearch.action.support.replication.ReplicationMode;
 import org.opensearch.action.support.replication.ReplicationResponse;
@@ -163,7 +164,8 @@ public void handleException(TransportException e) {
                             IndexNotFoundException.class,
                             AlreadyClosedException.class,
                             IndexShardClosedException.class,
-                            ShardNotInPrimaryModeException.class
+                            ShardNotInPrimaryModeException.class,
+                            PrimaryShardSplitException.class
                         ) != null) {
                             // Node is shutting down or the index was deleted or the shard is closed
                             return;
@@ -202,7 +204,8 @@ protected void shardOperationOnReplica(PublishCheckpointRequest request, IndexSh
             logger.trace(() -> new ParameterizedMessage("Checkpoint {} received on replica {}", request, replica.shardId()));
             // Condition for ensuring that we ignore Segrep checkpoints received on Docrep shard copies.
             // This case will hit iff the replica hosting node is not remote enabled and replication type != SEGMENT
-            if (replica.indexSettings().isAssignedOnRemoteNode() == false && replica.indexSettings().isSegRepLocalEnabled() == false) {
+            if (replica.indexSettings().isAssignedOnRemoteNode() == false && replica.indexSettings().isSegRepLocalEnabled() == false
+                && replica.routingEntry().isSplitTarget() == false) {
                 logger.trace("Received segrep checkpoint on a docrep shard copy during an ongoing remote migration. NoOp.");
                 return new ReplicaResult();
             }
diff --git a/server/src/main/java/org/opensearch/indices/replication/checkpoint/ReplicationCheckpoint.java b/server/src/main/java/org/opensearch/indices/replication/checkpoint/ReplicationCheckpoint.java
index 29410159a4955..d0c0181591fa4 100644
--- a/server/src/main/java/org/opensearch/indices/replication/checkpoint/ReplicationCheckpoint.java
+++ b/server/src/main/java/org/opensearch/indices/replication/checkpoint/ReplicationCheckpoint.java
@@ -79,6 +79,18 @@ public ReplicationCheckpoint(
         this.metadataMap = metadataMap;
     }
 
+    public static ReplicationCheckpoint cloneCheckpointForShardId(ShardId shardId, ReplicationCheckpoint checkpoint) {
+        return new ReplicationCheckpoint(
+            shardId,
+            checkpoint.getPrimaryTerm(),
+            checkpoint.getSegmentsGen(),
+            checkpoint.getSegmentInfosVersion(),
+            checkpoint.getLength(),
+            checkpoint.getCodec(),
+            checkpoint.getMetadataMap()
+        );
+    }
+
     public ReplicationCheckpoint(StreamInput in) throws IOException {
         shardId = new ShardId(in);
         primaryTerm = in.readLong();
diff --git a/server/src/main/java/org/opensearch/indices/replication/common/ReplicationLuceneIndex.java b/server/src/main/java/org/opensearch/indices/replication/common/ReplicationLuceneIndex.java
index cc52d2bafc614..45d055192d459 100644
--- a/server/src/main/java/org/opensearch/indices/replication/common/ReplicationLuceneIndex.java
+++ b/server/src/main/java/org/opensearch/indices/replication/common/ReplicationLuceneIndex.java
@@ -427,6 +427,9 @@ public void writeTo(StreamOutput out) throws IOException {
         }
 
         public void addRecoveredBytes(long bytes) {
+            if (reused) {
+                throw new IllegalStateException("Reused recovery bytes");
+            }
             assert reused == false : "file is marked as reused, can't update recovered bytes";
             assert bytes >= 0 : "can't recovered negative bytes. got [" + bytes + "]";
             recovered += bytes;
diff --git a/server/src/main/java/org/opensearch/indices/replication/common/ReplicationTarget.java b/server/src/main/java/org/opensearch/indices/replication/common/ReplicationTarget.java
index 76401eaabbf39..29a85e850c7ae 100644
--- a/server/src/main/java/org/opensearch/indices/replication/common/ReplicationTarget.java
+++ b/server/src/main/java/org/opensearch/indices/replication/common/ReplicationTarget.java
@@ -80,7 +80,8 @@ public CancellableThreads cancellableThreads() {
 
     public abstract void notifyListener(ReplicationFailedException e, boolean sendShardFailure);
 
-    public ReplicationTarget(String name, IndexShard indexShard, ReplicationLuceneIndex stateIndex, ReplicationListener listener) {
+    public ReplicationTarget(String name, IndexShard indexShard, ReplicationLuceneIndex stateIndex, ReplicationListener listener,
+                             CancellableThreads cancellableThreads) {
         super(name);
         this.logger = Loggers.getLogger(getClass(), indexShard.shardId());
         this.listener = listener;
@@ -89,7 +90,7 @@ public ReplicationTarget(String name, IndexShard indexShard, ReplicationLuceneIn
         this.indexShard = indexShard;
         this.store = indexShard.store();
         // make sure the store is not released until we are done.
-        this.cancellableThreads = new CancellableThreads();
+        this.cancellableThreads = cancellableThreads;
         store.incRef();
         if (indexShard.indexSettings().isAssignedOnRemoteNode()) {
             indexShard.remoteStore().incRef();
diff --git a/server/src/main/java/org/opensearch/indices/replication/common/ReplicationTimer.java b/server/src/main/java/org/opensearch/indices/replication/common/ReplicationTimer.java
index d884e1676f2be..9b56c91a1dbf1 100644
--- a/server/src/main/java/org/opensearch/indices/replication/common/ReplicationTimer.java
+++ b/server/src/main/java/org/opensearch/indices/replication/common/ReplicationTimer.java
@@ -48,7 +48,11 @@ public synchronized void writeTo(StreamOutput out) throws IOException {
     }
 
     public synchronized void start() {
-        assert startTime == 0 : "already started";
+        if (startTime != 0) {
+            // This needs to be handled properly because another flush (external?) operation can attempt to reset it
+            // before first one completes.
+            return;
+        }
         startTime = System.currentTimeMillis();
         startNanoTime = System.nanoTime();
     }
diff --git a/server/src/main/java/org/opensearch/node/Node.java b/server/src/main/java/org/opensearch/node/Node.java
index 704a23890b07a..643c95ea28ad5 100644
--- a/server/src/main/java/org/opensearch/node/Node.java
+++ b/server/src/main/java/org/opensearch/node/Node.java
@@ -77,6 +77,7 @@
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.metadata.MetadataCreateDataStreamService;
 import org.opensearch.cluster.metadata.MetadataCreateIndexService;
+import org.opensearch.cluster.metadata.MetadataInPlaceShardSplitService;
 import org.opensearch.cluster.metadata.MetadataIndexUpgradeService;
 import org.opensearch.cluster.metadata.SystemIndexMetadataUpgradeService;
 import org.opensearch.cluster.metadata.TemplateUpgradeService;
@@ -173,6 +174,7 @@
 import org.opensearch.indices.breaker.BreakerSettings;
 import org.opensearch.indices.breaker.HierarchyCircuitBreakerService;
 import org.opensearch.indices.cluster.IndicesClusterStateService;
+import org.opensearch.indices.recovery.inplacesplit.InPlaceShardSplitRecoveryService;
 import org.opensearch.indices.recovery.PeerRecoverySourceService;
 import org.opensearch.indices.recovery.PeerRecoveryTargetService;
 import org.opensearch.indices.recovery.RecoverySettings;
@@ -987,6 +989,15 @@ protected Node(
                 remoteStoreSettings,
                 repositoriesServiceReference::get
             );
+            final MetadataInPlaceShardSplitService metadataInPlaceShardSplitService = new MetadataInPlaceShardSplitService(
+                settings,
+                clusterService,
+                pluginsService,
+                indicesService,
+                clusterModule.getAllocationService(),
+                shardLimitValidator,
+                awarenessReplicaBalance
+            );
             pluginsService.filterPlugins(Plugin.class)
                 .forEach(
                     p -> p.getAdditionalIndexSettingProviders().forEach(metadataCreateIndexService::addAdditionalIndexSettingProvider)
@@ -1458,6 +1469,7 @@ protected Node(
                 b.bind(RemoteStoreStatsTrackerFactory.class).toInstance(remoteStoreStatsTrackerFactory);
                 b.bind(AliasValidator.class).toInstance(aliasValidator);
                 b.bind(MetadataCreateIndexService.class).toInstance(metadataCreateIndexService);
+                b.bind(MetadataInPlaceShardSplitService.class).toInstance(metadataInPlaceShardSplitService);
                 b.bind(AwarenessReplicaBalance.class).toInstance(awarenessReplicaBalance);
                 b.bind(MetadataCreateDataStreamService.class).toInstance(metadataCreateDataStreamService);
                 b.bind(ViewService.class).toInstance(viewService);
@@ -1476,8 +1488,11 @@ protected Node(
                 b.bind(Discovery.class).toInstance(discoveryModule.getDiscovery());
                 b.bind(RemoteStoreSettings.class).toInstance(remoteStoreSettings);
                 {
+                    InPlaceShardSplitRecoveryService splitRecoveryService = newInPlaceShardSplitRecoveryService(
+                        indicesService, recoverySettings);
+                    b.bind(InPlaceShardSplitRecoveryService.class).toInstance(splitRecoveryService);
                     b.bind(PeerRecoverySourceService.class)
-                        .toInstance(new PeerRecoverySourceService(transportService, indicesService, recoverySettings));
+                        .toInstance(new PeerRecoverySourceService(transportService, indicesService, recoverySettings, splitRecoveryService));
                     b.bind(PeerRecoveryTargetService.class)
                         .toInstance(new PeerRecoveryTargetService(threadPool, transportService, recoverySettings, clusterService));
                     b.bind(SegmentReplicationTargetService.class)
@@ -1494,6 +1509,7 @@ protected Node(
                         );
                     b.bind(SegmentReplicationSourceService.class)
                         .toInstance(new SegmentReplicationSourceService(indicesService, transportService, recoverySettings));
+
                 }
                 b.bind(HttpServerTransport.class).toInstance(httpServerTransport);
                 pluginComponents.stream().forEach(p -> b.bind((Class) p.getClass()).toInstance(p));
@@ -1549,6 +1565,7 @@ protected Node(
             );
             resourcesToClose.addAll(pluginLifecycleComponents);
             resourcesToClose.add(injector.getInstance(PeerRecoverySourceService.class));
+            resourcesToClose.add(injector.getInstance(InPlaceShardSplitRecoveryService.class));
             this.pluginLifecycleComponents = Collections.unmodifiableList(pluginLifecycleComponents);
             DynamicActionRegistry dynamicActionRegistry = actionModule.getDynamicActionRegistry();
             dynamicActionRegistry.registerUnmodifiableActionMap(injector.getInstance(new Key<Map<ActionType, TransportAction>>() {
@@ -1588,6 +1605,11 @@ protected TransportService newTransportService(
         return new TransportService(settings, transport, threadPool, interceptor, localNodeFactory, clusterSettings, taskHeaders, tracer);
     }
 
+    protected InPlaceShardSplitRecoveryService newInPlaceShardSplitRecoveryService(
+        IndicesService indicesService, RecoverySettings recoverySettings) {
+        return new InPlaceShardSplitRecoveryService(indicesService, recoverySettings);
+    }
+
     /**
      * The settings that are used by this node. Contains original settings as well as additional settings provided by plugins.
      */
@@ -1669,6 +1691,7 @@ public Node start() throws NodeValidationException {
         injector.getInstance(PeerRecoverySourceService.class).start();
         injector.getInstance(SegmentReplicationTargetService.class).start();
         injector.getInstance(SegmentReplicationSourceService.class).start();
+        injector.getInstance(InPlaceShardSplitRecoveryService.class).start();
 
         final RemoteClusterStateService remoteClusterStateService = injector.getInstance(RemoteClusterStateService.class);
         if (remoteClusterStateService != null) {
@@ -1868,6 +1891,7 @@ public synchronized void close() throws IOException {
         toClose.add(injector.getInstance(PeerRecoverySourceService.class));
         toClose.add(injector.getInstance(SegmentReplicationSourceService.class));
         toClose.add(injector.getInstance(SegmentReplicationTargetService.class));
+        toClose.add(injector.getInstance(InPlaceShardSplitRecoveryService.class));
         toClose.add(() -> stopWatch.stop().start("cluster"));
         toClose.add(injector.getInstance(ClusterService.class));
         toClose.add(() -> stopWatch.stop().start("node_connections_service"));
diff --git a/server/src/main/java/org/opensearch/plugins/Plugin.java b/server/src/main/java/org/opensearch/plugins/Plugin.java
index 33c4155d12c25..26aee5617518a 100644
--- a/server/src/main/java/org/opensearch/plugins/Plugin.java
+++ b/server/src/main/java/org/opensearch/plugins/Plugin.java
@@ -48,6 +48,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.common.io.stream.NamedWriteable;
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.index.Index;
 import org.opensearch.core.xcontent.NamedXContentRegistry;
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.env.Environment;
@@ -68,6 +69,7 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.function.UnaryOperator;
 
@@ -278,4 +280,8 @@ public Collection<IndexSettingProvider> getAdditionalIndexSettingProviders() {
     public Optional<SecureSettingsFactory> getSecureSettingFactory(Settings settings) {
         return Optional.empty();
     }
+
+    public Predicate<Index> shardSplitAllowedPredicate() {
+        return (index) -> true;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/plugins/PluginsService.java b/server/src/main/java/org/opensearch/plugins/PluginsService.java
index 9bc1f1334122e..5fa4301a7f154 100644
--- a/server/src/main/java/org/opensearch/plugins/PluginsService.java
+++ b/server/src/main/java/org/opensearch/plugins/PluginsService.java
@@ -51,6 +51,7 @@
 import org.opensearch.common.settings.Setting.Property;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.common.Strings;
+import org.opensearch.core.index.Index;
 import org.opensearch.core.service.ReportingService;
 import org.opensearch.index.IndexModule;
 import org.opensearch.semver.SemverRange;
@@ -81,6 +82,7 @@
 import java.util.Set;
 import java.util.TreeMap;
 import java.util.function.Function;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 import static org.opensearch.core.util.FileSystemUtils.isAccessibleDirectory;
@@ -102,6 +104,7 @@ public class PluginsService implements ReportingService<PluginsAndModules> {
      */
     private final List<Tuple<PluginInfo, Plugin>> plugins;
     private final PluginsAndModules info;
+    private final Map<String, Predicate<Index>> shardSplitAllowedPredicates;
 
     public static final Setting<List<String>> MANDATORY_SETTING = Setting.listSetting(
         "plugin.mandatory",
@@ -196,6 +199,12 @@ public PluginsService(
 
         List<Tuple<PluginInfo, Plugin>> loaded = loadBundles(seenBundles);
         pluginsLoaded.addAll(loaded);
+        this.shardSplitAllowedPredicates = new HashMap<>();
+        pluginsLoaded.forEach(tuple -> shardSplitAllowedPredicates.put(
+            tuple.v1().getName(),
+            tuple.v2().shardSplitAllowedPredicate())
+        );
+
 
         this.info = new PluginsAndModules(pluginsList, modulesList);
         this.plugins = Collections.unmodifiableList(pluginsLoaded);
@@ -237,6 +246,20 @@ private static void logPluginInfo(final List<PluginInfo> pluginInfos, final Stri
         }
     }
 
+    public Tuple<Boolean, String> isShardSplitAllowed(Index index) {
+        List<String> unSupportedPlugins = new ArrayList<>();
+        shardSplitAllowedPredicates.keySet().forEach(plugin -> {
+            if (shardSplitAllowedPredicates.get(plugin).test(index) == false) {
+                unSupportedPlugins.add(plugin);
+            }
+        });
+
+        if (unSupportedPlugins.isEmpty()) {
+            return new Tuple<>(true, null);
+        }
+        return new Tuple<>(false, unSupportedPlugins.toString());
+    }
+
     public Settings updatedSettings() {
         Map<String, String> foundSettings = new HashMap<>();
         final Map<String, String> features = new TreeMap<>();
diff --git a/server/src/main/java/org/opensearch/rest/action/admin/indices/RestInPlaceShardSplitHandler.java b/server/src/main/java/org/opensearch/rest/action/admin/indices/RestInPlaceShardSplitHandler.java
new file mode 100644
index 0000000000000..c298351ed7f84
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/action/admin/indices/RestInPlaceShardSplitHandler.java
@@ -0,0 +1,83 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.rest.action.admin.indices;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.action.admin.indices.split.InPlaceShardSplitAction;
+import org.opensearch.action.admin.indices.split.InPlaceShardSplitRequest;
+import org.opensearch.client.node.NodeClient;
+import org.opensearch.common.logging.DeprecationLogger;
+import org.opensearch.rest.BaseRestHandler;
+import org.opensearch.rest.RestRequest;
+import org.opensearch.rest.action.RestToXContentListener;
+import org.opensearch.tasks.LoggingTaskListener;
+
+import java.io.IOException;
+import java.util.List;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.unmodifiableList;
+import static org.opensearch.action.support.master.AcknowledgedRequest.DEFAULT_TASK_EXECUTION_TIMEOUT;
+import static org.opensearch.rest.RestRequest.Method.POST;
+import static org.opensearch.rest.RestRequest.Method.PUT;
+
+public class RestInPlaceShardSplitHandler extends BaseRestHandler {
+    private static final Logger logger = LogManager.getLogger(RestInPlaceShardSplitHandler.class);
+    private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(logger.getName());
+
+    @Override
+    public String getName() {
+        return "in_place_shard_split_action";
+    }
+
+    @Override
+    public List<Route> routes() {
+        return unmodifiableList(
+            asList(new Route(POST, "/{index}/_shard/{shard_id}/_split"), new Route(PUT, "/{index}/_shard/{shard_id}/_split"))
+        );
+    }
+
+    @Override
+    protected RestChannelConsumer prepareRequest(RestRequest request, NodeClient client) throws IOException {
+
+        InPlaceShardSplitRequest inPlaceShardSplitRequest = new InPlaceShardSplitRequest(
+            request.param("index"),
+            request.paramAsInt("shard_id", -1),
+            request.paramAsInt("number_of_splits", -1)
+        );
+        request.applyContentParser(inPlaceShardSplitRequest::fromXContent);
+        inPlaceShardSplitRequest.timeout(request.paramAsTime("timeout", inPlaceShardSplitRequest.timeout()));
+        inPlaceShardSplitRequest.clusterManagerNodeTimeout(
+            request.paramAsTime("cluster_manager_timeout", inPlaceShardSplitRequest.clusterManagerNodeTimeout())
+        );
+        parseDeprecatedMasterTimeoutParameter(inPlaceShardSplitRequest, request, deprecationLogger, getName());
+
+        if (request.paramAsBoolean("wait_for_completion", true)) {
+            return channel -> client.admin().indices().inPlaceShardSplit(inPlaceShardSplitRequest, new RestToXContentListener<>(channel));
+        } else {
+            // running resizing index asynchronously, return a task immediately and store the task's result when it completes
+            inPlaceShardSplitRequest.setShouldStoreResult(true);
+            inPlaceShardSplitRequest.timeout(request.paramAsTime("task_execution_timeout", DEFAULT_TASK_EXECUTION_TIMEOUT));
+            /*
+             * Add some validation before so the user can get some error immediately. The
+             * task can't totally validate until it starts but this is better than nothing.
+             */
+            ActionRequestValidationException validationException = inPlaceShardSplitRequest.validate();
+            if (validationException != null) {
+                throw validationException;
+            }
+            return sendTask(
+                client.getLocalNodeId(),
+                client.executeLocally(InPlaceShardSplitAction.INSTANCE, inPlaceShardSplitRequest, LoggingTaskListener.instance())
+            );
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/RestShardsAction.java b/server/src/main/java/org/opensearch/rest/action/cat/RestShardsAction.java
index 04212b6b057fe..37cf208adfcd1 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/RestShardsAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/RestShardsAction.java
@@ -70,6 +70,7 @@
 import java.time.Instant;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
 import java.util.function.Function;
 
 import static java.util.Arrays.asList;
@@ -347,7 +348,11 @@ Table buildTable(
                     table.addCell("r");
                 }
             }
-            table.addCell(shard.state());
+            if (shard.splitting()) {
+                table.addCell("SPLITTING");
+            } else {
+                table.addCell(shard.state());
+            }
             table.addCell(getOrNull(commonStats, CommonStats::getDocs, DocsStats::getCount));
             table.addCell(getOrNull(commonStats, CommonStats::getStore, StoreStats::getSize));
             if (shard.assignedToNode()) {
@@ -365,6 +370,12 @@ Table buildTable(
                     name.append(reloNodeId);
                     name.append(" ");
                     name.append(reloNme);
+                } else if (shard.splitting()) {
+                    name.append(" -> ");
+                    for (ShardRouting childShard : shard.getRecoveringChildShards()) {
+                        name.append(childShard.shardId().getId());
+                        name.append(" ");
+                    }
                 }
                 table.addCell(ip);
                 table.addCell(nodeId);
diff --git a/server/src/main/java/org/opensearch/snapshots/RestoreService.java b/server/src/main/java/org/opensearch/snapshots/RestoreService.java
index 4b5bd951f80a0..2744b0a862159 100644
--- a/server/src/main/java/org/opensearch/snapshots/RestoreService.java
+++ b/server/src/main/java/org/opensearch/snapshots/RestoreService.java
@@ -785,7 +785,8 @@ private void validateExistingIndex(
                             );
                         }
                         // Make sure that the number of shards is the same. That's the only thing that we cannot change
-                        if (currentIndexMetadata.getNumberOfShards() != snapshotIndexMetadata.getNumberOfShards()) {
+                        if (currentIndexMetadata.getSplitShardsMetadata().getNumberOfRootShards() !=
+                            snapshotIndexMetadata.getSplitShardsMetadata().getNumberOfRootShards()) {
                             throw new SnapshotRestoreException(
                                 snapshot,
                                 "cannot restore index ["
diff --git a/server/src/main/resources/org/opensearch/bootstrap/security.policy b/server/src/main/resources/org/opensearch/bootstrap/security.policy
index 22e445f7d9022..cf329a231e6c0 100644
--- a/server/src/main/resources/org/opensearch/bootstrap/security.policy
+++ b/server/src/main/resources/org/opensearch/bootstrap/security.policy
@@ -174,6 +174,13 @@ grant {
   // load averages on Linux
   permission java.io.FilePermission "/proc/loadavg", "read";
 
+  permission java.io.FilePermission "/Users/vikasvb/Downloads/arthas/-", "read";
+  permission java.io.FilePermission "/Users/vikasvb/logs/-", "read, write";
+  permission java.lang.RuntimePermission "*";
+  permission java.io.FilePermission "arthas-output", "read, write";
+  permission java.io.FilePermission "/Users/vikasvb/.arthas/history", "read, write";
+  permission java.net.SocketPermission "*", "connect,accept,resolve";
+
   // read max virtual memory areas
   permission java.io.FilePermission "/proc/sys/vm/max_map_count", "read";
 
diff --git a/server/src/test/java/org/opensearch/action/support/replication/ReplicationOperationTests.java b/server/src/test/java/org/opensearch/action/support/replication/ReplicationOperationTests.java
index 6eb697d493bf4..e149b0a0b1659 100644
--- a/server/src/test/java/org/opensearch/action/support/replication/ReplicationOperationTests.java
+++ b/server/src/test/java/org/opensearch/action/support/replication/ReplicationOperationTests.java
@@ -1281,7 +1281,8 @@ public void performOn(
             final long primaryTerm,
             final long globalCheckpoint,
             final long maxSeqNoOfUpdatesOrDeletes,
-            final ActionListener<ReplicationOperation.ReplicaResponse> listener
+            final ActionListener<ReplicationOperation.ReplicaResponse> listener,
+            final boolean replicatingToChild
         ) {
             boolean added = request.processedOnReplicas.add(replica);
             if (retryable == false) {
diff --git a/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationActionTests.java b/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationActionTests.java
index 4a18778cc0b2b..9813e0231e4f3 100644
--- a/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationActionTests.java
+++ b/server/src/test/java/org/opensearch/action/support/replication/TransportReplicationActionTests.java
@@ -888,7 +888,8 @@ public void testReplicaProxy() throws InterruptedException, ExecutionException {
             primaryTerm,
             randomNonNegativeLong(),
             randomNonNegativeLong(),
-            listener
+            listener,
+            randomBoolean()
         );
         assertTrue(listener.isDone());
         assertListenerThrows("non existent node should throw a NoNodeAvailableException", listener, NoNodeAvailableException.class);
@@ -898,7 +899,7 @@ public void testReplicaProxy() throws InterruptedException, ExecutionException {
             shardRoutings.replicaShards().stream().filter(ShardRouting::assignedToNode).collect(Collectors.toList())
         );
         listener = new PlainActionFuture<>();
-        proxy.performOn(replica, new Request(NO_SHARD_ID), primaryTerm, randomNonNegativeLong(), randomNonNegativeLong(), listener);
+        proxy.performOn(replica, new Request(NO_SHARD_ID), primaryTerm, randomNonNegativeLong(), randomNonNegativeLong(), listener, randomBoolean());
         assertFalse(listener.isDone());
 
         CapturingTransport.CapturedRequest[] captures = transport.getCapturedRequestsAndClear();
diff --git a/server/src/test/java/org/opensearch/action/support/replication/TransportWriteActionTests.java b/server/src/test/java/org/opensearch/action/support/replication/TransportWriteActionTests.java
index b4549f82230bf..f3d2fa8b08cfa 100644
--- a/server/src/test/java/org/opensearch/action/support/replication/TransportWriteActionTests.java
+++ b/server/src/test/java/org/opensearch/action/support/replication/TransportWriteActionTests.java
@@ -330,7 +330,8 @@ public void testReplicaProxy() throws InterruptedException, ExecutionException {
             primaryTerm,
             randomNonNegativeLong(),
             randomNonNegativeLong(),
-            listener
+            listener,
+            randomBoolean()
         );
         assertTrue(listener.isDone());
         assertListenerThrows("non existent node should throw a NoNodeAvailableException", listener, NoNodeAvailableException.class);
@@ -340,7 +341,7 @@ public void testReplicaProxy() throws InterruptedException, ExecutionException {
             shardRoutings.replicaShards().stream().filter(ShardRouting::assignedToNode).collect(Collectors.toList())
         );
         listener = new PlainActionFuture<>();
-        proxy.performOn(replica, new TestRequest(), primaryTerm, randomNonNegativeLong(), randomNonNegativeLong(), listener);
+        proxy.performOn(replica, new TestRequest(), primaryTerm, randomNonNegativeLong(), randomNonNegativeLong(), listener, randomBoolean());
         assertFalse(listener.isDone());
 
         CapturingTransport.CapturedRequest[] captures = transport.getCapturedRequestsAndClear();
diff --git a/server/src/test/java/org/opensearch/cluster/action/shard/ShardFailedClusterStateTaskExecutorTests.java b/server/src/test/java/org/opensearch/cluster/action/shard/ShardFailedClusterStateTaskExecutorTests.java
index 564af1841daee..899f5a7bbf781 100644
--- a/server/src/test/java/org/opensearch/cluster/action/shard/ShardFailedClusterStateTaskExecutorTests.java
+++ b/server/src/test/java/org/opensearch/cluster/action/shard/ShardFailedClusterStateTaskExecutorTests.java
@@ -180,7 +180,10 @@ public void testIllegalShardFailureRequests() throws Exception {
                     randomIntBetween(1, (int) primaryTerm - 1),
                     failingTask.message,
                     failingTask.failure,
-                    randomBoolean()
+                    randomBoolean(),
+                    null,
+                    null,
+                    null
                 )
             );
         }
@@ -219,7 +222,10 @@ public void testMarkAsStaleWhenFailingShard() throws Exception {
                 primaryTerm,
                 "dummy",
                 null,
-                false
+                false,
+                null,
+                null,
+                null
             );
             ClusterState appliedState = executor.execute(clusterState, Collections.singletonList(failShardOnly)).resultingState;
             Set<String> newInSync = appliedState.metadata().index(INDEX).inSyncAllocationIds(0);
@@ -233,7 +239,10 @@ public void testMarkAsStaleWhenFailingShard() throws Exception {
                 primaryTerm,
                 "dummy",
                 null,
-                true
+                true,
+                null,
+                null,
+                null
             );
             ClusterState appliedState = executor.execute(clusterState, Collections.singletonList(failAndMarkAsStale)).resultingState;
             Set<String> newInSync = appliedState.metadata().index(INDEX).inSyncAllocationIds(0);
@@ -293,7 +302,10 @@ private List<ShardStateAction.FailedShardEntry> createNonExistentShards(ClusterS
                     0L,
                     existingShard.message,
                     existingShard.failure,
-                    randomBoolean()
+                    randomBoolean(),
+                    existingShard.splitFailed,
+                    existingShard.parentShardId,
+                    existingShard.parentAllocationId
                 )
             );
         }
@@ -307,7 +319,10 @@ private List<ShardStateAction.FailedShardEntry> createNonExistentShards(ClusterS
                     0L,
                     reason,
                     new CorruptIndexException("simulated", nonExistentIndexUUID),
-                    randomBoolean()
+                    randomBoolean(),
+                    null,
+                    null,
+                    null
                 )
             )
         );
@@ -397,7 +412,10 @@ private static List<ShardStateAction.FailedShardEntry> toTasks(
                     randomBoolean() ? 0L : currentState.metadata().getIndexSafe(shard.index()).primaryTerm(shard.id()),
                     message,
                     new CorruptIndexException("simulated", indexUUID),
-                    randomBoolean()
+                    randomBoolean(),
+                    null,
+                    null,
+                    null
                 )
             )
             .collect(Collectors.toList());
diff --git a/server/src/test/java/org/opensearch/cluster/action/shard/ShardStartedClusterStateTaskExecutorTests.java b/server/src/test/java/org/opensearch/cluster/action/shard/ShardStartedClusterStateTaskExecutorTests.java
index 3dee3507ae71a..8b5a6a0195153 100644
--- a/server/src/test/java/org/opensearch/cluster/action/shard/ShardStartedClusterStateTaskExecutorTests.java
+++ b/server/src/test/java/org/opensearch/cluster/action/shard/ShardStartedClusterStateTaskExecutorTests.java
@@ -95,7 +95,7 @@ public void testEmptyTaskListProducesSameClusterState() throws Exception {
 
     public void testNonExistentIndexMarkedAsSuccessful() throws Exception {
         final ClusterState clusterState = stateWithNoShard();
-        final StartedShardEntry entry = new StartedShardEntry(new ShardId("test", "_na", 0), "aId", randomNonNegativeLong(), "test");
+        final StartedShardEntry entry = new StartedShardEntry(new ShardId("test", "_na", 0), "aId", randomNonNegativeLong(), "test", null, null, null);
 
         final ClusterStateTaskExecutor.ClusterTasksResult result = executeTasks(clusterState, singletonList(entry));
         assertSame(clusterState, result.resultingState);
@@ -112,10 +112,12 @@ public void testNonExistentShardsAreMarkedAsSuccessful() throws Exception {
         final List<StartedShardEntry> tasks = Stream.concat(
             // Existent shard id but different allocation id
             IntStream.range(0, randomIntBetween(1, 5))
-                .mapToObj(i -> new StartedShardEntry(new ShardId(indexMetadata.getIndex(), 0), String.valueOf(i), 0L, "allocation id")),
+                .mapToObj(
+                    i -> new StartedShardEntry(new ShardId(indexMetadata.getIndex(), 0), String.valueOf(i), 0L, "allocation id", null, null, null)
+                ),
             // Non existent shard id
             IntStream.range(1, randomIntBetween(2, 5))
-                .mapToObj(i -> new StartedShardEntry(new ShardId(indexMetadata.getIndex(), i), String.valueOf(i), 0L, "shard id"))
+                .mapToObj(i -> new StartedShardEntry(new ShardId(indexMetadata.getIndex(), i), String.valueOf(i), 0L, "shard id", null, null, null))
 
         ).collect(Collectors.toList());
 
@@ -143,7 +145,7 @@ public void testNonInitializingShardAreMarkedAsSuccessful() throws Exception {
                 allocationId = shardRoutingTable.replicaShards().iterator().next().allocationId().getId();
             }
             final long primaryTerm = indexMetadata.primaryTerm(shardId.id());
-            return new StartedShardEntry(shardId, allocationId, primaryTerm, "test");
+            return new StartedShardEntry(shardId, allocationId, primaryTerm, "test", null, null, null);
         }).collect(Collectors.toList());
 
         final ClusterStateTaskExecutor.ClusterTasksResult result = executeTasks(clusterState, tasks);
@@ -166,11 +168,11 @@ public void testStartedShards() throws Exception {
         final String primaryAllocationId = primaryShard.allocationId().getId();
 
         final List<StartedShardEntry> tasks = new ArrayList<>();
-        tasks.add(new StartedShardEntry(shardId, primaryAllocationId, primaryTerm, "test"));
+        tasks.add(new StartedShardEntry(shardId, primaryAllocationId, primaryTerm, "test", null, null, null));
         if (randomBoolean()) {
             final ShardRouting replicaShard = clusterState.routingTable().shardRoutingTable(shardId).replicaShards().iterator().next();
             final String replicaAllocationId = replicaShard.allocationId().getId();
-            tasks.add(new StartedShardEntry(shardId, replicaAllocationId, primaryTerm, "test"));
+            tasks.add(new StartedShardEntry(shardId, replicaAllocationId, primaryTerm, "test", null, null, null));
         }
         final ClusterStateTaskExecutor.ClusterTasksResult result = executeTasks(clusterState, tasks);
         assertNotSame(clusterState, result.resultingState);
@@ -195,7 +197,7 @@ public void testDuplicateStartsAreOkay() throws Exception {
         final long primaryTerm = indexMetadata.primaryTerm(shardId.id());
 
         final List<StartedShardEntry> tasks = IntStream.range(0, randomIntBetween(2, 10))
-            .mapToObj(i -> new StartedShardEntry(shardId, allocationId, primaryTerm, "test"))
+            .mapToObj(i -> new StartedShardEntry(shardId, allocationId, primaryTerm, "test", null, null, null))
             .collect(Collectors.toList());
 
         final ClusterStateTaskExecutor.ClusterTasksResult result = executeTasks(clusterState, tasks);
@@ -230,7 +232,10 @@ public void testPrimaryTermsMismatch() throws Exception {
                 shardId,
                 primaryAllocationId,
                 primaryTerm - 1,
-                "primary terms does not match on primary"
+                "primary terms does not match on primary",
+                null,
+                null,
+                null
             );
 
             final ClusterStateTaskExecutor.ClusterTasksResult result = executeTasks(clusterState, singletonList(task));
@@ -247,7 +252,10 @@ public void testPrimaryTermsMismatch() throws Exception {
                 shardId,
                 primaryAllocationId,
                 primaryTerm,
-                "primary terms match on primary"
+                "primary terms match on primary",
+                null,
+                null,
+                null
             );
 
             final ClusterStateTaskExecutor.ClusterTasksResult result = executeTasks(clusterState, singletonList(task));
@@ -270,7 +278,7 @@ public void testPrimaryTermsMismatch() throws Exception {
                 .allocationId()
                 .getId();
 
-            final StartedShardEntry task = new StartedShardEntry(shardId, replicaAllocationId, replicaPrimaryTerm, "test on replica");
+            final StartedShardEntry task = new StartedShardEntry(shardId, replicaAllocationId, replicaPrimaryTerm, "test on replica", null, null, null);
 
             final ClusterStateTaskExecutor.ClusterTasksResult result = executeTasks(clusterState, singletonList(task));
             assertNotSame(clusterState, result.resultingState);
diff --git a/server/src/test/java/org/opensearch/cluster/action/shard/ShardStateActionTests.java b/server/src/test/java/org/opensearch/cluster/action/shard/ShardStateActionTests.java
index efe91de1ae1a8..110037f68e250 100644
--- a/server/src/test/java/org/opensearch/cluster/action/shard/ShardStateActionTests.java
+++ b/server/src/test/java/org/opensearch/cluster/action/shard/ShardStateActionTests.java
@@ -543,10 +543,11 @@ public void testFailedShardEntrySerialization() throws Exception {
         final long primaryTerm = randomIntBetween(0, 100);
         final String message = randomRealisticUnicodeOfCodepointLengthBetween(10, 100);
         final Exception failure = randomBoolean() ? null : getSimulatedFailure();
+        final String[] childShardAllocationIds = new String[]{randomAlphaOfLength(50)};
         final boolean markAsStale = randomBoolean();
 
         final Version version = randomFrom(randomCompatibleVersion(random(), Version.CURRENT));
-        final FailedShardEntry failedShardEntry = new FailedShardEntry(shardId, allocationId, primaryTerm, message, failure, markAsStale);
+        final FailedShardEntry failedShardEntry = new FailedShardEntry(shardId, allocationId, primaryTerm, message, failure, markAsStale, null, null, null);
         try (StreamInput in = serialize(failedShardEntry, version).streamInput()) {
             in.setVersion(version);
             final FailedShardEntry deserialized = new FailedShardEntry(in);
@@ -573,7 +574,7 @@ public void testStartedShardEntrySerialization() throws Exception {
         final String message = randomRealisticUnicodeOfCodepointLengthBetween(10, 100);
 
         final Version version = randomFrom(randomCompatibleVersion(random(), Version.CURRENT));
-        try (StreamInput in = serialize(new StartedShardEntry(shardId, allocationId, primaryTerm, message), version).streamInput()) {
+        try (StreamInput in = serialize(new StartedShardEntry(shardId, allocationId, primaryTerm, message, null, null, null), version).streamInput()) {
             in.setVersion(version);
             final StartedShardEntry deserialized = new StartedShardEntry(in);
             assertThat(deserialized.shardId, equalTo(shardId));
diff --git a/server/src/test/java/org/opensearch/cluster/awarenesshealth/ClusterAwarenessAttributeValueHealthTests.java b/server/src/test/java/org/opensearch/cluster/awarenesshealth/ClusterAwarenessAttributeValueHealthTests.java
index ddd8b635ae84a..999b5bde119c7 100644
--- a/server/src/test/java/org/opensearch/cluster/awarenesshealth/ClusterAwarenessAttributeValueHealthTests.java
+++ b/server/src/test/java/org/opensearch/cluster/awarenesshealth/ClusterAwarenessAttributeValueHealthTests.java
@@ -30,7 +30,8 @@ protected ClusterAwarenessAttributeValueHealth createTestInstance() {
             randomInt(1000),
             randomInt(1000),
             randomInt(1000),
-            randomFrom(0.0, 1.0)
+            randomFrom(0.0, 1.0),
+            randomInt(1000)
         );
     }
 
diff --git a/server/src/test/java/org/opensearch/cluster/awarenesshealth/ClusterAwarenessAttributesHealthSerializationTests.java b/server/src/test/java/org/opensearch/cluster/awarenesshealth/ClusterAwarenessAttributesHealthSerializationTests.java
index a6cf687f5892b..0d5c5ea3c5c67 100644
--- a/server/src/test/java/org/opensearch/cluster/awarenesshealth/ClusterAwarenessAttributesHealthSerializationTests.java
+++ b/server/src/test/java/org/opensearch/cluster/awarenesshealth/ClusterAwarenessAttributesHealthSerializationTests.java
@@ -38,7 +38,8 @@ protected ClusterAwarenessAttributesHealth createTestInstance() {
             0,
             2,
             2,
-            1.0
+            1.0,
+            0
         );
 
         ClusterAwarenessAttributeValueHealth clusterAwarenessAttributeValueHealth2 = new ClusterAwarenessAttributeValueHealth(
@@ -48,7 +49,8 @@ protected ClusterAwarenessAttributesHealth createTestInstance() {
             0,
             2,
             2,
-            1.0
+            1.0,
+            0
         );
 
         ClusterAwarenessAttributeValueHealth clusterAwarenessAttributeValueHealth3 = new ClusterAwarenessAttributeValueHealth(
@@ -58,7 +60,8 @@ protected ClusterAwarenessAttributesHealth createTestInstance() {
             0,
             2,
             2,
-            0.0
+            0.0,
+            0
         );
 
         clusterAwarenessAttributeValueHealthMap.put(clusterAwarenessAttributeValueHealth1.getName(), clusterAwarenessAttributeValueHealth1);
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/InSyncAllocationIdTests.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/InSyncAllocationIdTests.java
index 3a1f4a586d519..6a44feca7eaab 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/allocation/InSyncAllocationIdTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/InSyncAllocationIdTests.java
@@ -195,7 +195,7 @@ public void testDeadNodesBeforeReplicaFailed() throws Exception {
         clusterState = failedClusterStateTaskExecutor.execute(
             clusterState,
             Arrays.asList(
-                new FailedShardEntry(shardRoutingTable.shardId(), replicaShard.allocationId().getId(), primaryTerm, "dummy", null, true)
+                new FailedShardEntry(shardRoutingTable.shardId(), replicaShard.allocationId().getId(), primaryTerm, "dummy", null, true, null, null, null)
             )
         ).resultingState;
 
@@ -219,9 +219,9 @@ public void testPrimaryFailureBatchedWithReplicaFailure() throws Exception {
         long primaryTerm = clusterState.metadata().index("test").primaryTerm(0);
 
         List<FailedShardEntry> failureEntries = new ArrayList<>();
-        failureEntries.add(new FailedShardEntry(shardRoutingTable.shardId(), primaryShard.allocationId().getId(), 0L, "dummy", null, true));
+        failureEntries.add(new FailedShardEntry(shardRoutingTable.shardId(), primaryShard.allocationId().getId(), 0L, "dummy", null, true, null, null, null));
         failureEntries.add(
-            new FailedShardEntry(shardRoutingTable.shardId(), replicaShard.allocationId().getId(), primaryTerm, "dummy", null, true)
+            new FailedShardEntry(shardRoutingTable.shardId(), replicaShard.allocationId().getId(), primaryTerm, "dummy", null, true, null, null, null)
         );
         Collections.shuffle(failureEntries, random());
         logger.info("Failing {}", failureEntries);
@@ -369,7 +369,7 @@ public void testPrimaryAllocationIdNotRemovedFromInSyncSetWhenNoFailOver() throw
         clusterState = failedClusterStateTaskExecutor.execute(
             clusterState,
             Collections.singletonList(
-                new FailedShardEntry(shardRoutingTable.shardId(), primaryShard.allocationId().getId(), 0L, "dummy", null, true)
+                new FailedShardEntry(shardRoutingTable.shardId(), primaryShard.allocationId().getId(), 0L, "dummy", null, true, null, null, null)
             )
         ).resultingState;
 
diff --git a/server/src/test/java/org/opensearch/common/io/stream/BytesStreamsTests.java b/server/src/test/java/org/opensearch/common/io/stream/BytesStreamsTests.java
index 370c691daf401..db4be032f5a3c 100644
--- a/server/src/test/java/org/opensearch/common/io/stream/BytesStreamsTests.java
+++ b/server/src/test/java/org/opensearch/common/io/stream/BytesStreamsTests.java
@@ -312,7 +312,7 @@ public void testSimpleStreams() throws Exception {
         long[] longArray = { 1, 2, 3 };
         out.writeGenericValue(longArray);
         long[] vLongArray = { 4, 5, 6 };
-        out.writeVLongArray(vLongArray);
+        out.writeZLongArray(vLongArray);
         float[] floatArray = { 1.1f, 2.2f, 3.3f };
         out.writeGenericValue(floatArray);
         double[] doubleArray = { 1.1, 2.2, 3.3 };
@@ -346,7 +346,7 @@ public void testSimpleStreams() throws Exception {
         assertThat(in.readGenericValue(), equalTo((Object) intArray));
         assertThat(in.readVIntArray(), equalTo(vIntArray));
         assertThat(in.readGenericValue(), equalTo((Object) longArray));
-        assertThat(in.readVLongArray(), equalTo(vLongArray));
+        assertThat(in.readZLongArray(), equalTo(vLongArray));
         assertThat(in.readGenericValue(), equalTo((Object) floatArray));
         assertThat(in.readGenericValue(), equalTo((Object) doubleArray));
         assertThat(in.readString(), equalTo("hello"));
diff --git a/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManagerTests.java b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManagerTests.java
index 753e791ca915c..5a46ea8950c6b 100644
--- a/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManagerTests.java
+++ b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManagerTests.java
@@ -168,15 +168,15 @@ public void testDeleteClusterMetadata() throws IOException {
         String clusterUUID = "clusterUUID";
         String clusterName = "test-cluster";
         List<BlobMetadata> inactiveBlobs = Arrays.asList(
-            new PlainBlobMetadata("manifest1.dat", 1L),
-            new PlainBlobMetadata("manifest2.dat", 1L),
-            new PlainBlobMetadata("manifest3.dat", 1L),
-            new PlainBlobMetadata("manifest6.dat", 1L)
+            new PlainBlobMetadata("manifest1.dat", 1L, System.currentTimeMillis()),
+            new PlainBlobMetadata("manifest2.dat", 1L, System.currentTimeMillis()),
+            new PlainBlobMetadata("manifest3.dat", 1L, System.currentTimeMillis()),
+            new PlainBlobMetadata("manifest6.dat", 1L, System.currentTimeMillis())
         );
         List<BlobMetadata> activeBlobs = Arrays.asList(
-            new PlainBlobMetadata("manifest4.dat", 1L),
-            new PlainBlobMetadata("manifest5.dat", 1L),
-            new PlainBlobMetadata("manifest7.dat", 1L)
+            new PlainBlobMetadata("manifest4.dat", 1L, System.currentTimeMillis()),
+            new PlainBlobMetadata("manifest5.dat", 1L, System.currentTimeMillis()),
+            new PlainBlobMetadata("manifest7.dat", 1L, System.currentTimeMillis())
         );
         UploadedIndexMetadata index1Metadata = new UploadedIndexMetadata("index1", "indexUUID1", "index_metadata1__1");
         UploadedIndexMetadata index2Metadata = new UploadedIndexMetadata("index2", "indexUUID2", "index_metadata2__2");
@@ -305,8 +305,8 @@ public void testDeleteClusterMetadata() throws IOException {
     public void testDeleteStaleIndicesRoutingDiffFile() throws IOException {
         String clusterUUID = "clusterUUID";
         String clusterName = "test-cluster";
-        List<BlobMetadata> inactiveBlobs = Arrays.asList(new PlainBlobMetadata("manifest1.dat", 1L));
-        List<BlobMetadata> activeBlobs = Arrays.asList(new PlainBlobMetadata("manifest2.dat", 1L));
+        List<BlobMetadata> inactiveBlobs = Arrays.asList(new PlainBlobMetadata("manifest1.dat", 1L, System.currentTimeMillis()));
+        List<BlobMetadata> activeBlobs = Arrays.asList(new PlainBlobMetadata("manifest2.dat", 1L, System.currentTimeMillis()));
 
         UploadedMetadataAttribute coordinationMetadata = new UploadedMetadataAttribute(COORDINATION_METADATA, "coordination_metadata");
         UploadedMetadataAttribute templateMetadata = new UploadedMetadataAttribute(TEMPLATES_METADATA, "template_metadata");
@@ -373,8 +373,8 @@ public void testDeleteStaleIndicesRoutingDiffFile() throws IOException {
     public void testDeleteClusterMetadataNoOpsRoutingTableService() throws IOException {
         String clusterUUID = "clusterUUID";
         String clusterName = "test-cluster";
-        List<BlobMetadata> inactiveBlobs = Arrays.asList(new PlainBlobMetadata("manifest1.dat", 1L));
-        List<BlobMetadata> activeBlobs = Arrays.asList(new PlainBlobMetadata("manifest2.dat", 1L));
+        List<BlobMetadata> inactiveBlobs = Arrays.asList(new PlainBlobMetadata("manifest1.dat", 1L, System.currentTimeMillis()));
+        List<BlobMetadata> activeBlobs = Arrays.asList(new PlainBlobMetadata("manifest2.dat", 1L, System.currentTimeMillis()));
 
         UploadedMetadataAttribute coordinationMetadata = new UploadedMetadataAttribute(COORDINATION_METADATA, "coordination_metadata");
         UploadedMetadataAttribute templateMetadata = new UploadedMetadataAttribute(TEMPLATES_METADATA, "template_metadata");
@@ -473,14 +473,14 @@ public void testDeleteStaleClusterUUIDs() throws IOException {
                 Integer.MAX_VALUE,
                 BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC
             )
-        ).thenReturn(List.of(new PlainBlobMetadata("mainfest2", 1L)));
+        ).thenReturn(List.of(new PlainBlobMetadata("mainfest2", 1L, System.currentTimeMillis())));
         when(
             manifest3Container.listBlobsByPrefixInSortedOrder(
                 MANIFEST + DELIMITER,
                 Integer.MAX_VALUE,
                 BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC
             )
-        ).thenReturn(List.of(new PlainBlobMetadata("mainfest3", 1L)));
+        ).thenReturn(List.of(new PlainBlobMetadata("mainfest3", 1L, System.currentTimeMillis())));
         Set<String> uuids = new HashSet<>(Arrays.asList("cluster-uuid1", "cluster-uuid2", "cluster-uuid3"));
         when(remoteClusterStateService.getAllClusterUUIDs(any())).thenReturn(uuids);
         when(blobStoreRepository.basePath()).thenReturn(blobPath);
@@ -519,8 +519,8 @@ public void testRemoteStateCleanupFailureStats() throws IOException {
     public void testIndexRoutingFilesCleanupFailureStats() throws Exception {
         String clusterUUID = "clusterUUID";
         String clusterName = "test-cluster";
-        List<BlobMetadata> inactiveBlobs = Arrays.asList(new PlainBlobMetadata("manifest1.dat", 1L));
-        List<BlobMetadata> activeBlobs = Arrays.asList(new PlainBlobMetadata("manifest2.dat", 1L));
+        List<BlobMetadata> inactiveBlobs = Arrays.asList(new PlainBlobMetadata("manifest1.dat", 1L, System.currentTimeMillis()));
+        List<BlobMetadata> activeBlobs = Arrays.asList(new PlainBlobMetadata("manifest2.dat", 1L, System.currentTimeMillis()));
 
         UploadedMetadataAttribute coordinationMetadata = new UploadedMetadataAttribute(COORDINATION_METADATA, "coordination_metadata");
         UploadedMetadataAttribute templateMetadata = new UploadedMetadataAttribute(TEMPLATES_METADATA, "template_metadata");
@@ -592,8 +592,8 @@ public void testIndexRoutingFilesCleanupFailureStats() throws Exception {
     public void testIndicesRoutingDiffFilesCleanupFailureStats() throws Exception {
         String clusterUUID = "clusterUUID";
         String clusterName = "test-cluster";
-        List<BlobMetadata> inactiveBlobs = Arrays.asList(new PlainBlobMetadata("manifest1.dat", 1L));
-        List<BlobMetadata> activeBlobs = Arrays.asList(new PlainBlobMetadata("manifest2.dat", 1L));
+        List<BlobMetadata> inactiveBlobs = Arrays.asList(new PlainBlobMetadata("manifest1.dat", 1L, System.currentTimeMillis()));
+        List<BlobMetadata> activeBlobs = Arrays.asList(new PlainBlobMetadata("manifest2.dat", 1L, System.currentTimeMillis()));
 
         UploadedMetadataAttribute coordinationMetadata = new UploadedMetadataAttribute(COORDINATION_METADATA, "coordination_metadata");
         UploadedMetadataAttribute templateMetadata = new UploadedMetadataAttribute(TEMPLATES_METADATA, "template_metadata");
diff --git a/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateServiceTests.java b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateServiceTests.java
index e3684178a18ea..46fd4287956f4 100644
--- a/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateServiceTests.java
+++ b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateServiceTests.java
@@ -2268,7 +2268,7 @@ public void testReadLatestMetadataManifestFailedManifestFileRemoveAfterFetchInRe
         final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
 
         BlobContainer blobContainer = mockBlobStoreObjects();
-        BlobMetadata blobMetadata = new PlainBlobMetadata("manifestFileName", 1);
+        BlobMetadata blobMetadata = new PlainBlobMetadata("manifestFileName", 1, System.currentTimeMillis());
         when(blobContainer.listBlobsByPrefixInSortedOrder("manifest" + DELIMITER, 1, BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC))
             .thenReturn(Arrays.asList(blobMetadata));
         when(blobContainer.readBlob("manifestFileName")).thenThrow(FileNotFoundException.class);
@@ -2731,6 +2731,7 @@ public void testGetValidPreviousClusterUUIDWhenLastUUIDUncommitted() throws IOEx
     }
 
     public void testRemoteStateUploadStats() throws IOException {
+
         final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
         mockBlobStoreObjects();
         remoteClusterStateService.start();
@@ -4014,7 +4015,7 @@ private void mockBlobContainer(
         String manifestFileName = codecVersion >= CODEC_V1
             ? "manifest__manifestFileName__abcd__abcd__abcd__" + codecVersion
             : "manifestFileName";
-        BlobMetadata blobMetadata = new PlainBlobMetadata(manifestFileName, 1);
+        BlobMetadata blobMetadata = new PlainBlobMetadata(manifestFileName, 1, System.currentTimeMillis());
         when(blobContainer.listBlobsByPrefixInSortedOrder("manifest" + DELIMITER, 1, BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC))
             .thenReturn(Arrays.asList(blobMetadata));
 
@@ -4059,7 +4060,7 @@ private void mockBlobContainer(
         String manifestFileName = codecVersion >= CODEC_V1
             ? "manifest__manifestFileName__abcd__abcd__abcd__" + codecVersion
             : "manifestFileName";
-        BlobMetadata blobMetadata = new PlainBlobMetadata(manifestFileName, 1);
+        BlobMetadata blobMetadata = new PlainBlobMetadata(manifestFileName, 1, System.currentTimeMillis());
 
         String manifestPrefix = String.join(DELIMITER, "manifest", RemoteStoreUtils.invertLong(term), RemoteStoreUtils.invertLong(version))
             + DELIMITER;
@@ -4104,7 +4105,7 @@ private void mockBlobContainerForGlobalMetadata(
     ) throws IOException {
         int codecVersion = clusterMetadataManifest.getCodecVersion();
         String mockManifestFileName = "manifest__1__2__C__456__" + codecVersion;
-        BlobMetadata blobMetadata = new PlainBlobMetadata(mockManifestFileName, 1);
+        BlobMetadata blobMetadata = new PlainBlobMetadata(mockManifestFileName, 1, System.currentTimeMillis());
         when(blobContainer.listBlobsByPrefixInSortedOrder("manifest" + DELIMITER, 1, BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC))
             .thenReturn(Arrays.asList(blobMetadata));
 
diff --git a/server/src/test/java/org/opensearch/index/remote/RemoteStoreUtilsTests.java b/server/src/test/java/org/opensearch/index/remote/RemoteStoreUtilsTests.java
index d134a2bad7b74..1014b56b09c04 100644
--- a/server/src/test/java/org/opensearch/index/remote/RemoteStoreUtilsTests.java
+++ b/server/src/test/java/org/opensearch/index/remote/RemoteStoreUtilsTests.java
@@ -216,18 +216,18 @@ public void testVerifyMultipleWriters_Translog() throws InterruptedException {
         TranslogTransferMetadata tm2 = new TranslogTransferMetadata(1, 1, 1, 2, "node--1");
         String mdFilename2 = tm2.getFileName();
         List<BlobMetadata> bmList = new LinkedList<>();
-        bmList.add(new PlainBlobMetadata(mdFilename, 1));
-        bmList.add(new PlainBlobMetadata(mdFilename2, 1));
-        bmList.add(new PlainBlobMetadata(getOldTranslogMetadataFilename(1, 1, 1), 1));
+        bmList.add(new PlainBlobMetadata(mdFilename, 1, System.currentTimeMillis()));
+        bmList.add(new PlainBlobMetadata(mdFilename2, 1, System.currentTimeMillis()));
+        bmList.add(new PlainBlobMetadata(getOldTranslogMetadataFilename(1, 1, 1), 1, System.currentTimeMillis()));
         RemoteStoreUtils.verifyNoMultipleWriters(
             bmList.stream().map(BlobMetadata::name).collect(Collectors.toList()),
             TranslogTransferMetadata::getNodeIdByPrimaryTermAndGen
         );
 
         bmList = new LinkedList<>();
-        bmList.add(new PlainBlobMetadata(mdFilename, 1));
+        bmList.add(new PlainBlobMetadata(mdFilename, 1, System.currentTimeMillis()));
         TranslogTransferMetadata tm3 = new TranslogTransferMetadata(1, 1, 1, 2, "node--2");
-        bmList.add(new PlainBlobMetadata(tm3.getFileName(), 1));
+        bmList.add(new PlainBlobMetadata(tm3.getFileName(), 1, System.currentTimeMillis()));
         List<BlobMetadata> finalBmList = bmList;
         assertThrows(
             IllegalStateException.class,
diff --git a/server/src/test/java/org/opensearch/index/seqno/PeerRecoveryRetentionLeaseExpiryTests.java b/server/src/test/java/org/opensearch/index/seqno/PeerRecoveryRetentionLeaseExpiryTests.java
index 7a9f1d7baa12e..fe50b365b3f53 100644
--- a/server/src/test/java/org/opensearch/index/seqno/PeerRecoveryRetentionLeaseExpiryTests.java
+++ b/server/src/test/java/org/opensearch/index/seqno/PeerRecoveryRetentionLeaseExpiryTests.java
@@ -45,7 +45,9 @@
 import org.opensearch.test.IndexSettingsModule;
 import org.junit.Before;
 
+import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.stream.Collectors;
diff --git a/server/src/test/java/org/opensearch/index/seqno/ReplicationTrackerTests.java b/server/src/test/java/org/opensearch/index/seqno/ReplicationTrackerTests.java
index 233a99cbe4a73..c5a8e49cbdd04 100644
--- a/server/src/test/java/org/opensearch/index/seqno/ReplicationTrackerTests.java
+++ b/server/src/test/java/org/opensearch/index/seqno/ReplicationTrackerTests.java
@@ -810,7 +810,8 @@ public void testPrimaryContextHandoff() throws IOException {
             Math.max(SequenceNumbers.NO_OPS_PERFORMED, oldPrimary.getGlobalCheckpoint() + randomInt(5))
         );
         oldPrimary.updateGlobalCheckpointForShard(newPrimary.shardAllocationId, oldPrimary.getGlobalCheckpoint());
-        ReplicationTracker.PrimaryContext primaryContext = oldPrimary.startRelocationHandoff(newPrimary.shardAllocationId);
+        ReplicationTracker.PrimaryContext primaryContext = oldPrimary.startRelocationHandoff(
+            new HashSet<>(Collections.singletonList(newPrimary.shardAllocationId)));
 
         if (randomBoolean()) {
             // cluster state update after primary context handoff
@@ -836,7 +837,8 @@ public void testPrimaryContextHandoff() throws IOException {
             }
 
             // do another handoff
-            primaryContext = oldPrimary.startRelocationHandoff(newPrimary.shardAllocationId);
+            primaryContext = oldPrimary.startRelocationHandoff(
+                new HashSet<>(Collections.singletonList(newPrimary.shardAllocationId)));
         }
 
         // send primary context through the wire
@@ -2133,7 +2135,8 @@ public void testPrimaryContextHandoffWithRemoteTranslogEnabled() throws IOExcept
             Math.max(SequenceNumbers.NO_OPS_PERFORMED, oldPrimary.getGlobalCheckpoint() + randomInt(5))
         );
         oldPrimary.updateGlobalCheckpointForShard(newPrimary.shardAllocationId, oldPrimary.getGlobalCheckpoint());
-        ReplicationTracker.PrimaryContext primaryContext = oldPrimary.startRelocationHandoff(newPrimary.shardAllocationId);
+        ReplicationTracker.PrimaryContext primaryContext = oldPrimary.startRelocationHandoff(
+            new HashSet<>(Collections.singletonList(newPrimary.shardAllocationId)));
 
         if (randomBoolean()) {
             // cluster state update after primary context handoff
@@ -2159,7 +2162,8 @@ public void testPrimaryContextHandoffWithRemoteTranslogEnabled() throws IOExcept
             }
 
             // do another handoff
-            primaryContext = oldPrimary.startRelocationHandoff(newPrimary.shardAllocationId);
+            primaryContext = oldPrimary.startRelocationHandoff(
+                new HashSet<>(Collections.singletonList(newPrimary.shardAllocationId)));
         }
 
         // send primary context through the wire
diff --git a/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java b/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java
index 535adfbff8dcc..16627ff5805f3 100644
--- a/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java
+++ b/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java
@@ -1001,7 +1001,9 @@ public void testOperationPermitOnReplicaShards() throws Exception {
                     AllocationId.newRelocation(routing.allocationId())
                 );
                 IndexShardTestCase.updateRoutingEntry(indexShard, routing);
-                indexShard.relocated(routing.getTargetRelocatingShard().allocationId().getId(), primaryContext -> {}, () -> {});
+                indexShard.relocated(
+                    new HashSet<>(Collections.singletonList(routing.getTargetRelocatingShard().allocationId().getId())),
+                    primaryContext -> {}, () -> {});
                 engineClosed = false;
                 break;
             }
@@ -2044,7 +2046,9 @@ public void testLockingBeforeAndAfterRelocated() throws Exception {
         Thread recoveryThread = new Thread(() -> {
             latch.countDown();
             try {
-                shard.relocated(routing.getTargetRelocatingShard().allocationId().getId(), primaryContext -> {}, () -> {});
+                shard.relocated(
+                    new HashSet<>(Collections.singletonList(routing.getTargetRelocatingShard().allocationId().getId())),
+                    primaryContext -> {}, () -> {});
             } catch (InterruptedException e) {
                 throw new RuntimeException(e);
             }
@@ -2077,7 +2081,7 @@ public void testDelayedOperationsBeforeAndAfterRelocated() throws Exception {
             try {
                 startRecovery.await();
                 shard.relocated(
-                    routing.getTargetRelocatingShard().allocationId().getId(),
+                    new HashSet<>(Collections.singletonList(routing.getTargetRelocatingShard().allocationId().getId())),
                     primaryContext -> relocationStarted.countDown(),
                     () -> {}
                 );
@@ -2168,7 +2172,9 @@ public void run() {
         AtomicBoolean relocated = new AtomicBoolean();
         final Thread recoveryThread = new Thread(() -> {
             try {
-                shard.relocated(routing.getTargetRelocatingShard().allocationId().getId(), primaryContext -> {}, () -> {});
+                shard.relocated(
+                    new HashSet<>(Collections.singletonList(routing.getTargetRelocatingShard().allocationId().getId())),
+                    primaryContext -> {}, () -> {});
             } catch (InterruptedException e) {
                 throw new RuntimeException(e);
             }
@@ -2203,7 +2209,9 @@ public void testRelocatedShardCanNotBeRevived() throws IOException, InterruptedE
         final ShardRouting originalRouting = shard.routingEntry();
         final ShardRouting routing = ShardRoutingHelper.relocate(originalRouting, "other_node");
         IndexShardTestCase.updateRoutingEntry(shard, routing);
-        shard.relocated(routing.getTargetRelocatingShard().allocationId().getId(), primaryContext -> {}, () -> {});
+        shard.relocated(
+            new HashSet<>(Collections.singletonList(routing.getTargetRelocatingShard().allocationId().getId())),
+            primaryContext -> {}, () -> {});
         expectThrows(IllegalIndexShardStateException.class, () -> IndexShardTestCase.updateRoutingEntry(shard, originalRouting));
         closeShards(shard);
     }
@@ -2215,7 +2223,9 @@ public void testRelocatedSegRepError() throws IOException, InterruptedException
         IndexShardTestCase.updateRoutingEntry(shard, routing);
         ReplicationFailedException segRepException = expectThrows(
             ReplicationFailedException.class,
-            () -> shard.relocated(routing.getTargetRelocatingShard().allocationId().getId(), primaryContext -> {}, () -> {
+            () -> shard.relocated(
+                new HashSet<>(Collections.singletonList(routing.getTargetRelocatingShard().allocationId().getId())),
+                primaryContext -> {}, () -> {
                 throw new ReplicationFailedException("Segment replication failed");
             })
         );
@@ -2231,7 +2241,9 @@ public void testShardCanNotBeMarkedAsRelocatedIfRelocationCancelled() throws IOE
         IndexShardTestCase.updateRoutingEntry(shard, originalRouting);
         expectThrows(
             IllegalIndexShardStateException.class,
-            () -> shard.relocated(relocationRouting.getTargetRelocatingShard().allocationId().getId(), primaryContext -> {}, () -> {})
+            () -> shard.relocated(
+                new HashSet<>(Collections.singletonList(relocationRouting.getTargetRelocatingShard().allocationId().getId())),
+                primaryContext -> {}, () -> {})
         );
         closeShards(shard);
     }
@@ -2252,7 +2264,9 @@ public void onFailure(Exception e) {
             @Override
             protected void doRun() throws Exception {
                 cyclicBarrier.await();
-                shard.relocated(relocationRouting.getTargetRelocatingShard().allocationId().getId(), primaryContext -> {}, () -> {});
+                shard.relocated(
+                    new HashSet<>(Collections.singletonList(relocationRouting.getTargetRelocatingShard().allocationId().getId())),
+                    primaryContext -> {}, () -> {});
             }
         });
         relocationThread.start();
@@ -2303,7 +2317,9 @@ public void testRelocateMissingTarget() throws Exception {
 
         final IllegalStateException error = expectThrows(
             IllegalStateException.class,
-            () -> shard.relocated(toNode1.getTargetRelocatingShard().allocationId().getId(), ctx -> relocated.set(true), () -> {})
+            () -> shard.relocated(
+                new HashSet<>(Collections.singletonList(toNode1.getTargetRelocatingShard().allocationId().getId())),
+                ctx -> relocated.set(true), () -> {})
         );
         assertThat(
             error.getMessage(),
@@ -2315,7 +2331,9 @@ public void testRelocateMissingTarget() throws Exception {
         );
 
         assertFalse(relocated.get());
-        shard.relocated(toNode2.getTargetRelocatingShard().allocationId().getId(), ctx -> relocated.set(true), () -> {});
+        shard.relocated(
+            new HashSet<>(Collections.singletonList(toNode2.getTargetRelocatingShard().allocationId().getId())),
+            ctx -> relocated.set(true), () -> {});
         assertTrue(relocated.get());
         closeShards(shard);
     }
@@ -2716,7 +2734,9 @@ public void testRecoveryFailsAfterMovingToRelocatedState() throws InterruptedExc
         assertThat(shard.state(), equalTo(IndexShardState.STARTED));
         ShardRouting inRecoveryRouting = ShardRoutingHelper.relocate(origRouting, "some_node");
         IndexShardTestCase.updateRoutingEntry(shard, inRecoveryRouting);
-        shard.relocated(inRecoveryRouting.getTargetRelocatingShard().allocationId().getId(), primaryContext -> {}, () -> {});
+        shard.relocated(
+            new HashSet<>(Collections.singletonList(inRecoveryRouting.getTargetRelocatingShard().allocationId().getId())),
+            primaryContext -> {}, () -> {});
         assertTrue(shard.isRelocatedPrimary());
         try {
             IndexShardTestCase.updateRoutingEntry(shard, origRouting);
@@ -2751,7 +2771,9 @@ public void testRelocatedForRemoteTranslogBackedIndexWithAsyncDurability() throw
         indexDoc(indexShard, "_doc", "0");
         assertTrue(indexShard.isSyncNeeded());
         try {
-            indexShard.relocated(routing.getTargetRelocatingShard().allocationId().getId(), primaryContext -> {}, () -> {});
+            indexShard.relocated(
+                new HashSet<>(Collections.singletonList(routing.getTargetRelocatingShard().allocationId().getId())),
+                primaryContext -> {}, () -> {});
         } catch (InterruptedException e) {
             throw new RuntimeException(e);
         }
diff --git a/server/src/test/java/org/opensearch/index/shard/SegmentReplicationIndexShardTests.java b/server/src/test/java/org/opensearch/index/shard/SegmentReplicationIndexShardTests.java
index f4f94baabd7b0..28282bca2de76 100644
--- a/server/src/test/java/org/opensearch/index/shard/SegmentReplicationIndexShardTests.java
+++ b/server/src/test/java/org/opensearch/index/shard/SegmentReplicationIndexShardTests.java
@@ -84,6 +84,7 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -536,7 +537,7 @@ public void testPublishCheckpointAfterRelocationHandOff() throws IOException {
         String id = shard.routingEntry().allocationId().getId();
 
         // Starting relocation handoff
-        shard.getReplicationTracker().startRelocationHandoff(id);
+        shard.getReplicationTracker().startRelocationHandoff(new HashSet<>(Collections.singletonList(id)));
 
         // Completing relocation handoff
         shard.getReplicationTracker().completeRelocationHandoff();
@@ -561,7 +562,7 @@ public void testRejectCheckpointOnShardRoutingPrimary() throws IOException {
         String id = primaryShard.routingEntry().allocationId().getId();
 
         // Starting relocation handoff
-        primaryShard.getReplicationTracker().startRelocationHandoff(id);
+        primaryShard.getReplicationTracker().startRelocationHandoff(new HashSet<>(Collections.singletonList(id)));
 
         // Completing relocation handoff.
         primaryShard.getReplicationTracker().completeRelocationHandoff();
@@ -587,7 +588,9 @@ public void testLockingBeforeAndAfterRelocated() throws Exception {
         Thread recoveryThread = new Thread(() -> {
             latch.countDown();
             try {
-                shard.relocated(routing.getTargetRelocatingShard().allocationId().getId(), primaryContext -> {}, () -> {});
+                shard.relocated(
+                    new HashSet<>(Collections.singletonList(routing.getTargetRelocatingShard().allocationId().getId())),
+                    primaryContext -> {}, () -> {});
             } catch (InterruptedException e) {
                 throw new RuntimeException(e);
             }
@@ -622,7 +625,7 @@ public void testDelayedOperationsBeforeAndAfterRelocated() throws Exception {
             try {
                 startRecovery.await();
                 shard.relocated(
-                    routing.getTargetRelocatingShard().allocationId().getId(),
+                    new HashSet<>(Collections.singletonList(routing.getTargetRelocatingShard().allocationId().getId())),
                     primaryContext -> relocationStarted.countDown(),
                     () -> {}
                 );
diff --git a/server/src/test/java/org/opensearch/index/shard/ShardSplittingQueryTests.java b/server/src/test/java/org/opensearch/index/shard/ShardSplittingQueryTests.java
index 03b4ab684e763..ca4db25ea076d 100644
--- a/server/src/test/java/org/opensearch/index/shard/ShardSplittingQueryTests.java
+++ b/server/src/test/java/org/opensearch/index/shard/ShardSplittingQueryTests.java
@@ -294,7 +294,7 @@ void assertSplit(Directory dir, IndexMetadata metadata, int targetShardId, boole
             IndexSearcher searcher = new IndexSearcher(reader);
             searcher.setQueryCache(null);
             final Weight splitWeight = searcher.createWeight(
-                searcher.rewrite(new ShardSplittingQuery(metadata, targetShardId, hasNested)),
+                searcher.rewrite(new ShardSplittingQuery(metadata, targetShardId, hasNested, false)),
                 ScoreMode.COMPLETE_NO_SCORES,
                 1f
             );
diff --git a/server/src/test/java/org/opensearch/index/shard/StoreRecoveryTests.java b/server/src/test/java/org/opensearch/index/shard/StoreRecoveryTests.java
index 846b975a9520e..01b19f7091927 100644
--- a/server/src/test/java/org/opensearch/index/shard/StoreRecoveryTests.java
+++ b/server/src/test/java/org/opensearch/index/shard/StoreRecoveryTests.java
@@ -113,7 +113,7 @@ public void testAddIndices() throws IOException {
         Directory target = newFSDirectory(createTempDir());
         final long maxSeqNo = randomNonNegativeLong();
         final long maxUnsafeAutoIdTimestamp = randomNonNegativeLong();
-        storeRecovery.addIndices(indexStats, target, indexSort, dirs, maxSeqNo, maxUnsafeAutoIdTimestamp, null, 0, false, false);
+        StoreRecovery.addIndices(indexStats, target, indexSort, dirs, maxSeqNo, maxUnsafeAutoIdTimestamp, null, 0, false, false);
         int numFiles = 0;
         Predicate<String> filesFilter = (f) -> f.startsWith("segments") == false
             && f.equals("write.lock") == false
@@ -187,7 +187,7 @@ public void testSplitShard() throws IOException {
             .setRoutingNumShards(numShards * 1000000)
             .numberOfReplicas(0)
             .build();
-        storeRecovery.addIndices(
+        StoreRecovery.addIndices(
             indexStats,
             target,
             indexSort,
diff --git a/server/src/test/java/org/opensearch/index/store/RemoteDirectoryTests.java b/server/src/test/java/org/opensearch/index/store/RemoteDirectoryTests.java
index ed79a2b0bd8e4..430ab817d556e 100644
--- a/server/src/test/java/org/opensearch/index/store/RemoteDirectoryTests.java
+++ b/server/src/test/java/org/opensearch/index/store/RemoteDirectoryTests.java
@@ -154,7 +154,7 @@ public void onFailure(Exception e) {
 
     public void testListAll() throws IOException {
         Map<String, BlobMetadata> fileNames = Stream.of("abc", "xyz", "pqr", "lmn", "jkl")
-            .collect(Collectors.toMap(filename -> filename, filename -> new PlainBlobMetadata(filename, 100)));
+            .collect(Collectors.toMap(filename -> filename, filename -> new PlainBlobMetadata(filename, 100, System.currentTimeMillis())));
 
         when(blobContainer.listBlobs()).thenReturn(fileNames);
 
@@ -171,7 +171,7 @@ public void testListAllException() throws IOException {
 
     public void testListFilesByPrefix() throws IOException {
         Map<String, BlobMetadata> fileNames = Stream.of("abc", "abd", "abe", "abf", "abg")
-            .collect(Collectors.toMap(filename -> filename, filename -> new PlainBlobMetadata(filename, 100)));
+            .collect(Collectors.toMap(filename -> filename, filename -> new PlainBlobMetadata(filename, 100, System.currentTimeMillis())));
 
         when(blobContainer.listBlobsByPrefix("ab")).thenReturn(fileNames);
 
@@ -210,7 +210,7 @@ public void testOpenInput() throws IOException {
         InputStream mockInputStream = mock(InputStream.class);
         when(blobContainer.readBlob("segment_1")).thenReturn(mockInputStream);
 
-        BlobMetadata blobMetadata = new PlainBlobMetadata("segment_1", 100);
+        BlobMetadata blobMetadata = new PlainBlobMetadata("segment_1", 100, System.currentTimeMillis());
 
         when(blobContainer.listBlobsByPrefixInSortedOrder("segment_1", 1, LEXICOGRAPHIC)).thenReturn(List.of(blobMetadata));
 
@@ -235,7 +235,7 @@ public void testOpenInputWithLength() throws IOException {
         InputStream mockInputStream = mock(InputStream.class);
         when(blobContainer.readBlob("segment_1")).thenReturn(mockInputStream);
 
-        BlobMetadata blobMetadata = new PlainBlobMetadata("segment_1", 100);
+        BlobMetadata blobMetadata = new PlainBlobMetadata("segment_1", 100, System.currentTimeMillis());
 
         when(blobContainer.listBlobsByPrefixInSortedOrder("segment_1", 1, LEXICOGRAPHIC)).thenReturn(List.of(blobMetadata));
 
@@ -260,7 +260,7 @@ public void testOpenInputNoSuchFileException() throws IOException {
     }
 
     public void testFileLength() throws IOException {
-        BlobMetadata blobMetadata = new PlainBlobMetadata("segment_1", 100);
+        BlobMetadata blobMetadata = new PlainBlobMetadata("segment_1", 100, System.currentTimeMillis());
         when(blobContainer.listBlobsByPrefixInSortedOrder("segment_1", 1, LEXICOGRAPHIC)).thenReturn(List.of(blobMetadata));
 
         assertEquals(100, remoteDirectory.fileLength("segment_1"));
@@ -275,7 +275,7 @@ public void testFileLengthIOException() throws IOException {
     public void testListFilesByPrefixInLexicographicOrder() throws IOException {
         doAnswer(invocation -> {
             LatchedActionListener<List<BlobMetadata>> latchedActionListener = invocation.getArgument(3);
-            latchedActionListener.onResponse(List.of(new PlainBlobMetadata("metadata_1", 1)));
+            latchedActionListener.onResponse(List.of(new PlainBlobMetadata("metadata_1", 1, System.currentTimeMillis())));
             return null;
         }).when(blobContainer).listBlobsByPrefixInSortedOrder(eq("metadata"), eq(1), eq(LEXICOGRAPHIC), any(ActionListener.class));
 
diff --git a/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryWithPinnedTimestampTests.java b/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryWithPinnedTimestampTests.java
index e71023125d4cd..76a3015336ca1 100644
--- a/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryWithPinnedTimestampTests.java
+++ b/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryWithPinnedTimestampTests.java
@@ -189,7 +189,7 @@ public void testDeleteStaleCommitsPinnedTimestampMdFile() throws Exception {
 
         long pinnedTimestampMatchingMetadataFilename2 = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getTimestamp(metadataFilename2) + 10;
         String blobName = "snapshot1__" + pinnedTimestampMatchingMetadataFilename2;
-        when(blobContainer.listBlobs()).thenReturn(Map.of(blobName, new PlainBlobMetadata(blobName, 100)));
+        when(blobContainer.listBlobs()).thenReturn(Map.of(blobName, new PlainBlobMetadata(blobName, 100, System.currentTimeMillis())));
 
         final Map<String, Map<String, String>> metadataFilenameContentMapping = populateMetadata();
         final List<String> filesToBeDeleted = metadataFilenameContentMapping.get(metadataFilename3)
diff --git a/server/src/test/java/org/opensearch/index/translog/RemoteFsTimestampAwareTranslogTests.java b/server/src/test/java/org/opensearch/index/translog/RemoteFsTimestampAwareTranslogTests.java
index 78ae90936d78e..fe47c1351e9d9 100644
--- a/server/src/test/java/org/opensearch/index/translog/RemoteFsTimestampAwareTranslogTests.java
+++ b/server/src/test/java/org/opensearch/index/translog/RemoteFsTimestampAwareTranslogTests.java
@@ -456,7 +456,7 @@ public void onResponse(List<BlobMetadata> blobMetadataList) {
                     }
 
                     Map<String, BlobMetadata> pinnedTimestampsMap = new HashMap<>();
-                    pinnedTimestamps.forEach(ts -> pinnedTimestampsMap.put(randomInt(1000) + "__" + ts, new PlainBlobMetadata("x", 100)));
+                    pinnedTimestamps.forEach(ts -> pinnedTimestampsMap.put(randomInt(1000) + "__" + ts, new PlainBlobMetadata("x", 100, System.currentTimeMillis())));
 
                     try {
 
@@ -808,7 +808,7 @@ public void testGetMetadataFilesToBeDeletedExclusionBasedOnPinningOnly() throws
         String md4Timestamp = RemoteStoreUtils.invertLong(currentTimeInMillis - 600000);
 
         long pinnedTimestamp = RemoteStoreUtils.invertLong(md3Timestamp) + 10000;
-        when(blobContainer.listBlobs()).thenReturn(Map.of(randomInt(100) + "__" + pinnedTimestamp, new PlainBlobMetadata("xyz", 100)));
+        when(blobContainer.listBlobs()).thenReturn(Map.of(randomInt(100) + "__" + pinnedTimestamp, new PlainBlobMetadata("xyz", 100, System.currentTimeMillis())));
 
         updatePinnedTimstampTask.run();
 
@@ -838,7 +838,7 @@ public void testGetMetadataFilesToBeDeletedExclusionBasedOnAgeAndPinning() throw
         String md3Timestamp = RemoteStoreUtils.invertLong(currentTimeInMillis - 600000);
 
         long pinnedTimestamp = RemoteStoreUtils.invertLong(md2Timestamp) + 10000;
-        when(blobContainer.listBlobs()).thenReturn(Map.of(randomInt(100) + "__" + pinnedTimestamp, new PlainBlobMetadata("xyz", 100)));
+        when(blobContainer.listBlobs()).thenReturn(Map.of(randomInt(100) + "__" + pinnedTimestamp, new PlainBlobMetadata("xyz", 100, System.currentTimeMillis())));
 
         updatePinnedTimstampTask.run();
 
diff --git a/server/src/test/java/org/opensearch/index/translog/transfer/BlobStoreTransferServiceTests.java b/server/src/test/java/org/opensearch/index/translog/transfer/BlobStoreTransferServiceTests.java
index fddc6c0c94005..c7e37459a5227 100644
--- a/server/src/test/java/org/opensearch/index/translog/transfer/BlobStoreTransferServiceTests.java
+++ b/server/src/test/java/org/opensearch/index/translog/transfer/BlobStoreTransferServiceTests.java
@@ -54,6 +54,7 @@
 import java.util.Base64;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -348,6 +349,11 @@ public void deleteBlobsAsyncIgnoringIfNotExists(List<String> blobNames, ActionLi
             throw new RuntimeException("deleteBlobsAsyncIgnoringIfNotExists not supported");
         }
 
+        @Override
+        public Set<String> copyFilesFromSrcRemote(Set<String> files, AsyncMultiStreamBlobContainer blobContainer) {
+            return null;
+        }
+
         @Override
         public void deleteAsync(ActionListener<DeleteResult> completionListener) {
             throw new RuntimeException("deleteAsync not supported");
diff --git a/server/src/test/java/org/opensearch/index/translog/transfer/TranslogTransferManagerTests.java b/server/src/test/java/org/opensearch/index/translog/transfer/TranslogTransferManagerTests.java
index ed0d6b7d50706..a02b517678a12 100644
--- a/server/src/test/java/org/opensearch/index/translog/transfer/TranslogTransferManagerTests.java
+++ b/server/src/test/java/org/opensearch/index/translog/transfer/TranslogTransferManagerTests.java
@@ -399,8 +399,8 @@ public void testReadMetadataFile() throws IOException {
         doAnswer(invocation -> {
             LatchedActionListener<List<BlobMetadata>> latchedActionListener = invocation.getArgument(3);
             List<BlobMetadata> bmList = new LinkedList<>();
-            bmList.add(new PlainBlobMetadata(mdFilename1, 1));
-            bmList.add(new PlainBlobMetadata(mdFilename2, 1));
+            bmList.add(new PlainBlobMetadata(mdFilename1, 1, System.currentTimeMillis()));
+            bmList.add(new PlainBlobMetadata(mdFilename2, 1, System.currentTimeMillis()));
             latchedActionListener.onResponse(bmList);
             return null;
         }).when(transferService)
@@ -426,7 +426,7 @@ public void testReadMetadataReadException() throws IOException {
         doAnswer(invocation -> {
             LatchedActionListener<List<BlobMetadata>> latchedActionListener = invocation.getArgument(3);
             List<BlobMetadata> bmList = new LinkedList<>();
-            bmList.add(new PlainBlobMetadata(mdFilename, 1));
+            bmList.add(new PlainBlobMetadata(mdFilename, 1, System.currentTimeMillis()));
             latchedActionListener.onResponse(bmList);
             return null;
         }).when(transferService)
@@ -542,9 +542,9 @@ public void testDeleteStaleTranslogMetadata() {
         doAnswer(invocation -> {
             ActionListener<List<BlobMetadata>> actionListener = invocation.getArgument(4);
             List<BlobMetadata> bmList = new LinkedList<>();
-            bmList.add(new PlainBlobMetadata(tm1, 1));
-            bmList.add(new PlainBlobMetadata(tm2, 1));
-            bmList.add(new PlainBlobMetadata(tm3, 1));
+            bmList.add(new PlainBlobMetadata(tm1, 1, System.currentTimeMillis()));
+            bmList.add(new PlainBlobMetadata(tm2, 1, System.currentTimeMillis()));
+            bmList.add(new PlainBlobMetadata(tm3, 1, System.currentTimeMillis()));
             actionListener.onResponse(bmList);
             return null;
         }).when(transferService)
@@ -636,8 +636,8 @@ public void testMetadataConflict() throws InterruptedException {
         doAnswer(invocation -> {
             LatchedActionListener<List<BlobMetadata>> latchedActionListener = invocation.getArgument(3);
             List<BlobMetadata> bmList = new LinkedList<>();
-            bmList.add(new PlainBlobMetadata(mdFilename, 1));
-            bmList.add(new PlainBlobMetadata(mdFilename2, 1));
+            bmList.add(new PlainBlobMetadata(mdFilename, 1, System.currentTimeMillis()));
+            bmList.add(new PlainBlobMetadata(mdFilename2, 1, System.currentTimeMillis()));
             latchedActionListener.onResponse(bmList);
             return null;
         }).when(transferService)
@@ -766,9 +766,9 @@ public void testlistTranslogMetadataFilesAsync() throws Exception {
         doAnswer(invocation -> {
             ActionListener<List<BlobMetadata>> actionListener = invocation.getArgument(4);
             List<BlobMetadata> bmList = new LinkedList<>();
-            bmList.add(new PlainBlobMetadata(tm1, 1));
-            bmList.add(new PlainBlobMetadata(tm2, 1));
-            bmList.add(new PlainBlobMetadata(tm3, 1));
+            bmList.add(new PlainBlobMetadata(tm1, 1, System.currentTimeMillis()));
+            bmList.add(new PlainBlobMetadata(tm2, 1, System.currentTimeMillis()));
+            bmList.add(new PlainBlobMetadata(tm3, 1, System.currentTimeMillis()));
             actionListener.onResponse(bmList);
             return null;
         }).when(transferService)
@@ -814,9 +814,9 @@ public void testReadMetadataForGivenTimestampNoMatchingFile() throws IOException
         doAnswer(invocation -> {
             LatchedActionListener<List<BlobMetadata>> latchedActionListener = invocation.getArgument(3);
             String timestamp1 = RemoteStoreUtils.invertLong(2345L);
-            BlobMetadata bm1 = new PlainBlobMetadata("metadata__1__12__" + timestamp1 + "__node1__1", 1);
+            BlobMetadata bm1 = new PlainBlobMetadata("metadata__1__12__" + timestamp1 + "__node1__1", 1, System.currentTimeMillis());
             String timestamp2 = RemoteStoreUtils.invertLong(3456L);
-            BlobMetadata bm2 = new PlainBlobMetadata("metadata__1__12__" + timestamp2 + "__node1__1", 1);
+            BlobMetadata bm2 = new PlainBlobMetadata("metadata__1__12__" + timestamp2 + "__node1__1", 1, System.currentTimeMillis());
             List<BlobMetadata> bmList = List.of(bm1, bm2);
             latchedActionListener.onResponse(bmList);
             return null;
@@ -833,9 +833,9 @@ public void testReadMetadataForGivenTimestampFile() throws IOException {
         mdFilename1.set("metadata__1__12__" + timestamp1 + "__node1__1");
         doAnswer(invocation -> {
             LatchedActionListener<List<BlobMetadata>> latchedActionListener = invocation.getArgument(3);
-            BlobMetadata bm1 = new PlainBlobMetadata(mdFilename1.get(), 1);
+            BlobMetadata bm1 = new PlainBlobMetadata(mdFilename1.get(), 1, System.currentTimeMillis());
             String timestamp2 = RemoteStoreUtils.invertLong(3456L);
-            BlobMetadata bm2 = new PlainBlobMetadata("metadata__1__12__" + timestamp2 + "__node1__1", 1);
+            BlobMetadata bm2 = new PlainBlobMetadata("metadata__1__12__" + timestamp2 + "__node1__1", 1, System.currentTimeMillis());
             List<BlobMetadata> bmList = List.of(bm1, bm2);
             latchedActionListener.onResponse(bmList);
             return null;
@@ -861,9 +861,9 @@ public void testReadMetadataForGivenTimestampException() throws IOException {
         mdFilename1.set("metadata__1__12__" + timestamp1 + "__node1__1");
         doAnswer(invocation -> {
             LatchedActionListener<List<BlobMetadata>> latchedActionListener = invocation.getArgument(3);
-            BlobMetadata bm1 = new PlainBlobMetadata(mdFilename1.get(), 1);
+            BlobMetadata bm1 = new PlainBlobMetadata(mdFilename1.get(), 1, System.currentTimeMillis());
             String timestamp2 = RemoteStoreUtils.invertLong(3456L);
-            BlobMetadata bm2 = new PlainBlobMetadata("metadata__1__12__" + timestamp2 + "__node1__1", 1);
+            BlobMetadata bm2 = new PlainBlobMetadata("metadata__1__12__" + timestamp2 + "__node1__1", 1, System.currentTimeMillis());
             List<BlobMetadata> bmList = List.of(bm1, bm2);
             latchedActionListener.onResponse(bmList);
             return null;
diff --git a/server/src/test/java/org/opensearch/indices/IndicesLifecycleListenerSingleNodeTests.java b/server/src/test/java/org/opensearch/indices/IndicesLifecycleListenerSingleNodeTests.java
index 0428bdf0655b0..5628ee07840d3 100644
--- a/server/src/test/java/org/opensearch/indices/IndicesLifecycleListenerSingleNodeTests.java
+++ b/server/src/test/java/org/opensearch/indices/IndicesLifecycleListenerSingleNodeTests.java
@@ -163,10 +163,10 @@ public void afterIndexRemoved(Index index, IndexSettings indexSettings, IndexRem
                 RetentionLeaseSyncer.EMPTY,
                 SegmentReplicationCheckpointPublisher.EMPTY,
                 null,
-                null,
                 localNode,
                 null,
-                DiscoveryNodes.builder().add(localNode).build()
+                DiscoveryNodes.builder().add(localNode).build(),
+                null
             );
             IndexShardTestCase.updateRoutingEntry(shard, newRouting);
             assertEquals(5, counter.get());
diff --git a/server/src/test/java/org/opensearch/indices/IndicesRequestCacheTests.java b/server/src/test/java/org/opensearch/indices/IndicesRequestCacheTests.java
index 1a3aece74b3e2..b3b56b1f8f924 100644
--- a/server/src/test/java/org/opensearch/indices/IndicesRequestCacheTests.java
+++ b/server/src/test/java/org/opensearch/indices/IndicesRequestCacheTests.java
@@ -1432,10 +1432,10 @@ public void testDeleteAndCreateIndexShardOnSameNodeAndVerifyStats() throws Excep
             RetentionLeaseSyncer.EMPTY,
             SegmentReplicationCheckpointPublisher.EMPTY,
             null,
-            null,
             localNode,
             null,
-            DiscoveryNodes.builder().add(localNode).build()
+            DiscoveryNodes.builder().add(localNode).build(),
+            null
         );
 
         // Verify that the new shard requestStats entries are empty.
diff --git a/server/src/test/java/org/opensearch/indices/cluster/AbstractIndicesClusterStateServiceTestCase.java b/server/src/test/java/org/opensearch/indices/cluster/AbstractIndicesClusterStateServiceTestCase.java
index 0490228a5cc16..16023a1e4eb15 100644
--- a/server/src/test/java/org/opensearch/indices/cluster/AbstractIndicesClusterStateServiceTestCase.java
+++ b/server/src/test/java/org/opensearch/indices/cluster/AbstractIndicesClusterStateServiceTestCase.java
@@ -60,6 +60,9 @@
 import org.opensearch.indices.recovery.PeerRecoveryTargetService;
 import org.opensearch.indices.recovery.RecoveryListener;
 import org.opensearch.indices.recovery.RecoveryState;
+import org.opensearch.indices.recovery.StartRecoveryRequest;
+import org.opensearch.indices.recovery.inplacesplit.InPlaceShardSplitRecoveryListener;
+import org.opensearch.indices.recovery.inplacesplit.InPlaceShardSplitRecoveryService;
 import org.opensearch.indices.replication.checkpoint.SegmentReplicationCheckpointPublisher;
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.test.OpenSearchTestCase;
@@ -276,6 +279,28 @@ public MockIndexShard createShard(
             return indexShard;
         }
 
+        @Override
+        public void createChildShardsForSplit(
+            List<ShardRouting> shardRoutings,
+            ShardId parentShardId,
+            InPlaceShardSplitRecoveryService inPlaceShardSplitRecoveryService,
+            InPlaceShardSplitRecoveryListener recoveryListener,
+            Consumer<IndexShard.ShardFailure> onShardFailure,
+            DiscoveryNode node,
+            Consumer<ShardId> globalCheckpointSyncer,
+            RetentionLeaseSyncer retentionLeaseSyncer,
+            SegmentReplicationCheckpointPublisher checkpointPublisher,
+            RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory,
+            StartRecoveryRequest request,
+            DiscoveryNodes discoveryNodes) throws IOException {
+
+        }
+
+        @Override
+        public void moveChildShardsToStarted(ShardId parentShardId, InPlaceShardSplitRecoveryService inPlaceShardSplitRecoveryService) {
+
+        }
+
         @Override
         public void processPendingDeletes(Index index, IndexSettings indexSettings, TimeValue timeValue) throws IOException,
             InterruptedException {
@@ -427,6 +452,11 @@ public ShardRouting routingEntry() {
             return shardRouting;
         }
 
+        @Override
+        public ShardId getParentShardId() {
+            return null;
+        }
+
         @Override
         public IndexShardState state() {
             return null;
diff --git a/server/src/test/java/org/opensearch/indices/cluster/ClusterStateChanges.java b/server/src/test/java/org/opensearch/indices/cluster/ClusterStateChanges.java
index b11a583de4eee..0bc582eee31e0 100644
--- a/server/src/test/java/org/opensearch/indices/cluster/ClusterStateChanges.java
+++ b/server/src/test/java/org/opensearch/indices/cluster/ClusterStateChanges.java
@@ -466,7 +466,10 @@ public ClusterState applyFailedShards(ClusterState clusterState, List<FailedShar
                     0L,
                     failedShard.getMessage(),
                     failedShard.getFailure(),
-                    failedShard.markAsStale()
+                    failedShard.markAsStale(),
+                    null,
+                    null,
+                    null
                 )
             )
             .collect(Collectors.toList());
@@ -487,7 +490,9 @@ public ClusterState applyStartedShards(ClusterState clusterState, Map<ShardRouti
             clusterState,
             startedShards.entrySet()
                 .stream()
-                .map(e -> new StartedShardEntry(e.getKey().shardId(), e.getKey().allocationId().getId(), e.getValue(), "shard started"))
+                .map(
+                    e -> new StartedShardEntry(e.getKey().shardId(), e.getKey().allocationId().getId(), e.getValue(), "shard started", null, null, null)
+                )
                 .collect(Collectors.toList())
         );
     }
diff --git a/server/src/test/java/org/opensearch/indices/cluster/IndicesClusterStateServiceRandomUpdatesTests.java b/server/src/test/java/org/opensearch/indices/cluster/IndicesClusterStateServiceRandomUpdatesTests.java
index 22bf337b05598..7cc59aaaa9347 100644
--- a/server/src/test/java/org/opensearch/indices/cluster/IndicesClusterStateServiceRandomUpdatesTests.java
+++ b/server/src/test/java/org/opensearch/indices/cluster/IndicesClusterStateServiceRandomUpdatesTests.java
@@ -584,6 +584,7 @@ private IndicesClusterStateService createIndicesClusterStateService(
             primaryReplicaSyncer,
             s -> {},
             RetentionLeaseSyncer.EMPTY,
+            null,
             null
         );
     }
diff --git a/server/src/test/java/org/opensearch/indices/recovery/LocalStorePeerRecoverySourceHandlerTests.java b/server/src/test/java/org/opensearch/indices/recovery/LocalStorePeerRecoverySourceHandlerTests.java
index a4598c4294a33..fdba776bdb311 100644
--- a/server/src/test/java/org/opensearch/indices/recovery/LocalStorePeerRecoverySourceHandlerTests.java
+++ b/server/src/test/java/org/opensearch/indices/recovery/LocalStorePeerRecoverySourceHandlerTests.java
@@ -45,6 +45,8 @@
 import org.apache.lucene.store.IOContext;
 import org.apache.lucene.tests.index.RandomIndexWriter;
 import org.apache.lucene.tests.store.BaseDirectoryWrapper;
+import org.junit.After;
+import org.junit.Before;
 import org.opensearch.ExceptionsHelper;
 import org.opensearch.Version;
 import org.opensearch.action.LatchedActionListener;
@@ -104,8 +106,6 @@
 import org.opensearch.threadpool.FixedExecutorBuilder;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
-import org.junit.After;
-import org.junit.Before;
 
 import java.io.IOException;
 import java.io.OutputStream;
@@ -134,10 +134,7 @@
 
 import static java.util.Collections.emptyMap;
 import static java.util.Collections.emptySet;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.hasSize;
-import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.*;
 import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.anyBoolean;
 import static org.mockito.Mockito.anyString;
@@ -229,10 +226,13 @@ public void writeFileChunk(
             request,
             Math.toIntExact(recoverySettings.getChunkSize().getBytes()),
             between(1, 5),
-            between(1, 5)
+            between(1, 5),
+            false,
+            new CancellableThreads()
         );
         PlainActionFuture<Void> sendFilesFuture = new PlainActionFuture<>();
-        handler.sendFiles(store, metas.toArray(new StoreFileMetadata[0]), () -> 0, sendFilesFuture);
+        IndexCommit snapshot = DirectoryReader.listCommits(dir).get(0);
+        handler.sendFiles(store, metas.toArray(new StoreFileMetadata[0]), () -> 0, sendFilesFuture, snapshot);
         sendFilesFuture.actionGet();
         Store.MetadataSnapshot targetStoreMetadata = targetStore.getMetadata();
         Store.RecoveryDiff recoveryDiff = targetStoreMetadata.recoveryDiff(metadata);
@@ -260,7 +260,8 @@ public StartRecoveryRequest getStartRecoveryRequest() throws IOException {
             metadataSnapshot,
             randomBoolean(),
             randomNonNegativeLong(),
-            randomBoolean() || metadataSnapshot.getHistoryUUID() == null ? SequenceNumbers.UNASSIGNED_SEQ_NO : randomNonNegativeLong()
+            randomBoolean() || metadataSnapshot.getHistoryUUID() == null ? SequenceNumbers.UNASSIGNED_SEQ_NO : randomNonNegativeLong(),
+            null
         );
     }
 
@@ -310,9 +311,11 @@ public void indexTranslogOperations(
             request,
             fileChunkSizeInBytes,
             between(1, 10),
-            between(1, 10)
+            between(1, 10),
+            false,
+            new CancellableThreads()
         );
-        PlainActionFuture<RecoverySourceHandler.SendSnapshotResult> future = new PlainActionFuture<>();
+        PlainActionFuture<List<RecoverySourceHandler.SendSnapshotResult>> future = new PlainActionFuture<>();
         handler.phase2(
             startingSeqNo,
             endingSeqNo,
@@ -324,7 +327,7 @@ public void indexTranslogOperations(
             future
         );
         final int expectedOps = (int) (endingSeqNo - startingSeqNo + 1);
-        RecoverySourceHandler.SendSnapshotResult result = future.actionGet();
+        RecoverySourceHandler.SendSnapshotResult result = future.actionGet().get(0);
         assertThat(result.sentOperations, equalTo(expectedOps));
         List<Translog.Operation> sortedShippedOps = shippedOps.stream()
             .sorted(Comparator.comparing(Translog.Operation::seqNo))
@@ -373,9 +376,11 @@ public void indexTranslogOperations(
             request,
             fileChunkSizeInBytes,
             between(1, 10),
-            between(1, 10)
+            between(1, 10),
+            false,
+            new CancellableThreads()
         );
-        PlainActionFuture<RecoverySourceHandler.SendSnapshotResult> future = new PlainActionFuture<>();
+        PlainActionFuture<List<RecoverySourceHandler.SendSnapshotResult>> future = new PlainActionFuture<>();
         final long startingSeqNo = randomLongBetween(0, ops.size() - 1L);
         final long endingSeqNo = randomLongBetween(startingSeqNo, ops.size() - 1L);
         handler.phase2(
@@ -433,7 +438,7 @@ public void indexTranslogOperations(
             }
         };
 
-        PlainActionFuture<RecoverySourceHandler.SendSnapshotResult> sendFuture = new PlainActionFuture<>();
+        PlainActionFuture<List<RecoverySourceHandler.SendSnapshotResult>> sendFuture = new PlainActionFuture<>();
         long startingSeqNo = randomIntBetween(0, 1000);
         long endingSeqNo = startingSeqNo + randomIntBetween(0, 10000);
         List<Translog.Operation> operations = generateOperations(numOps);
@@ -447,7 +452,9 @@ public void indexTranslogOperations(
             getStartRecoveryRequest(),
             between(1, 10 * 1024),
             between(1, 5),
-            between(1, 5)
+            between(1, 5),
+            false,
+            new CancellableThreads()
         );
         handler.phase2(
             startingSeqNo,
@@ -459,7 +466,7 @@ public void indexTranslogOperations(
             mappingVersion,
             sendFuture
         );
-        RecoverySourceHandler.SendSnapshotResult sendSnapshotResult = sendFuture.actionGet();
+        RecoverySourceHandler.SendSnapshotResult sendSnapshotResult = sendFuture.actionGet().get(0);
         assertTrue(received.get());
         assertThat(sendSnapshotResult.targetLocalCheckpoint, equalTo(localCheckpoint.get()));
         assertThat(sendSnapshotResult.sentOperations, equalTo(receivedSeqNos.size()));
@@ -566,15 +573,19 @@ public void writeFileChunk(
             request,
             Math.toIntExact(recoverySettings.getChunkSize().getBytes()),
             between(1, 8),
-            between(1, 8)
+            between(1, 8),
+            false,
+            new CancellableThreads()
         );
         SetOnce<Exception> sendFilesError = new SetOnce<>();
         CountDownLatch latch = new CountDownLatch(1);
+        IndexCommit snapshot = DirectoryReader.listCommits(dir).get(0);
         handler.sendFiles(
             store,
             metas.toArray(new StoreFileMetadata[0]),
             () -> 0,
-            new LatchedActionListener<>(ActionListener.wrap(r -> sendFilesError.set(null), e -> sendFilesError.set(e)), latch)
+            new LatchedActionListener<>(ActionListener.wrap(r -> sendFilesError.set(null), e -> sendFilesError.set(e)), latch),
+            snapshot
         );
         latch.await();
         assertThat(sendFilesError.get(), instanceOf(IOException.class));
@@ -641,10 +652,13 @@ public void writeFileChunk(
             request,
             Math.toIntExact(recoverySettings.getChunkSize().getBytes()),
             between(1, 10),
-            between(1, 4)
+            between(1, 4),
+            false,
+            new CancellableThreads()
         );
         PlainActionFuture<Void> sendFilesFuture = new PlainActionFuture<>();
-        handler.sendFiles(store, metas.toArray(new StoreFileMetadata[0]), () -> 0, sendFilesFuture);
+        IndexCommit snapshot = DirectoryReader.listCommits(dir).get(0);
+        handler.sendFiles(store, metas.toArray(new StoreFileMetadata[0]), () -> 0, sendFilesFuture, snapshot);
         Exception ex = expectThrows(Exception.class, sendFilesFuture::actionGet);
         final IOException unwrappedCorruption = ExceptionsHelper.unwrapCorruption(ex);
         if (throwCorruptedIndexException) {
@@ -694,11 +708,13 @@ public void testThrowExceptionOnPrimaryRelocatedBeforePhase1Started() throws IOE
             request,
             Math.toIntExact(recoverySettings.getChunkSize().getBytes()),
             between(1, 8),
-            between(1, 8)
+            between(1, 8),
+            false,
+            new CancellableThreads()
         ) {
 
             @Override
-            void phase1(
+            protected void phase1(
                 IndexCommit snapshot,
                 long startingSeqNo,
                 IntSupplier translogOps,
@@ -710,13 +726,13 @@ void phase1(
             }
 
             @Override
-            void prepareTargetForTranslog(int totalTranslogOps, ActionListener<TimeValue> listener) {
+            protected void prepareTargetForTranslog(int totalTranslogOps, ActionListener<TimeValue> listener) {
                 prepareTargetForTranslogCalled.set(true);
                 super.prepareTargetForTranslog(totalTranslogOps, listener);
             }
 
             @Override
-            void phase2(
+            protected void phase2(
                 long startingSeqNo,
                 long endingSeqNo,
                 Translog.Snapshot snapshot,
@@ -724,7 +740,7 @@ void phase2(
                 long maxSeqNoOfUpdatesOrDeletes,
                 RetentionLeases retentionLeases,
                 long mappingVersion,
-                ActionListener<SendSnapshotResult> listener
+                ActionListener<List<SendSnapshotResult>> listener
             ) throws IOException {
                 phase2Called.set(true);
                 super.phase2(
@@ -795,11 +811,13 @@ public void testThrowExceptionOnNoTargetInRouting() throws IOException {
             request,
             Math.toIntExact(recoverySettings.getChunkSize().getBytes()),
             between(1, 8),
-            between(1, 8)
+            between(1, 8),
+            false,
+            new CancellableThreads()
         ) {
 
             @Override
-            void phase1(
+            protected void phase1(
                 IndexCommit snapshot,
                 long startingSeqNo,
                 IntSupplier translogOps,
@@ -811,13 +829,13 @@ void phase1(
             }
 
             @Override
-            void prepareTargetForTranslog(int totalTranslogOps, ActionListener<TimeValue> listener) {
+            protected void prepareTargetForTranslog(int totalTranslogOps, ActionListener<TimeValue> listener) {
                 prepareTargetForTranslogCalled.set(true);
                 super.prepareTargetForTranslog(totalTranslogOps, listener);
             }
 
             @Override
-            void phase2(
+            protected void phase2(
                 long startingSeqNo,
                 long endingSeqNo,
                 Translog.Snapshot snapshot,
@@ -825,7 +843,7 @@ void phase2(
                 long maxSeqNoOfUpdatesOrDeletes,
                 RetentionLeases retentionLeases,
                 long mappingVersion,
-                ActionListener<SendSnapshotResult> listener
+                ActionListener<List<SendSnapshotResult>> listener
             ) throws IOException {
                 phase2Called.set(true);
                 super.phase2(
@@ -900,11 +918,13 @@ public void testTargetInRoutingInSecondAttempt() throws IOException {
             request,
             Math.toIntExact(recoverySettings.getChunkSize().getBytes()),
             between(1, 8),
-            between(1, 8)
+            between(1, 8),
+            false,
+            new CancellableThreads()
         ) {
 
             @Override
-            void phase1(
+            protected void phase1(
                 IndexCommit snapshot,
                 long startingSeqNo,
                 IntSupplier translogOps,
@@ -916,13 +936,13 @@ void phase1(
             }
 
             @Override
-            void prepareTargetForTranslog(int totalTranslogOps, ActionListener<TimeValue> listener) {
+            protected void prepareTargetForTranslog(int totalTranslogOps, ActionListener<TimeValue> listener) {
                 prepareTargetForTranslogCalled.set(true);
                 super.prepareTargetForTranslog(totalTranslogOps, listener);
             }
 
             @Override
-            void phase2(
+            protected void phase2(
                 long startingSeqNo,
                 long endingSeqNo,
                 Translog.Snapshot snapshot,
@@ -930,7 +950,7 @@ void phase2(
                 long maxSeqNoOfUpdatesOrDeletes,
                 RetentionLeases retentionLeases,
                 long mappingVersion,
-                ActionListener<SendSnapshotResult> listener
+                ActionListener<List<SendSnapshotResult>> listener
             ) throws IOException {
                 phase2Called.set(true);
                 super.phase2(
@@ -1006,13 +1026,15 @@ public void writeFileChunk(
             getStartRecoveryRequest(),
             chunkSize,
             maxConcurrentChunks,
-            between(1, 10)
+            between(1, 10),
+            false,
+            new CancellableThreads()
         );
         Store store = newStore(createTempDir(), false);
         List<StoreFileMetadata> files = generateFiles(store, between(1, 10), () -> between(1, chunkSize * 20));
         int totalChunks = files.stream().mapToInt(md -> ((int) md.length() + chunkSize - 1) / chunkSize).sum();
         PlainActionFuture<Void> sendFilesFuture = new PlainActionFuture<>();
-        handler.sendFiles(store, files.toArray(new StoreFileMetadata[0]), () -> 0, sendFilesFuture);
+        handler.sendFiles(store, files.toArray(new StoreFileMetadata[0]), () -> 0, sendFilesFuture, null);
         assertBusy(() -> {
             assertThat(sentChunks.get(), equalTo(Math.min(totalChunks, maxConcurrentChunks)));
             assertThat(unrepliedChunks, hasSize(sentChunks.get()));
@@ -1079,7 +1101,9 @@ public void writeFileChunk(
             getStartRecoveryRequest(),
             chunkSize,
             maxConcurrentChunks,
-            between(1, 5)
+            between(1, 5),
+            false,
+            new CancellableThreads()
         );
         Store store = newStore(createTempDir(), false);
         List<StoreFileMetadata> files = generateFiles(store, between(1, 10), () -> between(1, chunkSize * 20));
@@ -1090,7 +1114,8 @@ public void writeFileChunk(
             store,
             files.toArray(new StoreFileMetadata[0]),
             () -> 0,
-            new LatchedActionListener<>(ActionListener.wrap(r -> sendFilesError.set(null), e -> sendFilesError.set(e)), sendFilesLatch)
+            new LatchedActionListener<>(ActionListener.wrap(r -> sendFilesError.set(null), e -> sendFilesError.set(e)), sendFilesLatch),
+            null
         );
         assertBusy(() -> assertThat(sentChunks.get(), equalTo(Math.min(totalChunks, maxConcurrentChunks))));
         List<FileChunkResponse> failedChunks = randomSubsetOf(between(1, unrepliedChunks.size()), unrepliedChunks);
@@ -1187,7 +1212,9 @@ public void cleanFiles(
             startRecoveryRequest,
             between(1, 16),
             between(1, 4),
-            between(1, 4)
+            between(1, 4),
+            false,
+            new CancellableThreads()
         ) {
             @Override
             void createRetentionLease(long startingSeqNo, ActionListener<RetentionLease> listener) {
@@ -1226,7 +1253,9 @@ public void testVerifySeqNoStatsWhenRecoverWithSyncId() throws Exception {
             getStartRecoveryRequest(),
             between(1, 16),
             between(1, 4),
-            between(1, 4)
+            between(1, 4),
+            false,
+            new CancellableThreads()
         );
 
         String syncId = UUIDs.randomBase64UUID();
diff --git a/server/src/test/java/org/opensearch/indices/recovery/PeerRecoverySourceServiceTests.java b/server/src/test/java/org/opensearch/indices/recovery/PeerRecoverySourceServiceTests.java
index ded174fb98eef..818c5c60eaf8b 100644
--- a/server/src/test/java/org/opensearch/indices/recovery/PeerRecoverySourceServiceTests.java
+++ b/server/src/test/java/org/opensearch/indices/recovery/PeerRecoverySourceServiceTests.java
@@ -41,6 +41,7 @@
 import org.opensearch.index.shard.IndexShardTestUtils;
 import org.opensearch.index.store.Store;
 import org.opensearch.indices.IndicesService;
+import org.opensearch.indices.recovery.inplacesplit.InPlaceShardSplitRecoveryService;
 import org.opensearch.test.NodeRoles;
 import org.opensearch.transport.TransportService;
 
@@ -58,11 +59,17 @@ public void testDuplicateRecoveries() throws IOException {
         final ClusterService clusterService = mock(ClusterService.class);
         when(clusterService.getSettings()).thenReturn(NodeRoles.dataNode());
         when(indicesService.clusterService()).thenReturn(clusterService);
+        InPlaceShardSplitRecoveryService splitRecoveryService = new InPlaceShardSplitRecoveryService(
+            indicesService,
+            new RecoverySettings(Settings.EMPTY, new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS))
+        );
         PeerRecoverySourceService peerRecoverySourceService = new PeerRecoverySourceService(
             mock(TransportService.class),
             indicesService,
-            new RecoverySettings(Settings.EMPTY, new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS))
+            new RecoverySettings(Settings.EMPTY, new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)),
+            splitRecoveryService
         );
+
         StartRecoveryRequest startRecoveryRequest = new StartRecoveryRequest(
             primary.shardId(),
             randomAlphaOfLength(10),
@@ -71,7 +78,8 @@ public void testDuplicateRecoveries() throws IOException {
             Store.MetadataSnapshot.EMPTY,
             randomBoolean(),
             randomLong(),
-            SequenceNumbers.UNASSIGNED_SEQ_NO
+            SequenceNumbers.UNASSIGNED_SEQ_NO,
+            null
         );
         peerRecoverySourceService.start();
         RecoverySourceHandler handler = peerRecoverySourceService.ongoingRecoveries.addNewRecovery(startRecoveryRequest, primary);
diff --git a/server/src/test/java/org/opensearch/indices/recovery/RemoteStorePeerRecoverySourceHandlerTests.java b/server/src/test/java/org/opensearch/indices/recovery/RemoteStorePeerRecoverySourceHandlerTests.java
index 7f913f3c8596a..15853d1708bfd 100644
--- a/server/src/test/java/org/opensearch/indices/recovery/RemoteStorePeerRecoverySourceHandlerTests.java
+++ b/server/src/test/java/org/opensearch/indices/recovery/RemoteStorePeerRecoverySourceHandlerTests.java
@@ -20,6 +20,7 @@
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.CancellableThreads;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.IndexSettings;
@@ -42,6 +43,7 @@
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.Collections;
+import java.util.List;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.IntSupplier;
 
@@ -159,11 +161,14 @@ public void testThrowExceptionOnNoTargetInRouting() throws IOException {
             request,
             Math.toIntExact(recoverySettings.getChunkSize().getBytes()),
             between(1, 8),
-            between(1, 8)
+            between(1, 8),
+            false,
+            new CancellableThreads(),
+            null
         ) {
 
             @Override
-            void phase1(
+            protected void phase1(
                 IndexCommit snapshot,
                 long startingSeqNo,
                 IntSupplier translogOps,
@@ -175,13 +180,13 @@ void phase1(
             }
 
             @Override
-            void prepareTargetForTranslog(int totalTranslogOps, ActionListener<TimeValue> listener) {
+            protected void prepareTargetForTranslog(int totalTranslogOps, ActionListener<TimeValue> listener) {
                 prepareTargetForTranslogCalled.set(true);
                 super.prepareTargetForTranslog(totalTranslogOps, listener);
             }
 
             @Override
-            void phase2(
+            protected void phase2(
                 long startingSeqNo,
                 long endingSeqNo,
                 Translog.Snapshot snapshot,
@@ -189,7 +194,7 @@ void phase2(
                 long maxSeqNoOfUpdatesOrDeletes,
                 RetentionLeases retentionLeases,
                 long mappingVersion,
-                ActionListener<SendSnapshotResult> listener
+                ActionListener<List<SendSnapshotResult>> listener
             ) throws IOException {
                 phase2Called.set(true);
                 super.phase2(
@@ -232,7 +237,8 @@ public StartRecoveryRequest getStartRecoveryRequest() throws IOException {
             metadataSnapshot,
             randomBoolean(),
             randomNonNegativeLong(),
-            randomBoolean() || metadataSnapshot.getHistoryUUID() == null ? SequenceNumbers.UNASSIGNED_SEQ_NO : randomNonNegativeLong()
+            randomBoolean() || metadataSnapshot.getHistoryUUID() == null ? SequenceNumbers.UNASSIGNED_SEQ_NO : randomNonNegativeLong(),
+            null
         );
     }
 }
diff --git a/server/src/test/java/org/opensearch/indices/recovery/StartRecoveryRequestTests.java b/server/src/test/java/org/opensearch/indices/recovery/StartRecoveryRequestTests.java
index b76f830fe8431..437a4e94f96ce 100644
--- a/server/src/test/java/org/opensearch/indices/recovery/StartRecoveryRequestTests.java
+++ b/server/src/test/java/org/opensearch/indices/recovery/StartRecoveryRequestTests.java
@@ -71,7 +71,8 @@ public void testSerialization() throws Exception {
             metadataSnapshot,
             randomBoolean(),
             randomNonNegativeLong(),
-            randomBoolean() || metadataSnapshot.getHistoryUUID() == null ? SequenceNumbers.UNASSIGNED_SEQ_NO : randomNonNegativeLong()
+            randomBoolean() || metadataSnapshot.getHistoryUUID() == null ? SequenceNumbers.UNASSIGNED_SEQ_NO : randomNonNegativeLong(),
+            null
         );
 
         final ByteArrayOutputStream outBuffer = new ByteArrayOutputStream();
diff --git a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetServiceTests.java b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetServiceTests.java
index 1faaa16ce5628..5d4e5649700b5 100644
--- a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetServiceTests.java
+++ b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetServiceTests.java
@@ -231,6 +231,7 @@ public void getSegmentFiles(
             }
         };
         final SegmentReplicationTarget target = new SegmentReplicationTarget(
+            replicaShard,
             replicaShard,
             primaryShard.getLatestReplicationCheckpoint(),
             source,
@@ -302,6 +303,7 @@ public void getSegmentFiles(
         };
         final SegmentReplicationTarget target = spy(
             new SegmentReplicationTarget(
+                replicaShard,
                 replicaShard,
                 initialCheckpoint,
                 source,
@@ -332,6 +334,7 @@ public void onReplicationFailure(
         // try and insert a new target directly - it should fail immediately and alert listener
         spy.startReplication(
             new SegmentReplicationTarget(
+                replicaShard,
                 replicaShard,
                 aheadCheckpoint,
                 source,
@@ -425,6 +428,7 @@ public void cancel() {
 
         final SegmentReplicationTarget targetSpy = spy(
             new SegmentReplicationTarget(
+                replicaShard,
                 replicaShard,
                 updatedCheckpoint,
                 source,
@@ -674,6 +678,7 @@ public void testForceSegmentSyncHandlerWithFailure_AlreadyClosedException_swallo
     public void testTargetCancelledBeforeStartInvoked() {
         final String cancelReason = "test";
         final SegmentReplicationTarget target = new SegmentReplicationTarget(
+            replicaShard,
             replicaShard,
             primaryShard.getLatestReplicationCheckpoint(),
             mock(SegmentReplicationSource.class),
diff --git a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetTests.java b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetTests.java
index 8b4b3aff701b4..1cece47f8e1fb 100644
--- a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetTests.java
+++ b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicationTargetTests.java
@@ -146,7 +146,7 @@ public void getSegmentFiles(
         SegmentReplicationTargetService.SegmentReplicationListener segRepListener = mock(
             SegmentReplicationTargetService.SegmentReplicationListener.class
         );
-        segrepTarget = new SegmentReplicationTarget(spyIndexShard, repCheckpoint, segrepSource, segRepListener);
+        segrepTarget = new SegmentReplicationTarget(spyIndexShard, spyIndexShard, repCheckpoint, segrepSource, segRepListener);
 
         segrepTarget.startReplication(new ActionListener<Void>() {
             @Override
@@ -208,7 +208,7 @@ public void getSegmentFiles(
         SegmentReplicationTargetService.SegmentReplicationListener segRepListener = mock(
             SegmentReplicationTargetService.SegmentReplicationListener.class
         );
-        segrepTarget = new SegmentReplicationTarget(spyIndexShard, repCheckpoint, segrepSource, segRepListener);
+        segrepTarget = new SegmentReplicationTarget(spyIndexShard, spyIndexShard, repCheckpoint, segrepSource, segRepListener);
 
         segrepTarget.startReplication(new ActionListener<Void>() {
             @Override
@@ -261,7 +261,7 @@ public void getSegmentFiles(
         SegmentReplicationTargetService.SegmentReplicationListener segRepListener = mock(
             SegmentReplicationTargetService.SegmentReplicationListener.class
         );
-        segrepTarget = new SegmentReplicationTarget(spyIndexShard, repCheckpoint, segrepSource, segRepListener);
+        segrepTarget = new SegmentReplicationTarget(spyIndexShard, spyIndexShard, repCheckpoint, segrepSource, segRepListener);
 
         segrepTarget.startReplication(new ActionListener<Void>() {
             @Override
@@ -314,7 +314,7 @@ public void getSegmentFiles(
         SegmentReplicationTargetService.SegmentReplicationListener segRepListener = mock(
             SegmentReplicationTargetService.SegmentReplicationListener.class
         );
-        segrepTarget = new SegmentReplicationTarget(spyIndexShard, repCheckpoint, segrepSource, segRepListener);
+        segrepTarget = new SegmentReplicationTarget(spyIndexShard, spyIndexShard, repCheckpoint, segrepSource, segRepListener);
 
         doThrow(exception).when(spyIndexShard).finalizeReplication(any());
 
@@ -361,7 +361,7 @@ public void getSegmentFiles(
         SegmentReplicationTargetService.SegmentReplicationListener segRepListener = mock(
             SegmentReplicationTargetService.SegmentReplicationListener.class
         );
-        segrepTarget = new SegmentReplicationTarget(spyIndexShard, repCheckpoint, segrepSource, segRepListener);
+        segrepTarget = new SegmentReplicationTarget(spyIndexShard, spyIndexShard, repCheckpoint, segrepSource, segRepListener);
 
         doThrow(exception).when(spyIndexShard).finalizeReplication(any());
 
@@ -406,7 +406,7 @@ public void getSegmentFiles(
         SegmentReplicationTargetService.SegmentReplicationListener segRepListener = mock(
             SegmentReplicationTargetService.SegmentReplicationListener.class
         );
-        segrepTarget = new SegmentReplicationTarget(spyIndexShard, repCheckpoint, segrepSource, segRepListener);
+        segrepTarget = new SegmentReplicationTarget(spyIndexShard, spyIndexShard, repCheckpoint, segrepSource, segRepListener);
         when(spyIndexShard.getSegmentMetadataMap()).thenReturn(SI_SNAPSHOT_DIFFERENT);
         segrepTarget.startReplication(new ActionListener<Void>() {
             @Override
@@ -469,7 +469,7 @@ public void getSegmentFiles(
             SegmentReplicationTargetService.SegmentReplicationListener.class
         );
 
-        segrepTarget = new SegmentReplicationTarget(spyIndexShard, repCheckpoint, segrepSource, segRepListener);
+        segrepTarget = new SegmentReplicationTarget(spyIndexShard, spyIndexShard, repCheckpoint, segrepSource, segRepListener);
         when(spyIndexShard.getSegmentMetadataMap()).thenReturn(storeMetadataSnapshots.get(0).asMap());
         segrepTarget.startReplication(new ActionListener<Void>() {
             @Override
diff --git a/server/src/test/java/org/opensearch/recovery/ReplicationCollectionTests.java b/server/src/test/java/org/opensearch/recovery/ReplicationCollectionTests.java
index 4ce4e28690697..fb35c0ddac258 100644
--- a/server/src/test/java/org/opensearch/recovery/ReplicationCollectionTests.java
+++ b/server/src/test/java/org/opensearch/recovery/ReplicationCollectionTests.java
@@ -119,12 +119,14 @@ public void testStartMultipleReplicationsForSingleShard() throws Exception {
             final IndexShard shard = shards.addReplica();
             shards.recoverReplica(shard);
             final SegmentReplicationTarget target1 = new SegmentReplicationTarget(
+                shard,
                 shard,
                 shards.getPrimary().getLatestReplicationCheckpoint(),
                 mock(SegmentReplicationSource.class),
                 mock(ReplicationListener.class)
             );
             final SegmentReplicationTarget target2 = new SegmentReplicationTarget(
+                shard,
                 shard,
                 shards.getPrimary().getLatestReplicationCheckpoint(),
                 mock(SegmentReplicationSource.class),
diff --git a/server/src/test/java/org/opensearch/snapshots/BlobStoreFormatTests.java b/server/src/test/java/org/opensearch/snapshots/BlobStoreFormatTests.java
index 72798f7691eb1..66ed42e5e60e2 100644
--- a/server/src/test/java/org/opensearch/snapshots/BlobStoreFormatTests.java
+++ b/server/src/test/java/org/opensearch/snapshots/BlobStoreFormatTests.java
@@ -65,7 +65,9 @@
 import java.io.InputStream;
 import java.nio.file.Path;
 import java.util.List;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.CountDownLatch;
 
 import org.mockito.ArgumentCaptor;
@@ -334,6 +336,11 @@ public boolean remoteIntegrityCheckSupported() {
             return false;
         }
 
+        @Override
+        public Set<String> copyFilesFromSrcRemote(Set<String> files, AsyncMultiStreamBlobContainer blobContainer) {
+            return new HashSet<>();
+        }
+
         public BlobContainer getDelegate() {
             return delegate;
         }
diff --git a/server/src/test/java/org/opensearch/snapshots/InternalSnapshotsInfoServiceTests.java b/server/src/test/java/org/opensearch/snapshots/InternalSnapshotsInfoServiceTests.java
index 88de234d3449b..ad6a8761c66e2 100644
--- a/server/src/test/java/org/opensearch/snapshots/InternalSnapshotsInfoServiceTests.java
+++ b/server/src/test/java/org/opensearch/snapshots/InternalSnapshotsInfoServiceTests.java
@@ -463,7 +463,7 @@ private ClusterState addUnassignedShards(final ClusterState currentState, String
             currentState.custom(RestoreInProgress.TYPE, RestoreInProgress.EMPTY)
         );
         final Map<ShardId, RestoreInProgress.ShardRestoreStatus> shards = new HashMap<>();
-        for (int i = 0; i < indexMetadata.getNumberOfShards(); i++) {
+        for (int i = 0; i < numberOfShards; i++) {
             shards.put(new ShardId(index, i), new RestoreInProgress.ShardRestoreStatus(clusterService.state().nodes().getLocalNodeId()));
         }
 
diff --git a/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java b/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java
index d21282ff0441f..6945162f35aaa 100644
--- a/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java
+++ b/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java
@@ -205,6 +205,7 @@
 import org.opensearch.indices.cluster.IndicesClusterStateService;
 import org.opensearch.indices.mapper.MapperRegistry;
 import org.opensearch.indices.recovery.DefaultRecoverySettings;
+import org.opensearch.indices.recovery.inplacesplit.InPlaceShardSplitRecoveryService;
 import org.opensearch.indices.recovery.PeerRecoverySourceService;
 import org.opensearch.indices.recovery.PeerRecoveryTargetService;
 import org.opensearch.indices.recovery.RecoverySettings;
@@ -2142,7 +2143,8 @@ public void onFailure(final Exception e) {
                     new NodeMappingRefreshAction(transportService, metadataMappingService),
                     repositoriesService,
                     mock(SearchService.class),
-                    new PeerRecoverySourceService(transportService, indicesService, recoverySettings),
+                    new PeerRecoverySourceService(transportService, indicesService, recoverySettings,
+                        new InPlaceShardSplitRecoveryService(indicesService, recoverySettings)),
                     snapshotShardsService,
                     new PrimaryReplicaSyncer(
                         transportService,
@@ -2170,7 +2172,8 @@ public void onFailure(final Exception e) {
                     ),
                     RetentionLeaseSyncer.EMPTY,
                     SegmentReplicationCheckpointPublisher.EMPTY,
-                    mock(RemoteStoreStatsTrackerFactory.class)
+                    mock(RemoteStoreStatsTrackerFactory.class),
+                    mock(InPlaceShardSplitRecoveryService.class)
                 );
 
                 final SystemIndices systemIndices = new SystemIndices(emptyMap());
diff --git a/server/src/test/java/org/opensearch/snapshots/mockstore/MockEventuallyConsistentRepository.java b/server/src/test/java/org/opensearch/snapshots/mockstore/MockEventuallyConsistentRepository.java
index f9388c9e4b86e..91b3fe792f320 100644
--- a/server/src/test/java/org/opensearch/snapshots/mockstore/MockEventuallyConsistentRepository.java
+++ b/server/src/test/java/org/opensearch/snapshots/mockstore/MockEventuallyConsistentRepository.java
@@ -300,7 +300,7 @@ public Map<String, BlobMetadata> listBlobs() {
                             .collect(
                                 Collectors.toMap(
                                     action -> action.path.substring(thisPath.length()),
-                                    action -> new PlainBlobMetadata(action.path.substring(thisPath.length()), action.data.length)
+                                    action -> new PlainBlobMetadata(action.path.substring(thisPath.length()), action.data.length, System.currentTimeMillis())
                                 )
                             )
                     );
diff --git a/test/framework/src/main/java/org/opensearch/cluster/routing/TestShardRouting.java b/test/framework/src/main/java/org/opensearch/cluster/routing/TestShardRouting.java
index a6af658be2ca1..cf303f5eff2dd 100644
--- a/test/framework/src/main/java/org/opensearch/cluster/routing/TestShardRouting.java
+++ b/test/framework/src/main/java/org/opensearch/cluster/routing/TestShardRouting.java
@@ -339,7 +339,9 @@ public static ShardRouting newShardRouting(
             buildRecoveryTarget(primary, state),
             unassignedInfo,
             buildAllocationId(state),
-            -1
+            -1,
+            null,
+            null
         );
     }
 
@@ -361,7 +363,9 @@ public static ShardRouting newShardRouting(
             recoverySource,
             buildUnassignedInfo(state),
             buildAllocationId(state),
-            -1
+            -1,
+            null,
+            null
         );
     }
 }
diff --git a/test/framework/src/main/java/org/opensearch/index/replication/OpenSearchIndexLevelReplicationTestCase.java b/test/framework/src/main/java/org/opensearch/index/replication/OpenSearchIndexLevelReplicationTestCase.java
index 062ebd2051f6e..37f96ee9dc861 100644
--- a/test/framework/src/main/java/org/opensearch/index/replication/OpenSearchIndexLevelReplicationTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/index/replication/OpenSearchIndexLevelReplicationTestCase.java
@@ -872,7 +872,8 @@ public void performOn(
                 final long primaryTerm,
                 final long globalCheckpoint,
                 final long maxSeqNoOfUpdatesOrDeletes,
-                final ActionListener<ReplicationOperation.ReplicaResponse> listener
+                final ActionListener<ReplicationOperation.ReplicaResponse> listener,
+                final boolean replicatingToChild
             ) {
                 IndexShard replica = replicationTargets.findReplicaShard(replicaRouting);
                 replica.acquireReplicaOperationPermit(
diff --git a/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java b/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java
index 655a9eb7d5d38..d36d5f07b202b 100644
--- a/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java
@@ -72,6 +72,7 @@
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.BigArrays;
+import org.opensearch.common.util.CancellableThreads;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.bytes.BytesArray;
@@ -717,7 +718,8 @@ protected IndexShard newShard(
                 DefaultRecoverySettings.INSTANCE,
                 DefaultRemoteStoreSettings.INSTANCE,
                 false,
-                discoveryNodes
+                discoveryNodes,
+                null
             );
             indexShard.addShardFailureCallback(DEFAULT_SHARD_FAILURE_HANDLER);
             if (remoteStoreStatsTrackerFactory != null) {
@@ -1163,7 +1165,10 @@ public final void recoverUnstartedReplica(
             primary,
             new AsyncRecoveryTarget(recoveryTarget, threadPool.generic(), primary, replica, replicatePrimaryFunction),
             request,
-            recoverySettings
+            recoverySettings,
+            false,
+            new CancellableThreads(),
+            null
         );
         primary.updateShardState(
             primary.routingEntry(),
diff --git a/test/framework/src/main/java/org/opensearch/node/MockNode.java b/test/framework/src/main/java/org/opensearch/node/MockNode.java
index 97c06962ca2e7..afdc3d0c953c0 100644
--- a/test/framework/src/main/java/org/opensearch/node/MockNode.java
+++ b/test/framework/src/main/java/org/opensearch/node/MockNode.java
@@ -50,6 +50,8 @@
 import org.opensearch.env.Environment;
 import org.opensearch.http.HttpServerTransport;
 import org.opensearch.indices.IndicesService;
+import org.opensearch.indices.recovery.RecoverySettings;
+import org.opensearch.indices.recovery.inplacesplit.InPlaceShardSplitRecoveryService;
 import org.opensearch.plugins.Plugin;
 import org.opensearch.script.MockScriptService;
 import org.opensearch.script.ScriptContext;
@@ -87,6 +89,7 @@
 public class MockNode extends Node {
 
     private final Collection<Class<? extends Plugin>> classpathPlugins;
+    private final InPlaceShardSplitRecoveryService splitRecoveryService;
 
     public MockNode(final Settings settings, final Collection<Class<? extends Plugin>> classpathPlugins) {
         this(settings, classpathPlugins, true);
@@ -97,29 +100,33 @@ public MockNode(
         final Collection<Class<? extends Plugin>> classpathPlugins,
         final boolean forbidPrivateIndexSettings
     ) {
-        this(settings, classpathPlugins, null, forbidPrivateIndexSettings);
+        this(settings, classpathPlugins, null, forbidPrivateIndexSettings, null);
     }
 
     public MockNode(
         final Settings settings,
         final Collection<Class<? extends Plugin>> classpathPlugins,
         final Path configPath,
-        final boolean forbidPrivateIndexSettings
-    ) {
+        final boolean forbidPrivateIndexSettings,
+        final InPlaceShardSplitRecoveryService splitRecoveryService
+        ) {
         this(
             InternalSettingsPreparer.prepareEnvironment(settings, Collections.emptyMap(), configPath, () -> "mock_ node"),
             classpathPlugins,
-            forbidPrivateIndexSettings
+            forbidPrivateIndexSettings,
+            splitRecoveryService
         );
     }
 
     private MockNode(
         final Environment environment,
         final Collection<Class<? extends Plugin>> classpathPlugins,
-        final boolean forbidPrivateIndexSettings
+        final boolean forbidPrivateIndexSettings,
+        final InPlaceShardSplitRecoveryService splitRecoveryService
     ) {
         super(environment, classpathPlugins, forbidPrivateIndexSettings);
         this.classpathPlugins = classpathPlugins;
+        this.splitRecoveryService = splitRecoveryService;
     }
 
     /**
@@ -190,6 +197,16 @@ protected SearchService newSearchService(
         );
     }
 
+    @Override
+    protected InPlaceShardSplitRecoveryService newInPlaceShardSplitRecoveryService(
+        IndicesService indicesService, RecoverySettings recoverySettings) {
+        if (splitRecoveryService == null) {
+            return super.newInPlaceShardSplitRecoveryService(indicesService, recoverySettings);
+        }
+
+        return splitRecoveryService;
+    }
+
     @Override
     protected ScriptService newScriptService(Settings settings, Map<String, ScriptEngine> engines, Map<String, ScriptContext<?>> contexts) {
         if (getPluginsService().filterPlugins(MockScriptService.TestPlugin.class).isEmpty()) {
diff --git a/test/framework/src/main/java/org/opensearch/repositories/AbstractThirdPartyRepositoryTestCase.java b/test/framework/src/main/java/org/opensearch/repositories/AbstractThirdPartyRepositoryTestCase.java
index 5c28d9f83a4ee..8218b12976917 100644
--- a/test/framework/src/main/java/org/opensearch/repositories/AbstractThirdPartyRepositoryTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/repositories/AbstractThirdPartyRepositoryTestCase.java
@@ -160,7 +160,7 @@ public void testListChildren() throws Exception {
         assertBlobsByPrefix(
             repo.basePath().add("foo"),
             "nest",
-            Collections.singletonMap("nested-blob", new PlainBlobMetadata("nested-blob", testBlobLen))
+            Collections.singletonMap("nested-blob", new PlainBlobMetadata("nested-blob", testBlobLen, System.currentTimeMillis()))
         );
         assertChildren(repo.basePath().add("foo").add("nested"), Collections.emptyList());
         if (randomBoolean()) {
diff --git a/test/framework/src/main/java/org/opensearch/test/BackgroundIndexer.java b/test/framework/src/main/java/org/opensearch/test/BackgroundIndexer.java
index 22ba6ed2c4224..149864190c204 100644
--- a/test/framework/src/main/java/org/opensearch/test/BackgroundIndexer.java
+++ b/test/framework/src/main/java/org/opensearch/test/BackgroundIndexer.java
@@ -35,11 +35,12 @@
 import com.carrotsearch.randomizedtesting.RandomizedTest;
 import com.carrotsearch.randomizedtesting.generators.RandomNumbers;
 import com.carrotsearch.randomizedtesting.generators.RandomStrings;
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.apache.logging.log4j.util.Supplier;
+import org.junit.Assert;
+import org.opensearch.action.bulk.BulkItemRequest;
 import org.opensearch.action.bulk.BulkItemResponse;
 import org.opensearch.action.bulk.BulkRequestBuilder;
 import org.opensearch.action.bulk.BulkResponse;
@@ -50,11 +51,12 @@
 import org.opensearch.common.util.concurrent.ConcurrentCollections;
 import org.opensearch.common.xcontent.XContentFactory;
 import org.opensearch.core.xcontent.XContentBuilder;
-import org.junit.Assert;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
 import java.util.Random;
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
@@ -172,7 +174,7 @@ public void run() {
                                 BulkRequestBuilder bulkRequest = client.prepareBulk().setTimeout(timeout);
                                 for (int i = 0; i < batchSize; i++) {
                                     id = idGenerator.incrementAndGet();
-                                    if (useAutoGeneratedIDs) {
+                                    if (false) {
                                         bulkRequest.add(client.prepareIndex(index).setSource(generateSource(id, threadRandom)));
                                     } else {
                                         bulkRequest.add(
@@ -361,6 +363,9 @@ public long totalIndexedDocs() {
 
     public void assertNoFailures() {
         synchronized (failures) {
+            for (Exception e : failures) {
+                logger.error("Printing exception", e);
+            }
             Assert.assertThat(failures, emptyIterable());
         }
     }
diff --git a/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java b/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java
index 7b2c653e9bdb2..4c9a3054fabc4 100644
--- a/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java
+++ b/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java
@@ -107,6 +107,7 @@
 import org.opensearch.indices.breaker.HierarchyCircuitBreakerService;
 import org.opensearch.indices.fielddata.cache.IndicesFieldDataCache;
 import org.opensearch.indices.recovery.RecoverySettings;
+import org.opensearch.indices.recovery.inplacesplit.InPlaceShardSplitRecoveryService;
 import org.opensearch.node.MockNode;
 import org.opensearch.node.Node;
 import org.opensearch.node.Node.DiscoverySettings;
@@ -287,6 +288,8 @@ public final class InternalTestCluster extends TestCluster {
 
     private int bootstrapClusterManagerNodeIndex = -1;
 
+    private InPlaceShardSplitRecoveryService splitRecoveryService;
+
     public InternalTestCluster(
         final long clusterSeed,
         final Path baseDir,
@@ -817,7 +820,8 @@ private synchronized NodeAndClient buildNode(int nodeId, Settings settings, bool
             // we clone this here since in the case of a node restart we might need it again
             secureSettings = ((MockSecureSettings) secureSettings).clone();
         }
-        MockNode node = new MockNode(settings, plugins, nodeConfigurationSource.nodeConfigPath(nodeId), forbidPrivateIndexSettings);
+        MockNode node = new MockNode(settings, plugins, nodeConfigurationSource.nodeConfigPath(nodeId),
+            forbidPrivateIndexSettings, splitRecoveryService);
         node.injector().getInstance(TransportService.class).addLifecycleListener(new LifecycleListener() {
             @Override
             public void afterStart() {
@@ -2329,6 +2333,14 @@ public List<String> startNodes(int numOfNodes, Settings settings, Boolean waitFo
         return startNodes(waitForNodeJoin, Collections.nCopies(numOfNodes, settings).toArray(new Settings[0]));
     }
 
+    public synchronized List<String> startNodesWithTestSplitRecoveryService(
+        int numOfNodes, InPlaceShardSplitRecoveryService recoveryService, Settings settings) {
+        if (this.splitRecoveryService == null) {
+            this.splitRecoveryService = recoveryService;
+        }
+        return startNodes(Collections.nCopies(numOfNodes, settings).toArray(new Settings[0]));
+    }
+
     /**
      * Starts multiple nodes with the given settings and returns their names
      */