diff --git a/Shared/Models/WriteFreelyModel.swift b/Shared/Models/WriteFreelyModel.swift
index f5b1011..d392e02 100644
--- a/Shared/Models/WriteFreelyModel.swift
+++ b/Shared/Models/WriteFreelyModel.swift
@@ -1,74 +1,76 @@
 import Foundation
 import WriteFreely
 import Security
 import Network
 
 // MARK: - WriteFreelyModel
 
 final class WriteFreelyModel: ObservableObject {
     @Published var account = AccountModel()
     @Published var preferences = PreferencesModel()
     @Published var posts = PostListModel()
     @Published var editor = PostEditorModel()
     @Published var isLoggingIn: Bool = false
     @Published var isProcessingRequest: Bool = false
     @Published var hasNetworkConnection: Bool = true
     @Published var selectedPost: WFAPost?
     @Published var selectedCollection: WFACollection?
     @Published var showAllPosts: Bool = true
     @Published var isPresentingDeleteAlert: Bool = false
     @Published var isPresentingLoginErrorAlert: Bool = false
     @Published var isPresentingNetworkErrorAlert: Bool = false
     @Published var postToDelete: WFAPost?
     #if os(iOS)
     @Published var isPresentingSettingsView: Bool = false
     #endif
 
+    static var shared = WriteFreelyModel()
+
     var loginErrorMessage: String?
 
     // swiftlint:disable line_length
     let helpURL = URL(string: "https://discuss.write.as/c/help/5")!
     let howToURL = URL(string: "https://discuss.write.as/t/using-the-writefreely-ios-app/1946")!
     let reviewURL = URL(string: "https://apps.apple.com/app/id1531530896?action=write-review")!
     let licensesURL = URL(string: "https://github.com/writeas/writefreely-swiftui-multiplatform/tree/main/Shared/Resources/Licenses")!
     // swiftlint:enable line_length
 
     internal var client: WFClient?
     private let defaults = UserDefaults.standard
     private let monitor = NWPathMonitor()
     private let queue = DispatchQueue(label: "NetworkMonitor")
     internal var postToUpdate: WFAPost?
 
     init() {
         DispatchQueue.main.async {
             self.preferences.appearance = self.defaults.integer(forKey: self.preferences.colorSchemeIntegerKey)
             self.preferences.font = self.defaults.integer(forKey: self.preferences.defaultFontIntegerKey)
             self.account.restoreState()
             if self.account.isLoggedIn {
                 guard let serverURL = URL(string: self.account.server) else {
                     print("Server URL not found")
                     return
                 }
                 guard let token = self.fetchTokenFromKeychain(
                         username: self.account.username,
                         server: self.account.server
                 ) else {
                     print("Could not fetch token from Keychain")
                     return
                 }
                 self.account.login(WFUser(token: token, username: self.account.username))
                 self.client = WFClient(for: serverURL)
                 self.client?.user = self.account.user
                 self.fetchUserCollections()
                 self.fetchUserPosts()
             }
         }
 
         monitor.pathUpdateHandler = { path in
             DispatchQueue.main.async {
                 self.hasNetworkConnection = path.status == .satisfied
             }
         }
         monitor.start(queue: queue)
     }
 }
