Skip to main content

Why Test Exported Builds?

Your game might work perfectly in the Summer Engine editor but have issues when exported. Always test exported builds before releasing to players!
Critical difference: Some features work differently (or only work) in exported builds:
  • Microphone permissions (macOS)
  • Performance characteristics
  • File paths and resource loading
  • Platform-specific features
This guide shows you how to properly test your game after export but before release.

Quick Testing Workflow

1

Export Your Game

Follow the macOS export or Windows export guide
2

Test on Your Development Machine

First smoke test - does it launch and run?
3

Test on a Clean Machine

Critical! Test on different computer to catch distribution issues
4

Fix Issues and Re-export

Make changes in Summer Engine, export again, repeat

macOS Local Testing

First Run: Ad-Hoc Signing

Summer Engine creates ad-hoc signed builds by default. These work on your Mac but have security dialogs.
1

Export Your Game

Project → Export → macOSConfigure minimum settings:
  • Bundle Identifier: com.yourgame.test (any reverse-domain format)
  • Codesign → Codesign: Disabled or Built-in (ad-hoc only)
  • Notarization → Notarization: Disabled
Click Export Project → Save as ~/Desktop/YourGame.app
2

Launch the Exported Game

Navigate to Desktop → Double-click YourGame.app
3

Handle Security Dialog

First launch: macOS shows “unidentified developer” warningTo bypass:
  • Right-click (don’t double-click!) YourGame.app
  • Click Open from menu
  • Click Open in the dialog
This is normal for local testing! You’re using ad-hoc signing, not production signing.
4

Grant Permissions

If your game uses microphone, camera, or other features:macOS will ask for permissions on first launch of the exported appThis is good - it means your game can access hardware in exported builds!

Why the Security Warning Appears

Ad-hoc signed apps (for testing):
  • Run on your Mac
  • Request permissions properly
  • Good for development testing
  • Other people’s Macs warn about them (Gatekeeper) when they are downloaded
Signed and notarized apps (for distribution):
  • Run on anyone’s Mac
  • No security warnings
  • Need an Apple Developer account
  • Usually not needed for Steam; optional for itch.io
For local testing: Ad-hoc signing is perfect! Only get proper signing when you’re ready to distribute outside Steam/itch.io.

Testing Features That Only Work in Exports

Microphone/Audio Input

Why it matters: Voice chat, voice commands, audio recording In editor: May not request permissions properly (macOS security limitation) In export: the macOS permission dialog appears on first use Set up the export preset first. On macOS a game can only use the microphone when its preset says so:
  • Privacy → Microphone Usage Description: one sentence that tells players why the game needs the microphone
  • Codesign → Entitlements → Audio Input: On
Without them, the game gets no microphone input and macOS never asks. The camera works the same way, with Camera Usage Description and the Camera entitlement. How to test:
1

Export and Launch

Export game → Right-click Open → Click Open in dialog
2

Trigger Mic Usage

Start your game’s voice feature (voice chat, recording, etc.)
3

Grant Permission

macOS shows: “YourGame would like to access the microphone”Click OK
4

Verify It Works

  • Speak into mic
  • Check audio input is captured
  • Test your voice features work properly
Check System Settings:
  • After granting permission, verify in System Settings → Privacy & Security → Microphone
  • Your game should appear in the list

Camera Access

Similar process to microphone - permission dialog appears on first use in exported build.

File System Access

