Swiftpack.co - Package - onekiloparsec/SwiftAA


Become a Patreon

SwiftAA (and ObjCAA)

Travis Codecov Carthage compatible FOSSA Status

The most comprehensive collection of accurate astronomical algorithms, in C++, Objective-C and Swift, all in one place.

(Available through all distribution mechanisms: Swift Package Manager, Cocoapods and Carthage.)

Other implementations: JavaScript (AA.js), C# (AASharp).

See Notes below for the difference between ObjCAA and SwiftAA.


SwiftAA provides everything you need to build our Solar System, compute length of seasons, moon phases, determine rise, transit and set times, get positions of large planetary moons, transform coordinates, determine physical details of planets, their illumination, distance etc. With a professional-grade accuracy.

SwiftAA is already used in production apps. In particular, MeteorActive, a carefully crafted iOS app to get everything about meteors.

SwiftAA is first built with an Objective-C(++) layer atop the C++ implementation by P.J. Naughter of the reference textbook Astronomical Algorithms, by Jean Meeus (2nd ed., Amazon). This C++ package is called AA+ (see below). AA+ also includes additional algorithms of the VSOP87 framework, and includes the complete support for the ELP/MPP02 theory. Thus, SwiftAA, thanks to AA+, is the most complete and accurate collection of algorithms for all things astronomical in Swift.

But SwiftAA provides more modern and a lot more readable APIs, taking advantage of the expressiveness of Swift and its various syntax elements, making it fun and easy of use. In fact, you simply can't use AA+ without having the AA book. While SwiftAA is precisely made to be accessible by anyone. Additional functions and algorithms are added to improve even more the completeness and ease of use. In particular, SwiftAA provides units safety a lot stronger compared to C++ APIs.

Moreover, SwiftAA has a much larger unit tests coverage (>90% for the Swift code!). In fact, unit tests are being carefully written with data directly taken from Jean Meeus' textbook, AA+ own tests, USNO, SkySafari and Xephem (and thus trying to achieve a probably hypothetical consistency between these sources).


The documentation generated from the code itself is available at http://onekiloparsec.github.io/SwiftAA.


Using the Swift Package Manager: either through Xcode > File > Swift Packages > Add Package Dependency... and enter this repo URL (including the .git extension), , then choose SwiftAA target. Or add the line .package(url: "https://github.com/onekiloparsec/SwiftAA.git", from: "2.2.2") in the dependencies section of your Package.swift file.

Using Carthage: add github "onekiloparsec/SwiftAA" to your Cartfile, then run carthage update, and finally add the newly built SwiftAA-macOS.framework or SwiftAA-iOS.framework into your project (in embedded binaries).

Using CocoaPods: add pod 'SwiftAA', or pod 'ObjCAA' to your Podfile and then run pod update.



For a long time, all the C++, Objective-C++ and Swift code was bundled together. But in order to distribute SwiftAA through the SPM, it was necessary to split the sources into seperate folders. Then, three different libraries were declared in the Package.swift file and built separatedly, each of them depending on the previous one (AA+, then ObjCAA, and finally SwiftAA).

During that evolution, we chose to create a specific ObjCAA target inside the Xcode project. The consequence is that ObjCAA must be imported in SwiftAA source files that need it. Not a big deal, expect for Cocoapods which doesn't understand the subtelty. Hence, we created a specific ObjCAA pod, which will follow the versionning numbers of the main package.

In summary, we have:

  • Three targets available through the Swift Package Manager: AA+, ObjCAA and SwiftAA. Embed only the last level you intend to use in your project.
  • Three targets available through Carthage, inside the Xcode project: ObjCAA (including AA+), SwiftAA-iOS and SwiftAA-macOS.
  • Two pods available through Cocoapods: ObjCAA and SwiftAA.


The AA+ framework, written in C++ by PJ Naughter (Visual C++ MVP) is certainly the best and most complete implementation of the "Astronomical Algorithms", found in the reference textbook by Jean Meeus. To make the most of this code specifically, you have to have a copy of the book with you (APIs and method names are hardly understandable without knowing what they refer to).

Pull requests are accepted only about the Objective-C(++) and Swift code. The AA+ code changes must be directed (as I will personnaly do if I need to) to the original source (see the AA+ website).

Today's version of AA+ used in SwiftAA is 2.08 (released October 22th, 2019).

Caution on Coordinates

The coordinates computations are key for modern astronomy. However, there is no mention to modern conventions (like ICRS) in the textbook of Jean Meeus, therefore in the AA+ code. Awaiting for such improvement, any user wanting to compute coordinates transformations should be careful. For a good example of a complete implementation of such transformations, see the AstroPy excellent package.

