1. pygame
  2. pygame
  3. pygame


pygame / install.txt

                            Pygame Installation

   Python can be built from source, but the easiest way is to get a
   binary package for your type of system and version of python. This
   document will give you information on either type of installation.
   Windows Binary Installer

     This is probably the most popular method of installation. If you
     are running on windows, it is highly recommended you use this form
     of installing. The installers come with with nearly everything you
     need, and have an easy point and click installers.

     The first thing you will need is an installation of Python. Python
     binary installers make it easy to get this done. Pygame binaries
     usually come for the latest 2 releases of python, so you'll want to
     be fairly up to date.

     Once that is in place, you want to download the appropriate windows
     binary. From the pygame downloads page you can find the .EXE file
     you need. This will automatically install all of pygame and all the
     SDL dependencies. The windows binaries have filenames like this;
     "pygame-1.3.win32-py2.1.exe". This would be the installer for
     pygame version 1.3, for python version 2.1. You shouldn't have
     trouble finding the correct binary from the "Windows" section of
     the download page. http://www.pygame.org/download.shtml.

     You will also probably want to install the windows documentation
     and installation package. This will add easy links to the different
     documentation and games that come with pygame. The installer for
     this is found next to the other windows binary downloads. The
     filename looks like this; "pygame-docs-1.3.exe". And this would
     install the documentation and examples for pygame-1.3.

     One other thing the windows binaries are missing is the Numeric
     Python package. You can easily install this separately and it will
     allow you to use the pygame "surfarray" module. This module is
     optional, so there is no need to do this. There are binary
     installers from the Numeric download page.

   Unix Binary Packages

     For many unix systems, the easiest way to install pygame is from
     source. Still, there are binary packages available for different

     There are several binary RPM packages for linux machines. These are
     actually a little bit of work to install, since you will also need
     several RPM packages for the dependencies. There is a good chance
     your linux distribution came with the needed dependencies (like
     Python and SDL). There are binary RPMs available from the website
     for each dependency.

     For debian systems, pygame is actively maintained in the debian
     archives. Visit the debian pygame page for more information.

     FreeBSD also has an active pygame package. While techinicaly it
     isn't binary, it is automatically built and installed by the ports
     manager. See the FreeBSD package page for more information.

     Gentoo has a builtin package for pygame. This is compiled for your
     system as it installs, similar to BSD,

   Macintosh Binaries

     There are separate binaries for both MacOS and OSX. For both these
     operating systems, there are several remaining problems with the
     Python and SDL dependencies. Therefore the binary packages for
     pygame also come with fixed versions of python and the SDL

     For MacOS 9.x, binaries are available on the pygame downloads page.
     http://www.pygame.org/download.shtml. Unfortunately the binaries
     are stuck at pygame version-1.1. This also only works with an old
     copy of MacPython 2.1.

     For OSX, we are creeping along towards binary compatability.
     Previously there was a hefty "kitchen sink" package which included
     a heavily patched version of python and dependencies, also many
     extra libraries like pyopengl. Nowadays those patches have made
     their way into the real dependencies, so the need for the "kitchen
     sink" should no longer be necessary. Once Python 2.3 is released we
     should be able to make a simple binary package for OSX.

   Installing From Source

     Compiling and installing pygame is handled by Python's distutils.
     Pygame also comes with some scripts to automatically configure the
     flags needed to build pygame. Use the "setup.py" script to start
     the installation.

     The first time you run the setup script, it will call the
     "config.py" script. This will build a "Setup" file which stores all
     the information needed to compile. The "config.py" will do a good
     job of detecting what dependencies are available and where they are
     located. If it isn't perfect, it is easy to build your own, or edit
     the created "Setup" text file. This "Setup" file is a simple
     Makefile-like text file. It defines variables needed to use each
     dependency, and then enables all the pygame modules with found
     dependencies. If you have trouble compiling, you should be able to
     easily fix any problems inside the "Setup" file.

     Running the "setup.py" script will call distutils to build and
     install the pygame package. Distutils actually supports a wide
     variety of compile and install options. running "python setup.py
     help" will start to show you the different options available. You
     can change many things like install locations, compiler to use, and
     more. Calling the "setup.py" script with no arguments and it will
     just ask you if you want the default flags needed to compile and

   Windows Compiling Info

     Compiling all the dependencies on windows is a real challenge.
     Fortunately there is zip file with all the libraries and headers
     you need to compile. You should definitely unzip this into your
     pygame source folder, and all the files go into a "prebuilt"
     subdirectory. The autoconfigure "config.py" script will find this
     prebuilt directory and make use of it for you.
     http://www.pygame.org/ftp/win32-dependencies.zip. If you don't use
     the prebuilt binaries directory, the autoconfig script will scan
     the neighboring directory trees to find the dependencies.

     When installing on windows, the "setup.py" script will also copy
     all the used .DLL files into the pygame directory.

     If compiling with VisualC, these instructions are all you'll need
     to do. If you are using Borland's free compiler or cygwin, you will
     need an extra step. You need to convert the VisualC style .LIB
     files into the format used by your compiler. Both Borland and
     Cygwin include a command to do this. To convert the python library
     the command looks like this with Borland: COFF2OMF python22.lib
     python22_bcpp.lib. For Cygwin, this is the command you need:
     DLLTOOL --dllname python15.dll --def python15.def --output-lib
     libpython15.a. You will also need to do this conversion on all the
     LIB files that come with the prebuilt dependencies (in the
     prebuilt/lib directory). Note that with cygwin you should replace
     the --def flag and argument with --export-all-symbols since they do
     not come with .def files.

     Mingw is well supported by SDL, but a little rougher for python
     extensions. Here is a link with more information to compiling with
     non-ms compilers.

   Unix Compiling Info

     Compiling from linux shouldn't give you any problems. One thing you
     must keep in mind is that most linux RPM packages separate the
     actual library from the "dev" files needed to compile. To build you
     will need to make sure the packages like "SDL-dev" are installed.

     You can check to see if SDL is ready to be built from by running
     the command sdl-config and seeing if it is found. If the sdl-config
     script is not on the path (or you have more than one?) Set the
     environment variable SDL_CONFIG to its location.

     Sometimes you will have the SDL libraries installed in once
     location, and the other SDL libraries in another. This tricks the
     pygame config scripts, but you can help it out by setting the
     environment LOCALBASE to a path prefix where the other libraries
     are. The common case for this is SDL installed in /usr and other
     SDL libs installed in /usr/local. The command for this situation is
     "LOCALBASE=/usr/local python setup.py install".

   OSX Compiling Info

     OSX Support is coming along slowly. With the release of Python 2.3
     coming, things should actually be much smoother. Soon after that
     there should be a pygame 1.6 release, with out-of-the-box support
     for OSX. Currently it works fairly well, follow along the regular
     UNIX compile instructions, and report your results, we need more