Context

In our most recent Homathon (hackathon at Homa), 10 teams utilized generative AI to tackle various challenges of the game creation process. We created innovative prototypes to enhance workflows for our game developers, our colleagues at our partner studios, and Homa Lab Users in general. This initiative involved the active participation of members from many different teams, providing a space for collaboration and brainstorming. Ultimately, we achieved our goal of exploring both the transformative realm of GenAI and its impact on the mobile gaming industry.

Among the many projects presented, we witnessed some very novel proposals—such as tools to produce animated personalized avatars, create ready-to-use 3D assets, and generate game concepts with built-in hit potential based on real-time data. This last project has already been deployed—and a huge shoutout goes to our team members Guilherme, Sachin, and Radoslav for their principal contributions to this project, the “Game Idea Generator”.

In this article we will focus on how we built the “Game Idea Generator” that is now in Homa Lab. We will delve into the initial stages of our exploration, the challenges we encountered, and our solutions to those problems. We'll also share some valuable insights gained during the hackathon and while transitioning these prototypes to production releases on our platform.

Tackling the Ideation process

Starting a project can often be the toughest part, so we aimed to find ways to jumpstart the creative process for both new and experienced game developers.

Our bone to pick with the creation process boiled down to this:

• Coming up with marketable and clear game ideas is difficult.
• Spotting new trends / finding marketability can be tough.
• Dealing with a lot of data from different places is a challenge.
• Creating a game concept that combines themes, mechanics, and gameplay loops into a fun experience is tricky.
• Documenting an idea thoroughly and clearly, as well as collecting materials for reference, is time consuming and can feel tedious.

Unpacking the Solution

Keeping in mind the challenges game creators face when coming up with ideas that work, we identified a unique opportunity to address these issues utilizing Gen-AI and our data pipeline inside Homa Lab. Here’s how we do it:

Spotting Trends

We use a combination of proprietary data gathering from external sources, including the Android and Apple app stores, on top of our dataset consisting of hundreds of apps tested every quarter. All the data is custom labelled by our AI models (read more about this in our first article). This combination of varied sources allows us to see both the macro and granular pictures of what is working on the stores at the moment as well as insights into staying power, age, and direction of trends.

Below is a schema of one of the tables we use for this and its associated record count.

create table tbl_store_scraper_apps
(
    s_app_id                       varchar(256) encode bytedict,
    s_app_name                     varchar(256) encode bytedict,
    s_app_url                      varchar(512) encode bytedict,
    s_platform                     varchar(8) encode bytedict,
    f_original_price               numeric(10, 2),
    s_currency_code                varchar(3) encode bytedict,
    b_is_free                      boolean,
    b_is_sale                      boolean,
    f_sale_price                   numeric(10, 2),
    dt_sale_end_datetime           timestamp encode runlength,
    d_release_date                 date encode runlength,
    s_developer_id                 varchar(256) encode bytedict,
    s_developer_name               varchar(256) encode bytedict,
    s_developer_url                varchar(512) encode bytedict,
    s_developer_internal_id        varchar(30) encode bytedict,
    s_developer_email_address      varchar(100) encode bytedict,
    s_developer_website_url        varchar(100) encode bytedict,
    s_developer_address            varchar(500) encode bytedict,
    s_developer_privacy_policy_url varchar(500) encode bytedict,
    s_category_id                  varchar(30) encode bytedict,
    b_is_category_game             boolean,
    b_is_editors_choice            boolean,
    i_app_rating_1_star_count      bigint,
    i_app_rating_2_star_count      bigint,
    i_app_rating_3_star_count      bigint,
    i_app_rating_4_star_count      bigint,
    i_app_rating_5_star_count      bigint,
    i_app_rating_count             bigint,
    f_app_rating                   numeric(7, 6),
    i_reviews_count                bigint,
    s_content_rating               varchar(100) encode bytedict,
    s_content_rating_description   varchar(100) encode bytedict,
    s_description_short            varchar(100) encode bytedict,
    s_description_full             varchar(5000) encode bytedict,
    i_app_size                     bigint,
    s_app_version                  varchar(30) encode bytedict,
    dt_app_update_datetime         timestamp encode runlength,
    s_recent_changes               varchar(1000) encode bytedict,
    s_min_os_version_text          varchar(20) encode bytedict,
    s_min_os_version               varchar(20) encode bytedict,
    i_installs                     bigint,
    i_min_installs                 bigint,
    b_has_in_app_purchases         boolean,
    s_iap_price_range              varchar(30) encode bytedict,
    f_iap_price_min                numeric(10, 2),
    f_iap_price_max                numeric(10, 2),
    s_cover_image_url              varchar(512) encode bytedict,
    a_screenshot_url_list          varchar(3500) encode bytedict,
    s_video_url                    varchar(512) encode bytedict,
    s_video_image_url              varchar(512) encode bytedict,
    s_header_image_url             varchar(512) encode bytedict,
    s_store_country_code           varchar(3) encode bytedict,
    s_store_language_code          varchar(20) encode bytedict,
    i_screenshot_url_count         bigint,
    b_has_subscription             boolean,
    i_description_short_length     bigint,
    i_description_full_length      bigint,
    dt_fetch_datetime              timestamp encode runlength,
    d_fetch_date                   date encode runlength,
    d_reference_date               date encode runlength
)

