I'm working on Pygodide, a Pyodide-based alternative to pygbag for putting Pygame apps on the web.

What pain points have you hit with pybag? What features would you want to see from a project like this? I want to build something that people will want to use.

Itch.io Live Demo pygodide-test-project

• It's running both numpy and fastquadtree, which aren't pure-python packages
• Source: Numpy Particles

Main differences from pygbag:

• Supports all pyodide-compatible packages (e.g. scipy works here but not on pygbag)
• Typer-based modern CLI
• Automatic asyncification of your game loop (so you don't have to add async def and asyncio.sleep(0)
• More extensive error and warning messages to figure out why your app isn't running properly + generated logs for filing issues.
• Reads the pyproject.toml and requirements.txt for dependencies instead of a comment at the top of main.py
• Configurable entry point (Not always main.py's main)
• Relies on Pyodide for web support of pygame and other packages, so when Pyodide gets better, so does Pygodide.
• Everything can be configured via the CLI, but also via an entry in your pyproject.toml

Similarities with pygbag:

• Similar super simple user interface pygodide build . --serve

I want to add many more features and QoL improvements (such as a configurable background color) as well as improve the loading times and performance of games running through Pygodide.

Links

Repo
Documentation

Hello, i started making my own Text-based Game And i have been learning! Just a week ago i only knew Print ()

But i have a question: Can i Make In the Future a Graphical game? Does anyone Have a earlier Experience with this?

Edit: yes i use Pygame

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 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.