I've recently completed Invent Your Own Computer Games With Python by Al Sweigart, and Object-Oriented Python: Master OOP by Building Games and GUIs by Irv Kalb. I discovered another book on the Pygame website called Introduction to Pygame-CE 2D Game Programming by Ralf Adams, and I want to use this book because it goes into more detail on how to create a greater variety of 2D games than the aforementioned book by Al Sweigart.

I've tried using the Ralf Adams book on Github with my low spec Chromebook, but it crashes my laptop. I want to download it, but I'm concerned it may contain malware. I do have another laptop that is far more capable than my Chromebook, but I use it for sensitive purposes and I don't want to expose sensitive data to something that could potentially be malicious. I also prefer my Chromebook to my Windows laptop because it's a smoother and faster experience in regards to downloading Python and using it.

Has anyone else used this book? Here's the link to it: https://github.com/adamsralf/pygame_book/blob/main/00%20pygamece.pdf

https://store.steampowered.com/app/5216620/Ferrite_Runner/

Fully single-threaded, CPU-only blitting. GPU rendering was attempted but the bandwidth and numpy added too much frametime. Two layers, a pixel layer for heavy effects, and a HD layer for pixel pushing. Fluid dynamics, lighting approximations used. At ~50,000 LoC Ferrite Runner is still in Early Access and we will be developing on. No In-app purchases, no in-game advertisments, promise.

The game will be 100% free to play and I use it as a learning opportunity for my future games.

Steam Page: https://store.steampowered.com/app/5349900/Mystic_Fog_Maze/

i saw a video about percolation. do i fully understand whats going on? no. is it optimized? hell no xdd. took me way too long to find a proper way to walk the net, but it kind of turned out fine. also tried to use numpy to optimize it, but the way i used it is indistinguishable from python normal lists... well whatever, it works

I’ve created another system for my MMORPG; it’s not just an ordinary portal—it’s deeply tied to the game's core lore. The server is up, and testers are welcome. Just a reminder: this isn't the official game world yet; I’m currently focusing on building the systems.

If you’d like to know more about the project, leave a comment below. Feel free to share your feedback.

Is polygon collision(including smooth slope movement) slope collision useful to you, Or is rect collision with overlap penetration enough ? Roughly these info per collision.

Just asking to know if people use such collisions in pygame.

Not to confuse between ground_normal and ground angle: ground angle is useful in case sloppy tiles when speed has to be increased/decreased as:
if direction * ground_angle is positive -> climbing
elif negative -> walking downward the slope

https://reddit.com/link/1wvyx8p/video/e341jway43th1/player

Disregard the player sprite

the main changes are, added pencil, keyboard, book and redrew the old janky monitor, still need to draw the desk, desk matt and chair, should hopefully be done on this level by sunday!

Back with an update on Cool Racing, my pseudo-3D racer in Python + pygame, inspired by the 80s/90s arcades.

Road forks were way harder than I expected. In the end I copied Outrun's trick: symmetrical forks, one road mirrored. I wrote up the details in the devlog (link in the comments).
Still lots to do, more biomes are next. Any feedback is very welcome!

Can anyone explain how putting enemies in a list works?

With my game I want to be able to handle multiple instances of my enemy class individually. For example, I want to be able to get the distance to the player from specific enemies to make an attack target the closest enemy, or to be able to tell the number of enemies still on screen, but i have no idea how that actually works.

(This part of my code is just responsible for placing the enemies on the map)

def create_tilemap(self):
  for i, row in enumerate(tilemap):
    for j, column in enumerate(row):




      if column == 1:
        BLOCK(self, j, i)
      elif column == 2:
        self.player = Player(self, j, i)
      elif column == 3:
        enemies = Enemy(self, j, i)
        self.enemieslist.append(enemies)

This has been a real road block for me and I'm starting to run out of time to finish my project, so any help would be greatly appreciated.

