Blit Pygame Tutorial – Complete Guide

Understanding the many aspects of Pygame, can seem like an intimidating task for a beginner. However, there is one element that every game needs – the blit. It’s a key aspect of Pygame and interestingly enough, it’s also fundamental to many different aspects of game development.

What Is Blit in Pygame?

In Pygame, blit is a method used to draw one image onto another. It is often used in the process of rendering graphics to a surface, making it crucial for the display of any images, text or animation in a Pygame window.

Why Should You Learn About Blit?

Learning about blit and mastering how it works can significantly enhance your game development capabilities in Pygame. It gives you the ability to:

  • Create engaging visual elements.
  • Develop sophisticated animations.
  • Fully control the appearance of your game environment.

By understanding how to use the blit method effectively, you open up a whole new world of possibilities for your game creation.

What is it used for?

Blit is used surprisingly often in game development. Every time you see something moving on your Pygame surface, or you view different scenes one after another, blit is doing its job. It’s the reason why you can see any visual elements at all on your Pygame window. It’s the magic behind the player character moving across the screen, the villain running to catch him, and the breathtaking backdrop of your game.

For those interested in being able to create such visual wonders, understanding blit is a must. Let’s break down how you can use blit in Pygame and make your games come to life.

CTA Small Image

The Basics of Blit

Drawing with blit in Pygame is simple, yet there are a few key points to remember.

Firstly, to harness the power of blit, you need to import Pygame and create a game window. You will set the window size and add a title:

import pygame


window = pygame.display.set_mode((800, 600))

pygame.display.set_caption('My First Blit')

Once you initialize the Pygame module and create the game window, you need to load your image that you want to draw.

player_image = pygame.image.load('player.png')

Remember to replace the ‘player.png’ with the path to the actual image that you are going to use in your game.

Using Blit

Finally, we’ll use the blit() function to draw the image onto our window. This method takes two arguments, the source surface and a tuple for the desired position. For instance, if we want to draw our image 10 pixels from the top left of the window:

window.blit(player_image, (10, 10))

And don’t forget to include pygame.display.flip() at the end to update the entire Surface:


Moving the Image

One of the most common uses for blit in Pygame is moving images around the screen.

x_position = 0

for _ in range(100):
    window.fill((0,0,0)) # Clear the previous drawings
    window.blit(player_image, (x_position, 10)) 
    x_position += 5

In the above example, every frame, we clear the window with a black color using window.fill(), move the image 5 pixels to the right by increasing x_position, and then draw it again at its new location.

Animating a Sprite with Blit

Blit is also incredibly useful when it comes to animating sprites. Suppose you have a sprite sheet where each frame of animation is 64 x 64 pixels. You could animate it with the help of blit as follows:

sprite_sheet = pygame.image.load('sprite_sheet.png')

frame_number = 0
x_position, y_position = 0, 0

for _ in range(100):
    window.fill((0, 0, 0))  # Clear the previous drawings
    window.blit(sprite_sheet, (x_position, y_position), (frame_number*64, 0, 64, 64)) 
    frame_number += 1
    if frame_number == 10: # if we reached the last frame
        frame_number = 0 # go back to the first one

The third argument to blit in this case is a pygame.Rect (or a simple tuple) representing a portion of the source Surface to draw.

Text Rendering with Blit

The power of blit extends beyond just images – it’s also the key to rendering text in Pygame. Here’s how you can render a piece of text onto the screen:

font = pygame.font.Font(None, 36)
text = font.render("Hello, Pygame!", True, (255, 255, 255))

window.fill((0, 0, 0))  # Clear the screen
window.blit(text, (100, 100))  # Render the text

The font.render() method returns a new Surface with the specified text rendered on it. The True parameter specifies whether to use antialiased text (for smoother edges).

Layering with Blit

Blit can also be used for creating layers. Suppose we have a background image and several sprite images that we want to display in different layers.

