pygame is
Simple DirectMedia Layer is
Site Swing



I was stuck using a platform that did not support extended image formats, but I absolutely had to have per-pixel-alpha. To overcome, I wrote this nifty little module.

Load a 32-bit, RGBA Windows Bitmap file for use with PyGame.
2007 Michael Thomas Greer
Released to the Public Domain.
  PyGame does not always come with the ability to load all image types. This
  is inconvenient because sometimes you just really, really want to play with
  per-pixel alpha images, but PyGame's BMP support doesn't understand a
  bitmap's alpha channel, and if you are stuck using a platform without
  extended image support, who do you call?
  Windows BMP files have always been capable of storing alpha data, but it was
  only with the release of Windows XP that Microsoft actually supported such
  use. As a result, most BMP readers/editors ignore or clobber alpha data in
  your bitmap. PyGame is no different.
  This module addresses that problem in pure python code.
Example of How to Use
  Here's a very simple example. You'll need two files to run it. The first,
  named "background.bmp", is any normal BMP file to use for the background
  image. The other, "foreground.bmp32", is a 32-bit BMP with alpha channel
  which follows the cursor as you move it around the PyGame display window.
    import pygame
    import bmp32
    bg     = pygame.image.load( 'background.bmp' )
    screen = pygame.display.set_mode( bg.get_size() )
    bg     = bg.convert()
    fg     = bmp32.load( 'foreground.bmp32' ).convert_alpha()
    screen.blit( bg, (0, 0) )
    pygame.mouse.set_visible( False )
    done = False
    while not done:
      for event in pygame.event.get():
        if event.type in [pygame.QUIT, pygame.KEYDOWN]:
          done = True
        elif event.type == pygame.MOUSEMOTION:
          screen.blit( bg, (0, 0) )
          screen.blit( fg, event.pos )
Building a 32-bit BMP with alpha channel
  Photoshop is one of the few programs that can load and save a BMP with alpha
  data. If you don't have access to Photoshop (as I don't), here's a little
  cross-platform C++ source to compile a bitmap with alpha.
  It requires the EasyBMP library at "".
  EasyBMP is specifically cross-platform, small, and self-contained. Just
  unzip everything to a new directory. Create a new CPP file in that same
  directory and paste the following into it.
    // bmp32.cpp
    // Takes two BMP files and combines them into a 32-bit, RGBA Bitmap.
    // 2007 Michael Thomas Greer
    #include <iostream>
    #include <fstream>
    #include "EasyBMP.h"
    using namespace std;
    int usage() {
      cerr &lt;&lt; "usage:"                                              &lt;&lt; endl
           &lt;&lt; "  bmp32 rgb.bmp alpha.bmp result.bmp32"              &lt;&lt; endl
           &lt;&lt;                                                          endl
           &lt;&lt; "where:"                                              &lt;&lt; endl
           &lt;&lt; "  rgb.bmp    is the name of the image with colors."  &lt;&lt; endl
           &lt;&lt; "  alpha.bmp  is a grayscale image representing the"  &lt;&lt; endl
           &lt;&lt; "             alpha channel. Black is fully"          &lt;&lt; endl
           &lt;&lt; "             transparent and white is fully opaque." &lt;&lt; endl
           &lt;&lt; "  result.bmp is the name of the file you wish to"    &lt;&lt; endl
           &lt;&lt; "             create (overwrites existing files)."    &lt;&lt; endl;
      return EXIT_FAILURE;
    int failure( const char *message ) {
      cout &lt;&lt; message &lt;&lt; endl;
      return EXIT_FAILURE;
    int main( int argc, char **argv ) {
      BMP rgb_file, alpha_file;
      if (argc &lt; 4) return usage();
      if (!rgb_file  .ReadFromFile( argv[ 1 ] ))
        return failure( "Could not read RGB color bitmap" );
      if (!alpha_file.ReadFromFile( argv[ 2 ] ))
        return failure( "Could not read alpha data bitmap" );
      if ((rgb_file.TellHeight() != alpha_file.TellHeight()) ||
          (rgb_file.TellWidth()  != alpha_file.TellWidth()))
        return failure( "The source bitmaps are not the same size!" );
      rgb_file.SetBitDepth( 32 );
      for (int y = 0; y &lt; rgb_file.TellHeight(); y++)
      for (int x = 0; x &lt; rgb_file.TellWidth();  x++)
        rgb_file( x, y )->Alpha = alpha_file( x, y )->Red;
      if (!rgb_file.WriteToFile( argv[ 3 ] ))
        return failure( "Failed to create or overwrite output file." );
      return EXIT_SUCCESS;
    // end bmp32.cpp
  Compile it with your favorite C++ compiler. I use the GCC:
    g++ -o bmp32 bmp32.cpp EasyBMP.cpp
import pygame
def load( filename ):
  Load a 32-bit BMP image file containing per-pixel-alpha.
  You will probably want to call convert_alpha() on the result.
  Returns the new surface, or None on error.
  def get_word( bytes ):
    result = 0
    is_neg = bool( ord( bytes[ -1 ] ) >> 7 )
    for shift, value in enumerate( bytes ):
      if is_neg:
        result -= (255 - ord( value )) &lt;&lt; (shift *8)
        result += ord( value ) &lt;&lt; (shift *8)
    if is_neg:
      return result -1
      return result
  # Initialize ...............................................................
    f = open( filename, 'rb' )
    data =
    # Assert: this is a Windows BMP
    if data[:2] != 'BM': raise Exception()
    pixel_data_offset  = get_word( data[ 10:14 ] )
    bitmap_info_header = data[ 14:(14+40) ]
    # Assert: this is a valid Windows BMP
    if get_word( bitmap_info_header[ :4 ] ) != 40: raise Exception()
    # Assert: image type is BI_RGB (not compressed) 
    if get_word( bitmap_info_header[ 16:20 ] ) != 0: raise Exception()
    width    = get_word( bitmap_info_header[  4:8  ] )
    height   = get_word( bitmap_info_header[  8:12 ] )
    bitcount = get_word( bitmap_info_header[ 14:16 ] )
    # Assert: bitmap has bitdepth of 32-bits per pixel 
    if bitcount != 32: raise Exception()
    is_inverted = (height &lt; 0)
    if is_inverted: height = -height
    # Load and store the image data ..........................................
    result = pygame.Surface( (width, height), pygame.SRCALPHA, 32 )
      for y in xrange( height ):
        if not is_inverted: y = height -y
        for x in xrange( width ):
            (x, y),
            (ord( data[ pixel_data_offset +2 ] ),  # Red
             ord( data[ pixel_data_offset +1 ] ),  # Green
             ord( data[ pixel_data_offset +0 ] ),  # Blue
             ord( data[ pixel_data_offset +3 ] ))  # Alpha
          pixel_data_offset += 4
    return None
  return result
# end

It looks like the wiki code is broken when dealing with C++ include directives. That last line with iostream and fstream doesn't belong there.

Alas, I also can't figure out how to get rid of & lt; in the code block. If you copy this file, you'll have to do a search and replace to change them back to the less-than and left-shift operators.



our projects welcomes all python game, art, music, sound, video and multimedia projects. If they use pygame or not.
recent releases
Jan 24, 2017

Jan 19, 2017

Jan 18, 2017

Jan 7, 2017

Dec 30, 2016

Dec 21, 2016

Dec 8, 2016

Nov 28, 2016

Nov 27, 2016

Nov 24, 2016

Nov 20, 2016

... more!
for pygame related questions, comments, and suggestions, please see help (lists, irc)