diff --git a/data/app.drey.PaperPlane.gschema.xml.in b/data/app.drey.PaperPlane.gschema.xml.in
index 170bed437..f3f7838c4 100644
--- a/data/app.drey.PaperPlane.gschema.xml.in
+++ b/data/app.drey.PaperPlane.gschema.xml.in
@@ -31,5 +31,10 @@
       <summary>Color Scheme</summary>
       <description>The color scheme to be used in the app</description>
     </key>
+    <key name="theme-name" type="s">
+      <default>'🏠'</default>
+      <summary>Theme Name</summary>
+      <description>The chat theme name to be used in the app</description>
+    </key>
   </schema>
 </schemalist>
diff --git a/data/resources/style-dark.css b/data/resources/style-dark.css
index 815f73aea..90f6a00cb 100644
--- a/data/resources/style-dark.css
+++ b/data/resources/style-dark.css
@@ -1,3 +1,13 @@
+@define-color outgoing_message_accent_color white;
+
+label.link link {
+  color: #78aeed;
+}
+
+messagebubble.outgoing label.link link {
+  color: currentColor;
+}
+
 #new-login-icon {
   background-color: @dark_2;
 }
@@ -19,12 +29,8 @@ messagebubble.outgoing {
   background-color: #2c52ac;
 }
 
