diff --git a/ext/ghoul b/ext/ghoul
index 52bb0bae10..38ef288aa1 160000
--- a/ext/ghoul
+++ b/ext/ghoul
@@ -1 +1 @@
-Subproject commit 52bb0bae102b16d0fe8b5fe0575d2280ba9736e6
+Subproject commit 38ef288aa14d9ee54dbc68c77703c8638215726f
diff --git a/modules/atmosphere/rendering/atmospheredeferredcaster.cpp b/modules/atmosphere/rendering/atmospheredeferredcaster.cpp
index 3ea90797f7..931766841e 100644
--- a/modules/atmosphere/rendering/atmospheredeferredcaster.cpp
+++ b/modules/atmosphere/rendering/atmospheredeferredcaster.cpp
@@ -66,6 +66,7 @@
 #include <ghoul/opengl/texture.h>
 #include <ghoul/opengl/textureunit.h>
 #include <ghoul/opengl/programobject.h>
+#include <ghoul/filesystem/filesystem.h>
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/util/powerscaledcoordinate.h>
 #include <openspace/util/updatestructures.h>
@@ -491,8 +492,8 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
     if (!_transmittanceProgramObject) {
         _transmittanceProgramObject = ghoul::opengl::ProgramObject::Build(
             "transmittanceCalcProgram",
-            "${MODULE_ATMOSPHERE}/shaders/transmittance_calc_vs.glsl",
-            "${MODULE_ATMOSPHERE}/shaders/transmittance_calc_fs.glsl");
+            absPath("${MODULE_ATMOSPHERE}/shaders/transmittance_calc_vs.glsl"),
+            absPath("${MODULE_ATMOSPHERE}/shaders/transmittance_calc_fs.glsl"));
     }
     using IgnoreError = ghoul::opengl::ProgramObject::IgnoreError;
     _transmittanceProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
@@ -502,8 +503,8 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
     if (!_irradianceProgramObject) {
         _irradianceProgramObject = ghoul::opengl::ProgramObject::Build(
             "irradianceCalcProgram",
-            "${MODULE_ATMOSPHERE}/shaders/irradiance_calc_vs.glsl",
-            "${MODULE_ATMOSPHERE}/shaders/irradiance_calc_fs.glsl");        
+            absPath("${MODULE_ATMOSPHERE}/shaders/irradiance_calc_vs.glsl"),
+            absPath("${MODULE_ATMOSPHERE}/shaders/irradiance_calc_fs.glsl"));
     }
     _irradianceProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
     _irradianceProgramObject->setIgnoreUniformLocationError(IgnoreError::Yes);
@@ -511,8 +512,8 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
     if (!_irradianceSupTermsProgramObject) {
         _irradianceSupTermsProgramObject = ghoul::opengl::ProgramObject::Build(
             "irradianceSupTermsCalcProgram",
-            "${MODULE_ATMOSPHERE}/shaders/irradiance_sup_calc_vs.glsl",
-            "${MODULE_ATMOSPHERE}/shaders/irradiance_sup_calc_fs.glsl");
+            absPath("${MODULE_ATMOSPHERE}/shaders/irradiance_sup_calc_vs.glsl"),
+            absPath("${MODULE_ATMOSPHERE}/shaders/irradiance_sup_calc_fs.glsl"));
     }
     _irradianceSupTermsProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
     _irradianceSupTermsProgramObject->setIgnoreUniformLocationError(IgnoreError::Yes);
@@ -521,9 +522,9 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
     if (!_inScatteringProgramObject) {
         _inScatteringProgramObject = ghoul::opengl::ProgramObject::Build(
             "inScatteringCalcProgram",
-            "${MODULE_ATMOSPHERE}/shaders/inScattering_calc_vs.glsl",
-            "${MODULE_ATMOSPHERE}/shaders/inScattering_calc_fs.glsl",
-            "${MODULE_ATMOSPHERE}/shaders/inScattering_calc_gs.glsl");
+            absPath("${MODULE_ATMOSPHERE}/shaders/inScattering_calc_vs.glsl"),
+            absPath("${MODULE_ATMOSPHERE}/shaders/inScattering_calc_fs.glsl"),
+            absPath("${MODULE_ATMOSPHERE}/shaders/inScattering_calc_gs.glsl"));
     }
     _inScatteringProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
     _inScatteringProgramObject->setIgnoreUniformLocationError(IgnoreError::Yes);
