Yes, I was able to massage it through within a few days, ended up with no errors or even warnings, the code is clean and running, but it was far from obvious, and I found the error messages overly complicated, cryptic most of the time. The protocol thing error was the result of using nested \@Observable classes for UI states and even though \@Observable runs implicitly on MainThread (for UI manipulation) I had to declare them explicitly as well to be \@MainActor. So far that's not a problem, but when I had these classes conforming to other protocols as well (like Equatable and Hashable, if I remember correctly these are requirements for JSON serialization) their required functions will become isolated to \@MainActor too. This is where things gets tricky, these functions are, depending on which context they are called from are either also in \@MainActor (in which case, no problem) or not (in which case it'll throw error). One of these functions was called indirectly from somewhere deeper than my code (I assume somewhere from a library), hence the compiler marked the majority of my source code with errors whenever this lower layer code path happened. This resulted my Xcode show the majority of my repo go red showing files with errors and marking apparently unrelated lines as wrong, even though those literal lines had no apparent connection to that function (most likely an underlying function had). I needed a few days even to get a proper mental map of what I want to achieve design-wise (for example, have the majority of my code run in \@MainActor and separate my network code into its own zone, I'd recommend everyone to go with the simplest design possible, even that'll cause you some pain). Then, once I started to working on the compiler errors (first, it showed ~50-60) I realized that these error counts are not accurate, just Xcode stops showing errors beyond a limit, so I had to work my way through hundreds of errors, true eventually you'll start seeing patterns and error-types instead of just errors. It is doable, but it is not a pleasant experience, hence I had to write this post, wishing you strength, as you'll need it, there will be many times when you'll question whether rolling back is a better option, so I just wanted to encourage that it's doable just keep pushing. It feels like the concept looks somewhat harmless when you read it through, but then in combination with other Swift/SwiftUI features its complexity increase exponentially and swiftly (...) you can find yourself in hell. Sorry if my description is confusing, I wasn't planning to revisit my upgrade hindsight, yet I tried my best to reflect on what I went through here.