diff --git a/plugins/SimulationView/SimulationPass.py b/plugins/SimulationView/SimulationPass.py
index 2099f6c21d..efe80162b5 100644
--- a/plugins/SimulationView/SimulationPass.py
+++ b/plugins/SimulationView/SimulationPass.py
@@ -121,6 +121,7 @@ class SimulationPass(RenderPass):
         disabled_batch = RenderBatch(self._disabled_shader)
         head_position = None  # Indicates the current position of the print head
         nozzle_node = None
+        not_a_vector = Vector(math.nan, math.nan, math.nan)
 
         for node in DepthFirstIterator(self._scene.getRoot()):
 
@@ -143,6 +144,10 @@ class SimulationPass(RenderPass):
                 if self._layer_view.getCurrentLayer() > -1 and ((not self._layer_view._only_show_top_layers) or (not self._layer_view.getCompatibilityMode())):
                     start = 0
                     end = 0
+                    vertex_before_head = not_a_vector
+                    vertex_after_head = not_a_vector
+                    vertex_distance_ratio = 0.0
+                    towards_next_vertex = 0
                     element_counts = layer_data.getElementCounts()
                     for layer in sorted(element_counts.keys()):
                         # In the current layer, we show just the indicated paths
@@ -159,6 +164,8 @@ class SimulationPass(RenderPass):
                                 ratio = self._layer_view.getCurrentPath() - math.floor(self._layer_view.getCurrentPath())
                                 pos_a = Vector(polygon.data[index][0], polygon.data[index][1],
                                                polygon.data[index][2])
+                                vertex_before_head = pos_a
+                                vertex_distance_ratio = ratio
                                 if ratio <= 0.0001 or index + 1 == len(polygon.data):
                                     # in case there multiple polygons and polygon changes, the first point has the same value as the last point in the previous polygon
                                     head_position = pos_a + node.getWorldPosition()
@@ -168,6 +175,8 @@ class SimulationPass(RenderPass):
                                                    polygon.data[index + 1][2])
                                     vec = pos_a * (1.0 - ratio) + pos_b * ratio
                                     head_position = vec + node.getWorldPosition()
+                                    vertex_after_head = pos_b
+                                    towards_next_vertex = 2  # Add two to the index to print the current and next vertices as an 'unfinished' line (to the nozzle).
                                 break
                             break
                         if self._layer_view.getMinimumLayer() > layer:
@@ -187,6 +196,11 @@ class SimulationPass(RenderPass):
                         self._current_shader = self._layer_shader
                         self._switching_layers = True
 
+                    # reset 'last vertex'
+                    self._layer_shader.setUniformValue("u_last_vertex", not_a_vector)
+                    self._layer_shader.setUniformValue("u_next_vertex", not_a_vector)
+                    self._layer_shader.setUniformValue("u_last_line_ratio", 1.0)
+
                     # The first line does not have a previous line: add a MoveCombingType in front for start detection
                     # this way the first start of the layer can also be drawn
                     prev_line_types = numpy.concatenate([numpy.asarray([LayerPolygon.MoveCombingType], dtype = numpy.float32), layer_data._attributes["line_types"]["value"]])
@@ -203,6 +217,17 @@ class SimulationPass(RenderPass):
                     current_layer_batch.addItem(node.getWorldTransformation(), layer_data)
                     current_layer_batch.render(self._scene.getActiveCamera())
 
+                    # Last line may be partial
+                    if vertex_after_head != not_a_vector and vertex_after_head != not_a_vector:
+                        self._layer_shader.setUniformValue("u_last_vertex", vertex_before_head)
+                        self._layer_shader.setUniformValue("u_next_vertex", vertex_after_head)
+                        self._layer_shader.setUniformValue("u_last_line_ratio", vertex_distance_ratio)
+                        last_line_start = current_layer_end
+                        last_line_end = current_layer_end + towards_next_vertex
+                        last_line_batch = RenderBatch(self._layer_shader, type = RenderBatch.RenderType.Solid, mode=RenderBatch.RenderMode.Lines, range = (last_line_start, last_line_end))
+                        last_line_batch.addItem(node.getWorldTransformation(), layer_data)
+                        last_line_batch.render(self._scene.getActiveCamera())
+
                     self._old_current_layer = self._layer_view.getCurrentLayer()
                     self._old_current_path = self._layer_view.getCurrentPath()
 
diff --git a/plugins/SimulationView/layers3d.shader b/plugins/SimulationView/layers3d.shader
index b43d998690..508126e163 100644
--- a/plugins/SimulationView/layers3d.shader
+++ b/plugins/SimulationView/layers3d.shader
@@ -19,6 +19,10 @@ vertex41core =
 
     uniform highp mat4 u_normalMatrix;
 
+    uniform vec3 u_last_vertex;
+    uniform vec3 u_next_vertex;
+    uniform float u_last_line_ratio;
+
     in highp vec4 a_vertex;
     in lowp vec4 a_color;
     in lowp vec4 a_material_color;
@@ -134,6 +138,10 @@ vertex41core =
     void main()
     {
         vec4 v1_vertex = a_vertex;
+        if (v1_vertex.xyz == u_next_vertex)
+        {
+            v1_vertex.xyz = mix(u_last_vertex, u_next_vertex, u_last_line_ratio);
+        }
         v1_vertex.y -= a_line_dim.y / 2;  // half layer down
 
         vec4 world_space_vert = u_modelMatrix * v1_vertex;
@@ -427,6 +435,10 @@ u_max_feedrate = 1
 u_min_thickness = 0
 u_max_thickness = 1
 
+u_last_vertex = [0.0, 0.0, 0.0]
+u_next_vertex = [0.0, 0.0, 0.0]
+u_last_line_ratio = 1.0
+
 [bindings]
 u_modelMatrix = model_matrix
 u_viewMatrix = view_matrix