Remove `alacritty_config` from alacritty_terminal

There's no need to force alacritty's user configuration on
other users of the crate, thus provide the options actually used
by alacritty_terminal itself.

23 files changed, 661 insertions, 85 deletions

diff --git a/alacritty/src/cli.rs b/alacritty/src/cli.rs
index c9890b9b..4745ee8d 100644
--- a/alacritty/src/cli.rs
+++ b/alacritty/src/cli.rs
@@ -6,8 +6,9 @@ use log::{self, error, LevelFilter};
 use serde::{Deserialize, Serialize};
 use toml::{Table, Value};
 
-use alacritty_terminal::config::{Program, PtyConfig};
+use alacritty_terminal::tty::Options as PtyOptions;
 
+use crate::config::ui_config::Program;
 use crate::config::window::{Class, Identity};
 use crate::config::{serde_utils, UiConfig};
 
@@ -178,8 +179,8 @@ impl TerminalOptions {
         Some(Program::WithArgs { program: program.clone(), args: args.to_vec() })
     }
 
-    /// Override the [`PtyConfig`]'s fields with the [`TerminalOptions`].
-    pub fn override_pty_config(&self, pty_config: &mut PtyConfig) {
+    /// Override the [`PtyOptions`]'s fields with the [`TerminalOptions`].
+    pub fn override_pty_config(&self, pty_config: &mut PtyOptions) {
         if let Some(working_directory) = &self.working_directory {
             if working_directory.is_dir() {
                 pty_config.working_directory = Some(working_directory.to_owned());
@@ -189,18 +190,18 @@ impl TerminalOptions {
         }
 
         if let Some(command) = self.command() {
-            pty_config.shell = Some(command);
+            pty_config.shell = Some(command.into());
         }
 
         pty_config.hold |= self.hold;
     }
 }
 
-impl From<TerminalOptions> for PtyConfig {
+impl From<TerminalOptions> for PtyOptions {
     fn from(mut options: TerminalOptions) -> Self {
-        PtyConfig {
+        PtyOptions {
             working_directory: options.working_directory.take(),
-            shell: options.command(),
+            shell: options.command().map(Into::into),
             hold: options.hold,
         }
     }
diff --git a/alacritty/src/config/bell.rs b/alacritty/src/config/bell.rs
index fbf5be2f..1510f4b5 100644
--- a/alacritty/src/config/bell.rs
+++ b/alacritty/src/config/bell.rs
@@ -2,8 +2,8 @@ use std::time::Duration;
 
 use alacritty_config_derive::ConfigDeserialize;
 
-use alacritty_terminal::config::Program;
-use alacritty_terminal::term::color::Rgb;
+use crate::config::ui_config::Program;
+use crate::display::color::Rgb;
 
 #[derive(ConfigDeserialize, Clone, Debug, PartialEq, Eq)]
 pub struct BellConfig {
diff --git a/alacritty/src/config/bindings.rs b/alacritty/src/config/bindings.rs
index c56445f3..01e7e59c 100644
--- a/alacritty/src/config/bindings.rs
+++ b/alacritty/src/config/bindings.rs
@@ -14,11 +14,10 @@ use winit::platform::scancode::PhysicalKeyExtScancode;
 
 use alacritty_config_derive::{ConfigDeserialize, SerdeReplace};
 
-use alacritty_terminal::config::Program;
 use alacritty_terminal::term::TermMode;
 use alacritty_terminal::vi_mode::ViMotion;
 
-use crate::config::ui_config::Hint;
+use crate::config::ui_config::{Hint, Program, StringVisitor};
 
 /// Describes a state and action to take in that state.
 ///
@@ -1103,8 +1102,9 @@ impl<'a> Deserialize<'a> for RawBinding {
 
                             action = if let Ok(vi_action) = ViAction::deserialize(value.clone()) {
                                 Some(vi_action.into())
-                            } else if let Ok(vi_motion) = ViMotion::deserialize(value.clone()) {
-                                Some(vi_motion.into())
+                            } else if let Ok(vi_motion) = SerdeViMotion::deserialize(value.clone())
+                            {
+                                Some(vi_motion.0.into())
                             } else if let Ok(search_action) =
                                 SearchAction::deserialize(value.clone())
                             {
@@ -1213,6 +1213,21 @@ impl<'a> Deserialize<'a> for KeyBinding {
     }
 }
 
+#[derive(SerdeReplace, Debug, Copy, Clone, Eq, PartialEq)]
+pub struct SerdeViMotion(ViMotion);
+
+impl<'de> Deserialize<'de> for SerdeViMotion {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let value = deserializer.deserialize_str(StringVisitor)?;
+        ViMotion::deserialize(SerdeValue::String(value))
+            .map(SerdeViMotion)
+            .map_err(de::Error::custom)
+    }
+}
+
 /// Newtype for implementing deserialize on winit Mods.
 ///
 /// Our deserialize impl wouldn't be covered by a derive(Deserialize); see the
diff --git a/alacritty/src/config/color.rs b/alacritty/src/config/color.rs
index b6334460..995d0499 100644
--- a/alacritty/src/config/color.rs
+++ b/alacritty/src/config/color.rs
@@ -2,7 +2,8 @@ use serde::de::Error as SerdeError;
 use serde::{Deserialize, Deserializer};
 
 use alacritty_config_derive::ConfigDeserialize;
-use alacritty_terminal::term::color::{CellRgb, Rgb};
+
+use crate::display::color::{CellRgb, Rgb};
 
 #[derive(ConfigDeserialize, Clone, Debug, Default, PartialEq, Eq)]
 pub struct Colors {
diff --git a/alacritty/src/config/cursor.rs b/alacritty/src/config/cursor.rs
new file mode 100644
index 00000000..dc205b4b
--- /dev/null
+++ b/alacritty/src/config/cursor.rs
@@ -0,0 +1,156 @@
+use std::cmp;
+use std::time::Duration;
+
+use serde::Deserialize;
+
+use alacritty_config_derive::{ConfigDeserialize, SerdeReplace};
+use alacritty_terminal::vte::ansi::{CursorShape as VteCursorShape, CursorStyle as VteCursorStyle};
+
+use crate::config::ui_config::Percentage;
+
+/// The minimum blink interval value in milliseconds.
+const MIN_BLINK_INTERVAL: u64 = 10;
+
+/// The minimum number of blinks before pausing.
+const MIN_BLINK_CYCLES_BEFORE_PAUSE: u64 = 1;
+
+#[derive(ConfigDeserialize, Copy, Clone, Debug, PartialEq)]
+pub struct Cursor {
+    pub style: ConfigCursorStyle,
+    pub vi_mode_style: Option<ConfigCursorStyle>,
+    pub unfocused_hollow: bool,
+
+    thickness: Percentage,
+    blink_interval: u64,
+    blink_timeout: u8,
+}
+
+impl Default for Cursor {
+    fn default() -> Self {
+        Self {
+            thickness: Percentage::new(0.15),
+            unfocused_hollow: true,
+            blink_interval: 750,
+            blink_timeout: 5,
+            style: Default::default(),
+            vi_mode_style: Default::default(),
+        }
+    }
+}
+
+impl Cursor {
+    #[inline]
+    pub fn thickness(self) -> f32 {
+        self.thickness.as_f32()
+    }
+
+    #[inline]
+    pub fn style(self) -> VteCursorStyle {
+        self.style.into()
+    }
+
+    #[inline]
+    pub fn vi_mode_style(self) -> Option<VteCursorStyle> {
+        self.vi_mode_style.map(Into::into)
+    }
+
+    #[inline]
+    pub fn blink_interval(self) -> u64 {
+        cmp::max(self.blink_interval, MIN_BLINK_INTERVAL)
+    }
+
+    #[inline]
+    pub fn blink_timeout(self) -> Duration {
+        if self.blink_timeout == 0 {
+            Duration::ZERO
+        } else {
+            cmp::max(
+                // Show/hide is what we consider a cycle, so multiply by `2`.
+                Duration::from_millis(self.blink_interval * 2 * MIN_BLINK_CYCLES_BEFORE_PAUSE),
+                Duration::from_secs(self.blink_timeout as u64),
+            )
+        }
+    }
+}
+
+#[derive(SerdeReplace, Deserialize, Debug, Copy, Clone, PartialEq, Eq)]
+#[serde(untagged, deny_unknown_fields)]
+pub enum ConfigCursorStyle {
+    Shape(CursorShape),
+    WithBlinking {
+        #[serde(default)]
+        shape: CursorShape,
+        #[serde(default)]
+        blinking: CursorBlinking,
+    },
+}
+
+impl Default for ConfigCursorStyle {
+    fn default() -> Self {
+        Self::Shape(CursorShape::default())
+    }
+}
+
+impl ConfigCursorStyle {
+    /// Check if blinking is force enabled/disabled.
+    pub fn blinking_override(&self) -> Option<bool> {
+        match self {
+            Self::Shape(_) => None,
+            Self::WithBlinking { blinking, .. } => blinking.blinking_override(),
+        }
+    }
+}
+
+impl From<ConfigCursorStyle> for VteCursorStyle {
+    fn from(config_style: ConfigCursorStyle) -> Self {
+        match config_style {
+            ConfigCursorStyle::Shape(shape) => Self { shape: shape.into(), blinking: false },
+            ConfigCursorStyle::WithBlinking { shape, blinking } => {
+                Self { shape: shape.into(), blinking: blinking.into() }
+            },
+        }
+    }
+}
+
+#[derive(ConfigDeserialize, Default, Debug, Copy, Clone, PartialEq, Eq)]
+pub enum CursorBlinking {
+    Never,
+    #[default]
+    Off,
+    On,
+    Always,
+}
+
+impl CursorBlinking {
+    fn blinking_override(&self) -> Option<bool> {
+        match self {
+            Self::Never => Some(false),
+            Self::Off | Self::On => None,
+            Self::Always => Some(true),
+        }
+    }
+}
+
+impl From<CursorBlinking> for bool {
+    fn from(blinking: CursorBlinking) -> bool {
+        blinking == CursorBlinking::On || blinking == CursorBlinking::Always
+    }
+}
+
+#[derive(ConfigDeserialize, Debug, Default, Eq, PartialEq, Copy, Clone, Hash)]
+pub enum CursorShape {
+    #[default]
+    Block,
+    Underline,
+    Beam,
+}
+
+impl From<CursorShape> for VteCursorShape {
+    fn from(value: CursorShape) -> Self {
+        match value {
+            CursorShape::Block => VteCursorShape::Block,
+            CursorShape::Underline => VteCursorShape::Underline,
+            CursorShape::Beam => VteCursorShape::Beam,
+        }
+    }
+}
diff --git a/alacritty/src/config/mod.rs b/alacritty/src/config/mod.rs
index 762e1f39..678e08d5 100644
--- a/alacritty/src/config/mod.rs
+++ b/alacritty/src/config/mod.rs
@@ -10,14 +10,16 @@ use toml::de::Error as TomlError;
 use toml::ser::Error as TomlSeError;
 use toml::{Table, Value};
 
-use alacritty_terminal::config::LOG_TARGET_CONFIG;
-
 pub mod bell;
 pub mod color;
+pub mod cursor;
 pub mod debug;
 pub mod font;
 pub mod monitor;
+pub mod scrolling;
+pub mod selection;
 pub mod serde_utils;
+pub mod terminal;
 pub mod ui_config;
 pub mod window;
 
@@ -31,6 +33,7 @@ pub use crate::config::bindings::{
     Action, BindingKey, BindingMode, MouseAction, SearchAction, ViAction,
 };
 pub use crate::config::ui_config::UiConfig;
+use crate::logging::LOG_TARGET_CONFIG;
 
 /// Maximum number of depth for the configuration file imports.
 pub const IMPORT_RECURSION_LIMIT: usize = 5;
diff --git a/alacritty/src/config/scrolling.rs b/alacritty/src/config/scrolling.rs
new file mode 100644
index 00000000..3b2b21f3
--- /dev/null
+++ b/alacritty/src/config/scrolling.rs
@@ -0,0 +1,53 @@
+use serde::de::Error as SerdeError;
+use serde::{Deserialize, Deserializer};
+
+use alacritty_config_derive::{ConfigDeserialize, SerdeReplace};
+
+/// Maximum scrollback amount configurable.
+pub const MAX_SCROLLBACK_LINES: u32 = 100_000;
+
+/// Struct for scrolling related settings.
+#[derive(ConfigDeserialize, Copy, Clone, Debug, PartialEq, Eq)]
+pub struct Scrolling {
+    pub multiplier: u8,
+
+    history: ScrollingHistory,
+}
+
+impl Default for Scrolling {
+    fn default() -> Self {
+        Self { multiplier: 3, history: Default::default() }
+    }
+}
+
+impl Scrolling {
+    pub fn history(self) -> u32 {
+        self.history.0
+    }
+}
+
+#[derive(SerdeReplace, Copy, Clone, Debug, PartialEq, Eq)]
+struct ScrollingHistory(u32);
+
+impl Default for ScrollingHistory {
+    fn default() -> Self {
+        Self(10_000)
+    }
+}
+
+impl<'de> Deserialize<'de> for ScrollingHistory {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let lines = u32::deserialize(deserializer)?;
+
+        if lines > MAX_SCROLLBACK_LINES {
+            Err(SerdeError::custom(format!(
+                "exceeded maximum scrolling history ({lines}/{MAX_SCROLLBACK_LINES})"
+            )))
+        } else {
+            Ok(Self(lines))
+        }
+    }
+}
diff --git a/alacritty/src/config/selection.rs b/alacritty/src/config/selection.rs
new file mode 100644
index 00000000..bf90b48f
--- /dev/null
+++ b/alacritty/src/config/selection.rs
@@ -0,0 +1,17 @@
+use alacritty_config_derive::ConfigDeserialize;
+use alacritty_terminal::term::SEMANTIC_ESCAPE_CHARS;
+
+#[derive(ConfigDeserialize, Clone, Debug, PartialEq, Eq)]
+pub struct Selection {
+    pub semantic_escape_chars: String,
+    pub save_to_clipboard: bool,
+}
+
+impl Default for Selection {
+    fn default() -> Self {
+        Self {
+            semantic_escape_chars: SEMANTIC_ESCAPE_CHARS.to_owned(),
+            save_to_clipboard: Default::default(),
+        }
+    }
+}
diff --git a/alacritty/src/config/terminal.rs b/alacritty/src/config/terminal.rs
new file mode 100644
index 00000000..b41af5db
--- /dev/null
+++ b/alacritty/src/config/terminal.rs
@@ -0,0 +1,26 @@
+use serde::{de, Deserialize, Deserializer};
+use toml::Value;
+
+use alacritty_config_derive::{ConfigDeserialize, SerdeReplace};
+use alacritty_terminal::term::Osc52;
+
+use crate::config::ui_config::StringVisitor;
+
+#[derive(ConfigDeserialize, Default, Copy, Clone, Debug, PartialEq)]
+pub struct Terminal {
+    /// OSC52 support mode.
+    pub osc52: SerdeOsc52,
+}
+
+#[derive(SerdeReplace, Default, Copy, Clone, Debug, PartialEq)]
+pub struct SerdeOsc52(pub Osc52);
+
+impl<'de> Deserialize<'de> for SerdeOsc52 {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let value = deserializer.deserialize_str(StringVisitor)?;
+        Osc52::deserialize(Value::String(value)).map(SerdeOsc52).map_err(de::Error::custom)
+    }
+}
diff --git a/alacritty/src/config/ui_config.rs b/alacritty/src/config/ui_config.rs
index 15423da5..a76bbb78 100644
--- a/alacritty/src/config/ui_config.rs
+++ b/alacritty/src/config/ui_config.rs
@@ -1,8 +1,11 @@
 use std::cell::RefCell;
+use std::collections::HashMap;
 use std::fmt::{self, Formatter};
 use std::path::PathBuf;
 use std::rc::Rc;
 
+use alacritty_terminal::term::Config as TermConfig;
+use alacritty_terminal::tty::{Options as PtyOptions, Shell};
 use log::{error, warn};
 use serde::de::{Error as SerdeError, MapAccess, Visitor};
 use serde::{self, Deserialize, Deserializer};
@@ -10,7 +13,6 @@ use unicode_width::UnicodeWidthChar;
 use winit::keyboard::{Key, KeyLocation, ModifiersState};
 
 use alacritty_config_derive::{ConfigDeserialize, SerdeReplace};
-use alacritty_terminal::config::{Config as TerminalConfig, Program, LOG_TARGET_CONFIG};
 use alacritty_terminal::term::search::RegexSearch;
 
 use crate::config::bell::BellConfig;
@@ -18,10 +20,15 @@ use crate::config::bindings::{
     self, Action, Binding, BindingKey, KeyBinding, ModeWrapper, ModsWrapper, MouseBinding,
 };
 use crate::config::color::Colors;
+use crate::config::cursor::Cursor;
 use crate::config::debug::Debug;
 use crate::config::font::Font;
 use crate::config::mouse::{Mouse, MouseBindings};
+use crate::config::scrolling::Scrolling;
+use crate::config::selection::Selection;
+use crate::config::terminal::Terminal;
 use crate::config::window::WindowConfig;
+use crate::config::LOG_TARGET_CONFIG;
 
 /// Regex used for the default URL hint.
 #[rustfmt::skip]
@@ -30,6 +37,18 @@ const URL_REGEX: &str = "(ipfs:|ipns:|magnet:|mailto:|gemini://|gopher://|https:
 
 #[derive(ConfigDeserialize, Clone, Debug, PartialEq)]
 pub struct UiConfig {
+    /// Extra environment variables.
+    pub env: HashMap<String, String>,
+
+    /// How much scrolling history to keep.
+    pub scrolling: Scrolling,
+
+    /// Cursor configuration.
+    pub cursor: Cursor,
+
+    /// Selection configuration.
+    pub selection: Selection,
+
     /// Font configuration.
     pub font: Font,
 
@@ -68,8 +87,13 @@ pub struct UiConfig {
     pub ipc_socket: bool,
 
     /// Config for the alacritty_terminal itself.
-    #[config(flatten)]
-    pub terminal_config: TerminalConfig,
+    pub terminal: Terminal,
+
+    /// Path to a shell program to run on startup.
+    pub shell: Option<Program>,
+
+    /// Shell startup directory.
+    pub working_directory: Option<PathBuf>,
 
     /// Keyboard configuration.
     keyboard: Keyboard,
@@ -100,25 +124,48 @@ impl Default for UiConfig {
             #[cfg(unix)]
             ipc_socket: true,
             draw_bold_text_with_bright_colors: Default::default(),
-            terminal_config: Default::default(),
+            working_directory: Default::default(),
             mouse_bindings: Default::default(),
             config_paths: Default::default(),
             key_bindings: Default::default(),
             alt_send_esc: Default::default(),
+            scrolling: Default::default(),
+            selection: Default::default(),
             keyboard: Default::default(),
+            terminal: Default::default(),
             import: Default::default(),
+            cursor: Default::default(),
             window: Default::default(),
             colors: Default::default(),
+            shell: Default::default(),
             mouse: Default::default(),
             debug: Default::default(),
             hints: Default::default(),
             font: Default::default(),
             bell: Default::default(),
+            env: Default::default(),
         }
     }
 }
 
 impl UiConfig {
+    /// Derive [`TermConfig`] from the config.
+    pub fn term_options(&self) -> TermConfig {
+        TermConfig {
+            scrolling_history: self.scrolling.history() as usize,
+            default_cursor_style: self.cursor.style(),
+            vi_mode_cursor_style: self.cursor.vi_mode_style(),
+            semantic_escape_chars: self.selection.semantic_escape_chars.clone(),
+            osc52: self.terminal.osc52.0,
+        }
+    }
+
+    /// Derive [`PtyOptions`] from the config.
+    pub fn pty_config(&self) -> PtyOptions {
+        let shell = self.shell.clone().map(Into::into);
+        PtyOptions { shell, working_directory: self.working_directory.clone(), hold: false }
+    }
+
     /// Generate key bindings for all keyboard hints.
     pub fn generate_hint_bindings(&mut self) {
         // Check which key bindings is most likely to be the user's configuration.
@@ -551,6 +598,78 @@ impl PartialEq for LazyRegexVariant {
 }
 impl Eq for LazyRegexVariant {}
 
+/// Wrapper around f32 that represents a percentage value between 0.0 and 1.0.
+#[derive(SerdeReplace, Deserialize, Clone, Copy, Debug, PartialEq)]
+pub struct Percentage(f32);
+
+impl Default for Percentage {
+    fn default() -> Self {
+        Percentage(1.0)
+    }
+}
+
+impl Percentage {
+    pub fn new(value: f32) -> Self {
+        Percentage(value.clamp(0., 1.))
+    }
+
+    pub fn as_f32(self) -> f32 {
+        self.0
+    }
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(untagged, deny_unknown_fields)]
+pub enum Program {
+    Just(String),
+    WithArgs {
+        program: String,
+        #[serde(default)]
+        args: Vec<String>,
+    },
+}
+
+impl Program {
+    pub fn program(&self) -> &str {
+        match self {
+            Program::Just(program) => program,
+            Program::WithArgs { program, .. } => program,
+        }
+    }
+
+    pub fn args(&self) -> &[String] {
+        match self {
+            Program::Just(_) => &[],
+            Program::WithArgs { args, .. } => args,
+        }
+    }
+}
+
+impl From<Program> for Shell {
+    fn from(value: Program) -> Self {
+        match value {
+            Program::Just(program) => Shell::new(program, Vec::new()),
+            Program::WithArgs { program, args } => Shell::new(program, args),
+        }
+    }
+}
+
+pub(crate) struct StringVisitor;
+impl<'de> serde::de::Visitor<'de> for StringVisitor {
+    type Value = String;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter.write_str("a string")
+    }
+
+    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        Ok(s.to_lowercase())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/alacritty/src/config/window.rs b/alacritty/src/config/window.rs
index bb7c4080..3ae4e29e 100644
--- a/alacritty/src/config/window.rs
+++ b/alacritty/src/config/window.rs
@@ -9,10 +9,9 @@ use winit::window::{Fullscreen, Theme};
 use winit::platform::macos::OptionAsAlt as WinitOptionAsAlt;
 
 use alacritty_config_derive::{ConfigDeserialize, SerdeReplace};
-use alacritty_terminal::config::{Percentage, LOG_TARGET_CONFIG};
-use alacritty_terminal::index::Column;
 
-use crate::config::ui_config::Delta;
+use crate::config::ui_config::{Delta, Percentage};
+use crate::config::LOG_TARGET_CONFIG;
 
 /// Default Alacritty name, used for window title and class.
 pub const DEFAULT_NAME: &str = "Alacritty";
@@ -90,7 +89,7 @@ impl Default for WindowConfig {
 impl WindowConfig {
     #[inline]
     pub fn dimensions(&self) -> Option<Dimensions> {
-        let (lines, columns) = (self.dimensions.lines, self.dimensions.columns.0);
+        let (lines, columns) = (self.dimensions.lines, self.dimensions.columns);
         let (lines_is_non_zero, columns_is_non_zero) = (lines != 0, columns != 0);
 
         if lines_is_non_zero && columns_is_non_zero {
@@ -194,7 +193,7 @@ pub enum Decorations {
 #[derive(ConfigDeserialize, Default, Debug, Copy, Clone, PartialEq, Eq)]
 pub struct Dimensions {
     /// Window width in character columns.
-    pub columns: Column,
+    pub columns: usize,
 
     /// Window Height in character lines.
     pub lines: usize,
diff --git a/alacritty/src/display/color.rs b/alacritty/src/display/color.rs
index f742ee84..669bf502 100644
--- a/alacritty/src/display/color.rs
+++ b/alacritty/src/display/color.rs
@@ -1,9 +1,14 @@
-use std::ops::{Index, IndexMut};
+use std::fmt::{self, Display, Formatter};
+use std::ops::{Add, Deref, Index, IndexMut, Mul};
+use std::str::FromStr;
 
 use log::trace;
+use serde::de::{Error as SerdeError, Visitor};
+use serde::{Deserialize, Deserializer};
 
-use alacritty_terminal::ansi::NamedColor;
-use alacritty_terminal::term::color::{Rgb, COUNT};
+use alacritty_config_derive::SerdeReplace;
+use alacritty_terminal::term::color::COUNT;
+use alacritty_terminal::vte::ansi::{NamedColor, Rgb as VteRgb};
 
 use crate::config::color::Colors;
 
@@ -165,3 +170,191 @@ impl IndexMut<NamedColor> for List {
         &mut self.0[idx as usize]
     }
 }
+
+#[derive(SerdeReplace, Debug, Eq, PartialEq, Copy, Clone, Default)]
+pub struct Rgb(pub VteRgb);
+
+impl Rgb {
+    #[inline]
+    pub const fn new(r: u8, g: u8, b: u8) -> Self {
+        Self(VteRgb { r, g, b })
+    }
+
+    #[inline]
+    pub fn as_tuple(self) -> (u8, u8, u8) {
+        (self.0.r, self.0.g, self.0.b)
+    }
+}
+
+impl From<VteRgb> for Rgb {
+    fn from(value: VteRgb) -> Self {
+        Self(value)
+    }
+}
+
+impl Deref for Rgb {
+    type Target = VteRgb;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl Mul<f32> for Rgb {
+    type Output = Rgb;
+
+    fn mul(self, rhs: f32) -> Self::Output {
+        Rgb(self.0 * rhs)
+    }
+}
+
+impl Add<Rgb> for Rgb {
+    type Output = Rgb;
+
+    fn add(self, rhs: Rgb) -> Self::Output {
+        Rgb(self.0 + rhs.0)
+    }
+}
+
+/// Deserialize an Rgb from a hex string.
+///
+/// This is *not* the deserialize impl for Rgb since we want a symmetric
+/// serialize/deserialize impl for ref tests.
+impl<'de> Deserialize<'de> for Rgb {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct RgbVisitor;
+
+        // Used for deserializing reftests.
+        #[derive(Deserialize)]
+        struct RgbDerivedDeser {
+            r: u8,
+            g: u8,
+            b: u8,
+        }
+
+        impl<'a> Visitor<'a> for RgbVisitor {
+            type Value = Rgb;
+
+            fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result {
+                f.write_str("hex color like #ff00ff")
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Rgb, E>
+            where
+                E: serde::de::Error,
+            {
+                Rgb::from_str(value).map_err(|_| {
+                    E::custom(format!(
+                        "failed to parse rgb color {value}; expected hex color like #ff00ff"
+                    ))
+                })
+            }
+        }
+
+        // Return an error if the syntax is incorrect.
+        let value = toml::Value::deserialize(deserializer)?;
+
+        // Attempt to deserialize from struct form.
+        if let Ok(RgbDerivedDeser { r, g, b }) = RgbDerivedDeser::deserialize(value.clone()) {
+            return Ok(Rgb::new(r, g, b));
+        }
+
+        // Deserialize from hex notation (either 0xff00ff or #ff00ff).
+        value.deserialize_str(RgbVisitor).map_err(D::Error::custom)
+    }
+}
+
+impl Display for Rgb {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "#{:02x}{:02x}{:02x}", self.r, self.g, self.b)
+    }
+}
+
+impl FromStr for Rgb {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Rgb, ()> {
+        let chars = if s.starts_with("0x") && s.len() == 8 {
+            &s[2..]
+        } else if s.starts_with('#') && s.len() == 7 {
+            &s[1..]
+        } else {
+            return Err(());
+        };
+
+        match u32::from_str_radix(chars, 16) {
+            Ok(mut color) => {
+                let b = (color & 0xff) as u8;
+                color >>= 8;
+                let g = (color & 0xff) as u8;
+                color >>= 8;
+                let r = color as u8;
+                Ok(Rgb::new(r, g, b))
+            },
+            Err(_) => Err(()),
+        }
+    }
+}
+
+/// RGB color optionally referencing the cell's foreground or background.
+#[derive(SerdeReplace, Copy, Clone, Debug, PartialEq, Eq)]
+pub enum CellRgb {
+    CellForeground,
+    CellBackground,
+    Rgb(Rgb),
+}
+
+impl CellRgb {
+    pub fn color(self, foreground: Rgb, background: Rgb) -> Rgb {
+        match self {
+            Self::CellForeground => foreground,
+            Self::CellBackground => background,
+            Self::Rgb(rgb) => rgb,
+        }
+    }
+}
+
+impl Default for CellRgb {
+    fn default() -> Self {
+        Self::Rgb(Rgb::default())
+    }
+}
+
+impl<'de> Deserialize<'de> for CellRgb {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        const EXPECTING: &str = "CellForeground, CellBackground, or hex color like #ff00ff";
+
+        struct CellRgbVisitor;
+        impl<'a> Visitor<'a> for CellRgbVisitor {
+            type Value = CellRgb;
+
+            fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result {
+                f.write_str(EXPECTING)
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<CellRgb, E>
+            where
+                E: serde::de::Error,
+            {
+                // Attempt to deserialize as enum constants.
+                match value {
+                    "CellForeground" => return Ok(CellRgb::CellForeground),
+                    "CellBackground" => return Ok(CellRgb::CellBackground),
+                    _ => (),
+                }
+
+                Rgb::from_str(value).map(CellRgb::Rgb).map_err(|_| {
+                    E::custom(format!("failed to parse color {value}; expected {EXPECTING}"))
+                })
+            }
+        }
+
+        deserializer.deserialize_str(CellRgbVisitor).map_err(D::Error::custom)
+    }
+}
diff --git a/alacritty/src/display/content.rs b/alacritty/src/display/content.rs
index ba716154..30439fc0 100644
--- a/alacritty/src/display/content.rs
+++ b/alacritty/src/display/content.rs
@@ -2,18 +2,17 @@ use std::borrow::Cow;
 use std::ops::Deref;
 use std::{cmp, mem};
 
-use alacritty_terminal::ansi::{Color, CursorShape, NamedColor};
 use alacritty_terminal::event::EventListener;
 use alacritty_terminal::grid::{Dimensions, Indexed};
 use alacritty_terminal::index::{Column, Line, Point};
 use alacritty_terminal::selection::SelectionRange;
 use alacritty_terminal::term::cell::{Cell, Flags, Hyperlink};
-use alacritty_terminal::term::color::{CellRgb, Rgb};
 use alacritty_terminal::term::search::{Match, RegexSearch};
 use alacritty_terminal::term::{self, RenderableContent as TerminalContent, Term, TermMode};
+use alacritty_terminal::vte::ansi::{Color, CursorShape, NamedColor};
 
 use crate::config::UiConfig;
-use crate::display::color::{List, DIM_FACTOR};
+use crate::display::color::{CellRgb, List, Rgb, DIM_FACTOR};
 use crate::display::hint::{self, HintState};
 use crate::display::{Display, SizeInfo};
 use crate::event::SearchState;
@@ -55,7 +54,7 @@ impl<'a> RenderableContent<'a> {
             || display.ime.preedit().is_some()
         {
             CursorShape::Hidden
-        } else if !term.is_focused && config.terminal_config.cursor.unfocused_hollow {
+        } else if !term.is_focused && config.cursor.unfocused_hollow {
             CursorShape::HollowBlock
         } else {
             terminal_content.cursor.shape
@@ -102,7 +101,7 @@ impl<'a> RenderableContent<'a> {
 
     /// Get the RGB value for a color index.
     pub fn color(&self, color: usize) -> Rgb {
-        self.terminal_content.colors[color].unwrap_or(self.colors[color])
+        self.terminal_content.colors[color].map(Rgb).unwrap_or(self.colors[color])
     }
 
     pub fn selection_range(&self) -> Option<SelectionRange> {
@@ -117,8 +116,8 @@ impl<'a> RenderableContent<'a> {
         } else {
             self.config.colors.cursor
         };
-        let cursor_color =
-            self.terminal_content.colors[NamedColor::Cursor].map_or(color.background, CellRgb::Rgb);
+        let cursor_color = self.terminal_content.colors[NamedColor::Cursor]
+            .map_or(color.background, |c| CellRgb::Rgb(Rgb(c)));
         let text_color = color.foreground;
 
         let insufficient_contrast = (!matches!(cursor_color, CellRgb::Rgb(_))
diff --git a/alacritty/src/display/cursor.rs b/alacritty/src/display/cursor.rs
index 8a4cc729..65933ccc 100644
--- a/alacritty/src/display/cursor.rs
+++ b/alacritty/src/display/cursor.rs
@@ -1,8 +1,8 @@
 //! Convert a cursor into an iterator of rects.
 
-use alacritty_terminal::ansi::CursorShape;
-use alacritty_terminal::term::color::Rgb;
+use alacritty_terminal::vte::ansi::CursorShape;
 
+use crate::display::color::Rgb;
 use crate::display::content::RenderableCursor;
 use crate::display::SizeInfo;
 use crate::renderer::rects::RenderRect;
diff --git a/alacritty/src/display/hint.rs b/alacritty/src/display/hint.rs
index f508d10c..bd09a881 100644
--- a/alacritty/src/display/hint.rs
+++ b/alacritty/src/display/hint.rs
@@ -590,9 +590,9 @@ impl<'a, T> Iterator for HintPostProcessor<'a, T> {
 
 #[cfg(test)]
 mod tests {
-    use alacritty_terminal::ansi::Handler;
     use alacritty_terminal::index::{Column, Line};
     use alacritty_terminal::term::test::mock_term;
+    use alacritty_terminal::vte::ansi::Handler;
 
     use super::*;
 
diff --git a/alacritty/src/display/mod.rs b/alacritty/src/display/mod.rs
index dfe2809f..1d993af8 100644
--- a/alacritty/src/display/mod.rs
+++ b/alacritty/src/display/mod.rs
@@ -23,23 +23,22 @@ use winit::window::CursorIcon;
 use crossfont::{self, Rasterize, Rasterizer};
 use unicode_width::UnicodeWidthChar;
 
-use alacritty_terminal::ansi::{CursorShape, NamedColor};
-use alacritty_terminal::config::MAX_SCROLLBACK_LINES;
 use alacritty_terminal::event::{EventListener, OnResize, WindowSize};
 use alacritty_terminal::grid::Dimensions as TermDimensions;
 use alacritty_terminal::index::{Column, Direction, Line, Point};
 use alacritty_terminal::selection::{Selection, SelectionRange};
 use alacritty_terminal::term::cell::Flags;
-use alacritty_terminal::term::color::Rgb;
 use alacritty_terminal::term::{self, Term, TermDamage, TermMode, MIN_COLUMNS, MIN_SCREEN_LINES};
+use alacritty_terminal::vte::ansi::{CursorShape, NamedColor};
 
 use crate::config::font::Font;
+use crate::config::scrolling::MAX_SCROLLBACK_LINES;
 use crate::config::window::Dimensions;
 #[cfg(not(windows))]
 use crate::config::window::StartupMode;
 use crate::config::UiConfig;
 use crate::display::bell::VisualBell;
-use crate::display::color::List;
+use crate::display::color::{List, Rgb};
 use crate::display::content::{RenderableContent, RenderableCursor};
 use crate::display::cursor::IntoRects;
 use crate::display::damage::RenderDamageIterator;
@@ -53,13 +52,13 @@ use crate::renderer::{self, GlyphCache, Renderer};
 use crate::scheduler::{Scheduler, TimerId, Topic};
 use crate::string::{ShortenDirection, StrShortener};
 
+pub mod color;
 pub mod content;
 pub mod cursor;
 pub mod hint;
 pub mod window;
 
 mod bell;
-mod color;
 mod damage;
 mod meter;
 
@@ -862,7 +861,7 @@ impl Display {
         };
 
         // Draw cursor.
-        rects.extend(cursor.rects(&size_info, config.terminal_config.cursor.thickness()));
+        rects.extend(cursor.rects(&size_info, config.cursor.thickness()));
 
         // Push visual bell after url/underline/strikeout rects.
         let visual_bell_intensity = self.visual_bell.intensity();
@@ -900,9 +899,7 @@ impl Display {
                     let fg = config.colors.footer_bar_foreground();
                     let shape = CursorShape::Underline;
                     let cursor = RenderableCursor::new(Point::new(line, column), shape, fg, false);
-                    rects.extend(
-                        cursor.rects(&size_info, config.terminal_config.cursor.thickness()),
-                    );
+                    rects.extend(cursor.rects(&size_info, config.cursor.thickness()));
                 }
 
                 Some(Point::new(line, column))
@@ -1144,9 +1141,7 @@ impl Display {
                 let cursor_point = Point::new(point.line, cursor_column);
                 let cursor =
                     RenderableCursor::new(cursor_point, CursorShape::HollowBlock, fg, is_wide);
-                rects.extend(
-                    cursor.rects(&self.size_info, config.terminal_config.cursor.thickness()),
-                );
+                rects.extend(cursor.rects(&self.size_info, config.cursor.thickness()));
                 cursor_point
             },
             _ => end,
@@ -1622,7 +1617,7 @@ fn window_size(
 ) -> PhysicalSize<u32> {
     let padding = config.window.padding(scale_factor);
 
-    let grid_width = cell_width * dimensions.columns.0.max(MIN_COLUMNS) as f32;
+    let grid_width = cell_width * dimensions.columns.max(MIN_COLUMNS) as f32;
     let grid_height = cell_height * dimensions.lines.max(MIN_SCREEN_LINES) as f32;
 
     let width = (padding.0).mul_add(2., grid_width).floor();
diff --git a/alacritty/src/event.rs b/alacritty/src/event.rs
index beab7c74..d710c826 100644
--- a/alacritty/src/event.rs
+++ b/alacritty/src/event.rs
@@ -27,7 +27,6 @@ use winit::event_loop::{
 };
 use winit::window::WindowId;
 
-use alacritty_terminal::config::LOG_TARGET_CONFIG;
 use alacritty_terminal::event::{Event as TerminalEvent, EventListener, Notify};
 use alacritty_terminal::event_loop::Notifier;
 use alacritty_terminal::grid::{BidirectionalIterator, Dimensions, Scroll};
@@ -45,10 +44,12 @@ use crate::config::{self, UiConfig};
 #[cfg(not(windows))]
 use crate::daemon::foreground_process_path;
 use crate::daemon::spawn_daemon;
+use crate::display::color::Rgb;
 use crate::display::hint::HintMatch;
 use crate::display::window::Window;
 use crate::display::{Display, Preedit, SizeInfo};
 use crate::input::{self, ActionContext as _, FONT_SIZE_STEP};
+use crate::logging::LOG_TARGET_CONFIG;
 use crate::message_bar::{Message, MessageBuffer};
 use crate::scheduler::{Scheduler, TimerId, Topic};
 use crate::window_context::WindowContext;
@@ -284,8 +285,7 @@ impl<'a, N: Notify + 'a, T: EventListener> input::ActionContext<T> for ActionCon
             None => return,
         };
 
-        if ty == ClipboardType::Selection && self.config.terminal_config.selection.save_to_clipboard
-        {
+        if ty == ClipboardType::Selection && self.config.selection.save_to_clipboard {
             self.clipboard.store(ClipboardType::Clipboard, text.clone());
         }
         self.clipboard.store(ty, text);
@@ -1033,10 +1033,10 @@ impl<'a, N: Notify + 'a, T: EventListener> ActionContext<'a, N, T> {
     /// Update the cursor blinking state.
     fn update_cursor_blinking(&mut self) {
         // Get config cursor style.
-        let mut cursor_style = self.config.terminal_config.cursor.style;
+        let mut cursor_style = self.config.cursor.style;
         let vi_mode = self.terminal.mode().contains(TermMode::VI);
         if vi_mode {
-            cursor_style = self.config.terminal_config.cursor.vi_mode_style.unwrap_or(cursor_style);
+            cursor_style = self.config.cursor.vi_mode_style.unwrap_or(cursor_style);
         }
 
         // Check terminal cursor style.
@@ -1066,23 +1066,21 @@ impl<'a, N: Notify + 'a, T: EventListener> ActionContext<'a, N, T> {
         let window_id = self.display.window.id();
         let timer_id = TimerId::new(Topic::BlinkCursor, window_id);
         let event = Event::new(EventType::BlinkCursor, window_id);
-        let blinking_interval =
-            Duration::from_millis(self.config.terminal_config.cursor.blink_interval());
+        let blinking_interval = Duration::from_millis(self.config.cursor.blink_interval());
         self.scheduler.schedule(event, blinking_interval, true, timer_id);
     }
 
     fn schedule_blinking_timeout(&mut self) {
-        let blinking_timeout = self.config.terminal_config.cursor.blink_timeout();
-        if blinking_timeout == 0 {
+        let blinking_timeout = self.config.cursor.blink_timeout();
+        if blinking_timeout == Duration::ZERO {
             return;
         }
 
         let window_id = self.display.window.id();
-        let blinking_timeout_interval = Duration::from_secs(blinking_timeout);
         let event = Event::new(EventType::BlinkCursorTimeout, window_id);
         let timer_id = TimerId::new(Topic::BlinkTimeout, window_id);
 
-        self.scheduler.schedule(event, blinking_timeout_interval, false, timer_id);
+        self.scheduler.schedule(event, blinking_timeout, false, timer_id);
     }
 
     /// Perform vi mode inline search in the specified direction.
@@ -1324,8 +1322,9 @@ impl input::Processor<EventProxy, ActionContext<'_, Notifier, EventProxy>> {
                     },
                     TerminalEvent::ColorRequest(index, format) => {
                         let color = self.ctx.terminal().colors()[index]
+                            .map(Rgb)
                             .unwrap_or(self.ctx.display.colors[index]);
-                        self.ctx.write_to_pty(format(color).into_bytes());
+                        self.ctx.write_to_pty(format(color.0).into_bytes());
                     },
                     TerminalEvent::TextAreaSizeRequest(format) => {
                         let text = format(self.ctx.size_info().into());
@@ -1386,7 +1385,7 @@ impl input::Processor<EventProxy, ActionContext<'_, Notifier, EventProxy>> {
                         self.ctx.terminal.is_focused = is_focused;
 
                         // When the unfocused hollow is used we must redraw on focus change.
-                        if self.ctx.config.terminal_config.cursor.unfocused_hollow {
+                        if self.ctx.config.cursor.unfocused_hollow {
                             *self.ctx.dirty = true;
                         }
 
diff --git a/alacritty/src/input.rs b/alacritty/src/input.rs
index b1a25288..3c11c435 100644
--- a/alacritty/src/input.rs
+++ b/alacritty/src/input.rs
@@ -29,7 +29,6 @@ use winit::platform::macos::{EventLoopWindowTargetExtMacOS, OptionAsAlt};
 use winit::platform::modifier_supplement::KeyEventExtModifierSupplement;
 use winit::window::CursorIcon;
 
-use alacritty_terminal::ansi::{ClearMode, Handler};
 use alacritty_terminal::event::EventListener;
 use alacritty_terminal::grid::{Dimensions, Scroll};
 use alacritty_terminal::index::{Boundary, Column, Direction, Point, Side};
@@ -37,6 +36,7 @@ use alacritty_terminal::selection::SelectionType;
 use alacritty_terminal::term::search::Match;
 use alacritty_terminal::term::{ClipboardType, Term, TermMode};
 use alacritty_terminal::vi_mode::ViMotion;
+use alacritty_terminal::vte::ansi::{ClearMode, Handler};
 
 use crate::clipboard::Clipboard;
 use crate::config::{
@@ -701,7 +701,7 @@ impl<T: EventListener, A: ActionContext<T>> Processor<T, A> {
     }
 
     pub fn mouse_wheel_input(&mut self, delta: MouseScrollDelta, phase: TouchPhase) {
-        let multiplier = self.ctx.config().terminal_config.scrolling.multiplier;
+        let multiplier = self.ctx.config().scrolling.multiplier;
         match delta {
             MouseScrollDelta::LineDelta(columns, lines) => {
                 let new_scroll_px_x = columns * self.ctx.size_info().cell_width();
@@ -1382,7 +1382,7 @@ mod tests {
                     false,
                 );
 
-                let mut terminal = Term::new(&cfg.terminal_config, &size, MockEventProxy);
+                let mut terminal = Term::new(cfg.term_options(), &size, MockEventProxy);
 
                 let mut mouse = Mouse {
                     click_state: $initial_state,
diff --git a/alacritty/src/logging.rs b/alacritty/src/logging.rs
index ae564a00..4c92a9de 100644
--- a/alacritty/src/logging.rs
+++ b/alacritty/src/logging.rs
@@ -16,8 +16,6 @@ use log::{self, Level, LevelFilter};
 use once_cell::sync::Lazy;
 use winit::event_loop::EventLoopProxy;
 
-use alacritty_terminal::config::LOG_TARGET_CONFIG;
-
 use crate::cli::Options;
 use crate::event::{Event, EventType};
 use crate::message_bar::{Message, MessageType};
@@ -28,6 +26,9 @@ pub const LOG_TARGET_IPC_CONFIG: &str = "alacritty_log_ipc_config";
 /// Name for the environment variable containing the log file's path.
 const ALACRITTY_LOG_ENV: &str = "ALACRITTY_LOG";
 
+/// Logging target for config error messages.
+pub const LOG_TARGET_CONFIG: &str = "alacritty_config_derive";
+
 /// Name for the environment variable containing extra logging targets.
 ///
 /// The targets are semicolon separated.
diff --git a/alacritty/src/main.rs b/alacritty/src/main.rs
index ea4cd281..028a42e8 100644
--- a/alacritty/src/main.rs
+++ b/alacritty/src/main.rs
@@ -12,13 +12,11 @@
 #[cfg(not(any(feature = "x11", feature = "wayland", target_os = "macos", windows)))]
 compile_error!(r#"at least one of the "x11"/"wayland" features must be enabled"#);
 
-#[cfg(target_os = "macos")]
-use std::env;
 use std::error::Error;
 use std::fmt::Write as _;
-use std::fs;
 use std::io::{self, Write};
 use std::path::PathBuf;
+use std::{env, fs};
 
 use log::info;
 #[cfg(windows)]
@@ -147,8 +145,13 @@ fn alacritty(options: Options) -> Result<(), Box<dyn Error>> {
     // Update the log level from config.
     log::set_max_level(config.debug.log_level);
 
-    // Set environment variables.
-    tty::setup_env(&config.terminal_config);
+    // Set tty environment variables.
+    tty::setup_env();
+
+    // Set env vars from config.
+    for (key, value) in config.env.iter() {
+        env::set_var(key, value);
+    }
 
     // Switch to home directory.
     #[cfg(target_os = "macos")]
diff --git a/alacritty/src/renderer/mod.rs b/alacritty/src/renderer/mod.rs
index bd3c0015..df3ca0b7 100644
--- a/alacritty/src/renderer/mod.rs
+++ b/alacritty/src/renderer/mod.rs
@@ -13,9 +13,9 @@ use unicode_width::UnicodeWidthChar;
 
 use alacritty_terminal::index::Point;
 use alacritty_terminal::term::cell::Flags;
-use alacritty_terminal::term::color::Rgb;
 
 use crate::config::debug::RendererPreference;
+use crate::display::color::Rgb;
 use crate::display::content::RenderableCell;
 use crate::display::SizeInfo;
 use crate::gl;
diff --git a/alacritty/src/renderer/rects.rs b/alacritty/src/renderer/rects.rs
index 8d7a78e6..3b0b8695 100644
--- a/alacritty/src/renderer/rects.rs
+++ b/alacritty/src/renderer/rects.rs
@@ -7,8 +7,8 @@ use crossfont::Metrics;
 use alacritty_terminal::grid::Dimensions;
 use alacritty_terminal::index::{Column, Point};
 use alacritty_terminal::term::cell::Flags;
-use alacritty_terminal::term::color::Rgb;
 
+use crate::display::color::Rgb;
 use crate::display::content::RenderableCell;
 use crate::display::SizeInfo;
 use crate::gl;
diff --git a/alacritty/src/window_context.rs b/alacritty/src/window_context.rs
index d2f7ffd4..be8eba47 100644
--- a/alacritty/src/window_context.rs
+++ b/alacritty/src/window_context.rs
@@ -174,7 +174,7 @@ impl WindowContext {
         options: WindowOptions,
         proxy: EventLoopProxy<Event>,
     ) -> Result<Self, Box<dyn Error>> {
-        let mut pty_config = config.terminal_config.pty_config.clone();
+        let mut pty_config = config.pty_config();
         options.terminal_options.override_pty_config(&mut pty_config);
 
         let preserve_title = options.window_identity.title.is_some();
@@ -192,7 +192,7 @@ impl WindowContext {
         // This object contains all of the state about what's being displayed. It's
         // wrapped in a clonable mutex since both the I/O loop and display need to
         // access it.
-        let terminal = Term::new(&config.terminal_config, &display.size_info, event_proxy.clone());
+        let terminal = Term::new(config.term_options(), &display.size_info, event_proxy.clone());
         let terminal = Arc::new(FairMutex::new(terminal));
 
         // Create the PTY.
@@ -229,7 +229,7 @@ impl WindowContext {
         let _io_thread = event_loop.spawn();
 
         // Start cursor blinking, in case `Focused` isn't sent on startup.
-        if config.terminal_config.cursor.style().blinking {
+        if config.cursor.style().blinking {
             event_proxy.send_event(TerminalEvent::CursorBlinkingChange.into());
         }
 
@@ -289,14 +289,10 @@ impl WindowContext {
         }
 
         self.display.update_config(&self.config);
-        self.terminal.lock().update_config(&self.config.terminal_config);
+        self.terminal.lock().set_options(self.config.term_options());
 
         // Reload cursor if its thickness has changed.
-        if (old_config.terminal_config.cursor.thickness()
-            - self.config.terminal_config.cursor.thickness())
-        .abs()
-            > f32::EPSILON
-        {
+        if (old_config.cursor.thickness() - self.config.cursor.thickness()).abs() > f32::EPSILON {
             self.display.pending_update.set_cursor_dirty();
         }