diff --git a/libs/ui/CMakeLists.txt b/libs/ui/CMakeLists.txt
index 344805c564..a387a7d8d9 100644
--- a/libs/ui/CMakeLists.txt
+++ b/libs/ui/CMakeLists.txt
@@ -1,590 +1,591 @@
 include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}/qtlockedfile
     ${EXIV2_INCLUDE_DIR}
 )
 
 include_directories(SYSTEM
     ${EIGEN3_INCLUDE_DIR}
     ${OCIO_INCLUDE_DIR}
 )
 
 add_subdirectory( tests )
 
 if (APPLE)
     find_library(FOUNDATION_LIBRARY Foundation)
     find_library(APPKIT_LIBRARY AppKit)
 endif ()
 
 set(kritaui_LIB_SRCS
     canvas/kis_canvas_widget_base.cpp
     canvas/kis_canvas2.cpp
     canvas/kis_canvas_updates_compressor.cpp
     canvas/kis_canvas_controller.cpp
     canvas/kis_paintop_transformation_connector.cpp
     canvas/kis_display_color_converter.cpp
     canvas/kis_display_filter.cpp
     canvas/kis_exposure_gamma_correction_interface.cpp
     canvas/kis_tool_proxy.cpp
     canvas/kis_canvas_decoration.cc
     canvas/kis_coordinates_converter.cpp
     canvas/kis_grid_manager.cpp
     canvas/kis_grid_decoration.cpp
     canvas/kis_grid_config.cpp
     canvas/kis_prescaled_projection.cpp
     canvas/kis_qpainter_canvas.cpp
     canvas/kis_projection_backend.cpp
     canvas/kis_update_info.cpp
     canvas/kis_image_patch.cpp
     canvas/kis_image_pyramid.cpp
     canvas/kis_infinity_manager.cpp
     canvas/kis_change_guides_command.cpp
     canvas/kis_guides_decoration.cpp
     canvas/kis_guides_manager.cpp
     canvas/kis_guides_config.cpp
     canvas/kis_snap_config.cpp
     canvas/kis_snap_line_strategy.cpp
     canvas/KisSnapPointStrategy.cpp
     dialogs/kis_about_application.cpp
     dialogs/kis_dlg_adj_layer_props.cc
     dialogs/kis_dlg_adjustment_layer.cc
     dialogs/kis_dlg_filter.cpp
     dialogs/kis_dlg_generator_layer.cpp
     dialogs/kis_dlg_file_layer.cpp
     dialogs/kis_dlg_filter.cpp
     dialogs/kis_dlg_stroke_selection_properties.cpp
     dialogs/kis_dlg_image_properties.cc
     dialogs/kis_dlg_layer_properties.cc
     dialogs/kis_dlg_preferences.cc
     dialogs/slider_and_spin_box_sync.cpp
     dialogs/kis_dlg_blacklist_cleanup.cpp
     dialogs/kis_dlg_layer_style.cpp
     dialogs/kis_dlg_png_import.cpp
     dialogs/kis_dlg_import_image_sequence.cpp
     dialogs/kis_delayed_save_dialog.cpp
     dialogs/kis_dlg_internal_color_selector.cpp
     dialogs/KisSessionManagerDialog.cpp
     dialogs/KisNewWindowLayoutDialog.cpp
     flake/kis_node_dummies_graph.cpp
     flake/kis_dummies_facade_base.cpp
     flake/kis_dummies_facade.cpp
     flake/kis_node_shapes_graph.cpp
     flake/kis_node_shape.cpp
     flake/kis_shape_controller.cpp
     flake/kis_shape_layer.cc
     flake/kis_shape_layer_canvas.cpp
     flake/kis_shape_selection.cpp
     flake/kis_shape_selection_canvas.cpp
     flake/kis_shape_selection_model.cpp
     flake/kis_take_all_shapes_command.cpp
     brushhud/kis_uniform_paintop_property_widget.cpp
     brushhud/kis_brush_hud.cpp
     brushhud/kis_round_hud_button.cpp
     brushhud/kis_dlg_brush_hud_config.cpp
     brushhud/kis_brush_hud_properties_list.cpp
     brushhud/kis_brush_hud_properties_config.cpp
     kis_aspect_ratio_locker.cpp
     kis_autogradient.cc
     kis_bookmarked_configurations_editor.cc
     kis_bookmarked_configurations_model.cc
     kis_bookmarked_filter_configurations_model.cc
     kis_base_option.cpp
     kis_canvas_resource_provider.cpp
     kis_derived_resources.cpp
     kis_categories_mapper.cpp
     kis_categorized_list_model.cpp
     kis_categorized_item_delegate.cpp
     kis_clipboard.cc
     kis_config.cc
     kis_config_notifier.cpp
     kis_control_frame.cpp
     kis_composite_ops_model.cc
     kis_paint_ops_model.cpp
     kis_cursor.cc
     kis_cursor_cache.cpp
     kis_custom_pattern.cc
     kis_file_layer.cpp
     kis_change_file_layer_command.h
     kis_safe_document_loader.cpp
     kis_splash_screen.cpp
     kis_filter_manager.cc
     kis_filters_model.cc
     kis_histogram_view.cc
     KisImageBarrierLockerWithFeedback.cpp
     kis_image_manager.cc
     kis_image_view_converter.cpp
     kis_import_catcher.cc
     kis_layer_manager.cc
     kis_mask_manager.cc
     kis_mimedata.cpp
     kis_node_commands_adapter.cpp
     kis_node_manager.cpp
     kis_node_juggler_compressed.cpp
     kis_node_selection_adapter.cpp
     kis_node_insertion_adapter.cpp
     kis_node_model.cpp
     kis_node_filter_proxy_model.cpp
     kis_model_index_converter_base.cpp
     kis_model_index_converter.cpp
     kis_model_index_converter_show_all.cpp
     kis_painting_assistant.cc
     kis_painting_assistants_decoration.cpp
     KisDecorationsManager.cpp
     kis_paintop_box.cc
     kis_paintop_option.cpp
     kis_paintop_options_model.cpp
     kis_paintop_settings_widget.cpp
     kis_popup_palette.cpp
     kis_png_converter.cpp
     kis_preference_set_registry.cpp
     KisResourceServerProvider.cpp
     KisResourceBundleServerProvider.cpp
     KisSelectedShapesProxy.cpp
     kis_selection_decoration.cc
     kis_selection_manager.cc
     kis_statusbar.cc
     kis_zoom_manager.cc
     kis_favorite_resource_manager.cpp
     kis_workspace_resource.cpp
     kis_action.cpp
     kis_action_manager.cpp
     KisActionPlugin.cpp
     kis_canvas_controls_manager.cpp
     kis_tooltip_manager.cpp
     kis_multinode_property.cpp
     kis_stopgradient_editor.cpp
     kisexiv2/kis_exif_io.cpp
     kisexiv2/kis_exiv2.cpp
     kisexiv2/kis_iptc_io.cpp
     kisexiv2/kis_xmp_io.cpp
     opengl/kis_opengl.cpp
     opengl/kis_opengl_canvas2.cpp
     opengl/kis_opengl_canvas_debugger.cpp
     opengl/kis_opengl_image_textures.cpp
     opengl/kis_texture_tile.cpp
     opengl/kis_opengl_shader_loader.cpp
     opengl/kis_texture_tile_info_pool.cpp
     kis_fps_decoration.cpp
     recorder/kis_node_query_path_editor.cc
     recorder/kis_recorded_action_creator.cc
     recorder/kis_recorded_action_creator_factory.cc
     recorder/kis_recorded_action_creator_factory_registry.cc
     recorder/kis_recorded_action_editor_factory.cc
     recorder/kis_recorded_action_editor_factory_registry.cc
     recorder/kis_recorded_filter_action_editor.cc
     recorder/kis_recorded_filter_action_creator.cpp
     recorder/kis_recorded_paint_action_editor.cc
     tool/kis_selection_tool_helper.cpp
     tool/kis_selection_tool_config_widget_helper.cpp
     tool/kis_rectangle_constraint_widget.cpp
     tool/kis_shape_tool_helper.cpp
     tool/kis_tool.cc
     tool/kis_delegated_tool_policies.cpp
     tool/kis_tool_freehand.cc
     tool/kis_speed_smoother.cpp
     tool/kis_painting_information_builder.cpp
     tool/kis_stabilized_events_sampler.cpp
     tool/kis_tool_freehand_helper.cpp
     tool/kis_tool_multihand_helper.cpp
     tool/kis_figure_painting_tool_helper.cpp
     tool/kis_recording_adapter.cpp
     tool/kis_tool_paint.cc
     tool/kis_tool_shape.cc
     tool/kis_tool_ellipse_base.cpp
     tool/kis_tool_rectangle_base.cpp
     tool/kis_tool_polyline_base.cpp
     tool/kis_tool_utils.cpp
     tool/kis_resources_snapshot.cpp
     tool/kis_smoothing_options.cpp
     tool/KisStabilizerDelayedPaintHelper.cpp
     tool/KisStrokeSpeedMonitor.cpp
     tool/strokes/freehand_stroke.cpp
     tool/strokes/KisStrokeEfficiencyMeasurer.cpp
     tool/strokes/kis_painter_based_stroke_strategy.cpp
     tool/strokes/kis_filter_stroke_strategy.cpp
     tool/strokes/kis_color_picker_stroke_strategy.cpp
     tool/strokes/KisFreehandStrokeInfo.cpp
     tool/strokes/KisMaskedFreehandStrokePainter.cpp
     tool/strokes/KisMaskingBrushRenderer.cpp
     tool/strokes/KisMaskingBrushCompositeOpFactory.cpp
 
     widgets/kis_cmb_composite.cc
     widgets/kis_cmb_contour.cpp
     widgets/kis_cmb_gradient.cpp
     widgets/kis_paintop_list_widget.cpp
     widgets/kis_cmb_idlist.cc
     widgets/kis_color_space_selector.cc
     widgets/kis_advanced_color_space_selector.cc
     widgets/kis_cie_tongue_widget.cpp
     widgets/kis_tone_curve_widget.cpp
     widgets/kis_curve_widget.cpp
     widgets/kis_custom_image_widget.cc
     widgets/kis_image_from_clipboard_widget.cpp
     widgets/kis_double_widget.cc
     widgets/kis_filter_selector_widget.cc
     widgets/kis_gradient_chooser.cc
     widgets/kis_iconwidget.cc
     widgets/kis_mask_widgets.cpp
     widgets/kis_meta_data_merge_strategy_chooser_widget.cc
     widgets/kis_multi_bool_filter_widget.cc
     widgets/kis_multi_double_filter_widget.cc
     widgets/kis_multi_integer_filter_widget.cc
     widgets/kis_multipliers_double_slider_spinbox.cpp
     widgets/kis_paintop_presets_popup.cpp
     widgets/kis_tool_options_popup.cpp
     widgets/kis_paintop_presets_chooser_popup.cpp
     widgets/kis_paintop_presets_save.cpp
     widgets/kis_paintop_preset_icon_library.cpp
     widgets/kis_pattern_chooser.cc
 
     widgets/kis_popup_button.cc
     widgets/kis_preset_chooser.cpp
     widgets/kis_progress_widget.cpp
     widgets/kis_selection_options.cc
     widgets/kis_scratch_pad.cpp
     widgets/kis_scratch_pad_event_filter.cpp
     widgets/kis_preset_selector_strip.cpp
     widgets/kis_slider_spin_box.cpp
     widgets/KisSelectionPropertySlider.cpp
     widgets/kis_size_group.cpp
     widgets/kis_size_group_p.cpp
     widgets/kis_wdg_generator.cpp
     widgets/kis_workspace_chooser.cpp
     widgets/kis_categorized_list_view.cpp
     widgets/kis_widget_chooser.cpp
     widgets/kis_tool_button.cpp
     widgets/kis_floating_message.cpp
     widgets/kis_lod_availability_widget.cpp
     widgets/kis_color_label_selector_widget.cpp
     widgets/kis_color_filter_combo.cpp
     widgets/kis_elided_label.cpp
     widgets/kis_stopgradient_slider_widget.cpp
     widgets/kis_spinbox_color_selector.cpp
     widgets/kis_screen_color_picker.cpp
     widgets/kis_preset_live_preview_view.cpp
     widgets/KoDualColorButton.cpp
     widgets/kis_color_input.cpp
     widgets/kis_color_button.cpp
     widgets/KisVisualColorSelector.cpp
     widgets/KisVisualColorSelectorShape.cpp
     widgets/KisVisualEllipticalSelectorShape.cpp
     widgets/KisVisualRectangleSelectorShape.cpp
     widgets/KisVisualTriangleSelectorShape.cpp
     widgets/KoStrokeConfigWidget.cpp
     widgets/KoFillConfigWidget.cpp
 
     widgets/KisLayoutSelector.cpp
 
 
     utils/kis_document_aware_spin_box_unit_manager.cpp
 
     input/kis_input_manager.cpp
     input/kis_input_manager_p.cpp
     input/kis_extended_modifiers_mapper.cpp
     input/kis_abstract_input_action.cpp
     input/kis_tool_invocation_action.cpp
     input/kis_pan_action.cpp
     input/kis_alternate_invocation_action.cpp
     input/kis_rotate_canvas_action.cpp
     input/kis_zoom_action.cpp
     input/kis_change_frame_action.cpp
     input/kis_gamma_exposure_action.cpp
     input/kis_show_palette_action.cpp
     input/kis_change_primary_setting_action.cpp
     input/kis_abstract_shortcut.cpp
     input/kis_native_gesture_shortcut.cpp
     input/kis_single_action_shortcut.cpp
     input/kis_stroke_shortcut.cpp
     input/kis_shortcut_matcher.cpp
     input/kis_select_layer_action.cpp
     input/KisQtWidgetsTweaker.cpp
     input/KisInputActionGroup.cpp
 
     operations/kis_operation.cpp
     operations/kis_operation_configuration.cpp
     operations/kis_operation_registry.cpp
     operations/kis_operation_ui_factory.cpp
     operations/kis_operation_ui_widget.cpp
     operations/kis_filter_selection_operation.cpp
     actions/kis_selection_action_factories.cpp
     actions/KisPasteActionFactory.cpp
     input/kis_touch_shortcut.cpp
     kis_document_undo_store.cpp
     kis_transaction_based_command.cpp
     kis_gui_context_command.cpp
     kis_gui_context_command_p.cpp
     input/kis_tablet_debugger.cpp
     input/kis_input_profile_manager.cpp
     input/kis_input_profile.cpp
     input/kis_shortcut_configuration.cpp
     input/config/kis_input_configuration_page.cpp
     input/config/kis_edit_profiles_dialog.cpp
     input/config/kis_input_profile_model.cpp
     input/config/kis_input_configuration_page_item.cpp
     input/config/kis_action_shortcuts_model.cpp
     input/config/kis_input_type_delegate.cpp
     input/config/kis_input_mode_delegate.cpp
     input/config/kis_input_button.cpp
     input/config/kis_input_editor_delegate.cpp
     input/config/kis_mouse_input_editor.cpp
     input/config/kis_wheel_input_editor.cpp
     input/config/kis_key_input_editor.cpp
     processing/fill_processing_visitor.cpp
     kis_asl_layer_style_serializer.cpp
     kis_psd_layer_style_resource.cpp
     canvas/kis_mirror_axis.cpp
 
     kis_abstract_perspective_grid.cpp
     
     KisApplication.cpp
     KisAutoSaveRecoveryDialog.cpp
     KisDetailsPane.cpp
     KisDocument.cpp
     KisNodeDelegate.cpp
     kis_node_view_visibility_delegate.cpp
     KisNodeToolTip.cpp
     KisNodeView.cpp
     kis_node_view_color_scheme.cpp
     KisImportExportFilter.cpp
     KisFilterEntry.cpp
     KisImportExportManager.cpp
     KisImportExportUtils.cpp
     kis_async_action_feedback.cpp
     KisMainWindow.cpp
     KisOpenPane.cpp
     KisPart.cpp
     KisPrintJob.cpp
     KisTemplate.cpp
     KisTemplateCreateDia.cpp
     KisTemplateGroup.cpp
     KisTemplates.cpp
     KisTemplatesPane.cpp
     KisTemplateTree.cpp
     KisUndoActionsUpdateManager.cpp
     KisView.cpp
 
     thememanager.cpp
 
     kis_mainwindow_observer.cpp
     KisViewManager.cpp
     kis_mirror_manager.cpp
 
     qtlockedfile/qtlockedfile.cpp
 
     qtsingleapplication/qtlocalpeer.cpp
     qtsingleapplication/qtsingleapplication.cpp
 
     KisResourceBundle.cpp
     KisResourceBundleManifest.cpp
 
     kis_md5_generator.cpp
     KisApplicationArguments.cpp
 
     KisNetworkAccessManager.cpp
     KisMultiFeedRSSModel.cpp
     KisRemoteFileFetcher.cpp
 
     KisPaletteModel.cpp
     kis_palette_delegate.cpp
     kis_palette_view.cpp
     KisColorsetChooser.cpp
     KisSaveGroupVisitor.cpp
     KisWindowLayoutResource.cpp
     KisWindowLayoutManager.cpp
     KisSessionResource.cpp
 
     KisReferenceImagesDecoration.cpp
     KisReferenceImage.cpp
     flake/KisReferenceImagesLayer.cpp
     flake/KisReferenceImagesLayer.h
 )
 
 if(WIN32)
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         input/kis_tablet_event.cpp
         input/wintab/kis_tablet_support_win.cpp
         input/wintab/kis_screen_size_choice_dialog.cpp
         qtlockedfile/qtlockedfile_win.cpp
         input/wintab/kis_tablet_support_win8.cpp
         opengl/kis_opengl_win.cpp
         )
 endif()
 
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         kis_animation_frame_cache.cpp
         kis_animation_cache_populator.cpp
         KisAsyncAnimationRendererBase.cpp
         KisAsyncAnimationCacheRenderer.cpp
         KisAsyncAnimationFramesSavingRenderer.cpp
         dialogs/KisAsyncAnimationRenderDialogBase.cpp
         dialogs/KisAsyncAnimationCacheRenderDialog.cpp
         dialogs/KisAsyncAnimationFramesSaveDialog.cpp
         canvas/kis_animation_player.cpp
         kis_animation_importer.cpp
         KisSyncedAudioPlayback.cpp