-messagebubble.document.outgoing .file > overlay > statusindicator {
-  color: white;
-}
-
 .event-row {
-  background-color: alpha(#404040, 0.8);
+  background-color: alpha(#404040, 0.8);style_context_remove_provider_for_display
 }
 
 .chat-list row .unread-count-muted {
@@ -64,3 +70,7 @@ messagebubble.document.outgoing .file > overlay > statusindicator {
   background: #303030;
 }
 /* End of values for cairo renderer */
+
+themepreview {
+  color: #303030;
+}
diff --git a/data/resources/style.css b/data/resources/style.css
index 1c9574c9d..14e429c0d 100644
--- a/data/resources/style.css
+++ b/data/resources/style.css
@@ -1,3 +1,14 @@
+@define-color outgoing_message_accent_color #79c271;
+
+/* Gtk doesn't redraw links after their color changed, so it's better for it to be constant */
+label.link link {
+  color: @blue_4;
+}
+
+messagebubble.outgoing label.link link {
+  color: currentColor;
+}
+
 .bold {
   font-weight: bold;
 }
@@ -166,11 +177,15 @@ messagebubble:not(.outgoing):dir(rtl) {
   margin-left: 38px;
 }
 
-messagebubble.outgoing link,
 messagebubble.outgoing messagereply label.message {
   color: @window_fg_color;
 }
 
+messagebubble.outgoing messagereply label.caption-heading,
+messagebubble.outgoing messagereply separator {
+  color: @outgoing_message_accent_color;
+}
+
 messagebubble messageindicators {
   opacity: 0.7;
 }
@@ -208,7 +223,7 @@ messagebubble.document .file > overlay > statusindicator {
 
 messagebubble.document.outgoing .file > overlay > statusindicator {
   /* depends on bubble color */
-  color: #79c271;
+  color: @outgoing_message_accent_color;
 }
 
 messagebubble.document .file:hover > overlay > statusindicator {
@@ -314,6 +329,10 @@ messagereply label.message {
   color: @window_fg_color;
 }
 
+messagebubble.outgoing messagereply label.message {
+  color: currentColor;
+}
+
 messagesticker {
   border-spacing: 6px;
 }
@@ -407,3 +426,41 @@ window.chat-info .main-page > list {
 .small-pill {
   border-radius: 18px;
 }
+
+themepreview {
+  color: white;
+}
+
+themepreview .card {
+  border-radius: 6px;
+}
+
+themepreview > label {
+  text-shadow: 0 -1px rgba(0, 0, 0, 0.05), 1px 0 rgba(0, 0, 0, 0.1),
+    0 1px rgba(0, 0, 0, 0.3), -1px 0 rgba(0, 0, 0, 0.1);
+}
+
+.theme-variants {
+  padding: 4px;
+}
+
+.theme-variants button {
+  margin: 4px;
+  background: none;
+  border-radius: 9px;
+  padding: 3px;
+  box-shadow: none;
+  outline: none;
+}
+
+.theme-variants button:checked {
+  box-shadow: 0 0 0 3px @accent_color;
+}
+
+.theme-variants button:focus:focus-visible {
+  box-shadow: 0 0 0 3px alpha(@accent_color, 0.3);
+}
+
+.theme-variants button:checked:focus:focus-visible {
+  box-shadow: 0 0 0 3px @accent_color, 0 0 0 6px alpha(@accent_color, 0.3);
+}
diff --git a/data/resources/ui/content-chat-history.ui b/data/resources/ui/content-chat-history.ui
index e869c3177..63b070f8a 100644
--- a/data/resources/ui/content-chat-history.ui
+++ b/data/resources/ui/content-chat-history.ui
@@ -3,6 +3,8 @@
   <template class="ContentChatHistory" parent="AdwBin">
     <child>
       <object class="AdwToolbarView">
+        <property name="top-bar-style">raised</property>
+        <property name="bottom-bar-style">raised</property>
         <child type="top">
           <object class="GtkOverlay">
             <child>
@@ -87,29 +89,26 @@
               </object>
             </child>
             <child>
-              <object class="ContentBackground" id="background">
-                <property name="vexpand">True</property>
+              <object class="GtkScrolledWindow" id="scrolled_window">
+                <property name="hscrollbar-policy">never</property>
                 <property name="child">
-                  <object class="GtkScrolledWindow" id="scrolled_window">
-                    <property name="hscrollbar-policy">never</property>
+                  <object class="AdwClampScrollable">
+                    <property name="maximum-size">800</property>
+                    <property name="tightening-threshold">600</property>
+                    <property name="vscroll-policy">natural</property>
                     <property name="child">
-                      <object class="AdwClampScrollable">
-                        <property name="maximum-size">800</property>
-                        <property name="tightening-threshold">600</property>
-                        <property name="vscroll-policy">natural</property>
-                        <property name="child">
-                          <object class="GtkListView" id="list_view">
-                            <property name="reversed">True</property>
-                            <style>
-                              <class name="chat-history"/>
-                            </style>
-                            <property name="factory">
-                              <object class="GtkBuilderListItemFactory">
-                                <property name="bytes"><![CDATA[
+                      <object class="GtkListView" id="list_view">
+                        <property name="reversed">True</property>
+                        <style>
+                          <class name="chat-history"/>
+                        </style>
+                        <property name="factory">
+                          <object class="GtkBuilderListItemFactory">
+                            <property name="bytes"><![CDATA[
 <?xml version="1.0" encoding="UTF-8"?>
 <interface>
-  <template class="GtkListItem">
-    <property name="activatable">False</property>
+<template class="GtkListItem">
+  <property name="activatable">False</property>
     <property name="child">
       <object class="ContentChatHistoryRow">
         <binding name="item">
@@ -119,9 +118,7 @@
     </property>
   </template>
 </interface>
-                        ]]></property>
-                              </object>
-                            </property>
+                    ]]></property>
                           </object>
                         </property>
                       </object>
diff --git a/data/resources/ui/content.blp b/data/resources/ui/content.blp
index 39abed311..ff3a65735 100644
--- a/data/resources/ui/content.blp
+++ b/data/resources/ui/content.blp
@@ -7,10 +7,14 @@ template $Content : Adw.Bin {
 
   styles ["view"]
 
-  Stack stack {
-    Adw.ToolbarView unselected_chat_view {
-      [top]
-      Overlay {
+  $ContentBackground {
+    controls-accent: true;
+
+    child: Stack stack {
+      Adw.ToolbarView unselected_chat_view {
+        extend-content-to-top-edge: true;
+
+        [top]
         Adw.HeaderBar {
           show-start-title-buttons: false;
 
@@ -18,23 +22,20 @@ template $Content : Adw.Bin {
           Adw.WindowTitle {}
         }
 
-        [overlay]
-        $ComponentsSnow snow {
-          sensitive: false;
-        }
+        content: Label {
+          styles ["event-row"]
+
+          halign: center;
+          valign: center;
+
+          label: _("Select a chat to start messaging.");
+        };
       }
 
-      content: Adw.StatusPage {
-        vexpand: true;
-        icon-name: "user-available-symbolic";
-        title: _("No Chat Selected");
-        description: _("Select a chat to start messaging.");
-      };
-    }
-
-    $ContentChatHistory chat_history {
-      compact: bind template.compact;
-      chat: bind template.chat;
-    }
+      $ContentChatHistory chat_history {
+        compact: bind template.compact;
+        chat: bind template.chat;
+      }
+    };
   }
 }
diff --git a/data/resources/ui/preferences-window.blp b/data/resources/ui/preferences-window.blp
index 9319d92f4..037668abc 100644
--- a/data/resources/ui/preferences-window.blp
+++ b/data/resources/ui/preferences-window.blp
@@ -3,6 +3,23 @@ using Adw 1;
 
 template $PreferencesWindow : Adw.PreferencesWindow {
   Adw.PreferencesPage {
+    Adw.PreferencesGroup {
+      title: _("Theme");
+
+      Adw.PreferencesRow {
+        title: "Select Theme";
+
+        activatable: false;
+
+        child: FlowBox theme_variants_box {
+          styles ["theme-variants"]
+          overflow: hidden;
+
+          selection-mode: none;
+        };
+      }
+    }
+
     Adw.PreferencesGroup {
       title: _("Color Scheme");
 
diff --git a/src/components/background.rs b/src/components/background.rs
new file mode 100644
index 000000000..f2177284a
--- /dev/null
+++ b/src/components/background.rs
@@ -0,0 +1,809 @@
+use std::cell::Cell;
+use std::cell::RefCell;
+use std::fmt::Write;
+
+use adw::prelude::*;
+use adw::subclass::prelude::*;
+use glib::clone;
+use glib::once_cell::unsync::OnceCell;
+use gtk::gdk;
+use gtk::gio;
+use gtk::glib;
+use gtk::graphene;
+use gtk::gsk;
+use once_cell::sync::Lazy;
+
+use crate::utils::spawn;
+
+const GRADIENT_SHADER: &[u8] = r#"
+// That shader was taken from Telegram for android source
+// https://github.com/DrKLO/Telegram/commit/2112affb2e4941334f8fbc3944385806b3c4e3d6#diff-dfdd1e8c4691747fd30199b7a2f5041a126b23e1450b29afe441eb0ebed01c68
+
+precision highp float;
+
+uniform vec3 color1;
+uniform vec3 color2;
+uniform vec3 color3;
+uniform vec3 color4;
+uniform vec4 p12;
+uniform vec4 p34;
+uniform vec4 gradient_bounds;
+
+void mainImage(out vec4 fragColor,
+               in vec2 fragCoord,
+               in vec2 resolution,
+               in vec2 uv) {
+    vec2 p1 = p12.xy;
+    vec2 p2 = p12.zw;
+    vec2 p3 = p34.xy;
+    vec2 p4 = p34.zw;
+
+    uv = (fragCoord - gradient_bounds.xy) / gradient_bounds.zw;
+    uv.y = 1.0 - uv.y;
+
+    float dp1 = distance(uv, p1);
+    float dp2 = distance(uv, p2);
+    float dp3 = distance(uv, p3);
+    float dp4 = distance(uv, p4);
+    float minD = min(dp1, min(dp2, min(dp3, dp4)));
+    float p = 5.0;
+    dp1 = pow(1.0 - (dp1 - minD), p);
+    dp2 = pow(1.0 - (dp2 - minD), p);
+    dp3 = pow(1.0 - (dp3 - minD), p);
+    dp4 = pow(1.0 - (dp4 - minD), p);
+    float sumDp = dp1 + dp2 + dp3 + dp4;
+
+    vec3 color = (color1 * dp1 + color2 * dp2 + color3 * dp3 + color4 * dp4) / sumDp;
+    fragColor = vec4(color, 1.0);
+}
+"#
+.as_bytes();
+
+static DEFAULT_PATTERN: Lazy<gdk::Texture> =
+    Lazy::new(|| gdk::Texture::from_resource("/app/drey/paper-plane/images/pattern.svg"));
+
+static mut SHADER: Option<gsk::GLShader> = None;
+
+mod imp {
+
+    use super::*;
+
+    #[derive(Default, glib::Properties)]
+    #[properties(wrapper_type = super::Background)]
+    pub(crate) struct Background {
+        #[property(get, set)]
+        pub(super) thumbnail_mode: Cell<bool>,
+
+        pub(super) settings: OnceCell<gio::Settings>,
+        pub(super) session: RefCell<glib::WeakRef<crate::Session>>,
+        pub(super) settings_handler: RefCell<Option<glib::SignalHandlerId>>,
+
+        pub(super) chat_theme: RefCell<Option<tdlib::types::ChatTheme>>,
+
+        pub(super) background_cache: RefCell<Option<gdk::Texture>>,
+
+        pub(super) document: RefCell<Option<tdlib::types::Document>>,
+        pub(super) document_target_file_id: Cell<i32>,
+        pub(super) document_texture: RefCell<Option<gdk::Texture>>,
+
+        pub(super) loaded_documents: RefCell<Vec<(i32, gdk::Texture)>>,
+
+        pub(super) last_size: Cell<(f32, f32)>,
+
+        pub(super) pattern: OnceCell<gdk::Texture>,
+
+        pub(super) gradient_animation: OnceCell<adw::Animation>,
+        pub(super) progress: Cell<f32>,
+        pub(super) phase: Cell<u32>,
+
+        pub(super) dark: Cell<bool>,
+        pub(super) pattern_intensity: Cell<f32>,
+        pub(super) pattern_is_inverted: Cell<bool>,
+
+        pub(super) bg_colors: RefCell<Vec<graphene::Vec3>>,
+        pub(super) message_colors: RefCell<Vec<graphene::Vec3>>,
+
+        #[property(get, set = Self::setup_provider)]
+        pub(super) controls_accent: Cell<bool>,
+        pub(super) css_provider: OnceCell<gtk::CssProvider>,
+    }
+
+    #[glib::object_subclass]
+    impl ObjectSubclass for Background {
+        const NAME: &'static str = "ContentBackground";
+        type Type = super::Background;
+        type ParentType = adw::Bin;
+    }
+
+    impl ObjectImpl for Background {
+        fn properties() -> &'static [glib::ParamSpec] {
+            Self::derived_properties()
+        }
+
+        fn set_property(&self, id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
+            self.derived_set_property(id, value, pspec)
+        }
+
+        fn property(&self, id: usize, pspec: &glib::ParamSpec) -> glib::Value {
+            self.derived_property(id, pspec)
+        }
+
+        fn constructed(&self) {
+            self.parent_constructed();
+
+            let obj = self.obj();
+
+            let settings = gio::Settings::new(crate::config::APP_ID);
+            let settings_handler = settings.connect_changed(
+                Some("theme-name"),
+                clone!(@weak obj => move |_, _| {
+                    let imp = obj.imp();
+
+                    if imp.chat_theme.borrow().is_none() {
+                        obj.refresh_theme(imp.dark.get());
+                    }
+                }),
+            );
+
+            self.settings.set(settings).unwrap();
+            self.settings_handler.replace(Some(settings_handler));
+
+            self.pattern.set(DEFAULT_PATTERN.to_owned()).unwrap();
+
+            // Dark / light style
+            let style_manager = adw::StyleManager::default();
+            self.dark.set(style_manager.is_dark());
+
+            style_manager.connect_dark_notify(clone!(@weak obj => move |style_manager| {
+                obj.refresh_theme(style_manager.is_dark());
+            }));
+
+            if style_manager.is_high_contrast() {
+                obj.add_css_class("fallback");
+            }
+
+            style_manager.connect_high_contrast_notify(clone!(@weak obj => move |style_manager| {
+                if style_manager.is_high_contrast() {
+                    obj.add_css_class("fallback");
+                } else if obj.shader().is_some() {
+                    obj.remove_css_class("fallback");
+                }
+            }));
+
+            // Gradient animation
+            let target = adw::CallbackAnimationTarget::new(clone!(@weak obj => move |progress| {
+                let imp = obj.imp();
+                imp.background_cache.take();
+                let progress = progress as f32;
+                if progress >= 1.0 {
+                    imp.progress.set(0.0);
+                    imp.phase.set((imp.phase.get() + 1) % 8);
+                } else {
+                    imp.progress.set(progress)
+                }
+                obj.queue_draw();
+            }));
+
+            let animation = adw::TimedAnimation::builder()
+                .widget(&*obj)
+                .value_from(0.0)
+                .value_to(1.0)
+                .duration(200)
+                .target(&target)
+                .easing(adw::Easing::EaseInOutQuad)
+                .build()
+                .upcast();
+
+            self.gradient_animation.set(animation).unwrap();
+        }
+
+        fn dispose(&self) {
+            if let Some(settings) = self.settings.get() {
+                settings.disconnect(self.settings_handler.take().unwrap());
+            }
+        }
+    }
+
+    impl WidgetImpl for Background {
+        fn realize(&self) {
+            self.parent_realize();
+            self.obj().ensure_shader();
+            self.obj().refresh_theme(self.dark.get());
+        }
+
+        fn snapshot(&self, snapshot: &gtk::Snapshot) {
+            let widget = self.obj();
+
+            if widget.has_css_class("fallback") {
+                // fallback code
+                if let Some(child) = widget.child() {
+                    widget.snapshot_child(&child, snapshot);
+                }
+                return;
+            };
+
+            self.snapshot_background(snapshot);
+
+            if let Some(child) = widget.child() {
+                widget.snapshot_child(&child, snapshot);
+            }
+        }
+    }
+
+    impl BinImpl for Background {}
+
+    impl Background {
+        fn snapshot_background(&self, snapshot: &gtk::Snapshot) {
+            let widget = self.obj();
+
+            let width = widget.width() as f32;
+            let height = widget.height() as f32;
+
+            if width == 0.0 || height == 0.0 {
+                return;
+            }
+
+            let bounds = graphene::Rect::new(0.0, 0.0, width, height);
+
+            let size_changed = self.last_size.replace((width, height)) != (width, height);
+
+            self.snapshot_gradient(snapshot, &bounds, size_changed);
+
+            self.snapshot_pattern(snapshot, &bounds);
+        }
+
+        fn snapshot_gradient(
+            &self,
+            snapshot: &gtk::Snapshot,
+            bounds: &graphene::Rect,
+            size_changed: bool,
+        ) {
+            if self.progress.get() == 0.0 {
+                let texture = match self.background_cache.take() {
+                    Some(texture) if !size_changed => texture,
+                    _ => {
+                        let renderer = self.obj().native().unwrap().renderer();
+
+                        renderer.render_texture(self.obj().bg_node(bounds, bounds), Some(bounds))
+                    }
+                };
+
+                snapshot.append_texture(&texture, bounds);
+                self.background_cache.replace(Some(texture));
+            } else {
+                snapshot.append_node(&self.obj().bg_node(bounds, bounds));
+            }
+        }
+
+        fn snapshot_pattern(&self, snapshot: &gtk::Snapshot, bounds: &graphene::Rect) {
+            let pattern_intensity = self.pattern_intensity.get();
+
+            if pattern_intensity == 0.0 {
+                return;
+            }
+
+            let texture = self.document_texture.borrow();
+
+            let pattern = texture.as_ref().unwrap_or(&DEFAULT_PATTERN);
+
+            let pattern_scale = if self.thumbnail_mode.get() {
+                if texture.is_some() {
+                    0.5
+                } else {
+                    0.2
+                }
+            } else {
+                0.3
+            };
+
+            let pattern_bounds = graphene::Rect::new(
+                0.0,
+                0.0,
+                pattern.width() as f32 * pattern_scale,
+                pattern.height() as f32 * pattern_scale,
+            );
+
+            let mut matrix = [0.0; 16];
+            let mut offset = [0.0; 4];
+
+            if self.pattern_is_inverted.get() {
+                matrix[15] = -pattern_intensity;
+                offset = [0.08; 4];
+                offset[3] = 1.0;
+            } else {
+                matrix[15] = pattern_intensity * 0.3;
+            }
+
+            let color_matrix = graphene::Matrix::from_float(matrix);
+            let color_offset = graphene::Vec4::from_float(offset);
+
+            snapshot.push_color_matrix(&color_matrix, &color_offset);
+            snapshot.push_repeat(bounds, Some(&pattern_bounds));
+            snapshot.append_scaled_texture(pattern, gsk::ScalingFilter::Trilinear, &pattern_bounds); // .append_texture(pattern, &pattern_bounds);
+            snapshot.pop();
+            snapshot.pop();
+        }
+
+        pub(super) fn fill_node(
+            &self,
+            bounds: &graphene::Rect,
+            gradient_bounds: &graphene::Rect,
+            colors: &[graphene::Vec3],
+        ) -> gsk::RenderNode {
+            match colors.len() {
+                1 => gsk::ColorNode::new(&vec3_to_rgba(&colors[0]), bounds).upcast(),
+                2 => gsk::LinearGradientNode::new(
+                    bounds,
+                    &gradient_bounds.top_left(),
+                    &gradient_bounds.bottom_left(),
+                    &[
+                        gsk::ColorStop::new(0.0, vec3_to_rgba(&colors[0])),
+                        gsk::ColorStop::new(1.0, vec3_to_rgba(&colors[1])),
+                    ],
+                )
+                .upcast(),
+                3 => {
+                    log::error!("Three color gradients aren't supported yet");
+
+                    let mut colors = colors.to_vec();
+                    colors.push(colors[2]);
+
+                    self.gradient_shader_node(bounds, gradient_bounds, &colors)
+                        .upcast()
+                }
+                4 => self
+                    .gradient_shader_node(bounds, gradient_bounds, colors)
+                    .upcast(),
+                _ => unreachable!("Unsupported color count"),
+            }
+        }
+
+        pub(super) fn gradient_shader_node(
+            &self,
+            bounds: &graphene::Rect,
+            gradient_bounds: &graphene::Rect,
+            colors: &[graphene::Vec3],
+        ) -> gsk::GLShaderNode {
+            let Some(gradient_shader) = self.obj().shader() else {
+                unreachable!()
+            };
+
+            let args_builder = gsk::ShaderArgsBuilder::new(gradient_shader, None);
+
+            let progress = self.progress.get();
+            let phase = self.phase.get() as usize;
+
+            let &[c1, c2, c3, c4] = colors else {
+                  unimplemented!("Unexpected color count")
+            };
+
+            args_builder.set_vec3(0, &c1);
+            args_builder.set_vec3(1, &c2);
+            args_builder.set_vec3(2, &c3);
+            args_builder.set_vec3(3, &c4);
+
+            let [p12, p34] = Self::calculate_positions(progress, phase);
+            args_builder.set_vec4(4, &p12);
+            args_builder.set_vec4(5, &p34);
+
+            let gradient_bounds = {
+                graphene::Vec4::new(
+                    gradient_bounds.x(),
+                    gradient_bounds.y(),
+                    gradient_bounds.width(),
+                    gradient_bounds.height(),
+                )
+            };
+
+            args_builder.set_vec4(6, &gradient_bounds);
+
+            gsk::GLShaderNode::new(gradient_shader, bounds, &args_builder.to_args(), &[])
+        }
+
+        fn calculate_positions(progress: f32, phase: usize) -> [graphene::Vec4; 2] {
+            static POSITIONS: [(f32, f32); 8] = [
+                (0.80, 0.10),
+                (0.60, 0.20),
+                (0.35, 0.25),
+                (0.25, 0.60),
+                (0.20, 0.90),
+                (0.40, 0.80),
+                (0.65, 0.75),
+                (0.75, 0.40),
+            ];
+
+            let mut points = [(0.0, 0.0); 4];
+
+            for i in 0..4 {
+                let start = POSITIONS[(i * 2 + phase) % 8];
+                let end = POSITIONS[(i * 2 + phase + 1) % 8];
+
+                fn interpolate(start: f32, end: f32, value: f32) -> f32 {
+                    start + ((end - start) * value)
+                }
+
+                let x = interpolate(start.0, end.0, progress);
+                let y = interpolate(start.1, end.1, progress);
+
+                points[i] = (x, y);
+            }
+
+            let points: Vec<_> = points
+                .chunks(2)
+                .map(|p| {
+                    let [(x1, y1), (x2, y2)]: [(f32, f32); 2] = p.try_into().unwrap();
+                    graphene::Vec4::from_float([x1, y1, x2, y2])
+                })
+                .collect();
+
+            points.try_into().unwrap()
+        }
+
+        fn setup_provider(&self, controls_accent: bool) {
+            self.controls_accent.set(controls_accent);
+
+            if let Some(display) = gdk::Display::default() {
+                let provider = self.css_provider.get_or_init(gtk::CssProvider::new);
+
+                if controls_accent {
+                    gtk::style_context_add_provider_for_display(&display, provider, 1000);
+                } else {
+                    gtk::style_context_remove_provider_for_display(&display, provider);
+                }
+            }
+        }
+    }
+}
+
+glib::wrapper! {
+    pub(crate) struct Background(ObjectSubclass<imp::Background>)
+        @extends gtk::Widget, adw::Bin;
+}
+
+impl Background {
+    pub(crate) fn new() -> Self {
+        glib::Object::new()
+    }
+
+    pub(crate) fn set_chat_theme(&self, theme: Option<tdlib::types::ChatTheme>) {
+        let old_theme = &self.imp().chat_theme;
+
+        if *old_theme.borrow() != theme {
+            old_theme.replace(theme);
+            self.refresh_theme(adw::StyleManager::default().is_dark());
+        }
+    }
+
+    pub(crate) fn set_theme(&self, theme: &tdlib::types::ThemeSettings) {
+        let Some(background) = &theme.background else { return; };
+        let imp = self.imp();
+
+        imp.dark.set(background.is_dark);
+
+        imp.pattern_intensity.take();
+
+        self.update_accent(theme.accent_color, theme.outgoing_message_accent_color);
+
+        let bg_fill = match &background.r#type {
+            tdlib::enums::BackgroundType::Pattern(pattern) => {
+                imp.pattern_is_inverted.set(pattern.is_inverted);
+                imp.pattern_intensity.set(pattern.intensity as f32 / 100.0);
+                &pattern.fill
+            }
+            tdlib::enums::BackgroundType::Fill(fill) => &fill.fill,
+            tdlib::enums::BackgroundType::Wallpaper(_) => {
+                unimplemented!("Wallpaper chat background")
+            }
+        };
+
+        imp.document.replace(background.document.clone());
+
+        imp.bg_colors.replace(fill_colors(bg_fill));
+        imp.message_colors
+            .replace(fill_colors(&theme.outgoing_message_fill));
+
+        imp.background_cache.take();
+
+        imp.document_texture.take();
+
+        match &background.document {
+            Some(doc) if doc.document.local.is_downloading_completed => {
+                // load_document will call queue_draw fast enough
+            }
+            _ => self.queue_draw(),
+        }
+
+        self.load_document();
+    }
+
+    pub(crate) fn animate(&self) {
+        let nothing_to_animate = self.imp().bg_colors.borrow().len() <= 2
+            && self.imp().message_colors.borrow().len() <= 2;
+
+        if nothing_to_animate {
+            return;
+        }
+
+        let animation = self.imp().gradient_animation.get().unwrap();
+
+        let val = animation.value();
+        if val == 0.0 || val == 1.0 {
+            animation.play()
+        }
+    }
+
+    pub fn subscribe_to_redraw(&self, child: &gtk::Widget) {
+        let animation = self.imp().gradient_animation.get().unwrap();
+        animation.connect_value_notify(clone!(@weak child => move |_| child.queue_draw()));
+    }
+
+    pub fn bg_node(
+        &self,
+        bounds: &graphene::Rect,
+        gradient_bounds: &graphene::Rect,
+    ) -> gsk::RenderNode {
+        self.imp()
+            .fill_node(bounds, gradient_bounds, &self.imp().bg_colors.borrow())
+    }
+
+    pub fn message_bg_node(
+        &self,
+        bounds: &graphene::Rect,
+        gradient_bounds: &graphene::Rect,
+    ) -> gsk::RenderNode {
+        self.imp()
+            .fill_node(bounds, gradient_bounds, &self.imp().message_colors.borrow())
+    }
+
+    fn shader(&self) -> Option<&'static gsk::GLShader> {
+        unsafe { SHADER.as_ref() }
+    }
+
+    fn ensure_shader(&self) {
+        if self.shader().is_none() {
+            let renderer = self.native().unwrap().renderer();
+
+            let shader = gsk::GLShader::from_bytes(&GRADIENT_SHADER.into());
+            match shader.compile(&renderer) {
+                Err(e) => {
+                    if !e.matches(gio::IOErrorEnum::NotSupported) {
+                        log::error!("can't compile shader for gradient background {e}");
+                    }
+                    self.add_css_class("fallback");
+                }
+                Ok(_) => unsafe {
+                    SHADER = Some(shader);
+                },
+            }
+        };
+    }
+
+    pub(crate) fn set_session(&self, session: &crate::Session) {
+        self.imp().session.replace(session.downgrade());
+    }
+
+    fn session(&self) -> Option<crate::Session> {
+        self.ancestor(crate::Session::static_type())
+            .and_downcast::<crate::Session>()
+            .or(self.imp().session.borrow().upgrade())
+    }
+
+    fn load_document(&self) {
+        let imp = self.imp();
+
+        if let Some(document) = &*imp.document.borrow() {
+            if let Some(session) = self.session() {
+                let file = if !imp.thumbnail_mode.get() {
+                    &document.document
+                } else if let Some(thumbnail) = &document.thumbnail {
+                    &thumbnail.file
+                } else {
+                    return;
+                };
+
+                imp.document_target_file_id.set(file.id);
+
+                if file.local.is_downloading_completed {
+                    self.set_downloaded_file(file);
+                } else {
+                    let file_id = file.id;
+
+                    spawn(clone!(@weak self as obj => async move {
+                        match session.download_file(file_id).await {
+                            Ok(file) => {
+                                obj.set_downloaded_file(&file);
+                            }
+                            Err(e) => log::error!("Can't download background: {e:?}")
+                        }
+                    }))
+                }
+            }
+        }
+    }
+
+    fn set_downloaded_file(&self, file: &tdlib::types::File) {
+        let imp = self.imp();
+
+        assert!(file.local.is_downloading_completed);
+
+        let file_id = file.id;
+
+        if imp.document_target_file_id.get() != file_id {
+            return;
+        }
+
+        if let Some((_, texture)) = imp
+            .loaded_documents
+            .borrow()
+            .iter()
+            .find(|(id, _)| *id == file_id)
+        {
+            imp.document_texture.replace(Some(texture.to_owned()));
+            self.queue_draw();
+            return;
+        }
+
+        let path = file.local.path.clone();
+
+        let cache_path = path.replace(".tgv", "cache.png");
+
+        if let Ok(texture) = gdk::Texture::from_filename(&cache_path) {
+            self.imp()
+                .loaded_documents
+                .borrow_mut()
+                .push((file_id, texture.clone()));
+            self.imp().document_texture.replace(Some(texture));
+            self.queue_draw();
+            return;
+        }
+
+        let (sender, receiver) =
+            glib::MainContext::channel::<(i32, gdk::Texture)>(glib::PRIORITY_DEFAULT);
+
+        std::thread::spawn(move || {
+            if path.ends_with(".tgv") {
+                if let Ok(data) = std::fs::read(&path) {
+                    let decompressor = gio::ZlibDecompressor::new(gio::ZlibCompressorFormat::Gzip);
+
+                    let mut bytes_read = 0;
+
+                    let mut accumulator = Vec::<u8>::new();
+
+                    let mut buffer = [0; 262144];
+
+                    loop {
+                        let Ok((result, br, bw)) = decompressor.convert(
+                            &data[bytes_read..],
+                            &mut buffer,
+                            gio::ConverterFlags::NONE,
+                        ) else {
+                            log::error!("Decompression error");
+                            return;
+                        };
+
+                        accumulator.extend_from_slice(&buffer[..bw]);
+
+                        bytes_read += br;
+
+                        if result == gio::ConverterResult::Finished {
+                            break;
+                        }
+                    }
+
+                    match gdk::Texture::from_bytes(&glib::Bytes::from_owned(accumulator)) {
+                        Ok(texture) => {
+                            texture.save_to_png(&cache_path).unwrap();
+                            sender.send((file_id, texture)).unwrap();
+                        }
+                        Err(e) => {
+                            log::error!("Failed to create texture from decompressed data {e}")
+                        }
+                    }
+                }
+            } else {
+                match gdk::Texture::from_filename(&path) {
+                    Ok(texture) => sender.send((file_id, texture)).unwrap(),
+                    Err(e) => log::error!("Failed to create texture from filename {e}"),
+                };
+            }
+        });
+
+        receiver.attach(
+            None,
+            clone!(@weak self as obj => @default-return glib::Continue(false),
+                move |(id, texture)| {
+                    obj.imp().loaded_documents.borrow_mut().push((id, texture.clone()));
+                    obj.imp().document_texture.replace(Some(texture));
+                    obj.queue_draw();
+                    glib::Continue(false)
+                }
+            ),
+        );
+    }
+
+    fn refresh_theme(&self, dark: bool) {
+        if let Some(chat_theme) = &*self.imp().chat_theme.borrow() {
+            let theme = if dark {
+                &chat_theme.dark_settings
+            } else {
+                &chat_theme.light_settings
+            };
+
+            self.set_theme(theme);
+        } else {
+            let chat_theme = self
+                .session()
+                .map(|s| s.default_chat_theme())
+                .unwrap_or(crate::utils::default_theme());
+
+            if dark {
+                self.set_theme(&chat_theme.dark_settings);
+            } else {
+                self.set_theme(&chat_theme.light_settings);
+            }
+        }
+
+        // For some reason tdlib tells that light theme is dark
+        self.imp().dark.set(dark);
+
+        if let Some(animation) = self.imp().gradient_animation.get() {
+            animation.notify("value");
+        }
+    }
+
+    fn update_accent(&self, accent: i32, outgoing_accent: i32) {
+        if !self.controls_accent() {
+            return;
+        }
+
+        let provider = self.imp().css_provider.get().unwrap();
+
+        let mut css = String::new();
+
+        if accent != -1 {
+            let accent = vec3_to_rgba(&int_color_to_vec3(&accent));
+            _ = write!(css, "@define-color accent_color {accent};");
+            _ = write!(css, "@define-color accent_bg_color {accent};");
+        }
+
+        if !adw::StyleManager::default().is_dark() {
+            let outgoing_accent = vec3_to_rgba(&int_color_to_vec3(&outgoing_accent));
+            _ = write!(
+                css,
+                "@define-color outgoing_message_accent_color {outgoing_accent};"
+            );
+        }
+
+        provider.load_from_data(&css);
+    }
+}
+
+impl Default for Background {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+fn fill_colors(fill: &tdlib::enums::BackgroundFill) -> Vec<graphene::Vec3> {
+    match fill {
+        tdlib::enums::BackgroundFill::FreeformGradient(gradient) if gradient.colors.len() == 4 => {
+            gradient.colors.iter().map(int_color_to_vec3).collect()
+        }
+        tdlib::enums::BackgroundFill::Solid(solid) => vec![int_color_to_vec3(&solid.color)],
+        tdlib::enums::BackgroundFill::Gradient(gradient) => vec![
+            int_color_to_vec3(&gradient.top_color),
+            int_color_to_vec3(&gradient.bottom_color),
+        ],
+        _ => unimplemented!("Unsupported background fill: {fill:?}"),
+    }
+}
+
+fn int_color_to_vec3(color: &i32) -> graphene::Vec3 {
+    let [_, r, g, b] = color.to_be_bytes();
+    graphene::Vec3::new(r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0)
+}
+
+fn vec3_to_rgba(vec3: &graphene::Vec3) -> gdk::RGBA {
+    let [red, green, blue] = vec3.to_float();
+    gdk::RGBA::new(red, green, blue, 1.0)
+}
diff --git a/src/components/mod.rs b/src/components/mod.rs
index f5efdd186..715c1b57a 100644
--- a/src/components/mod.rs
+++ b/src/components/mod.rs
@@ -1,9 +1,13 @@
 mod avatar;
+mod background;
 mod message_entry;
 mod snow;
 mod sticker;
+mod theme_preview;
 
 pub(crate) use self::avatar::Avatar;
+pub(crate) use self::background::Background;
 pub(crate) use self::message_entry::MessageEntry;
 pub(crate) use self::snow::Snow;
 pub(crate) use self::sticker::Sticker;
+pub(crate) use self::theme_preview::ThemePreview;
diff --git a/src/components/theme_preview.rs b/src/components/theme_preview.rs
new file mode 100644
index 000000000..65fa8a1a7
--- /dev/null
+++ b/src/components/theme_preview.rs
@@ -0,0 +1,154 @@
+use gtk::glib;
+use gtk::graphene;
+use gtk::gsk;
+use gtk::prelude::*;
+use gtk::subclass::prelude::*;
+
+use super::Background;
+
+mod imp {
+    use super::*;
+
+    #[derive(Default, gtk::CompositeTemplate)]
+    #[template(string = r#"
+        template $ComponentsThemePreview {
+            $ContentBackground background {
+                styles ["card"]
+                overflow: hidden;
+                thumbnail-mode: true;
+            }
+
+            Label label {
+                styles ["title-1"]
+            }
+        }
+    "#)]
+    pub struct ThemePreview {
+        #[template_child]
+        pub(super) background: TemplateChild<Background>,
+        #[template_child]
+        pub(super) label: TemplateChild<gtk::Label>,
+    }
+
+    #[glib::object_subclass]
+    impl ObjectSubclass for ThemePreview {
+        const NAME: &'static str = "ComponentsThemePreview";
+        type Type = super::ThemePreview;
+        type ParentType = gtk::Widget;
+
+        fn class_init(klass: &mut Self::Class) {
+            klass.set_css_name("themepreview");
+            klass.bind_template();
+        }
+
+        fn instance_init(obj: &glib::subclass::InitializingObject<Self>) {
+            obj.init_template();
+        }
+    }
+
+    impl ObjectImpl for ThemePreview {
+        fn dispose(&self) {
+            self.background.unparent();
+            self.label.unparent();
+        }
+    }
+
+    impl WidgetImpl for ThemePreview {
+        fn measure(&self, orientation: gtk::Orientation, for_size: i32) -> (i32, i32, i32, i32) {
+            _ = self.background.measure(orientation, for_size);
+            _ = self.label.measure(orientation, for_size);
+            if orientation == gtk::Orientation::Vertical {
+                (110, 110, -1, -1)
+            } else {
+                (80, 80, -1, -1)
+            }
+        }
+
+        fn request_mode(&self) -> gtk::SizeRequestMode {
+            gtk::SizeRequestMode::ConstantSize
+        }
+
+        fn size_allocate(&self, width: i32, height: i32, baseline: i32) {
+            self.background.allocate(width, height, baseline, None);
+
+            let label_transform =
+                gsk::Transform::new().translate(&graphene::Point::new(0.0, height as f32 - 40.0));
+
+            self.label
+                .allocate(width, 40, baseline, Some(label_transform));
+        }
+
+        fn snapshot(&self, snapshot: &gtk::Snapshot) {
+            self.parent_snapshot(snapshot);
+
+            let widget = self.obj();
+
+            let width = widget.width() as f32;
+            let height = widget.height() as f32;
+
+            let msg_height = 24.0;
+            let msg_width = 46.0;
+            let msg_margins = 8.0;
+
+            let gradient_bounds = graphene::Rect::new(0.0, 0.0, width, height);
+
+            let outgoing_message_bounds = graphene::Rect::new(
+                width - msg_width - msg_margins,
+                msg_margins,
+                msg_width,
+                msg_height,
+            );
+
+            let message_node = self
+                .background
+                .message_bg_node(&outgoing_message_bounds, &outgoing_message_bounds);
+
+            snapshot.push_rounded_clip(&gsk::RoundedRect::from_rect(outgoing_message_bounds, 16.0));
+            snapshot.append_node(message_node);
+            snapshot.pop();
+
+            let ingoing_message_bounds = graphene::Rect::new(
+                msg_margins,
+                msg_margins * 2.0 + msg_height,
+                msg_width,
+                msg_height,
+            );
+
+            let message_node = self
+                .background
+                .bg_node(&ingoing_message_bounds, &gradient_bounds);
+
+            snapshot.push_rounded_clip(&gsk::RoundedRect::from_rect(ingoing_message_bounds, 16.0));
+
+            snapshot.append_color(&widget.color(), &ingoing_message_bounds);
+            snapshot.push_opacity(0.1);
+            snapshot.append_node(message_node);
+            snapshot.pop();
+            snapshot.pop();
+        }
+    }
+}
+
+glib::wrapper! {
+    pub struct ThemePreview(ObjectSubclass<imp::ThemePreview>)
+        @extends gtk::Widget;
+}
+
+impl ThemePreview {
+    pub(crate) fn new(session: Option<&crate::Session>) -> Self {
+        Self::from_chat_theme(crate::utils::default_theme(), session)
+    }
+
+    pub(crate) fn from_chat_theme(
+        chat_theme: tdlib::types::ChatTheme,
+        session: Option<&crate::Session>,
+    ) -> Self {
+        let obj: Self = glib::Object::new();
+        obj.imp().label.set_label(&chat_theme.name);
+        obj.imp().background.set_chat_theme(Some(chat_theme));
+        if let Some(session) = session {
+            obj.imp().background.set_session(session);
+        }
+        obj
+    }
+}
diff --git a/src/session/content/background.rs b/src/session/content/background.rs
deleted file mode 100644
index 713ca213a..000000000
--- a/src/session/content/background.rs
+++ /dev/null
@@ -1,408 +0,0 @@
-use std::cell::Cell;
-use std::cell::RefCell;
-
-use adw::prelude::*;
-use adw::subclass::prelude::*;
-use glib::clone;
-use glib::once_cell::unsync::OnceCell;
-use gtk::gdk;
-use gtk::gio;
-use gtk::glib;
-use gtk::graphene;
-use gtk::gsk;
-
-const GRADIENT_SHADER: &[u8] = r#"
-// That shader was taken from Telegram for android source
-// https://github.com/DrKLO/Telegram/commit/2112affb2e4941334f8fbc3944385806b3c4e3d6#diff-dfdd1e8c4691747fd30199b7a2f5041a126b23e1450b29afe441eb0ebed01c68
-
-precision highp float;
-
-uniform vec3 color1;
-uniform vec3 color2;
-uniform vec3 color3;
-uniform vec3 color4;
-uniform vec2 p1;
-uniform vec2 p2;
-uniform vec2 p3;
-uniform vec2 p4;
-
-void mainImage(out vec4 fragColor,
-               in vec2 fragCoord,
-               in vec2 resolution,
-               in vec2 uv) {
-    uv.y = 1.0 - uv.y;
-
-    float dp1 = distance(uv, p1);
-    float dp2 = distance(uv, p2);
-    float dp3 = distance(uv, p3);
-    float dp4 = distance(uv, p4);
-    float minD = min(dp1, min(dp2, min(dp3, dp4)));
-    float p = 5.0;
-    dp1 = pow(1.0 - (dp1 - minD), p);
-    dp2 = pow(1.0 - (dp2 - minD), p);
-    dp3 = pow(1.0 - (dp3 - minD), p);
-    dp4 = pow(1.0 - (dp4 - minD), p);
-    float sumDp = dp1 + dp2 + dp3 + dp4;
-
-    vec3 color = (color1 * dp1 + color2 * dp2 + color3 * dp3 + color4 * dp4) / sumDp;
-    fragColor = vec4(color, 1.0);
-}
-"#
-.as_bytes();
-
-mod imp {
-    use super::*;
-
-    #[derive(Default)]
-    pub(crate) struct Background {
-        pub(super) gradient_texture: RefCell<Option<gdk::Texture>>,
-        pub(super) last_size: Cell<(f32, f32)>,
-
-        pub(super) shader: RefCell<Option<gsk::GLShader>>,
-        pub(super) pattern: OnceCell<gdk::Texture>,
-
-        pub(super) animation: OnceCell<adw::Animation>,
-        pub(super) progress: Cell<f32>,
-        pub(super) phase: Cell<u32>,
-
-        pub(super) dark: Cell<bool>,
-
-        pub(super) colors: RefCell<Vec<graphene::Vec3>>,
-    }
-
-    #[glib::object_subclass]
-    impl ObjectSubclass for Background {
-        const NAME: &'static str = "ContentBackground";
-        type Type = super::Background;
-        type ParentType = adw::Bin;
-    }
-
-    impl ObjectImpl for Background {
-        fn constructed(&self) {
-            self.parent_constructed();
-
-            let obj = self.obj();
-
-            let pattern = gdk::Texture::from_resource("/app/drey/paper-plane/images/pattern.svg");
-
-            self.pattern.set(pattern).unwrap();
-
-            let style_manager = adw::StyleManager::default();
-            obj.set_theme(hard_coded_themes(style_manager.is_dark()));
-
-            style_manager.connect_dark_notify(clone!(@weak obj => move |style_manager| {
-                obj.set_theme(hard_coded_themes(style_manager.is_dark()))
-            }));
-
-            if style_manager.is_high_contrast() {
-                obj.add_css_class("fallback");
-            }
-
-            style_manager.connect_high_contrast_notify(clone!(@weak obj => move |style_manager| {
-                if style_manager.is_high_contrast() {
-                    obj.add_css_class("fallback");
-                } else if obj.imp().shader.borrow().is_some() {
-                    obj.remove_css_class("fallback");
-                }
-            }));
-
-            let target = adw::CallbackAnimationTarget::new(clone!(@weak obj => move |progress| {
-                let imp = obj.imp();
-                imp.gradient_texture.take();
-                let progress = progress as f32;
-                if progress >= 1.0 {
-                    imp.progress.set(0.0);
-                    imp.phase.set((imp.phase.get() + 1) % 8);
-                } else {
-                    imp.progress.set(progress)
-                }
-                obj.queue_draw();
-            }));
-
-            let animation = adw::TimedAnimation::builder()
-                .widget(&*obj)
-                .value_from(0.0)
-                .value_to(1.0)
-                .duration(200)
-                .target(&target)
-                .easing(adw::Easing::EaseInOutQuad)
-                .build()
-                .upcast();
-
-            self.animation.set(animation).unwrap();
-        }
-    }
-
-    impl WidgetImpl for Background {
-        fn realize(&self) {
-            self.parent_realize();
-            self.obj().ensure_shader();
-        }
-
-        fn snapshot(&self, snapshot: &gtk::Snapshot) {
-            let widget = self.obj();
-
-            if widget.has_css_class("fallback") {
-                // fallback code
-                if let Some(child) = widget.child() {
-                    widget.snapshot_child(&child, snapshot);
-                }
-                return;
-            };
-
-            let width = widget.width() as f32;
-            let height = widget.height() as f32;
-
-            if width == 0.0 || height == 0.0 {
-                return;
-            }
-
-            let bounds = graphene::Rect::new(0.0, 0.0, width, height);
-
-            let size_changed = self.last_size.replace((width, height)) != (width, height);
-
-            self.snapshot_gradient(snapshot, &bounds, size_changed);
-
-            self.snapshot_pattern(snapshot, &bounds);
-        }
-    }
-
-    impl BinImpl for Background {}
-
-    impl Background {
-        fn snapshot_gradient(
-            &self,
-            snapshot: &gtk::Snapshot,
-            bounds: &graphene::Rect,
-            size_changed: bool,
-        ) {
-            if self.progress.get() == 0.0 {
-                let texture = match self.gradient_texture.take() {
-                    Some(texture) if !size_changed => texture,
-                    _ => {
-                        let renderer = self.obj().native().unwrap().renderer();
-                        renderer.render_texture(self.gradient_shader_node(bounds), Some(bounds))
-                    }
-                };
-
-                snapshot.append_texture(&texture, bounds);
-                self.gradient_texture.replace(Some(texture));
-            } else {
-                snapshot.append_node(self.gradient_shader_node(bounds));
-            }
-        }
-
-        fn snapshot_pattern(&self, snapshot: &gtk::Snapshot, bounds: &graphene::Rect) {
-            let widget = self.obj();
-            let pattern = self.pattern.get().unwrap();
-
-            let pattern_bounds = graphene::Rect::new(
-                0.0,
-                0.0,
-                pattern.width() as f32 * 0.3,
-                pattern.height() as f32 * 0.3,
-            );
-
-            let mut matrix = [0.0; 16];
-            let mut offset = [0.0; 4];
-            if self.dark.get() {
-                matrix[15] = -0.3;
-                offset = [0.08; 4];
-                offset[3] = 1.0;
-            } else {
-                matrix[15] = 0.1;
-            }
-            let color_matrix = graphene::Matrix::from_float(matrix);
-            let color_offset = graphene::Vec4::from_float(offset);
-
-            snapshot.push_color_matrix(&color_matrix, &color_offset);
-            snapshot.push_repeat(bounds, Some(&pattern_bounds));
-            snapshot.append_texture(pattern, &pattern_bounds);
-            snapshot.pop();
-            snapshot.pop();
-
-            if let Some(child) = widget.child() {
-                widget.snapshot_child(&child, snapshot);
-            }
-        }
-
-        fn gradient_shader_node(&self, bounds: &graphene::Rect) -> gsk::GLShaderNode {
-            let Some(gradient_shader) = &*self.shader.borrow() else {
-                unreachable!()
-            };
-
-            let args_builder = gsk::ShaderArgsBuilder::new(gradient_shader, None);
-
-            let progress = self.progress.get();
-            let phase = self.phase.get() as usize;
-
-            let colors = self.colors.borrow();
-
-            let &[c1, c2, c3, c4] = &colors[..] else {
-                unimplemented!("Unexpected color count");
-            };
-
-            args_builder.set_vec3(0, &c1);
-            args_builder.set_vec3(1, &c2);
-            args_builder.set_vec3(2, &c3);
-            args_builder.set_vec3(3, &c4);
-
-            let [p1, p2, p3, p4] = Self::calculate_positions(progress, phase);
-            args_builder.set_vec2(4, &p1);
-            args_builder.set_vec2(5, &p2);
-            args_builder.set_vec2(6, &p3);
-            args_builder.set_vec2(7, &p4);
-
-            gsk::GLShaderNode::new(gradient_shader, bounds, &args_builder.to_args(), &[])
-        }
-
-        fn calculate_positions(progress: f32, phase: usize) -> [graphene::Vec2; 4] {
-            static POSITIONS: [(f32, f32); 8] = [
-                (0.80, 0.10),
-                (0.60, 0.20),
-                (0.35, 0.25),
-                (0.25, 0.60),
-                (0.20, 0.90),
-                (0.40, 0.80),
-                (0.65, 0.75),
-                (0.75, 0.40),
-            ];
-
-            let mut points = [graphene::Vec2::new(0.0, 0.0); 4];
-
-            for i in 0..4 {
-                let start = POSITIONS[(i * 2 + phase) % 8];
-                let end = POSITIONS[(i * 2 + phase + 1) % 8];
-
-                fn interpolate(start: f32, end: f32, value: f32) -> f32 {
-                    start + ((end - start) * value)
-                }
-
-                let x = interpolate(start.0, end.0, progress);
-                let y = interpolate(start.1, end.1, progress);
-
-                points[i] = graphene::Vec2::new(x, y);
-            }
-
-            points
-        }
-    }
-}
-
-glib::wrapper! {
-    pub(crate) struct Background(ObjectSubclass<imp::Background>)
-        @extends gtk::Widget, adw::Bin;
-}
-
-impl Background {
-    pub(crate) fn new() -> Self {
-        glib::Object::new()
-    }
-
-    pub(crate) fn set_theme(&self, theme: tdlib::types::ThemeSettings) {
-        let Some(background) = theme.background else { return; };
-        let imp = self.imp();
-
-        imp.dark.set(background.is_dark);
-
-        let fill = match background.r#type {
-            tdlib::enums::BackgroundType::Pattern(pattern) => pattern.fill,
-            tdlib::enums::BackgroundType::Fill(fill) => fill.fill,
-            tdlib::enums::BackgroundType::Wallpaper(_) => {
-                unimplemented!("Wallpaper chat background")
-            }
-        };
-
-        match fill {
-            tdlib::enums::BackgroundFill::FreeformGradient(gradient) => {
-                if gradient.colors.len() != 4 {
-                    unimplemented!("Unsupported gradient colors count");
-                }
-
-                let colors = gradient
-                    .colors
-                    .into_iter()
-                    .map(|int_color| {
-                        let r = (int_color >> 16) & 0xFF;
-                        let g = (int_color >> 8) & 0xFF;
-                        let b = int_color & 0xFF;
-
-                        graphene::Vec3::new(r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0)
-                    })
-                    .collect();
-
-                imp.colors.replace(colors);
-            }
-            _ => unimplemented!("Background fill"),
-        }
-
-        imp.gradient_texture.take();
-        self.queue_draw();
-    }
-
-    pub(crate) fn animate(&self) {
-        let animation = self.imp().animation.get().unwrap();
-
-        let val = animation.value();
-        if val == 0.0 || val == 1.0 {
-            animation.play()
-        }
-    }
-
-    fn ensure_shader(&self) {
-        let imp = self.imp();
-        if imp.shader.borrow().is_none() {
-            let renderer = self.native().unwrap().renderer();
-
-            let shader = gsk::GLShader::from_bytes(&GRADIENT_SHADER.into());
-            match shader.compile(&renderer) {
-                Err(e) => {
-                    if !e.matches(gio::IOErrorEnum::NotSupported) {
-                        log::error!("can't compile shader for gradient background {e}");
-                    }
-                    self.add_css_class("fallback");
-                }
-                Ok(_) => {
-                    imp.shader.replace(Some(shader));
-                }
-            }
-        };
-    }
-}
-
-impl Default for Background {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-fn hard_coded_themes(dark: bool) -> tdlib::types::ThemeSettings {
-    fn theme(dark: bool, colors: Vec<i32>) -> tdlib::types::ThemeSettings {
-        use tdlib::enums::BackgroundFill::*;
-        use tdlib::enums::BackgroundType::Fill;
-        use tdlib::types::*;
-
-        ThemeSettings {
-            background: Some(Background {
-                is_default: true,
-                is_dark: dark,
-                r#type: Fill(BackgroundTypeFill {
-                    fill: FreeformGradient(BackgroundFillFreeformGradient { colors }),
-                }),
-                id: 0,
-                name: String::new(),
-                document: None,
-            }),
-            accent_color: 0,
-            animate_outgoing_message_fill: false,
-            outgoing_message_accent_color: 0,
-            outgoing_message_fill: Solid(BackgroundFillSolid { color: 0 }),
-        }
-    }
-
-    if dark {
-        theme(dark, vec![0xd6932e, 0xbc40db, 0x4280d7, 0x614ed5])
-    } else {
-        theme(dark, vec![0x94dae9, 0x9aeddb, 0x94c3f6, 0xac96f7])
-    }
-}
diff --git a/src/session/content/chat_history.rs b/src/session/content/chat_history.rs
index d0c24b51c..b53e7e37f 100644
--- a/src/session/content/chat_history.rs
+++ b/src/session/content/chat_history.rs
@@ -14,8 +14,8 @@ use once_cell::unsync::OnceCell;
 use tdlib::enums::ChatMemberStatus;
 use tdlib::functions;
 
+use crate::components::Background;
 use crate::expressions;
-use crate::session::content::Background;
 use crate::session::content::ChatActionBar;
 use crate::session::content::ChatHistoryError;
 use crate::session::content::ChatHistoryModel;
@@ -37,7 +37,8 @@ mod imp {
     pub(crate) struct ChatHistory {
         pub(super) compact: Cell<bool>,
         pub(super) chat: RefCell<Option<Chat>>,
-        pub(super) chat_handler: RefCell<Option<glib::SignalHandlerId>>,
+        pub(super) chat_handlers: RefCell<Vec<glib::SignalHandlerId>>,
+        pub(super) session_handlers: RefCell<Vec<glib::SignalHandlerId>>,
         pub(super) model: RefCell<Option<ChatHistoryModel>>,
         pub(super) message_menu: OnceCell<gtk::PopoverMenu>,
         pub(super) is_auto_scrolling: Cell<bool>,
@@ -45,8 +46,6 @@ mod imp {
         #[template_child]
         pub(super) window_title: TemplateChild<adw::WindowTitle>,
         #[template_child]
-        pub(super) background: TemplateChild<Background>,
-        #[template_child]
         pub(super) scrolled_window: TemplateChild<gtk::ScrolledWindow>,
         #[template_child]
         pub(super) list_view: TemplateChild<gtk::ListView>,
@@ -357,18 +356,48 @@ impl ChatHistory {
                 }
             }));
 
-            let handler = chat.connect_new_message(clone!(@weak self as obj => move |_, msg| {
-                if msg.is_outgoing() {
-                    obj.imp().background.animate();
-                }
-            }));
+            self.background().set_chat_theme(chat.chat_theme());
 
-            if let Some(old_handler) = self.imp().chat_handler.replace(Some(handler)) {
+            let new_message_handler =
+                chat.connect_new_message(clone!(@weak self as obj => move |_, msg| {
+                    if msg.is_outgoing() {
+                        obj.background().animate();
+                    }
+                }));
+
+            let chat_theme_handler = chat.connect_notify_local(
+                Some("theme-name"),
+                clone!(@weak self as obj => move |chat, _| {
+                    obj.background().set_chat_theme(chat.chat_theme());
+                }),
+            );
+
+            for old_handler in self
+                .imp()
+                .chat_handlers
+                .replace(vec![new_message_handler, chat_theme_handler])
+            {
                 if let Some(old_chat) = &*imp.chat.borrow() {
                     old_chat.disconnect(old_handler);
                 }
             }
 
+            let chat_themes_handler = chat.session().connect_update_chat_themes(
+                clone!(@weak self as obj, @weak chat => move || {
+                    obj.background().set_chat_theme(chat.chat_theme());
+                }),
+            );
+
+            for old_handler in self
+                .imp()
+                .session_handlers
+                .replace(vec![chat_themes_handler])
+            {
+                if let Some(old_chat) = &*imp.chat.borrow() {
+                    old_chat.session().disconnect(old_handler);
+                }
+            }
+
             let selection = gtk::NoSelection::new(Some(list_view_model));
             imp.list_view.set_model(Some(&selection));
 
@@ -400,4 +429,10 @@ impl ChatHistory {
         imp.scrolled_window
             .emit_by_name::<bool>("scroll-child", &[&gtk::ScrollType::End, &false]);
     }
+
+    fn background(&self) -> Background {
+        self.ancestor(Background::static_type())
+            .and_downcast()
+            .unwrap()
+    }
 }
diff --git a/src/session/content/message_row/bubble.rs b/src/session/content/message_row/bubble.rs
index 056a30503..6e01dcdb4 100644
--- a/src/session/content/message_row/bubble.rs
+++ b/src/session/content/message_row/bubble.rs
@@ -4,11 +4,13 @@ use std::hash::Hash;
 use std::hash::Hasher;
 
 use adw::prelude::*;
+use glib::clone;
 use gtk::glib;
 use gtk::subclass::prelude::*;
 use gtk::CompositeTemplate;
 use once_cell::sync::Lazy;
 
+use crate::components::Background;
 use crate::session::content::message_row::MessageIndicators;
 use crate::session::content::message_row::MessageLabel;
 use crate::session::content::message_row::MessageReply;
@@ -37,6 +39,8 @@ mod imp {
     using Adw 1;
 
     template $MessageBubble {
+        overflow: hidden;
+
         Overlay overlay {
             Box {
                 orientation: vertical;
@@ -69,6 +73,8 @@ mod imp {
     pub(crate) struct MessageBubble {
         pub(super) sender_color_class: RefCell<Option<String>>,
         pub(super) sender_binding: RefCell<Option<gtk::ExpressionWatch>>,
+        pub(super) parent_list_view: RefCell<glib::WeakRef<gtk::ListView>>,
+        pub(super) parent_background: RefCell<glib::WeakRef<Background>>,
         #[template_child]
         pub(super) overlay: TemplateChild<gtk::Overlay>,
         #[template_child]
@@ -128,6 +134,54 @@ mod imp {
     }
 
     impl WidgetImpl for MessageBubble {
+        fn realize(&self) {
+            self.parent_realize();
+
+            let widget = self.obj();
+
+            if let Some(view) = widget.parent_list_view() {
+                self.parent_list_view.replace(view.downgrade());
+                view.vadjustment()
+                    .unwrap()
+                    .connect_value_notify(clone!(@weak widget => move |_| {
+                        widget.queue_draw();
+                    }));
+            }
+
+            if let Some(background) = widget.parent_background() {
+                self.parent_background.replace(background.downgrade());
+                background.subscribe_to_redraw(widget.upcast_ref());
+            }
+        }
+
+        fn snapshot(&self, snapshot: &gtk::Snapshot) {
+            let widget = self.obj();
+
+            if let Some(background) = self.parent_background.borrow().upgrade() {
+                if !background.has_css_class("fallback") {
+                    let bounds = {
+                        let width = widget.width() as f32;
+                        let height = widget.height() as f32;
+
+                        gtk::graphene::Rect::new(0.0, 0.0, width, height)
+                    };
+
+                    let gradient_bounds = background.compute_bounds(self.obj().as_ref()).unwrap();
+
+                    if widget.has_css_class("outgoing") {
+                        snapshot
+                            .append_node(&background.message_bg_node(&bounds, &gradient_bounds));
+                    } else {
+                        snapshot.push_opacity(0.1);
+                        snapshot.append_node(&background.bg_node(&bounds, &gradient_bounds));
+                        snapshot.pop();
+                    };
+                }
+            }
+
+            self.parent_snapshot(snapshot);
+        }
+
         fn measure(&self, orientation: gtk::Orientation, for_size: i32) -> (i32, i32, i32, i32) {
             // Limit the widget width
             if orientation == gtk::Orientation::Horizontal {
@@ -317,4 +371,12 @@ impl MessageBubble {
                 .set_indicators(Some(imp.indicators.clone()));
         }
     }
+
+    fn parent_list_view(&self) -> Option<gtk::ListView> {
+        self.ancestor(gtk::ListView::static_type())?.downcast().ok()
+    }
+
+    fn parent_background(&self) -> Option<Background> {
+        self.ancestor(Background::static_type())?.downcast().ok()
+    }
 }
diff --git a/src/session/content/mod.rs b/src/session/content/mod.rs
index 8633e0b19..4aa82957e 100644
--- a/src/session/content/mod.rs
+++ b/src/session/content/mod.rs
@@ -1,4 +1,3 @@
-mod background;
 mod chat_action_bar;
 mod chat_history;
 mod chat_history_item;
@@ -19,7 +18,6 @@ use gtk::subclass::prelude::*;
 use gtk::CompositeTemplate;
 use once_cell::sync::Lazy;
 
-use self::background::Background;
 use self::chat_action_bar::ChatActionBar;
 use self::chat_history::ChatHistory;
 use self::chat_history_item::ChatHistoryItem;
@@ -31,6 +29,7 @@ use self::chat_info_window::ChatInfoWindow;
 use self::event_row::EventRow;
 use self::message_row::MessageRow;
 use self::send_photo_dialog::SendPhotoDialog;
+use crate::components::Background;
 use crate::tdlib::Chat;
 
 mod imp {
@@ -56,6 +55,7 @@ mod imp {
         type ParentType = adw::Bin;
 
         fn class_init(klass: &mut Self::Class) {
+            Background::static_type();
             ChatHistory::static_type();
             klass.bind_template();
         }
diff --git a/src/session/mod.rs b/src/session/mod.rs
index c51a98836..970c9eba9 100644
--- a/src/session/mod.rs
+++ b/src/session/mod.rs
@@ -10,7 +10,9 @@ use std::collections::hash_map::HashMap;
 
 use adw::subclass::prelude::BinImpl;
 use glib::clone;
+use glib::subclass::Signal;
 use glib::Sender;
+use gtk::gio;
 use gtk::glib;
 use gtk::glib::WeakRef;
 use gtk::prelude::*;
@@ -59,6 +61,7 @@ mod imp {
         pub(super) archive_chat_list: OnceCell<ChatList>,
         pub(super) folder_chat_lists: RefCell<HashMap<i32, ChatList>>,
         pub(super) chats: RefCell<HashMap<i64, Chat>>,
+        pub(super) chat_themes: RefCell<Vec<tdlib::types::ChatTheme>>,
         pub(super) users: RefCell<HashMap<i64, User>>,
         pub(super) basic_groups: RefCell<HashMap<i64, BasicGroup>>,
         pub(super) supergroups: RefCell<HashMap<i64, Supergroup>>,
@@ -154,6 +157,12 @@ mod imp {
             PROPERTIES.as_ref()
         }
 
+        fn signals() -> &'static [Signal] {
+            static SIGNALS: Lazy<Vec<Signal>> =
+                Lazy::new(|| vec![Signal::builder("update-chat-themes").build()]);
+            SIGNALS.as_ref()
+        }
+
         fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
             match pspec.name() {
                 "client-id" => {
@@ -227,6 +236,7 @@ impl Session {
             }
             Update::ChatTitle(ref data) => self.chat(data.chat_id).handle_update(update),
             Update::ChatPhoto(ref data) => self.chat(data.chat_id).handle_update(update),
+            Update::ChatTheme(ref data) => self.chat(data.chat_id).handle_update(update),
             Update::ChatPermissions(ref data) => self.chat(data.chat_id).handle_update(update),
             Update::ChatLastMessage(ref data) => {
                 let chat = self.chat(data.chat_id);
@@ -338,6 +348,10 @@ impl Session {
             Update::UserStatus(data) => {
                 self.user(data.user_id).update_status(data.status);
             }
+            Update::ChatThemes(chat_themes) => {
+                self.imp().chat_themes.replace(chat_themes.chat_themes);
+                self.emit_by_name::<()>("update-chat-themes", &[]);
+            }
             _ => {}
         }
     }
@@ -510,6 +524,42 @@ impl Session {
         }
     }
 
+    pub(crate) fn default_chat_theme(&self) -> tdlib::types::ChatTheme {
+        let theme_name = gio::Settings::new(crate::config::APP_ID).string("theme-name");
+
+        if theme_name == "🏠" {
+            crate::utils::default_theme()
+        } else if let Some(theme) = self.find_chat_theme(&theme_name) {
+            theme
+        } else {
+            log::error!("Chat theme not found: {theme_name}");
+            crate::utils::default_theme()
+        }
+    }
+
+    pub(crate) fn find_chat_theme(&self, name: &str) -> Option<tdlib::types::ChatTheme> {
+        self.imp()
+            .chat_themes
+            .borrow()
+            .iter()
+            .find(|theme| theme.name == name)
+            .cloned()
+    }
+
+    pub(crate) fn chat_themes(&self) -> std::cell::Ref<'_, Vec<tdlib::types::ChatTheme>> {
+        self.imp().chat_themes.borrow()
+    }
+
+    pub(crate) fn connect_update_chat_themes<F>(&self, callback: F) -> glib::SignalHandlerId
+    where
+        F: Fn() + 'static,
+    {
+        self.connect_local("update-chat-themes", true, move |_| {
+            callback();
+            None
+        })
+    }
+
     pub(crate) fn handle_paste_action(&self) {
         self.imp().content.handle_paste_action();
     }
diff --git a/src/session/preferences_window.rs b/src/session/preferences_window.rs
index a6b16668b..74545e31c 100644
--- a/src/session/preferences_window.rs
+++ b/src/session/preferences_window.rs
@@ -18,8 +18,11 @@ mod imp {
     #[derive(Debug, Default, CompositeTemplate)]
     #[template(resource = "/app/drey/paper-plane/ui/preferences-window.ui")]
     pub(crate) struct PreferencesWindow {
+        pub(super) settings: OnceCell<gio::Settings>,
         pub(super) session: OnceCell<Session>,
         #[template_child]
+        pub(super) theme_variants_box: TemplateChild<gtk::FlowBox>,
+        #[template_child]
         pub(super) follow_system_colors_switch: TemplateChild<gtk::Switch>,
         #[template_child]
         pub(super) dark_theme_switch: TemplateChild<gtk::Switch>,
@@ -81,11 +84,12 @@ mod imp {
 
             let obj = self.obj();
 
+            let settings = self.settings.get_or_init(|| gio::Settings::new(APP_ID));
+
             // If the system supports color schemes, load the 'Follow system colors'
             // switch state, otherwise make that switch insensitive
             let style_manager = adw::StyleManager::default();
             if style_manager.system_supports_color_schemes() {
-                let settings = gio::Settings::new(APP_ID);
                 let follow_system_colors = settings.string("color-scheme") == "default";
                 self.follow_system_colors_switch
                     .set_active(follow_system_colors);
@@ -93,6 +97,62 @@ mod imp {
                 self.follow_system_colors_switch.set_sensitive(false);
             }
 
+            let theme_name = settings.string("theme-name");
+
+            let session = self.session.get();
+
+            let preview = crate::components::ThemePreview::new(session);
+            let toggle_button = gtk::ToggleButton::builder()
+                .halign(gtk::Align::Center)
+                .valign(gtk::Align::Center)
+                .child(&preview)
+                .active(
+                    settings
+                        .default_value("theme-name")
+                        .unwrap()
+                        .get::<String>()
+                        .unwrap()
+                        == theme_name,
+                )
+                .build();
+
+            toggle_button.connect_clicked(clone!(@weak settings => move |_| {
+                settings.reset("theme-name");
+            }));
+
+            let child = gtk::FlowBoxChild::builder()
+                .child(&toggle_button)
+                .focusable(false)
+                .build();
+
+            self.theme_variants_box.append(&child);
+
+            for chat_theme in &*session.unwrap().chat_themes() {
+                let preview =
+                    crate::components::ThemePreview::from_chat_theme(chat_theme.clone(), session);
+
+                let name = chat_theme.name.clone();
+
+                let button = gtk::ToggleButton::builder()
+                    .group(&toggle_button)
+                    .halign(gtk::Align::Center)
+                    .valign(gtk::Align::Center)
+                    .child(&preview)
+                    .active(theme_name == name)
+                    .build();
+
+                button.connect_clicked(clone!(@weak settings => move |_| {
+                    settings.set_string("theme-name", &name).unwrap();
+                }));
+
+                let child = gtk::FlowBoxChild::builder()
+                    .child(&button)
+                    .focusable(false)
+                    .build();
+
+                self.theme_variants_box.append(&child);
+            }
+
             obj.setup_bindings();
 
             spawn(clone!(@weak obj => async move {
diff --git a/src/tdlib/chat.rs b/src/tdlib/chat.rs
index bdd92bcb4..db4c62594 100644
--- a/src/tdlib/chat.rs
+++ b/src/tdlib/chat.rs
@@ -90,6 +90,7 @@ mod imp {
         pub(super) type_: OnceCell<ChatType>,
         pub(super) is_blocked: Cell<bool>,
         pub(super) title: RefCell<String>,
+        pub(super) theme_name: RefCell<String>,
         pub(super) avatar: RefCell<Option<Avatar>>,
         pub(super) last_read_outbox_message_id: Cell<i64>,
         pub(super) is_marked_as_unread: Cell<bool>,
@@ -136,6 +137,9 @@ mod imp {
                         .read_only()
                         .build(),
                     glib::ParamSpecString::builder("title").read_only().build(),
+                    glib::ParamSpecString::builder("theme-name")
+                        .read_only()
+                        .build(),
                     glib::ParamSpecBoxed::builder::<Avatar>("avatar")
                         .read_only()
                         .build(),
@@ -184,6 +188,7 @@ mod imp {
                 "type" => obj.type_().to_value(),
                 "is-blocked" => obj.is_blocked().to_value(),
                 "title" => obj.title().to_value(),
+                "theme-name" => obj.theme_name().to_value(),
                 "avatar" => obj.avatar().to_value(),
                 "last-read-outbox-message-id" => obj.last_read_outbox_message_id().to_value(),
                 "is-marked-as-unread" => obj.is_marked_as_unread().to_value(),
@@ -221,6 +226,7 @@ impl Chat {
         imp.type_.set(type_).unwrap();
         imp.is_blocked.set(td_chat.is_blocked);
         imp.title.replace(td_chat.title);
+        imp.theme_name.replace(td_chat.theme_name);
         imp.avatar.replace(avatar);
         imp.last_read_outbox_message_id
             .set(td_chat.last_read_outbox_message_id);
@@ -270,6 +276,7 @@ impl Chat {
                 self.set_last_read_outbox_message_id(update.last_read_outbox_message_id);
             }
             ChatTitle(update) => self.set_title(update.title),
+            ChatTheme(update) => self.set_theme_name(update.theme_name),
             ChatUnreadMentionCount(update) => {
                 self.set_unread_mention_count(update.unread_mention_count)
             }
@@ -365,6 +372,23 @@ impl Chat {
         self.notify("title");
     }
 
+    pub(crate) fn theme_name(&self) -> String {
+        self.imp().theme_name.borrow().to_owned()
+    }
+
+    fn set_theme_name(&self, theme_name: String) {
+        if self.title() == theme_name {
+            return;
+        }
+        self.imp().theme_name.replace(theme_name);
+        self.notify("theme-name");
+    }
+
+    pub(crate) fn chat_theme(&self) -> Option<types::ChatTheme> {
+        self.session()
+            .find_chat_theme(&self.imp().theme_name.borrow())
+    }
+
     pub(crate) fn avatar(&self) -> Option<Avatar> {
         self.imp().avatar.borrow().to_owned()
     }
diff --git a/src/utils.rs b/src/utils.rs
index 86fb0e20b..a20a1303b 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -283,3 +283,55 @@ pub(crate) fn decode_image_from_path(path: &str) -> Result<gdk::MemoryTexture, D
 
     Ok(texture)
 }
+
+pub(crate) fn default_theme() -> tdlib::types::ChatTheme {
+    fn theme(
+        dark: bool,
+        bg_colors: Vec<i32>,
+        message_colors: Vec<i32>,
+    ) -> tdlib::types::ThemeSettings {
+        use tdlib::enums::BackgroundFill::*;
+        use tdlib::enums::BackgroundType::Pattern;
+        use tdlib::types::*;
+
+        ThemeSettings {
+            background: Some(Background {
+                is_default: true,
+                is_dark: dark,
+                r#type: Pattern(BackgroundTypePattern {
+                    fill: FreeformGradient(BackgroundFillFreeformGradient { colors: bg_colors }),
+                    intensity: 30,
+                    is_inverted: dark,
+                    is_moving: false,
+                }),
+                id: 0,
+                name: String::new(),
+                document: None,
+            }),
+            accent_color: -1,
+            animate_outgoing_message_fill: false,
+            outgoing_message_accent_color: 0,
+            outgoing_message_fill: FreeformGradient(BackgroundFillFreeformGradient {
+                colors: message_colors,
+            }),
+        }
+    }
+
+    let light_settings = theme(
+        false,
+        vec![0x94dae9, 0x9aeddb, 0x94c3f6, 0xac96f7],
+        vec![0xddecff, 0xe0ddfd, 0xdbffff, 0xddffdf],
+    );
+
+    let dark_settings = theme(
+        true,
+        vec![0xd6932e, 0xbc40db, 0x4280d7, 0x614ed5],
+        vec![0x2d52ab, 0x4036a1, 0x9f388d, 0x9d3941],
+    );
+
+    tdlib::types::ChatTheme {
+        name: "🏠".to_owned(),
+        light_settings,
+        dark_settings,
+    }
+}