Creating a game in Python for Android: from idea to publication on Google Play

3. Setting up the environment. development

Before writing code, you need to prepare a minimum set of tools:

• 💻 Python 3.9+ (for Pygame/Kivy) or Godot/Ren'Py (do not require a separate installation of Python).
• 📱 Android SDK and Java JDK 17 (for building APK).
• 🛠️ Buildozer (for Kivy/Pygame) or built-in tools (Godot/Ren'Py).
• 🎨 Code editor: VS Code, PyCharm or Godot Editor.

If you selected Godot or Ren'Py, download them from the official websites:

- Godot: https://godotengine.org/download

- Ren'Py: https://www.renpy.org/download.html

Both engines include everything necessary for development and export.

For Kivy or Pygame more will be required steps:

1. Install Python and add it to PATH.
2. Install the framework via pip:

   pip install kivy[full] # For Kivy
   pip install pygame # For Pygame

3. Install buildozer to build the APK:

   pip install buildozer
   buildozer init # Creates a configuration template

4. Configure buildozer.spec (specify the game name, Android SDK version, permissions).

⚠️ Attention: When working with buildozer on Windows, errors may occur due to paths with spaces (for example, C:\app Files\...). The solution is to install the Android SDK in a folder without spaces, for example C:\AndroidSDK\.

4. Kivy

Let's consider the process using the example of a simple arcade game, where the player controls a square, avoiding falling objects. This example is universal and can be adapted to any of the listed frameworks.

Project structure:

my_game/
├── main.py # Main game code
├── buildozer.spec # Configuration for building
└── assets/ # Resources (images, sounds)

Code for main.py (Kivy):

from kivy.app import App
from kivy.uix.widget import Widget
from kivy.properties import NumericProperty, ReferenceListProperty
from kivy.clock import Clock
from kivy.core.window import Window
from random import randint

class Player(Widget):
velocity = NumericProperty(0)

def move(self):
self.y += self.velocity

class Obstacle(Widget):
pass

class Game(Widget):
player = ReferenceListProperty()
obstacles = ReferenceListProperty()

def __init__(self, **kwargs):
super(Game, self).__init__(**kwargs)
self._keyboard = Window.request_keyboard(self._keyboard_closed, self)
self._keyboard.bind(on_key_down=self._on_keyboard_down)
Clock.schedule_interval(self.update, 1.0/60.0)
Clock.schedule_interval(self.spawn_obstacle, 1.5)

def _keyboard_closed(self):
self._keyboard.unbind(on_key_down=self._on_keyboard_down)
self._keyboard = None

def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
if keycode[1] == 'left':
self.player.velocity = -10
elif keycode[1] == 'right':
self.player.velocity = 10
return True

def update(self, dt):
self.player.move()
for obstacle in self.obstacles:
obstacle.y -= 5
if obstacle.y < 0:
self.obstacles.remove(obstacle)
self.remove_widget(obstacle)

def spawn_obstacle(self, dt):
x = randint(0, self.width - 50)
obstacle = Obstacle(pos=(x, self.height), size=(50, 50))
self.add_widget(obstacle)
self.obstacles.append(obstacle)

class MyGameApp(App):
def build(self):
game = Game()
game.player = Player(pos=(100, 100), size=(50, 50))
game.add_widget(game.player)
return game

if __name__ == '__main__':
MyGameApp().run()

This code creates:

• 🟦 Playing field with key controls ← i →.
• 🟥 Falling obstacles (red squares) that appear every 1.5 seconds.
• 🔄 An update cycle that moves objects 60 times per second.

Install Android SDK and NDK|Set up environment variables (ANDROID_HOME, JAVA_HOME)|Check paths in buildozer.spec (package.name, title)|Add game icon (512x512 px)|Test on an emulator before building-->

To run the game on PC, do:

python main.py

To build an APK:

buildozer -v android debug

⚠️ Attention: The first APK build can take up to 30 minutes - buildozer downloads all dependencies (including Android NDK size ~1 GB). Use the flag -v for detailed logging and error debugging.

5. Optimizing the game for mobile devices

Python games often suffer from High memory consumption on weak devices. The following tricks will help improve performance: Low FPS on weak devices. The following techniques will help improve your performance:

• 🗑️ Memory management:
  • Delete unnecessary objects using del or gc.collect().
  • Avoid global variables - they are not freed by the garbage collector.
• 🎨 Optimizing graphics:
  • Use sprites with a resolution no higher 1024x1024.
  • Turn off anti-aliasing (antialiasing) if it is not critical.
  • For animations, use texture atlases (one large file instead of many small ones).
• ⚡ Code acceleration:
  • Move heavy calculations to Cython or Numba.
  • Replace loops for with vectorized operations (NumPy).

Example of graphics optimization in Kivy:

# Instead of:
with self.canvas:
Color(1, 0, 0)
Rectangle(pos=(x, y), size=(50, 50))

Use Batch rendering:
from kivy.graphics.instructions import InstructionGroup

self.rect = InstructionGroup()
self.rect.add(Color(1, 0, 0))
self.rect.add(Rectangle(pos=(x, y), size=(50, 50)))
self.canvas.add(self.rect)

For Godot key optimization settings are in Project Settings → Rendering:

- Disable VSync for FPS testing.

- Install Texture Compression → Basis Universal (reduces texture size by 50-70%).

- Use Visibility Notifier for disabling objects outside the screen.

6. Testing and debugging on an Android device

Testing on a real device is a mandatory step. Emulators (for example Android Studio Emulator) do not always accurately reproduce performance and bugs.

Connect your phone via USB and enable developer mode:

1. Go to Settings → About phone → Build number and tap 7 times.

2. Go back to Settings → System → For Developers and enable USB Debugging.

3. Connect the device to the PC and confirm permission to debug.

To launch the game from Godot or Ren'Py:

1. In the editor, select Export → Android.

2. Connect the device and click Run (the engine will automatically install the APK).

For Kivy/Pygame use adb:

adb install bin/MyGame-debug.apk
adb logcat | grep python # View logs

Typical problems and solutions:

7. Publishing a game on Google Play

To publish a game on Google Play, follow these steps:

1. Create a developer account:

   - Go to https://play.google.com/console.

   - Pay a one-time registration fee ($25).

   - Fill out your profile (name, email, address).

2. Prepare materials:

   - Game icon (512×512 px, PNG format).

   - Screenshots (1080×1920 px for portrait mode).

   - Banner (1024×500 px).

   - Description (in Russian and English, up to 4000 characters).

   - Video preview (optional, but increases conversion).

3. Collect the release APK:

   - For Godot/Ren'Py: export with settings Release and signature.

   - For Kivy: use buildozer android release.

4. Download the game to the console:

   - Create a new application.

   - Fill out the card: name, category (for example, "Arcade"), age rating.

   - Upload the APK/AAB file to the section Production.

5. Set up pricing:

   - Free game: check Free.

   - Paid: specify the price and countries of distribution.

6. Publish:

   - Click Submit for Review.

   - Expect moderation (usually 1-3 days).

⚠️ Attention: Google Play requires all APKs to be signed release key. Don't lose the file keystore —without it you won't be able to update the game! Store it in a safe place (for example, in an encrypted archive).

After publication, follow reviews and analytics in Google Play Console:

- Statistics → User Acquisition: where installations come from.

- Android Vitals: crashes, ANR (freezes), battery consumption.

- Reviews: respond to reviews - this increases the rating.

8. Alternative distribution methods

Google Play is not the only way to distribute the game. Consider alternatives:

• 🌍 Self distribution:

  - Upload APK to your website or cloud storage (for example, Dropbox, Google Drive).

  - Advantage: no commission (30% on Google Play), full control over updates.

  - Disadvantage: more difficult attract users.

• 📦 Alternative stores:

  - Amazon Appstore (popular on Fire devices).

  - Samsung Galaxy Store (for Samsung devices).

  - APKMirror, APKPure (for beta testing).

  - Commission is usually lower than on Google Play (15-20%).

• 🤝 Affiliate apps:

  - TapTap (popular among indie developers).

  - itch.io (ideal for niche games).

  - These platforms often hold promotions to help with promotion.

If you choose self-distribution, make sure that your APK signed and optimized:

- Use aapt to check the manifest:

aapt dump badging your_file.apk

- Compress the APK using zipalign:

zipalign -v 4 unoptimized.apk optimized.apk

To attract users without an advertising budget:

• 📢 Post an announcement on the forums: 4PDA, XDA-Developers, Reddit (r/AndroidGaming).
• 🎥 Record the gameplay and upload to YouTube with tags #indiegame #android #python.
• 🤳 Create a page on social networks (VK, Telegram) and publish updates.

FAQ: Frequently asked questions about creating games in Python for Android

from ursina import *

app = Ursina()
player = Entity(model='cube', color=color.red, collider='box')
ground = Entity(model='plane', scale=(10,1,10), collider='box')

def update():
player.x += held_keys['d'] * 0.1
player.x -= held_keys['a'] * 0.1

app.run()

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>