+        KisFrameDataSerializer.cpp
     )
 
 if(UNIX)
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         input/kis_tablet_event.cpp
         input/wintab/kis_tablet_support.cpp
         qtlockedfile/qtlockedfile_unix.cpp
         )
     if(NOT APPLE)
         set(kritaui_LIB_SRCS
             ${kritaui_LIB_SRCS}
             input/wintab/qxcbconnection_xi2.cpp
             input/wintab/qxcbconnection.cpp
             input/wintab/kis_xi2_event_filter.cpp
             )
     endif()
 endif()
 
 if(APPLE)
     set(kritaui_LIB_SRCS
         ${kritaui_LIB_SRCS}
         osx.mm
     )
 endif()
 
 ki18n_wrap_ui(kritaui_LIB_SRCS
     widgets/KoFillConfigWidget.ui
     widgets/KoStrokeConfigWidget.ui
     forms/wdgdlgpngimport.ui
     forms/wdgfullscreensettings.ui
     forms/wdgautogradient.ui
     forms/wdggeneralsettings.ui
     forms/wdgperformancesettings.ui
     forms/wdggenerators.ui
     forms/wdgbookmarkedconfigurationseditor.ui
     forms/wdgapplyprofile.ui
     forms/wdgcustompattern.ui
     forms/wdglayerproperties.ui
     forms/wdgcolorsettings.ui
     forms/wdgtabletsettings.ui
     forms/wdgcolorspaceselector.ui
     forms/wdgcolorspaceselectoradvanced.ui
     forms/wdgdisplaysettings.ui
     forms/kis_previewwidgetbase.ui
     forms/kis_matrix_widget.ui
     forms/wdgselectionoptions.ui
     forms/wdggeometryoptions.ui
     forms/wdgnewimage.ui
     forms/wdgimageproperties.ui
     forms/wdgmaskfromselection.ui
     forms/wdgmasksource.ui
     forms/wdgfilterdialog.ui
     forms/wdgmetadatamergestrategychooser.ui
     forms/wdgpaintoppresets.ui
     forms/wdgpaintopsettings.ui
     forms/wdgdlggeneratorlayer.ui
     forms/wdgdlgfilelayer.ui
     forms/wdgfilterselector.ui
     forms/wdgfilternodecreation.ui
     forms/wdgpaintactioneditor.ui
     forms/wdgmultipliersdoublesliderspinbox.ui
     forms/wdgnodequerypatheditor.ui
     forms/wdgpresetselectorstrip.ui
     forms/wdgsavebrushpreset.ui
     forms/wdgpreseticonlibrary.ui
     forms/wdgdlgblacklistcleanup.ui
     forms/wdgrectangleconstraints.ui
     forms/wdgimportimagesequence.ui
     forms/wdgstrokeselectionproperties.ui
     forms/KisDetailsPaneBase.ui
     forms/KisOpenPaneBase.ui
     forms/wdgstopgradienteditor.ui
     forms/wdgsessionmanager.ui
     forms/wdgnewwindowlayout.ui
     brushhud/kis_dlg_brush_hud_config.ui
     forms/wdgdlginternalcolorselector.ui
     dialogs/kis_delayed_save_dialog.ui
     input/config/kis_input_configuration_page.ui
     input/config/kis_edit_profiles_dialog.ui
     input/config/kis_input_configuration_page_item.ui
     input/config/kis_mouse_input_editor.ui
     input/config/kis_wheel_input_editor.ui
     input/config/kis_key_input_editor.ui
 
     layerstyles/wdgBevelAndEmboss.ui
     layerstyles/wdgblendingoptions.ui
     layerstyles/WdgColorOverlay.ui
     layerstyles/wdgContour.ui
     layerstyles/wdgdropshadow.ui
     layerstyles/WdgGradientOverlay.ui
     layerstyles/wdgInnerGlow.ui
     layerstyles/wdglayerstyles.ui
     layerstyles/WdgPatternOverlay.ui
     layerstyles/WdgSatin.ui
     layerstyles/WdgStroke.ui
     layerstyles/wdgstylesselector.ui
     layerstyles/wdgTexture.ui
 
     wdgsplash.ui
     input/wintab/kis_screen_size_choice_dialog.ui
 
 )
 
 
 QT5_WRAP_CPP(kritaui_HEADERS_MOC KisNodePropertyAction_p.h)
 
 add_library(kritaui SHARED ${kritaui_HEADERS_MOC} ${kritaui_LIB_SRCS} )
 generate_export_header(kritaui BASE_NAME kritaui)
 
 target_link_libraries(kritaui KF5::CoreAddons KF5::Completion KF5::I18n KF5::ItemViews Qt5::Network
                       kritaimpex kritacolor kritaimage kritalibbrush kritawidgets kritawidgetutils ${PNG_LIBRARIES} ${EXIV2_LIBRARIES}
 )
 
 if (HAVE_QT_MULTIMEDIA)
     target_link_libraries(kritaui Qt5::Multimedia)
 endif()
 
 if (HAVE_KIO)
     target_link_libraries(kritaui KF5::KIOCore)
 endif() 
 
 if (NOT WIN32 AND NOT APPLE)
   target_link_libraries(kritaui ${X11_X11_LIB}
                                 ${X11_Xinput_LIB}
                                 ${XCB_LIBRARIES})
 endif()
 
 if(APPLE)
     target_link_libraries(kritaui ${FOUNDATION_LIBRARY})
     target_link_libraries(kritaui ${APPKIT_LIBRARY})
 endif ()
 
 
 target_link_libraries(kritaui ${OPENEXR_LIBRARIES})
 
 # Add VSync disable workaround
 if(NOT WIN32 AND NOT APPLE)
     target_link_libraries(kritaui ${CMAKE_DL_LIBS} Qt5::X11Extras)
 endif()
 
 if(X11_FOUND)
     target_link_libraries(kritaui Qt5::X11Extras ${X11_LIBRARIES})
 endif()
 
 target_include_directories(kritaui
     PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/canvas>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/flake>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/ora>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/tool>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/utils>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/widgets>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/input/wintab>
 )
 
 set_target_properties(kritaui
     PROPERTIES VERSION ${GENERIC_KRITA_LIB_VERSION} SOVERSION ${GENERIC_KRITA_LIB_SOVERSION}
 )
 install(TARGETS kritaui  ${INSTALL_TARGETS_DEFAULT_ARGS})
 
 
 if (APPLE)
     install(FILES osx.stylesheet DESTINATION ${DATA_INSTALL_DIR}/krita)
 endif ()
