diff --git a/src/libslic3r/Technologies.hpp b/src/libslic3r/Technologies.hpp
index 6132430f1..fd7609e77 100644
--- a/src/libslic3r/Technologies.hpp
+++ b/src/libslic3r/Technologies.hpp
@@ -57,4 +57,13 @@
 #define ENABLE_SAVE_COMMANDS_ALWAYS_ENABLED (1 && ENABLE_2_4_0_ALPHA0)
 
 
+//====================
+// 2.4.0.alpha2 techs
+//====================
+#define ENABLE_2_4_0_ALPHA2 1
+
+// Enable coloring of toolpaths in preview by layer time
+#define ENABLE_PREVIEW_LAYER_TIME (1 && ENABLE_2_4_0_ALPHA2)
+
+
 #endif // _prusaslicer_technologies_h_
diff --git a/src/libslic3r/Utils.hpp b/src/libslic3r/Utils.hpp
index a01e63166..d4f53013f 100644
--- a/src/libslic3r/Utils.hpp
+++ b/src/libslic3r/Utils.hpp
@@ -6,6 +6,7 @@
 #include <functional>
 #include <type_traits>
 #include <system_error>
+#include <cmath>
 
 #include <boost/system/error_code.hpp>
 
@@ -343,7 +344,7 @@ inline std::string get_time_dhms(float time_in_secs)
     else if (minutes > 0)
         ::sprintf(buffer, "%dm %ds", minutes, (int)time_in_secs);
     else
-        ::sprintf(buffer, "%ds", (int)time_in_secs);
+        ::sprintf(buffer, "%ds", (int)std::round(time_in_secs));
 
     return buffer;
 }
diff --git a/src/slic3r/GUI/GCodeViewer.cpp b/src/slic3r/GUI/GCodeViewer.cpp
index 656a67406..d909f8ac2 100644
--- a/src/slic3r/GUI/GCodeViewer.cpp
+++ b/src/slic3r/GUI/GCodeViewer.cpp
@@ -730,6 +730,18 @@ void GCodeViewer::refresh(const GCodeProcessor::Result& gcode_result, const std:
         }
     }
 
+#if ENABLE_PREVIEW_LAYER_TIME
+    for (size_t i = 0; i < gcode_result.print_statistics.modes.size(); ++i) {
+        m_layers_times[i] = gcode_result.print_statistics.modes[i].layers_times;
+    }
+
+    for (size_t i = 0; i < m_layers_times.size(); ++i) {
+        for (float time : m_layers_times[i]) {
+            m_extrusions.ranges.layer_time[i].update_from(time);
+        }
+    }
+#endif // ENABLE_PREVIEW_LAYER_TIME
+
 #if ENABLE_GCODE_VIEWER_STATISTICS
     m_statistics.refresh_time = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - start_time).count();
 #endif // ENABLE_GCODE_VIEWER_STATISTICS
@@ -771,6 +783,11 @@ void GCodeViewer::reset()
     m_layers_z_range = { 0, 0 };
     m_roles = std::vector<ExtrusionRole>();
     m_print_statistics.reset();
+#if ENABLE_PREVIEW_LAYER_TIME
+    for (size_t i = 0; i < static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count); ++i) {
+        m_layers_times[i] = std::vector<float>();
+    }
+#endif // ENABLE_PREVIEW_LAYER_TIME
 #if ENABLE_FIX_IMPORTING_COLOR_PRINT_VIEW_INTO_GCODEVIEWER
     m_custom_gcode_per_print_z = std::vector<CustomGCode::Item>();
 #endif // ENABLE_FIX_IMPORTING_COLOR_PRINT_VIEW_INTO_GCODEVIEWER
@@ -1965,7 +1982,7 @@ void GCodeViewer::load_toolpaths(const GCodeProcessor::Result& gcode_result)
             if (last_z == nullptr || z < *last_z - EPSILON || *last_z + EPSILON < z)
                 m_layers.append(z, { last_travel_s_id, i });
             else
-                m_layers.get_endpoints().back().last = i;
+                m_layers.get_ranges().back().last = i;
             // extruder ids
             m_extruder_ids.emplace_back(move.extruder_id);
             // roles
@@ -1974,7 +1991,7 @@ void GCodeViewer::load_toolpaths(const GCodeProcessor::Result& gcode_result)
         }
         else if (move.type == EMoveType::Travel) {
             if (i - last_travel_s_id > 1 && !m_layers.empty())
-                m_layers.get_endpoints().back().last = i;
+                m_layers.get_ranges().back().last = i;
 
             last_travel_s_id = i;
         }
