Bringing Bobium Brawlers to Android with Arm SME2

What changes when generative AI runs inside a game rather than behind a cloud API?

For Studio Atelico, the answer is Bobium Brawlers, a fast-paced player-versus-player card and dice game. Players craft creatures from a text prompt and take them into battle. The prompt generates the creature's artwork and a playable deck of cards. Each creation has its own appearance, traits, and strategic possibilities.

Studio Atelico is now bringing this experience to Android with Arm SME2. The Android beta will run entirely on-device and will initially target a defined set of support devices.

Scalable Matrix Extension 2 (SME2) is an Arm CPU architecture feature designed to accelerate matrix-heavy workloads such as AI inference. For Bobium Brawlers, SME2 enables parts of the AI to run locally on the CPU. The GPU remains available for graphics and image generation.

A single player prompt creates both a unique creature and a game-ready deck in Bobium Brawlers.

AI is part of the game loop

Bobium Brawlers uses on-device AI for three different jobs:

• A small language model (SLM) creates structured card and deck data.
• An image model creates the creature artwork.
• Embedding-based classifiers check player input against the game's content guardrails.

Each job has a different performance requirement. Deck and artwork generation can be scheduled behind a loading screen or prepared while the player is doing something else. Content moderation must respond during the interaction, with a target of less than 200 milliseconds.

This distinction shapes the whole implementation. Studio Atelico runs inference as part of the game rather than as a separate sidecar service. The Atelico AI engine can share game resources, schedule work around rendering, and decide where each model runs.

Different AI workloads run at different points in the creation flow, each with its own latency requirement.

Using the CPU and GPU together

Studio Atelico found that smaller language models performed better on its SME2 CPU path than on its Vulkan GPU path. For larger language models, the team uses a more specialized split. The GPU handles initial prompt processing, known as prefill, and the SME2 CPU handles token-by-token generation.

Image generation remains on the GPU, where it is faster. the CPU and GPU can therefore work concurrently. For example, they can generate the card deck and creature artwork at the same time.

That separation also protects the game experience. Studio Atelico can leave GPU capacity available for rendering, schedule generation around play and prepare future content before the player asks for it. The game already creates potential level-up cards while a battle is in progress. The choices are ready when the player needs them.

Bobium Brawlers assigns each AI workload to the processor that best matches its performance characteristics.

Optimization guided by the game, not a benchmark

Studio Atelico calls SME2 microkernels directly from Rust and packs model weights once when a model loads. Kernel selection then adapts to the available hardware and data format. Available formats include INT4 for quantized language models and BF16 for image models.

The team also reduced the overhead created by repeatedly dispatching small kernels. Studio Atelico combines a complete layer’s operation into a larger unit of work. The team measured a 2x to 5x improvement, depending on model size. Profiling also led to targeted implementations for operations such as softmax, RMS norm and data conversion.

Those details matter, but the result is not that every workload should run on the CPU. Studio Atelico reduced SME2 CPU image generation from 46 seconds to 16 seconds, then selected the GPU for production image generation because it was still the faster option. Similarly, adding more CPU cores did not necessarily improve performance because memory bandwidth became the limiting factor.

The useful lesson is architectural: profile the real application and place each workload where it performs best. Optimize each workload for when the player experiences it.

Workload-level measurements determine whether Bobium Brawlers uses the SME2 CPU, the GPU or both.

Reducing dispatch overhead has the largest relative effect on smaller language models

Offline AI changes the experience and the economics

Running these models on the device removes a network request from the core game loop. Players can create and battle without requiring cloud inference for every generated asset, and moderation can happen locally at interactive latency.

Local execution also changes the cost model. A cloud-based generative game incurs an inference cost as players create more content. With on-device inference, Studio Atelico does not have to pay a serving charge for every creature, deck or moderation check. Parameter-efficient fine-tuning also keeps model development practical. Studio Atelico reports a fine-tuning cost of around $5–$10 per model using LoRA. The reported cost excludes the wider engineering, data, and validation costs involved in shipping a model.

The trade-off is a deliberately narrower hardware target. The first Android beta is intended for devices whose CPU and GPU capabilities can deliver the complete offline experience. Restricting the beta allows Studio Atelico to validate performance, thermals, memory use and sustained gameplay on a defined set of platforms. The team can then consider broader availability.

Next steps for the Android beta

Studio Atelico is finalizing model fine-tuning for the Android build and is investigating further improvements. Its iOS closed beta is live, with the Android beta planned in coordination with Arm.

This work shows what SME2 can contribute beyond an isolated inference benchmark. In Bobium Brawlers, SME 2 is one part of a complete game system. Moderation responds while a player types. The CPU and GPU generate different parts of a creature in parallel. The resulting experience does not require cloud inference during play.

Explore the implementation in depth   Sign up for Bobium Brawlers Beta