Save games and user data (user://):
  • In the editor and in the export: ~/Library/Application Support/Godot/app_userdata/YourGame/ on macOS, unless your project sets a custom user folder
  • res:// is read-only in an exported game: never save there
Test:
  1. Save game in exported build
  2. Quit game
  3. Launch again - verify save loaded

Windows Local Testing

No Security Warnings on Your PC

Windows trusts your own builds by default. But test what other users will see:
1

Export for Windows

Project → Export → Windows DesktopExport to MyGame.exe
2

Test Launch

Double-click MyGame.exe - should run immediately
3

Test on Friend's PC

Copy MyGame.exe to another Windows PCThey’ll see: Windows Defender SmartScreen warning

What Users See (Unsigned Windows Build)

First launch on clean PC:
  1. Double-click MyGame.exe
  2. Windows Defender SmartScreen appears:
    “Windows protected your PC. Microsoft Defender SmartScreen prevented an unrecognized app from starting.”
How to bypass (show in your game’s README):
  1. Click More info
  2. Click Run anyway
  3. Game launches
This is normal for unsigned games! itch.io players are used to this. Steam removes the warning automatically.Only code sign if you’re doing direct downloads outside Steam/itch.io.

Performance Testing

Test Debug vs Release

When to use: During development, need console outputCharacteristics:
  • Shows debug messages in the console
  • Runs slower than release
  • Larger file size
Good for: Finding bugs, checking logs
When to use: Final distribution to playersCharacteristics:
  • Full optimization enabled
  • Smaller file size
  • No console output
  • Maximum performance
Good for: Final release, performance testing
How to switch:
  • In the export file dialog, Export With Debug on makes a debug build; off makes a release build
  • On Windows, Debug → Export Console Wrapper set to Debug Only adds a console .exe to debug builds, so you can read their output
Test workflow: Export as Debug during testing (see errors), then export as Release for final performance check before publishing.

Framerate Testing

Check FPS in exported build:
  1. Enable FPS display in your game (or use external tools)
  2. Run through demanding scenes
  3. Verify maintains target FPS (30 or 60)
If slow:
  • Profile in editor first (Debug → Profiler)
  • Optimize before exporting
  • Lower graphics settings in Project Settings

Testing on Clean Machines

Why This Matters

Your dev machine has:
  • Summer Engine installed
  • All dependencies
  • Your project files
  • Visual C++ runtimes
  • Ideal testing environment
User’s machine has:
  • Nothing except the OS
  • Might be missing runtimes
  • Different GPU/drivers
  • Real-world conditions
Common issues only found on clean machines:
  • Missing DLL files (Windows)
  • Graphics driver incompatibilities
  • Audio device issues
  • Save file path problems

How to Test on Clean Machine

Easiest option: Send your exported game to a friendSteps:
  1. Export your game
  2. Copy to USB drive or upload to Google Drive/Dropbox
  3. Friend downloads and runs it
  4. Watch them play (screen share if remote)
  5. Note any errors or issues

Testing Checklist

Before releasing your game, verify:

Launch and Stability

  • Game launches without errors
  • No crashes during 30+ minutes of gameplay
  • Game can be quit properly (doesn’t hang)
  • Multiple launch/quit cycles work (no state corruption)

Graphics

  • All textures load correctly
  • Shaders work (no pink/magenta materials)
  • UI scales properly at different resolutions
  • Fullscreen and windowed modes work
  • Game looks correct on different monitors

Audio

  • Music plays without crackling
  • Sound effects trigger correctly
  • Volume controls work
  • Audio doesn’t cut out or distort
  • Works with both speakers and headphones

Input

  • Keyboard controls work (if applicable)
  • Mouse controls work (if applicable)
  • Gamepad controls work (if applicable)
  • Input remapping works (if your game has it)

Game Features

  • Save/load works
  • Saved data persists after quitting
  • All levels/content accessible
  • Achievements unlock (if implemented)
  • Multiplayer connects (if applicable)

Platform-Specific (macOS)

  • Microphone permission requested (if using voice)
  • Camera permission requested (if using camera)
  • Game works on both Intel and Apple Silicon (if using universal)

Platform-Specific (Windows)

  • No DLL missing errors
  • Works on Windows 10 and 11
  • Runs on a clean PC with no extra installs

Voice Feature Testing (Special Case)

If your game uses microphone input (voice chat, voice commands):

The Editor Problem

Issue: When the editor runs your game, macOS asks for microphone access for the editor, not for your game. If the editor never got access, voice features look broken. Result: Voice features may appear broken in the editor but work fine in exported builds.

The Solution: Test Via Export

1

Export Your Game

Create a macOS export preset (ad-hoc signing is fine) with Microphone Usage Description and the Audio Input entitlement set
2

Launch Exported .app

Right-click → Open → OpenNot launching via editor’s “Run” button!
3

Trigger Voice Feature

Join voice chat, speak command, or start recording
4

Permission Dialog Appears

macOS shows: “YourGame would like to access the microphone”This is correct behavior: it will work for players.
5

Grant and Test

Click OK → Test voice features work properly
Voice features cannot be fully tested in the editor on macOS, because the permission belongs to the editor, not your game.Always export and test voice features in the exported .app build!

Fixing Issues Found During Testing

Game Crashes on Launch

Debug process:
1

Export in Debug Mode

Turn on Export With Debug in the export dialog (on Windows, also set Debug → Export Console Wrapper to Debug Only)Re-export your game
2

Launch from Terminal

Errors will print to terminal
3

Read Error Messages

Look for:
  • Missing file errors
  • Script errors
  • Resource loading failures
4

Fix in Summer Engine

Fix the issue in your project, re-export, test again

Graphics Issues (Missing Textures, Pink Materials)

Possible causes:
  1. Texture compression not enabled for platform
  2. Shaders not exported properly
  3. Resources not included in export
Solution:
  1. Verify texture compression enabled (ETC2 ASTC for Mac, S3TC BPTC for Windows)
  2. Check Export → Resources → Export Mode is “Export all resources in project”
  3. Re-export and test

Audio Not Playing

Check:
  1. Audio files are Ogg Vorbis, WAV or MP3
  2. AudioStreamPlayer nodes properly configured
  3. Audio bus not muted
  4. Test with headphones (not just speakers)

Testing Different Architectures (macOS)

macOS has three architecture options - each needs testing if you support it: What it is: Single app that runs on both Intel and Apple Silicon Macs How to test:
  • Test on an Apple Silicon Mac
  • Test on Intel Mac (if you have access)
If you only have one Mac type: Ask a friend with the other type to test!

arm64 Only

What it is: Apple Silicon only (smaller file size) How to test: Runs on Apple Silicon Macs only Will NOT run on: Intel Macs (shows error)

x86_64 Only (Legacy)

What it is: Intel Macs only How to test: Runs on Intel Macs On Apple Silicon: Runs via Rosetta 2 (translation layer) - slower performance
For Steam and itch.io: Use universal to support the most players. The file is larger, but every Mac can run it.

Testing Save Data

Where Saves Go

user:// is the same folder in the editor and in the exported game, unless your project sets a custom user folder:
  • macOS: ~/Library/Application Support/Godot/app_userdata/YourGameName/
  • Windows: %APPDATA%\Godot\app_userdata\YourGameName\
  • Linux: ~/.local/share/godot/app_userdata/YourGameName/

Test Save Persistence

1

Create Save Data

Launch exported game → Save your progress
2

Quit Completely

Fully quit the game (don’t just close window)
3

Relaunch

Open game again
4

Verify Save Loaded

Check that your progress/settings persisted
Common save issues:
  • Using wrong directory (hardcoded paths instead of user://)
  • Not closing the FileAccess (call close() or let it go out of scope)
  • File permissions issues on different OS

Performance Testing

Compare Editor vs Export

Expected: Exported game runs faster than editor (especially Release builds) If exported game is slower:
  • Check you exported a release build (Export With Debug off)
  • Profile in editor first (Debug → Profiler) - find bottlenecks before exporting
  • Test on same machine for fair comparison

Minimum Spec Testing

Test on lower-end hardware:
  • An older Intel Mac
  • Budget Windows PC
  • Integrated graphics (Intel/AMD iGPU, not dedicated GPU)
Check:
  • Maintains target FPS (30 or 60)
  • No stuttering during gameplay
  • Memory usage stays reasonable (< 4 GB for most indie games)
Can’t test on low-end hardware?In Project Settings: Rendering → Quality - set to “Low” and test. If it runs well on your dev machine at Low quality, it’ll run OK on budget PCs at similar settings.

Platform-Specific Testing

macOS Specific

Test these features:
  • Retina display rendering (high DPI)
  • Fullscreen vs windowed mode
  • Menu bar integration (if using native menus)
  • Dock icon appears correctly
  • Microphone permissions (if using voice)
  • Trackpad gestures (if supported)
Test on both:
  • The newest macOS
  • The version before it

Windows Specific

Test these features:
  • Rendering on the player’s GPU (Vulkan or Direct3D 12 for Forward+ and Mobile, OpenGL for Compatibility)
  • Fullscreen exclusive mode
  • Alt+Tab works properly
  • Multiple monitor support
  • Windows 10 AND Windows 11
Common Windows-only bugs:
  • Path separators (/ vs \) in paths you build yourself
  • File name case: the exported pack is case-sensitive, so res://Player.png loaded as res://player.png works in the editor and fails in the export
  • Missing Visual C++ Runtime on a clean PC

Multiplayer Testing

Summer multiplayer games run on Summer’s hosted servers. Test them in two steps:
  1. On your machine, with Local Play. Run two clients against a local server. See Testing it on your machine.
  2. Online, with the version you release. Join online with the exact build players get, from two devices. See Join online with the version you release.
Check that movement and actions sync, that players can join and leave, and, if your game has voice, that it sounds clear.

What to Look For During Testing

Red Flags (Fix Before Release)

  • Crashes within the first 5 minutes - major stability issue
  • Missing textures or audio - resource export problem
  • Stuttering or freezing - performance issue
  • Save doesn’t persist - save system broken
  • Controls don’t work - input mapping issue

Minor Issues (Fix If Time Permits)

  • Occasional visual glitch - note it and fix it if easy
  • One sound effect too loud - balance issue
  • Typo in UI text - polish issue
  • Minor FPS dip in one area - optimize if possible

What’s OK to Ship

  • Security warnings on macOS or Windows - normal for unsigned games on itch.io
  • Not perfect graphics - indie games are judged on gameplay
  • Small bugs you know about - patch them after release
Perfection is the enemy of shipping. Fix critical bugs, polish what you can, then release! You can always update after launch based on player feedback.

Iteration Speed

Fast Testing Loop

1

Make Changes

Edit code/assets in Summer Engine
2

Quick Test in Editor

Run game in editor - basic functionality check
3

Export

Project → Export → macOS/WindowsUsually takes under a minute once the first export has imported your assets
4

Test Export

Launch exported build - verify fix worked
5

Repeat

Iterate until all issues fixed!
Export is fast once your export templates are installed and your assets are imported. Export often while you test.

Preparing for Release

Once testing is complete:

Final Export Checklist

  • Export a release build (Export With Debug off)
  • Test on clean machine(s)
  • All critical bugs fixed
  • Save/load verified working
  • Performance acceptable on minimum spec
  • File size reasonable (< 500 MB ideal for indie games)
  • Game can be quit properly
  • README/instructions included (if distributing manually)

For Steam

  • Exported for all target platforms (Windows, Mac, Linux)
  • Tested each platform build
  • Build size under Steam depot limits (usually fine for indie games)
  • Steam Input configured (if using controllers)

For itch.io

  • Game zipped if needed (macOS .app must be zipped)
  • File named clearly (MyGame-Mac.zip, MyGame-Windows.exe)
  • README explains how to bypass security warnings
  • File size under itch.io’s upload limit, or upload with butler

Common Testing Mistakes

Only Testing on the Development Machine

Problem: Works for you, crashes for users Solution: Test on at least one other computer

Only Testing Debug Builds

Problem: Debug is slow, users get Release build Solution: Always test final Release build before publishing

Skipping Platform-Specific Testing

Problem: Works on Mac, crashes on Windows (or vice versa) Solution: Test every platform you’re releasing on

Not Testing Permissions

Problem: Microphone/camera don’t work for users Solution: Test exported build specifically for permission dialogs

Assuming Editor = Export

Problem: Different behaviors in editor vs export Solution: Always export and test before considering game “done”

Getting Help

Discord Community

Share testing issues in #game-dev for quick help

X / Twitter

Tweet @SummerEngineCom for support

Report Bugs

Found an export bug in Summer Engine? Let us know!

Back to Export Guides

Platform-specific export instructions
Testing takes time, but it’s worth it! Players remember buggy launches. Taking an extra day to test properly can save weeks of damage control later.When in doubt: test more, and ship when you are confident.