@@ -2082,6 +2099,24 @@ void GCodeViewer::refresh_render_paths(bool keep_sequential_current_first, bool
         case EViewType::Feedrate:       { color = m_extrusions.ranges.feedrate.get_color_at(path.feedrate); break; }
         case EViewType::FanSpeed:       { color = m_extrusions.ranges.fan_speed.get_color_at(path.fan_speed); break; }
         case EViewType::Temperature:    { color = m_extrusions.ranges.temperature.get_color_at(path.temperature); break; }
+#if ENABLE_PREVIEW_LAYER_TIME
+        case EViewType::LayerTime: {
+            const Path::Sub_Path& sub_path = path.sub_paths.front();
+            double z = static_cast<double>(sub_path.first.position.z());
+            const std::vector<double>& zs = m_layers.get_zs();
+            const std::vector<Layers::Range>& ranges = m_layers.get_ranges();
+            size_t time_mode_id = static_cast<size_t>(m_time_estimate_mode);
+            for (size_t i = 0; i < zs.size(); ++i) {
+                if (std::abs(zs[i] - z) < EPSILON) {
+                    if (ranges[i].contains(sub_path.first.s_id)) {
+                        color = m_extrusions.ranges.layer_time[time_mode_id].get_color_at(m_layers_times[time_mode_id][i]);
+                        break;
+                    }
+                }
+            }
+            break;
+        }
+#endif // ENABLE_PREVIEW_LAYER_TIME
         case EViewType::VolumetricRate: { color = m_extrusions.ranges.volumetric_rate.get_color_at(path.volumetric_rate); break; }
         case EViewType::Tool:           { color = m_tool_colors[path.extruder_id]; break; }
         case EViewType::ColorPrint:     {
@@ -2106,7 +2141,7 @@ void GCodeViewer::refresh_render_paths(bool keep_sequential_current_first, bool
 
     auto is_in_layers_range = [this](const Path& path, size_t min_id, size_t max_id) {
         auto in_layers_range = [this, min_id, max_id](size_t id) {
-            return m_layers.get_endpoints_at(min_id).first <= id && id <= m_layers.get_endpoints_at(max_id).last;
+            return m_layers.get_range_at(min_id).first <= id && id <= m_layers.get_range_at(max_id).last;
         };
 
         return in_layers_range(path.sub_paths.front().first.s_id) || in_layers_range(path.sub_paths.back().last.s_id);
@@ -2131,8 +2166,8 @@ void GCodeViewer::refresh_render_paths(bool keep_sequential_current_first, bool
             path.sub_paths.back().last = buffer.paths[last].sub_paths.back().last;
         }
 
-        const size_t min_s_id = m_layers.get_endpoints_at(min_id).first;
-        const size_t max_s_id = m_layers.get_endpoints_at(max_id).last;
+        const size_t min_s_id = m_layers.get_range_at(min_id).first;
+        const size_t max_s_id = m_layers.get_range_at(max_id).last;
 
         return (min_s_id <= path.sub_paths.front().first.s_id && path.sub_paths.front().first.s_id <= max_s_id) ||
             (min_s_id <= path.sub_paths.back().last.s_id && path.sub_paths.back().last.s_id <= max_s_id);
@@ -2167,14 +2202,14 @@ void GCodeViewer::refresh_render_paths(bool keep_sequential_current_first, bool
 #if ENABLE_SEAMS_USING_MODELS
         if (buffer.render_primitive_type == TBuffer::ERenderPrimitiveType::Model) {
             for (size_t id : buffer.model.instances.s_ids) {
-                if (id < m_layers.get_endpoints_at(m_layers_z_range[0]).first || m_layers.get_endpoints_at(m_layers_z_range[1]).last < id)
+                if (id < m_layers.get_range_at(m_layers_z_range[0]).first || m_layers.get_range_at(m_layers_z_range[1]).last < id)
                     continue;
 
                 global_endpoints.first = std::min(global_endpoints.first, id);
                 global_endpoints.last = std::max(global_endpoints.last, id);
 
                 if (top_layer_only) {
-                    if (id < m_layers.get_endpoints_at(m_layers_z_range[1]).first || m_layers.get_endpoints_at(m_layers_z_range[1]).last < id)
+                    if (id < m_layers.get_range_at(m_layers_z_range[1]).first || m_layers.get_range_at(m_layers_z_range[1]).last < id)
                         continue;
 
                     top_layer_endpoints.first = std::min(top_layer_endpoints.first, id);
@@ -2847,8 +2882,13 @@ void GCodeViewer::render_legend(float& legend_height)
     };
 
     const PrintEstimatedStatistics::Mode& time_mode = m_print_statistics.modes[static_cast<size_t>(m_time_estimate_mode)];
+#if ENABLE_PREVIEW_LAYER_TIME
+    bool show_estimated_time = time_mode.time > 0.0f && (m_view_type == EViewType::FeatureType || m_view_type == EViewType::LayerTime ||
+        (m_view_type == EViewType::ColorPrint && !time_mode.custom_gcode_times.empty()));
+#else
     bool show_estimated_time = time_mode.time > 0.0f && (m_view_type == EViewType::FeatureType ||
         (m_view_type == EViewType::ColorPrint && !time_mode.custom_gcode_times.empty()));
+#endif // ENABLE_PREVIEW_LAYER_TIME
 
     const float icon_size = ImGui::GetTextLineHeight();
     const float percent_bar_size = 2.0f * ImGui::GetTextLineHeight();
@@ -2971,6 +3011,7 @@ void GCodeViewer::render_legend(float& legend_height)
             // single item use case
             append_range_item(0, range.min, decimals);
         else if (range.count == 2) {
+            // two items use case
             append_range_item(static_cast<int>(Range_Colors.size()) - 1, range.max, decimals);
             append_range_item(0, range.min, decimals);
         }
@@ -2982,6 +3023,29 @@ void GCodeViewer::render_legend(float& legend_height)
         }
     };
 
+#if ENABLE_PREVIEW_LAYER_TIME
+    auto append_time_range = [append_item](const Extrusions::Range& range) {
+        auto append_range_item = [append_item](int i, float value) {
+            append_item(EItemType::Rect, Range_Colors[i], get_time_dhms(value));
+        };
+
+        if (range.count == 1)
+            // single item use case
+            append_range_item(0, range.min);
+        else if (range.count == 2) {
+            // two items use case
+            append_range_item(static_cast<int>(Range_Colors.size()) - 1, range.max);
+            append_range_item(0, range.min);
+        }
+        else {
+            const float step_size = range.step_size();
+            for (int i = static_cast<int>(Range_Colors.size()) - 1; i >= 0; --i) {
+                append_range_item(i, range.min + static_cast<float>(i) * step_size);
+            }
+        }
+    };
+#endif // ENABLE_PREVIEW_LAYER_TIME
+
     auto append_headers = [&imgui](const std::array<std::string, 5>& texts, const std::array<float, 4>& offsets) {
         size_t i = 0;
         for (; i < offsets.size(); i++) {
@@ -3163,8 +3227,10 @@ void GCodeViewer::render_legend(float& legend_height)
     case EViewType::FanSpeed:       { imgui.title(_u8L("Fan Speed (%)")); break; }
     case EViewType::Temperature:    { imgui.title(_u8L("Temperature (°C)")); break; }
     case EViewType::VolumetricRate: { imgui.title(_u8L("Volumetric flow rate (mm³/s)")); break; }
-    case EViewType::Tool:
-    {
+#if ENABLE_PREVIEW_LAYER_TIME
+    case EViewType::LayerTime:      { imgui.title(_u8L("Layer time")); break; }
+#endif // ENABLE_PREVIEW_LAYER_TIME
+    case EViewType::Tool:           {
         append_headers({ _u8L("Tool"), _u8L("Used filament") }, offsets);
         break;
     }
@@ -3186,7 +3252,7 @@ void GCodeViewer::render_legend(float& legend_height)
                 visible, times[i], percents[i], max_percent, offsets, used_filaments_m[i], used_filaments_g[i], [this, role, visible]() {
                     m_extrusions.role_visibility_flags = visible ? m_extrusions.role_visibility_flags & ~(1 << role) : m_extrusions.role_visibility_flags | (1 << role);
                     // update buffers' render paths
-                    refresh_render_paths(false, false);
+                    refresh_render_paths();
                     wxGetApp().plater()->update_preview_moves_slider();
                     wxGetApp().plater()->get_current_canvas3D()->set_as_dirty();
                     wxGetApp().plater()->update_preview_bottom_toolbar();
@@ -3201,8 +3267,10 @@ void GCodeViewer::render_legend(float& legend_height)
     case EViewType::FanSpeed:       { append_range(m_extrusions.ranges.fan_speed, 0); break; }
     case EViewType::Temperature:    { append_range(m_extrusions.ranges.temperature, 0); break; }
     case EViewType::VolumetricRate: { append_range(m_extrusions.ranges.volumetric_rate, 3); break; }
-    case EViewType::Tool:
-    {
+#if ENABLE_PREVIEW_LAYER_TIME
+    case EViewType::LayerTime:      { append_time_range(m_extrusions.ranges.layer_time[static_cast<size_t>(m_time_estimate_mode)]); break; }
+#endif // ENABLE_PREVIEW_LAYER_TIME
+    case EViewType::Tool:           {
         // shows only extruders actually used
         size_t i = 0;
         for (unsigned char extruder_id : m_extruder_ids) {
@@ -3212,8 +3280,7 @@ void GCodeViewer::render_legend(float& legend_height)
         }
         break;
     }
-    case EViewType::ColorPrint:
-    {
+    case EViewType::ColorPrint:     {
 #if ENABLE_FIX_IMPORTING_COLOR_PRINT_VIEW_INTO_GCODEVIEWER
         const std::vector<CustomGCode::Item>& custom_gcode_per_print_z = wxGetApp().is_editor() ? wxGetApp().plater()->model().custom_gcode_per_print_z.gcodes : m_custom_gcode_per_print_z;
 #else
@@ -3626,7 +3693,7 @@ void GCodeViewer::render_legend(float& legend_height)
         if (can_show_mode_button(m_time_estimate_mode)) {
             switch (m_time_estimate_mode)
             {
-            case PrintEstimatedStatistics::ETimeMode::Normal: { time_title += " [" + _u8L("Normal mode") + "]"; break; }
+            case PrintEstimatedStatistics::ETimeMode::Normal:  { time_title += " [" + _u8L("Normal mode") + "]"; break; }
             case PrintEstimatedStatistics::ETimeMode::Stealth: { time_title += " [" + _u8L("Stealth mode") + "]"; break; }
             default: { assert(false); break; }
             }
@@ -3657,6 +3724,10 @@ void GCodeViewer::render_legend(float& legend_height)
             if (can_show_mode_button(mode)) {
                 if (imgui.button(label)) {
                     m_time_estimate_mode = mode;
+#if ENABLE_PREVIEW_LAYER_TIME
+                    if (m_view_type == EViewType::LayerTime)
+                        refresh_render_paths();
+#endif // ENABLE_PREVIEW_LAYER_TIME
                     wxGetApp().plater()->get_current_canvas3D()->set_as_dirty();
                     wxGetApp().plater()->get_current_canvas3D()->request_extra_frame();
                 }
@@ -3803,7 +3874,7 @@ void GCodeViewer::log_memory_used(const std::string& label, int64_t additional)
             }
         }
         int64_t layers_size = SLIC3R_STDVEC_MEMSIZE(m_layers.get_zs(), double);
-        layers_size += SLIC3R_STDVEC_MEMSIZE(m_layers.get_endpoints(), Layers::Endpoints);
+        layers_size += SLIC3R_STDVEC_MEMSIZE(m_layers.get_ranges(), Layers::Range);
         BOOST_LOG_TRIVIAL(trace) << label
             << "(" << format_memsize_MB(additional + paths_size + render_paths_size + layers_size) << ");"
             << log_memory_info();
diff --git a/src/slic3r/GUI/GCodeViewer.hpp b/src/slic3r/GUI/GCodeViewer.hpp
index 429175fe6..73bdb0ac0 100644
--- a/src/slic3r/GUI/GCodeViewer.hpp
+++ b/src/slic3r/GUI/GCodeViewer.hpp
@@ -417,6 +417,10 @@ class GCodeViewer
             Range volumetric_rate;
             // Color mapping by extrusion temperature.
             Range temperature;
+#if ENABLE_PREVIEW_LAYER_TIME
+            // Color mapping by layer time.
+            std::array<Range, static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count)> layer_time;
+#endif // ENABLE_PREVIEW_LAYER_TIME
 
             void reset() {
                 height.reset();
@@ -425,6 +429,11 @@ class GCodeViewer
                 fan_speed.reset();
                 volumetric_rate.reset();
                 temperature.reset();
+#if ENABLE_PREVIEW_LAYER_TIME
+                for (auto& range : layer_time) {
+                    range.reset();
+                }
+#endif // ENABLE_PREVIEW_LAYER_TIME
             }
         };
 
@@ -444,43 +453,42 @@ class GCodeViewer
     class Layers
     {
     public:
-        struct Endpoints
+        struct Range
         {
             size_t first{ 0 };
             size_t last{ 0 };
 
-            bool operator == (const Endpoints& other) const {
-                return first == other.first && last == other.last;
-            }
+            bool operator == (const Range& other) const { return first == other.first && last == other.last; }
+            bool contains(size_t id) const { return first <= id && id <= last; }
         };
 
     private:
         std::vector<double> m_zs;
-        std::vector<Endpoints> m_endpoints;
+        std::vector<Range> m_ranges;
 
     public:
-        void append(double z, Endpoints endpoints) {
+        void append(double z, const Range& range) {
             m_zs.emplace_back(z);
-            m_endpoints.emplace_back(endpoints);
+            m_ranges.emplace_back(range);
         }
 
         void reset() {
             m_zs = std::vector<double>();
-            m_endpoints = std::vector<Endpoints>();
+            m_ranges = std::vector<Range>();
         }
 
         size_t size() const { return m_zs.size(); }
         bool empty() const { return m_zs.empty(); }
         const std::vector<double>& get_zs() const { return m_zs; }
-        const std::vector<Endpoints>& get_endpoints() const { return m_endpoints; }
-        std::vector<Endpoints>& get_endpoints() { return m_endpoints; }
+        const std::vector<Range>& get_ranges() const { return m_ranges; }
+        std::vector<Range>& get_ranges() { return m_ranges; }
         double get_z_at(unsigned int id) const { return (id < m_zs.size()) ? m_zs[id] : 0.0; }
-        Endpoints get_endpoints_at(unsigned int id) const { return (id < m_endpoints.size()) ? m_endpoints[id] : Endpoints(); }
+        Range get_range_at(unsigned int id) const { return (id < m_ranges.size()) ? m_ranges[id] : Range(); }
 
         bool operator != (const Layers& other) const {
             if (m_zs != other.m_zs)
                 return true;
-            if (!(m_endpoints == other.m_endpoints))
+            if (!(m_ranges == other.m_ranges))
                 return true;
 
             return false;
@@ -692,6 +700,9 @@ public:
         FanSpeed,
         Temperature,
         VolumetricRate,
+#if ENABLE_PREVIEW_LAYER_TIME
+        LayerTime,
+#endif // ENABLE_PREVIEW_LAYER_TIME
         Tool,
         ColorPrint,
         Count
@@ -727,6 +738,9 @@ private:
     std::array<float, 2> m_detected_point_sizes = { 0.0f, 0.0f };
     GCodeProcessor::Result::SettingsIds m_settings_ids;
     std::array<SequentialRangeCap, 2> m_sequential_range_caps;
+#if ENABLE_PREVIEW_LAYER_TIME
+    std::array<std::vector<float>, static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Count)> m_layers_times;
+#endif // ENABLE_PREVIEW_LAYER_TIME
 
 #if ENABLE_FIX_IMPORTING_COLOR_PRINT_VIEW_INTO_GCODEVIEWER
     std::vector<CustomGCode::Item> m_custom_gcode_per_print_z;
diff --git a/src/slic3r/GUI/GUI_Preview.cpp b/src/slic3r/GUI/GUI_Preview.cpp
index 8c10fb157..231fa9206 100644
--- a/src/slic3r/GUI/GUI_Preview.cpp
+++ b/src/slic3r/GUI/GUI_Preview.cpp
@@ -225,6 +225,9 @@ bool Preview::init(wxWindow* parent, Model* model)
     m_choice_view_type->Append(_L("Fan speed"));
     m_choice_view_type->Append(_L("Temperature"));
     m_choice_view_type->Append(_L("Volumetric flow rate"));
+#if ENABLE_PREVIEW_LAYER_TIME
+    m_choice_view_type->Append(_L("Layer time"));
+#endif // ENABLE_PREVIEW_LAYER_TIME
     m_choice_view_type->Append(_L("Tool"));
     m_choice_view_type->Append(_L("Color Print"));
     m_choice_view_type->SetSelection(0);