@@ -531,9 +532,9 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
     if (!_inScatteringSupTermsProgramObject) {
         _inScatteringSupTermsProgramObject = ghoul::opengl::ProgramObject::Build(
             "inScatteringSupTermsCalcProgram",
-            "${MODULE_ATMOSPHERE}/shaders/inScattering_sup_calc_vs.glsl",
-            "${MODULE_ATMOSPHERE}/shaders/inScattering_sup_calc_fs.glsl",
-            "${MODULE_ATMOSPHERE}/shaders/inScattering_sup_calc_gs.glsl");
+            absPath("${MODULE_ATMOSPHERE}/shaders/inScattering_sup_calc_vs.glsl"),
+            absPath("${MODULE_ATMOSPHERE}/shaders/inScattering_sup_calc_fs.glsl"),
+            absPath("${MODULE_ATMOSPHERE}/shaders/inScattering_sup_calc_gs.glsl"));
     }
     _inScatteringSupTermsProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
     _inScatteringSupTermsProgramObject->setIgnoreUniformLocationError(IgnoreError::Yes);
@@ -542,8 +543,8 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
     if (!_deltaEProgramObject) {
         _deltaEProgramObject = ghoul::opengl::ProgramObject::Build(
             "deltaECalcProgram",
-            "${MODULE_ATMOSPHERE}/shaders/deltaE_calc_vs.glsl",
-            "${MODULE_ATMOSPHERE}/shaders/deltaE_calc_fs.glsl");
+            absPath("${MODULE_ATMOSPHERE}/shaders/deltaE_calc_vs.glsl"),
+            absPath("${MODULE_ATMOSPHERE}/shaders/deltaE_calc_fs.glsl"));
     }
     _deltaEProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
     _deltaEProgramObject->setIgnoreUniformLocationError(IgnoreError::Yes);
@@ -552,8 +553,8 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
     if (!_irradianceFinalProgramObject) {
         _irradianceFinalProgramObject = ghoul::opengl::ProgramObject::Build(
             "irradianceEFinalProgram",
-            "${MODULE_ATMOSPHERE}/shaders/irradiance_final_vs.glsl",
-            "${MODULE_ATMOSPHERE}/shaders/irradiance_final_fs.glsl");
+            absPath("${MODULE_ATMOSPHERE}/shaders/irradiance_final_vs.glsl"),
+            absPath("${MODULE_ATMOSPHERE}/shaders/irradiance_final_fs.glsl"));
     }
     _irradianceFinalProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
     _irradianceFinalProgramObject->setIgnoreUniformLocationError(IgnoreError::Yes);
@@ -562,9 +563,9 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
     if (!_deltaSProgramObject) {
         _deltaSProgramObject = ghoul::opengl::ProgramObject::Build(
             "deltaSCalcProgram",
-            "${MODULE_ATMOSPHERE}/shaders/deltaS_calc_vs.glsl",
-            "${MODULE_ATMOSPHERE}/shaders/deltaS_calc_fs.glsl",
-            "${MODULE_ATMOSPHERE}/shaders/deltaS_calc_gs.glsl");
+            absPath("${MODULE_ATMOSPHERE}/shaders/deltaS_calc_vs.glsl"),
+            absPath("${MODULE_ATMOSPHERE}/shaders/deltaS_calc_fs.glsl"),
+            absPath("${MODULE_ATMOSPHERE}/shaders/deltaS_calc_gs.glsl"));
     }
     _deltaSProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
     _deltaSProgramObject->setIgnoreUniformLocationError(IgnoreError::Yes);
