@@ -23,9 +23,9 @@ use crate::persist;
 use crate::preferences;
 use crate::render::{RenderError, RenderState};
 use crate::spawner::TokioSpawner;
-use crate::ui::{InputEvent, UiCommand, UiInstance};
+use crate::ui::{Acceleration, InputEvent, UiCommand, UiConfig, UiInstance};
 use crate::window::Window;
-use crate::wrapper::messages::{DesktopFrontendMessage, DesktopWrapperMessage, IngestAction, Preferences};
+use crate::wrapper::messages::{DesktopFrontendMessage, DesktopWrapperMessage, IngestAction};
 use crate::wrapper::{DesktopWrapper, FolderStore, MmapResourceStorage, WgpuContext, WgpuExecutor, serialize_frontend_messages};
 
 pub(crate) struct App {
@@ -40,18 +40,16 @@ pub(crate) struct App {
 	pending_dnd_fetch: Option<AsyncRequestSerial>,
 	pending_clipboard_fetch: Option<AsyncRequestSerial>,
 	input_state: InputState,
-	ui_scale: f64,
 	app_event_receiver: Receiver<AppEvent>,
 	app_event_scheduler: AppEventScheduler,
 	desktop_wrapper: DesktopWrapper,
 	ui: UiInstance,
 	ui_frame_received: bool,
 	start_render_sender: SyncSender<()>,
-	web_communication_initialized: bool,
+	ui_initialized: Option<Instant>,
 	web_communication_startup_buffer: Vec<Vec<u8>>,
-	preferences: Preferences,
+	preferences: preferences::DesktopPreferences,
 	launch_documents: Option<Vec<PathBuf>>,
-	startup_time: Option<Instant>,
 	exiting: Arc<AtomicBool>,
 	exit_reason: ExitReason,
 }
@@ -66,7 +64,7 @@ impl App {
 		wgpu_context: WgpuContext,
 		app_event_receiver: Receiver<AppEvent>,
 		app_event_scheduler: AppEventScheduler,
-		preferences: Preferences,
+		preferences: preferences::DesktopPreferences,
 		launch_documents: Vec<PathBuf>,
 	) -> Self {
 		let ctrlc_app_event_scheduler = app_event_scheduler.clone();
@@ -96,7 +94,6 @@ impl App {
 		let runtime_wake = move || {
 			let _ = runtime_wake_sender.try_send(());
 		};
-		// The node graph and the window's overlays render through this one executor, sharing its renderer and texture cache
 		let wgpu_executor = WgpuExecutor::with_context(wgpu_context).expect("Failed to create WgpuExecutor");
 		let (desktop_wrapper, mut node_runtime) = DesktopWrapper::new(
 			rand::rng().random(),
@@ -133,18 +130,16 @@ impl App {
 			pending_dnd_fetch: None,
 			pending_clipboard_fetch: None,
 			input_state: InputState::new(),
-			ui_scale: 1.,
 			app_event_receiver,
 			app_event_scheduler,
 			desktop_wrapper,
 			ui,
 			ui_frame_received: false,
 			start_render_sender,
-			web_communication_initialized: false,
+			ui_initialized: None,
 			web_communication_startup_buffer: Vec::new(),
 			preferences,
 			launch_documents: Some(launch_documents),
-			startup_time: None,
 			exiting,
 			exit_reason: ExitReason::Shutdown,
 		}
@@ -166,6 +161,22 @@ impl App {
 		self.app_event_scheduler.schedule(AppEvent::Exit);
 	}
 
+	fn restart_ui(&mut self) {
+		let acceleration = self.preferences.acceleration;
+		if let Err(error) = self.ui.restart(UiConfig { acceleration }) {
+			tracing::error!("Failed to restart the UI: {error}");
+			self.exit(Some(ExitReason::Shutdown));
+			return;
+		}
+		self.ui_initialized = None;
+
+		self.window_size = PhysicalSize { width: 0, height: 0 };
+		self.window_scale = 1.;
+		self.window_maximized = false;
+		self.window_fullscreen = false;
+		self.resize();
+	}
+
 	fn resize(&mut self) {
 		let Some(window) = &self.window else {
 			tracing::error!("Resize failed due to missing window");
@@ -186,7 +197,7 @@ impl App {
 		}
 
 		let size = window.surface_size();
-		let scale = window.scale_factor() * self.ui_scale;
+		let scale = window.scale_factor() * self.preferences.ui_scale;
 		let is_new_size = size != self.window_size;
 		let is_new_scale = scale != self.window_scale;
 
@@ -309,13 +320,9 @@ impl App {
 			DesktopFrontendMessage::WindowUpdateDirectInput { enabled } => {
 				self.input_state.set_direct_input(enabled);
 			}
-			DesktopFrontendMessage::UpdateUIScale { scale } => {
-				self.ui_scale = scale;
-				self.resize();
-			}
 			DesktopFrontendMessage::UpdateOverlays(scene) => {
 				if let Some(render_state) = &mut self.render_state {
-					render_state.set_overlays_scene(scene);
+					render_state.set_overlays_scene(*scene);
 				}
 				if let Some(window) = &self.window {
 					window.request_redraw();
@@ -327,8 +334,26 @@ impl App {
 			DesktopFrontendMessage::PersistenceReadState => {
 				responses.push(DesktopWrapperMessage::LoadPersistedState { state: persist::read_state() });
 			}
-			DesktopFrontendMessage::PersistenceWritePreferences { preferences } => {
+			DesktopFrontendMessage::PersistenceUpdatePreferences { preferences } => {
+				let old_preferences = self.preferences.clone();
+				self.preferences = preferences::DesktopPreferences::from(&preferences);
+
 				preferences::write(preferences);
+
+				if old_preferences.present_mode != self.preferences.present_mode
+					&& let Some(render_state) = &mut self.render_state
+				{
+					render_state.set_present_mode(self.preferences.present_mode);
+				}
+
+				if old_preferences.ui_scale != self.preferences.ui_scale {
+					self.resize();
+				}
+
+				if old_preferences.acceleration != self.preferences.acceleration {
+					tracing::info!("UI acceleration preference changed, restarting UI");
+					self.restart_ui();
+				}
 			}
 			DesktopFrontendMessage::PersistenceLoadPreferences => {
 				let preferences = preferences::read();
@@ -337,7 +362,6 @@ impl App {
 			}
 			DesktopFrontendMessage::OpenLaunchDocuments => {
 				let Some(launch_documents) = std::mem::take(&mut self.launch_documents) else {
-					tracing::error!("OpenLaunchDocuments should only be sent once");
 					return;
 				};
 				self.app_event_scheduler.schedule(AppEvent::OpenFiles(launch_documents));
@@ -434,7 +458,7 @@ impl App {
 	}
 
 	fn send_or_queue_web_message(&mut self, message: Vec<u8>) {
-		if self.web_communication_initialized {
+		if self.ui_initialized.is_some() {
 			self.ui.send(UiCommand::Message(message));
 		} else {
 			self.web_communication_startup_buffer.push(message);
@@ -444,7 +468,8 @@ impl App {
 	fn user_event(&mut self, event_loop: &dyn ActiveEventLoop, event: AppEvent) {
 		match event {
 			AppEvent::WebCommunicationInitialized => {
-				self.web_communication_initialized = true;
+				self.ui_initialized = Some(Instant::now());
+				self.ui_frame_received = false;
 				for message in self.web_communication_startup_buffer.drain(..) {
 					self.ui.send(UiCommand::Message(message));
 				}
@@ -505,6 +530,10 @@ impl App {
 				tracing::info!("Exiting main event loop");
 				event_loop.exit();
 			}
+			AppEvent::UiCrashed if self.ui_initialized.is_some() => {
+				tracing::error!("UI process crashed, restarting it.");
+				self.restart_ui();
+			}
 			AppEvent::UiCrashed => {
 				tracing::error!("UI process crashed, exiting.");
 				self.exit(Some(ExitReason::Shutdown));
@@ -548,21 +577,17 @@ impl ApplicationHandler for App {
 		let window = Window::new(event_loop, self.app_event_scheduler.clone());
 		self.window = Some(window);
 
-		#[cfg(not(target_os = "macos"))]
-		let present_mode = None;
-		#[cfg(target_os = "macos")]
-		let present_mode = if !self.preferences.vsync { Some(wgpu::PresentMode::Immediate) } else { None };
-
-		let render_state = RenderState::new(self.window.as_ref().unwrap(), self.wgpu_executor.clone(), present_mode);
+		let mut render_state = RenderState::new(self.window.as_ref().unwrap(), self.wgpu_executor.clone());
+		if self.preferences.present_mode.is_some() {
+			render_state.set_present_mode(self.preferences.present_mode);
+		}
 		self.render_state = Some(render_state);
 
 		if let Some(window) = &self.window.as_ref() {
 			window.show();
 		}
 
 		self.resize();
-
-		self.startup_time = Some(Instant::now());
 	}
 
 	fn proxy_wake_up(&mut self, event_loop: &dyn ActiveEventLoop) {
@@ -625,13 +650,14 @@ impl ApplicationHandler for App {
 				}
 
 				if !self.ui_frame_received
-					&& !self.preferences.disable_ui_acceleration
-					&& self.web_communication_initialized
-					&& let Some(startup_time) = self.startup_time
-					&& startup_time.elapsed() > Duration::from_secs(3)
+					&& self.preferences.acceleration != Acceleration::Disabled
+					&& let Some(initialized) = self.ui_initialized
+					&& initialized.elapsed() > Duration::from_secs(3)
 				{
-					tracing::error!("UI acceleration not working, exiting.");
-					self.exit(Some(ExitReason::UiAccelerationFailure));
+					tracing::error!("UI acceleration not working, disabling it.");
+					let mut preferences = preferences::read();
+					preferences.disable_ui_acceleration = true;
+					self.dispatch_desktop_wrapper_message(DesktopWrapperMessage::LoadPreferences { preferences });
 				}
 			}
 			WindowEvent::DragEntered { id, .. } => {
@@ -733,5 +759,4 @@ impl ApplicationHandler for App {
 pub(crate) enum ExitReason {
 	Shutdown,
 	Restart,
-	UiAccelerationFailure,
 }
@@ -337,21 +337,16 @@ impl ViewportInfo {
 	}
 }
 
-/// Counts clicks the way the operating system does, so a single click is never taken as the end of a double-click.
-/// The count is decided when a button is pressed and reported again when it's released.
 #[derive(Default)]
 struct ClickTracker {
-	/// The latest press of any button, since pressing another button in between ends a chain of clicks.
 	latest_press: Option<Press>,
 }
 
-/// A button press, kept to tell whether the next press continues its chain of clicks.
 struct Press {
 	button: MouseButton,
 	time: Instant,
 	position: (i32, i32),
 	count: u32,
-	/// Whether the button was released away from where it was pressed, which makes the press a drag rather than a click.
 	dragged: bool,
 }
 
@@ -362,7 +357,6 @@ impl ClickTracker {
 		let within_travel = |from: (i32, i32)| from.0.abs_diff(position.0) as usize <= MULTICLICK_ALLOWED_TRAVEL && from.1.abs_diff(position.1) as usize <= MULTICLICK_ALLOWED_TRAVEL;
 
 		match state {
-			// A press continues the chain when it comes soon after a click of the same button and lands near it
 			ElementState::Pressed => {
 				let count = match &self.latest_press {
 					Some(previous) if previous.button == button && !previous.dragged && now.saturating_duration_since(previous.time) <= MULTICLICK_TIMEOUT && within_travel(previous.position) => {
@@ -379,7 +373,6 @@ impl ClickTracker {
 				});
 				count
 			}
-			// A release reports the count of its press, unless the pointer traveled away in between, which makes it a drag that ends the chain
 			ElementState::Released => {
 				let Some(press) = self.latest_press.as_mut().filter(|press| press.button == button) else {
 					return 1;
 
@@ -77,8 +77,6 @@ pub fn start() -> ExitCode {
 	// TODO: Eventually remove this cleanup code for the old "browser" CEF directory
 	dirs::delete_old_cef_browser_directory();
 
-	let mut prefs = preferences::read();
-
 	// Must be called before event loop initialization or native window integrations will break
 	App::init();
 
@@ -90,15 +88,19 @@ pub fn start() -> ExitCode {
 
 	let _socket_handle = socket::start(app_event_scheduler.clone());
 
+	let mut prefs = preferences::DesktopPreferences::from(&preferences::read());
+
 	if cli.disable_ui_acceleration {
-		prefs.disable_ui_acceleration = true;
+		prefs.acceleration = Acceleration::Disabled;
+		preferences::modify(|prefs| {
+			prefs.disable_ui_acceleration = true;
+		});
 	}
-	if prefs.disable_ui_acceleration {
+	if prefs.acceleration == Acceleration::Disabled {
 		println!("UI acceleration is disabled");
 	}
 
-	let acceleration = if prefs.disable_ui_acceleration { Acceleration::Disabled } else { Acceleration::Auto };
-	let ui_context = match ui_context.start(UiConfig { acceleration }) {
+	let ui_context = match ui_context.start(UiConfig { acceleration: prefs.acceleration }) {
 		Ok(context) => context,
 		Err(error) => {
 			tracing::error!("Failed to start the UI runtime: {error}");
@@ -148,29 +150,18 @@ pub fn start() -> ExitCode {
 	// ui needs to be shutdown before restarting
 	ui.shutdown();
 
-	// If exiting due to a UI acceleration failure, update preferences to disable it for next launch
-	if matches!(exit_reason, app::ExitReason::UiAccelerationFailure) {
-		tracing::error!("Disabling UI acceleration");
-		preferences::modify(|prefs| {
-			prefs.disable_ui_acceleration = true;
-		});
-	}
-
 	// Explicitly drop the instance lock
 	drop(lock);
 
-	match exit_reason {
-		app::ExitReason::Restart | app::ExitReason::UiAccelerationFailure => {
-			tracing::info!("Restarting application");
-			let mut command = std::process::Command::new(std::env::current_exe().unwrap());
-			#[cfg(target_family = "unix")]
-			let _ = std::os::unix::process::CommandExt::exec(&mut command);
-			#[cfg(target_family = "unix")]
-			tracing::error!("Failed to restart application");
-			#[cfg(not(target_family = "unix"))]
-			let _ = command.spawn();
-		}
-		_ => {}
+	if matches!(exit_reason, app::ExitReason::Restart) {
+		tracing::info!("Restarting application");
+		let mut command = std::process::Command::new(std::env::current_exe().unwrap());
+		#[cfg(target_family = "unix")]
+		let _ = std::os::unix::process::CommandExt::exec(&mut command);
+		#[cfg(target_family = "unix")]
+		tracing::error!("Failed to restart application");
+		#[cfg(not(target_family = "unix"))]
+		let _ = command.spawn();
 	}
 
 	ExitCode::SUCCESS
 
@@ -1,4 +1,31 @@
 use graphite_desktop_wrapper::messages::Preferences;
+use wgpu::PresentMode;
+
+use crate::ui::Acceleration;
+
+#[derive(Clone, PartialEq)]
+pub(crate) struct DesktopPreferences {
+	pub(crate) acceleration: Acceleration,
+	pub(crate) present_mode: Option<PresentMode>,
+	pub(crate) ui_scale: f64,
+}
+
+impl From<&Preferences> for DesktopPreferences {
+	fn from(preferences: &Preferences) -> Self {
+		#[cfg(not(target_os = "macos"))]
+		let present_mode = None;
+		#[cfg(target_os = "macos")]
+		let present_mode = if !preferences.vsync { Some(PresentMode::Immediate) } else { None };
+
+		let acceleration = if preferences.disable_ui_acceleration { Acceleration::Disabled } else { Acceleration::Auto };
+
+		Self {
+			acceleration,
+			present_mode,
+			ui_scale: preferences.ui_scale,
+		}
+	}
+}
 
 pub(crate) fn write(preferences: Preferences) {
 	let Ok(preferences) = ron::ser::to_string_pretty(&preferences, Default::default()) else {