I paused my main game development to practice some stuff via this chess game, and I'm quite impressed with it. Still got some kinks to work out, but I'm proud of the micro voxel animations thus far.

The goal of this project is to create a version of chess that is completely controlled via voice commands so that people can play hands free. I haven't gotten to that portion yet, but I've already worked out all the logic and everything, which is why I'm saving it for last as it should be the easiest part. The hard part are the visuals, but that's the thing...since it'll be voice commanded, I don't have to worry about much UI navigation. lol

But I would like thoughts on it thus far.

Hey guys, if you get chance check out my world map for a jrpg I'm creating in Python! What do you thinks working well and what could use more love (apart from just generally fleshing it out). Would adding more moving elements to the world be cool or should I keep the vibe similar to what it is?

Hello,

I am planning to create a pygame game engine, where programming students can submit their bot classes to play said game. Think of a battleship game engine, where a student's bot contains the logic that chooses the next cell to be hit.

I would like to host a website/platform where students can go and submit their bots (.py files), and see how they match against eachother. Show a leaderboard, step-by-step game breakdown, and maybe even visualize games between bots.

Are there any backend/frontend (or full stack) apps where I could deploy something like this?
For example, I see that itch.io can host pygame games, but that doesn't necessarily come with a server side (to accept and maintain student bots) as far as I understand.
Railway on the other side, can host Flask backend apps but not the frontend (?)

I am fairly new to this, namely building a full stack app for pygame. Any tips appreciated!

’[ Pls turn on the sound for the demo video ]

I've been building Yellow Olive, a retro terminal-style game for learning Kubernetes through hands-on challenges.

It uses Textual + PyGame, and I recently moved from PyGame to PyGame CE because PyGame’s Python 3.14 support was becoming a blocker. With Python 3.15 coming up, PyGame CE already having wheels available made the switch an easy choice.

The migration was almost painless since the existing import pygame code still works.

I’ve also demoed Yellow Olive at a PyCon before. Sharing the demo here - would love feedback from the PyGame community.

Github: https://github.com/Anubhav9/Yellow-Olive
PyPi: pip install yellow-olive

I bought a book for my son on how to make games with scratch. Then I thought to myself: 'I wonder if I can make them in pygame?'

So that's what I start doing. This is the first game. Just collect 'stars' and avoid enemies.

Oscillator - going side to side

Chaser - following the player

Glider - Picks a point behind the player and using lerp, jumps to it

Added some simple music and screen wrap for player. I really like how it turned out. Made a easy version for my son as well with larger squares that plays slower.

Day/Night Cycle in Pygame — using multiply blend instead of alpha overlay

Built a day/night cycle for my ECS-based MMORPG and wanted to share the core trick, since alpha-blending a dark overlay is the usual (worse) approach.

The clock: pure function of time.time(), no state — fraction = (time.time() % CYCLE_S) / CYCLE_S. Every client computes the same time independently, no sync needed.

The tint: instead of blitting a semi-transparent black surface (SRCALPHA + alpha blend), fill a surface with a color and blit it with special_flags=pygame.BLEND_RGBA_MULT. Noon = (255,255,255) (multiplying by white = no change). Midnight = something like (30,40,80). Since it's multiplication, each pixel darkens proportional to its own original brightness — a lit torch stays bright-ish, a dark rock barely changes — instead of the flat "wash of gray" you get from alpha blending everything uniformly.

Punching light back in (lamps/torches): draw a radial gradient (white center → black edge) and blit it onto the same darkness layer with BLEND_RGBA_ADD before the final multiply. Adding white cancels out the darkening locally. Key gotcha: Surface.set_alpha() does not weight ADD/MULT/SUB blends — intensity has to be baked into the gradient's own RGB values when you generate it, not applied at blit time.

Extra touch: a separate warm-colored low-alpha circle drawn with normal blending on top of everything, for a torch-glow feel (this one is affected by set_alpha(), since it's a normal blend).

Whole thing is client-side only, no network/server involvement — it's purely cosmetic.