Astropy has the following strict requirements:

Astropy also depends on other packages for optional features:

  • h5py: To read/write Table objects from/to HDF5 files
  • scipy: To power a variety of features (currently mainly cosmology-related functionality)
  • xmllint: To validate VOTABLE XML files.

However, note that these only need to be installed if those particular features are needed. Astropy will import even if these dependencies are not installed.

Installing Astropy

Using pip

To install Astropy with pip, simply run:

pip install astropy

Binary installers

No binary installers are available at this time.

Testing Astropy

The easiest way to test your installed version of astropy is running correctly is to use the astropy.test() function:

import astropy

The tests should run and print out any failures, which you can report at the Astropy issue tracker.

Building from source


You will need a compiler suite and the development headers for Python and Numpy in order to build Astropy. Using the package manager for your platform will usually be the easiest route.

The instructions for building Numpy from source are also a good resource for setting up your environment to build Python packages.

You will also need Cython installed to build from source, unless you are installing a numbered release. (The releases packages have the necessary C files packaged with them, and hence do not require Cython.)


If you are using MacOS X, the easiest way to install a compiler suite is to install the MacOS X developer tools (XCode) As of XCode 4.3, the command-line compilers are no longer installed by default: you will need to open the XCode application, go to Preferences, then Downloads, and then under Components, click on the Install button to the right of Command Line Tools.

Obtaining the source packages

Source packages

Source tarballs of past releases and the current development branch of astropy can be downloaded from

Development repository

The latest development version of Astropy can be cloned from github using this command:

git clone git://


If you wish to participate in the development of Astropy, see Developer Documentation. This document covers only the basics necessary to install Astropy.

Building and Installing

Astropy uses the Python distutils framework for building and installing.

To build Astropy (from the root of the source tree):

python build

To install Astropy (from the root of the source tree):

python install

External C libraries

The Astropy source ships with the C source code of a number of libraries. By default, these internal copies are used to build Astropy. However, if you wish to use the system-wide installation of one of those libraries, you can pass one or more of the --use-system-X flags to the build command.

For example, to build Astropy using the system libexpat, use:

python build --use-system-expat

To build using all of the system libraries, use:

python build --use-system-libraries

To see which system libraries Astropy knows how to build against, use:

python build --help

As with all distutils commandline options, they may also be provided in a setup.cfg in the same directory as For example, to use the system libexpat, add the following to the setup.cfg file:


Compatibility packages


This feature is still experimental, and you may run into unexpected issues with other packages, so we strongly recommend simply updating your code to use Astropy if possible, rather than rely on these compatibility packages.

Optionally, it is possible to install ‘compatibility’ packages that emulate the behavior of previous packages that have now been incorporated into Astropy. These are:

If you build Astropy with:

python build --enable-legacy
python install

or simply:

python install --enable-legacy

then you will be able to import these modules from your scripts as if the original packages had been installed. Using:

import pyfits
import vo
import pywcs

will then be equivalent to:

from import fits as pyfits
from import vo
from astropy import wcs as pywcs

In order to install the compatibility packages none of the original packages should be present.


If you are interested in testing out existing code with Astropy without modifying the import statements, but don’t want to uninstall existing packages, you can use virtualenv to set up a clean environment.

Building documentation


Building the documentation is in general not necessary unless you are writing new documentation or do not have internet access, because the latest (and archive) versions of astropy’s documentation should be available at .

Building the documentation requires the Astropy source code and some additional packages:

There are two ways to build the Astropy documentation. The most straightforward way is to execute the command (from the astropy source directory):

python build_sphinx

The documentation will be built in the docs/_build/html directory, and can be read by pointing a web browser to docs/_build/html/index.html.

The above method builds the API documentation from the source code. Alternatively, you can do:

cd docs
make html

And the documentation will be generated in the same location, but using the installed version of Astropy.

Testing your Astropy build

The easiest way to test that your Astropy built correctly (without installing astropy) is to run this from the root of the source tree:

python test

There are also alternative methods of Running Tests.