A Swift package for statistics, linear algebra and machine learning.
Quiver adds numerical methods directly to Swift’s standard Array through extensions. A plain [Double] gains the math without becoming a different type, so it still flows straight into SwiftUI, Swift Charts and SwiftData.
Swift’s type system validates math at compile time. Constrained extensions expose operations only on compatible types, while [Double] and [[Double]] define vectors and matrices as plain arrays, with dimensions checked when the code runs.
A browser-based Swift IDE for testing and evaluating Quiver models before they move into an app. Quiver and Foundation are already imported, teaching datasets are bundled, and documentation appears inline for every symbol.
Iris, Titanic, California housing, GloVe word vectors and more, each loading by name in one line. toPanel() hands back a table of named columns.
Hover any Quiver symbol for its signature and summary, pulled from the same documentation that ships with the package. Autocomplete and signature help fill in the rest.
The server answers on 127.0.0.1 with a per-launch key. No accounts, no telemetry, no analytics.
Code written in the Notebook is ordinary Swift. Copy it into an Xcode project, add Quiver as a package dependency, and it compiles unchanged for iPhone, Apple Watch, Vision Pro or the Mac.
A model fits inside the app from data the device already collects, such as motion, location, HealthKit samples and workouts. Every model exposes what it learned as plain Swift values: coefficients with standard errors and p-values, cluster centroids, principal components. The same code runs on Apple Watch, iPhone, the Mac and Linux.
The Notebook builds every snippet against the published Quiver package, pinned to the release shown in its footer. Code that compiles in the Notebook compiles in Xcode against that same release.
The teaching datasets are part of the Notebook, not the Quiver package, so the package an app ships stays small with zero dependencies. toPanel() hands back a Quiver Panel, so every line after the load is plain Quiver.
The True Effort Score model learns each runner's baseline from their own recent runs. It measures heart rate, pace, cadence, grade, altitude and vertical oscillation during a run and scores the effort on Apple Watch.
For models created with fit, there is no empty or unfitted state. The fit method returns a trained model, so calling predict on an untrained model cannot compile.
No runtime error for “model not fitted”. The situation cannot arise.
let model = KNearestNeighbors.fit( features: trainingData, labels: labels, k: 3) let predictions = model.predict(newData)
Coefficients, centroids and learned parameters cannot change once a fitted model exists. A whole category of accidental-retraining bugs disappears.
Every stored property is a basic Swift type, so models encode to JSON with no extra code. Save one to disk and load it on the next launch without retraining.
try LinearRegression.fit(...) // can fail KNearestNeighbors.fit(...) // cannot fail [Double].polyfit(...) // nil on failure
Regressorpolyfit, plus analytic derivatives.ClassifierModels share their prediction interface through two protocols. Code written against Regressor accepts LinearRegression, Ridge and GradientDescent interchangeably, and code written against Classifier does the same for every classifier.
Every model and result type prints a readable summary. Vectors and matrices render in textbook form, and the underlying values are never touched.
Fitted models in Quiver are Sendable. A fitted model is an immutable value, so it crosses task boundaries with nothing to lock and nothing to coordinate.
Run a fit on a detached task and await the trained model back. The interface keeps drawing while training runs.
Prediction is a pure read against immutable parameters, so any number of concurrent tasks can call predict without serialization.
Pairwise comparisons and other heavy operations split cleanly with withTaskGroup, and the results update SwiftUI when training completes.
Retrieval-augmented context, commonly known as RAG, in six steps. Quiver handles the search so the app can decide what to do with what it finds.
Quiver returns a String and stops. The same context block feeds an on-device model on a phone, a hosted model behind an API, or a model running on a server.
Quiver has zero dependencies, so the search code that runs on an iPhone runs inside a Vapor app unchanged. The [Double] Vapor decodes from JSON is the same [Double] Quiver computes on, with no subprocess and no second runtime.
This example ranks a small dictionary. For a catalog that grows, EmbeddingIndex stores each vector beside its label, ranks a query against all of them by cosine similarity, and saves as a Codable snapshot. Those are the core operations behind vector search, written in Swift.
Here both tables are made by hand. A sentence model, plugged in through Quiver’s Embedder protocol, would produce the vectors instead, and the ranking with nearest(to:k:) stays the same.
A /search route is retrieval. Feed its results to a language model as context and the server has a full RAG pipeline, with Quiver handling the search.
Quiver runs on the CPU with plain Swift arrays and no dependencies, so the same code runs unchanged on Apple Watch, iPhone and the Mac. Swift concurrency lets us move heavy work off the main thread and divide it across cores.
One of Quiver’s goals is to grow machine learning education on Swift. The math stays visible at every step, models expose what they learned, and a classroom needs nothing more than a Mac and the Notebook.
Start with a skewed population, draw a thousand small samples from it, and bin their means. The underlying data is nowhere near normal, but the sample means assemble into a classic bell curve. With a fixed seed, every student in the room produces the exact same histogram on their first run.
The sample means center on the population mean, and their spread of 0.294 is the standard error.
Built to teach. Built to ship.
The math runs on Swift arrays and every model exposes its learned parameters so the models are never a black box.
Fork the Notebook, drop examples into examples-custom/ and switch to Presenter mode. Each clone is pinned to one Quiver release for the whole semester.
The documentation includes nearly 70 articles covering concepts, data preparation, training and implementation. Results are tested against established reference implementations.
Swift Package Manager.
macOS 15 or newer with Swift 6. Then open localhost:8080.