Wololo.net

Homebrew Release: Warnel Chawpiovs v1.4.0 (PC, Nintendo Switch, Android), adds Android Support, 7 new heroes, and 5 new scenarios

by · June 16, 2026

Tags:

wololo

Finger on the pulse of the PlayStation hacking scene since 2006

2 Responses

  1. lollypop says:
    June 22, 2026 at 4:44 pm

    do u have a warnell pygame version with sdl ? heres how on android …
    so tudum … have termux and termux-x11 in one app together with proot-distro and python installed with pygame for runnning a backend python webserver that interacts with pygame frontend AIO ALL IN ONE APP ???? …. i like to think of this little pygame ofc …
    You can absolutely build an all‑in‑one Termux + Termux‑X11 + proot‑distro + Python + Pygame environment inside a single Android app — and it’s actually a pretty elegant setup once everything is wired together.

    Short answer:
    Yes, your idea is doable. Termux + Termux‑X11 can run a full Linux distro (via proot‑distro), and inside that you can run Python, Pygame, and even a backend webserver that talks to a Pygame frontend. It becomes a tiny portable Linux workstation inside one Android app.

    How the pieces fit together
    1. Termux
    Your base shell. This is where you install packages, run Python, and launch proot‑distro.

    2. Termux‑X11
    Provides an X11 display server so Pygame can open windows.
    Pygame uses SDL → SDL needs a display → Termux‑X11 gives you that.

    3. proot‑distro
    This gives you a full Linux root filesystem (Ubuntu, Debian, Arch, etc.) without root access.
    Inside it, you can install “real” Linux packages, including Pygame, Flask, FastAPI, etc.

    4. Python
    Installed either in Termux or inside the proot distro.
    Pygame works best inside the proot distro because of X11 compatibility.

    5. Pygame
    Runs your graphical frontend.
    With Termux‑X11, Pygame windows behave like desktop apps.

    6. Backend Python Webserver
    You can run a backend using:

    Flask

    FastAPI

    aiohttp

    or even a custom socket server

    Your Pygame frontend can talk to it via HTTP or WebSockets.

    ️ Architecture of your “AIO APP”
    Code
    Android App (Termux)
    ├── Termux shell
    │ ├── proot-distro (Ubuntu/Debian)
    │ │ ├── Python
    │ │ ├── Pygame (frontend)
    │ │ └── Backend webserver (Flask/FastAPI)
    │ └── Termux-X11 (display server)
    └── Android system
    Everything runs inside one Termux installation.
    Termux‑X11 is technically a separate APK, but it behaves like a plugin.

    Why this setup works surprisingly well
    Pygame uses SDL2 → SDL2 works with X11 → Termux‑X11 provides X11

    proot‑distro gives you a clean Linux environment

    Python packages install normally

    You can run both backend and frontend simultaneously

    Android multitasking keeps everything alive

    It’s basically a pocket Linux gaming + dev environment.

    A non‑obvious insight
    Pygame doesn’t have to be the frontend.
    You can also run:

    Godot 3.x (headless or editor)

    Tkinter

    PyQt5 / PySide2

    Kivy

    All inside Termux‑X11.

    But Pygame is the lightest and most stable.

    ️ If you want, I can help you next with:
    Setting up Pygame inside proot‑distro

    Creating a backend–frontend communication template

    Optimizing performance

    Packaging your whole setup into a single launch script

    Which direction do you want to go:
    setup pygame • build backend • connect pygame to backend • optimize performance

    help you next with:
    Setting up Pygame inside proot‑distro

    Creating a backend–frontend communication template

    Optimizing performance

    Packaging your whole setup into a single launch script
    Great — you want the full pipeline:
    Pygame setup → backend/frontend template → performance tuning → one‑tap launch script.
    Let’s build it cleanly and in the right order so everything works smoothly inside Termux + Termux‑X11 + proot‑distro.

    Below is the complete, structured guide with all four parts.

    ✅ 1. Setting up Pygame inside proot‑distro
    This is the most stable layout:

    Code
    Termux
    ├── proot-distro (Ubuntu or Debian)
    │ ├── Python3 + pip
    │ ├── SDL2 + dev libs
    │ └── Pygame
    └── Termux-X11 (display)
    Install Ubuntu (recommended)
    Code
    pkg install proot-distro
    proot-distro install ubuntu
    proot-distro login ubuntu
    Install dependencies inside Ubuntu
    Code
    apt update
    apt install python3 python3-pip python3-dev \
    libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev \
    libportmidi-dev libfreetype6-dev
    Install Pygame
    Code
    pip install pygame
    Test Pygame
    Create test.py:

    python
    import pygame
    pygame.init()
    screen = pygame.display.set_mode((400, 300))
    pygame.display.set_caption(“Pygame OK”)
    while True:
    for e in pygame.event.get():
    if e.type == pygame.QUIT:
    quit()
    screen.fill((30, 30, 30))
    pygame.display.flip()
    Run it:

    Code
    DISPLAY=:0 python3 test.py
    ✅ 2. Backend ↔ Frontend communication template
    This is a minimal working architecture:

    Backend (Flask)
    backend.py:

    python
    from flask import Flask, request, jsonify

    app = Flask(__name__)

    @app.route(“/state”, methods=[“GET”])
    def get_state():
    return jsonify({“message”: “Hello from backend”, “value”: 42})

    @app.route(“/input”, methods=[“POST”])
    def receive_input():
    data = request.json
    print(“Frontend sent:”, data)
    return jsonify({“status”: “ok”})

    app.run(host=”0.0.0.0″, port=5000)
    Run it:

    Code
    python3 backend.py
    Pygame frontend talking to backend
    frontend.py:

    python
    import pygame, requests, json

    pygame.init()
    screen = pygame.display.set_mode((600, 400))
    font = pygame.font.SysFont(None, 32)

    def get_state():
    try:
    r = requests.get(“http://127.0.0.1:5000/state”)
    return r.json()
    except:
    return {“message”: “No backend”, “value”: 0}

    while True:
    for e in pygame.event.get():
    if e.type == pygame.QUIT:
    quit()

    state = get_state()
    screen.fill((0, 0, 0))

    text = font.render(f”{state[‘message’]} | {state[‘value’]}”, True, (255,255,255))
    screen.blit(text, (20, 20))

    pygame.display.flip()
    This gives you a live, interactive Pygame UI that polls the backend.

    ✅ 3. Optimizing performance inside Termux + proot‑distro
    Key optimizations
    Use SDL2 (already installed above) — Pygame 2 uses it automatically.

    Disable vsync if you need faster loops:

    python
    pygame.display.set_mode((800,600), pygame.SCALED | pygame.DOUBLEBUF)
    Use integer scaling to reduce GPU load:

    python
    pygame.display.set_mode((800,600), pygame.SCALED)
    Avoid heavy Python loops — use pygame.time.Clock():

    python
    clock = pygame.time.Clock()
    clock.tick(60)
    Run backend and frontend in separate Termux sessions
    Termux supports multiple sessions; this avoids blocking.

    Use lightweight backend frameworks
    Flask is fine, but aiohttp or FastAPI with uvicorn is faster.

    ✅ 4. Packaging everything into a single launch script
    This gives you a one‑tap startup for:

    Termux‑X11

    proot‑distro

    backend

    frontend

    Create run_all.sh in Termux (outside proot)
    Code
    nano run_all.sh
    Paste:

    bash
    #!/data/data/com.termux/files/usr/bin/bash

    # Start Termux-X11 if not running
    am start –user 0 -n com.termux.x11/com.termux.x11.MainActivity

    # Wait for X11 to initialize
    sleep 2

    # Launch proot-distro and run backend + frontend
    proot-distro login ubuntu –shared-tmp — bash -c ”
    export DISPLAY=:0
    cd ~/myapp

    # Start backend in background
    python3 backend.py &

    # Start frontend
    python3 frontend.py
    ”
    Make executable:

    Code
    chmod +x run_all.sh
    Run:

    Code
    ./run_all.sh
    Now you have a full AIO app launcher.

    What do you want to build next?
    Choose your next step:

    add websocket support

    add buttons and UI widgets

    package the whole thing into a single folder

    add sound, music, or assets

    Tell me where you want to take this little Pygame universe next.

    Reply
  2. lollypop says:
    June 22, 2026 at 9:55 pm

    https://nopaste.net/Jx9xEvRb9j
    here u go for the minimal pygame launcher assets project …

    Reply

Leave a Reply

Your email address will not be published. Required fields are marked *

Most comments are automatically approved, but in some cases, it might take up to 24h for your comments to show up on the site, if they need manual moderation. Thanks for your understanding

Follolow:

Featured

Popular Downloads

Archives