             }
         })
         animateSnapshotViewOut()
-        
-        // Clear display link
         clearAutoScrollDisplayLink()
         
-        // Notify delegate
         delegate?.tableViewDidFinishReordering?(tableView)
     }
     
     // MARK: - Destination row
     
-    func updateDestinationRow() {
+    private func updateDestinationRow() {
         guard case let .Reordering(sourceRow, destinationRow, snapshotOffset) = reorderState else { return }
-        guard let tableView = tableView, snapshotView = snapshotView else { return }
-        
-        // Calculate snapping distances for rows
+        guard let tableView = tableView else { return }
+        
+        guard let newDestinationRow = newDestinationRow() where newDestinationRow != destinationRow else { return }
+        
+        reorderState = .Reordering(
+            sourceRow: sourceRow,
+            destinationRow: newDestinationRow,
+            snapshotOffset: snapshotOffset
+        )
+        delegate?.tableView(tableView, reorderRowAtIndexPath: destinationRow, toIndexPath: newDestinationRow)
+        
+        tableView.beginUpdates()
+        tableView.deleteRowsAtIndexPaths([destinationRow], withRowAnimation: .Fade)
+        tableView.insertRowsAtIndexPaths([newDestinationRow], withRowAnimation: .Fade)
+        tableView.endUpdates()
+    }
+    
+    private func newDestinationRow() -> NSIndexPath? {
+        guard case let .Reordering(_, destinationRow, _) = reorderState else { return nil }
+        guard let tableView = tableView, snapshotView = snapshotView else { return nil }
+        
         let rowSnapDistances = tableView.indexPathsForVisibleRows?.map { path -> (path: NSIndexPath, distance: CGFloat) in
             let rect = tableView.rectForRowAtIndexPath(path)
             

        guard case .Ready = reorderState else { return }
        guard let tableView = tableView, sourceRow = tableView.indexPathForRowAtPoint(point) else { return }
        
        // Make sure this row is reorderable
        guard delegate?.tableView?(tableView, canReorderRowAtIndexPath: sourceRow) != false else { return }
        
        // Create snapshot view
        createSnapshotViewForCellAtIndexPath(sourceRow)
        animateSnapshotViewIn()
        
        // Update state
        let snapshotOffset = snapshotView.flatMap { $0.center.y - point.y } ?? 0
        reorderState = .Reordering(
            sourceRow: sourceRow,

        guard case let .Reordering(_, _, snapshotOffset) = reorderState else { return }
        guard let snapshotView = snapshotView else { return }
        
        snapshotView.center.y = point.y + snapshotOffset
        updateDestinationRow()
    }
    