diff --git a/libs/ui/KisFrameDataSerializer.cpp b/libs/ui/KisFrameDataSerializer.cpp
new file mode 100644
index 0000000000..485c60fefb
--- /dev/null
+++ b/libs/ui/KisFrameDataSerializer.cpp
@@ -0,0 +1,265 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+#include "KisFrameDataSerializer.h"
+
+#include <cstring>
+#include <QTemporaryDir>
+
+
+struct KisFrameDataSerializer::Private
+{
+    Private(const QString &frameCachePath, KisTextureTileInfoPoolSP _pool)
+        : framesDir(
+              (!frameCachePath.isEmpty() ? frameCachePath : QDir::tempPath()) +
+              QDir::separator() + "KritaFrameCacheXXXXXX"),
+          pool(_pool)
+    {
+        KIS_SAFE_ASSERT_RECOVER_NOOP(framesDir.isValid());
+        framesDirObject = QDir(framesDir.path());
+        framesDirObject.makeAbsolute();
+    }
+
+    QString subfolderNameForFrame(int frameId)
+    {
+        const int subfolderIndex = frameId & 0xff00;
+        return QString::number(subfolderIndex);
+    }
+
+    QString fileNameForFrame(int frameId) {
+        return QString("frame_%1").arg(frameId);
+    }
+
+    QString filePathForFrame(int frameId)
+    {
+        return framesDirObject.filePath(
+                    subfolderNameForFrame(frameId) + QDir::separator() +
+                    fileNameForFrame(frameId));
+    }
+
+    QTemporaryDir framesDir;
+    QDir framesDirObject;
+    KisTextureTileInfoPoolSP pool;
+};
+
+KisFrameDataSerializer::KisFrameDataSerializer(KisTextureTileInfoPoolSP pool)
+    : KisFrameDataSerializer(pool, QString())
+{
+}
+
+KisFrameDataSerializer::KisFrameDataSerializer(KisTextureTileInfoPoolSP pool, const QString &frameCachePath)
+    : m_d(new Private(frameCachePath, pool))
+{
+}
+
+KisFrameDataSerializer::~KisFrameDataSerializer()
+{
+}
+
+void KisFrameDataSerializer::saveFrame(const KisFrameDataSerializer::Frame &frame)
+{
+    const QString frameSubfolder = m_d->subfolderNameForFrame(frame.frameId);
+
+    if (!m_d->framesDirObject.exists(frameSubfolder)) {
+        m_d->framesDirObject.mkpath(frameSubfolder);
+    }
+
+    const QString frameRelativePath = frameSubfolder + QDir::separator() + m_d->fileNameForFrame(frame.frameId);
+
+    if (m_d->framesDirObject.exists(frameRelativePath)) {
+        qWarning() << "WARNING: overwriting existing frame file!" << frameRelativePath;
+        forgetFrame(frame.frameId);
+    }
+
+    const QString frameFilePath = m_d->framesDirObject.filePath(frameRelativePath);
+
+    QFile file(frameFilePath);
+    file.open(QFile::WriteOnly);
+
+    QDataStream stream(&file);
+    stream << frame.frameId;
+    stream << frame.pixelSize;
+
+    stream << int(frame.frameTiles.size());
+
+    for (int i = 0; i < int(frame.frameTiles.size()); i++) {
+        const FrameTile &tile = frame.frameTiles[i];
+
+        stream << tile.col;
+        stream << tile.row;
+        stream << tile.size.width();
+        stream << tile.size.height();
+
+        const int bufferSize = frame.pixelSize * tile.size.width() * tile.size.height();
+        stream.writeRawData((char*)tile.data.data(), bufferSize);
+    }
+
+    file.close();
+}
+
+KisFrameDataSerializer::Frame KisFrameDataSerializer::loadFrame(int frameId)
+{
+    KisFrameDataSerializer::Frame frame;
+
+    const QString framePath = m_d->filePathForFrame(frameId);
+
+    QFile file(framePath);
+    KIS_SAFE_ASSERT_RECOVER_NOOP(file.exists());
+    if (!file.open(QFile::ReadOnly)) return frame;
+
+    QDataStream stream(&file);
+
+    int numTiles = 0;
+
+    stream >> frame.frameId;
+    stream >> frame.pixelSize;
+    stream >> numTiles;
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(frame.frameId == frameId, KisFrameDataSerializer::Frame());
+
+    for (int i = 0; i < numTiles; i++) {
+        FrameTile tile(m_d->pool);
+        stream >> tile.col;
+        stream >> tile.row;
+        stream >> tile.size.rwidth();
+        stream >> tile.size.rheight();
+
+        const int bufferSize = frame.pixelSize * tile.size.width() * tile.size.height();
+        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(bufferSize <= m_d->pool->chunkSize(frame.pixelSize),
+                                             KisFrameDataSerializer::Frame());
+
+        tile.data.allocate(frame.pixelSize);
+        stream.readRawData((char*)tile.data.data(), bufferSize);
+
+        frame.frameTiles.push_back(std::move(tile));
+    }
+
+    file.close();
+
+    return frame;
+}
+
+bool KisFrameDataSerializer::hasFrame(int frameId) const
+{
+    const QString framePath = m_d->filePathForFrame(frameId);
+    return QFileInfo(framePath).exists();
+}
+
+void KisFrameDataSerializer::forgetFrame(int frameId)
+{
+    const QString framePath = m_d->filePathForFrame(frameId);
+    QFile::remove(framePath);
+}
+
+boost::optional<qreal> KisFrameDataSerializer::estimateFrameUniqueness(const KisFrameDataSerializer::Frame &lhs, const KisFrameDataSerializer::Frame &rhs, qreal portion)
+{
+    if (lhs.pixelSize != rhs.pixelSize) return boost::none;
+    if (lhs.frameTiles.size() != rhs.frameTiles.size()) return boost::none;
+
+    const int pixelSize = lhs.pixelSize;
+    int numSampledPixels = 0;
+    int numUniquePixels = 0;
+    const int sampleStep = portion > 0.0 ? qMax(1, qRound(1.0 / portion)) : 0;
+
+    for (int i = 0; i < int(lhs.frameTiles.size()); i++) {
+        const FrameTile &lhsTile = lhs.frameTiles[i];
+        const FrameTile &rhsTile = rhs.frameTiles[i];
+
+        if (lhsTile.col != rhsTile.col ||
+            lhsTile.row != rhsTile.row ||
+            lhsTile.size != rhsTile.size) {
+
+            return boost::none;
+        }
+
+        if (sampleStep > 0) {
+            const int numPixels = lhsTile.size.width() * lhsTile.size.height();
+            for (int j = 0; j < numPixels; j += sampleStep) {
+                quint8 *lhsDataPtr = lhsTile.data.data() + j * pixelSize;
+                quint8 *rhsDataPtr = rhsTile.data.data() + j * pixelSize;
+
+                if (std::memcmp(lhsDataPtr, rhsDataPtr, pixelSize) != 0) {
+                    numUniquePixels++;
+                }
+                numSampledPixels++;
+            }
+        }
+    }
+
+    return numSampledPixels > 0 ? qreal(numUniquePixels) / numSampledPixels : 1.0;
+}
+
+template <template <typename U> class OpPolicy, typename T>
+bool processData(T *dst, const T *src, int numUnits)
+{
+    OpPolicy<T> op;
+
+    bool unitsAreSame = true;
+
+    for (int j = 0; j < numUnits; j++) {
+        *dst = op(*dst, *src);
+
+        if (*dst != 0) {
+            unitsAreSame = false;
+        }
+
+        src++;
+        dst++;
+    }
+    return unitsAreSame;
+}
+
+
+template<template <typename U> class OpPolicy>
+bool KisFrameDataSerializer::processFrames(KisFrameDataSerializer::Frame &dst, const KisFrameDataSerializer::Frame &src)
+{
+    bool framesAreSame = true;
+
+    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(estimateFrameUniqueness(src, dst, 0.0), false);
+
+    for (int i = 0; i < int(src.frameTiles.size()); i++) {
+        const FrameTile &srcTile = src.frameTiles[i];
+        FrameTile &dstTile = dst.frameTiles[i];
+
+        const int numBytes = srcTile.size.width() * srcTile.size.height() * src.pixelSize;
+        const int numQWords = numBytes / 8;
+
+        const quint64 *srcDataPtr = reinterpret_cast<const quint64*>(srcTile.data.data());
+        quint64 *dstDataPtr = reinterpret_cast<quint64*>(dstTile.data.data());
+
+        framesAreSame &= processData<OpPolicy>(dstDataPtr, srcDataPtr, numQWords);
+
+
+        const int tailBytes = numBytes % 8;
+        const quint8 *srcTailDataPtr = srcTile.data.data() + numBytes - tailBytes;
+        quint8 *dstTailDataPtr = dstTile.data.data() + numBytes - tailBytes;
+
+        framesAreSame &= processData<OpPolicy>(dstTailDataPtr, srcTailDataPtr, tailBytes);
+    }
+
+    return framesAreSame;
+}
+
+bool KisFrameDataSerializer::subtractFrames(KisFrameDataSerializer::Frame &dst, const KisFrameDataSerializer::Frame &src)
+{
+    return processFrames<std::minus>(dst, src);
+}
+
+void KisFrameDataSerializer::addFrames(KisFrameDataSerializer::Frame &dst, const KisFrameDataSerializer::Frame &src)
+{
+    // TODO: don't spend time on calculation of "framesAreSame" in this case
+    (void) processFrames<std::plus>(dst, src);
+}
diff --git a/libs/ui/KisFrameDataSerializer.h b/libs/ui/KisFrameDataSerializer.h
new file mode 100644
index 0000000000..3093608b1c
--- /dev/null
+++ b/libs/ui/KisFrameDataSerializer.h
@@ -0,0 +1,82 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+#ifndef KISFRAMEDATASERIALIZER_H
+#define KISFRAMEDATASERIALIZER_H
+
+#include "kritaui_export.h"
+#include <QScopedPointer>
+#include "opengl/kis_texture_tile_info_pool.h"
+
+// TODO: extract DataBuffer into a separate file
+#include "opengl/kis_texture_tile_update_info.h"
+
+#include <vector>
+#include <boost/optional.hpp>
+
+class QString;
+
+class KRITAUI_EXPORT KisFrameDataSerializer
+{
+public:
+    struct FrameTile
+    {
+        FrameTile(KisTextureTileInfoPoolSP pool) : data(pool) {}
+        int col = -1;
+        int row = -1;
+        QSize size;
+        DataBuffer data;
+    };
+
+    struct Frame
+    {
+        int frameId = -1;
+        int pixelSize = 0;
+        std::vector<FrameTile> frameTiles;
+
+        bool isValid() const {
+            return frameId >= 0;
+        }
+    };
+
+public:
+    KisFrameDataSerializer(KisTextureTileInfoPoolSP pool);
+    KisFrameDataSerializer(KisTextureTileInfoPoolSP pool, const QString &frameCachePath);
+    ~KisFrameDataSerializer();
+
+    void saveFrame(const Frame &frame);
+    Frame loadFrame(int frameId);
+
+    bool hasFrame(int frameId) const;
+    void forgetFrame(int frameId);
+
+    static boost::optional<qreal> estimateFrameUniqueness(const Frame &lhs, const Frame &rhs, qreal portion);
+    static bool subtractFrames(Frame &dst, const Frame &src);
+    static void addFrames(Frame &dst, const Frame &src);
+
+private:
+    template<template <typename U> class OpPolicy>
+    static bool processFrames(KisFrameDataSerializer::Frame &dst, const KisFrameDataSerializer::Frame &src);
+
+private:
+    Q_DISABLE_COPY(KisFrameDataSerializer)
+
+    struct Private;
+    QScopedPointer<Private> m_d;
+};
+
+#endif // KISFRAMEDATASERIALIZER_H
diff --git a/libs/ui/opengl/kis_texture_tile_info_pool.h b/libs/ui/opengl/kis_texture_tile_info_pool.h
index 87fab1c13a..c594bff0fa 100644
--- a/libs/ui/opengl/kis_texture_tile_info_pool.h
+++ b/libs/ui/opengl/kis_texture_tile_info_pool.h
@@ -1,231 +1,233 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef __KIS_TEXTURE_TILE_INFO_POOL_H
 #define __KIS_TEXTURE_TILE_INFO_POOL_H
 
 #include <boost/pool/pool.hpp>
 #include <QtGlobal>
 #include <QVector>
 
 #include <QMutex>
 #include <QMutexLocker>
 #include <QSharedPointer>
 #include <QApplication>
 
 #include "kis_assert.h"
 #include "kis_debug.h"
 #include "kis_global.h"
 #include "kis_signal_compressor.h"
 
