Creating a horror game on Android: from idea to publication on Google Play

Creating a horror game for Android is not only an opportunity to realize your darkest fantasies, but also a chance to make money on a popular genre. Mobile horror games, from psychological thrillers to jump-scare action games, occupy a stable niche injump scares), occupy a stable niche in Google Play, attracting millions of players. However, developing a truly atmospheric game that will scare and not make you laugh is a non-trivial task. Everything is important here: from the choice of engine to little things like sound design or optimization for weak smartphones.

In this guide, we will analyze the process of creating a horror game from Android from scratch: from concept formation to publication in the store. You will learn what tools to use (including free ones), how to avoid common beginner mistakes, and what technical nuances to consider so that the game does not lag on budget devices. And if you have never been involved in game development, don’t worry - we will give recommendations for any level of training, from a complete beginner to an experienced programmer.

1. Choosing a concept: what kind of horror do you want to create?

Before opening the engine, decide on genre niche your game. Horror on mobile platforms is conventionally divided into several types, each of which requires different approaches to gameplay and atmosphere:

• 👻 Psychological horror - emphasis on tension, mystery and slow plot development (example: Year Walk). Plot twists and working with the player’s imagination are important here.
• 💀 Slasher/action - dynamic chases, fights with monsters and abundant jump scares (example: Dead by Daylight Mobile). Requires high-quality animation and responsive controls.
• 🏚️ Stealth horror - the player must hide from enemies in a limited space (example: Five Nights at Freddy’s). The main thing is competent AI of opponents and a detection system.
• 📖 Visual novel - minimal gameplay, maximum text and atmosphere (example: Doki Doki Literature Club with a dark twist). Suitable for beginners as it does not require complex graphics.

Define also target audience. Teenagers 12–16 years old prefer bright, but not too scary games (for example, Granny), while adult players value deep plots and non-linearity (Oxenfree). Think about whether your game will be:

