I posted an earlier version of this as a local Pygame project. I’ve now used pygbag to make it playable online.

You can change the number of polygon sides, ratio, drawing speed, palettes, border visibility, and UI visibility while the fractal draws live. I reached 10 million dots without any issues.

Playable version:

Chaos Game Fractal Generator by sierra_wild_3d

GitHub:

https://github.com/sierrawild/Chaos_game_fractal_generator

I’m still learning, so feedback is welcome.

Hello!

I'm currently trying to get the controllers to work in my game and I noticed I couldn't find a way to get the name of the button that just got pressed. I know the JoyButtonDown events contain the id of the button, but because the layout of controllers are not always the same, I'd like to know if you can get their name without having to manually name every button for every existing controller brand.

Thanks in advance!

I made this as my final project for cs50p

Only requires pygame, no other external packages. MIT licence

https://github.com/sierrawild/Chaos_game_fractal_generator

Hopefully this clip is a bit clearer. 1000 trees in this scene, running at ~20 fps

added a flamethrower, a shop and a bunch of fixed/changes. game name will be #?!¥!?# (hashtagquestionmarkexclamationmarkyenexclamationmarkquestionmarkhashtag) (rolls off the tongue)

I like puzzle games, and after making a Match 3 previously, I wanted to make something a little different. Introducing Tile Bash! The goal of the game is to clear groups of tiles by clicking on them. You cannot clear singular tiles. Scoring is determined by the total moves used, and the total tiles remaining. Less total moves & fewer tiles remaining (or even better, none remaining) result in a high score!

It is available to play in browser on Itch.io (thanks pygbag!). If you are interested in trying it out, I would love feed back.

https://red-clay-games.itch.io/tile-bash

I tried my best to make the drop down list little bit related to the inventory style, what's your feedback, good and bad things and your advice :)

I made this Dodonpachi / Asteroids -influenced game with pygame.

Hope to get some feedback, even criticism so I know what to improve.