background = pygame.image.load('background.png')
sprite1 = pygame.image.load('sprite1.png')
sprite2 = pygame.image.load('sprite2.png')

window.blit(background, (0, 0))
window.blit(sprite1, (100, 100))
window.blit(sprite2, (200, 200))


In the above code, the background is drawn first, followed by sprite1 and sprite2. As a result, sprite1 and sprite2 are displayed on top of the background layer.

With blit as your implantation tool for game visualization, you’re now well equipped to produce versatile and interactive Pygame projects. Take this knowledge and let your creative side run wild!

Blitting with Transparency

Another crucial aspect of game development is the effective use of transparent and semi-transparent images. The blit method provides a simple way to draw images with transparency on top of your surfaces. Suppose you have a semi-transparent overlay image (i.e., a ‘light’ effect) that you want to draw on top of your existing surface.

overlay = pygame.image.load('overlay.png').convert_alpha()

window.blit(overlay, (0, 0))


In the example above, the convert_alpha() function is used on a surface to provide per pixel alpha transparency.

Running the Game Loop

In a real Pygame application, you can’t just run blit once. You have to consistently update the screen inside a game loop.

Here’s an example of a Pygame game loop where we continuously draw a moving image:

running = True
x_position = 0

while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    window.fill((0, 0, 0))  # Clear the screen
    window.blit(player_image, (x_position, 10))
    x_position += 5

Scaling Surfaces

You can use the pygame.transform.scale() function to scale your surfaces to any size you like. This is handy when you want to resize assets dynamically. Here’s how you would create a scaled surface and then blit it onto the screen:

image = pygame.image.load('image.png')
scaled_image = pygame.transform.scale(image, (800, 600))

window.blit(scaled_image, (0, 0))


Rotating Surfaces

Last but not least, pygame.transform.rotate() allows you to rotate your surfaces before using blit. This is paramount when creating games where objects need to be rotated, like a spaceship that adjusts its angle based on user input:

image = pygame.image.load('ship.png')
rotated_image = pygame.transform.rotate(image, 45)



In the example above, we’ve rotated the image by 45 degrees. This only affects the instance of the image being rendered and doesn’t permanently adjust the original image. This flexibility provided by the blit function allows us to truly create a dynamic and versatile gaming experience.

Where To Go Next?

You’re on your way to becoming proficient in the nuances of game development with Pygame, but your journey doesn’t have to stop here. To continue fostering your growth and learning, consider taking up Zenva’s comprehensive Python Mini-Degree. This collection of courses is designed to help students learn Python programming from the ground up with topics including coding basics, algorithms, object-oriented programming, and app development. The content is flexible, accessible 24/7, and encourages students to showcase their Python projects in a portfolio-building component.

At Zenva, we strive to equip learners with practical skills through interactive courses. We host a community of over 1 million learners and developers who have used their skills to launch successful careers, develop games, and found startups. Our curriculum is regularly updated to stay up to date with the industry’s best practices and is taught by experienced instructors certified by globally recognized institutions like Unity Technologies and CompTIA.

If you’re interested in sinking your teeth into more Python learning material, don’t forget to check out our wide array of Python courses. Whether you’re a beginner or a professional looking to expand their skill-set, we have the Python course for you. Your journey to mastering Pygame and Python has only just begun, and we’re here to support you every step of the way.


Developing a firm understanding of blit and implementing it effectively could turn a simple game into a visually compelling experience. By gaining proficiency in Pygame and mastering blit, you’re honing a skillset that could be fundamental to your journey in game creation as well as numerous professional paths in programming.

At Zenva, we’re thrilled to accompany you on this exciting learning path. Our online courses, such as the Python Mini-Degree, are designed to provide you with the comprehensive knowledge and real-world skills you need to excel in the technology field. Together, let’s harness the power of Pygame and bring digits to life on the screen. The game world is your oyster!

Did you come across any errors in this tutorial? Please let us know by completing this form and we’ll look into it!

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.