+#include "kritaui_export.h"
+
 const int minPoolChunk = 32; // 8 MiB (default, with tilesize 256)
 const int maxPoolChunk = 128; // 32 MiB (default, with tilesize 256)
 const int freeThreshold = 64; // 16 MiB (default, with tilesize 256)
 
 
 /**
  * A pool for keeping the chunks of data of constant size. We have one
  * such pool per used openGL tile size. The size of the chunk
  * obviously depends on the size of the tile in pixels and the size of
  * a single pixel in bytes.
  *
  * As soon as the number of allocations drops to zero, all the memory
  * is returned back to the operating system. Please note, that there
  * is *no way* of reclaiming even unused pool memory until *all* the
  * allocated chunks are free'd.
  */
-class KisTextureTileInfoPoolSingleSize
+class KRITAUI_EXPORT KisTextureTileInfoPoolSingleSize
 {
 public:
     KisTextureTileInfoPoolSingleSize(int tileWidth, int tileHeight, int pixelSize)
         : m_chunkSize(tileWidth * tileHeight * pixelSize),
           m_pool(m_chunkSize, minPoolChunk, maxPoolChunk),
           m_numAllocations(0),
           m_maxAllocations(0),
           m_numFrees(0)
     {
     }
 
     quint8* malloc() {
         m_numAllocations++;
         m_maxAllocations = qMax(m_maxAllocations, m_numAllocations);
 
         return (quint8*)m_pool.malloc();
     }
 
     bool free(quint8 *ptr) {
         m_numAllocations--;
         m_numFrees++;
         m_pool.free(ptr);
 
         KIS_ASSERT_RECOVER_NOOP(m_numAllocations >= 0);
 
         return !m_numAllocations && m_maxAllocations > freeThreshold;
     }
 
     int chunkSize() const {
         return m_chunkSize;
     }
 
     int numFrees() const {
         return m_numFrees;
     }
 
     void tryPurge(int numFrees) {
         // checking numFrees here is asserting that there were no frees
         // between the time we originally indicated the purge and now.
         if (numFrees == m_numFrees && !m_numAllocations) {
             m_pool.purge_memory();
             m_maxAllocations = 0;
         }
     }
 
 private:
     const int m_chunkSize;
     boost::pool<boost::default_user_allocator_new_delete> m_pool;
     int m_numAllocations;
     int m_maxAllocations;
     int m_numFrees;
 };
 
 class KisTextureTileInfoPool;
 