diff --git a/Shared/WriteFreely_MultiPlatformApp.swift b/Shared/WriteFreely_MultiPlatformApp.swift
index bca2dd9..5fd1814 100644
--- a/Shared/WriteFreely_MultiPlatformApp.swift
+++ b/Shared/WriteFreely_MultiPlatformApp.swift
@@ -1,149 +1,149 @@
 import SwiftUI
 
 #if os(macOS)
 import Sparkle
 #endif
 
 @main
 struct CheckForDebugModifier {
     static func main() {
         #if os(macOS)
             if NSEvent.modifierFlags.contains(.shift) {
                 // Clear the launch-to-last-draft values to load a new draft.
                 UserDefaults.standard.setValue(false, forKey: "showAllPostsFlag")
                 UserDefaults.standard.setValue(nil, forKey: "selectedCollectionURL")
                 UserDefaults.standard.setValue(nil, forKey: "lastDraftURL")
             } else {
                 // No-op
             }
         #endif
         WriteFreely_MultiPlatformApp.main()
     }
 }
 
 struct WriteFreely_MultiPlatformApp: App {
-    @StateObject private var model = WriteFreelyModel()
+    @StateObject private var model = WriteFreelyModel.shared
 
     #if os(macOS)
     // swiftlint:disable:next weak_delegate
     @NSApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
     @State private var selectedTab = 0
     #endif
 
     var body: some Scene {
         WindowGroup {
             ContentView()
                 .onAppear(perform: {
                     if model.editor.showAllPostsFlag {
                         DispatchQueue.main.async {
                             self.model.selectedCollection = nil
                             self.model.showAllPosts = true
                         }
                     } else {
                         DispatchQueue.main.async {
                             self.model.selectedCollection = model.editor.fetchSelectedCollectionFromAppStorage()
                             self.model.showAllPosts = false
                         }
                     }
                     DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                         if model.editor.lastDraftURL != nil {
                             self.model.selectedPost = model.editor.fetchLastDraftFromAppStorage()
                         } else {
                             createNewLocalPost()
                         }
                     }
                 })
                 .environmentObject(model)
                 .environment(\.managedObjectContext, LocalStorageManager.persistentContainer.viewContext)
 //                .preferredColorScheme(preferences.selectedColorScheme)    // See PreferencesModel for info.
         }
         .commands {
             #if os(macOS)
             CommandGroup(after: .appInfo, addition: {
                 Button("Check For Updates") {
                     SUUpdater.shared()?.checkForUpdates(self)
                 }
             })
             #endif
             CommandGroup(replacing: .newItem, addition: {
                 Button("New Post") {
                     createNewLocalPost()
                 }
                 .keyboardShortcut("n", modifiers: [.command])
             })
             CommandGroup(after: .newItem) {
                 Button("Refresh Posts") {
                     DispatchQueue.main.async {
                         model.fetchUserCollections()
                         model.fetchUserPosts()
                     }
                 }
                 .disabled(!model.account.isLoggedIn)
                 .keyboardShortcut("r", modifiers: [.command])
             }
             SidebarCommands()
             #if os(macOS)
             PostCommands(model: model)
             #endif
             CommandGroup(after: .help) {
                 Button("Visit Support Forum") {
                     #if os(macOS)
                     NSWorkspace().open(model.helpURL)
                     #else
                     UIApplication.shared.open(model.helpURL)
                     #endif
                 }
             }
             ToolbarCommands()
             TextEditingCommands()
         }
 
         #if os(macOS)
         Settings {
             TabView(selection: $selectedTab) {
                 MacAccountView()
                     .environmentObject(model)
                     .tabItem {
                         Image(systemName: "person.crop.circle")
                         Text("Account")
                     }
                     .tag(0)
                 MacPreferencesView(preferences: model.preferences)
                     .tabItem {
                         Image(systemName: "gear")
                         Text("Preferences")
                     }
                     .tag(1)
                 MacUpdatesView()
                     .tabItem {
                         Image(systemName: "arrow.down.circle")
                         Text("Updates")
                     }
                     .tag(2)
             }
             .frame(minWidth: 500, maxWidth: 500, minHeight: 200)
             .padding()
 //            .preferredColorScheme(preferences.selectedColorScheme)    // See PreferencesModel for info.
         }
         #endif
     }
 
     private func createNewLocalPost() {
         withAnimation {
             // Un-set the currently selected post
             self.model.selectedPost = nil
 
             // Navigate to the Drafts list
             self.model.showAllPosts = false
             self.model.selectedCollection = nil
         }
         // Create the new-post managed object
         let managedPost = model.editor.generateNewLocalPost(withFont: model.preferences.font)
         withAnimation {
             // Set it as the selectedPost
             DispatchQueue.main.asyncAfter(deadline: .now()) {
                 self.model.selectedPost = managedPost
             }
         }
     }
 }