diff --git a/AppSchema.json b/AppSchema.json
index 1dcda25e6..9500af612 100644
--- a/AppSchema.json
+++ b/AppSchema.json
@@ -12425,6 +12425,15 @@
                 "label": "Add Dashboard",
                 "relatedUiObject": "Dashboard",
                 "actionFunction": "payload.onMenuItemClick"
+            },
+            {
+                "action": "Add Missing Dashboards",
+                "label": "Add Missing Dashboards",
+                "askConfirmation": true,
+                "confirmationLabel": "Confirm to Proceed",
+                "workDoneLabel": "Done",
+                "relatedUiObject": "Dashboard",
+                "actionFunction": "payload.onMenuItemClick"
             }
         ],
         "isHierarchyHead": true,
@@ -12474,6 +12483,9 @@
         ],
         "addLeftIcons": true,
         "level": 1,
+        "referenceAttachesTo": {
+            "compatibleTypes": "->Testing Environment->Production Environment->"
+        },
         "chainAttachesTo": {
             "compatibleTypes": "->Charting Space->"
         },
diff --git a/BackendServers/WebServer/index.html b/BackendServers/WebServer/index.html
index 88e9d558b..4e77c1241 100644
--- a/BackendServers/WebServer/index.html
+++ b/BackendServers/WebServer/index.html
@@ -11,9 +11,10 @@
     <script src="externalScripts/CCapture.all.min.js"></script>
 
     <!-- Documentation Style Sheets -->
+    <!--
     <link rel="stylesheet" type="text/css"
         href="https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css">
