Swift seems like a really nice language that's held back by it's association with Apple.
Seems to hit a sweet spot of a fast/compiled (compared to Javascript), memory safe (compared to C++), object orientated (compared to Go) and easy to write (compared to Rust).
> Swift seems like a really nice language that's held back by it's association with Apple.
Or empowered by its association with Apple. That's a pretty big pond.
I like Swift, and I write software for Apple devices. I don't really care, whether or not it supports other platforms. For my backend work, I tend to use PHP, because there's a very broad base of servers that support it, it's good enough, fast enough, and, doggone it, people like it...
Another comment mentions that languages aren't really the issue, platforms are, and enumerates a number of application contexts, and the languages that are used to develop in those contexts.
If you want to write native Apple software, then you need to either use ObjC, or Swift. You can use C or C++, and JavaScript, if you don't mind gluing them on, but native is Swift/ObjC, and Apple doesn't really do much to support ObjC (but they have to, anyway, because I guarantee that some of the biggest apps out there, still run with ObjC -including some Apple ones).
I use Swift. I write both UIKit and SwiftUI, but find that UIKit is what I use to deliver a great user experience. I have to use SwiftUI, for a few applications (like Watch apps), and am constantly slamming into its limitations.
Eh. That's why I run showdead = no. That comment obviously got nuked.
It's really fun, knowing that some folks hate me, just because I write software for Apple platforms.
I don't hate them back. That kind of hatred isn't very good for you. It's Commissioner Dreyfus-level obsession.
But this also shows what a tiny, tiny minority of people are represented here. Apple's a three-trillion-dollar company, because most folks aren't like us.
The thread was about "Swift would be a good language, but all the attention and focus is on the Apple ecosystem and everybody using it for something else is an outlier and if you don't want to deal with apple it's a hard game"
My response was directed at that. I said that its lack of non-Apple support isn’t a bad thing for many folks.
It was designed by Apple, for Apple. They only care about non-Apple support, if it results in Apple software for Apple hardware. I suspect they will be using it for some of their new custom server farms (or Python).
Mercenary as hell, but it’s not an uncommon stance; especially with hardware companies. I had to work with that attitude all the time, at my last job.
We are all “main characters” of our own stories. If we keep the focus on ourselves, and what we have learned, from our own experiences, then we’re likely to be writing about stuff we know.
I have had decades of experience with people saying “I hate you” because I write software for Apple systems, so I’m not imagining it. I also know that I’m not alone. It’s not exactly a “cutting edge” mindset.
Personally, I’m offended. I think that it’s shallow. I have plenty of other fine qualities to hate.
I’m always tempted to project motivation and intention onto others, but I’m not very good at it, so I keep it to myself.
I mean, as long as Apple continues to support ObjC, you can use any language that has an ObjC interface. I've shipped native AppKit stuff in Rust before, people have done Ruby, etc.
ObjC is one of the greatest "glue languages" to have existed IMO.
If your response to "Swift is being limited by Apple" is "well at least Apple hasn't killed it yet" then yeah, you're proving their point. Assuming you're right, and Swift is being empowered by Apple, then what is the language without Apple's support? Another .Net situation. They control the vision, the pitfalls of Swift as a language are the result of Apple's discretion. You can't blame the community for refusing to do Apple's dirty work pro-bono.
And honestly, Apple shouldn't be unhappy with where Swift is at right now either. They got exactly what they wanted from it, having third-party language stakeholders was never part of the equation for supporting Swift. A best-case scenario like Mono for Dotnet wouldn't be worth it, and Apple devrel is already in the toilet to boot. Might as well just go mask-off and run the whole thing like any other iOS library, but that's just my $0.02.
My view is that languages don't matter only libraries and engines. If you want to make an iOS app then Swift is for you. If you want to make an Unreal Engine game then C++. If you want to make a website then JavaScript. If you want to play with Bevy or Servo libraries then Rust. If you want to play with Blender or do anything with AI then Python.
I think that argument is on increasingly shaky ground these days as the barriers are starting to come down in a lot of ways.
First in the sense of hand crafted interop solutions that modern languages provide.
Take Dart for example as something that has a (by comparison) very small package ecosystem.
However it has support for interop across: JavaScript, Java, Objective C, C, C++, Rust, Swift, Kotlin and Go I believe off the top of my head.
Then you also have efforts like WebAssembly and specifically the in-development component model which seeks to totally break down that language specific package ecosystem and make importing and working with another language as easy as it is when importing a package from your own language ecosystem.
So with those things in mind, however true that might be today, I don’t think it’s a strong argument moving forward.
I am not sure but your comment seems to make the point of the person you're answering to.
Dart is used probably and exclusively in one context (= library): Flutter. Nobody would dream of writing anything else with it and put it in production.
Why? Because despite the interop, all the libs are still in the original language and they shine in the language they were written with. And Dart has no ecosystem comparable to the top 5-10 most used languages.
Try to build bindings for QT in Dart. That alone would require a company just to make that happen. You'd have to pay developers just to make that interop work - that's what Riverbank did with pyqt. No other companies did that, as far as I know (until Nokia developed pySide). And what for?
So I somehow agree with the previous comment, unless someone writes really good bindings. That's rare, though, and from my experience it's mostly to put something in legacy mode.
There's at least 2 bindings for QT in Dart (in general, darts a pretty big pond, there's been a strong steady uptake of Flutter that's not delineable enough in a way to concisely update impressions it's small)
Yeah, and I agree with you, I would think its nuts too. A couple years ago I didn't have any experience to tell me otherwise and would never have done that -- I'm only up for it now because I've had a great and literally painless time wrapping ONNX, llama.cpp, and a couple other C++ libraries using generated bindings.
I agree strongly on that it is good to make software architectural decisions, involving business, based on if you have a bunch of other people with the same problem shape as you.
And on specifically the idea that Darts not exactly hosting multiple UI frameworks, even though it theoretically could. (I don't know enough about Qt to know who uses it and why, my understanding vaguely is Linux UI. Canonical is all-in on Flutter, for whatever reason, so I discount the probability that Dart would naturally gain Qt bindings, if it was non-small)
There is a circular dependency — the language strongly influences what libraries/engines can and will be written.
Bevy and Servo wouldn't exist without Rust. Unreal probably wouldn't succeed without C++.
Languages may also matter for other reasons than just their feature set. Node.js got traction specifically because it was JavaScript.
Even though Fortran had state-of-the-art numeric libraries, Python enabled numpy to have the sweet spot of usability with good enough speed.
The killer libraries need years of effort to build them. That won't happen if users don't want to use the language, or the language isn't good enough for the task.
For Swift to have killer libraries, users must first choose Swift to build them. Catch22.
Spot on, for a long time, the project and platform dictactes the languages I use, not the other way around.
Being a YXZ Developer trying to fit YXZ into every domain, means that for many scenarios one ends up yak shaving until the foundations are in place for the actuall work one is supposed to do.
And even then, the tooling (IDE, debugging, build, libraries) will fail short from the platform native experience.
My motto is to always be curious and learn what is out there just in case, however in what concerns production work, only what is directly supported out of the box by the platform matters.
Typescript is maybe the exception, then again it is really a JavaScript linter in practice, the team has learned not to add additional language features.
After coding in swift for ~5 years at job - 1, I can count on one hand the times I had to deal with a reference cycle, and in each instance it was obvious in context that there was going to be a cycle so I used “weak” in anticipation. Zero times did I ever accidentally forget to use a weak reference.
A simple rule of thumb is that if anything has a parent/child relationship, the child should use the weak keyword (or even “unowned” if you’re certain about object lifetimes) when referring back to the parent. That and things like hand-rolled doubly linked lists, but the standard library already has that so who cares.
Also for all the hate Xcode deservedly receives, it comes with some really great tooling in the Instruments package that, among other things, makes it trivial to detect leaked memory when it does happen. And from my own experience developing in Obj-C and Swift for 15 years, I agree that it’s really not the big issue that anti-reference counting people make it out to be.
Well kinda; even in a tracing GC language like C# you have things like WeakEventManager (https://learn.microsoft.com/en-us/dotnet/api/system.windows....) to prevent memory leaks when using callbacks as event handlers. It is definitely not exclusive to ref counted languages.
True, but it only works on Apple systems, which makes Swift far less appealing on non-Apple systems. This adds weight to the point the GP comment makes about Swift being held back by its association with Apple
They used to. AppCode was excellent. Fleet kind of supports Swift well enough.
AppCode was abandoned because Apple is impossible to work with and never provided up to date semantics and language definitions for Swift, keeping everything under wraps and making every single Swift release a race to suddenly implement whatever new keyword they made up this week.
Fleet is more of a VSCode. Probably using the LSP these days, and it's good enough if a simple text editor is what you need.
Swift is literally developed in the open, so I don’t think your argument makes sense.
I think the reason they abandoned it was trouble keeping up with new iOS SDK features getting shadow dropped as part of new Xcode betas and iOS devs wanting to immediately prepare their apps to use those features, not anything to do with Swift language releases. Also things like having to recreate interface builder, then support auto layout in it, and then later SwiftUI previews, etc. Again all iOS platform stuff, not Swift language stuff.
I don’t think anyone actually believes that the language change is what made the difference in that post. As far as anyone can tell there were 2 things that made their rewrite better:
1. They had experience on the type of app and you tend to do things better when you do it the second time.
2. Reading between the lines they were likely running an ancient version of Java from 10+ years ago.
> I don’t think anyone actually believes that the language change is what made the difference in that post
They already admit in the article that JVM setup costs were a huge overhead during scaling operations. JIT might also incur a similar overhead at the same stage. So, not the language per se, but the runtime difference must have made a difference.
Compiled native code may not be too different between the two. But, in terms of memory management, Swift's ability to keep the heap in a smaller area might contribute to better cache utilization which might implicitly contribute to performance.
In the end, as you said, writing better code the second time might have made the greatest contribution of course. That doesn't necessarily mean that language change has made no difference.
> They already admit in the article that JVM setup costs were a huge overhead during scaling operations. JIT might also incur a similar overhead at the same stage.
Yeah the startup costs are an active problem. I do think though that if they weren’t running an old runtime they wouldn’t have had the same GC issues.
No wonder Swift performs unwell in this benchmark. The Swift implementation is written very poorly, done by developers obviously unexperienced in writing proper Swift :)
When I write code, I always start with the platform, which drives and limits the language choices. I don't say I want to write in C++, I say I want to write for web, or for iOS, or Windows, or whatever. If I'm writing for web, I'll reach for TypeScript. If iOS, then ObjC. If Windows, maybe C# if I'm being threatened. Using Rust to build a web app is like pulling teeth.
If many people think the same way, then yeah, there's no good reason to reach for Swift unless you're writing an iOS or Mac app and don't want it to be cross platform for some reason that I almost can't imagine in 2025.
>Seems to hit a sweet spot of a fast/compiled (compared to Javascript), memory safe (compared to C++), object orientated (compared to Go) and easy to write (compared to Rust).
What you've enumerated are also applicable to Dlang with potential of even faster compile and execution time than C++ or even the venerable Fortran [1].
[1] Numeric age for D: Mir GLAS is faster than OpenBLAS and Eigen:
>Swift seems like a really nice language that's held back by it's association with Apple.
>Seems to hit a sweet spot of a fast/compiled (compared to Javascript), memory safe (compared to C++), object orientated (compared to Go) and easy to write (compared to Rust).
Replace Apple with MS and Swift with C# and all of this is still true but makes my heart ache even more.
or embracing complexity as C++. It used to be very simple and pragmatic language. that stopped with Swift 3. Remember Protocol based Swift - better than OOP - but now it seems a bastard child of C++.
Swift at one point could've been Golang with better C++ interop. A better Rust since it's memory safe without the gymnastics.
I don't think anyone cares about Apple here. Swift solved a problem that people outside iOS/macOS didn't have. Then it took ~10 years to make Swift more seriously general purpose and multi-platform, it's simply too late to be compelling when other languages have progressed too.
Re: easy to write, I'm not sure, Swift's recent explosion in complexity makes it a hard sell vs Rust, even if the learning curve might be slightly less steep. At the end of the day, Rust's DX wins in almost every dimension, people are willing to learn slightly more complex semantics if it saves times everywhere else: tooling, libraries, build tool and package manager, ... I believe even compilation speeds don't compare favorably.
Of the opposite.. there’s soo much hate against Apple and all their contributions. But somehow Google, Meta, annd Microsoft are better represented.
Swift solves a problem that is still there. It was also released before the final release of Rust.
It’s just that people seem to think that because it’s from Apple, it’s only meant for iOS/macOS.
I love swift, it combines so many things, and Apple is really good get pushing the language forward with its compilers/warnings.
I’m also using it for shell scripts and small utils, and it’s really great. I made https://github.com/jrz/container-shell to improve the experience of scripting cli tools in Swift.
They deserve it. Look, Microsoft and Meta and Google are all evil companies too, but all of them actually make good-faith contributions to Open Source projects. Meta maintains React.js and Zstd, Microsoft does tons of open work on Typescript, VS Code and the Linux Kernel. Google handles the AOSP, Blink Engine, Go, Angular, JAX, Grpc... the list goes on. They're brimming with genuine, self-evident goodwill, even when their businesses detract from humanity.
So; what exactly are Apple's big, selfless contributions? XNU is Source Availible but unusable without buying proprietary Apple hardware. iBoot is mysterious and has to be reverse-engineered to use it like UEFI. Open standards like Vulkan are ignored for political reasons, CUPS is basically derelict, WebKit killed KHTML because sharing was too hard, and APFS and Metal are still both undocumented despite promised transparency. CoreML is proprietary but can't compete with CUDA, iPads can't use QEMU despite supporting it in-hardware, all the Apple Silicon DeviceTree code is private, competing runtimes like Corellium get sued and security researchers get ignored. Swift, as an offering to the Open Source community, is a punch line at the end of a 20 year long gag.
Apple does genuinely nothing to advance the wellbeing of common computing for mankind. Apple leaves behind no charitable contributions to anything that does not ensure their absolute preservation as a business. Combined with the proven anticompetitive damages that the App Store incurs on the burgeoning mobile market, they are unequivocally a net-negative force and aren't hated enough for their parasitic influence on global software production.
And yet, they make the best damn computers out there with hardware second to none, make the single best consumer-level AI computer, are better at product design than basically anyone in the world, and have defined at least four different product categories, while donating billions of dollars to truly charitable causes and being more clearly committed to sustainability than any of their other large tech giants.
Well, your first three claims are subjective and your second two claims are something both Meta, Microsoft and Google have all done themselves. I was focusing more on what made Apple unique, not why people want to exonerate them so desperately. Your could use the same defense to protect Facebook and nobody could objectively disprove you.
Cause like... we could start judging companies based on how many carbon credits they buy. But that wouldn't make Microsoft or Apple or Google any less evil, so it's a non-sequitur. Apple can simultaneously mass-produce the most desirable hardware in the world while creating anticompetitive market conditions that debilitates fair choice and destroys legitimate value. The United States threatened to break up Microsoft for the same overreach.
I'm fairness, when Swift was first released it was basically Apple devices only. It took forever for Foundation to get ported to other platforms (and good luck writing anything useful without Foundation).
Yes this exactly. People are also conveniently ignoring or forgetting that Apple kept changing the ABI for Swift binaries - it wasn't until 'v5' did they lock it down. Objective-C is 30+ years old and only once had this issue with the ObjC 2.0 release. Really, Swift v5 was the real v1.0 release because it was at that version Swift was truly ready for primetime.
When C#/.NET was first released it was basically Windows devices only, too. First release: 2000, cross-platform and opened up in 2014, if I’m reading Wikipedia correctly.
When Android was first released it was basically Android devices only, too. Still is.
Lots of folks are looking for a sweet spot that combines most of Rust's upsides with a less restrictive model. I'm working on a game in Swift (using Godot bindings) for that reason.
Meh, I could've been curious about playing with Swift if it wasn't so Apple-centric. Just like I could've been curious about playing with C# if it wasn't so Microsoft-centric.
I don't feel C# is that Microsoft-centric anymore - not after the release of Roslyn.
It works well on Windows, macOS, iOS, Android and I suspect Linux as well (but I never use Linux, hence I can't be sure). And if you want a multiplatform UI there's some decent options like Avalonia UI [0].
When Microsoft ported C# to Linux, they actually held off on releasing it because Linux ran C# applications better than Windows OS. They took time to refactor the code so Windows OS and Linux where on par. I cannot remember the source video where Microsoft employees talking about it is. The video was right after the .NET Core initial release.
That being said. Microsoft does not want a cross-platform C# that works on Linux. This is why their .NET MAUI does not support Linux and a 3rd party framework will be needed.
Only reason I would choose C# for non-Windows is because of existing / legacy code base. Any new application would use language and libraries that fit the problem versus trying to fit C# as the solution to all.
Mono actually is the primary project that greatly improved the C# world and evolved the latest .NET infrastructure, not Microsoft. Mono developers actually cleaner APIs. Even Microsoft Visual Studio for Mac is just Mono Developer with the Linux supporting bits removed.
I think the evolution of C# beyond Microsoft is overplayed. The entire tooling around the language remains a Microsoft product, with all the attendant Microsoft nonsense. It has opt out telemetry, even on Linux, and like every other MS product is currently having AI force-fed down its throat. It's only a matter of time until a compiler update automatically uploads all your code to Microsoft Azure Recall .net Passport Hotmail ft. the Copilot dancers.
If you're developing Windows apps or Windows games, C# is a fine choice; much as Swift is a fine choice for Apple apps. But no one worried about Apple's control of Swift should be pointing people to C# with a straight face.
To be fair, LLVM wasn't an Apple-initiated project, but one Apple noticed and decided to adopt later on (they hired Chris Latner in 2005; LLVM began in 2000, and had its first public stable release in 2003).
Unlike Swift, there was never a period of time where LLVM only worked exclusively on Apples own OS's or hardware. From the get go, you could run early versions of LLVM on Windows. In Swift's case, Linux support came in 2016, 1.5 years after Swift's initial release in 2014, then Windows support came 6 years later in v5 (2020).
If Apple didn't want to let Swift suffer the reputation of being an Apple-only language they should've invested more into cross platform support much earlier on. Yes, today Apple and everyone else can say, 'Swift is cross-platform', but dig deeper into the history of Swift and its clear that from the get go, Apple treated non-Apple OS support as an afterthought.
Seems to hit a sweet spot of a fast/compiled (compared to Javascript), memory safe (compared to C++), object orientated (compared to Go) and easy to write (compared to Rust).
Doesn't seem like there's any maintained bindings for Qt though, although there are some interesting ones for GTK (e.g. https://git.aparoksha.dev/aparoksha/adwaita-swift)