@@ -572,9 +573,9 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
     if (!_deltaSSupTermsProgramObject) {
         _deltaSSupTermsProgramObject = ghoul::opengl::ProgramObject::Build(
             "deltaSSUPTermsCalcProgram",
-            "${MODULE_ATMOSPHERE}/shaders/deltaS_sup_calc_vs.glsl",
-            "${MODULE_ATMOSPHERE}/shaders/deltaS_sup_calc_fs.glsl",
-            "${MODULE_ATMOSPHERE}/shaders/deltaS_sup_calc_gs.glsl");
+            absPath("${MODULE_ATMOSPHERE}/shaders/deltaS_sup_calc_vs.glsl"),
+            absPath("${MODULE_ATMOSPHERE}/shaders/deltaS_sup_calc_fs.glsl"),
+            absPath("${MODULE_ATMOSPHERE}/shaders/deltaS_sup_calc_gs.glsl"));
     }
     _deltaSSupTermsProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
     _deltaSSupTermsProgramObject->setIgnoreUniformLocationError(IgnoreError::Yes);
@@ -583,9 +584,9 @@ void AtmosphereDeferredcaster::loadComputationPrograms() {
     if (!_deltaJProgramObject) {
         _deltaJProgramObject = ghoul::opengl::ProgramObject::Build(
             "deltaJCalcProgram",
-            "${MODULE_ATMOSPHERE}/shaders/deltaJ_calc_vs.glsl",
-            "${MODULE_ATMOSPHERE}/shaders/deltaJ_calc_fs.glsl",
-            "${MODULE_ATMOSPHERE}/shaders/deltaJ_calc_gs.glsl");
+            absPath("${MODULE_ATMOSPHERE}/shaders/deltaJ_calc_vs.glsl"),
+            absPath("${MODULE_ATMOSPHERE}/shaders/deltaJ_calc_fs.glsl"),
+            absPath("${MODULE_ATMOSPHERE}/shaders/deltaJ_calc_gs.glsl"));
     }
     _deltaJProgramObject->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
     _deltaJProgramObject->setIgnoreUniformLocationError(IgnoreError::Yes);