-class KisTextureTileInfoPoolWorker : public QObject
+class KRITAUI_EXPORT KisTextureTileInfoPoolWorker : public QObject
 {
     Q_OBJECT
 public:
     KisTextureTileInfoPoolWorker(KisTextureTileInfoPool *pool);
 
 public Q_SLOTS:
     void slotPurge(int pixelSize, int numFrees);
     void slotDelayedPurge();
 
 private:
     KisTextureTileInfoPool *m_pool;
     KisSignalCompressor m_compressor;
     QMap<int, int> m_purge;
 };
 
 /**
  * A universal pool for keeping the openGL tile of different pixel
  * sizes.  The underlying pools are created for each pixel size on
  * demand.
  */
-class KisTextureTileInfoPool : public QObject
+class KRITAUI_EXPORT KisTextureTileInfoPool : public QObject
 {
     Q_OBJECT
 public:
     KisTextureTileInfoPool(int tileWidth, int tileHeight)
         : m_tileWidth(tileWidth),
           m_tileHeight(tileHeight)
     {
         m_worker = new KisTextureTileInfoPoolWorker(this);
         m_worker->moveToThread(QApplication::instance()->thread());
         connect(this, SIGNAL(purge(int, int)), m_worker, SLOT(slotPurge(int, int)));
     }
 
     ~KisTextureTileInfoPool() {
         delete m_worker;
         qDeleteAll(m_pools);
     }
 
     /**
      * Alloc a tile with the specified pixel size
      */
     quint8* malloc(int pixelSize) {
         QMutexLocker l(&m_mutex);
 
         if (m_pools.size() <= pixelSize) {
             m_pools.resize(pixelSize + 1);
         }
 
         if (!m_pools[pixelSize]) {
             m_pools[pixelSize] =
                 new KisTextureTileInfoPoolSingleSize(m_tileWidth, m_tileHeight, pixelSize);
         }
 
         return m_pools[pixelSize]->malloc();
     }
 
     /**
      * Free a tile with the specified pixel size
      */
     void free(quint8 *ptr, int pixelSize) {
         QMutexLocker l(&m_mutex);
         KisTextureTileInfoPoolSingleSize *pool = m_pools[pixelSize];
         if (pool->free(ptr)) {
             emit purge(pixelSize, pool->numFrees());
         }
     }
 
     /**
      * \return the length of the chunks stored in the pool
      */
     int chunkSize(int pixelSize) const {
         QMutexLocker l(&m_mutex);
         return m_pools[pixelSize]->chunkSize();
     }
 
     void tryPurge(int pixelSize, int numFrees) {
         QMutexLocker l(&m_mutex);
         m_pools[pixelSize]->tryPurge(numFrees);
     }
 
 Q_SIGNALS:
     void purge(int pixelSize, int numFrees);
 
 private:
     mutable QMutex m_mutex;
     const int m_tileWidth;
     const int m_tileHeight;
     QVector<KisTextureTileInfoPoolSingleSize*> m_pools;
     KisTextureTileInfoPoolWorker *m_worker;
 };
 
 typedef QSharedPointer<KisTextureTileInfoPool> KisTextureTileInfoPoolSP;
 
-class KisTextureTileInfoPoolRegistry
+class KRITAUI_EXPORT KisTextureTileInfoPoolRegistry
 {
     typedef QWeakPointer<KisTextureTileInfoPool> KisTextureTileInfoPoolWSP;
     typedef QPair<int, int> PoolId;
 
 public:
     KisTextureTileInfoPoolSP getPool(int tileWidth, int tileHeight) {
         QMutexLocker l(&m_mutex);
 
         PoolId id(tileWidth, tileHeight);
 
         KisTextureTileInfoPoolSP pool =
             m_storage[id].toStrongRef();
 
         if (!pool) {
             pool = toQShared(
                 new KisTextureTileInfoPool(tileWidth, tileHeight));
             m_storage[id] = pool;
         }
 
         return pool;
     }
 
 private:
     QMutex m_mutex;
     QHash<PoolId, KisTextureTileInfoPoolWSP> m_storage;
 };
 
 
 #endif /* __KIS_TEXTURE_TILE_INFO_POOL_H */