-
+-->
     <script type="text/javascript">
         function loadCanvas() {
             try {
@@ -42,8 +43,8 @@
     <div id="canvasApp"></div>
     <div id="docApp" style="position:fixed; top:100000px; left:100000px">
         <iframe id="docIFrame" style="border:none; " height="2000" 
-            width="900" src="https://julian-molina.github.io/Documentation/"></iframe>
-    </div> <!--    -->
+            width="900" ></iframe>
+    </div> <!-- src="https://julian-molina.github.io/Documentation/"   -->
     <div id="textAreaDiv"></div>
     <div id="inputDiv" style="font-family:saira condensed;">&nbsp;</div>
 
diff --git a/CanvasApp/DesignSpace/Workspace/FunctionLibraries/ChartingSpaceFunctions.js b/CanvasApp/DesignSpace/Workspace/FunctionLibraries/ChartingSpaceFunctions.js
index fda297ad3..453752151 100644
--- a/CanvasApp/DesignSpace/Workspace/FunctionLibraries/ChartingSpaceFunctions.js
+++ b/CanvasApp/DesignSpace/Workspace/FunctionLibraries/ChartingSpaceFunctions.js
@@ -1,7 +1,9 @@
 function newChartingSpaceFunctions() {
     thisObject = {
         addAllMineLayers: addAllMineLayers,
-        addMissingTimeMachines: addMissingTimeMachines
+        addMissingDashboards: addMissingDashboards,
+        addMissingTimeMachines: addMissingTimeMachines,
+        createTimeMachine: createTimeMachine
     }
 
     return thisObject
@@ -64,6 +66,10 @@ function newChartingSpaceFunctions() {
     }
 
     function addMissingTimeMachines(node, rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter) {
+        if (node.payload.referenceParent === undefined) {
+            node.payload.uiObject.setErrorMessage('This node needs to have a Reference Parent for this command tu run.')
+            return
+        }
 
         for (let i = 0; i < rootNodes.length; i++) {
             let rootNode = rootNodes[i]
@@ -89,97 +95,140 @@ function newChartingSpaceFunctions() {
             function scanSessionArray(sessionsArray) {
                 for (let i = 0; i < sessionsArray.length; i++) {
                     let session = sessionsArray[i]
+                    let environment = findNodeInNodeMesh(session, node.payload.referenceParent.type, undefined, true, false, true, false)
+                    if (environment === undefined) { continue }
+                    if (environment.id !== node.payload.referenceParent.id) { continue }
                     let market = findNodeInNodeMesh(session, 'Market Trading Tasks', undefined, true, false, true, false)
                     if (market.payload.referenceParent === undefined) { continue }
                     if (isMissingChildren(node, session, true) === true) {
-                        let mineProducts
-                        let timeMachine = functionLibraryUiObjectsFromNodes.addUIObject(node, 'Time Machine')
-                        timeMachine.payload.referenceParent = session
-                        timeMachine.name = session.name + ' ' + session.type
-                        timeMachine.payload.floatingObject.collapseToggle()
-
-                        /*
-                        We need to create a Timeline Chart for each Data Mine Indicators.
-                        */
-                        mineProducts = nodeBranchToArray(networkNode, 'Data Mine Products')
-                        for (let j = 0; j < mineProducts.length; j++) {
-                            let mineProduct = mineProducts[j]
-                            /*
-                            We need to filter out the ones that do not belong to the market where 
-                            the session is running at. 
-                            */
-                            if (mineProduct.payload.parentNode.payload.referenceParent === undefined) { continue }
-                            if (mineProduct.payload.parentNode.payload.referenceParent.id !== market.payload.referenceParent.id) { continue }
-
-                            let timelineChart = functionLibraryUiObjectsFromNodes.addUIObject(timeMachine, 'Timeline Chart')
-                            timelineChart.name = mineProduct.name
-                            timelineChart.layersManager.payload.referenceParent = mineProduct
-                            timelineChart.payload.floatingObject.collapseToggle()
-                            timelineChart.layersManager.payload.floatingObject.collapseToggle()
-
-                            let menu = timelineChart.layersManager.payload.uiObject.menu
-                            menu.internalClick('Add All Mine Layers')
-                            menu.internalClick('Add All Mine Layers')
-                        }
-
-                        mineProducts = nodeBranchToArray(networkNode, 'Trading Mine Products')
-                        for (let j = 0; j < mineProducts.length; j++) {
-                            let mineProduct = mineProducts[j]
-                            /*
-                            The mine products found so far, belongs to any session. To filer all the sessions
-                            that are not the one we are interested in, we do the following:
-                            */
-                            if (mineProduct.payload.parentNode === undefined) { continue }
-                            if (mineProduct.payload.parentNode.payload.parentNode.payload.referenceParent === undefined) { continue }
-                            if (mineProduct.payload.parentNode.payload.parentNode.payload.referenceParent.id !== session.id) { continue }
-                            /*
-                            At the current version of Superalgos, beta 6, there is only one Trading Mine,
-                            with only one bot, and it has so many data products that we want to put them
-                            in 3 different timeline charts. So we will create 3 charts, connect them, 
-                            and delete from each one 1/3 of the layers. We do all that next:
-                            */
-
-                            for (let k = 0; k < 3; k++) {
-                                let timelineChart = functionLibraryUiObjectsFromNodes.addUIObject(timeMachine, 'Timeline Chart')
-
-                                timelineChart.layersManager.payload.referenceParent = mineProduct
-                                timelineChart.payload.floatingObject.collapseToggle()
-                                timelineChart.layersManager.payload.floatingObject.collapseToggle()
-
-                                let menu = timelineChart.layersManager.payload.uiObject.menu
-                                menu.internalClick('Add All Mine Layers')
-                                menu.internalClick('Add All Mine Layers')
-
-                                switch (k) {
-                                    case 0: {
-                                        timelineChart.name = 'Trading Engine'
-                                        deleteNodeByName('Trading System')
-                                        deleteNodeByName('Objects')
-                                        break
-                                    }
-                                    case 1: {
-                                        timelineChart.name = 'Trading System'
-                                        deleteNodeByName('Trading Engine')
-                                        deleteNodeByName('Objects')
-                                        break
-                                    }
-                                    case 2: {
-                                        timelineChart.name = 'Objects'
-                                        deleteNodeByName('Trading Engine')
-                                        deleteNodeByName('Trading System')
-                                        break
-                                    }
-                                }
-                                function deleteNodeByName(nodeName) {
-                                    let nodeToDelete = findNodeInNodeMesh(timelineChart.layersManager, undefined, nodeName, true, true, false, false)
-                                    if (nodeToDelete === undefined) { return }
-                                    functionLibraryNodeDeleter.deleteUIObject(nodeToDelete, rootNodes)
-                                }
-                            }
-                        }
+                        createTimeMachine(node, session, market.payload.referenceParent, networkNode, rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter)
                     }
                 }
             }
         }
     }
+
+    function createTimeMachine(dashboard, session, market, networkNode, rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter) {
+        let mineProducts
+        let timeMachine = functionLibraryUiObjectsFromNodes.addUIObject(dashboard, 'Time Machine')
+        timeMachine.payload.referenceParent = session
+        timeMachine.name = session.name + ' ' + session.type
+        timeMachine.payload.floatingObject.collapseToggle()
+        timeMachine.payload.floatingObject.angleToParent = ANGLE_TO_PARENT.RANGE_180
+        /*
+        We need to create a Timeline Chart for each Data Mine Indicators.
+        */
+        mineProducts = nodeBranchToArray(networkNode, 'Data Mine Products')
+        for (let j = 0; j < mineProducts.length; j++) {
+            let mineProduct = mineProducts[j]
+            /*
+            We need to filter out the ones that do not belong to the market where 
+            the session is running at. 
+            */
+            if (mineProduct.payload.parentNode.payload.referenceParent === undefined) { continue }
+            if (mineProduct.payload.parentNode.payload.referenceParent.id !== market.id) { continue }
+
+            let timelineChart = functionLibraryUiObjectsFromNodes.addUIObject(timeMachine, 'Timeline Chart')
+            timelineChart.name = mineProduct.name
+            timelineChart.layersManager.payload.referenceParent = mineProduct
+            timelineChart.payload.floatingObject.collapseToggle()
+            timelineChart.layersManager.payload.floatingObject.collapseToggle()
+
+            let menu = timelineChart.layersManager.payload.uiObject.menu
+            menu.internalClick('Add All Mine Layers')
+            menu.internalClick('Add All Mine Layers')
+        }
+
+        mineProducts = nodeBranchToArray(networkNode, 'Trading Mine Products')
+        for (let j = 0; j < mineProducts.length; j++) {
+            let mineProduct = mineProducts[j]
+            /*
+            The mine products found so far, belongs to any session. To filer all the sessions
+            that are not the one we are interested in, we do the following:
+            */
+            if (mineProduct.payload.parentNode === undefined) { continue }
+            if (mineProduct.payload.parentNode.payload.parentNode.payload.referenceParent === undefined) { continue }
+            if (mineProduct.payload.parentNode.payload.parentNode.payload.referenceParent.id !== session.id) { continue }
+            /*
+            At the current version of Superalgos, beta 6, there is only one Trading Mine,
+            with only one bot, and it has so many data products that we want to put them
+            in 3 different timeline charts. So we will create 3 charts, connect them, 
+            and delete from each one 1/3 of the layers. We do all that next:
+            */
+
+            for (let k = 0; k < 3; k++) {
+                let timelineChart = functionLibraryUiObjectsFromNodes.addUIObject(timeMachine, 'Timeline Chart')
+
+                timelineChart.layersManager.payload.referenceParent = mineProduct
+                timelineChart.payload.floatingObject.collapseToggle()
+                timelineChart.layersManager.payload.floatingObject.collapseToggle()
+
+                let menu = timelineChart.layersManager.payload.uiObject.menu
+                menu.internalClick('Add All Mine Layers')
+                menu.internalClick('Add All Mine Layers')
+
+                switch (k) {
+                    case 0: {
+                        timelineChart.name = 'Trading Engine'
+                        deleteNodeByName('Trading System')
+                        deleteNodeByName('Objects')
+                        break
+                    }
+                    case 1: {
+                        timelineChart.name = 'Trading System'
+                        deleteNodeByName('Trading Engine')
+                        deleteNodeByName('Objects')
+                        break
+                    }
+                    case 2: {
+                        timelineChart.name = 'Objects'
+                        deleteNodeByName('Trading Engine')
+                        deleteNodeByName('Trading System')
+                        break
+                    }
+                }
+                function deleteNodeByName(nodeName) {
+                    let nodeToDelete = findNodeInNodeMesh(timelineChart.layersManager, undefined, nodeName, true, true, false, false)
+                    if (nodeToDelete === undefined) { return }
+                    functionLibraryNodeDeleter.deleteUIObject(nodeToDelete, rootNodes)
+                }
+            }
+        }
+    }
+
+    function addMissingDashboards(node, rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter) {
+        for (let i = 0; i < rootNodes.length; i++) {
+            let rootNode = rootNodes[i]
+            if (rootNode.type === 'Network') {
+                let network = rootNode
+                scanNetwork(network)
+            }
+        }
+
+        function scanNetwork(network) {
+            if (network === undefined) { return }
+
+            for (let j = 0; j < network.networkNodes.length; j++) {
+                let networkNode = network.networkNodes[j]
+                scanNetworkNode(networkNode)
+            }
+
+            function scanNetworkNode(networkNode) {
+                let testingEnvironment = findInBranch(networkNode, 'Testing Environment', node, true)
+                let productionEnvironment = findInBranch(networkNode, 'Production Environment', node, true)
+
+                if (isMissingChildren(node, testingEnvironment, true) === true) {
+                    let dashboard = functionLibraryUiObjectsFromNodes.addUIObject(node, 'Dashboard')
+                    dashboard.payload.referenceParent = testingEnvironment
+                    dashboard.name = testingEnvironment.type + ' ' + networkNode.name
+                }
+
+                if (isMissingChildren(node, productionEnvironment, true) === true) {
+                    let dashboard = functionLibraryUiObjectsFromNodes.addUIObject(node, 'Dashboard')
+                    dashboard.payload.referenceParent = productionEnvironment
+                    dashboard.name = productionEnvironment.type + ' ' + networkNode.name
+                }
+            }
+        }
+    }
 }
diff --git a/CanvasApp/DesignSpace/Workspace/FunctionLibraries/CryptoEcosystemFunctions.js b/CanvasApp/DesignSpace/Workspace/FunctionLibraries/CryptoEcosystemFunctions.js
index cebf36007..544347a5e 100644
--- a/CanvasApp/DesignSpace/Workspace/FunctionLibraries/CryptoEcosystemFunctions.js
+++ b/CanvasApp/DesignSpace/Workspace/FunctionLibraries/CryptoEcosystemFunctions.js
@@ -206,7 +206,7 @@ function newCryptoEcosystemFunctions() {
         }
     }
 
-    function installMarket(node, rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter) {
+    function installMarket(node, rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter, functionLibraryChartingSpaceFunctions, functionLibraryDataStorageFunctions) {
 
         let market = node
         let cryptoExchange = findNodeInNodeMesh(node, 'Crypto Exchange', undefined, true, false, true, false)
@@ -214,6 +214,7 @@ function newCryptoEcosystemFunctions() {
             node.payload.uiObject.setErrorMessage('Market must be a descendant of a Crypto Exchange')
             return
         }
+        let dashboardsArray = []
 
         for (let i = 0; i < rootNodes.length; i++) {
             let rootNode = rootNodes[i]
@@ -222,73 +223,179 @@ function newCryptoEcosystemFunctions() {
             }
         }
 
-        function installInNetwork(network) {
-            /*
-            Here we complete the missing stuff at Data Mining
-            */
-            let dataMining = findInBranch(network, 'Data Mining', node, true)
-            if (dataMining === undefined) { return }
-
-            let exchangeDataTasks = findOrCreateChildWithReference(dataMining, 'Exchange Data Tasks', cryptoExchange, functionLibraryUiObjectsFromNodes)
-            exchangeDataTasks.payload.floatingObject.angleToParent = ANGLE_TO_PARENT.RANGE_180
-            let marketDataTask = findAndRecreateChildWithReference(exchangeDataTasks, 'Market Data Tasks', market, rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter)
-
-            menuClick(marketDataTask, 'Add Missing Data Mine Tasks', true)
-            menuClickOfNodeArray(marketDataTask.dataMineTasks, 'Add All Tasks', true)
-            /*
-            Next we complete the missing stuff at Testing Environment
-            */
-            installEnvironment('Testing Environment')
-            /*
-            Next we complete the missing stuff at Production Environment
-            */
-            installEnvironment('Production Environment')
-
-            function installEnvironment(environment) {
-                let tradingMining = findInBranch(network, environment, node, true)
-                if (tradingMining === undefined) { return }
-
-                let exchangeTradingTasks = findOrCreateChildWithReference(tradingMining, 'Exchange Trading Tasks', cryptoExchange, functionLibraryUiObjectsFromNodes)
-                exchangeTradingTasks.payload.floatingObject.angleToParent = ANGLE_TO_PARENT.RANGE_180
-                let marketTradingTask = findAndRecreateChildWithReference(exchangeTradingTasks, 'Market Trading Tasks', market, rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter)
-
-                menuClick(marketTradingTask, 'Add Missing Trading Mine Tasks', true)
-                menuClickOfNodeArray(marketTradingTask.tradingMineTasks, 'Add All Tasks', true)
+        for (let i = 0; i < rootNodes.length; i++) {
+            let rootNode = rootNodes[i]
+            if (rootNode.type === 'Charting Space') {
+                installInChartingSpace(rootNode)
             }
-            /*
-            Here we complete the missing stuff at Session Independent Data
-            */
-            let sessionIndependentData = findInBranch(network, 'Session Independent Data', node, true)
-            if (sessionIndependentData === undefined) { return }
+        }
 
-            let exchangeDataProducts = findOrCreateChildWithReference(sessionIndependentData, 'Exchange Data Products', cryptoExchange, functionLibraryUiObjectsFromNodes)
-            exchangeDataProducts.payload.floatingObject.angleToParent = ANGLE_TO_PARENT.RANGE_180
-            let singleMarketData = findAndRecreateChildWithReference(exchangeDataProducts, 'Single Market Data', market, rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter)
-            singleMarketData.payload.floatingObject.collapseToggle()
+        function installInNetwork(network) {
 
-            menuClick(singleMarketData, 'Add All Data Mine Products', true)
-            menuClickOfNodeArray(singleMarketData.dataMineProducts, 'Add All Data Products', true)
-            /*
-            Finally we complete the missing stuff at Session Based Data
-            */
-            let sessionBasedData = findInBranch(network, 'Session Based Data', node, true)
-            if (sessionBasedData === undefined) { return }
+            for (let j = 0; j < network.networkNodes.length; j++) {
+                let networkNode = network.networkNodes[j]
+                installInNetworkNode(networkNode)
+            }
 
-            let exchangeSessions = findOrCreateChildWithReference(sessionBasedData, 'Exchange Sessions', cryptoExchange, functionLibraryUiObjectsFromNodes)
-            exchangeSessions.payload.floatingObject.angleToParent = ANGLE_TO_PARENT.RANGE_180
+            function installInNetworkNode(networkNode) {
+                /*
+                Here we complete the missing stuff at Data Mining
+                */
+                let dataMining = findInBranch(networkNode, 'Data Mining', node, true)
+                if (dataMining === undefined) {
+                    node.payload.uiObject.setErrorMessage('Data Mining node not found at Network Node ' + networkNode.name)
+                    return
+                }
 
-            menuClick(exchangeSessions, 'Add Missing Session References', true)
+                let exchangeDataTasks = findOrCreateChildWithReference(dataMining, 'Exchange Data Tasks', cryptoExchange, functionLibraryUiObjectsFromNodes)
+                exchangeDataTasks.payload.floatingObject.angleToParent = ANGLE_TO_PARENT.RANGE_180
+                let marketDataTask = findAndRecreateChildWithReference(exchangeDataTasks, 'Market Data Tasks', market, rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter)
 
-            for (let j = 0; j < exchangeSessions.sessionReferences.length; j++) {
-                sessionReference = exchangeSessions.sessionReferences[j]
-                menuClick(sessionReference.singleMarketTradingData, 'Add All Trading Mine Products', true)
-                menuClickOfNodeArray(sessionReference.singleMarketTradingData.tradingMineProducts, 'Add All Data Products', true)
-                sessionReference.singleMarketTradingData.payload.floatingObject.collapseToggle()
+                menuClick(marketDataTask, 'Add Missing Data Mine Tasks', true)
+                menuClickOfNodeArray(marketDataTask.dataMineTasks, 'Add All Tasks', true)
+
+                let sessionsCreatedArray = []
+                /*
+                Next we complete the missing stuff at Testing Environment
+                */
+                installEnvironment('Testing Environment')
+                /*
+                Next we complete the missing stuff at Production Environment
+                */
+                installEnvironment('Production Environment')
+
+                function installEnvironment(environment) {
+                    /*
+                    Now we install the environmnet at the current Network Node
+                    */
+                    let environmentFound = findInBranch(networkNode, environment, node, true)
+                    if (environmentFound === undefined) {
+                        node.payload.uiObject.setErrorMessage(environment + ' node not found at Network Node ' + networkNode.name)
+                        return
+                    }
+
+                    let exchangeTradingTasks = findOrCreateChildWithReference(environmentFound, 'Exchange Trading Tasks', cryptoExchange, functionLibraryUiObjectsFromNodes)
+                    exchangeTradingTasks.payload.floatingObject.angleToParent = ANGLE_TO_PARENT.RANGE_180
+                    let marketTradingTask = findAndRecreateChildWithReference(exchangeTradingTasks, 'Market Trading Tasks', market, rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter)
+
+                    menuClick(marketTradingTask, 'Add Missing Trading Mine Tasks', true)
+                    menuClickOfNodeArray(marketTradingTask.tradingMineTasks, 'Add All Tasks', true)
+
+                    /* This will be needed at the charging space, for creating Dashboards */
+                    let backtestingSessionsArray = nodeBranchToArray(marketTradingTask, 'Backtesting Session')
+                    let liveTradingSessionsArray = nodeBranchToArray(marketTradingTask, 'Live Trading Session')
+                    let allSessionsArray = backtestingSessionsArray.concat(liveTradingSessionsArray)
+                    sessionsCreatedArray = sessionsCreatedArray.concat(allSessionsArray)
+
+                    dashboardsArray.push({ environmentNode: environmentFound, networkNode: networkNode, sessionsArray: allSessionsArray })
+                }
+                /*
+                Here we complete the missing stuff at Session Independent Data
+                */
+                let sessionIndependentData = findInBranch(networkNode, 'Session Independent Data', node, true)
+                if (sessionIndependentData === undefined) {
+                    node.payload.uiObject.setErrorMessage('Session Independent Data node not found at Network Node ' + networkNode.name)
+                    return
+                }
+
+                let exchangeDataProducts = findOrCreateChildWithReference(sessionIndependentData, 'Exchange Data Products', cryptoExchange, functionLibraryUiObjectsFromNodes)
+                exchangeDataProducts.payload.floatingObject.angleToParent = ANGLE_TO_PARENT.RANGE_180
+                let singleMarketData = findAndRecreateChildWithReference(exchangeDataProducts, 'Single Market Data', market, rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter)
+                singleMarketData.payload.floatingObject.collapseToggle()
+
+                menuClick(singleMarketData, 'Add All Data Mine Products', true)
+                menuClickOfNodeArray(singleMarketData.dataMineProducts, 'Add All Data Products', true)
+                /*
+                Finally we complete the missing stuff at Session Based Data
+                */
+                let sessionBasedData = findInBranch(networkNode, 'Session Based Data', node, true)
+                if (sessionBasedData === undefined) {
+                    node.payload.uiObject.setErrorMessage('Session Based Data node not found at Network Node ' + networkNode.name)
+                    return
+                }
+
+                let exchangeSessions = findOrCreateChildWithReference(sessionBasedData, 'Exchange Sessions', cryptoExchange, functionLibraryUiObjectsFromNodes)
+                exchangeSessions.payload.floatingObject.angleToParent = ANGLE_TO_PARENT.RANGE_180
+                /*
+                We need to delete all the session references related to the market we are installing.
+                We make a copy of the array so that if we need to delete some nodes it does not 
+                affect the loop evaluating the nodes.
+                */
+                let sessionReferencesArray = []
+                for (let i = 0; i < exchangeSessions.sessionReferences.length; i++) {
+                    sessionReference = exchangeSessions.sessionReferences[i]
+                    sessionReferencesArray.push(sessionReference)
+                }
+                for (let i = 0; i < sessionReferencesArray.length; i++) {
+                    sessionReference = sessionReferencesArray[i]
+                    if (sessionReference.singleMarketTradingData === undefined) { continue }
+                    if (sessionReference.singleMarketTradingData.payload.referenceParent === undefined) { continue }
+                    if (sessionReference.singleMarketTradingData.payload.referenceParent.id === node.id) {
+                        functionLibraryNodeDeleter.deleteUIObject(sessionReference, rootNodes)
+                    }
+                }
+                /*
+                Create the new session references.
+                */
+                for (let i = 0; i < sessionsCreatedArray.length; i++) {
+                    let session = sessionsCreatedArray[i]
+                    if (isMissingChildren(exchangeSessions, session, true) === true) {
+                        functionLibraryDataStorageFunctions.createSessionReference(exchangeSessions, session, functionLibraryUiObjectsFromNodes)
+                    }
+                }
+                /*
+                Create everything inside the session references.
+                */
+                for (let j = 0; j < exchangeSessions.sessionReferences.length; j++) {
+                    sessionReference = exchangeSessions.sessionReferences[j]
+                    menuClick(sessionReference.singleMarketTradingData, 'Add All Trading Mine Products', true)
+                    menuClickOfNodeArray(sessionReference.singleMarketTradingData.tradingMineProducts, 'Add All Data Products', true)
+                    sessionReference.singleMarketTradingData.payload.floatingObject.collapseToggle()
+                }
+            }
+        }
+
+        function installInChartingSpace(chartingSpace) {
+
+            for (let i = 0; i < dashboardsArray.length; i++) {
+                /*
+                If the Dashboard we need is not already there we create a new one. 
+                */
+                let arrayItem = dashboardsArray[i]
+                let dashboard = findOrCreateChildWithReference(chartingSpace, 'Dashboard', arrayItem.environmentNode, functionLibraryUiObjectsFromNodes)
+                dashboard.name = arrayItem.environmentNode.type + ' ' + arrayItem.networkNode.name
+                /*
+                We delete all the existing Time Machines related to the market we are currently installing. 
+                For that, we make a new array with the existing Time Machines so that the deleting
+                of each node does not affect the proccessing of the whole set.
+                */
+                let timeMachines = []
+                for (let i = 0; i < dashboard.timeMachines.length; i++) {
+                    let timeMachine = dashboard.timeMachines[i]
+                    timeMachines.push(timeMachine)
+                }
+                for (let i = 0; i < timeMachines.length; i++) {
+                    let timeMachine = timeMachines[i]
+                    let session = timeMachine.payload.referenceParent
+                    if (session === undefined) {continue}
+                    let marketTradingTasks = findNodeInNodeMesh(session, 'Market Trading Tasks', undefined, true, false, true, false)
+                    if (marketTradingTasks.payload.referenceParent === undefined) {continue}
+                    if (marketTradingTasks.payload.referenceParent.id === market.id) {
+                        functionLibraryNodeDeleter.deleteUIObject(timeMachine, rootNodes)
+                    }
+                }
+                /*
+                We create a time machine for each session added during the previous processing. 
+                */
+                for (let j = 0; j < arrayItem.sessionsArray.length; j++) {
+                    let session = arrayItem.sessionsArray[j]
+                    functionLibraryChartingSpaceFunctions.createTimeMachine(dashboard, session, node, arrayItem.networkNode, rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter)
+                }
             }
         }
     }
 
-    function uninstallMarket(node, rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter) {
+    function uninstallMarket(node, rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter, functionLibraryChartingSpaceFunctions, functionLibraryDataStorageFunctions) {
 
     }
 }
diff --git a/CanvasApp/DesignSpace/Workspace/FunctionLibraries/DataStorageFunctions.js b/CanvasApp/DesignSpace/Workspace/FunctionLibraries/DataStorageFunctions.js
index b3ca80693..6b2ca9502 100644
--- a/CanvasApp/DesignSpace/Workspace/FunctionLibraries/DataStorageFunctions.js
+++ b/CanvasApp/DesignSpace/Workspace/FunctionLibraries/DataStorageFunctions.js
@@ -6,7 +6,8 @@ function newDataStorageFunctions() {
         addMissingSessionReferences: addMissingSessionReferences,
         addMissingSingleMarketData: addMissingSingleMarketData,
         addMissingExchangeSessions: addMissingExchangeSessions,
-        addMissingExchangeDataProducts: addMissingExchangeDataProducts
+        addMissingExchangeDataProducts: addMissingExchangeDataProducts, 
+        createSessionReference: createSessionReference
     }
 
     return thisObject
@@ -100,20 +101,24 @@ function newDataStorageFunctions() {
             for (let i = 0; i < sessionsArray.length; i++) {
                 let session = sessionsArray[i]
                 if (isMissingChildren(node, session, true) === true) {
-                    let sessionReference = functionLibraryUiObjectsFromNodes.addUIObject(node, 'Session Reference')
-                    sessionReference.payload.referenceParent = session 
-                    /*
-                    Now I will connect the Session Reference child that is auto created with the market 
-                    where the Session was found.
-                    */
-                    let marketTradingTasks = findNodeInNodeMesh(session, 'Market Trading Tasks', undefined, true, false, true, false)
-                    sessionReference.singleMarketTradingData.payload.referenceParent = marketTradingTasks.payload.referenceParent
-                    marketTradingTasks.payload.floatingObject.collapseToggle()
+                    createSessionReference(node, session, functionLibraryUiObjectsFromNodes)
                 }
             }
         }
     }
 
+    function createSessionReference(node, session, functionLibraryUiObjectsFromNodes) {
+        let sessionReference = functionLibraryUiObjectsFromNodes.addUIObject(node, 'Session Reference')
+        sessionReference.payload.referenceParent = session
+        /*
+        Now I will connect the Session Reference child that is auto created with the market 
+        where the Session was found.
+        */
+        let marketTradingTasks = findNodeInNodeMesh(session, 'Market Trading Tasks', undefined, true, false, true, false)
+        sessionReference.singleMarketTradingData.payload.referenceParent = marketTradingTasks.payload.referenceParent
+        marketTradingTasks.payload.floatingObject.collapseToggle()
+    }
+
     function addMissingSingleMarketData(node, rootNodes, functionLibraryUiObjectsFromNodes) {
         if (node.payload.referenceParent === undefined) { return }
         if (node.payload.referenceParent.exchangeMarkets === undefined) { return }
diff --git a/CanvasApp/DesignSpace/Workspace/Workspace.js b/CanvasApp/DesignSpace/Workspace/Workspace.js
index 991d43d68..1c8ed2df4 100644
--- a/CanvasApp/DesignSpace/Workspace/Workspace.js
+++ b/CanvasApp/DesignSpace/Workspace/Workspace.js
@@ -702,12 +702,12 @@ function newWorkspace() {
                 break
             case 'Install Market':
                 {
-                    functionLibraryCryptoEcosystemFunctions.installMarket(payload.node, thisObject.workspaceNode.rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter)
+                    functionLibraryCryptoEcosystemFunctions.installMarket(payload.node, thisObject.workspaceNode.rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter, functionLibraryChartingSpaceFunctions, functionLibraryDataStorageFunctions)
                 }
                 break
             case 'Uninstall Market':
                 {
-                    functionLibraryCryptoEcosystemFunctions.uninstallMarket(payload.node, thisObject.workspaceNode.rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter)
+                    functionLibraryCryptoEcosystemFunctions.uninstallMarket(payload.node, thisObject.workspaceNode.rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter, functionLibraryChartingSpaceFunctions, functionLibraryDataStorageFunctions)
                 }
                 break
             case 'Add All Output Datasets':
@@ -770,6 +770,11 @@ function newWorkspace() {
                     functionLibraryChartingSpaceFunctions.addMissingTimeMachines(payload.node, thisObject.workspaceNode.rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter)
                 }
                 break
+            case 'Add Missing Dashboards':
+                {
+                    functionLibraryChartingSpaceFunctions.addMissingDashboards(payload.node, thisObject.workspaceNode.rootNodes, functionLibraryUiObjectsFromNodes, functionLibraryNodeDeleter)
+                }
+                break
             case 'Play Tutorial':
                 {
                     canvas.tutorialSpace.playTutorial(payload.node)
diff --git a/CanvasApp/FloatingSpace/FloatingObject.js b/CanvasApp/FloatingSpace/FloatingObject.js
index 76901b340..c3da76f1c 100644
--- a/CanvasApp/FloatingSpace/FloatingObject.js
+++ b/CanvasApp/FloatingSpace/FloatingObject.js
@@ -274,6 +274,9 @@ function newFloatingObject() {
     }
 
     function invisiblePhysics() {
+        if (thisObject.payload === undefined) {return}
+        if (thisObject.payload.uiObject === undefined) {return}
+            
         if (thisObject.payload.uiObject !== undefined) {
             thisObject.payload.uiObject.invisiblePhysics()
         }
@@ -589,6 +592,9 @@ function newFloatingObject() {
     }
 
     function drawBackground() {
+        if (thisObject.payload === undefined) {return}
+        if (thisObject.payload.uiObject === undefined) {return}
+
         if (canvas.floatingSpace.isItFar(thisObject.payload) && thisObject.payload.uiObject.isShowing === false) { return }
         if ((thisObject.isCollapsed === true && thisObject.collapsedManually === false) || thisObject.isParentCollapsed === true) {
             if (thisObject.payload.uiObject.isShowing !== true) {
@@ -599,6 +605,9 @@ function newFloatingObject() {
     }
 
     function drawMiddleground() {
+        if (thisObject.payload === undefined) {return}
+        if (thisObject.payload.uiObject === undefined) {return}
+
         if (canvas.floatingSpace.isItFar(thisObject.payload) && thisObject.payload.uiObject.isShowing === false) { return }
         if ((thisObject.isCollapsed === true && thisObject.collapsedManually === false) || thisObject.isParentCollapsed === true) {
             if (thisObject.payload.uiObject.isShowing !== true) {
@@ -609,6 +618,9 @@ function newFloatingObject() {
     }
 
     function drawForeground() {
+        if (thisObject.payload === undefined) {return}
+        if (thisObject.payload.uiObject === undefined) {return}
+
         if (canvas.floatingSpace.isItFar(thisObject.payload) && thisObject.payload.uiObject.isShowing === false) { return }
         if ((thisObject.isCollapsed === true && thisObject.collapsedManually === false) || thisObject.isParentCollapsed === true) {
             if (thisObject.payload.uiObject.isShowing !== true) {
@@ -619,6 +631,9 @@ function newFloatingObject() {
     }
 
     function drawOnFocus() {
+        if (thisObject.payload === undefined) {return}
+        if (thisObject.payload.uiObject === undefined) {return}
+
         thisObject.payload.uiObject.drawOnFocus()
     }