diff --git a/modules/demo-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/demo/MainGLFW.java b/modules/demo-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/demo/MainGLFW.java
index fb1a09d..ea3ef2c 100644
--- a/modules/demo-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/demo/MainGLFW.java
+++ b/modules/demo-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/demo/MainGLFW.java
@@ -34,7 +34,7 @@ public class MainGLFW {
     private static final boolean DISABLE_INSTANCED_RENDERING = false;
     private static final boolean DISABLE_VAOS = false;
 
-    private static final boolean DEBUG = false;
+    private static final boolean DEBUG = true;
     private static final boolean USE_OPENGL_ES = false;
 
     private static final int WIDTH = 1024;
diff --git a/modules/engine-core/src/main/java/org/gephi/viz/engine/VizEngine.java b/modules/engine-core/src/main/java/org/gephi/viz/engine/VizEngine.java
index 48ccfe8..f436b38 100644
--- a/modules/engine-core/src/main/java/org/gephi/viz/engine/VizEngine.java
+++ b/modules/engine-core/src/main/java/org/gephi/viz/engine/VizEngine.java
@@ -1,19 +1,14 @@
 package org.gephi.viz.engine;
 
 import java.awt.Color;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Objects;
-import java.util.Set;
+import java.util.*;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
+
+import jdk.nashorn.internal.runtime.options.Option;
 import org.gephi.graph.api.GraphModel;
 import org.gephi.graph.api.Rect2D;
 import org.gephi.viz.engine.pipeline.RenderingLayer;
@@ -90,6 +85,36 @@ public class VizEngine<R extends RenderingTarget, I> {
     private final InstanceContent instanceContent;
     private final AbstractLookup lookup;
 
+    //Timer
+    private float globalTime;
+    private Optional<Float> selectedTime = Optional.empty();
+
+    public float getGlobalTime() {
+        return globalTime;
+    }
+
+    public void setGlobalTime(float globalTime) {
+        this.globalTime = globalTime;
+    }
+
+    public Optional<Float >getSelectedTime() {
+        return selectedTime;
+    }
+
+    // Update only if empty
+    // Dev comments : I don't know if it make sense to take what's currently in globalTime ?
+    public void setSelectedTime() {
+        if(!this.selectedTime.isPresent()) {
+            this.selectedTime = Optional.of(globalTime);
+        }
+    }
+
+    // Reset selected time
+    public void unsetSelectedTime() {
+        this.selectedTime = Optional.empty();
+    }
+
+
     public VizEngine(GraphModel graphModel, R renderingTarget) {
         this.graphModel = Objects.requireNonNull(graphModel, "graphModel mandatory");
         this.instanceContent = new InstanceContent();
diff --git a/modules/engine-core/src/main/java/org/gephi/viz/engine/status/GraphSelection.java b/modules/engine-core/src/main/java/org/gephi/viz/engine/status/GraphSelection.java
index caae5f8..abdf44a 100644
--- a/modules/engine-core/src/main/java/org/gephi/viz/engine/status/GraphSelection.java
+++ b/modules/engine-core/src/main/java/org/gephi/viz/engine/status/GraphSelection.java
@@ -1,9 +1,11 @@
 package org.gephi.viz.engine.status;
 
 import java.util.Collection;
+import java.util.Optional;
 import java.util.Set;
 import org.gephi.graph.api.Edge;
 import org.gephi.graph.api.Node;
+import org.gephi.viz.engine.util.TimeUtils;
 
 /**
  *
diff --git a/modules/engine-core/src/main/java/org/gephi/viz/engine/util/TimeUtils.java b/modules/engine-core/src/main/java/org/gephi/viz/engine/util/TimeUtils.java
index d3a001a..0803430 100644
--- a/modules/engine-core/src/main/java/org/gephi/viz/engine/util/TimeUtils.java
+++ b/modules/engine-core/src/main/java/org/gephi/viz/engine/util/TimeUtils.java
@@ -5,7 +5,6 @@
  * @author Eduardo Ramos
  */
 public class TimeUtils {
-
     public static long getTimeMillis() {
         return System.nanoTime() / 1_000_000;
     }
diff --git a/modules/opengl-commons/src/main/java/org/gephi/viz/engine/util/gl/Constants.java b/modules/opengl-commons/src/main/java/org/gephi/viz/engine/util/gl/Constants.java
index 601d85c..dc512da 100644
--- a/modules/opengl-commons/src/main/java/org/gephi/viz/engine/util/gl/Constants.java
+++ b/modules/opengl-commons/src/main/java/org/gephi/viz/engine/util/gl/Constants.java
@@ -18,6 +18,7 @@ public class Constants {
     public static final String ATTRIB_NAME_SOURCE_SIZE = "sourceSize";
     public static final String ATTRIB_NAME_TARGET_SIZE = "targetSize";
 
+
     public static final int SHADER_VERT_LOCATION = 0;
     public static final int SHADER_POSITION_LOCATION = 1;
     public static final int SHADER_COLOR_LOCATION = 2;
@@ -42,6 +43,9 @@ public class Constants {
     public static final String UNIFORM_NAME_BACKGROUND_COLOR = "backgroundColor";
     public static final String UNIFORM_NAME_COLOR_LIGHTEN_FACTOR = "colorLightenFactor";
 
+    public static final String UNIFORM_NAME_GLOBAL_TIME = "fGlobalTime";
+    public static final String UNIFORM_NAME_GLOBAL_SELECTED_START_TIME = "fSelectedStartGlobalTime";
+    public static final String UNIFORM_NAME_IS_SELECTION_ON = "bIsSelectionOn";
     //Rendering order:
     public static final int RENDERING_ORDER_NODES = 100;
     public static final int RENDERING_ORDER_EDGES = 50;
diff --git a/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/edge/edge-line-directed.frag b/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/edge/edge-line-directed.frag
index 7af8936..e87b3cd 100644
--- a/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/edge/edge-line-directed.frag
+++ b/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/edge/edge-line-directed.frag
@@ -4,8 +4,10 @@
 precision lowp float;
 #endif
 
+uniform float fGlobalTime;
+
 varying lowp vec4 fragColor;
 
 void main() {
     gl_FragColor = fragColor;
-}
+}
\ No newline at end of file
diff --git a/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/edge/edge-line-directed.vert b/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/edge/edge-line-directed.vert
index c54e420..f730f6f 100644
--- a/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/edge/edge-line-directed.vert
+++ b/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/edge/edge-line-directed.vert
@@ -8,6 +8,9 @@ uniform float minWeight;
 uniform float weightDifferenceDivisor;
 uniform float edgeScaleMin;
 uniform float edgeScaleMax;
+uniform float fGlobalTime;
+uniform float fSelectedStartGlobalTime;
+uniform bool bIsSelectionOn;
 
 attribute vec3 vert;
 attribute vec2 position;
@@ -45,8 +48,11 @@ void main() {
     }
     color = color / 255.0;
 
+    float smoothTransition = smoothstep(0.000,.5,.0001+pow(fGlobalTime - fSelectedStartGlobalTime,.5));
+
     color.rgb = min(colorBias + color.rgb * colorMultiplier, 1.0);
-    color.rgb = mix(color.rgb, backgroundColor.rgb, colorLightenFactor);
+
+    color.rgb = mix(color.rgb, backgroundColor.rgb, colorLightenFactor*smoothTransition);
 
     fragColor = color;
 }
diff --git a/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/edge/edge-line-undirected.frag b/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/edge/edge-line-undirected.frag
index 7af8936..9bdf3a8 100644
--- a/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/edge/edge-line-undirected.frag
+++ b/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/edge/edge-line-undirected.frag
@@ -4,6 +4,8 @@
 precision lowp float;
 #endif
 
+uniform float fGlobalTime;
+
 varying lowp vec4 fragColor;
 
 void main() {
diff --git a/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/edge/edge-line-undirected.vert b/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/edge/edge-line-undirected.vert
index 6c5008f..dcfe3ab 100644
--- a/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/edge/edge-line-undirected.vert
+++ b/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/edge/edge-line-undirected.vert
@@ -7,6 +7,9 @@ uniform float minWeight;
 uniform float weightDifferenceDivisor;
 uniform float edgeScaleMin;
 uniform float edgeScaleMax;
+uniform float fGlobalTime;
+uniform float fSelectedStartGlobalTime;
+uniform bool bIsSelectionOn;
 
 attribute vec2 vert;
 attribute vec2 position;
@@ -42,8 +45,11 @@ void main() {
     }
     color = color / 255.0;
 
+    float smoothTransition = smoothstep(0.001,.005,pow(fGlobalTime - fSelectedStartGlobalTime,.5));
+
     color.rgb = colorBias + color.rgb * colorMultiplier;
-    color.rgb = mix(color.rgb, backgroundColor.rgb, colorLightenFactor);
+
+    color.rgb = mix(color.rgb, backgroundColor.rgb, colorLightenFactor*smoothTransition);
 
     fragColor = color;
 }
diff --git a/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/node/node.frag b/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/node/node.frag
index 80b2c5b..c0d2f36 100644
--- a/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/node/node.frag
+++ b/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/node/node.frag
@@ -4,6 +4,8 @@
 precision lowp float;
 #endif
 
+uniform float fGlobalTime;
+
 varying vec4 fragColor;
 
 void main() {
diff --git a/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/node/node.vert b/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/node/node.vert
index 6e9ef27..24d07ea 100644
--- a/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/node/node.vert
+++ b/modules/opengl-commons/src/main/resources/org/gephi/viz-engine/shaders/node/node.vert
@@ -3,6 +3,9 @@
 uniform mat4 mvp;
 uniform vec4 backgroundColor;
 uniform float colorLightenFactor;
+uniform float fGlobalTime;
+uniform float fSelectedStartGlobalTime;
+uniform bool bIsSelectionOn;
 
 attribute vec2 vert;
 attribute vec2 position;
@@ -13,14 +16,16 @@ attribute float size;
 
 varying vec4 fragColor;
 
-void main() {	
+void main() {
     vec2 instancePosition = size * vert + position;
     gl_Position = mvp * vec4(instancePosition, 0.0, 1.0);
 
     //bgra -> rgba because Java color is argb big-endian
     vec4 color = elementColor.bgra / 255.0;
     color.rgb = colorBias + color.rgb * colorMultiplier;
-    color.rgb = mix(color.rgb, backgroundColor.rgb, colorLightenFactor);
+
+    float smoothTransition = smoothstep(0.000,.5,.0001+pow(fGlobalTime - fSelectedStartGlobalTime,.5));
+    color.rgb = mix(color.rgb, backgroundColor.rgb, colorLightenFactor*smoothTransition);
 
     fragColor = color;
 }
diff --git a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/LWJGLRenderingTargetGLFW.java b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/LWJGLRenderingTargetGLFW.java
index 618b4f9..728795d 100644
--- a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/LWJGLRenderingTargetGLFW.java
+++ b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/LWJGLRenderingTargetGLFW.java
@@ -1,30 +1,18 @@
 package org.gephi.viz.engine.lwjgl;
 
 import org.gephi.viz.engine.VizEngine;
+import org.gephi.viz.engine.status.GraphSelection;
 import org.gephi.viz.engine.util.TimeUtils;
 import org.gephi.viz.engine.util.gl.OpenGLOptions;
 import org.lwjgl.glfw.GLFW;
-import static org.lwjgl.glfw.GLFW.glfwMakeContextCurrent;
-import static org.lwjgl.glfw.GLFW.glfwPollEvents;
-import static org.lwjgl.glfw.GLFW.glfwSetWindowCloseCallback;
-import static org.lwjgl.glfw.GLFW.glfwSetWindowSizeCallback;
-import static org.lwjgl.glfw.GLFW.glfwSwapBuffers;
-import static org.lwjgl.glfw.GLFW.glfwSwapInterval;
-import static org.lwjgl.glfw.GLFW.glfwWindowShouldClose;
 import org.lwjgl.opengl.GL;
 import org.lwjgl.opengl.GL11;
-import static org.lwjgl.opengl.GL11.GL_COLOR_BUFFER_BIT;
-import static org.lwjgl.opengl.GL11.GL_RENDERER;
-import static org.lwjgl.opengl.GL11.GL_VENDOR;
-import static org.lwjgl.opengl.GL11.GL_VERSION;
-import static org.lwjgl.opengl.GL11.glClear;
-import static org.lwjgl.opengl.GL11.glClearColor;
-import static org.lwjgl.opengl.GL11.glDisable;
-import static org.lwjgl.opengl.GL11.glGetString;
-import static org.lwjgl.opengl.GL11.glViewport;
 import org.lwjgl.opengl.GLCapabilities;
 import org.lwjgl.opengl.GLUtil;
 
+import static org.lwjgl.glfw.GLFW.*;
+import static org.lwjgl.opengl.GL11.*;
+
 /**
  *
  * @author Eduardo Ramos
@@ -133,6 +121,19 @@ public void loop() {
         glClear(GL_COLOR_BUFFER_BIT); // clear the framebuffer
 
         updateFPS();
+
+        // fGlobalTime for all program of the engine, using glfwGetTime retrive time since started;
+        engine.setGlobalTime((float) glfwGetTime());
+
+        // selectedTime for all program of the engine.
+        GraphSelection selection = engine.getLookup().lookup(GraphSelection.class);
+
+        // A selection is currently active
+        if(selection.getSelectedNodesCount() > 0){
+            engine.setSelectedTime();
+        } else {
+            engine.unsetSelectedTime();
+        }
         engine.display();
 
         glfwSwapBuffers(windowHandle); // swap the color buffers
diff --git a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/models/EdgeLineModelDirected.java b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/models/EdgeLineModelDirected.java
index e1277a4..110f999 100644
--- a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/models/EdgeLineModelDirected.java
+++ b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/models/EdgeLineModelDirected.java
@@ -1,13 +1,16 @@
 package org.gephi.viz.engine.lwjgl.models;
 
-import org.gephi.viz.engine.util.gl.Constants;
-import static org.gephi.viz.engine.util.gl.Constants.*;
-import org.gephi.viz.engine.util.NumberUtils;
 import org.gephi.viz.engine.lwjgl.util.gl.GLShaderProgram;
+import org.gephi.viz.engine.util.NumberUtils;
+import org.gephi.viz.engine.util.gl.Constants;
 import org.lwjgl.opengl.GL20;
 import org.lwjgl.opengl.GL31;
 import org.lwjgl.opengl.GL42;
 
+import java.util.Optional;
+
+import static org.gephi.viz.engine.util.gl.Constants.*;
+
 /**
  *
  * @author Eduardo Ramos
@@ -63,6 +66,9 @@ private void initProgram() {
                 .addUniformName(UNIFORM_NAME_EDGE_SCALE_MAX)
                 .addUniformName(UNIFORM_NAME_MIN_WEIGHT)
                 .addUniformName(UNIFORM_NAME_WEIGHT_DIFFERENCE_DIVISOR)
+                .addUniformName(UNIFORM_NAME_GLOBAL_TIME)
+                .addUniformName(UNIFORM_NAME_GLOBAL_SELECTED_START_TIME)
+                .addUniformName(UNIFORM_NAME_IS_SELECTION_ON)
                 .addAttribLocation(ATTRIB_NAME_VERT, SHADER_VERT_LOCATION)
                 .addAttribLocation(ATTRIB_NAME_POSITION, SHADER_POSITION_LOCATION)
                 .addAttribLocation(ATTRIB_NAME_POSITION_TARGET, SHADER_POSITION_TARGET_LOCATION)
@@ -84,8 +90,8 @@ public void drawArraysMultipleInstance(int drawBatchCount) {
         GL20.glDrawArrays(GL20.GL_TRIANGLES, 0, VERTEX_COUNT * drawBatchCount);
     }
 
-    public void drawInstanced(float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, int instanceCount, int instancesOffset, float scale, float minWeight, float maxWeight) {
-        useProgram(mvpFloats, backgroundColorFloats, colorLightenFactor, scale, minWeight, maxWeight);
+    public void drawInstanced(float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, int instanceCount, int instancesOffset, float scale, float minWeight, float maxWeight, float globalTime, Optional<Float> selectedTime) {
+        useProgram(mvpFloats, backgroundColorFloats, colorLightenFactor, scale, minWeight, maxWeight, globalTime, selectedTime);
         if (instancesOffset > 0) {
             GL42.glDrawArraysInstancedBaseInstance(GL20.GL_TRIANGLES, 0, VERTEX_COUNT, instanceCount, instancesOffset);
         } else {
@@ -94,22 +100,30 @@ public void drawInstanced(float[] mvpFloats, float[] backgroundColorFloats, floa
         stopUsingProgram();
     }
 
-    public void useProgram(float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, float scale, float minWeight, float maxWeight) {
+    public void useProgram(float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, float scale, float minWeight, float maxWeight, float globalTime, Optional<Float> selectedTime) {
         program.use();
-        prepareProgramData(mvpFloats, backgroundColorFloats, colorLightenFactor, scale, minWeight, maxWeight);
+        prepareProgramData(mvpFloats, backgroundColorFloats, colorLightenFactor, scale, minWeight, maxWeight, globalTime, selectedTime);
     }
 
     public void stopUsingProgram() {
         program.stopUsing();
     }
 
-    private void prepareProgramData(float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, float scale, float minWeight, float maxWeight) {
+    private void prepareProgramData(float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, float scale, float minWeight, float maxWeight, float globalTime, Optional<Float> selectedTime) {
         GL20.glUniformMatrix4fv(program.getUniformLocation(UNIFORM_NAME_MODEL_VIEW_PROJECTION), false, mvpFloats);
         GL20.glUniform4fv(program.getUniformLocation(UNIFORM_NAME_BACKGROUND_COLOR), backgroundColorFloats);
         GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_COLOR_LIGHTEN_FACTOR), colorLightenFactor);
         GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_EDGE_SCALE_MIN), EDGE_SCALE_MIN * scale);
         GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_EDGE_SCALE_MAX), EDGE_SCALE_MAX * scale);
         GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_MIN_WEIGHT), minWeight);
+        GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_GLOBAL_TIME), globalTime);
+        if(selectedTime.isPresent()){
+            GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_GLOBAL_SELECTED_START_TIME), selectedTime.get());
+            GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_IS_SELECTION_ON), selectedTime.get());
+        } else {
+            GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_GLOBAL_SELECTED_START_TIME), 0);
+            GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_IS_SELECTION_ON), 0);
+        }
 
         if (NumberUtils.equalsEpsilon(minWeight, maxWeight, 1e-3f)) {
             GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_WEIGHT_DIFFERENCE_DIVISOR), 1);
diff --git a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/models/EdgeLineModelUndirected.java b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/models/EdgeLineModelUndirected.java
index e2b95bf..2baf4d5 100644
--- a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/models/EdgeLineModelUndirected.java
+++ b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/models/EdgeLineModelUndirected.java
@@ -1,13 +1,16 @@
 package org.gephi.viz.engine.lwjgl.models;
 
 import org.gephi.viz.engine.lwjgl.util.gl.GLShaderProgram;
-import org.gephi.viz.engine.util.gl.Constants;
-import static org.gephi.viz.engine.util.gl.Constants.*;
 import org.gephi.viz.engine.util.NumberUtils;
+import org.gephi.viz.engine.util.gl.Constants;
 import org.lwjgl.opengl.GL20;
 import org.lwjgl.opengl.GL31;
 import org.lwjgl.opengl.GL42;
 
+import java.util.Optional;
+
+import static org.gephi.viz.engine.util.gl.Constants.*;
+
 /**
  *
  * @author Eduardo Ramos
@@ -63,6 +66,9 @@ private void initProgram() {
                 .addUniformName(UNIFORM_NAME_EDGE_SCALE_MAX)
                 .addUniformName(UNIFORM_NAME_MIN_WEIGHT)
                 .addUniformName(UNIFORM_NAME_WEIGHT_DIFFERENCE_DIVISOR)
+                .addUniformName(UNIFORM_NAME_GLOBAL_TIME)
+                .addUniformName(UNIFORM_NAME_GLOBAL_SELECTED_START_TIME)
+                .addUniformName(UNIFORM_NAME_IS_SELECTION_ON)
                 .addAttribLocation(ATTRIB_NAME_VERT, SHADER_VERT_LOCATION)
                 .addAttribLocation(ATTRIB_NAME_POSITION, SHADER_POSITION_LOCATION)
                 .addAttribLocation(ATTRIB_NAME_POSITION_TARGET, SHADER_POSITION_TARGET_LOCATION)
@@ -85,8 +91,8 @@ public void drawArraysMultipleInstance(int drawBatchCount) {
         GL20.glDrawArrays(GL20.GL_TRIANGLES, 0, VERTEX_COUNT * drawBatchCount);
     }
 
-    public void drawInstanced(float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, int instanceCount, int instancesOffset, float scale, float minWeight, float maxWeight) {
-        useProgram(mvpFloats, backgroundColorFloats, colorLightenFactor, scale, minWeight, maxWeight);
+    public void drawInstanced(float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, int instanceCount, int instancesOffset, float scale, float minWeight, float maxWeight, float globalTime, Optional<Float> selectedTime) {
+        useProgram(mvpFloats, backgroundColorFloats, colorLightenFactor, scale, minWeight, maxWeight, globalTime, selectedTime);
         if (instancesOffset > 0) {
             GL42.glDrawArraysInstancedBaseInstance(GL20.GL_TRIANGLES, 0, VERTEX_COUNT, instanceCount, instancesOffset);
         } else {
@@ -95,23 +101,31 @@ public void drawInstanced(float[] mvpFloats, float[] backgroundColorFloats, floa
         stopUsingProgram();
     }
 
-    public void useProgram(float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, float scale, float minWeight, float maxWeight) {
+    public void useProgram(float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, float scale, float minWeight, float maxWeight, float globalTime, Optional<Float> selectedTime) {
         //Line:
         program.use();
-        prepareProgramData(mvpFloats, backgroundColorFloats, colorLightenFactor, scale, minWeight, maxWeight);
+        prepareProgramData(mvpFloats, backgroundColorFloats, colorLightenFactor, scale, minWeight, maxWeight, globalTime, selectedTime);
     }
 
     public void stopUsingProgram() {
         program.stopUsing();
     }
 
-    private void prepareProgramData(float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, float scale, float minWeight, float maxWeight) {
+    private void prepareProgramData(float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, float scale, float minWeight, float maxWeight, float globalTime, Optional<Float> selectedTime) {
         GL20.glUniformMatrix4fv(program.getUniformLocation(UNIFORM_NAME_MODEL_VIEW_PROJECTION), false, mvpFloats);
         GL20.glUniform4fv(program.getUniformLocation(UNIFORM_NAME_BACKGROUND_COLOR), backgroundColorFloats);
         GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_COLOR_LIGHTEN_FACTOR), colorLightenFactor);
         GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_EDGE_SCALE_MIN), EDGE_SCALE_MIN * scale);
         GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_EDGE_SCALE_MAX), EDGE_SCALE_MAX * scale);
         GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_MIN_WEIGHT), minWeight);
+        GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_GLOBAL_TIME), globalTime);
+        if(selectedTime.isPresent()){
+            GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_GLOBAL_SELECTED_START_TIME), selectedTime.get());
+            GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_IS_SELECTION_ON), selectedTime.get());
+        } else {
+            GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_GLOBAL_SELECTED_START_TIME), 0);
+            GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_IS_SELECTION_ON), 0);
+        }
 
         if (NumberUtils.equalsEpsilon(minWeight, maxWeight, 1e-3f)) {
             GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_WEIGHT_DIFFERENCE_DIVISOR), 1);
diff --git a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/models/NodeDiskModel.java b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/models/NodeDiskModel.java
index ed9403e..ad47865 100644
--- a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/models/NodeDiskModel.java
+++ b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/models/NodeDiskModel.java
@@ -1,15 +1,17 @@
 package org.gephi.viz.engine.lwjgl.models;
 
-import java.nio.IntBuffer;
-import org.gephi.viz.engine.util.gl.Constants;
-import static org.gephi.viz.engine.util.gl.Constants.*;
 import org.gephi.viz.engine.lwjgl.util.gl.GLShaderProgram;
+import org.gephi.viz.engine.util.gl.Constants;
 import org.gephi.viz.engine.util.gl.GLConstants;
 import org.lwjgl.opengl.GL20;
 import org.lwjgl.opengl.GL31;
 import org.lwjgl.opengl.GL42;
 import org.lwjgl.opengl.GL43;
 
+import java.util.Optional;
+
+import static org.gephi.viz.engine.util.gl.Constants.*;
+
 /**
  * @author Eduardo Ramos
  */
@@ -67,6 +69,9 @@ private void initProgram() {
                 .addUniformName(UNIFORM_NAME_MODEL_VIEW_PROJECTION)
                 .addUniformName(UNIFORM_NAME_BACKGROUND_COLOR)
                 .addUniformName(UNIFORM_NAME_COLOR_LIGHTEN_FACTOR)
+                .addUniformName(UNIFORM_NAME_GLOBAL_TIME)
+                .addUniformName(UNIFORM_NAME_GLOBAL_SELECTED_START_TIME)
+                .addUniformName(UNIFORM_NAME_IS_SELECTION_ON)
                 .addAttribLocation(ATTRIB_NAME_VERT, SHADER_VERT_LOCATION)
                 .addAttribLocation(ATTRIB_NAME_POSITION, SHADER_POSITION_LOCATION)
                 .addAttribLocation(ATTRIB_NAME_COLOR, SHADER_COLOR_LOCATION)
@@ -80,8 +85,8 @@ public void drawArraysSingleInstance(int firstVertexIndex, int vertexCount) {
         GL20.glDrawArrays(GL20.GL_TRIANGLES, firstVertexIndex, vertexCount);
     }
 
-    public void drawInstanced(int vertexOffset, float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, int instanceCount, int instancesOffset) {
-        useProgram(mvpFloats, backgroundColorFloats, colorLightenFactor);
+    public void drawInstanced(int vertexOffset, float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, int instanceCount, int instancesOffset, float globalTime, Optional<Float> selectedTime) {
+        useProgram(mvpFloats, backgroundColorFloats, colorLightenFactor, globalTime, selectedTime);
         if (instancesOffset > 0) {
             GL42.glDrawArraysInstancedBaseInstance(GL20.GL_TRIANGLES, vertexOffset, vertexCount, instanceCount, instancesOffset);
         } else {
@@ -90,23 +95,33 @@ public void drawInstanced(int vertexOffset, float[] mvpFloats, float[] backgroun
         stopUsingProgram();
     }
 
-    public void drawInstanced(float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, int instanceCount, int instancesOffset) {
-        drawInstanced(0, mvpFloats, backgroundColorFloats, colorLightenFactor, instanceCount, instancesOffset);
+    public void drawInstanced(float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, int instanceCount, int instancesOffset, float globalTime, Optional<Float> selectedTime) {
+        drawInstanced(0, mvpFloats, backgroundColorFloats, colorLightenFactor, instanceCount, instancesOffset, globalTime, selectedTime);
     }
 
-    public void drawIndirect(float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, int instanceCount, int instancesOffset) {
-        useProgram(mvpFloats, backgroundColorFloats, colorLightenFactor);
+    public void drawIndirect(float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, int instanceCount, int instancesOffset, float globalTime, Optional<Float> selectedTime) {
+        useProgram(mvpFloats, backgroundColorFloats, colorLightenFactor, globalTime, selectedTime);
         GL43.glMultiDrawArraysIndirect(GL20.GL_TRIANGLES, instancesOffset * GLConstants.INDIRECT_DRAW_COMMAND_BYTES, instanceCount, GLConstants.INDIRECT_DRAW_COMMAND_BYTES);
         stopUsingProgram();
     }
 
-    public void useProgram(float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor) {
+    public void useProgram(float[] mvpFloats, float[] backgroundColorFloats, float colorLightenFactor, float globalTime, Optional<Float> selectedTime) {
         //Circle:
         program.use();
 
         GL20.glUniformMatrix4fv(program.getUniformLocation(UNIFORM_NAME_MODEL_VIEW_PROJECTION), false, mvpFloats);
         GL20.glUniform4fv(program.getUniformLocation(UNIFORM_NAME_BACKGROUND_COLOR), backgroundColorFloats);
         GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_COLOR_LIGHTEN_FACTOR), colorLightenFactor);
+        GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_GLOBAL_TIME),globalTime);
+        if(selectedTime.isPresent()){
+            GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_GLOBAL_SELECTED_START_TIME), selectedTime.get());
+            GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_IS_SELECTION_ON), selectedTime.get());
+        } else {
+            GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_GLOBAL_SELECTED_START_TIME), 0);
+            GL20.glUniform1f(program.getUniformLocation(UNIFORM_NAME_IS_SELECTION_ON), 0);
+        }
+
+
     }
 
     public void stopUsingProgram() {
diff --git a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/arrays/ArrayDrawEdgeData.java b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/arrays/ArrayDrawEdgeData.java
index 64a7532..4db04b2 100644
--- a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/arrays/ArrayDrawEdgeData.java
+++ b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/arrays/ArrayDrawEdgeData.java
@@ -1,23 +1,26 @@
 package org.gephi.viz.engine.lwjgl.pipeline.arrays;
 
-import java.nio.FloatBuffer;
 import org.gephi.graph.api.Edge;
 import org.gephi.graph.api.Graph;
 import org.gephi.viz.engine.VizEngine;
+import org.gephi.viz.engine.lwjgl.models.EdgeLineModelDirected;
+import org.gephi.viz.engine.lwjgl.models.EdgeLineModelUndirected;
+import org.gephi.viz.engine.lwjgl.pipeline.common.AbstractEdgeData;
+import org.gephi.viz.engine.lwjgl.util.gl.GLBufferMutable;
+import org.gephi.viz.engine.lwjgl.util.gl.ManagedDirectBuffer;
 import org.gephi.viz.engine.pipeline.RenderingLayer;
 import org.gephi.viz.engine.status.GraphRenderingOptions;
 import org.gephi.viz.engine.status.GraphSelection;
 import org.gephi.viz.engine.structure.GraphIndex;
 import org.gephi.viz.engine.structure.GraphIndexImpl;
 import org.gephi.viz.engine.util.ArrayUtils;
-import org.gephi.viz.engine.lwjgl.models.EdgeLineModelDirected;
-import org.gephi.viz.engine.lwjgl.models.EdgeLineModelUndirected;
-import org.gephi.viz.engine.lwjgl.pipeline.common.AbstractEdgeData;
-import org.gephi.viz.engine.lwjgl.util.gl.GLBufferMutable;
-import org.gephi.viz.engine.lwjgl.util.gl.ManagedDirectBuffer;
+import org.lwjgl.system.MemoryUtil;
+
+import java.nio.FloatBuffer;
+import java.util.Optional;
+
 import static org.lwjgl.opengl.GL11.GL_FLOAT;
 import static org.lwjgl.opengl.GL15.glGenBuffers;
-import org.lwjgl.system.MemoryUtil;
 
 /**
  *
@@ -52,6 +55,9 @@ public void update(VizEngine engine, GraphIndexImpl graphIndex) {
     public void drawArrays(RenderingLayer layer, VizEngine engine, float[] mvpFloats) {
         final GraphRenderingOptions renderingOptions = engine.getLookup().lookup(GraphRenderingOptions.class);
 
+        float globalTime = engine.getGlobalTime();
+        Optional<Float> selectedTime = engine.getSelectedTime();
+
         final float[] backgroundColorFloats = engine.getBackgroundColor();
         final float edgeScale = renderingOptions.getEdgeScale();
         float lightenNonSelectedFactor = renderingOptions.getLightenNonSelectedFactor();
@@ -61,11 +67,11 @@ public void drawArrays(RenderingLayer layer, VizEngine engine, float[] mvpFloats
         final float minWeight = graphIndex.getEdgesMinWeight();
         final float maxWeight = graphIndex.getEdgesMaxWeight();
 
-        drawUndirected(engine, layer, mvpFloats, backgroundColorFloats, lightenNonSelectedFactor, edgeScale, minWeight, maxWeight);
-        drawDirected(engine, layer, mvpFloats, backgroundColorFloats, lightenNonSelectedFactor, edgeScale, minWeight, maxWeight);
+        drawUndirected(engine, layer, mvpFloats, backgroundColorFloats, lightenNonSelectedFactor, edgeScale, minWeight, maxWeight, globalTime, selectedTime);
+        drawDirected(engine, layer, mvpFloats, backgroundColorFloats, lightenNonSelectedFactor, edgeScale, minWeight, maxWeight, globalTime, selectedTime);
     }
 
-    private void drawUndirected(VizEngine engine, RenderingLayer layer, float[] mvpFloats, float[] backgroundColorFloats, float lightenNonSelectedFactor, float edgeScale, float minWeight, float maxWeight) {
+    private void drawUndirected(VizEngine engine, RenderingLayer layer, float[] mvpFloats, float[] backgroundColorFloats, float lightenNonSelectedFactor, float edgeScale, float minWeight, float maxWeight, float globalTime, Optional<Float> selectedTime) {
         final int instanceCount;
         final int instancesOffset;
         final float colorLightenFactor;
@@ -82,7 +88,7 @@ private void drawUndirected(VizEngine engine, RenderingLayer layer, float[] mvpF
 
         if (instanceCount > 0) {
             setupUndirectedVertexArrayAttributes(engine);
-            lineModelUndirected.useProgram(mvpFloats, backgroundColorFloats, colorLightenFactor, edgeScale, minWeight, maxWeight);
+            lineModelUndirected.useProgram(mvpFloats, backgroundColorFloats, colorLightenFactor, edgeScale, minWeight, maxWeight, globalTime, selectedTime);
 
             final FloatBuffer batchUpdateBuffer = attributesDrawBufferBatchOneCopyPerVertexManagedDirectBuffer.floatBuffer();
 
@@ -121,11 +127,10 @@ private void drawUndirected(VizEngine engine, RenderingLayer layer, float[] mvpF
         }
     }
 
-    private void drawDirected(VizEngine engine, RenderingLayer layer, float[] mvpFloats, float[] backgroundColorFloats, float lightenNonSelectedFactor, float edgeScale, float minWeight, float maxWeight) {
+    private void drawDirected(VizEngine engine, RenderingLayer layer, float[] mvpFloats, float[] backgroundColorFloats, float lightenNonSelectedFactor, float edgeScale, float minWeight, float maxWeight, float globalTime, Optional<Float> selectedTime) {
         final int instanceCount;
         final int instancesOffset;
         final float colorLightenFactor;
-
         if (layer == RenderingLayer.BACK) {
             instanceCount = directedInstanceCounter.unselectedCountToDraw;
             instancesOffset = undirectedInstanceCounter.totalToDraw();
@@ -138,7 +143,7 @@ private void drawDirected(VizEngine engine, RenderingLayer layer, float[] mvpFlo
 
         if (instanceCount > 0) {
             setupDirectedVertexArrayAttributes(engine);
-            lineModelDirected.useProgram(mvpFloats, backgroundColorFloats, colorLightenFactor, edgeScale, minWeight, maxWeight);
+            lineModelDirected.useProgram(mvpFloats, backgroundColorFloats, colorLightenFactor, edgeScale, minWeight, maxWeight, globalTime, selectedTime);
 
             final FloatBuffer batchUpdateBuffer = attributesDrawBufferBatchOneCopyPerVertexManagedDirectBuffer.floatBuffer();
 
diff --git a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/arrays/ArrayDrawNodeData.java b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/arrays/ArrayDrawNodeData.java
index 10e5c22..2f65d0c 100644
--- a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/arrays/ArrayDrawNodeData.java
+++ b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/arrays/ArrayDrawNodeData.java
@@ -1,6 +1,5 @@
 package org.gephi.viz.engine.lwjgl.pipeline.arrays;
 
-import java.nio.FloatBuffer;
 import org.gephi.graph.api.Node;
 import org.gephi.viz.engine.VizEngine;
 import org.gephi.viz.engine.lwjgl.models.NodeDiskModel;
@@ -13,13 +12,14 @@
 import org.gephi.viz.engine.status.GraphSelection;
 import org.gephi.viz.engine.status.GraphSelectionNeighbours;
 import org.gephi.viz.engine.structure.GraphIndexImpl;
+import org.lwjgl.system.MemoryStack;
+
+import java.nio.FloatBuffer;
+import java.util.Optional;
+
 import static org.gephi.viz.engine.util.gl.Constants.*;
 import static org.lwjgl.opengl.GL11.GL_FLOAT;
-import static org.lwjgl.opengl.GL20.glGenBuffers;
-import static org.lwjgl.opengl.GL20.glVertexAttrib1f;
-import static org.lwjgl.opengl.GL20.glVertexAttrib4f;
-import static org.lwjgl.opengl.GL20.glVertexAttrib2fv;
-import org.lwjgl.system.MemoryStack;
+import static org.lwjgl.opengl.GL20.*;
 
 /**
  *
@@ -75,6 +75,9 @@ public void update(VizEngine engine, GraphIndexImpl spatialIndex) {
     }
 
     public void drawArrays(RenderingLayer layer, VizEngine engine, float[] mvpFloats) {
+        float globalTime = engine.getGlobalTime();
+        Optional<Float> selectedTime = engine.getSelectedTime();
+
         final float[] backgroundColorFloats = engine.getBackgroundColor();
         final float zoom = engine.getZoom();
 
@@ -94,7 +97,7 @@ public void drawArrays(RenderingLayer layer, VizEngine engine, float[] mvpFloats
 
         if (instanceCount > 0) {
             setupVertexArrayAttributes(engine);
-            diskModel64.useProgram(mvpFloats, backgroundColorFloats, colorLightenFactor);
+            diskModel64.useProgram(mvpFloats, backgroundColorFloats, colorLightenFactor, globalTime, selectedTime);
 
             final float[] attrs = new float[ATTRIBS_STRIDE];
             int index = instancesOffset * ATTRIBS_STRIDE;
diff --git a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/indirect/IndirectNodeData.java b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/indirect/IndirectNodeData.java
index 8654c6e..82d2070 100644
--- a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/indirect/IndirectNodeData.java
+++ b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/indirect/IndirectNodeData.java
@@ -1,27 +1,30 @@
 package org.gephi.viz.engine.lwjgl.pipeline.indirect;
 
-import java.nio.FloatBuffer;
-import java.nio.IntBuffer;
 import org.gephi.graph.api.Node;
 import org.gephi.viz.engine.VizEngine;
 import org.gephi.viz.engine.lwjgl.models.NodeDiskModel;
-import org.gephi.viz.engine.pipeline.RenderingLayer;
 import org.gephi.viz.engine.lwjgl.pipeline.common.AbstractNodeData;
 import org.gephi.viz.engine.lwjgl.util.gl.GLBuffer;
 import org.gephi.viz.engine.lwjgl.util.gl.GLBufferImmutable;
+import org.gephi.viz.engine.lwjgl.util.gl.GLBufferMutable;
+import org.gephi.viz.engine.lwjgl.util.gl.ManagedDirectBuffer;
+import org.gephi.viz.engine.pipeline.RenderingLayer;
 import org.gephi.viz.engine.pipeline.common.InstanceCounter;
 import org.gephi.viz.engine.status.GraphRenderingOptions;
 import org.gephi.viz.engine.status.GraphSelection;
 import org.gephi.viz.engine.status.GraphSelectionNeighbours;
 import org.gephi.viz.engine.structure.GraphIndexImpl;
-import org.gephi.viz.engine.lwjgl.util.gl.GLBufferMutable;
-import static org.gephi.viz.engine.util.gl.GLConstants.INDIRECT_DRAW_COMMAND_INTS_COUNT;
-import org.gephi.viz.engine.lwjgl.util.gl.ManagedDirectBuffer;
+import org.lwjgl.system.MemoryStack;
+
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+import java.util.Optional;
+
 import static org.gephi.viz.engine.util.gl.GLConstants.INDIRECT_DRAW_COMMAND_BYTES;
+import static org.gephi.viz.engine.util.gl.GLConstants.INDIRECT_DRAW_COMMAND_INTS_COUNT;
 import static org.lwjgl.opengl.GL11.GL_FLOAT;
 import static org.lwjgl.opengl.GL11.GL_UNSIGNED_INT;
 import static org.lwjgl.opengl.GL20.glGenBuffers;
-import org.lwjgl.system.MemoryStack;
 
 /**
  *
@@ -85,6 +88,8 @@ public void update(VizEngine engine, GraphIndexImpl spatialIndex) {
     }
 
     public void drawIndirect(RenderingLayer layer, VizEngine engine, float[] mvpFloats) {
+        float globalTime = engine.getGlobalTime();
+        Optional<Float> selectedTime = engine.getSelectedTime();
         final float[] backgroundColorFloats = engine.getBackgroundColor();
 
         final int instanceCount;
@@ -105,7 +110,7 @@ public void drawIndirect(RenderingLayer layer, VizEngine engine, float[] mvpFloa
             setupVertexArrayAttributes(engine);
 
             commandsGLBuffer.bind();
-            diskModel64.drawIndirect(mvpFloats, backgroundColorFloats, colorLightenFactor, instanceCount, instancesOffset);
+            diskModel64.drawIndirect(mvpFloats, backgroundColorFloats, colorLightenFactor, instanceCount, instancesOffset, globalTime, selectedTime);
             commandsGLBuffer.unbind();
 
             unsetupVertexArrayAttributes();
diff --git a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/instanced/InstancedEdgeData.java b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/instanced/InstancedEdgeData.java
index 36f252e..c55b0bb 100644
--- a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/instanced/InstancedEdgeData.java
+++ b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/instanced/InstancedEdgeData.java
@@ -1,22 +1,25 @@
 package org.gephi.viz.engine.lwjgl.pipeline.instanced;
 
-import java.nio.FloatBuffer;
 import org.gephi.graph.api.Edge;
 import org.gephi.graph.api.Graph;
 import org.gephi.viz.engine.VizEngine;
-import org.gephi.viz.engine.pipeline.RenderingLayer;
-import org.gephi.viz.engine.status.GraphRenderingOptions;
-import org.gephi.viz.engine.status.GraphSelection;
-import org.gephi.viz.engine.structure.GraphIndex;
-import org.gephi.viz.engine.structure.GraphIndexImpl;
 import org.gephi.viz.engine.lwjgl.models.EdgeLineModelDirected;
 import org.gephi.viz.engine.lwjgl.models.EdgeLineModelUndirected;
 import org.gephi.viz.engine.lwjgl.pipeline.common.AbstractEdgeData;
 import org.gephi.viz.engine.lwjgl.util.gl.GLBufferMutable;
 import org.gephi.viz.engine.lwjgl.util.gl.ManagedDirectBuffer;
+import org.gephi.viz.engine.pipeline.RenderingLayer;
+import org.gephi.viz.engine.status.GraphRenderingOptions;
+import org.gephi.viz.engine.status.GraphSelection;
+import org.gephi.viz.engine.structure.GraphIndex;
+import org.gephi.viz.engine.structure.GraphIndexImpl;
+import org.lwjgl.system.MemoryStack;
+
+import java.nio.FloatBuffer;
+import java.util.Optional;
+
 import static org.lwjgl.opengl.GL11.GL_FLOAT;
 import static org.lwjgl.opengl.GL15.glGenBuffers;
-import org.lwjgl.system.MemoryStack;
 
 /**
  *
@@ -51,6 +54,9 @@ public void update(VizEngine engine, GraphIndexImpl graphIndex) {
     public void drawInstanced(RenderingLayer layer, VizEngine engine, float[] mvpFloats) {
         GraphRenderingOptions renderingOptions = engine.getLookup().lookup(GraphRenderingOptions.class);
 
+        float globalTime = engine.getGlobalTime();
+        Optional<Float> selectedTime = engine.getSelectedTime();
+
         final float[] backgroundColorFloats = engine.getBackgroundColor();
         final float edgeScale = renderingOptions.getEdgeScale();
         float lightenNonSelectedFactor = renderingOptions.getLightenNonSelectedFactor();
@@ -60,11 +66,11 @@ public void drawInstanced(RenderingLayer layer, VizEngine engine, float[] mvpFlo
         final float minWeight = graphIndex.getEdgesMinWeight();
         final float maxWeight = graphIndex.getEdgesMaxWeight();
 
-        drawUndirected(engine, layer, mvpFloats, backgroundColorFloats, lightenNonSelectedFactor, edgeScale, minWeight, maxWeight);
-        drawDirected(engine, layer, mvpFloats, backgroundColorFloats, lightenNonSelectedFactor, edgeScale, minWeight, maxWeight);
+        drawUndirected(engine, layer, mvpFloats, backgroundColorFloats, lightenNonSelectedFactor, edgeScale, minWeight, maxWeight, globalTime, selectedTime);
+        drawDirected(engine, layer, mvpFloats, backgroundColorFloats, lightenNonSelectedFactor, edgeScale, minWeight, maxWeight, globalTime, selectedTime);
     }
 
-    private void drawUndirected(VizEngine engine, RenderingLayer layer, float[] mvpFloats, float[] backgroundColorFloats, float lightenNonSelectedFactor, float edgeScale, float minWeight, float maxWeight) {
+    private void drawUndirected(VizEngine engine, RenderingLayer layer, float[] mvpFloats, float[] backgroundColorFloats, float lightenNonSelectedFactor, float edgeScale, float minWeight, float maxWeight, float globalTime, Optional<Float> selectedTime) {
         final int instanceCount;
         final int instancesOffset;
         final float colorLightenFactor;
@@ -81,12 +87,12 @@ private void drawUndirected(VizEngine engine, RenderingLayer layer, float[] mvpF
 
         if (instanceCount > 0) {
             setupUndirectedVertexArrayAttributes(engine);
-            lineModelUndirected.drawInstanced(mvpFloats, backgroundColorFloats, colorLightenFactor, instanceCount, instancesOffset, edgeScale, minWeight, maxWeight);
+            lineModelUndirected.drawInstanced(mvpFloats, backgroundColorFloats, colorLightenFactor, instanceCount, instancesOffset, edgeScale, minWeight, maxWeight, globalTime, selectedTime);
             unsetupUndirectedVertexArrayAttributes();
         }
     }
 
-    private void drawDirected(VizEngine engine, RenderingLayer layer, float[] mvpFloats, float[] backgroundColorFloats, float lightenNonSelectedFactor, float edgeScale, float minWeight, float maxWeight) {
+    private void drawDirected(VizEngine engine, RenderingLayer layer, float[] mvpFloats, float[] backgroundColorFloats, float lightenNonSelectedFactor, float edgeScale, float minWeight, float maxWeight, float globalTime, Optional<Float> selectedTime) {
         final int instanceCount;
         final int instancesOffset;
         final float colorLightenFactor;
@@ -103,7 +109,7 @@ private void drawDirected(VizEngine engine, RenderingLayer layer, float[] mvpFlo
 
         if (instanceCount > 0) {
             setupDirectedVertexArrayAttributes(engine);
-            lineModelDirected.drawInstanced(mvpFloats, backgroundColorFloats, colorLightenFactor, instanceCount, instancesOffset, edgeScale, minWeight, maxWeight);
+            lineModelDirected.drawInstanced(mvpFloats, backgroundColorFloats, colorLightenFactor, instanceCount, instancesOffset, edgeScale, minWeight, maxWeight, globalTime, selectedTime);
             unsetupDirectedVertexArrayAttributes();
         }
     }
diff --git a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/instanced/InstancedNodeData.java b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/instanced/InstancedNodeData.java
index 4ede59a..ede03b6 100644
--- a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/instanced/InstancedNodeData.java
+++ b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/instanced/InstancedNodeData.java
@@ -1,21 +1,24 @@
 package org.gephi.viz.engine.lwjgl.pipeline.instanced;
 
-import java.nio.FloatBuffer;
 import org.gephi.graph.api.Node;
 import org.gephi.viz.engine.VizEngine;
+import org.gephi.viz.engine.lwjgl.models.NodeDiskModel;
+import org.gephi.viz.engine.lwjgl.pipeline.common.AbstractNodeData;
+import org.gephi.viz.engine.lwjgl.util.gl.GLBufferMutable;
+import org.gephi.viz.engine.lwjgl.util.gl.ManagedDirectBuffer;
 import org.gephi.viz.engine.pipeline.RenderingLayer;
 import org.gephi.viz.engine.pipeline.common.InstanceCounter;
 import org.gephi.viz.engine.status.GraphRenderingOptions;
 import org.gephi.viz.engine.status.GraphSelection;
 import org.gephi.viz.engine.status.GraphSelectionNeighbours;
 import org.gephi.viz.engine.structure.GraphIndexImpl;
-import org.gephi.viz.engine.lwjgl.models.NodeDiskModel;
-import org.gephi.viz.engine.lwjgl.pipeline.common.AbstractNodeData;
-import org.gephi.viz.engine.lwjgl.util.gl.GLBufferMutable;
-import org.gephi.viz.engine.lwjgl.util.gl.ManagedDirectBuffer;
+import org.lwjgl.system.MemoryStack;
+
+import java.nio.FloatBuffer;
+import java.util.Optional;
+
 import static org.lwjgl.opengl.GL11.GL_FLOAT;
 import static org.lwjgl.opengl.GL20.glGenBuffers;
-import org.lwjgl.system.MemoryStack;
 
 /**
  *
@@ -73,6 +76,8 @@ public void update(VizEngine engine, GraphIndexImpl spatialIndex) {
     }
 
     public void drawInstanced(RenderingLayer layer, VizEngine engine, float[] mvpFloats) {
+        float globalTime = engine.getGlobalTime();
+        Optional<Float> selectedTime = engine.getSelectedTime();
         final float[] backgroundColorFloats = engine.getBackgroundColor();
         final float zoom = engine.getZoom();
 
@@ -110,7 +115,7 @@ public void drawInstanced(RenderingLayer layer, VizEngine engine, float[] mvpFlo
             }
 
             setupVertexArrayAttributes(engine);
-            diskModelToRender.drawInstanced(firstVertex, mvpFloats, backgroundColorFloats, colorLightenFactor, instanceCount, instancesOffset);
+            diskModelToRender.drawInstanced(firstVertex, mvpFloats, backgroundColorFloats, colorLightenFactor, instanceCount, instancesOffset, globalTime, selectedTime);
             unsetupVertexArrayAttributes();
         }
     }
diff --git a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/instanced/renderers/EdgeRendererInstanced.java b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/instanced/renderers/EdgeRendererInstanced.java
index e9af743..51426b1 100644
--- a/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/instanced/renderers/EdgeRendererInstanced.java
+++ b/modules/opengl-lwjgl/src/main/java/org/gephi/viz/engine/lwjgl/pipeline/instanced/renderers/EdgeRendererInstanced.java
@@ -1,15 +1,16 @@
 package org.gephi.viz.engine.lwjgl.pipeline.instanced.renderers;
 
-import java.util.EnumSet;
 import org.gephi.viz.engine.VizEngine;
 import org.gephi.viz.engine.lwjgl.LWJGLRenderingTarget;
-import org.gephi.viz.engine.pipeline.PipelineCategory;
-import org.gephi.viz.engine.pipeline.RenderingLayer;
 import org.gephi.viz.engine.lwjgl.availability.InstancedDraw;
 import org.gephi.viz.engine.lwjgl.pipeline.instanced.InstancedEdgeData;
+import org.gephi.viz.engine.pipeline.PipelineCategory;
+import org.gephi.viz.engine.pipeline.RenderingLayer;
 import org.gephi.viz.engine.spi.Renderer;
 import org.gephi.viz.engine.util.gl.Constants;
 
+import java.util.EnumSet;
+
 /**
  * TODO: self loops
  *