diff --git a/libs/ui/opengl/kis_texture_tile_update_info.h b/libs/ui/opengl/kis_texture_tile_update_info.h
index 3ad0bfe5fc..40c571d71a 100644
--- a/libs/ui/opengl/kis_texture_tile_update_info.h
+++ b/libs/ui/opengl/kis_texture_tile_update_info.h
@@ -1,331 +1,341 @@
 /*
  *  Copyright (c) 2010, Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_TEXTURE_TILE_UPDATE_INFO_H_
 #define KIS_TEXTURE_TILE_UPDATE_INFO_H_
 
 #include <QMessageBox>
 #include <QThreadStorage>
 #include <QScopedArrayPointer>
 
 #include <KoColorSpace.h>
 #include "kis_image.h"
 #include "kis_paint_device.h"
 #include "kis_config.h"
 #include <KoColorConversionTransformation.h>
 #include <KoChannelInfo.h>
 #include <kis_lod_transform.h>
 #include "kis_texture_tile_info_pool.h"
 
 
 class KisTextureTileUpdateInfo;
 typedef QSharedPointer<KisTextureTileUpdateInfo> KisTextureTileUpdateInfoSP;
 typedef QVector<KisTextureTileUpdateInfoSP> KisTextureTileUpdateInfoSPList;
 
 /**
  * A buffer object for temporary data needed during the update process.
  *
  * - the buffer is allocated from the common pool to avoid memory
  *   fragmentation
  *
  * - the buffer's lifetime defines the lifetime of the allocated chunk
  *   of memory, so you don't have to thing about free'ing the memory
  */
 
 class DataBuffer
 {
 public:
     DataBuffer(KisTextureTileInfoPoolSP pool)
         : m_data(0),
           m_pixelSize(0),
           m_pool(pool)
     {
     }
 
     DataBuffer(int pixelSize, KisTextureTileInfoPoolSP pool)
         : m_data(0),
           m_pixelSize(0),
           m_pool(pool)
     {
         allocate(pixelSize);
     }
 
+    DataBuffer(DataBuffer &&rhs)
+        : m_data(rhs.m_data),
+          m_pixelSize(rhs.m_pixelSize),
+          m_pool(rhs.m_pool)
+    {
+        rhs.m_data = 0;
+    }
+
     ~DataBuffer() {
         if (m_data) {
             m_pool->free(m_data, m_pixelSize);
         }
     }
 
     void allocate(int pixelSize) {
         Q_ASSERT(!m_data);
 
         m_pixelSize = pixelSize;
         m_data = m_pool->malloc(m_pixelSize);
     }
 
     inline quint8* data() const {
         return m_data;
     }
 
     void swap(DataBuffer &other) {
         std::swap(other.m_pixelSize, m_pixelSize);
         std::swap(other.m_data, m_data);
     }
 
     int size() const {
         return m_data ? m_pool->chunkSize(m_pixelSize) : 0;
     }
 
 private:
+    Q_DISABLE_COPY(DataBuffer)
+
     quint8 *m_data;
     int m_pixelSize;
     KisTextureTileInfoPoolSP m_pool;
 };
 
 class KisTextureTileUpdateInfo
 {
 public:
     KisTextureTileUpdateInfo(KisTextureTileInfoPoolSP pool)
         : m_patchPixels(pool),
           m_pool(pool)
     {
     }
 
     KisTextureTileUpdateInfo(qint32 col, qint32 row,
                              const QRect &tileRect, const QRect &updateRect, const QRect &currentImageRect,
                              int levelOfDetail,
                              KisTextureTileInfoPoolSP pool)
         : m_patchPixels(pool),
           m_pool(pool)
     {
         m_tileCol = col;
         m_tileRow = row;
         m_tileRect = tileRect;
         m_originalTileRect = m_tileRect;
         m_patchRect = m_tileRect & updateRect;
         m_originalPatchRect = m_patchRect;
         m_currentImageRect = currentImageRect;
 
         m_patchLevelOfDetail = levelOfDetail;
 
         if (m_patchLevelOfDetail) {
             m_originalPatchRect = KisLodTransform::alignedRect(m_originalPatchRect, m_patchLevelOfDetail);
             m_patchRect = KisLodTransform::scaledRect(m_originalPatchRect, m_patchLevelOfDetail);
             m_tileRect = KisLodTransform::scaledRect(m_originalTileRect, m_patchLevelOfDetail);
         }
     }
 
     ~KisTextureTileUpdateInfo() {
     }
 
     void retrieveData(KisPaintDeviceSP projectionDevice, const QBitArray &channelFlags, bool onlyOneChannelSelected, int selectedChannelIndex)
     {
         m_patchColorSpace = projectionDevice->colorSpace();
         m_patchPixels.allocate(m_patchColorSpace->pixelSize());
 
         projectionDevice->readBytes(m_patchPixels.data(),
                                        m_patchRect.x(), m_patchRect.y(),
                                        m_patchRect.width(), m_patchRect.height());
 
         // XXX: if the paint colorspace is rgb, we should do the channel swizzling in
         //      the display shader
         if (!channelFlags.isEmpty()) {
             DataBuffer conversionCache(m_patchColorSpace->pixelSize(), m_pool);
 
             QList<KoChannelInfo*> channelInfo = m_patchColorSpace->channels();
             int channelSize = channelInfo[selectedChannelIndex]->size();
             int pixelSize = m_patchColorSpace->pixelSize();
             quint32 numPixels = m_patchRect.width() * m_patchRect.height();
 
             KisConfig cfg;
 
             if (onlyOneChannelSelected && !cfg.showSingleChannelAsColor()) {
                 int selectedChannelPos = channelInfo[selectedChannelIndex]->pos();
                 for (uint pixelIndex = 0; pixelIndex < numPixels; ++pixelIndex) {
                     for (uint channelIndex = 0; channelIndex < m_patchColorSpace->channelCount(); ++channelIndex) {
 
                         if (channelInfo[channelIndex]->channelType() == KoChannelInfo::COLOR) {
                             memcpy(conversionCache.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    m_patchPixels.data() + (pixelIndex * pixelSize) + selectedChannelPos,
                                    channelSize);
                         }
                         else if (channelInfo[channelIndex]->channelType() == KoChannelInfo::ALPHA) {
                             memcpy(conversionCache.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    m_patchPixels.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    channelSize);
                         }
                     }
                 }
             }
             else {
                 for (uint pixelIndex = 0; pixelIndex < numPixels; ++pixelIndex) {
                     for (uint channelIndex = 0; channelIndex < m_patchColorSpace->channelCount(); ++channelIndex) {
                         if (channelFlags.testBit(channelIndex)) {
                             memcpy(conversionCache.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    m_patchPixels.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize),
                                    channelSize);
                         }
                         else {
                             memset(conversionCache.data() + (pixelIndex * pixelSize) + (channelIndex * channelSize), 0, channelSize);
                         }
                     }
                 }
 
             }
 
             conversionCache.swap(m_patchPixels);
         }
 
     }
 
     void convertTo(const KoColorSpace* dstCS,
                    KoColorConversionTransformation::Intent renderingIntent,
                    KoColorConversionTransformation::ConversionFlags conversionFlags)
     {
         // we use two-stage check of the color space equivalence:
         // first check pointers, and if not, check the spaces themselves
         if ((dstCS == m_patchColorSpace || *dstCS == *m_patchColorSpace) &&
             conversionFlags == KoColorConversionTransformation::Empty) {
 
             return;
         }
 
         if (m_patchRect.isValid()) {
             const qint32 numPixels = m_patchRect.width() * m_patchRect.height();
             DataBuffer conversionCache(dstCS->pixelSize(), m_pool);
 
             m_patchColorSpace->convertPixelsTo(m_patchPixels.data(), conversionCache.data(), dstCS, numPixels, renderingIntent, conversionFlags);
 
             m_patchColorSpace = dstCS;
             conversionCache.swap(m_patchPixels);
         }
     }
 
     void proofTo(const KoColorSpace* dstCS,
                    KoColorConversionTransformation::ConversionFlags conversionFlags,
                    KoColorConversionTransformation *proofingTransform)
     {
         if (dstCS == m_patchColorSpace && conversionFlags == KoColorConversionTransformation::Empty) return;
 
         if (m_patchRect.isValid()) {
             const qint32 numPixels = m_patchRect.width() * m_patchRect.height();
             DataBuffer conversionCache(dstCS->pixelSize(), m_pool);
 
             m_patchColorSpace->proofPixelsTo(m_patchPixels.data(), conversionCache.data(), numPixels, proofingTransform);
 
             m_patchColorSpace = dstCS;
             conversionCache.swap(m_patchPixels);
         }
     }
 
     KoColorConversionTransformation *generateProofingTransform(const KoColorSpace* dstCS, const KoColorSpace* proofingSpace,
                                                        KoColorConversionTransformation::Intent renderingIntent,
                                                        KoColorConversionTransformation::Intent proofingIntent,
                                                        KoColorConversionTransformation::ConversionFlags conversionFlags,
                                                        KoColor gamutWarning,
                                                        double adaptationState)
     {
         return m_patchColorSpace->createProofingTransform(dstCS, proofingSpace, renderingIntent, proofingIntent, conversionFlags, gamutWarning.data(), adaptationState);
     }
 
     inline quint8* data() const {
         return m_patchPixels.data();
     }
 
     inline int patchLevelOfDetail() const {
         return m_patchLevelOfDetail;
     }
 
     inline QPoint realPatchOffset() const {
         return QPoint(m_patchRect.x() - m_tileRect.x(),
                       m_patchRect.y() - m_tileRect.y());
     }
 
     inline QSize realPatchSize() const {
         return m_patchRect.size();
     }
 
     inline QSize realTileSize() const {
         return m_tileRect.size();
     }
 
     inline bool isTopmost() const {
         return m_originalPatchRect.top() == m_currentImageRect.top();
     }
 
     inline bool isLeftmost() const {
         return m_originalPatchRect.left() == m_currentImageRect.left();
     }
 
     inline bool isRightmost() const {
         return m_originalPatchRect.right() == m_currentImageRect.right();
     }
 
     inline bool isBottommost() const {
         return m_originalPatchRect.bottom() == m_currentImageRect.bottom();
     }
 
     inline bool isEntireTileUpdated() const {
         return m_patchRect == m_tileRect;
     }
 
     inline qint32 tileCol() const {
         return m_tileCol;
     }
 
     inline qint32 tileRow() const {
         return m_tileRow;
     }
 
     inline quint32 pixelSize() const {
         return m_patchColorSpace->pixelSize();
     }
 
     inline quint32 patchPixelsLength() const {
         return m_patchPixels.size();
     }
 
     inline bool valid() const {
         return m_patchRect.isValid();
     }
 
 private:
     Q_DISABLE_COPY(KisTextureTileUpdateInfo)
 
 private:
     qint32 m_tileCol;
     qint32 m_tileRow;
     QRect m_currentImageRect;
     QRect m_tileRect;
     QRect m_patchRect;
     const KoColorSpace* m_patchColorSpace;
 
     QRect m_realPatchRect;
     QRect m_realPatchOffset;
     QRect m_realTileSize;
     int m_patchLevelOfDetail;
 
     QRect m_originalPatchRect;
     QRect m_originalTileRect;
 
     DataBuffer m_patchPixels;
     KisTextureTileInfoPoolSP m_pool;
 };
 
 
 #endif /* KIS_TEXTURE_TILE_UPDATE_INFO_H_ */
 