Prefixes & Conventions

Needless to say how different the syntax is between C, C++, Objective-C and Swift. The main guideline in writting SwiftAA was to build an Objective-C(++) layer that follow strictly the methods and interfaces of the underlying C++ library. Only the name of some variables were a bit "Objective-C-fied" (to avoid prefix them with the one-letter type, 'b' for boolean etc').

As Objective-C lacks namespaces, everything must be prefixed. It is a convention to use 3-letters prefixes in Objective-C. KPC stands for "kiloparsec" and is "my" usual prefix. I chose to keep the AA prefix that belongs to the C++ library as well. Hence the (rather long) 5-letters KPCAA prefix of all methods.

The constraint of having an Objective-C layer first comes from the fact that no C++ code can be written directly alongside Swift code (in the same file). And Swift doesn't have the header/implementation split into different files. Hence one must write a Objective-C++/C wrapper around it, with name prefixes.


For Swift4, see the swift4 branch. Likewise for Swift3 (unmaintained).


C├ędric Foellmi, a.k.a. @onekiloparsec (website).
(Ph.D. in astrophysics, and former support astronomer at the European Southern Observatory in Chile).
I am the author of the app iObserve (for macOS (and formerly in [iOS/iPad]) and arcsecond.io.


You can help me spend more time on Open-Source software for astronomers by supporting me on Patreon!


The licence of this software is the MIT licence, which allows you to use it freely in open-source or commercial products. But it does not apply to the AA+ Framework, which retains its own licence. Quoting the original:

AA+ Copyright :

  • You are allowed to include the source code in any product (commercial, shareware, freeware or otherwise) when your product is released in binary form.
  • You are allowed to modify the source code in any way you want except you cannot modify the copyright details at the top of each module.
  • If you want to distribute source code with your application, then you are only allowed to distribute versions released by the author. This is to maintain a single distribution point for the source code.


FOSSA Status


Stars: 76


Used By

Total: 0


Swift5, Xcode11 and AA+ v2.0+ - 2019-11-01 08:10:31

Update of SwiftAA for Swift5, Xcode11 and AA+ v2.0+.

Moon Phase bugfix ! - 2019-02-17 10:41:47

Thanks to a dedicated user, a fix on the Moon phases has been applied to SwiftAA code. See the closed issue #81 for details.

The release also contains some annoyance fixes for Xcode 10.2.

AA+ version update - 2019-02-02 08:24:52

AA+ from P.J. Naughter has seen various fixes and improvements since the last time we included the AA+ sources (v1.91). It was time to update to the latest version: v1.99.

2.0! - 2017-09-28 06:56:53

After months of hard work and a last-push-to-the-summit the last week for bringing unit tests coverage above 90%, I am pleased to announce SwiftAA reaches the 2.0 milestone.

Putting the Moon high in the sky - 2017-09-17 14:31:45

Well, the Moon class deserved some better doc and some additional APIs. Here there are, with various improvements and tests in different places. As we continue to cover the Moon with Unit Tests, we are approaching 2.0 release.

Important fix on Rise Transit & Set times. - 2017-07-29 14:47:14

The problem was a confusion between two types of ecliptic coordinates (one geocentric, one heliocentric). And the equatorial coordinates needed for the computation of rise transit set times were based on the wrong ones (heliocentric).

All tests pass. But for some of them, the accuracy isn't satisfactory (> a few minutes, up to some hours). With the large spread of sources on the Internet, often providing little clue on how things are computed, make it very hard here to have a consistent set of tests which are accurate compared to all these sources at the same time.

Nevertheless, we keep thriving!

For the archive, let state that the sources of data for tests are: The AA book (by Jean Meeus), AA+ own C++ tests, USNO, Sky Safari, Xephem.

First draft release of SwiftAA 2! (alpha-0) - 2016-12-18 14:59:23

A whole world of modern expressive Swift code base giving access to most of the Astronomical Algorithms. Lots to be perfected, but that's time for a release, since most of the (Obj-)C++ code is now covered, and more importantly, elevated to a more expressive formulation.

A draft of a Swift Playground is also provided for those who wants to play with SwiftAA, to study solar system dynamics, and properties for instance.

Hello Universe... - 2015-07-10 10:06:01

This is the first release of SwiftAA. It contains all the Objective-C wrappers as well as the Swift headers and files for you to access all the Astronomical Algorithms implementation of AA+ in Swift.

It is for iOS8+ as well as OSX Yosemite+

There is a very basic Swift Playground included. It will be developed in the coming months to exemplify the use of the AA.