Skip to main content
This page documents the export configuration used in Space Pong, covering display settings, package configuration, rendering options, and other export-specific parameters.

​
Project Settings

The core project configuration is defined in project.godot:

​
Application Settings

[application]
config/name="SpacePong"
run/main_scene="res://scenes/game.tscn"
config/features=PackedStringArray("4.3", "Mobile")
config/icon="res://sprites/icon.svg"
  • config/name: The application display name shown to users
  • run/main_scene: Entry point scene that loads when the game starts
  • config/features: Targets Godot 4.3 with Mobile rendering profile
  • config/icon: Default icon used across platforms

​
Display Configuration

Space Pong uses a portrait-oriented display optimized for mobile phones: 
[display]
window/size/viewport_width=460
window/size/viewport_height=720
window/stretch/aspect="keep_height"

​
Window Dimensions

  • Width: 460 pixels
  • Height: 720 pixels
  • Aspect Ratio: Approximately 16:25 (portrait)
These dimensions provide a tall, narrow playing field ideal for single-hand portrait gameplay.
The keep_height stretch mode ensures the full vertical space is always visible, allowing width to adjust based on device aspect ratio.

​
Rendering Configuration

The project uses Godot’s mobile rendering backend for optimal performance: 
[rendering]
renderer/rendering_method="mobile"
textures/vram_compression/import_etc2_astc=true
  • mobile: Forward rendering optimized for mobile GPUs
  • VRAM Compression: ETC2/ASTC texture compression for reduced memory usage
The Mobile renderer is less feature-rich than the Forward+ renderer but provides better performance and battery life on mobile devices.

​
Android Export Preset

The Android export configuration is stored in export_presets.cfg:

​
Basic Preset Settings

[preset.0]
name="Android"
platform="Android"
runnable=true
advanced_options=false
dedicated_server=false
export_filter="all_resources"
export_path="./SpacePong.apk"
  • runnable: Allows one-click deployment to devices from the editor
  • export_filter: Includes all resources in the export (no selective filtering)
  • export_path: Default output location for the APK

​
Package Configuration

Package identity and versioning settings: 
package/unique_name="com.example.$genname"
package/signed=true
package/app_category=2
version/code=1
version/name=""

​
Package Name

The default com.example.$genname should be replaced before publishing. A proper package name follows this pattern: 
com.yourcompany.spacepong
1

Choose Domain

Use your reverse domain name (e.g., com.yourdomain)
2

Add App Identifier

Append a unique app identifier (e.g., spacepong)
3

Update Export Preset

In Godot, go to Project > Export > Android and update the Unique Name field under Package
Google Play Store requires a unique package name. Once published, the package name cannot be changed without creating a new app listing.

​
Version Management

  • version/code: Integer version code (increment for each release)
  • version/name: Human-readable version string (e.g., “1.0.0”)
The version code must increase with each update submitted to app stores.

​
Architecture Support

Space Pong targets modern 64-bit ARM devices: 
architectures/armeabi-v7a=false
architectures/arm64-v8a=true
architectures/x86=false
architectures/x86_64=false

ARM64-v8a

EnabledTargets 64-bit ARM processors (most modern Android devices)

ARMv7a

DisabledLegacy 32-bit ARM support excluded to reduce APK size
Google Play requires 64-bit support for all new apps and updates. ARMv7a is only needed for very old devices (pre-2017).

​
Screen Configuration

Screen-related settings control how the app appears on Android devices: 
screen/immersive_mode=true
screen/support_small=true
screen/support_normal=true
screen/support_large=true
screen/support_xlarge=true

​
Immersive Mode

Immersive mode is enabled, which hides the status bar and navigation buttons for a fullscreen gaming experience.
Users can swipe from the edge to temporarily reveal system UI. The game automatically returns to immersive mode after dismissal.

​
Screen Size Support

All screen sizes are supported (small to xlarge), allowing Space Pong to run on phones and tablets.

​
Graphics Settings

graphics/opengl_debug=false
xr_features/xr_mode=0
  • OpenGL Debug: Disabled for production builds (better performance)
  • XR Mode: No VR/AR support (standard 2D game)

​
Gradle Build Configuration

gradle_build/use_gradle_build=false
gradle_build/export_format=0
gradle_build/compress_native_libraries=false
Space Pong uses the legacy APK export method rather than Gradle builds:
  • Faster export times during development
  • Simpler configuration for small projects
  • Direct APK output (not Android App Bundle)
For Google Play Store distribution, consider enabling Gradle builds to generate an Android App Bundle (AAB) format, which supports dynamic delivery and smaller download sizes.

​
Permissions

Space Pong requires no special Android permissions. All permission entries in the export preset are set to false. The game works entirely offline with no network access, location services, or device sensors beyond basic touch input. 
permissions/internet=false
permissions/access_network_state=false
permissions/vibrate=false
This minimal permission model:
  • Improves user trust and privacy
  • Reduces installation friction
  • Simplifies app store review process

​
Script Export Mode

script_export_mode=2
Scripts are exported in compiled bytecode format (mode 2), which:
  • Protects source code from decompilation
  • Slightly reduces APK size
  • Improves loading performance
Text format exports (mode 1) are useful for debugging but expose your GDScript source code in the APK.

​
Encryption Settings

encrypt_pck=false
encrypt_directory=false
encryption_include_filters=""
encryption_exclude_filters=""
The game resources (.pck file) are not encrypted in the default configuration. For commercial releases, consider enabling encryption to protect game assets:
1

Generate Encryption Key

In Godot, go to Project > Export > Android > Resources
2

Enable PCK Encryption

Check Encrypt PCK and generate a 256-bit AES key
3

Store Key Securely

Save the encryption key in a secure location. You’ll need it for updates.
If you lose the encryption key, you cannot update your published app. Always keep secure backups.

​
Customizing Configuration

To modify export settings:
  1. Via Godot Editor (Recommended):
    • Open Project > Export
    • Select the Android preset
    • Modify settings in the right panel
    • Changes save automatically to export_presets.cfg
  2. Via Text Editor (Advanced):
    • Edit export_presets.cfg directly
    • Use the correct INI format
    • Reload project in Godot to apply changes
Manual editing of export_presets.cfg can break the export preset if syntax is incorrect. Always backup before manual edits.
Before publishing Space Pong, update these settings:
  • Change package/unique_name to your domain (e.g., com.yourstudio.spacepong)
  • Set version/name to a semantic version (e.g., "1.0.0")
  • Set version/code to 1 (increment for each release)
  • Add custom launcher icons (192x192 and adaptive 432x432)
  • Consider enabling encrypt_pck for asset protection
  • Enable gradle_build/use_gradle_build for AAB format
  • Update config/icon to a high-resolution app icon

​
Next Steps

Android Export

Follow the step-by-step guide to build and test your APK

Project Structure

Learn about the project’s file organization and scene structure

Build docs developers (and LLMs) love

Get started for freeTalk to us