diff --git a/libs/ui/tests/CMakeLists.txt b/libs/ui/tests/CMakeLists.txt
index a9c60cc191..949ace50e0 100644
--- a/libs/ui/tests/CMakeLists.txt
+++ b/libs/ui/tests/CMakeLists.txt
@@ -1,182 +1,185 @@
 set( EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR} )
 
 #add_subdirectory(scratchpad)
 include_directories(${CMAKE_SOURCE_DIR}/libs/image/metadata 
                     ${CMAKE_SOURCE_DIR}/sdk/tests )
 
 include(ECMAddTests)
 
 macro_add_unittest_definitions()
 
 ecm_add_tests(
     kis_image_view_converter_test.cpp
     kis_shape_selection_test.cpp
     kis_recorded_action_editor_test.cpp
     kis_doc2_test.cpp
     kis_coordinates_converter_test.cpp
     kis_grid_config_test.cpp
     kis_stabilized_events_sampler_test.cpp
     kis_derived_resources_test.cpp
     kis_brush_hud_properties_config_test.cpp
     kis_shape_commands_test.cpp
     kis_shape_layer_test.cpp
     kis_stop_gradient_editor_test.cpp
     NAME_PREFIX "krita-ui-"
     LINK_LIBRARIES kritaui Qt5::Test
 )
 
 ecm_add_tests(
     kis_file_layer_test.cpp
     kis_multinode_property_test.cpp
     NAME_PREFIX "krita-ui-"
     LINK_LIBRARIES kritaui kritaimage Qt5::Test
 )
 
