diff --git a/modules/globebrowsing/chunk/chunkrenderer.cpp b/modules/globebrowsing/chunk/chunkrenderer.cpp
index d29b0958b2..68431ec29e 100644
--- a/modules/globebrowsing/chunk/chunkrenderer.cpp
+++ b/modules/globebrowsing/chunk/chunkrenderer.cpp
@@ -97,13 +97,14 @@ namespace globebrowsing {
     }
 
     void ChunkRenderer::setDepthTransformUniforms(
+        ProgramObject* programObject,
         std::shared_ptr<LayeredTextureShaderUniformIdHandler> uniformIdHandler,
         LayeredTextures::TextureCategory textureCategory,
         LayeredTextures::BlendLayerSuffixes blendLayerSuffix,
         size_t layerIndex,
         const TileDepthTransform& tileDepthTransform)
     {   
-        uniformIdHandler->programObject().setUniform(
+        programObject->setUniform(
             uniformIdHandler->getId(
                 textureCategory,
                 blendLayerSuffix,
@@ -111,7 +112,7 @@ namespace globebrowsing {
                 LayeredTextures::GlslTileDataId::depthTransform_depthScale),
             tileDepthTransform.depthScale);
 
-        uniformIdHandler->programObject().setUniform(
+        programObject->setUniform(
             uniformIdHandler->getId(
                 textureCategory,
                 blendLayerSuffix,
@@ -122,6 +123,7 @@ namespace globebrowsing {
     }
 
     void ChunkRenderer::activateTileAndSetTileUniforms(
+        ProgramObject* programObject,
         std::shared_ptr<LayeredTextureShaderUniformIdHandler> uniformIdHandler,
         LayeredTextures::TextureCategory textureCategory,
         LayeredTextures::BlendLayerSuffixes blendLayerSuffix,
@@ -134,21 +136,21 @@ namespace globebrowsing {
         texUnit.activate();
         chunkTile.tile.texture->bind();
 
-        uniformIdHandler->programObject().setUniform(
+        programObject->setUniform(
             uniformIdHandler->getId(
                 textureCategory,
                 blendLayerSuffix,
                 layerIndex,
                 LayeredTextures::GlslTileDataId::textureSampler),
             texUnit);
-        uniformIdHandler->programObject().setUniform(
+        programObject->setUniform(
             uniformIdHandler->getId(
                 textureCategory,
                 blendLayerSuffix,
                 layerIndex,
                 LayeredTextures::GlslTileDataId::uvTransform_uvScale),
             chunkTile.uvTransform.uvScale);
-        uniformIdHandler->programObject().setUniform(
+        programObject->setUniform(
             uniformIdHandler->getId(
                 textureCategory,
                 blendLayerSuffix,
@@ -158,6 +160,7 @@ namespace globebrowsing {
     }
 
     void ChunkRenderer::setLayerSettingsUniforms(
+        ProgramObject* programObject,
         std::shared_ptr<LayeredTextureShaderUniformIdHandler> uniformIdHandler,
         LayeredTextures::TextureCategory textureCategory,
         size_t layerIndex,
@@ -165,7 +168,7 @@ namespace globebrowsing {
         
         for (int i = 0; i < settings.array().size(); i++) {
             settings.array()[i]->uploadUniform(
-                uniformIdHandler->programObject(),
+                *programObject,
                 uniformIdHandler->getSettingsId(
                     textureCategory,
                     layerIndex,
@@ -229,7 +232,11 @@ namespace globebrowsing {
             layeredTextureShaderProvider->getUpdatedShaderProgram(
                 layeredTexturePreprocessingData);
         
-        programUniformHandler->updateIdsIfNecessary(layeredTextureShaderProvider);
+        if (layeredTextureShaderProvider->updatedOnLastCall()) {
+            // Need to update uniforms            
+            programUniformHandler->updateIdsIfNecessary(layeredTextureShaderProvider, _layerManager.get());
+        }
+        
 
         // Activate the shader program
         programObject->activate();
@@ -248,54 +255,18 @@ namespace globebrowsing {
 
         // Go through all the categories
         for (size_t category = 0; category < LayeredTextures::NUM_TEXTURE_CATEGORIES; category++) {
-            // Go through all the providers in this category
+            LayerGroup& layerGroup = _layerManager->layerGroup(category);
             int i = 0;
-            for (const Layer& layer : _layerManager->layerGroup(category).activeLayers()) {
+            for (const Layer& layer : layerGroup.activeLayers()) {
                 TileProvider* tileProvider = layer.tileProvider.get();
-                // Get the texture that should be used for rendering
-                ChunkTile chunkTile = TileSelector::getHighestResolutionTile(tileProvider, tileIndex);
-                if (chunkTile.tile.status == Tile::Status::Unavailable) {
-                    chunkTile.tile = tileProvider->getDefaultTile();
-                    chunkTile.uvTransform.uvOffset = { 0, 0 };
-                    chunkTile.uvTransform.uvScale = { 1, 1 };
-                }
-
-                activateTileAndSetTileUniforms(
-                    programUniformHandler,
-                    LayeredTextures::TextureCategory(category),
-                    LayeredTextures::BlendLayerSuffixes::none,
-                    i,
-                    texUnits[category][i].blendTexture0,
-                    chunkTile);
-
-                // If blending is enabled, two more textures are needed
-                if (layeredTexturePreprocessingData.layeredTextureInfo[category].layerBlendingEnabled) {
-                    ChunkTile chunkTileParent1 = TileSelector::getHighestResolutionTile(tileProvider, tileIndex, 1);
-                    if (chunkTileParent1.tile.status == Tile::Status::Unavailable) {
-                        chunkTileParent1 = chunkTile;
-                    }
-                    activateTileAndSetTileUniforms(
-                        programUniformHandler,
-                        LayeredTextures::TextureCategory(category),
-                        LayeredTextures::BlendLayerSuffixes::Parent1,
-                        i,
-                        texUnits[category][i].blendTexture1,
-                        chunkTileParent1);
-
-                    ChunkTile chunkTileParent2 = TileSelector::getHighestResolutionTile(tileProvider, tileIndex, 2);
-                    if (chunkTileParent2.tile.status == Tile::Status::Unavailable) {
-                        chunkTileParent2 = chunkTileParent1;
-                    }
-                    activateTileAndSetTileUniforms(
-                        programUniformHandler,
-                        LayeredTextures::TextureCategory(category),
-                        LayeredTextures::BlendLayerSuffixes::Parent2,
-                        i,
-                        texUnits[category][i].blendTexture2,
-                        chunkTileParent2);
-                }
+                
+                int pileSize = layeredTexturePreprocessingData.layeredTextureInfo[category].layerBlendingEnabled ? 3 : 1;
+                
+                ChunkTilePile chunkTilePile = TileSelector::getHighestResolutionTilePile(tileProvider, tileIndex, pileSize);
+                programUniformHandler->_gpuLayerGroups[category].gpuActiveLayers[i].setValue(programObject, chunkTilePile);
                 
                 setLayerSettingsUniforms(
+                    programObject,
                     programUniformHandler,
                     LayeredTextures::TextureCategory(category),
                     i,
@@ -321,6 +292,7 @@ namespace globebrowsing {
         for (const Layer& heightLayer : heightLayers) {
             TileDepthTransform depthTransform = heightLayer.tileProvider->depthTransform();
             setDepthTransformUniforms(
+                programObject,
                 programUniformHandler,
                 LayeredTextures::TextureCategory::HeightMaps,
                 LayeredTextures::BlendLayerSuffixes::none,
@@ -409,11 +381,19 @@ namespace globebrowsing {
         glEnable(GL_CULL_FACE);
         glCullFace(GL_BACK);
         
-        TileIndex ti(2,2,2);
-        TileProvider* tp = _layerManager->layerGroup(0).activeLayers()[0].tileProvider.get();
-        ChunkTilePile tilePile = TileSelector::getHighestResolutionTilePile(tp, ti);
-        _globalRenderingShaderProvider->gpuChunkTilePile.updateUniformLocations(programObject, "test.");
-        _globalRenderingShaderProvider->gpuChunkTilePile.setValue(programObject, tilePile);
+        /*
+        TileIndex ti(5,5,5);
+        const auto& layers = _layerManager->layerGroup(0).activeLayers();
+        if(layers.size() > 0){
+            TileProvider* tp = layers[0].tileProvider.get();
+            int pileSize = _layerManager->layerGroup(0).levelBlendingEnabled ? 3 : 1;
+            ChunkTilePile tilePile = TileSelector::getHighestResolutionTilePile(tp, ti, pileSize);
+            auto& gpuChunkTilePile = _globalRenderingShaderProvider->gpuChunkTilePile;
+            gpuChunkTilePile.updateUniformLocations(programObject, "test.", pileSize);
+            gpuChunkTilePile.setValue(programObject, tilePile);
+        }
+         */
+        
 
         // render
         _grid->geometry().drawUsingActiveProgram();
diff --git a/modules/globebrowsing/chunk/chunkrenderer.h b/modules/globebrowsing/chunk/chunkrenderer.h
index ff7daa8118..6522386df0 100644
--- a/modules/globebrowsing/chunk/chunkrenderer.h
+++ b/modules/globebrowsing/chunk/chunkrenderer.h
@@ -90,6 +90,7 @@ namespace globebrowsing {
         void renderChunkLocally(const Chunk& chunk, const RenderData& data);
 
         void setDepthTransformUniforms(
+            ProgramObject* programObject,
             std::shared_ptr<LayeredTextureShaderUniformIdHandler> uniformIdHandler,
             LayeredTextures::TextureCategory textureCategory,
             LayeredTextures::BlendLayerSuffixes blendLayerSuffix,
@@ -97,6 +98,7 @@ namespace globebrowsing {
             const TileDepthTransform& tileDepthTransform);
 
         void activateTileAndSetTileUniforms(
+            ProgramObject* programObject,
             std::shared_ptr<LayeredTextureShaderUniformIdHandler> uniformIdHandler,
             LayeredTextures::TextureCategory textureCategory,
             LayeredTextures::BlendLayerSuffixes blendLayerSuffix,
@@ -105,6 +107,7 @@ namespace globebrowsing {
             const ChunkTile& chunkTile);
         
         void setLayerSettingsUniforms(
+            ProgramObject* programObject,
             std::shared_ptr<LayeredTextureShaderUniformIdHandler> uniformIdHandler,
             LayeredTextures::TextureCategory textureCategory,
             size_t layerIndex,
diff --git a/modules/globebrowsing/globes/renderableglobe.cpp b/modules/globebrowsing/globes/renderableglobe.cpp
index d71f818b23..fe080dfa3c 100644
--- a/modules/globebrowsing/globes/renderableglobe.cpp
+++ b/modules/globebrowsing/globes/renderableglobe.cpp
@@ -95,6 +95,7 @@ namespace globebrowsing {
             for (auto setting : layer.settings.array()) {
                 prop.addProperty(setting->property());
             }
+            
   
             addPropertySubOwner(prop);
         }
diff --git a/modules/globebrowsing/layered_rendering/layeredtextures.cpp b/modules/globebrowsing/layered_rendering/layeredtextures.cpp
index a0fc531fcb..a440f5515b 100644
--- a/modules/globebrowsing/layered_rendering/layeredtextures.cpp
+++ b/modules/globebrowsing/layered_rendering/layeredtextures.cpp
@@ -85,22 +85,19 @@ namespace globebrowsing {
     PerLayerSettings::PerLayerSettings()
     {
         // Here, all the per layer settings are specified and added
-        _array[LayeredTextures::LayerSettingsIds::opacity] =
-            std::make_shared<PerLayerFloatSetting>(
+        _array[LayeredTextures::LayerSettingsIds::opacity] = std::make_shared<PerLayerFloatSetting>(
             LayeredTextures::layerSettingsIds[LayeredTextures::LayerSettingsIds::opacity],
             LayeredTextures::layerSettingsIds[LayeredTextures::LayerSettingsIds::opacity],
             1,
             0,
             1);
-        _array[LayeredTextures::LayerSettingsIds::gamma] =
-            std::make_shared<PerLayerFloatSetting>(
+        _array[LayeredTextures::LayerSettingsIds::gamma] = std::make_shared<PerLayerFloatSetting>(
             LayeredTextures::layerSettingsIds[LayeredTextures::LayerSettingsIds::gamma],
             LayeredTextures::layerSettingsIds[LayeredTextures::LayerSettingsIds::gamma],
             1,
             0,
             5);
-        _array[LayeredTextures::LayerSettingsIds::multiplier] =
-            std::make_shared<PerLayerFloatSetting>(
+        _array[LayeredTextures::LayerSettingsIds::multiplier] = std::make_shared<PerLayerFloatSetting>(
             LayeredTextures::layerSettingsIds[LayeredTextures::LayerSettingsIds::multiplier],
             LayeredTextures::layerSettingsIds[LayeredTextures::LayerSettingsIds::multiplier],
             1,
@@ -119,7 +116,7 @@ namespace globebrowsing {
     const std::array<std::shared_ptr<PerLayerSetting>,
         LayeredTextures::NUM_LAYER_SETTINGS_VARIABLES>& PerLayerSettings::array() const {
             return _array;
-    }
+        }
 
-} // namespace globebrowsing
-} // namespace openspace
+}  // namespace globebrowsing
+}  // namespace openspace
diff --git a/modules/globebrowsing/layered_rendering/layeredtextureshaderprovider.cpp b/modules/globebrowsing/layered_rendering/layeredtextureshaderprovider.cpp
index 74013aa815..932b10776d 100644
--- a/modules/globebrowsing/layered_rendering/layeredtextureshaderprovider.cpp
+++ b/modules/globebrowsing/layered_rendering/layeredtextureshaderprovider.cpp
@@ -161,33 +161,24 @@ namespace globebrowsing {
     {}
 
     void LayeredTextureShaderUniformIdHandler::updateIdsIfNecessary(
-        LayeredTextureShaderProvider* shaderProvider)
-    {
-        if (shaderProvider->updatedOnLastCall())
-        {
-            _shaderProvider = shaderProvider;
-            // Ignore errors since this loops through even uniforms that does not exist.
-            _shaderProvider->_programObject->setIgnoreUniformLocationError(
-                ProgramObject::IgnoreError::Yes);
-            for (size_t i = 0; i < LayeredTextures::NUM_TEXTURE_CATEGORIES; i++)
-            {
-                for (size_t j = 0; j < LayeredTextures::NUM_BLEND_TEXTURES; j++)
-                {
-                    for (size_t k = 0; k < LayeredTextures::MAX_NUM_TEXTURES_PER_CATEGORY;
-                        k++)
-                    {
-                        for (size_t l = 0; l < LayeredTextures::NUM_TILE_DATA_VARIABLES; l++)
-                        {
-                            _tileUniformIds[i][j][k][l] =
-                                _shaderProvider->_programObject->uniformLocation(
-                                    LayeredTextures::TEXTURE_CATEGORY_NAMES[i] +
-                                    LayeredTextures::blendLayerSuffixes[j] +
-                                    "[" + std::to_string(k) + "]." +
-                                    LayeredTextures::glslTileDataNames[l]);
-                        }
-                    }
-                }
+        LayeredTextureShaderProvider* shaderProvider, LayerManager* layerManager) {
+        
+        if (shaderProvider->updatedOnLastCall()) {
+            ProgramObject* programObject = shaderProvider->_programObject.get();
+            
+            
+            programObject->setIgnoreUniformLocationError(ProgramObject::IgnoreError::No);
+            
+            for (size_t category = 0; category < LayeredTextures::NUM_TEXTURE_CATEGORIES; category++) {
+                LayerGroup& layerGroup = layerManager->layerGroup(category);
+                std::string nameBase = LayeredTextures::TEXTURE_CATEGORY_NAMES[category];
+                int pileSize = layerGroup.levelBlendingEnabled ? 3 : 1;
+                int numActiveLayers = layerGroup.activeLayers().size();
+                _gpuLayerGroups[category].updateUniformLocations(programObject, nameBase, pileSize, numActiveLayers);
             }
+            
+            // Ignore errors since this loops through even uniforms that does not exist.
+            programObject->setIgnoreUniformLocationError(ProgramObject::IgnoreError::Yes);
             for (size_t i = 0; i < LayeredTextures::NUM_TEXTURE_CATEGORIES; i++)
             {
                 for (size_t k = 0; k < LayeredTextures::MAX_NUM_TEXTURES_PER_CATEGORY;
@@ -196,7 +187,7 @@ namespace globebrowsing {
                     for (size_t l = 0; l < LayeredTextures::NUM_LAYER_SETTINGS_VARIABLES; l++)
                     {
                         _layerSettingsUniformIds[i][k][l] =
-                        _shaderProvider->_programObject->uniformLocation(
+                        programObject->uniformLocation(
                                     LayeredTextures::TEXTURE_CATEGORY_NAMES[i] +
                                     "Settings" +
                                     "[" + std::to_string(k) + "]." +
@@ -205,7 +196,7 @@ namespace globebrowsing {
                 }
             }
             // Reset ignore errors
-            _shaderProvider->_programObject->setIgnoreUniformLocationError(
+            programObject->setIgnoreUniformLocationError(
                 ProgramObject::IgnoreError::No);
         }
     }
@@ -226,11 +217,5 @@ namespace globebrowsing {
     {
         return _layerSettingsUniformIds[category][layerIndex][layerSettingsId];
     }
-    
-    ProgramObject& LayeredTextureShaderUniformIdHandler::programObject()
-    {
-        return *_shaderProvider->_programObject;
-    }
-
 } // namespace globebrowsing
 } // namespace openspace
diff --git a/modules/globebrowsing/layered_rendering/layeredtextureshaderprovider.h b/modules/globebrowsing/layered_rendering/layeredtextureshaderprovider.h
index 0564a82d38..4915050624 100644
--- a/modules/globebrowsing/layered_rendering/layeredtextureshaderprovider.h
+++ b/modules/globebrowsing/layered_rendering/layeredtextureshaderprovider.h
@@ -28,6 +28,7 @@
 #include <modules/globebrowsing/layered_rendering/layeredtextures.h>
 
 #include <modules/globebrowsing/tile/gpustructs.h>
+#include <modules/globebrowsing/tile/layermanager.h>
 
 #include "ghoul/opengl/programobject.h"
 
@@ -98,7 +99,6 @@ namespace globebrowsing {
 
         bool updatedOnLastCall();
         
-        GPUChunkTilePile gpuChunkTilePile;
     private:
         
         
@@ -124,7 +124,7 @@ namespace globebrowsing {
 
         LayeredTextureShaderUniformIdHandler();
         ~LayeredTextureShaderUniformIdHandler();
-        void updateIdsIfNecessary(LayeredTextureShaderProvider* shaderProvider);
+        void updateIdsIfNecessary(LayeredTextureShaderProvider* shaderProvider, LayerManager* layerManager);
 
         /**
         * \param <code>category</code> can be one of the categories specified in
@@ -152,6 +152,8 @@ namespace globebrowsing {
             size_t layerIndex,
             LayeredTextures::LayerSettingsIds layerSettingsId);
         ProgramObject& programObject();
+
+        std::array<GPULayerGroup, LayeredTextures::NUM_TEXTURE_CATEGORIES> _gpuLayerGroups;
     private:
 
         std::array<
@@ -164,6 +166,9 @@ namespace globebrowsing {
             LayeredTextures::NUM_BLEND_TEXTURES>,
             LayeredTextures::NUM_TEXTURE_CATEGORIES>
             _tileUniformIds;
+
+        
+
         
         std::array<
         std::array<
@@ -173,8 +178,6 @@ namespace globebrowsing {
         LayeredTextures::MAX_NUM_TEXTURES_PER_CATEGORY>,
         LayeredTextures::NUM_TEXTURE_CATEGORIES>
         _layerSettingsUniformIds;
-
-        LayeredTextureShaderProvider* _shaderProvider;
     };
 
 } // namespace globebrowsing
diff --git a/modules/globebrowsing/shaders/tile.hglsl b/modules/globebrowsing/shaders/tile.hglsl
index 421daad5d2..93a3b34796 100644
--- a/modules/globebrowsing/shaders/tile.hglsl
+++ b/modules/globebrowsing/shaders/tile.hglsl
@@ -71,12 +71,6 @@ struct Tile {
 	TileUvTransform uvTransform;
 };
 
-struct ChunkTilePile {
-	Tile chunkTile0;
-	Tile chunkTile1;
-	Tile chunkTile2;
-};
-
 vec2 compensateSourceTextureSampling(vec2 startOffset, vec2 sizeDiff, const Tile tile, vec2 tileUV){
 	ivec2 resolution = textureSize(tile.textureSampler, 0);
 
@@ -104,10 +98,10 @@ vec4 getTexVal(const Tile tile, vec2 tileUV){
 /////////////////////////////////////////////////////////////////////
 //                       Multi Level Tile                          //
 /////////////////////////////////////////////////////////////////////
-struct MultiLevelTile {
-	Tile tile0;
-	Tile tile1;
-	Tile tile2;
+struct MultiChunkTile {
+	Tile level0;
+	Tile level1;
+	Tile level2;
 };
 
 struct LevelWeights {
@@ -139,16 +133,10 @@ LevelWeights getDefaultLevelWeights(){
 }
 
 
-vec4 getTexVal(const MultiLevelTile multiLevelTile, const LevelWeights w, const vec2 uv){
-	return w.w1 * getTexVal(multiLevelTile.tile0, uv) + 
-		w.w2 * getTexVal(multiLevelTile.tile1, uv) + 
-		w.w3 * getTexVal(multiLevelTile.tile2, uv);
-}
-
-vec4 getTexVal(const ChunkTilePile chunkTilePine, const LevelWeights w, const vec2 uv){
-	return w.w1 * getTexVal(chunkTilePine.chunkTile0, uv) + 
-		w.w2 * getTexVal(chunkTilePine.chunkTile1, uv) + 
-		w.w3 * getTexVal(chunkTilePine.chunkTile2, uv);
+vec4 getTexVal(const MultiChunkTile multiChunkTile, const LevelWeights w, const vec2 uv){
+	return w.w1 * getTexVal(multiChunkTile.level0, uv) + 
+		w.w2 * getTexVal(multiChunkTile.level1, uv) + 
+		w.w3 * getTexVal(multiChunkTile.level2, uv);
 }
 
 // PerLayerSettings
diff --git a/modules/globebrowsing/shaders/tilefragcolor.hglsl b/modules/globebrowsing/shaders/tilefragcolor.hglsl
index d29ded516c..abe31879aa 100644
--- a/modules/globebrowsing/shaders/tilefragcolor.hglsl
+++ b/modules/globebrowsing/shaders/tilefragcolor.hglsl
@@ -98,7 +98,6 @@ in vec3 positionCameraSpace;
 // The value increases with the distance from the vertex (or fragment) to the camera
 in LevelWeights levelWeights;
 
-uniform ChunkTilePile test;
 
 ///////////////////////////////////////////////////////////////////// 
 
@@ -269,7 +268,6 @@ vec4 getTileFragColor(){
 	#endif
 #endif
 
-	color = 0.1*color + getTexVal(test, levelWeights, fs_uv);
 
 	return color;
 }
diff --git a/modules/globebrowsing/tile/chunktile.h b/modules/globebrowsing/tile/chunktile.h
index 140e7cca37..b259903534 100644
--- a/modules/globebrowsing/tile/chunktile.h
+++ b/modules/globebrowsing/tile/chunktile.h
@@ -46,7 +46,7 @@ namespace globebrowsing {
 
     struct ChunkTilePile {
     	static const size_t SIZE = 3;
-    	std::array<ChunkTile, SIZE> chunkTiles;
+    	std::vector<ChunkTile> chunkTiles;
     };
 
 } // namespace globebrowsing
diff --git a/modules/globebrowsing/tile/gpustructs.cpp b/modules/globebrowsing/tile/gpustructs.cpp
index 88d8bb0ed1..8446008ac0 100644
--- a/modules/globebrowsing/tile/gpustructs.cpp
+++ b/modules/globebrowsing/tile/gpustructs.cpp
@@ -24,10 +24,11 @@
 
 #include <modules/globebrowsing/tile/gpustructs.h>
 
+#include <modules/globebrowsing/tile/tileIndex.h>
 #include <modules/globebrowsing/tile/chunktile.h>
 #include <modules/globebrowsing/tile/tileselector.h>
-#include <modules/globebrowsing/tile/tileselector.h>
 #include <modules/globebrowsing/tile/tileprovider/tileprovider.h>
+#include <modules/globebrowsing/tile/layermanager.h>
 
 #include <modules/globebrowsing/layered_rendering/layeredtextures.h>
 
@@ -89,15 +90,36 @@ namespace globebrowsing {
     // ChunkTilePile
     
     void GPUChunkTilePile::setValue(ProgramObject* programObject, const ChunkTilePile& chunkTilePile){
-        for (size_t i = 0; i < ChunkTilePile::SIZE; ++i){
-            gpuChunkTilePile[i].setValue(programObject, chunkTilePile.chunkTiles[i]);
+        ghoul_assert(gpuChunkTiles.size() == chunkTilePile.chunkTiles.size(), "GPU and CPU ChunkTilePile must have same size!");
+        for (size_t i = 0; i < gpuChunkTiles.size(); ++i){
+            gpuChunkTiles[i].setValue(programObject, chunkTilePile.chunkTiles[i]);
         }
     }
 
-    void GPUChunkTilePile::updateUniformLocations(ProgramObject* programObject, const std::string& nameBase){
-        for (size_t i = 0; i < ChunkTilePile::SIZE; ++i){
-            std::string nameExtension = "chunkTile" + std::to_string(i) + ".";
-            gpuChunkTilePile[i].updateUniformLocations(programObject, nameBase + nameExtension);
+    void GPUChunkTilePile::updateUniformLocations(ProgramObject* programObject, const std::string& nameBase, int pileSize){
+        gpuChunkTiles.resize(pileSize);
+        for (size_t i = 0; i < gpuChunkTiles.size(); ++i){
+            std::string nameExtension = "level" + std::to_string(i) + ".";
+            gpuChunkTiles[i].updateUniformLocations(programObject, nameBase + nameExtension);
+        }
+    }
+
+    
+    // LayerGroup
+
+    void GPULayerGroup::setValue(ProgramObject* programObject, const LayerGroup& layerGroup){
+        size_t numActiveLayers = layerGroup.activeLayers().size();
+        ghoul_assert(numActiveLayers == gpuActiveLayers.size(), "GPU and CPU active layers must have same size!");
+        for (int i = 0; i < numActiveLayers; ++i){
+            //gpuActiveLayers[i].setValue(programObject, layerGroup.activeLayers()[i]);
+        }
+    }
+
+    void GPULayerGroup::updateUniformLocations(ProgramObject* programObject, const std::string& nameBase, int pileSize, int numActiveLayers){
+        gpuActiveLayers.resize(numActiveLayers);
+        for (size_t i = 0; i < gpuActiveLayers.size(); ++i){
+            std::string nameExtension = "[" + std::to_string(i) + "].";
+            gpuActiveLayers[i].updateUniformLocations(programObject, nameBase + nameExtension, pileSize);
         }
     }
 
diff --git a/modules/globebrowsing/tile/gpustructs.h b/modules/globebrowsing/tile/gpustructs.h
index bed63dbc74..88c21c8eaf 100644
--- a/modules/globebrowsing/tile/gpustructs.h
+++ b/modules/globebrowsing/tile/gpustructs.h
@@ -30,7 +30,7 @@
 
 #include <glm/glm.hpp>
 
-#include <array>
+#include <vector>
 
 
 namespace ghoul{
@@ -88,10 +88,35 @@ class GPUChunkTilePile{
 public:
     
     void setValue(ProgramObject* programObject, const ChunkTilePile& chunkTilePile);
-    void updateUniformLocations(ProgramObject* programObject, const std::string& nameBase);
+    void updateUniformLocations(ProgramObject* programObject, const std::string& nameBase, int pileSize);
 
 private:
-    std::array<GPUChunkTile, ChunkTilePile::SIZE> gpuChunkTilePile;
+    std::vector<GPUChunkTile> gpuChunkTiles;
+};
+
+
+class LayerSettings;
+class GPULayerSettings{
+public:
+    void setValue(ProgramObject* programObject, const LayerSettings& layerSettings);
+    void updateUniformLocations(ProgramObject* programObject, const std::string& nameBase);
+private:
+    GPUData<int> gpu_hej;
+    GPUData<float> gpu_tja;
+    GPUData<bool> gpu_senare;
+};
+
+
+class LayerGroup;
+class GPULayerGroup{
+public:
+    
+    void setValue(ProgramObject* programObject, const LayerGroup& layerGroup);
+    void updateUniformLocations(ProgramObject* programObject, const std::string& nameBase, int pileSize, int numActiveLayers);
+
+    std::vector<GPUChunkTilePile> gpuActiveLayers;
+
+
 };
 
 
diff --git a/modules/globebrowsing/tile/layermanager.cpp b/modules/globebrowsing/tile/layermanager.cpp
index cb7d19356e..984b9a840b 100644
--- a/modules/globebrowsing/tile/layermanager.cpp
+++ b/modules/globebrowsing/tile/layermanager.cpp
@@ -26,6 +26,8 @@
 
 #include <modules/globebrowsing/tile/layermanager.h>
 
+#include <openspace/properties/scalarproperty.h>
+
 #include <ghoul/logging/logmanager.h>
 
 #include "cpl_minixml.h"
@@ -36,8 +38,10 @@ namespace {
 
 namespace openspace {
 namespace globebrowsing {
+
+
     //////////////////////////////////////////////////////////////////////////////////////
-    //                            Tile Provider Group                                   //
+    //                               Layer Group                                        //
     //////////////////////////////////////////////////////////////////////////////////////
 
     void LayerGroup::update() {
diff --git a/modules/globebrowsing/tile/layermanager.h b/modules/globebrowsing/tile/layermanager.h
index 166cb13de5..0f5064b281 100644
--- a/modules/globebrowsing/tile/layermanager.h
+++ b/modules/globebrowsing/tile/layermanager.h
@@ -32,6 +32,8 @@
 #include <ghoul/misc/dictionary.h>
 #include <ghoul/misc/assert.h>
 
+#include <openspace/util/gpudata.h>
+
 #include <memory>
 #include <vector>
 #include <string>
@@ -39,12 +41,37 @@
 namespace openspace {
 namespace globebrowsing {
 
+
+    template<typename T> class LayerSetting;
+    
+    class ILayerSetting{
+    public:
+        virtual void setValue(ProgramObject* programObject) = 0;
+    };
+
+
+    template<typename T>
+    class LayerSetting : public ILayerSetting {
+    public:
+        LayerSetting(T t): data(t) {}
+
+        virtual void setValue(ProgramObject* programObject) override {
+            gpuData.setValue(programObject, data);
+        }
+
+    private:
+        GPUData<T> gpuData;
+        T data;
+    };
+
+
     struct Layer {
         std::string name;
         std::shared_ptr<TileProvider> tileProvider;
         bool isActive;
 
         PerLayerSettings settings;
+        std::vector<ILayerSetting*> isettings;
     };
 
     struct LayerGroup {
diff --git a/modules/globebrowsing/tile/tileselector.cpp b/modules/globebrowsing/tile/tileselector.cpp
index 5a3375b263..75279a7ced 100644
--- a/modules/globebrowsing/tile/tileselector.cpp
+++ b/modules/globebrowsing/tile/tileselector.cpp
@@ -23,10 +23,10 @@
 ****************************************************************************************/
 
 #include <modules/globebrowsing/tile/tileselector.h>
-
 #include <modules/globebrowsing/tile/tileprovider/tileprovider.h>
 
 #include <ghoul/logging/logmanager.h>
+#include <ghoul/misc/assert.h>
 
 #include <sstream>
 #include <algorithm>
@@ -42,19 +42,16 @@ namespace globebrowsing {
 
     const TileSelector::CompareResolution TileSelector::HIGHEST_RES = TileSelector::CompareResolution();
 
-    ChunkTilePile TileSelector::getHighestResolutionTilePile(TileProvider* tileProvider, TileIndex tileIndex){
+    ChunkTilePile TileSelector::getHighestResolutionTilePile(TileProvider* tileProvider, TileIndex tileIndex, int pileSize){
+        ghoul_assert(pileSize >= 0, "pileSize must be positive");
         ChunkTilePile chunkTilePile;
-        for (size_t i = 0; i < ChunkTilePile::SIZE; ++i){
+        chunkTilePile.chunkTiles.resize(pileSize);
+        for (size_t i = 0; i < pileSize; ++i){
             chunkTilePile.chunkTiles[i] = TileSelector::getHighestResolutionTile(tileProvider, tileIndex, i);
             if (chunkTilePile.chunkTiles[i].tile.status == Tile::Status::Unavailable) {
-                if(i>0){
-                    chunkTilePile.chunkTiles[i] = chunkTilePile.chunkTiles[i-1];
-                }
-                else{
-                    chunkTilePile.chunkTiles[i].tile = tileProvider->getDefaultTile();
-                    chunkTilePile.chunkTiles[i].uvTransform.uvOffset = { 0, 0 };
-                    chunkTilePile.chunkTiles[i].uvTransform.uvScale = { 1, 1 };    
-                }
+                chunkTilePile.chunkTiles[i].tile = tileProvider->getDefaultTile();
+                chunkTilePile.chunkTiles[i].uvTransform.uvOffset = { 0, 0 };
+                chunkTilePile.chunkTiles[i].uvTransform.uvScale = { 1, 1 };
             }
         }
         return std::move(chunkTilePile);
diff --git a/modules/globebrowsing/tile/tileselector.h b/modules/globebrowsing/tile/tileselector.h
index 4d2279b73c..fa0c750654 100644
--- a/modules/globebrowsing/tile/tileselector.h
+++ b/modules/globebrowsing/tile/tileselector.h
@@ -39,7 +39,7 @@ namespace globebrowsing {
     public:
         static ChunkTile getHighestResolutionTile(TileProvider* tileProvider, TileIndex tileIndex, int parents = 0);
         static ChunkTile getHighestResolutionTile(const LayerGroup& layerGroup, TileIndex tileIndex);
-        static ChunkTilePile getHighestResolutionTilePile(TileProvider* tileProvider, TileIndex tileIndex);
+        static ChunkTilePile getHighestResolutionTilePile(TileProvider* tileProvider, TileIndex tileIndex, int pileSize);
         static std::vector<ChunkTile> getTilesSortedByHighestResolution(const LayerGroup&, const TileIndex& tileIndex);
 
         struct CompareResolution {
diff --git a/src/util/gpudata.cpp b/src/util/gpudata.cpp
index 63c9ff2659..ea1413de54 100644
--- a/src/util/gpudata.cpp
+++ b/src/util/gpudata.cpp
@@ -43,7 +43,7 @@ namespace openspace {
 	void UpdatableUniformLocation::updateUniformLocations(ProgramObject* program, const std::string& name){
         _uniformLocation = program->uniformLocation(name);
         LDEBUG(name);
-    }    
+    }
 
 } // namespace openspace