TF's own analysis[0] was hesitant on static vs dynamic, finding downsides for either choice and suggested choosing a "middle ground" (which IMHO was doable starting from Julia's optional types).
So static typing might be your requirement, but it wasn't TF's requirement. When examining Julia later on, they don't mention dynamic types as a downside at all - and every argument save for "we're familiar with Swift's internal working" was contradicted within the same document...
Now, being familiar with Swift is a very understandable reason for their choice, but it's IMHO not the best choice for others which are not as familiar with Swift or ML. Most ML users are very familiar with Python and I think they will find Julia to be a welcome improvement on Python's pain points without Swift's baggage.
[0]
https://github.com/tensorflow/swift/blob/mas
tensorflow
swift
Jupyter Notebook2018–2026
tensorflow / swift · Archived
swift
Swift for TensorFlow
52Distinct people
59Mentions
0Explicit recommenders
6.1KGitHub stars
What to know before exploring
What it is
Swift for TensorFlow
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
No recommendation phrase was found in the indexed comments.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 8–Nov 15 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/15/2026, 9:02:44 AM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year59 dated mentions
Observed mentions: 2018-04-26 17:57:07 UTC to 2026-03-26 11:29:00 UTC.
* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 10 | 4 | 6 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 28 | 4 | 24 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 10 | 0 | 10 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 8 | 1 | 7 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 1 | 0 | 1 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
Swift for TensorFlow (Archived)
Swift for TensorFlow was an experiment in the next-generation platform for machine learning, incorporating the latest research across machine learning, compilers, differentiable programming, systems design, and beyond. It was archived in February 2021. Some significant achievements from this project include:
Added language-integrated differentiable programming into the Swift language. This work continues in the official Swift compiler.
Developed a mutable-value-semantics-oriented deep learning API.
Fostered the development of a model garden with more than 30 models from a variety of deep learning disciplines.
Enabled novel research that combines deep learning with probabilistic graphical models for 3D motion tracking and beyond.
Powered a(n almost) pure-Swift prototype of a GPU+CPU runtime supporting parallel map.
Spun off multiple open source side efforts which continue to be under active development:
PythonKit: Python interoperability with Swift.
swift-jupyter: Enables use of Swift within Jupyter notebooks.
swift-benchmark: Provides a robust benchmarking suite for Swift code.
Spun off several other open source efforts:
penguin: Parallel programming, data structures, graph algorithms, and more.
Tensors Fitting Perfectly: Static analysis of tensor shape mismatches.
Swift Evolution proposals pitched, implemented, and accepted:
SE-0195: User-defined "Dynamic Member Lookup" Types (@dynamicMemberLookup)
SE-0216: Introduce user-defined dynamically "callable" types (@dynamicCallable)
SE-0233: Make Numeric refine a new AdditiveArithmetic protocol
SE-0253: Callable values of user-defined nominal types (func callAsFunction)
This site will not receive further updates. The API documentation and binary downloads will continue to be accessible as well as the Open Design Review meeting recordings.
Getting started
Using Swift for TensorFlow
Google Colaboratory: The fastest way to get started is to try out Swift
for TensorFlow right in your browser. Just open up a tutorial,
or start from a blank notebook!
Read more in our usage guide.
Install locally: You can download a pre-built Swift for TensorFlow
package. After installation, you can follow these
step-by-step instructions to build and execute a Swift script on
your computer.
Run on GCP: You can spin up a GCE instance using a Swift for TensorFlow
Deep Learning VM image, with all drivers and the toolchain
pre-installed. Instructions can be found in the
Installation Guide.
Compile from source: If you'd like to customize Swift for TensorFlow or
contribute back, follow our instructions
on building Swift for TensorFlow from source.
Tutorials
Tutorial
Last Updated
A Swift Tour
March 2019
Protocol-Oriented Programming & Generics
August 2019
Python Interoperability
March 2019
Custom Differentiation
March 2019
Sharp Edges in Differentiability
November 2020
Model Training Walkthrough
March 2019
Raw TensorFlow Operators
December 2019
Introducing X10, an XLA-Based Backend
May 2020
Resources
Models and Examples
TensorFlow Swift API Reference
Release Notes
Known Issues
Frequently Asked Questions
TensorFlow Blog Posts
Forums
The discussions happened on the
swift@tensorflow.org mailing list.
Why Swift for TensorFlow?
Swift for TensorFlow is a new way to develop machine learning models. It
gives you the power of
TensorFlow directly integrated into the
Swift programming language. We believe that
machine learning paradigms are so important that they deserve
first-class language and compiler support.
A fundamental primitive in machine learning is gradient-based optimization:
computing function derivatives to optimize parameters. With Swift for
TensorFlow, you can easily differentiate functions using differential
operators like gradient(of:), or differentiate with respect to an entire
model by calling method gradient(in:). These differentiation APIs
are not just available for Tensor-related concepts—they are
generalized for all types that conform to the Differentiable
protocol, including Float, Double, SIMD vectors, and your own data
structures.
// Custom differentiable type.
struct Model: Differentiable {
var w: Float
var b: Float
func applied(to input: Float) -> Float {
return w * input + b
}
}
// Differentiate using `gradient(at:_:in:)`.
let model = Model(w: 4, b: 3)
let input: Float = 2
let (𝛁model, 𝛁input) = gradient(at: model, input) { model, input in
model.applied(to: input)
}
print(𝛁model) // Model.TangentVector(w: 2.0, b: 1.0)
print(𝛁input) // 4.0
Beyond derivatives, the Swift for TensorFlow project comes with a sophisticated toolchain
to make users more productive. You can run Swift interactively in a Jupyter
notebook, and get helpful autocomplete suggestions to help you explore the
massive API surface of a modern deep learning library. You can get started
right in your browser in
seconds!
Migrating to Swift for TensorFlow is really easy thanks to Swift's powerful
Python integration. You can incrementally migrate your Python code over (or
continue to use your favorite Python libraries), because you can easily call
your favorite Python library with a familiar syntax:
import TensorFlow
import Python
let np = Python.import("numpy")
let array = np.arange(100).reshape(10, 10) // Create a 10x10 numpy array.
let tensor = Tensor<Float>(numpy: array) // Seamless integration!
Documentation
Beware: the project is moving very quickly, and thus some of these documents
are slightly out of date as compared to the current state-of-the-art.
Overview
Document
Last Updated
Status
Why Swift for TensorFlow?
April 2018
Current
Swift for TensorFlow Design Overview
April 2018
Outdated
Supported Backends
May 2020
Current
Technology deep dive
The Swift for TensorFlow project builds on top of powerful theoretical
foundations. For insight into some of the underlying technologies, check
out the following documentation.
Document
Last Updated
Status
Swif
Read the full README on GitHubWhat Hacker News says
10 sourcesIn Swift for TensorFlow – A system for deep learning and differentiable computing
Related: Why Swift for TensorFlow: https://github.com/tensorflow/swift/blob/master/docs/WhySwif...
In Swift for TensorFlow – A system for deep learning and differentiable computing>Who would want to use an Apple-centric language for ML, seriously? Apple hardware is outright incompatible
Based on how you wrote your comment, I'm guessing you may not know this S4TF is a Google initiative.
Yes, Chris Lattner used to work for Apple but he was at Google Brain during the start of this project. When his team wanted to create a language where automatic differentiation and gradient descent was a 1st-class concept in the core syntax (i.e. without libraries) of the programming language , they looked at Rust, Julia, Swift, etc[1]. They ended up choosing Swift as the base language to extend with new ML syntax.
Also, Chris has said in previous interviews that he thought of Swift as general purpose language and that hoped it would be used outside of Apple's ecosystem.
EDIT to address the confusion where some assume Apple hardwa
Read the rest
re dictates the direction of S4TF: For those not aware, Google's hardware TPU (Tensor Processing Unit)[2] is built with custom ASIC chips and not ARM nor Apple Silicon chips. Presumably, S4TF would run natively against Google's TPU. In other words, the goals and execution targets of S4TF are not restricted by Apple's ecosystem of macOS/iOS/Macbooks/iMacs/iPads in any way. Yes, the SwiftUI framework is Apple-specific but Swift-the-core-language-syntax[3] is not.
[to downvoters: if I wrote inaccuracies, please correct me.]
[1] https://github.com/tensorflow/swift/blob/master/docs/WhySwif...
[2] https://en.wikipedia.org/wiki/Tensor_Processing_Unit
[3] https://docs.swift.org/swift-book/ReferenceManual/zzSummaryO...
They’re looking to build demand over time by making Swift available in as many places as possible.
And this is the Swift Open Source team, not Apple specifically. It’s not an Apple business decision (aside from lowering the learning hurdle for new iOS projects)
Not to mention there’s Swift for TensorFlow, would be nice if you could handle your code locally on a Windows machine: https://github.com/tensorflow/swift/blob/master/docs/WhySwif...
In Swift 5.3 Will Be Supported on Windows and Additional Linux DistributionsSwift for Tensorflow has implemented Python interoperability, rather than embedded Python code as in this article. A Swift program can import a Python module and interact with Python objects and functions as if they were native Swift objects (minus strong typing, of course). See https://github.com/tensorflow/swift/blob/master/docs/PythonI...
In Writing Python inside RustSounds great! I just looked at https://github.com/tensorflow/swift - where can I find a convolution operation written in Swift?
In Swift: Google’s Bet on Differentiable ProgrammingTheir reasoning: "We love Rust, but it has a steep learning curve that may exclude data scientists and other non-expert programmers who frequently use TensorFlow." [1]
(I can't comment on that because I don't know Rust nor am I a data scientist!)
[1] https://github.com/tensorflow/swift/blob/master/docs/WhySwif...
In Swift: Google’s Bet on Differentiable ProgrammingFrom the language selection doc[1]:
"Java / C# / Scala (and other OOP languages with pervasive dynamic dispatch): These languages share most of the static analysis problems as Python: their primary abstraction features (classes and interfaces) are built on highly dynamic constructs, which means that static analysis of Tensor operations depends on "best effort" techniques like alias analysis and class hierarchy analysis. Further, because they are pervasively reference-based, it is difficult to reliably disambiguate pointer aliases.
As with Python, it is possible that our approaches could work for this class of languages, but such a system would either force model developers to use very low-abstraction APIs (e.g. all code must be in a final class) or the system would rely on heuristic-based static analysis techniques that work in some cases
Read the rest
but not others."
[1] https://github.com/tensorflow/swift/blob/master/docs/WhySwif...
Rust cannot replace Python, it's syntax is ugly and completely designed against beginners. It's a systems programming language to replace C++ (replacing C might not be possible as most of Cargo packages use C libraries encapsulating them in unsafe code). So some libraries might move from C++ to Rust in machine learning, but it will still need to be used from within Python. Rust like C/C++ might become another glue language for Python.
Many Python programmer did go towards Go language but it also cannot replace it yet even after decade.
The only viable contender in this list is Julia, but not yet sure about it as it cannot be used to develop end to end application using AI and ML.
Probably the article should include Swift as more viable alternative given it's syntax is similar to Python along with good readability and already trying to pro
Read the rest
vide interface for Tensorflow [1].
[1] https://github.com/tensorflow/swift
Nitpick: Swift for TensorFlow currently is a fork of Swift, not a library implemented in Swift. https://github.com/tensorflow/swift:
”Compiler and standard library development happens on the tensorflow branch of the apple/swift repository.
[…]
Swift for TensorFlow is not intended to remain a long-term fork of the official Swift language. Language additions are designed to fit with the direction of Swift and will go through the Swift Evolution process.”
In Seq – A Language for Bioinformatics