diff --git a/modules/digitaluniverse/rendering/renderablebillboardscloud.cpp b/modules/digitaluniverse/rendering/renderablebillboardscloud.cpp
index e4089b56d5..16f065a816 100644
--- a/modules/digitaluniverse/rendering/renderablebillboardscloud.cpp
+++ b/modules/digitaluniverse/rendering/renderablebillboardscloud.cpp
@@ -1554,9 +1554,10 @@ void RenderableBillboardsCloud::loadPolygonGeometryForRendering() {
 void RenderableBillboardsCloud::renderPolygonGeometry(GLuint vao) {
     std::unique_ptr<ghoul::opengl::ProgramObject> program = 
         ghoul::opengl::ProgramObject::Build("RenderableBillboardsCloud_Polygon",
-        "${MODULE_DIGITALUNIVERSE}/shaders/billboardpolygon_vs.glsl",
-        "${MODULE_DIGITALUNIVERSE}/shaders/billboardpolygon_fs.glsl",
-        "${MODULE_DIGITALUNIVERSE}/shaders/billboardpolygon_gs.glsl");
+        absPath("${MODULE_DIGITALUNIVERSE}/shaders/billboardpolygon_vs.glsl"),
+        absPath("${MODULE_DIGITALUNIVERSE}/shaders/billboardpolygon_fs.glsl"),
+        absPath("${MODULE_DIGITALUNIVERSE}/shaders/billboardpolygon_gs.glsl")
+    );
 
     program->activate();
     static const float black[] = { 0.0f, 0.0f, 0.0f, 0.0f };
diff --git a/src/rendering/framebufferrenderer.cpp b/src/rendering/framebufferrenderer.cpp
index 1a11cd587d..63cdc524b7 100644
--- a/src/rendering/framebufferrenderer.cpp
+++ b/src/rendering/framebufferrenderer.cpp
@@ -461,8 +461,8 @@ void FramebufferRenderer::updateRaycastData() {
             outsideDict.setValue("getEntryPath", GetEntryOutsidePath);
             _raycastPrograms[raycaster] = ghoul::opengl::ProgramObject::Build(
                 "Volume " + std::to_string(data.id) + " raycast",
-                vsPath,
-                RaycastFragmentShaderPath,
+                absPath(vsPath),
+                absPath(RaycastFragmentShaderPath),
                 outsideDict
             );
         } catch (ghoul::RuntimeError e) {
@@ -473,8 +473,8 @@ void FramebufferRenderer::updateRaycastData() {
             insideDict.setValue("getEntryPath", GetEntryInsidePath);
             _insideRaycastPrograms[raycaster] = ghoul::opengl::ProgramObject::Build(
                 "Volume " + std::to_string(data.id) + " inside raycast",
-                "${SHADERS}/framebuffer/resolveframebuffer.vert",
-                RaycastFragmentShaderPath,
+                absPath("${SHADERS}/framebuffer/resolveframebuffer.vert"),
+                absPath(RaycastFragmentShaderPath),
                 insideDict
             );
         }
@@ -519,8 +519,8 @@ void FramebufferRenderer::updateDeferredcastData() {
             //deferredDict.setValue("getEntryPath", GetEntryOutsidePath);
             _deferredcastPrograms[deferredcaster] = ghoul::opengl::ProgramObject::Build(
                 "Deferred " + std::to_string(data.id) + " raycast",
-                vsPath,
-                deferredShaderPath,
+                absPath(vsPath),
+                absPath(deferredShaderPath),
                 deferredDict);
             using IgnoreError = ghoul::opengl::ProgramObject::IgnoreError;
             _deferredcastPrograms[deferredcaster]->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
@@ -538,8 +538,8 @@ void FramebufferRenderer::updateHDRData() {
     try {
         _hdrBackGroundProgram = ghoul::opengl::ProgramObject::Build(
             "HDR Background Control",
-            "${SHADERS}/framebuffer/hdrBackground.vert",
-            "${SHADERS}/framebuffer/hdrBackground.frag"
+            absPath("${SHADERS}/framebuffer/hdrBackground.vert"),
+            absPath("${SHADERS}/framebuffer/hdrBackground.frag")
         );
         using IgnoreError = ghoul::opengl::ProgramObject::IgnoreError;
         _hdrBackGroundProgram->setIgnoreSubroutineUniformLocationError(IgnoreError::Yes);
@@ -666,8 +666,8 @@ void FramebufferRenderer::updateMSAASamplingPattern() {
     try {
         pixelSizeProgram = ghoul::opengl::ProgramObject::Build(
             "OnePixel MSAA",
-            "${SHADERS}/framebuffer/pixelSizeMSAA.vert",
-            "${SHADERS}/framebuffer/pixelSizeMSAA.frag"
+            absPath("${SHADERS}/framebuffer/pixelSizeMSAA.vert"),
+            absPath("${SHADERS}/framebuffer/pixelSizeMSAA.frag")
         );
     }
     catch (const ghoul::RuntimeError& e) {
@@ -814,8 +814,8 @@ void FramebufferRenderer::updateMSAASamplingPattern() {
     try {
         nOneStripProgram = ghoul::opengl::ProgramObject::Build(
             "OneStrip MSAA",
-            "${SHADERS}/framebuffer/nOneStripMSAA.vert",
-            "${SHADERS}/framebuffer/nOneStripMSAA.frag"
+            absPath("${SHADERS}/framebuffer/nOneStripMSAA.vert"),
+            absPath("${SHADERS}/framebuffer/nOneStripMSAA.frag")
         );
     }
     catch (const ghoul::RuntimeError& e) {