Engaging Players

With our data pipelines that ascribe labels to the apps we process on the app store and our much deeper insight into our internal set of apps, we know what combinations of game properties work the best.

Finding Marketability

Following a trend is easy, but which are the easiest to follow? Which ones have staying power? Which are the most profitable? We can take advantage of our access to internal data regarding profitability of our currently testing and historically tested games to see behind the curtain and glean hidden insights regarding marketability. Our wealth of data allows us to more successfully detach from any recency or hindsight bias in judgment. Additionally, the internal data unveils market trends and profitability, providing a clear view of what works and what doesn’t.

Idea Fleshing

We're not done; we still have much to do in fleshing out the idea. We can leverage Gen-AI here to amplify the usefulness of our data and data processes.

To sum up

We have internal information on the best-performing creatives/concepts as well as consolidated labeled data on thousands of public apps. We see what is being tested in this present moment by devs who are still in the process of making their games. Therefore, by investigating what works among this cohort and comparing numbers with our expansive records, we have more insight on mobile game trends.

How the Game Idea Generator works in the background

1. We source our data using two ways.
   1. Proprietary data gathering from the Google Play / Apple App Stores / Sensor Tower / Apptweak. We have multiple jobs running on Airflow to scrape every gaming app from top developers since 2019. We consolidate, categorize, and label this data. This vast treasure trove of information lets us determine daily granularity about current trends and marketability.
   2. Not only do we have data on "post-release" performance, but we also use our proprietary data source collected from thousands of apps. These apps include those we're currently testing and the plethora of apps that we have tested in the past. Although this source is much smaller, the resolution of this data is much finer. This lets us see the marketability and scalability (profitability) of ideas/concepts directly backed up by our test advertising data. With platform economics, as the platform increases in usage, the data from the platform becomes more valuable.
2. We rank and measure the success of games and while recording stats that describe marketability/trendiness/profitability as different dimensions to compare.
   
   1. We can weigh specific dimensions and recalculate weights to evaluate current market favorability towards particular aspects of game ideas.
3. The data pipeline's conclusion is to develop a semi-randomized list of the critical elements that define a game.
4. We take the conclusion of the data pipeline and feed it to our Gen-AI pipeline.
5. We use GPT to expound on the elements outputted and generate a fully fledged game idea with mechanics, theme, and a basic gameplay loop.
6. We use a latent diffusion model to generate reference images from this description and source images from our private test assets or public assets from the app store.

We then expose the steps and processes above to a chat bot that functions as your own personal brainstorming partner. The bot creates ideas from scratch, from a minimal description, or from one of the 2000+ ideas that already exist on our platform. A typical use case is outlined below.

But a project it’s not successful without learnings. And here are ours

The key takeaways from this project shed light on the process of integrating AI into the development workflow:

1. Our high-quality data and the insights gleaned from it enable our AI to produce something impactful.
2. AI is used here as an impact multiplier and lets us enhance an existing process to add slices into our vertical integration.
3. The quality of data/tech, and the quality of the data/tech pipeline is still the most critical thing.
4. QA is even more useful in validating (intended) non-deterministic responses.
5. Optimizing performance when using GenAI should not be overlooked, as well as optimizing prompts.
6. Be okay with the unexpected. Utilizing GenAI will produce a lot more unintended results than you may be used to. Be ready to be constantly tweaking and fine-tuning

Overall, this project and the many other AI tools we’re building aim to empower developers and give them the ability to create, test, and iterate quicker—with more efficiency, and less friction.

Why all game devs should try the “Game Idea Generator”

We’re confident that this tool will assist solo creators and small teams in thinking of novel, marketable game ideas. Some of our favorites generated by the “Game Idea Generator” include a puzzle game with dj and rhythm elements and a side-scroller where the player needs to collect and eat as much junk food as possible.

For people who don't like the ideation process, the “Game Idea Generator” transforms it into a quick validation process in which one does not invest too much time. For people who do, the “Game Idea Generator” provides another perspective backed up by our data, which could in turn spur more conception. Think of the this bot as an extra team member with the sole purpose of aiding in ideation.

Explore the future with the “Game Idea Generator”, an AI-powered tool for revolutionary game ideas. Immerse yourself in it within Homa Lab today. The horizon of innovation in game development unfolds, guiding creators towards uncharted territories.

If you want to learn more about open positions at Homa, you can visit this page.