• 🎮 Casual (simple controls, short sessions) or hardcore (complex mechanics, long playthroughs)?
• 🌍 Linear (one story path) or with branches (the player's choice affects the ending)?
• 💰 Paid (one-time purchase) or free-to-play (with advertising/donations)?

If you are a beginner, start with a simple project - for example 2D horror with a top-down view (how Silent Hill: Shattered Memories on mobile devices). Such games require fewer resources for development, but with the right approach they can be no less atmospheric than 3D projects.

2. Choosing an engine: Unity vs Godot vs Unreal Engine vs others

The engine determines how quickly you can implement your idea and what technical limitations await you. Let's consider the main options for Androiddevelopment:

Engine	Pros	Cons	Suitable for
Unity	Rich ecosystem of plugins (for example Post Processing Stack for effects), good documentation, 2D/3D support.	Paid license for companies with income >$100K, high hardware requirements for complex projects.	Any horror games, especially 3D with advanced graphics.
Godot	Free, lightweight, open source, perfectly optimized for mobile.	Fewer ready-made solutions for horror effects, smaller community than Unity.	2D horror, prototypes, indie projects.
Unreal Engine	Best graphics (support ray tracing), ready-made solutions for lighting and particles.	Difficult for beginners, high device requirements, larger final APK size.	AAA-quality 3D horror with realistic graphics.
Construct 3	Visual programming (no code), fast prototyping 2D games.	Limited capabilities for 3D, paid subscription for export to Android.	2D horror for beginners (for example, point-and-click).

For most beginners, the optimal choice is Unity or Godot. Unity allows you to use ready-made assets for horror effects (for example, shaders for blood or fog), and Godot is free and easier to learn for 2D projects. If you need photorealistic graphics, but are willing to spend time learning, try it Unreal Engine.

Example of minimum requirements for start:

• 💻 For Unity/Godot: PC with 8 GB RAM, level video card GTX 1050 and SSD.
• 📱 For testing: smartphone on Android 8.0+ (for example Redmi Note 10 or older).

3. Creating an atmosphere: sound, light and visual effects

Horror lives in detail. Even a simple game can scare the player if handled correctly. atmosphere. Here are the key elements to pay attention to:

Sound design

Sound in horror is responsible for 50% of the fear. Use:

• 🔊 Ambient — background noise (creaking doors, whispering, wind). You can download free samples to Freesound.org.
• 🎵 Dynamic music —tracks that change depending on the player’s actions (for example, they speed up when a monster appears).
• 💥 Jump scare sounds —short sharp sounds (scream, blow). The main thing is not to overdo it, otherwise the player will get used to it.

For sound processing, the following apps are suitable:

• Audacity (free editor).
• FMOD or Wwise (for advanced mixing, integrated with Unity/Unreal).

Lighting and post-effects

Darkness is your best friend. The following techniques work in horror:

• 🌑 Contrast lighting - bright light in a dark room (for example, a player’s flashlight).
• 🌫️ Fog - limits visibility and adds mystery.
• 👁️ Effects distortion (for example, Bloom for glow or Chromatic Aberration to simulate stress).

In Unity these effects are configured via Post Processing Stack (install the package via Window → Package Manager). Q Godot use shaders or a plugin Godot Post Processing.

How to make a realistic flashlight in Unity?

1. Create Spot Light and attach it to the player's camera. 2. Set Range (range) to 5–7 units and Intensity to 2–3. 3. Add Cookie (texture for the shape of the light) with jagged edges to make the light appear more natural.

Animation and models

For 3D horror:

• 🤖 Use ready-made models with Mixamo (free animations for characters) or Sketchfab (3D models under a CC license).
• 🧟 Low-poly models with an emphasis on deformations (for example, stretchable limbs) are suitable for monsters.

For 2D:

• 🎨 Draw sprites in Aseprite or Krita (free alternatives to Photoshop).
• 👻 Effect “jittering” of sprites when danger approaches adds tension (configurable through scripts in Unity/Godot).

4. Gameplay programming: from movement to AI monsters

Even the most beautiful game will be useless without interesting gameplay. Let's look at the basic mechanics that are useful in horror:

Character control

For mobile games, it is important that the controls are intuitive. Popular schemes:

• 🎮 Virtual joystick (for example, plugin Joystick Pack for Unity).
• 👆 Swipe controls - swiping your finger to move (as in Temple Run).
• 🖱️ Point-and-click — taps on the screen to interact with objects.

Example code for simple character movement in Unity (C#):

using UnityEngine;

public class PlayerMovement : MonoBehaviour {
public float moveSpeed = 5f;
public VirtualJoystick joystick;

void Update() {
Vector3 direction = new Vector3(joystick.Horizontal(), 0, joystick.Vertical());
transform.Translate(direction  moveSpeed  Time.deltaTime);
}
}

Artificial intelligence for monsters

There should be AI in horror predictably unpredictable — the player should not feel that the enemies are moving according to the script, but chaos is also not needed. Basic approaches:

• 🧠 Patrol-system —the monster walks along given points until it notices the player.
• 👀 Field of view (FOV) — the enemy reacts only if the player gets into the “cone of visibility.”
• 🏃 Chase — after detection, the monster moves towards the player at a given speed.

Example script for simple AI on Unity:

public class EnemyAI : MonoBehaviour {
public Transform player;
public float chaseRange = 10f;
public float moveSpeed = 3f;

void Update() {
float distance = Vector3.Distance(transform.position, player.position);
if (distance < chaseRange) {
transform.LookAt(player);
transform.Translate(Vector3.forward  moveSpeed  Time.deltaTime);
}
}
}

Fear and health system

In horror, instead of the classic "HP" is often used level of fear, which grows from:

• 😨 Meetings with monsters.
• 🔦 Staying in the dark for a long time.
• 🎧 Loud sounds (jump scares).

Example implementations:

public class FearSystem : MonoBehaviour {
public float fearLevel = 0f;
public float maxFear = 100f;
public GameObject gameOverScreen;

void Update() {
if (fearLevel >= maxFear) {
gameOverScreen.SetActive(true);
Time.timeScale = 0; // Stop the game
}
}

public void IncreaseFear(float amount) {
fearLevel += amount;
}
}

Create a character with controls|Customize the camera (1st or 3rd person view)|Add a monster with simple AI|Implement the fear/health system|Test on a mobile device-->

5. Optimization for Android: how to avoid lags and overheating

Mobile devices vary greatly in performance, and your game should run smoothly even on weak smartphones. Here are the key optimization points:

Graphics and performance

• 📉 Reduce the number of polygons in 3D models (the goal is no more than 5-10 thousand per screen).
• 🖼️ Compress textures (smoke, blood) - they load the GPU heavily. to resolution 1024x1024 (or 512x512 for 2D). Use the format for sprites with transparency and for backgrounds. .PNG for sprites with transparency and .JPG for backgrounds.
• 🌳 Limit the number particles (smoke, blood) - they heavily load the GPU.
• 🔦 Turn off unnecessary light sources —in horror, 1-2 dynamic lamps are often enough.

In Unity turn on Occlusion Culling (in the menu Window → Rendering → Occlusion Culling) so that the engine does not render objects behind walls.

Build settings for Android

Before exporting APK:

1. Go to File → Build Settings → Android.
2. B Player Settings install:
   • Target Architecture: ARM64 (main option) + ARMv7 (for old devices).
   • Graphics API: only OpenGLES3 (universal for most smartphones).
   • Compression Method: LZ4 (quick unpacking when installation).

Enable Split Application Binaryso that the game weighs less than 100 MB (otherwise users will have to download an additional OBB file).

Working with memory

Mobile games are often closed due to lack of RAM. To avoid crashes:

• 🗑️ Destroy unnecessary objects (use Object Pooling for frequently created objects, such as bullets).
• 🔄 Unload unused assets using Resources.UnloadUnusedAssets().
• 📱 Limit FPS up to 30 or 60 (in Application.targetFrameRate).

6. Testing and debugging: catching bugs before release

Testing a horror game is not only about searching bugs, but also checking how much it is really scary. Here's how to organize the process:

Technical testing

Test the game on:

• 📱 Different devices (minimum 3–5 models with different chipsets: Snapdragon 4xx, Mediatek Helio, Kirin).
• 🔄 Different versions of Android (from 8.0 to 14).
• 🎮 Different screen resolutions (from 720p to 4K).

Use tools:

• Android Profiler (in Unity) - shows CPU/GPU consumption and memory.
• Logcat (in Android Studio) - to find errors in real time.

Gameplay testing

Invite 5-10 people (preferably not familiar with the game mechanics) and observe:

• 😱 Do they react to jump scares (if not, the sound or timing is bad).
• 🤔 Do they understand what to do (if not, you need tips or a tutorial).
• 😴 Do they lose interest after 5-10 minutes (if so, the gameplay is too monotonous).

Collect feedback using:

• 📝 Google Forms (questionnaire with questions like “What scared you the most?”).
• 🎥 Screen recordings (applications like AZ Screen Recorder).

How to find testers for free?

Post a post in communities like r/playmygame (Reddit) or Indie Game Devs (Facebook). Offer testers access to the closed beta version in exchange for feedback.

Optimization before release

Before publication:

• 🗑️ Remove unnecessary assets (check the folder Assets/Unused in Unity).
• 🔍 Run the game via Unity Cloud Diagnostics (free for small projects).
• 📦 Make sure that the APK size does not exceed 100 MB (otherwise users will download additional files).

7. Publishing on Google Play: from account to monetization

When the game is ready, it's time to upload it to Google Play Console. Here is the step-by-step process:

Register a developer account

An account is required to publish Google Play Developer:

1. Go to Google Play Console.
2. Register (you will need to pay one-time fee $25).
3. Fill out the developer's profile (name, logo, contacts).

Preparation of materials for the game page

You will need:

• 📸 Screenshots (minimum 2, preferably 4–6; size 1920x1080).
• 🎬 Video trailer (30–60 seconds; can be taken in CapCut).
• 📝 Description (in Russian and English; use keywords: “horror game”, “scary game”, “jump scare”).
• 🏷️ Icon (size 512x512, without text).
• 📋 ESRB/PEGI rating (for horror usually 12+ or 16+).

Example description for Google Play:

🌑 Dive into the nightmarish world of [Game Name] - a new horror game for Android!

🔦 You have to survive in [brief plot description], where every sound could be your last. Hide from monsters, solve riddles and try to maintain your sanity in an atmosphere of suffocating fear.

⚠️ WARNING: The game contains sharp sounds and frightening moments. Not recommended for people with weak nerves!

🎮 Features:
• [Feature 1]
• [Feature 2]
• [Feature 3]

📥 Download [Game Name] right now and see if you have the courage to reach the end!

Monetization settings

Select an earnings model:

• 💰 Paid game ($0.99–$4.99) - suitable for niche projects with a unique gameplay.
• 📺 Free with advertising - use AdMob (banners and videos between levels).
• 🛒 Free with donations - sell skins, additional levels or disable advertising.

To integrate advertising in Unity:

1. Install the package Unity Monetization via Window → Package Manager.
2. Create an account in AdMob i get App ID.
3. Add a script for displaying banners:

   using UnityEngine;
   using UnityEngine.Advertisements;
   
   public class AdManager : MonoBehaviour {
   string gameId = "YOUR_GAME_ID"; // From AdMob
   void Start() {
   Advertisement.Initialize(gameId);
   }
   
   public void ShowBanner() {
   Advertisement.Banner.Show("bannerPlacement");
   }
   }

Moderation and release

After downloading the APK, the game will undergo moderation (usually 1-3 days). Frequent reasons for rejection:

• 📛 Absent privacy policy (required even for free games).
• 🔞 The age rating is not indicated or it does not correspond to the content.
• 📱 The game crashes on Google test devices.

As soon as the game is published:

• 📢 Launch a promotion on social networks (TikTok, Instagram Reels, YouTube Shorts).
• 🤝 Write to horror communities (for example, r/horrorgaming on Reddit).
• 📊 Track statistics in Google Play Console (installations, churn, income).

8. Promotion and updates: how to attract players

Even the highest quality game will not become popular without promotion. Here are working strategies for horror games on Android:

Free promotion methods

• 🎥 TikTok/YouTube Shorts - record 10-15 second videos with the most frightening moments. Use hashtags: #horrorgame, #scarygame, #indiegame.
• 💬 Reddit and forums —publish a post in r/AndroidGaming or 4PDA (the “Games” section).
• 📱 Thematic groups in VK/Telegram —for example, “The best horror games on Android."
• 🎮 Game Jams - participate in competitions (for example, Ludum Dare) for free advertising.

Paid methods

If available budget:

• 📢 Targeted advertising on Facebook/Instagram (target audience: 16–30 years old, interests: “horror games”, “mobile gaming”)
• 🤝 Collaboration with bloggers —send game keys to small streamers (1–10k subscribers) in exchange for a review.
• 🏆 ASO (store optimization) —order keyword optimization from specialists (cost: $50–$200).

Updates and support

To retain players:

• 🔄 Add new content (levels, monsters, story branches) once every 1-2 months.
• 🐛 Fix bugs based on user reviews (monitor comments on Google Play).
• 🎁 Hold events (for example, a Halloween update with an exclusive monster