+ecm_add_test( KisFrameSerializerTest.cpp
+    TEST_NAME krita-ui-KisFrameSerializerTest
+    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 ecm_add_test( kis_selection_decoration_test.cpp ../../../sdk/tests/stroke_testing_utils.cpp
     TEST_NAME krita-ui-KisSelectionDecorationTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 ecm_add_test( kis_node_dummies_graph_test.cpp ../../../sdk/tests/testutil.cpp
     TEST_NAME krita-ui-KisNodeDummiesGraphTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 ecm_add_test( kis_node_shapes_graph_test.cpp ../../../sdk/tests/testutil.cpp
     TEST_NAME krita-ui-KisNodeShapesGraphTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 ecm_add_test( kis_model_index_converter_test.cpp ../../../sdk/tests/testutil.cpp
     TEST_NAME krita-ui-KisModelIndexConverterTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 ecm_add_test( kis_categorized_list_model_test.cpp modeltest.cpp
     TEST_NAME krita-ui-KisCategorizedListModelTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 ecm_add_test( kis_resource_server_provider_test.cpp modeltest.cpp
     TEST_NAME krita-ui-KisResourceServerProviderTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 ecm_add_test( kis_node_juggler_compressed_test.cpp  ../../../sdk/tests/testutil.cpp
     TEST_NAME krita-image-BaseNodeTest
     LINK_LIBRARIES kritaimage kritaui Qt5::Test)
 
 ecm_add_test(
     kis_animation_exporter_test.cpp
     TEST_NAME kritaui-animation_exporter_test
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 set(kis_node_view_test_SRCS kis_node_view_test.cpp  ../../../sdk/tests/testutil.cpp)
 qt5_add_resources(kis_node_view_test_SRCS ${krita_QRCS})
 ecm_add_test(${kis_node_view_test_SRCS}
     TEST_NAME krita-image-kis_node_view_test
     LINK_LIBRARIES kritaimage kritaui Qt5::Test)
 
 
 
 ##### Tests that currently fail and should be fixed #####
 
 include(KritaAddBrokenUnitTest)
 
 krita_add_broken_unit_test(
     kis_node_model_test.cpp modeltest.cpp
     TEST_NAME krita-ui-kis_node_model_test
     LINK_LIBRARIES kritaui Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_shape_controller_test.cpp kis_dummies_facade_base_test.cpp
     TEST_NAME krita-ui-kis_shape_controller_test
     LINK_LIBRARIES kritaimage kritaui Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_prescaled_projection_test.cpp
     TEST_NAME krita-ui-kis_prescaled_projection_test
     LINK_LIBRARIES kritaui Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_exiv2_test.cpp
     TEST_NAME krita-ui-KisExiv2Test
     LINK_LIBRARIES kritaimage kritaui Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_clipboard_test.cpp
     TEST_NAME krita-ui-KisClipboardTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     freehand_stroke_test.cpp ${CMAKE_SOURCE_DIR}/sdk/tests/stroke_testing_utils.cpp
     TEST_NAME krita-ui-FreehandStrokeTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     FreehandStrokeBenchmark.cpp ${CMAKE_SOURCE_DIR}/sdk/tests/stroke_testing_utils.cpp
     TEST_NAME krita-ui-FreehandStrokeBenchmark
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     fill_processing_visitor_test.cpp ${CMAKE_SOURCE_DIR}/sdk/tests/stroke_testing_utils.cpp
     TEST_NAME krita-ui-FillProcessingVisitorTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     filter_stroke_test.cpp ../../../sdk/tests/stroke_testing_utils.cpp
     TEST_NAME krita-ui-FilterStrokeTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_selection_manager_test.cpp
     TEST_NAME krita-ui-KisSelectionManagerTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 #set_tests_properties(krita-ui-KisSelectionManagerTest PROPERTIES TIMEOUT 300)
 
 krita_add_broken_unit_test(
     kis_node_manager_test.cpp
     TEST_NAME krita-ui-KisNodeManagerTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_dummies_facade_test.cpp kis_dummies_facade_base_test.cpp ../../../sdk/tests/testutil.cpp
     TEST_NAME krita-ui-KisDummiesFacadeTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_zoom_and_pan_test.cpp ../../../sdk/tests/testutil.cpp
     TEST_NAME krita-ui-KisZoomAndPanTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 #set_tests_properties(krita-ui-KisZoomAndPanTest PROPERTIES TIMEOUT 300)
 
 krita_add_broken_unit_test(
     kis_action_manager_test.cpp
     TEST_NAME krita-ui-KisActionManagerTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_categories_mapper_test.cpp testing_categories_mapper.cpp
     TEST_NAME krita-ui-KisCategoriesMapperTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_asl_layer_style_serializer_test.cpp
     TEST_NAME krita-ui-KisAslLayerStyleSerializerTest
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_animation_importer_test.cpp
     TEST_NAME kritaui-animation_importer_test
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     kis_animation_frame_cache_test.cpp
     TEST_NAME kritaui-animation_frame_cache_test
     LINK_LIBRARIES kritaui kritaimage Qt5::Test)
 
 krita_add_broken_unit_test(
     ResourceBundleTest.cpp
     TEST_NAME krita-resourcemanager-ResourceBundleTest
     LINK_LIBRARIES kritaui kritalibbrush kritalibpaintop Qt5::Test)
 
 # FIXME this test doesn't compile
 #ecm_add_test(
 #    kis_input_manager_test.cpp ../../../sdk/tests/testutil.cpp
 #    TEST_NAME krita-ui-KisInputManagerTest
 #    LINK_LIBRARIES kritaui kritaimage Qt5::Test)
diff --git a/libs/ui/tests/KisFrameSerializerTest.cpp b/libs/ui/tests/KisFrameSerializerTest.cpp
new file mode 100644
index 0000000000..0459f1fe05
--- /dev/null
+++ b/libs/ui/tests/KisFrameSerializerTest.cpp
@@ -0,0 +1,224 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "KisFrameSerializerTest.h"
+
+#include <KisFrameDataSerializer.h>
+#include "opengl/kis_texture_tile_info_pool.h"
+
+#include <QTest>
+
+static const int maxTileSize = 256;
+
+KisFrameDataSerializer::Frame generateTestFrame(int frameId, KisTextureTileInfoPoolSP pool)
+{
+    KisFrameDataSerializer::Frame frame;
+    frame.frameId = frameId;
+    frame.pixelSize = 4;
+
+    for (int i = 0; i < qBound(1, frameId * 5, 100); i++) {
+        KisFrameDataSerializer::FrameTile tile(pool);
+        tile.col = i * 10;
+        tile.row = i * 20;
+        tile.size = QSize(qMin(i * 5, maxTileSize), qMin(i * 7, maxTileSize));
+        tile.data.allocate(frame.pixelSize);
+
+        const int numPixels = tile.size.width() * tile.size.height();
+        qint32 *dataPtr = reinterpret_cast<qint32*>(tile.data.data());
+
+        for (int j = 0; j < numPixels; j++) {
+            *dataPtr++ = frameId + j;
+        }
+
+        frame.frameTiles.push_back(std::move(tile));
+    }
+
+    return frame;
+}
+
+#define KIS_COMPARE_RF(expr, ref) \
+    if ((expr) != (ref)) { \
+        qDebug() << "Compared values are not the same at line" << __LINE__; \
+        qDebug() << "    Actual  : " << #expr << "=" << (expr); \
+        qDebug() << "    Expected: " << #ref << "=" << (ref); \
+        return false; \
+    }
+
+bool verifyTestFrame(int frameId, const KisFrameDataSerializer::Frame &frame)
+{
+    KIS_COMPARE_RF(frame.frameId, frameId);
+    KIS_COMPARE_RF(frame.pixelSize, 4);
+    KIS_COMPARE_RF(int(frame.frameTiles.size()), qBound(1, frameId * 5, 100));
+
+    for (int i = 0; i < int(frame.frameTiles.size()); i++) {
+        const KisFrameDataSerializer::FrameTile &tile = frame.frameTiles[i];
+
+        KIS_COMPARE_RF(tile.col, i * 10);
+        KIS_COMPARE_RF(tile.row, i * 20);
+        KIS_COMPARE_RF(tile.size, QSize(qMin(i * 5, maxTileSize), qMin(i * 7, maxTileSize)));
+
+        const int numPixels = tile.size.width() * tile.size.height();
+        qint32 *dataPtr = reinterpret_cast<qint32*>(tile.data.data());
+
+        for (int j = 0; j < numPixels; j++) {
+            KIS_COMPARE_RF(*dataPtr++, frameId + j);
+        }
+    }
+
+    return true;
+}
+
+
+
+void KisFrameSerializerTest::testFrameDataSerialization()
+{
+    KisTextureTileInfoPoolRegistry poolRegistry;
+    KisTextureTileInfoPoolSP pool = poolRegistry.getPool(maxTileSize, maxTileSize);
+
+
+    KisFrameDataSerializer serializer(pool);
+
+    KisFrameDataSerializer::Frame testFrame1 = generateTestFrame(2, pool);
+    KisFrameDataSerializer::Frame testFrame2 = generateTestFrame(3, pool);
+    KisFrameDataSerializer::Frame testFrame3 = generateTestFrame(503, pool);
+
+
+    serializer.saveFrame(testFrame1);
+    QCOMPARE(serializer.hasFrame(2), true);
+    QCOMPARE(serializer.hasFrame(3), false);
+    QCOMPARE(serializer.hasFrame(503), false);
+
+    serializer.saveFrame(testFrame2);
+    QCOMPARE(serializer.hasFrame(2), true);
+    QCOMPARE(serializer.hasFrame(3), true);
+    QCOMPARE(serializer.hasFrame(503), false);
+
+    serializer.saveFrame(testFrame3);
+    QCOMPARE(serializer.hasFrame(2), true);
+    QCOMPARE(serializer.hasFrame(3), true);
+    QCOMPARE(serializer.hasFrame(503), true);
+
+    QVERIFY(verifyTestFrame(2, serializer.loadFrame(2)));
+    QVERIFY(verifyTestFrame(3, serializer.loadFrame(3)));
+    QVERIFY(verifyTestFrame(503, serializer.loadFrame(503)));
+
+    serializer.forgetFrame(3);
+    QCOMPARE(serializer.hasFrame(2), true);
+    QCOMPARE(serializer.hasFrame(3), false);
+    QCOMPARE(serializer.hasFrame(503), true);
+
+    serializer.forgetFrame(503);
+    QCOMPARE(serializer.hasFrame(2), true);
+    QCOMPARE(serializer.hasFrame(3), false);
+    QCOMPARE(serializer.hasFrame(503), false);
+
+    serializer.forgetFrame(2);
+    QCOMPARE(serializer.hasFrame(2), false);
+    QCOMPARE(serializer.hasFrame(3), false);
+    QCOMPARE(serializer.hasFrame(503), false);
+}
+
+#include "kis_random_source.h"
+
+void randomizeFrame(KisFrameDataSerializer::Frame &frame, qreal portion)
+{
+    // randomly reset 50% of the pixels
+    KisRandomSource rnd(1);
+    for (KisFrameDataSerializer::FrameTile &tile : frame.frameTiles) {
+        const int numPixels = tile.size.width() * tile.size.height();
+        qint32 *pixelPtr = reinterpret_cast<qint32*>(tile.data.data());
+
+        for (int j = 0; j < numPixels; j++) {
+            if (rnd.generateNormalized() < portion) {
+                (*pixelPtr) = 0;
+            }
+
+            pixelPtr++;
+        }
+    }
+}
+
+void KisFrameSerializerTest::testFrameUniquenessEstimation()
+{
+    KisTextureTileInfoPoolRegistry poolRegistry;
+    KisTextureTileInfoPoolSP pool = poolRegistry.getPool(maxTileSize, maxTileSize);
+
+    KisFrameDataSerializer::Frame testFrame1 = generateTestFrame(2, pool);
+    KisFrameDataSerializer::Frame testFrame2 = generateTestFrame(2, pool);
+
+    boost::optional<qreal> result;
+
+    result = KisFrameDataSerializer::estimateFrameUniqueness(testFrame1, testFrame2, 0.1);
+    QVERIFY(result);
+    QVERIFY(qFuzzyCompare(*result, 0.0));
+
+    KisFrameDataSerializer::Frame testFrame3 = generateTestFrame(3, pool);
+
+    result = KisFrameDataSerializer::estimateFrameUniqueness(testFrame1, testFrame3, 0.1);
+    QVERIFY(!result);
+
+    // randomly reset 50% of the pixels
+    randomizeFrame(testFrame2, 0.5);
+
+    result = KisFrameDataSerializer::estimateFrameUniqueness(testFrame1, testFrame2, 0.01);
+    QVERIFY(result);
+    QVERIFY(*result >= 0.45);
+    QVERIFY(*result <= 0.55);
+}
+
+void KisFrameSerializerTest::testFrameArithmetics()
+{
+    KisTextureTileInfoPoolRegistry poolRegistry;
+    KisTextureTileInfoPoolSP pool = poolRegistry.getPool(maxTileSize, maxTileSize);
+
+    KisFrameDataSerializer::Frame testFrame1 = generateTestFrame(2, pool);
+    KisFrameDataSerializer::Frame testFrame2 = generateTestFrame(2, pool);
+    randomizeFrame(testFrame2, 0.2);
+
+    boost::optional<qreal> result =
+        KisFrameDataSerializer::estimateFrameUniqueness(testFrame1, testFrame2, 0.01);
+
+    QVERIFY(result);
+    QVERIFY(*result >= 0.15);
+    QVERIFY(*result <= 0.25);
+
+
+    {
+        KisFrameDataSerializer::Frame testFrame3 = generateTestFrame(2, pool);
+        randomizeFrame(testFrame3, 0.2);
+
+        const bool framesAreSame = KisFrameDataSerializer::subtractFrames(testFrame3, testFrame2);
+        QVERIFY(framesAreSame);
+    }
+
+    {
+        KisFrameDataSerializer::Frame testFrame3 = generateTestFrame(2, pool);
+        randomizeFrame(testFrame3, 0.2);
+
+        const bool framesAreSame = KisFrameDataSerializer::subtractFrames(testFrame3, testFrame1);
+        QVERIFY(!framesAreSame);
+
+        KisFrameDataSerializer::addFrames(testFrame3, testFrame1);
+
+        result = KisFrameDataSerializer::estimateFrameUniqueness(testFrame3, testFrame2, 1.0);
+        QVERIFY(result);
+        QVERIFY(*result == 0.0);
+    }
+}
+
+QTEST_MAIN(KisFrameSerializerTest)
diff --git a/libs/ui/tests/KisFrameSerializerTest.h b/libs/ui/tests/KisFrameSerializerTest.h
new file mode 100644
index 0000000000..6e57819750
--- /dev/null
+++ b/libs/ui/tests/KisFrameSerializerTest.h
@@ -0,0 +1,35 @@
+/*
+ *  Copyright (c) 2018 Dmitry Kazakov <dimula73@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef KISFRAMESERIALIZERTEST_H
+#define KISFRAMESERIALIZERTEST_H
+
+#include <QObject>
+
+class KisFrameSerializerTest : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void testFrameDataSerialization();
+    void testFrameUniquenessEstimation();
+    void testFrameArithmetics();
+
+};
+
+#endif // KISFRAMESERIALIZERTEST_H