diff --git a/js/components/datasets/datasetMoleculeList.js b/js/components/datasets/datasetMoleculeList.js
index b1192ba50..7fb2bb84d 100644
--- a/js/components/datasets/datasetMoleculeList.js
+++ b/js/components/datasets/datasetMoleculeList.js
@@ -43,7 +43,10 @@ import {
   deleteDataset,
   getTrackingActions,
   moveDatasetMoleculeUpDown,
-  getAllVisibleButNotLockedCompounds
+  getAllVisibleButNotLockedCompounds,
+  getObservationForLHSReference,
+  getCurrentDatasetIterator,
+  resetDatasetIterator
 } from './redux/dispatchActions';
 import {
   setAskLockCompoundsQuestion,
@@ -57,7 +60,8 @@ import {
   appendCompoundColorOfDataset,
   appendColorToAllCompoundsOfDataset,
   removeCompoundColorOfDataset,
-  removeColorFromAllCompoundsOfDataset
+  removeColorFromAllCompoundsOfDataset,
+  setDatasetIterator
 } from './redux/actions';
 import { DatasetFilter } from './datasetFilter';
 import { FilterList, Link, DeleteForever, ArrowUpward, ArrowDownward, Edit } from '@material-ui/icons';
@@ -637,6 +641,7 @@ const DatasetMoleculeList = ({ title, datasetID, url }) => {
   };
 
   const onButtonToggle = (type, calledFromSelectAll = false) => {
+    resetIterator();
     if (calledFromSelectAll === true && selectedAll.current === true) {
       // REDO
       if (eval('is' + ucfirst(type) + 'On') === false) {
@@ -784,6 +789,10 @@ const DatasetMoleculeList = ({ title, datasetID, url }) => {
     lockedMolecules.map(cid => ({ datasetID, molecule: getCompoundForId(cid) }))
   );
 
+  const resetIterator = () => {
+    dispatch(resetDatasetIterator(datasetID));
+  };
+
   // useEffectDebugger(
   //   () => {},
   //   [setSortDialogAnchorEl, loadNextMolecules, addMoleculeViewRef, setSelectedMoleculeRef, moveMolecule],
@@ -851,14 +860,36 @@ const DatasetMoleculeList = ({ title, datasetID, url }) => {
   // );
 
   const getFirstItemForIterationStart = () => {
-    const firstItem = joinedMoleculeLists.find(
-      mol =>
-        (ligandList.includes(mol.id) ||
-          proteinList.includes(mol.id) ||
-          complexList.includes(mol.id) ||
-          surfaceList.includes(mol.id)) &&
-        !lockedMolecules.includes(mol.id)
-    );
+    let firstItem = dispatch(getCurrentDatasetIterator(datasetID));
+    if (!firstItem) {
+      firstItem = joinedMoleculeLists.find(mol => {
+        if (!mol.isCustomPdb) {
+          const obs = dispatch(getObservationForLHSReference(mol));
+          if (obs) {
+            return (
+              (ligandList.includes(mol.id) ||
+                proteinList.includes(obs.id) ||
+                complexList.includes(obs.id) ||
+                surfaceList.includes(obs.id)) &&
+              !lockedMolecules.includes(mol.id)
+            );
+          } else {
+            return false;
+          }
+        } else {
+          return (
+            (ligandList.includes(mol.id) ||
+              proteinListDataset.includes(mol.id) ||
+              complexListDataset.includes(mol.id) ||
+              surfaceListDataset.includes(mol.id)) &&
+            !lockedMolecules.includes(mol.id)
+          );
+        }
+      });
+      // if (firstItem) {
+      //   dispatch(setDatasetIterator(datasetID, firstItem));
+      // }
+    }
 
     return firstItem;
   };
@@ -892,12 +923,28 @@ const DatasetMoleculeList = ({ title, datasetID, url }) => {
         const node = getNode(nextItem.id);
         setScrollToMoleculeId(nextItem.id);
 
+        let firstItemIdToUse = firstItem.id;
+        let isCustomPdb = true;
+        if (!firstItem.isCustomPdb) {
+          isCustomPdb = false;
+          const obs = dispatch(getObservationForLHSReference(firstItem));
+          if (obs) {
+            firstItemIdToUse = obs.id;
+          }
+        }
+
         let dataValue = {
           colourToggle: getRandomColor(firstItem),
           isLigandOn: ligandList.includes(firstItem.id),
-          isProteinOn: proteinList.includes(firstItem.id),
-          isComplexOn: complexList.includes(firstItem.id),
-          isSurfaceOn: surfaceList.includes(firstItem.id)
+          isProteinOn: isCustomPdb
+            ? proteinListDataset.includes(firstItemIdToUse)
+            : proteinList.includes(firstItemIdToUse),
+          isComplexOn: isCustomPdb
+            ? complexListDataset.includes(firstItemIdToUse)
+            : complexList.includes(firstItemIdToUse),
+          isSurfaceOn: isCustomPdb
+            ? surfaceListDataset.includes(firstItemIdToUse)
+            : surfaceList.includes(firstItemIdToUse)
         };
 
         dispatch(setCrossReferenceCompoundName(moleculeTitleNext));
@@ -927,12 +974,28 @@ const DatasetMoleculeList = ({ title, datasetID, url }) => {
         const node = getNode(prevItem.id);
         setScrollToMoleculeId(prevItem.id);
 
+        let firstItemIdToUse = firstItem.id;
+        let isCustomPdb = true;
+        if (!firstItem.isCustomPdb) {
+          isCustomPdb = false;
+          const obs = dispatch(getObservationForLHSReference(firstItem));
+          if (obs) {
+            firstItemIdToUse = obs.id;
+          }
+        }
+
         let dataValue = {
           colourToggle: getRandomColor(firstItem),
           isLigandOn: ligandList.includes(firstItem.id),
-          isProteinOn: proteinList.includes(firstItem.id),
-          isComplexOn: complexList.includes(firstItem.id),
-          isSurfaceOn: surfaceList.includes(firstItem.id)
+          isProteinOn: isCustomPdb
+            ? proteinListDataset.includes(firstItemIdToUse)
+            : proteinList.includes(firstItemIdToUse),
+          isComplexOn: isCustomPdb
+            ? complexListDataset.includes(firstItemIdToUse)
+            : complexList.includes(firstItemIdToUse),
+          isSurfaceOn: isCustomPdb
+            ? surfaceListDataset.includes(firstItemIdToUse)
+            : surfaceList.includes(firstItemIdToUse)
         };
 
         dispatch(setCrossReferenceCompoundName(moleculeTitlePrev));
diff --git a/js/components/datasets/datasetMoleculeView/datasetMoleculeView.js b/js/components/datasets/datasetMoleculeView/datasetMoleculeView.js
index 5533d033c..eab19055a 100644
--- a/js/components/datasets/datasetMoleculeView/datasetMoleculeView.js
+++ b/js/components/datasets/datasetMoleculeView/datasetMoleculeView.js
@@ -39,7 +39,9 @@ import {
   isCompoundLocked,
   getFirstUnlockedSelectedCompoundAfter,
   moveSelectedDatasetMoleculeUpDown,
-  getFirstUnlockedSelectedCompoundBefore
+  getFirstUnlockedSelectedCompoundBefore,
+  resetSelectedCompoundIterator,
+  resetDatasetIterator
 } from '../redux/dispatchActions';
 
 import { isAnyInspirationTurnedOn, getFilteredDatasetMoleculeList } from '../redux/selectors';
@@ -504,6 +506,14 @@ const DatasetMoleculeView = memo(
       const current_style =
         isLigandOn || isProteinOn || isComplexOn || isSurfaceOn ? selected_style : not_selected_style;
 
+      const resetIterator = () => {
+        if (inSelectedCompoundsList) {
+          dispatch(resetSelectedCompoundIterator());
+        } else {
+          dispatch(resetDatasetIterator(datasetID));
+        }
+      };
+
       const addNewLigand = (skipTracking = false) => {
         dispatch(
           withDisabledDatasetMoleculeNglControlButton(datasetID, currentID, 'ligand', () => {
@@ -522,6 +532,7 @@ const DatasetMoleculeView = memo(
       const [loadingAll, setLoadingAll] = useState(false);
       const [loadingLigand, setLoadingLigand] = useState(false);
       const onLigand = calledFromSelectAll => {
+        resetIterator();
         setLoadingLigand(true);
         if (calledFromSelectAll === true && selectedAll.current === true) {
           if (isLigandOn === false) {
@@ -566,6 +577,7 @@ const DatasetMoleculeView = memo(
 
       const [loadingProtein, setLoadingProtein] = useState(false);
       const onProtein = calledFromSelectAll => {
+        resetIterator();
         setLoadingProtein(true);
         if (calledFromSelectAll === true && selectedAll.current === true) {
           if (isProteinOn === false) {
@@ -606,6 +618,7 @@ const DatasetMoleculeView = memo(
 
       const [loadingComplex, setLoadingComplex] = useState(false);
       const onComplex = calledFromSelectAll => {
+        resetIterator();
         setLoadingComplex(true);
         if (calledFromSelectAll === true && selectedAll.current === true) {
           if (isComplexOn === false) {
@@ -646,6 +659,7 @@ const DatasetMoleculeView = memo(
 
       const [loadingSurface, setLoadingSurface] = useState(false);
       const onSurface = calledFromSelectAll => {
+        resetIterator();
         setLoadingSurface(true);
         if (calledFromSelectAll === true && selectedAll.current === true) {
           if (isSurfaceOn === false) {
diff --git a/js/components/datasets/redux/actions.js b/js/components/datasets/redux/actions.js
index c172a9860..1c9875f6f 100644
--- a/js/components/datasets/redux/actions.js
+++ b/js/components/datasets/redux/actions.js
@@ -62,6 +62,16 @@ export const setFilterDialogOpen = filterDialogOpen => ({
   payload: filterDialogOpen
 });
 
+export const setDatasetIterator = (datasetID, currentCmp) => ({
+  type: constants.SET_DATASET_ITERATOR,
+  payload: { datasetID, currentCmp }
+});
+
+export const setSelectedCompoundsIterator = (datasetID, currentCmp) => ({
+  type: constants.SET_SELECTED_COMPOUNDS_ITERATOR,
+  payload: { datasetID, currentCmp }
+});
+
 export const setLigandList = function(datsetID, ligandList) {
   return {
     type: constants.SET_LIGAND_LIST,
@@ -579,4 +589,3 @@ export const setUpdatedDatasets = updatedDataset => ({
   type: constants.SET_UPDATED_DATASETS,
   payload: { updatedDataset }
 });
-
diff --git a/js/components/datasets/redux/constants.js b/js/components/datasets/redux/constants.js
index 99e1aab10..1fdfcbd64 100644
--- a/js/components/datasets/redux/constants.js
+++ b/js/components/datasets/redux/constants.js
@@ -115,7 +115,10 @@ export const constants = {
   SET_SELECT_ALL_BUTTON_FOR_DATASET: prefix + 'SET_SELECT_ALL_BUTTON_FOR_DATASET',
 
   SET_COMPOUND_SET: prefix + 'SET_COMPOUND_SET',
-  SET_UPDATED_DATASETS: prefix + 'SET_UPDATED_DATASETS'
+  SET_UPDATED_DATASETS: prefix + 'SET_UPDATED_DATASETS',
+
+  SET_DATASET_ITERATOR: prefix + 'SET_DATASET_ITERATOR',
+  SET_SELECTED_COMPOUNDS_ITERATOR: prefix + 'SET_SELECTED_COMPOUNDS_ITERATOR'
 };
 
 export const COUNT_OF_VISIBLE_SCORES = 7;
diff --git a/js/components/datasets/redux/dispatchActions.js b/js/components/datasets/redux/dispatchActions.js
index 1463b83ad..a6eef47c7 100644
--- a/js/components/datasets/redux/dispatchActions.js
+++ b/js/components/datasets/redux/dispatchActions.js
@@ -35,7 +35,9 @@ import {
   enableDatasetMoleculeNglControlButton,
   setArrowUpDown,
   removeDataset,
-  appendCompoundToSelectedCompoundsByDataset
+  appendCompoundToSelectedCompoundsByDataset,
+  setDatasetIterator,
+  setSelectedCompoundsIterator
 } from './actions';
 import { base_url } from '../../routes/constants';
 import {
@@ -66,7 +68,10 @@ import {
   addLigand,
   addDensity,
   addDensityCustomView,
-  hideAllSelectedMolecules
+  hideAllSelectedMolecules,
+  removeHitProtein,
+  removeComplex,
+  removeSurface
 } from '../../preview/molecule/redux/dispatchActions';
 import { OBJECT_TYPE } from '../../nglView/constants';
 import { getRepresentationsByType } from '../../nglView/generatingObjects';
@@ -586,42 +591,112 @@ export const autoHideDatasetDialogsOnScroll = ({ inspirationDialogRef, crossRefe
   }
 };
 
+export const getObservationForLHSReference = rhsCompound => (dispatch, getState) => {
+  let result = null;
+
+  if (!rhsCompound?.isCustomPdb && rhsCompound.site_observation_code) {
+    const state = getState();
+    const allLHSMols = state.apiReducers.all_mol_lists;
+    result = allLHSMols.find(mol => mol.code === rhsCompound.site_observation_code);
+  }
+
+  return result;
+};
+
+export const getRHSCmpReferencingLHSObservation = (obsId, obsReferenceToSkip = null) => (dispatch, getState) => {
+  let result = { obs: null, cmp: null };
+
+  const state = getState();
+  const lhsObservations = state.apiReducers.all_mol_lists;
+  const obs = lhsObservations.find(mol => mol.id === obsId);
+
+  if (obs?.code !== obsReferenceToSkip) {
+    const currentMolecules = state.datasetsReducers.moleculeLists;
+    const datasetIds = Object.keys(currentMolecules);
+    for (let i = 0; i < datasetIds.length; i++) {
+      const datasetID = datasetIds[i];
+      const molecules = currentMolecules[datasetID];
+      const found = molecules.find(mol => mol.site_observation_code === obs.code);
+      if (found) {
+        result = { obs: obs, cmp: found };
+        break;
+      }
+    }
+  }
+
+  return result;
+};
+
 export const clearCompoundView = (cmp, datasetID, stage, skipTracking) => (dispatch, getState) => {
   const state = getState();
 
-  const ligandList = state.datasetsReducers.ligandLists[datasetID];
-  const proteinList = state.datasetsReducers.proteinLists[datasetID];
-  const complexList = state.datasetsReducers.complexLists[datasetID];
-  const surfaceList = state.datasetsReducers.surfaceLists[datasetID];
+  let dataToUse = null;
+
+  let ligandList = state.datasetsReducers.ligandLists[datasetID];
+  let proteinList = [];
+  let complexList = [];
+  let surfaceList = [];
+
+  if (cmp.isCustomPdb) {
+    dataToUse = cmp;
 
-  if (ligandList?.includes(cmp.id)) {
+    proteinList = state.datasetsReducers.proteinLists[datasetID];
+    complexList = state.datasetsReducers.complexLists[datasetID];
+    surfaceList = state.datasetsReducers.surfaceLists[datasetID];
+  } else {
+    dataToUse = dispatch(getObservationForLHSReference(cmp));
+
+    proteinList = state.selectionReducers.proteinList;
+    complexList = state.selectionReducers.complexList;
+    surfaceList = state.selectionReducers.surfaceList;
+  }
+
+  if (ligandList?.includes(dataToUse.id)) {
     dispatch(removeDatasetLigand(stage, cmp, getRandomColor(cmp), datasetID, skipTracking));
   }
 
-  if (proteinList?.includes(cmp.id)) {
-    dispatch(removeDatasetHitProtein(stage, cmp, getRandomColor(cmp), datasetID, skipTracking));
+  if (proteinList?.includes(dataToUse.id)) {
+    if (dataToUse.isCustomPdb) {
+      dispatch(removeDatasetHitProtein(stage, cmp, getRandomColor(cmp), datasetID, skipTracking));
+    } else {
+      dispatch(removeHitProtein(stage, dataToUse, getRandomColor(cmp), skipTracking));
+    }
   }
 
-  if (complexList?.includes(cmp.id)) {
-    dispatch(removeDatasetComplex(stage, cmp, getRandomColor(cmp), datasetID, skipTracking));
+  if (complexList?.includes(dataToUse.id)) {
+    if (dataToUse.isCustomPdb) {
+      dispatch(removeDatasetComplex(stage, cmp, getRandomColor(cmp), datasetID, skipTracking));
+    } else {
+      dispatch(removeComplex(stage, dataToUse, getRandomColor(cmp), skipTracking));
+    }
   }
 
-  if (surfaceList?.includes(cmp.id)) {
-    dispatch(removeDatasetSurface(stage, cmp, getRandomColor(cmp), datasetID, skipTracking));
+  if (surfaceList?.includes(dataToUse.id)) {
+    if (dataToUse.isCustomPdb) {
+      dispatch(removeDatasetSurface(stage, cmp, getRandomColor(cmp), datasetID, skipTracking));
+    } else {
+      dispatch(removeSurface(stage, dataToUse, getRandomColor(cmp)));
+    }
   }
 };
 
-export const removeSelectedDatasetMolecules = (stage, skipTracking, skipMolecules = {}) => (dispatch, getState) => {
+export const removeSelectedDatasetMolecules = (stage, skipTracking, currentCmp = null, skipMolecules = {}) => (
+  dispatch,
+  getState
+) => {
   const state = getState();
   const datasets = state.datasetsReducers.datasets;
   const currentMolecules = state.datasetsReducers.moleculeLists;
   if (datasets) {
+    let proteinList = [];
+    let complexList = [];
+    let surfaceList = [];
     datasets.forEach(dataset => {
       const datasetID = dataset.id;
       const ligandList = state.datasetsReducers.ligandLists[datasetID];
-      const proteinList = state.datasetsReducers.proteinLists[datasetID];
-      const complexList = state.datasetsReducers.complexLists[datasetID];
-      const surfaceList = state.datasetsReducers.surfaceLists[datasetID];
+      proteinList = state.datasetsReducers.proteinLists[datasetID];
+      complexList = state.datasetsReducers.complexLists[datasetID];
+      surfaceList = state.datasetsReducers.surfaceLists[datasetID];
 
       const molecules = currentMolecules[datasetID].filter(molecule => {
         return !skipMolecules[datasetID]?.includes(molecule.id);
@@ -660,6 +735,33 @@ export const removeSelectedDatasetMolecules = (stage, skipTracking, skipMolecule
         }
       });
     });
+
+    proteinList = state.selectionReducers.proteinList;
+    complexList = state.selectionReducers.complexList;
+    surfaceList = state.selectionReducers.surfaceList;
+
+    const obsReferenceToSkip = currentCmp ? currentCmp.site_observation_code : '';
+
+    proteinList.forEach(obsId => {
+      const { obs, cmp } = dispatch(getRHSCmpReferencingLHSObservation(obsId, obsReferenceToSkip));
+      if (obs) {
+        dispatch(removeHitProtein(stage, obs, getRandomColor(cmp), skipTracking));
+      }
+    });
+
+    complexList.forEach(obsId => {
+      const { obs, cmp } = dispatch(getRHSCmpReferencingLHSObservation(obsId, obsReferenceToSkip));
+      if (obs) {
+        dispatch(removeComplex(stage, obs, getRandomColor(cmp), skipTracking));
+      }
+    });
+
+    surfaceList.forEach(obsId => {
+      const { obs, cmp } = dispatch(getRHSCmpReferencingLHSObservation(obsId, obsReferenceToSkip));
+      if (obs) {
+        dispatch(removeSurface(stage, obs, getRandomColor(cmp)));
+      }
+    });
   }
 };
 
@@ -674,11 +776,6 @@ const flattenInspirationsList = (inspirations, skipMolecules) => {
       }
     });
   });
-  // skipMolecules.forEach(molecule => {
-  //   if (!inspirationsToSkip.hasOwnProperty(molecule.id)) {
-  //     inspirationsToSkip[molecule.id] = molecule;
-  //   }
-  // });
 
   Object.keys(inspirations).forEach(molId => {
     const molecules = inspirations[molId];
@@ -1010,8 +1107,10 @@ export const moveSelectedDatasetMoleculeUpDown = (
     dispatch(moveSelectedDatasetMoleculeInspirationsSettings(item, newItem, stage, true))
   ]);
 
-  dispatch(removeSelectedDatasetMolecules(stage, true, { ...lockedCompounds }));
+  dispatch(removeSelectedDatasetMolecules(stage, true, newItem, { ...lockedCompounds }));
   dispatch(removeSelectedTypesOfDatasetInspirations([newItem], stage, true, datasetID));
+
+  dispatch(setSelectedCompoundsIterator(newItemDatasetID, newItem));
 };
 
 /**
@@ -1036,13 +1135,18 @@ export const moveDatasetMoleculeUpDown = (stage, datasetID, item, newItemDataset
   const inspirations = getInspirationsForMol(allInspirations, datasetID, newItem.id);
   dispatch(setInspirationMoleculeDataList(inspirations));
   dispatch(clearCompoundView(newItem, datasetID, stage, true));
+  console.log('moveDatasetMoleculeUpDown - compounds cleared');
   await Promise.all([
     dispatch(moveSelectedMoleculeSettings(stage, item, newItem, newItemDatasetID, datasetID, dataValue, true)),
     dispatch(moveSelectedDatasetMoleculeInspirationsSettings(item, newItem, stage, true))
   ]);
 
-  dispatch(removeSelectedDatasetMolecules(stage, true, { [newItemDatasetID]: [newItem.id, ...lockedCompounds] }));
+  dispatch(
+    removeSelectedDatasetMolecules(stage, true, newItem, { [newItemDatasetID]: [newItem.id, ...lockedCompounds] })
+  );
   dispatch(removeSelectedTypesOfDatasetInspirations([newItem], stage, true, datasetID));
+
+  dispatch(setDatasetIterator(newItemDatasetID, newItem));
 };
 
 export const getInspirationsForMol = (allInspirations, datasetId, molId) => {
@@ -1327,6 +1431,10 @@ export const moveSelectedMoleculeSettings = (
 ) => (dispatch, getState) => {
   const promises = [];
   if (newItem && data) {
+    let customPdbData = null;
+    if (!newItem.isCustomPdb) {
+      customPdbData = dispatch(getObservationForLHSReference(newItem));
+    }
     if (data.isLigandOn) {
       let representations = getRepresentationsByType(data.objectsInView, newItem, OBJECT_TYPE.LIGAND, datasetID);
       promises.push(
@@ -1337,34 +1445,59 @@ export const moveSelectedMoleculeSettings = (
     }
     if (data.isProteinOn) {
       let representations = getRepresentationsByType(data.objectsInView, newItem, OBJECT_TYPE.PROTEIN, datasetID);
-      promises.push(
-        dispatch(
-          addDatasetHitProtein(
-            stage,
-            newItem,
-            getRandomColor(newItem),
-            datasetIdOfMolecule,
-            skipTracking,
-            representations
+      if (newItem.isCustomPdb) {
+        promises.push(
+          dispatch(
+            addDatasetHitProtein(
+              stage,
+              newItem,
+              getRandomColor(newItem),
+              datasetIdOfMolecule,
+              skipTracking,
+              representations
+            )
           )
-        )
-      );
+        );
+      } else {
+        promises.push(
+          dispatch(
+            addHitProtein(stage, customPdbData, getRandomColor(newItem), true, skipTracking, representations, true)
+          )
+        );
+      }
     }
     if (data.isComplexOn) {
       let representations = getRepresentationsByType(data.objectsInView, newItem, OBJECT_TYPE.COMPLEX, datasetID);
-      promises.push(
-        dispatch(
-          addDatasetComplex(stage, newItem, getRandomColor(newItem), datasetIdOfMolecule, skipTracking, representations)
-        )
-      );
+      if (newItem.isCustomPdb) {
+        promises.push(
+          dispatch(
+            addDatasetComplex(
+              stage,
+              newItem,
+              getRandomColor(newItem),
+              datasetIdOfMolecule,
+              skipTracking,
+              representations
+            )
+          )
+        );
+      } else {
+        promises.push(
+          dispatch(addComplex(stage, customPdbData, getRandomColor(newItem), skipTracking, representations, true))
+        );
+      }
     }
     if (data.isSurfaceOn) {
       let representations = getRepresentationsByType(data.objectsInView, newItem, OBJECT_TYPE.SURFACE, datasetID);
-      promises.push(
-        dispatch(
-          addDatasetSurface(stage, newItem, getRandomColor(newItem), datasetIdOfMolecule, skipTracking, representations)
-        )
-      );
+      if (newItem.isCustomPdb) {
+        promises.push(
+          dispatch(addDatasetSurface(stage, newItem, getRandomColor(newItem), datasetIdOfMolecule, representations))
+        );
+      } else {
+        promises.push(
+          dispatch(addSurface(stage, customPdbData, getRandomColor(newItem), false, representations, true))
+        );
+      }
     }
   }
   return Promise.all(promises);
@@ -1493,3 +1626,32 @@ export const deleteDataset = (datasetID, stage) => async (dispatch, getState) =>
   dispatch(removeDataset(datasetID));
   console.log('dataset removed from redux store');
 };
+
+export const getCurrentDatasetIterator = datasetID => (dispatch, getState) => {
+  let result = null;
+
+  const state = getState();
+  const datasetIterators = state.datasetsReducers.iteratorDatasets;
+  if (datasetIterators.hasOwnProperty(datasetID)) {
+    result = datasetIterators[datasetID];
+  }
+
+  return result;
+};
+
+export const getCurrentSelectedCompoundIterator = () => (dispatch, getState) => {
+  let result = null;
+
+  const state = getState();
+  result = state.datasetsReducers.iteratorSelectedCompounds;
+
+  return result;
+};
+
+export const resetDatasetIterator = datasetID => (dispatch, getState) => {
+  dispatch(setDatasetIterator(datasetID, null));
+};
+
+export const resetSelectedCompoundIterator = () => (dispatch, getState) => {
+  dispatch(setSelectedCompoundsIterator(null, null));
+};
diff --git a/js/components/datasets/redux/reducer.js b/js/components/datasets/redux/reducer.js
index 17d8b52ea..af94f6198 100644
--- a/js/components/datasets/redux/reducer.js
+++ b/js/components/datasets/redux/reducer.js
@@ -79,7 +79,11 @@ export const INITIAL_STATE = {
   cmpForLocalLockVisibleCompoundsDialog: null,
   askLockCompoundsQuestion: true,
   editedColorGroup: null,
-  askLockSelectedCompoundsQuestion: true
+  askLockSelectedCompoundsQuestion: true,
+
+  //iterator functionality for dataset tabs and also selected compounds tab
+  iteratorDatasets: {},
+  iteratorSelectedCompounds: null
 };
 
 /**
@@ -283,6 +287,28 @@ export const datasetsReducers = (state = INITIAL_STATE, action = {}) => {
     case constants.REMOVE_FROM_INSPIRATION_LIST:
       return removeFromList(state, 'inspirationLists', action.payload.datasetID, action.payload.itemID);
 
+    case constants.SET_DATASET_ITERATOR: {
+      if (action.payload.currentCmp) {
+        return {
+          ...state,
+          iteratorDatasets: { ...state.iteratorDatasets, [action.payload.datasetID]: { ...action.payload.currentCmp } }
+        };
+      } else {
+        return {
+          ...state,
+          iteratorDatasets: { ...state.iteratorDatasets, [action.payload.datasetID]: null }
+        };
+      }
+    }
+
+    case constants.SET_SELECTED_COMPOUNDS_ITERATOR: {
+      if (action.payload) {
+        return { ...state, iteratorSelectedCompounds: { ...action.payload } };
+      } else {
+        return { ...state, iteratorSelectedCompounds: null };
+      }
+    }
+
     case constants.APPEND_TO_SCORE_DATASET_MAP:
       return Object.assign({}, state, {
         scoreDatasetMap: {
diff --git a/js/reducers/tracking/dispatchActions.js b/js/reducers/tracking/dispatchActions.js
index 2e5d5ca88..1ababf4f5 100644
--- a/js/reducers/tracking/dispatchActions.js
+++ b/js/reducers/tracking/dispatchActions.js
@@ -3485,7 +3485,7 @@ const handleArrowNavigationActionOfCompound = (action, isSelected, majorViewStag
     const qualityListMolecule = data.qualityList;
 
     dispatch(hideAllSelectedMolecules(majorViewStage, molecules, false, true));
-    dispatch(removeSelectedDatasetMolecules(majorViewStage, true));
+    dispatch(removeSelectedDatasetMolecules(majorViewStage, true, newItem));
 
     const newDatasetID = (newItem.hasOwnProperty('datasetID') && newItem.datasetID) || datasetID;
     const moleculeTitlePrev = newItem && newItem.name;