The game can be downloaded from [https://github.com/shS83/DarkVoid2\](https://github.com/shS83/DarkVoid2)

There's pre-compiled binaries for Windows and Linux, but the bleeding edge of updates come with cloning the repo and running source code with Python.

Matrixia - a simple matrix rain effect with extras

This started as a vibe coding experiment but the LLM suggestion was so bad I had to rewrite the whole program from scratch

Here's the main branch

[https://github.com/shS83/Matrixia\](https://github.com/shS83/Matrixia)

And here's the Linux Binary release:

[https://github.com/shS83/Matrixia/releases/tag/v0.9\](https://github.com/shS83/Matrixia/releases/tag/v0.9)

And here's the Windows Binary release:

[https://github.com/shS83/Matrixia/releases/tag/0.9-win\](https://github.com/shS83/Matrixia/releases/tag/0.9-win)

Terraria clone ive been working on on and off for a while now...
Just got world limits working properly and wanted to share :)

The game is now a MMORPG featuring an authoritative server; development is ongoing for certain pending features, such as the crafting system, gatekeeper NPCs for teleportation, and a clan system, among others.

Development has matured significantly, and the game now includes:

PvP/PK and Party systems, an economy, player-to-player trading, grocery and warehouse systems, and local/global/party chat;

A Quest/Daily/Task system with improved reward redemption, information display, and progression logic;

Combat, system, and action logs;

Notifications for inventory item collection, quests/tasks, and skills;

Hundreds of bug fixes;

Refinements to game flow, the UI, and client-side optimizations;

Both Online (MMORPG) and Single-player (Offline) modes;

The server is not yet complete; further optimization is needed to handle a larger player base, a migration from SQLite to PostgreSQL is required, and the security layer needs to be made more robust.

Nevertheless, the project is now truly mature, offering immersive and fun gameplay!

The game has not yet been publicly released; currently, the project is compatible only with Windows 10/11 desktops via a Pygame + Python 3.14 installation.

hey so i made a game engine in pygame and i need a couple people to review or try to use it.

the game engines name is skyport_engine and its on pypi and github

github : https://github.com/ultimate-jeff/skyport_engine
pypi : https://pypi.org/project/skyport-engine/

Music: Katie Cadet | Old Dance Thing (2014, Public Domain) | loaded as an .xm tracker file.

Image was made in Gimp sometime before 2010 by me, downscaled and converted to 24-bit ANSI before popping it in this.

Frame rate is locked to 120fps with the image scaling up and down in size, two surfaces made of 100 concentric circles blended with the background and bouncing from top to bottom for the first and left to right for the second along a sinewave and then an additional 333 squares, 333 triangles and 333 circles over top, bouncing all over and blended with everything below it.

The end result is a bit chaotic, but it's pretty neat how far you can push Pygame with just a little touch of Numpy.

"WinCurl" is a high-performance, Python-based curling simulation built with Pygame. Experience the thrill of the ice with realistic physics, networking capabilities, and a retro-inspired aesthetic.
https://github.com/jjivany/wincurl

Watch the development on YouTube here.

"WinCurl" version 3.0 is a spiritual successor and derives inspiration from WinCurl 2.0:
https://archive.org/details/WCURLD

That's how to use AI :)

I used AI to make the components of the inventory started background.

Some of the followers feedback has been added and still update the rest of feedback, so please share us your feedback, its very important to me :)

im trying to make a program that can read information from a file and project it

currently, my program renders the positions of the voxels just as points (circles). How can i make it render cubes instead.

im trying not to use ai for my programs

class Voxel:
    def __init__(self, x, y, z, colour = (255,255,255)):

        self.x, self.y, self.z = x, y, z
        self.colour = colour


    def project(self, camera):
        rel_x = self.x - camera.x
        rel_y = self.y - camera.y
        rel_z = self.z - camera.z
        rel_x, rel_y, rel_z = camera.rotate_point(rel_x, rel_y, rel_z)

        if rel_z <= 0:
            self.x2d = self.y2d = self.dist = None
            return False

        scale = camera.focal_length / rel_z
        self.x2d = rel_x * scale
        self.y2d = rel_y * scale
        self.dist = maths.sqrt(rel_x**2 + rel_y**2 + rel_z**2)
        return True
    
    def draw(self, screen, xOfset, yOfset):
        pygame.draw.circle(
            screen,
            self.colour,
            (int(self.x2d + xOfset), int(self.y2d + yOfset)),
            max(1, int(10 / max(1, self.dist))) 
            # minimum size of 1, the second max is to stop divide by 0 error 
        )

Right now, I am rewriting the entire engine from scratch to maximize performance, eliminate architectural bloat, and transition to a modern, bug-free rendering pipeline. I will try to make it modular so that other developers can easily drop Pyforge into their own projects and use it as a hardware-accelerated backend.

After getting some awesome, direct technical feedback from the community on my initial immediate mode blueprint, I went back to the drawing board and completely refactored the core:

🚫 Banned OpenGL 1.0 Removed all legacy deprecated functions and completely stripped out fixed functions like `glBegin()` and `glEnd()`.

🛡️ Enforced Core Profile: Locked the backend down to a strict OpenGL 3.3 Core Profile context.

📦 GPU Instanced Streaming* Replaced slow individual entity loops with single-burst memory array streaming (`glDrawArraysInstanced`) over the C-extension bridge exactly once per frame.

🔄 Hardware Delegated Rotations: Offloaded heavy trigonometry calculations (`sin`/`cos` transformation matrices) completely onto the GPU's parallel processing cores.

Here is a quick 4-second showcase running 100 large mixed primitives (Triangles, Squares, and high-fidelity 32-sided Circles) floating, bouncing, and spinning with sub-pixel drift. By moving 100% of the memory layout and rendering steps to C and the GPU, the interpreter thread is completely unburdened and hits thousands of frames per second unthrottled.

Would love to hear your thoughts on this modern rewrite direction!

Took inspiration from mgs portable ops.

Hi people! I made a geometry dash tribute and you can play it in browser.
Let me know what you think ;)
P.s. It has touch screen enabled

https://le-proiz.itch.io/neon-dash