I only use Swift for a side project, but I found myself splitting my time between AppCode and XCode. AppCode is nicer in terms of feature set (both in completeness and in my familiarity with the shortcuts), but I find XCode is much faster. If I'm working on something with a bunch of renaming/refactoring/etc, I'll do it in AppCode; if I'm more or less just typing and running tests, I'll do it in XCode.
So, while this announcement is sad, I can't say it's shocking. In other languages I know, IntelliJ products are significantly better than the competitors. For Swift, it's a bit more... meh.
AppCode used to be way better than Xcode in the early days of Swift. And IME has been better at least up to 2020. Did Xcode fix its performance and reliability issues in the last 2 years?
Not entirely, but mostly. The Swift tooling is far more reliable, 3 years ago I was getting noticeable code intelligence failures on hobby projects, 1 year ago I wasn’t noticing it during nearly full time professional iOS engineering. SwiftUI previews were still a little dodgy but getting better every release.
As for performance, it’s basically like any other major macOS app now in my experience. Only caveat might be the git committing which was a bit crap still last time I checked.
IntelliJ software still feels like everything takes 100ms longer than I expect, which makes it feel sluggish even if the heavy lifting is relatively fast.
AppCode i can understand, but the Swift plugin for CLion too? That's surprising, considering Apple is now maintaining a full featured LSP server implementation, so now VSCode users can do Swift dev
They have Fleet wich should support LSP, but i'm not sure if that product will be successful, they have a lot of work to do with regard to performance (cpu/memory), and based on the recent public preview, it's built with the wrong foundation for that matter
Fleet right now is a resource hog. Just with something like a small python script or a 20 line Rust file the editor was using 1GB, and an extra 1GB and 70% CPU usage (M1 MBA) with smart mode turned on.
You might be lucky that your project doesn't have a certain complexity. I'm working on multiple complex projects in the 100k loc to 500k loc range and here're some things that happen way too often:
- Auto completion completely doesn't work in some files
- Symbol lookup doesn't work (e.g. Xcode doesn't know the struct or class when I try to find information on it)
- Symbol search doesn't work (this literally never works. I've switched to using text based search for all things)
- The app compiles but Xcode still lists 3-4 compile errors in the sidebar. They stay there until I restart Xcode and clean the build folder
- Weird compile errors that disappear when I clean the build folder
- Swift Package Manager integration is awful. Change one package file, and Xcode needs 2min (where the UI is unresponsive) to reload all the packages and do some weird calculations
- Everything is slow. Searching for things, typing, the editor. Compare that to the speed of VSCode, where all interactions are super fast
- Sometimes the unit test buttons disappear (the ones that appear next to the unit test function name), which means I can't run individual tests anymore.
- Its still the case that compiler error messages are completely in the wrong place for complex type errors
- SwiftUI preview still doesn't work properly in many cases
- Sometimes Xcode needs forever to figure out that there's an error in something I wrote. Not while I'm typing, not when I've saved, only once I started compiling. Then it compiles, it fails, it needs another 5sec, and then the error message appears. That's a terrible feedback loop.
Apart from that, there's no useful plugin / extension interface. I'd like to have auto-reformat on save as a plugin, way better vim bindings (I mean, we finally got vim bindings but they're awful), bookmarks (I sometimes use disabled debugger breakpoints as bookmarks, but that's not really a feature).
There's obviously more, but here's the thing. I also work on a sizeable Rust project (60k loc), and while Rust analyser needs longer for the initial indexing of the project, everything else after that is way better than Xcode. VSCode is faster, smoother, auto completion works much more reliably, refactoring works great, the IDE already shows errors while I'm typing or right after I've saved. Also, when I save the code is formatted based on the guidelines, which is a godsend. I've tried to set up VSCode as a Xcode alternative, but the Swift sourcekit-lsp is way worse than Rust-Analyzer. Also, running and debugging is a pain then.
I only use it to release on iOS for flutter, every click takes 3 seconds, project files get random changes everytime and it plays badly with git, every update takes 12GB (not joking) and the app upload is so broken even apple had to release a third party upload tool to bypass it.
Just using it to compile the app to release it is very painful, I can't imagine doing any serious work with that kind of software.
I don’t work in flutter but I wouldn’t be surprised, having worked in react-native, if there isn’t a massive amount of native deps under the hood that have to be rebuilt often that are slowing things down more than your typical entirely native app. I’d look into fastlane and automating your uploads outside xcode it is not too bad to write a script to do this for you.
I’m an iOS dev and yes Xcode is trash. We migrated to SwiftUI since we thought it will get us out of UIKit hell, and then it is much worse than we thought. Xcode just couldn’t handle very large complex codebase.
Oh, that's disappointing. I was wondering if anyone made a decent competitor to XCode after dipping my toes into some iOS development, and it looks like it's just being killed as I'm learning about it.
I’d recommend just using Xcode, if you really want you can use any editor and the command line tools to build. That said despite being a bloated behemoth Xcode has a lot of very helpful tools built in and it being the default for all iOS devs means a lot of tutorials and docs are going to assume usage.
Additionally, a lot of the most common types of “grumpiness” encountered with Xcode can be avoided by avoiding code smells when writing Swift — SourceKit (which powers Xcode’s syntax highlighting, autocomplete, etc) doesn’t like it if you deeply nest closures, get a little too crazy with chaining optionals, etc.
Oh, and if at all possible avoid XIBs and storyboards and write your UI in pure code. Interface Builder was once a thing of beauty back when it was its own app, but it’s been a slow quirky mess ever since it got merged into Xcode. Code only UIs are a bit more verbose but it’s not too bad with Swift+UIKit and it’s so much less trouble, especially when you consider how much more git friendly code is than machine generated XML (merge conflicts with storyboards are nightmarish).
Doing this, I encounter little trouble with Xcode using it day in and day out. As a whole it’s smoother than my typical session in Android Studio.
Shame to see it happen, but an understandable decision - it's been a few years since I was writing native iOS code and AppCode really felt like a power-user tool in ways that Xcode couldn't.
I believe that the greatest sorrow actually is that there will no more be copilot support for ios devs (except if you use vscode side-by-side with xcode).
