brainBot isn't the only piece of AI goodness that we've had cooking - introducing the new brainCloud MCP Server!

Summary

Connect AI tools directly to your brainCloud account to manage apps, write and deploy cloud code, configure hooks, and S2S servers - all through natural language. Now available with a local Helper for two-way cloud code sync.

Details

We're excited to introduce the brainCloud MCP (Model Context Protocol) Server - a new way to connect AI tools directly to your brainCloud account.

Once connected, you can manage your brainCloud apps entirely through natural language. Ask your AI to write and deploy cloud code scripts, configure API hooks, manage S2S servers, explore the brainCloud API, run scripts, and even help build your client-side integrations.

Before you start

Your team must have the Builder API enabled before you can connect. A team admin can turn it on under Team > Setup > Team Info. There's nothing else to provision — no static API keys are required; you simply sign in with your brainCloud credentials.

What you can do

• List, read, create, and edit cloud code scripts - e.g., “Create a cloud code script that posts a score to multiple leaderboards.”
• Manage API hooks - e.g., “Add a pre-hook for posting leaderboard scores.”
• Configure S2S servers - e.g., “List my S2S servers.”
• Explore the brainCloud API - Your AI looks up the live documentation for your instance and verifies every method signature before writing a script.
• Run and test scripts - e.g., “Test the AwardCoins script.”
• Get help with client integration - the MCP's knowledge of the API helps you write your client apps too.

Easy, secure setup

The MCP server is hosted (HTTP/SSE) and uses OAuth - just add it as a connector in your AI tool and sign in with your brainCloud credentials. No static API keys required. The Public BaaS endpoint is https://mcp.braincloudservers.com/mcp.

Live app safety

Apps on a live plan are protected by brainCloud's live-lock feature. Your AI will notify you if an app is live-locked and ask you to confirm an unlock through the brainCloud portal before making any write operations.

Sync cloud code to local files

Pair the hosted server with the new brainCloud MCP Helper - a small, trustless companion that runs locally and lets your AI sync your cloud code scripts between brainCloud and a folder on your machine (pull, push, or full two-way sync with automatic merging). It stores no credentials, and your script data flows directly between your machine and brainCloud, never through the AI.

To install

Follow our step-by-step guides to get started:

• Getting Started with brainCloud MCP in Claude
• Syncing Cloud Code to Local Files with the brainCloud MCP Helper

Note: the brainCloud MCP is built and tested using Claude CLI and Claude Desktop, but we are adding support for additional MCP-compatible services. If you find your service doesn't work, contact us via support!

Our new AI assistant, brainBot, will totally transform how you use brainCloud. Super-capable and always available, brainBot makes everything faster and easier!

brainCloud 6.0 also includes the beta of our brand-new LiveOps Campaigns system, Group Tournaments, i3D Flex Metal hosting, Godot GDScript Support, 60-Day Retention analytics, visionOS support, and a long list of marketplace, multiplayer, and portal improvements. There's a lot here - let's dig in!

Given the large changes in this release, we have updated our legal and policy documents to reflect what brainCloud 6 actually does. These updates take effect Monday, June 22, 2026.  See the Updated Terms of Service section at the end of these notes for more details.

Compatibility Notes

We prioritize preserving stability and backward compatibility for existing apps. App compatibility flags are located under App > Design > Core App Info > Advanced Settings; each is enabled to preserve existing behavior for existing apps, but disabled by default for new apps.

New compatibility flags in 6.0 [all default to enabled for existing apps]

• [x] Support legacy Game Center authentication (less secure, not recommended) - retains the older Game Center auth path. Note - requires client changes and the brainCloud 6.0 client libs.
• [x] Support legacy Steam authentication - Retains the older Steam authentication path as we move to the modern, non-deprecated Steam APIs. Note that the new modern API requires devs to configure a new Steam Identity field on the App > Design > Core App Info > Application IDs page.Does not require updated brainCloud Client Lib.
• [x] Support legacy segmentIds in Cloud Code Script APIs - Enabled by default, so existing scripts keep working; disable it to require segment codes in your Cloud Code scripts and reject numeric IDs.  

Carried over from a 5.9 patch (listed here because 6.0 is the first full release to include it):

• [x] Do not strictly validate universalIds received via API endpoints (less secure, not recommended) - universalIds received via API are now sanitized and strictly validated; this flag preserves the looser legacy behavior

Release Highlights

Meet brainBot - your new team member!

The marquee feature of release 6.0 is brainBot, a Claude-powered AI assistant that lives inside the Design Portal. brainBot knows brainCloud, sees your screen, answers questions, writes and debugs scripts, and, with your permission, takes action on your apps.

What can brainBot do?

• Navigation - brainCloud can help you quickly navigate to the right screen or end-user account.
• Answer & Guide - context-aware help that reads the current screen, fetches the right docs/API references on demand, and walks you through tasks step-by-step.
• Write Scripts - brainCloud understands cloud code syntax and APIs and can write scripts for you. Even better, brainBot helps you test and debug interactively!
• Feature Setup - feature configuration can sometimes be tedious. Need to extend your XP level cap from 30 → 40? Adjust the slope of the XP curve? Let brainBot do it for you!
• Translate - brainBot can fill in missing localizations for your Item Catalog, Cash Products, and Promotions.
• Collaborate - brainBot helps you fill in the gaps in your inventory of Cash Products, Items, and Bundles. 
• LiveOps - brainBot can help you set up new Promotions, Redemption Codes, and even LiveOps Campaigns!
• Work with files - upload text files into a conversation and have brainBot generate text files for you. Allows brainBot to work with and/or generate design docs, simple import/export files, etc.

Built for trust & safety:

• Your data stays private - your app and user data is not used for training purposes. 
• Personally Identifiable Information (PII) - by default, PII is stripped before being sent to the AI provider. brainBot resolves PII tokens on the portal side, so player names and emails are shown to you without the provider ever seeing them.
• Team governance - admins control brainBot at the team and per-app level, set default restrictions (over app and user data), and configure daily/monthly cost caps.
• Portal permissions - brainBot has at most the same permissions as the portal user. If the user doesn’t have permission to edit cloud code scripts, then brainBot doesn't either. brainBot is also gated by brainCloud Live Lock feature.
• Per-app context - teams can give brainBot custom context on an app-by-app basis, so its help is tailored to your app.

Availability & costs:

• brainBot is an opt-in feature available on all paid plans (Dev+ or higher).
• AI Usage - the app charges a 35% markup on token costs for processed requests. Admins can set daily and monthly soft caps.
• Auto "power" tiers - brainBot automatically scales its model/tooling to the task, so simple questions stay fast, and complex ones get more horsepower. And this saves $ too!

Go to Team > Setup > AI Settings to enable brainBot!

LiveOps Campaigns [Beta] ENTERPRISE

brainCloud 6.0 introduces LiveOps Campaigns - a powerful new way to run targeted, time-boxed promotions and personalized pricing on top of our Segments and Promotions systems.

• Create & schedule campaigns with a guided creation Wizard, status tracking, and segment targeting.
• Personalized pricing - the AppStore service now returns each user's eligible campaigns alongside promotions, ensuring the right offer reaches the right player.
• Cash-product & item overrides are applied automatically during purchase processing.
• Per-campaign global property overrides, which let you schedule Limited Time Game Modes, such as Double XP Weekends, and Seasonal Modes (eg, Halloween, Happy Holidays, Boxing Week) that you set up in the client.
• Client support - a new Campaign client API (GetMyCampaigns) lets games read a player's eligible campaigns; brainBot can also help you create and refresh campaigns.

LiveOps Campaigns are an Enterprise Feature, available on Business/Business+ plans and higher.

Choose the type of campaign

Target the players you want, now with compound segments

Define your Scenarios and audience allocation

Use Global Property overrides to activate Limited Time Game modes in your client

LiveOps Campaigns are in [beta] while we continue working on the companion analytics features. Stay tuned!

Group Tournaments

We’re pleased to announce that brainCloud's tournament system now supports group-based competition. Tournaments and division sets can be configured with a GROUP entry type, allowing clans, guilds, and teams to compete against each other as single entities — each group enrolls in a tournament, posts shared scores, and is ranked on a group leaderboard. 

This includes support for division sets, where groups are automatically bucketed into division instances of a fixed size (for example, 100 groups per division instance) and compete only against other groups in their division. 

The Design Portal has been updated to support group entry types on tournament and division set configurations, including filtering configs by entry type. 

Note that group tournaments handle rewards via a post-processing script rather than brainCloud's built-in payout rules, so entry fees, payout rules, and tournament notifications do not apply to group-type tournaments.

60-Day Retention Analytics [ENTERPRISE]

Customers on Business/Business+ and above plans will see that our retention analytics now reach back a full 60 days - which means you can see a full month’s worth of D30 data! A new smart mini-card surfaces the extended window and the analytics-history status.
As part of this work, non-Enterprise customers will see a new D14 card, which is more useful than the previously single-point D30 card.

Segment Enhancements

The Segment Builder now supports nested AND/OR condition groups.  This helps your team effectively focus segments on the exact users they want to find. As always, Promotions can be made eligible to specific Segments.

Segments also now support Segment Codes - short, human-readable, permanent identifiers (e.g., new-players, usa_testers) that can be used in place of the numeric legacy ID when referencing a segment across Promotions, Notification Jobs, Campaigns, and Cloud Code.

But that’s not all, Segments can now be preserved during deployment. This allows you to create and edit your Segments in your Production app directly without worrying about them being overwritten.

Note that the APIs (client, S2S, and Cloud Code) now accept either segment IDs or segment codes - see API Changes for the full surface. We recommend moving to codes; Cloud Code can be locked to codes only via the new acceptLegacySegmentIds compatibility flag.

Godot GDScript!

We were one of the first backends to support Godot with our C#-based libraries – and now we’re happy to complete that support with our new GDScript-based libraries!

With our new GDScript plugin, you get the full brainCloud backend experience right in the language you already love:

• User authentication & profiles
• Cloud save & player data
• Leaderboards & matchmaking
• In-app purchases & economy
• Real-time multiplayer
• Push notifications & more

And to help you hit the ground running, we've built the Godot version of our Cursor Party demo app: a ready-to-run project showing GDScript + brainCloud in action. Grab it from the Godot Asset Library and start building today. 

Get the plugin: https://godotengine.org/asset-library/asset/5196

GD Script Cursor Party Demo: https://github.com/getbraincloud/examples-godot/tree/master/RelayTestApp-GDScript

Multiplayer & Hosting

i3D.net FlexMetal

Building on our i3D.net Orchestrator integration, brainCloud 6.0 adds support for i3D FlexMetal hosting, providing developers with access to bare-metal servers for brainCloud applications.

Our FlexMetal integration integrates deeply with brainCloud, supporting:

• Lobby Matchmaking
• Room Servers ← provide your own container image
• Relay Servers ← use brainCloud Relay Servers and RelayComms API
• Server Monitor ← monitors the launched FlexMetal servers.

More Lobby control

We’ve been gradually enhancing our Lobby APIs to support different player scenarios. 

The following enhancements are present in this release:

•  New CreateLobbyWithConfig() calls support overriding the team objects of an individual lobby. Useful if a player wants to limit their match to a different # of players than the lobby default
• Players can join during the starting phase of a match when Join-In-Progress is enabled

More Room Server control

This API allows devs to have greater control over the images used for their Room Servers:

• New call, SysUpdateRoomServerImage(), to update a Room Server's Docker image.

Marketplace

We have also been working on improving our Marketplace services. In addition to the new Lobby Campaign system, you’ll notice the following improvements.

• Archiving Products & Promotions

  • Deleting products and promotions has always been an issue, as you lose valuable revenue data. But keeping the old, no-longer-available Products and Promotions around makes them difficult to manage.
  • Our solution? Archive them! Now you can Archive Cash Products and Promotions – and they will disappear from your lists - but they are still there in case your reports refer to them [and customers restore purchases related to them]

• Auto-promotions can now target existing segment members

  • A new "Applicable Members" option lets a promotion apply to both existing and new members in a segment (previously, only new entrants).

• Per-platform bonus rewards 

  • Now, customers on Apple can get an iOS-branded decoration, while the Google Play Store players get an Android-specific decoration. You can also configure bonus currency payouts per store.  

Platform Support

Steam

• Updated Steam authentication - requires new Steam Identity setting on the Steam tab of App > Design > Core App Info > Application IDs page. New compatibility flag.
• Subscription (recurring billing) support - new and now supported
• Default-currency support ← set the default currency on the Steam tab of the App > Design > Core App Info > Application IDs page.

VisionOs

• Apple's visionOS is now a first-class platform on both server and portal, with clearer product-key labeling for visionOS keys.

PlayStation Network

• Updated Network Architecture support

App Alerts

App Alerts is the name we use for the warnings we show in the Alerts section of the App Dashboard.

Up until now, you had to log in to brainCloud to see them.

brainCloud 6 adds the ability to email these alerts to you!

Just go to the App > Design > Core App Info > Alerts page to add your email - or better yet, add the email for a team distribution list or a Slack channel.

Auto-Reconnect

We are sure this little feature will have some fans.

Enabling the new auto-reconnect in your client reduces the pain of ensuring the brainCloud session is still alive - especially useful as the user moves in and out of the app during their day.

Just call EnableAutoReconnect(true) after initial app start-up and authentication.

Portal Changes

We continue to polish the Portal with every release. The following areas of the portal got some extra love for this release:

App Management

The Team > Manage > Apps screen now provides additional context about your app’s consumption under its current plan. The bars will tell you when it makes sense to upgrade to the next highest plan. 

As you can see from the image:

• The development apps are well within their DAU and Total User limits
• The production app should be upgraded to a higher-level plan!

And if/when you choose to upgrade your plan, you’ll find more information to help you make the right decision.

Deployments

We have reworked the App > Admin > Deployment (and Import/Export) screens to be more instructive about which data will be migrated and when to use the Preserve/Exclusion options.

And the deployment screen will now remember the most recent deployment options you used, easing the drudgery of re-choosing the correct options for your development process each time.

There is even a new Item Catalog deployment tab that deploys only the Item Catalog data.

LiveOps Section

We’ve reorganized our key LiveOps systems underneath a new sub-menu. So now you will find:

• LiveOps Campaigns
• Promotions - both Automated & Scheduled
• Redemption Codes

All under the new App > Design > LiveOps section of the App menu.

Personalized Pricing

We have enhanced the Personalized Pricing page to support LiveOps campaigns.

So this is now the key screen to use when debugging the impact of Promotions and LiveOps Campaigns on the offers your end users experience.

Recent Errors

We have added some great improvements to the App > Global > Logs > Recent Errors screen.

These include:

• Improved Filter controls
• Recent Filters list - with the ability to pin favorites
• Exports! Export up to 10K lines of your current filter

Plus, we’ve made the screen prettier, too!

Note that these same enhancements also made it to the User > Summary > Recent Errors screen!

There were also changes to the following screens:

• App > Design > AI - new menu housing brainBot and AI settings.
• App > Design > Admin Tools > Deployment - redesigned for clarity, with separate Complete and Item Catalog deploys and improved dependency precondition checking.
• App > Design > Admin Tools > Configuration Data - reworked into separate Import and Export tabs, matching the new Deployment layout.
• App > Design > Cloud Code > Script Editor - improved syncing of changes (by other team members/tools)
• App > Design > Cloud Data > Global Properties - new Markdown property type, isSecret support, and category filtering when selecting properties.
• App > Design > Cloud Data > Segments - Segment Code field with guidance, AND/OR condition groups, and searchable dropdowns.
• App > Design > Integrations - new i3D FlexMetal integration.
• App > Design > LiveOps > Campaigns - the new campaigns experience, including the creation wizard.
• App > Design > Marketplace > Cash Products - type chips, search/filtering, archived-state treatment, and a refreshed edit dialog.
• App > Design > Marketplace > Promotions - archive/unarchive, status chips, and the new "applicable members" auto-promotion option.
• App > Reports > Analytics > Retention - 60-Day Retention minicard (Enterprise) and the D14 default card.
• App > Reports > Usage - AI usage on the API Usage and Monthly Summary screens; improved bulk-operations display.
• Team > Setup > Team Info / Billing - billing moved to its own page, redesigned team info, expanded Fusebill details, and complimentary-plan display across billing tabs.

API Changes

The following changes/additions affect the brainCloud API:

• AppStore

  • GetEligiblePromotions() - now includes eligible LiveOps campaigns for the user (with segment codes where applicable).

• Authentication

  • AuthenticateSteam() - updated to newer, non-deprecated Steam APIs. Note that there is a compatibility flag to preserve compatibility with existing apps.
  • AuthenticateGameCenter() - new API with improved security. Note that there is a compatibility flag to preserve compatibility with existing apps.

• Campaign - new service for LiveOps Campaigns

  • GetMyCampaigns() - returns the calling user's eligible LiveOps campaigns
  • SysTriggerCampaignForUser(), SysRemoveCampaignForUser(), and SysRemoveAllCampaignsForUser() - used for triggering / removing campaigns for test users 
• Client
  • EnableAutoReconnect() - enables the new auto-reconnect feature

• Lobby 

  • new CreateLobbyWithConfig() and CreateLobbyWithConfigAndPingData() calls that take a configOverrides (JSON) object that can be used to override certain settings of the lobby for this particular match
  • new join reason codes LOBBY_TEAM_FULL (40612) and TOO_MANY_USERS_FOR_LOBBY_TYPE (40624).

• Segments 

  • segment-targeting APIs now accept either a numeric segment ID or a segment code. Behavior is unchanged for existing integrations; codes are recommended. Cloud Code can be locked to codes via the acceptLegacySegmentIds compatibility flag.

    • Push Notification (Cloud Code & S2S) - send/schedule-to-segments calls such as sendRichToSegments, sendRawToSegments, sendNormalizedToSegments, and scheduleRich/Raw/NormalizedPushNotifications.
    • Script (Cloud Code & S2S) - runBatchUserScriptForSegments and the scheduleBatchUserScript...ForSegments variants.
    • Segment config (design / Builder API) - read / create / update / delete accept a segmentCode in place of segmentConfigId.
    • Promotions - support segment codes (segment-code matching on player refresh).

• Tournament

  • New Tournament service APIs for group play:

    • JoinGroupTournament() / LeaveGroupTournament() — enroll or withdraw a group from a tournament on a group leaderboard
    • GetGroupTournamentStatus() — retrieve the tournament timetable, configs, and the group's enrollment status
    • PostGroupTournamentScore() / PostGroupTournamentScoreWithResults() — post a score on the group's behalf, optionally returning the surrounding leaderboard results
    • JoinGroupDivision() / LeaveGroupDivisionInstance() — enroll a group into a division set (brainCloud assigns it to a division instance) or remove it
    • GetGroupDivisionInfo() / GetGroupDivisions() — query division set info for a group and list the group's active, pending, and completed divisions
    • SysGetGroupDivisions(), SysJoinGroupTournament(), SysLeaveGroupTournament(), SysJoinGroupDivision(), SysLeaveGroupDivisionInstance() — cloud-code system variants for managing tournament/division membership without membership checks

• PlayerState

  • New calls to allow programmatically resetting the sessions for a player; optional concurrent-session control/session locking: SysInvalidateAllButCurrentSession(), SysInvalidateAllSessions(), SysInvalidateAllSessionsForUser(), SysInvalidateAllSessionsForUserExcept(), SysInvalidateCurrentSession(), SysInvalidateSessionForUser()
  • Renamed UpdateName() → UpdateUserName() in select client libs that were out-of-sync.

• RoomServer (S2S)

  • LAUNCH_SERVER renamed to SYS_LAUNCH_SERVER, and its scriptId parameter is now scriptName for easier use.

Libraries and Examples

Client Libraries

All Libraries

• Group Tournaments & Group Divisions APIs - full set on the Tournament service (join/leave/post-score for group tournaments; get/join/leave for group divisions).
• Campaign service - new GetMyCampaigns() call for LiveOps Campaigns.
• Lobby config & ping - CreateLobbyWithConfig() / CreateLobbyWithConfigAndPingData() and a getPingDataSnapshot() accessor.
• RTT auto-reconnect - enableAutoReconnect() plus register/deregister callbacks, so long-lived sessions transparently re-authenticate after a drop (formerly "long session").
• Request compression - compressIfLarger threshold check.
• Refreshed reason codes, service names/operations, and 2026 copyright headers.

Unity, C#, and Godot

• UDP Relay handshake stabilized across Unity, Godot, and Xamarin (fixes silent UDP connect failures on Godot and under network latency on Unity/Xamarin).
• Game Center authentication updated for the new server call.
• Deprecated functions marked obsolete and removed; DLLs now built without deprecated functions.
• New.unitypackage build/release pipeline.

C++

• getPingDataSnapshot() on the Lobby service (thread-safe), returning a region-to-ping map; more performant ping handling.
• cURL loader reworked to reuse the curl handle/connections (Linux connection-cleanup fix).

Java & Android

• Campaign service added to the Android wrapper; createLobbyWithConfig / ...AndPingData; auto-reconnect re-authentication callback; compressIfLarger.

JavaScript

• Group Tournament APIs, getMyCampaigns, ping-data access, and auto-reconnect (enableAutoReconnect + callbacks); latest API additions and reason codes.

Objective-C

• Group Tournament APIs.

• SAMKeychain Dependency integrated into the client to support VisionOS

  • You may need to update code references

    • #import "SAMKeychain/SAMKeychain.h" → #import

  • You may need to add Build Settings to locate the required new headers.

    • $(PODS_ROOT)/BrainCloudCpp/Include/brainCloud/internal/Apple

• Minimum OS deployment targets were raised or added

  • iOS 12.0 → 15.0
  • MacOS 10.13 → 13.0
  • tvOS 12.0 → 15.0
  • watchOS 4.0 → 8.0
  • visionOS 1.0 * New

Unreal

• "Long session" renamed to auto-reconnect; fixes for UE 5.6+ on macOS.

Roblox BETA

• Designed to be intuitive, developer‑friendly, and aligned with Roblox's client‑server model. 

  • Requires HTTP Service and Studio API Services. 
  • Real‑time socket and relay features are limited by Roblox platform constraints.

• Now supports all of: 

  • Authentication tied to Roblox UserId 
  • Tournaments, leaderboards, achievements 
  • Cloud player data storage 
  • Virtual economy and item systems 
  • Cloud Code for secure server logic 
  • Messaging, notifications, and in‑game mail 
  • Analytics for behavior, retention, and monetization
• Get the new brainCloud Roblox Plugin for your Roblox development environment here: https://create.roblox.com/store/asset/132685604407597/brainCloud

S2S Libraries

• Global File upload via S2S - SysUploadStream / Global File Service added to the C++, Java, C#/.NET, and Node S2S libraries.
• C# S2S - RTT comms / WebSocket support refactor.
• Unreal S2S - structural refactor, secret obfuscation in logs (on by default), and a request builder with operation/param/service-name constants.
• Node S2S - Pre-Launch Ready support (server accepts pre-launch ready).

Example / Demo Libraries

•  Cursor Party (Relay Test App,RTA) - a unified cross-platform refactor across C++, C#, Java, JavaScript, Unity, and Unreal, now displaying Ping Region data in-game; Unity adds a 4-player Play Mode scenario, and colors are driven from a global property. Updated display with cloud-driven colors, splat effects, and a new icon. Updated Auto Ping Regions across lobby types within C++.
• BCFishnet (Unity) - lobby pin support; C# S2S RTT support example.
• Pre-Launch Ready (PRL) support and documentation across the JavaScript/Node demos.
• Marketplace - Focused on Marketplace features, demonstrating items, bundles, cash products (IAPs) and subscriptions, as well as user experience and levels, status effects, etc.

Documentation and Tutorials

• All API additions and changes are documented at docs.braincloudservers.com.
• In addition, we have now added both Roblox and GDScript code samples for all API methods to the docs.
• The Cloud Code scripting guide is updated to cover segment-code usage and the per-app compatibility flag. 

Updated Terms of Service

Alongside the platform launch, we've updated our legal and policy documents to reflect what brainCloud 6 actually does. These updates take effect Monday, June 22, 2026.

Everything lives in our new Trust Center:
https://getbraincloud.com/trust/ 

What's changing

Terms of Service - Updated to cover AI services, beta features, and a cleaner structure overall. The core commercial terms (governing law, liability, payment) are consistent with what you're used to.

Privacy Policy - Updated to reflect AI data handling and modernized privacy rights. The key commitment: brainCloud will never use your data or your users' data to train AI models.

Data Processing Agreement - Updated with formal schedules and the same no-training commitment for AI. If you've signed a separate DPA with us, the new version supersedes it.

Cookie Policy - Broadened from EU-only to global.

Service Level Agreement, Acceptable Use Policy, and Subprocessor List - Updated to reflect brainCloud 6 and current operational practices.

New documents -  We've also added a Security Overview, Vulnerability Disclosure Policy, Support Agreement, and Deployment Responsibility Matrix for customers who need them for procurement or compliance purposes.

What you need to do

Nothing urgent. Continuing to use brainCloud after June 23 constitutes acceptance of the updated terms, consistent with our existing Terms of Service. If you have questions about any of the changes — particularly the DPA if you're subject to GDPR or similar regulations — feel free to reach out via the email address listed in the Trust Center.

Executive Summary

brainCloud 6 is bringing a bunch of improvements to segments. As part of those improvements, we are replacing the existing Segment IDs, which are auto-generated numeric IDs, with Segment Codes, which are short alphanumeric codes that you pick.  (See later sections for rationale)

The important thing to note is that you have until the end of the day on Friday, June 5th, to set these codes - after which the system will auto-generate the codes for you! [And codes cannot be changed once set].

Tips when setting the codes:

• Codes are lowercase and limited to 12 alphanumeric characters. Letters, numbers, hyphens, and underscores allowed. No spaces.
• Try to pick meaningful names: “newbies”, “lifers”, “payers”, etc.
• Ensure that the codes in the Dev and Prod versions of your apps match up! That’s the whole point of this change - is to improve segment deployments!

Background

Segments in brainCloud have long-used Segment IDs, which are auto-generated numeric IDs. The first segment created is 1, the second is 2, and so on.

This simplistic system works fine - until you start really getting into segments - and start creating them in the prod instance of your app separately from the dev instance of your app.  Even if you remember and go back to the dev instance of your app to backfill them, you’ll often find that the segment IDs in the two app instances don’t match up!

So, for instance, your “Players” segment for players who have spent more than $0 – might have a segment ID of 2 in the live version of your app - but 3 in the dev version of your app!  

This wreaks havoc if you deploy from Dev → Prod, as the Dev segments will overwrite the Prod segments - and it takes a day for the segment membership to catch up!   

The Solution - Segment Codes

Segment Codes are our solution to this problem. They are short 12-character codes that uniquely identify a segment. Because they are manually set, it is easy to keep them in sync between Dev and Prod.

This makes for better code as well - triggering the push notification job to a particular segment is easier to understand with a meaningful Segment Code instead of an arbitrary Segment ID.

API Impact

Note that from an API perspective, Segment IDs will continue to work. That said, we are extending all API calls to work with Segment Codes as well, and we encourage everyone to move to that mechanism.

Deployments

Finally, we are adding a new option to exclude Segments from deployment. Segments are more of a LiveOps domain element than an app design concern, so we are extending the Deployment system to allow Segments to be excluded from Deployment in the same way that Cash Products, Promotions, etc. can be now.

We are starting 2026 with a bang!  This release is packed with popular requests: Inventory Bundles, i3D.net Hosting, Meta Horizon IAP, StoreKit 2, Visual Studio Code, and heck - even Roblox! There is something here for everyone!

Compatibility Notes

We prioritize preserving stability and backward compatibility for existing apps. 

⭐ Unity Developers should be aware that the 5.9 version of the Unity Plugin has been completely rewritten - and now requires the [x] Builder API access permission to be enabled on the Team > Setup > Team Info page.  Note that this permission must be enabled by a Team Administrator.

Also, as a security improvement, we have changed the response that is returned by the Authentication Service’s Reset Password calls. These calls will now always return a status: 200 response, even if the targeted account does not exist.

A new compatibility flag has been added to control this feature. It is enabled by default for existing apps (to preserve the old behaviour).  For optimal security, app developers should disable this setting.

[ x ] Support legacy reset password failure response (includes reason for failure, for example: "credential not found").

Release Highlights

Bundles (and other Item-related Enhancements)

We have [finally!] added support for Bundles to our Catalog system. Bundles can contain multiple Items and collections of Virtual Currencies. Which means that Bundles can double as a convenient mechanism for Currency Exchange - e.g., to exchange 1 bar for 100 coins.

We have also added the ability to put Catalog Items and Bundles “on sale” via our Promotions system.

Finally, we have enhanced Items (and Bundles) to allow the system to enforce a Maximum Quantity of an Item (or Bundle) that a user can own. 

Bundle features

• Bundles are defined via the Item Catalog service - and managed via the User Items service 
• Bundles can contain multiple Items and/or Currencies [but not other Bundles - this is not Inception!]
• Bundles can be purchased, awarded, and/or traded with others
• Bundles can be awarded anywhere that Items are currently awarded in the system 
• Bundles must be opened to get their contents. A bundle is destroyed upon opening it.

Catalog Promotions

• Promotions may not include special pricing (in virtual currencies) for Items and Bundles
• Promotions can also make Items/Bundles available for sale for a limited time
• As part of this feature, the Item Catalog system can now properly distinguish between free and not-for-sale items.

Max Quantity

• Devs can now set the maximum quantity of an item that can be owned by a user
• Note that this capability is limited to “Stackable” items.  To limit the quantity to 1, set the item stackable and the max quantity to 1.
• Note that when using the Trading APIs, items/bundles with a max quantity set must be traded with the immediate option, as we can’t enforce max quantity if the trade is deferred.  [Max-quantity items can, of course, still be traded by custom means.]

Multiplayer & Hosting

We also have several multiplayer and hosting enhancements in this release!

i3D.net integration

You may not know i3D.net - but chances are you have played games on their servers. Ubisoft, EA, Hi-Rez, and more are among the many companies whose players compete via i3D.net’s high-performance global network and hybrid “bare metal cloud”.

And now, brainCloud devs can too! 

To take advantage of our new i3D.net integration:

• Set up an account with i3D.net - and configure your hosting via i3D Orchestrator
• Configure the i3D.net integration on the App > Design > Integrations > Manage Integrations page
• Create an i3D.net Orchestrator server type via the App > Design > My Servers page
• Link that server type to your Lobby via the App > Design > Multiplayer > Lobbies page

And voila - your brainCloud lobbies will now launch servers on i3D.net!

Faster lobby launches

Whether you are using brainCloud’s built-in hosting or the services of one of our hosting partners, apps can now start launching servers while players are still in the lobby! Depending on how quickly your lobby fills, this can shave 5-20 seconds off launch time!

brainCloud’s v3 Protocol Relay Servers have been updated to support this new feature. Games with custom Room Servers will likely need to make a few modifications to ensure their servers launch (and wait) before players begin connecting.

Game clients aren’t heavily affected, but they may receive fewer launch progress messages as the server would have started launching before the lobby reached the starting state.

Roblox Support [beta!]

brainCloud does Roblox now?!!  Yes, we do!

Late last year, some developers approached us to ask whether brainCloud’s services could be made available to Roblox game developers. We hadn’t really considered it before - but we are always up for a challenge!

We are thrilled to present the culmination of a whirlwind couple of months of hard work. Roblox developers can now access key brainCloud services, including cloud saves, leaderboards, tournaments, gamification, groups, deep data, the item catalog, and more. All core services are available, except RTT itself, as we haven’t yet figured out how to integrate a bidirectional WebSocket in Roblox.

So - Roblox devs - come check us out! Our à la carte feature set and API-based pricing are perfect for games that want to add a feature or two!

In-App Purchases

Devs are always looking for more ways to monetize their apps - while maddeningly, the store APIs keep changing!

We are pleased to bring the following new & improved app store updates to brainCloud:

• Meta Horizon Platform IAP - brainCloud now supports in-app purchases for Meta’s Horizon ecosystem
• Apple StoreKit 2 - brainCloud now supports Apple’s StoreKit 2 APIs
• Google Play One-time Products API - brainCloud also supports Google’s One-time Products API; technically, this was added in a 5.8.5 patch

Visual Studio Code Extension [beta!]

Although this was released late last year, it is still worth mentioning.  For the devs that don’t already know - brainCloud now has an official Visual Studio Code Extension!

The extension securely connects to brainCloud and lets you work on your brainCloud scripts directly in Visual Studio Code. And you get access to all your favorite Visual Studio Code features - including AI assistance!

So look for “brainCloud Cloud Code FS” in the Visual Studio Code marketplace – and be sure to give us a star!

Additional Improvements

brainCloud 5.9 also includes:

• Global File Uploads

  • Our S2S API now supports the uploading of global files
  • Note that these new APIs have not yet been added to our S2S client libraries, but they are available to developers who want to make S2S calls directly.

• Session Durations (Bonus!)

  • Apps that use RTT will now notice that brainCloud is tracking player session times. 
  • These durations can be viewed on the User Activity screen and in the User Context Banner, which shows the average session duration.
  • Note that apps that don’t use RTT can still notify the system that a session is complete by calling the PlayerState.Logout() method when the player leaves the app.

• Tournament Completion Scripts

  • Ever wanted to trigger a custom script when a tournament completes? Now you can!  

• [Improved] Unity Plugin

  • There is an improved Unity Plug-in. It’s more secure - and works better with private brainCloud deployments. 

Portal Changes

We continue to improve our Portal with each release.

Item Catalog

The Item Catalog screens have been completely refactored to not only add support for Bundles but also improve overall workflow.

Promotions & Personal Pricing

The Promotions and Personal Pricing screens have been significantly enhanced to support Items/Bundles and improve the overall workflow.

Cloud Code Editor Improvements

We have added several quality-of-life improvements to our Cloud Code Editor. These improvements include:

• Improved Tab UI: It is now easier to tell which tab is active, and the editor now properly restores the active tab when you return to the Editor from another screen.
• Better sync: the editor now highlights when a script has changed while the user is viewing it. If the script isn’t currently being edited, the view will automatically update to the latest version.
• Control-S, Alt-S - the editor now supports common keyboard shortcuts to save the current script

DataStream Improvements

We have made significant improvements to the User DataStream screen and also added a new Global DataStream screen.

Additional Improvements

The following sections of the portal have also seen significant improvements:

• App > Dashboard

  • Has been improved and reorganized to put the most important information front and center.
  • Includes a new Calendar widget to show currently active events.

• App > Calendar

  • Long-term events (i.e., >365 days) are hidden by default. This allows devs to focus on managing day-to-day events.

• App > Design > Core App Info > Application IDs

  • The new Apple StoreKit2 settings can be found in the Apple tab
  • The new Meta Horizon and Rift settings can be found in the Oculus tab

• App > Design > Cloud Data > Global Properties

  • We improved inline property editing.

• App > Design > Integrations > Manage Integrations

  • The page has been redesigned to be easier to use. 
  • Also includes the new i3D.net integration settings.

• App > Design > Multiplayer > Lobbies

  • Added the new pre-launch option to the lobby Rules tab.

• App > Design > Servers > My Servers

  • Added the ability to create i3D.net server types.

• App > Global > Logs > Job Queue

  • Added the ability to filter by Job Type.

• App > Groups > Groups > Groups

  • Preview Blade - Added the ability to jump to Group Entities and Group Files for the selected group.

• App > Groups > Group Files

  • A new screen that allows portal users to view and manage group-owned files.

• App > Reports > Usage > API Usage

  • File uploads are now displayed separately from File downloads.

• User > Marketplace > Inventory

  • Updated to support Bundles.

• User > Marketplace > Personalized Pricing

  • Updated to support Catalog Promotions. See the Items & Bundles tab in the Offers section.

API Changes

The following changes/additions have affected the brainCloud API:

• Authentication

  • For improved security, the Reset Password APIs - i.e. ResetEmailPassword*() and ResetUniversalId*() now always return status: 200 – even if the accounts targeted do not exist. The old behaviour is still supported via a new compatibility flag, which is enabled by default for existing apps.

• Global File

  • Now supports direct file uploads via the S2S API.  [Before, devs needed to upload User Files via the Client API and migrate them to Global Files.]
  • The process is similar to uploading User Files. Call SysPrepareUpload() to receive an URL that can be used when performing the upload.

• Group

  • Several group-related APIs, including GetMyGroups(), have been enhanced to return the group version field for convenience

• User Items

  • AwardUserItemWithOptions() - Allows item(s) to be awarded to a user without collecting the purchase amount. Includes an optionsJson field that can be used to specify how the system should respond if the player already has the maximum quantity of an item.
  • GetItemsOnPromotion() - Returns a list of items that currently have promotional pricing for the current user
  • GetItemPromotionalDetails() - Get promotional details for the specified item definition
  • PurchaseUserItemWithOptions() - Purchases a quantity of an item from the specified store. Includes an optionsJson field that can be used to specify how the system should respond if the player already has the maximum quantity of an item.
  • OpenBundle() - used to open a bundle, depositing the contents into the user’s inventory.

Client Libraries

All Libraries

• New User Items APIs: AwardUserItemWithOptions(), GetItemsOnPromotion(), GetItemPromotionDetails(), PurchaseUserItemWithOptions(), OpenBundle()

• Exposed Constants:

  • Operation Param
  • Service Name
  • Service Operation
  • Reason Codes
• Updated all copyrights to be correct and consistent.

Unity, C#, and Godot

• Exposed constants were updated to use readyonly struct data structure
• Meta Quest devices will set the platform to OCULUS for brainCloud authentication
• Optimized the response processing, which was more apparent during large responses

Objective-C

• SSKeychain has been deprecated; was updated, and replaced with SAMKeychain

Roblox - Lua (Beta!)

• New brainCloud-roblox Client- Plugin

  • The experience must be “published” to Roblox in order to gain access to the Data store for users to seamlessly log in with Roblox.
  • The experience must be configured with Studio Access to API Services - Enabled.
  • Allow HTTP Requests as well to communicate with brainCloud.

• Known Limitations

  • Real-Time Technology

    • Persistent socket connections to brainCloud servers from Roblox clients and servers are currently limited.

  • Relay Servers

    • Relay-based multiplayer functionality is constrained by the same real-time connection limitations.

  • File and Group File Uploads

    • Multi-part upload streams are not currently supported in Roblox.

  • App Store Service

    • Has not been fully tested or confirmed

  • Authentication

    • Not all identity types have been fully tested.
    • A Universal brainCloud UserId is generated from the Roblox UserId to streamline player login.

S2S Libraries

Example/Demo Libraries

• Cursor Party - i3D support

• Updated Authentication Unity example

  • Added Game Center authentication support
  • Added Steam authentication support
  • Updated Google OpenId support

• New AuthenticationOculus Unity example added

  • Intended for Meta Horizon devices on Windows (via Meta Horizon Link) and Meta Quest
  • Showcases Oculus Authentication
  • Showcases Marketplace support with Consumable, Durable, and Subscription purchases on Meta Quest devices

• New BCFishnet - Collaborative Canvas Unity example added

  • Includes authentication, long-lived lobbies, host merging when the active host drops during gameplay, and join-in-progress support.

• New BCKart - Photon Unity example added

  • Extended an existing Photon sample with brainCloud authentication, lobby management, and leaderboard integration.

Documentation and Tutorials

Documentation

• All the latest API additions and changes have been incorporated into our documentation at docs.braincloudservers.com

Back to school with brainCloud!

Our new Classroom Invites feature makes it easy to set up a class of budding developers. Get organized with our new App Calendar! Plus Steam Ownership Checks, IAP Improvements, Push Optimizations, and more!

Compatibility Notes

brainCloud prioritizes API stability and backward compatibility for apps. The following configuration flags control key brainCloud 5.8 behaviours:

• Compatibility flag: Allow purchases without requiring a developer payload or cached purchase context. Defaults to ON for existing apps, OFF for new apps.
• Steam Platform setting: Steam Verify App Ownership. Defaults to OFF.

Release Highlights

Classroom Invites

We have supercharged our Team Member invitation system. 

Not only can you now invite multiple team members at once, but we have also added the ability to quickly set up a student classroom, with each student getting their own personal app to work on. We even support importing team lists from .csv files.

brainCloud has always been great for student learning - now it’s even easier to get started.

App Calendar

This release adds a new Calendar view for apps. The Calendar automatically surfaces important initiatives like scheduled Redemption and Promotion campaigns.

It’s also a great place to note important dates like Soft Launches, New Feature Releases, Advertising Campaigns, etc.  Just click the [+] button to add a new entry to the calendar.

If you are expecting a significant traffic surge associated with a new launch or promotion, you can give the brainCloud Ops team a heads up!

We will be building upon our Calendar system significantly in the coming releases - so stay tuned!

Improved IOS and Android In-App Purchases

We’ve had some complaints over the years regarding some limitations on the use of In-App Purchase price/item IDs – which are the codes that you define in iTunes Connect or Google Play for various IAP price points for your products.

[Note - the purchase interactions for other stores are different. Only the Apple and Google Play stores are subject to this limitation.] 

The complaint is that developers cannot effectively reuse these codes across products. So if I (a dev) want to sell “Apples” for 1.99, and “Oranges” for 1.99 as well - I need to create two separate codes in the various app stores (“applesregprice” and “orangesregprice”) instead of re-using one shared code between them (e.g. “fruitregprice199”).

The reason for this is due to the context information that we can derive from the receipts. Basically, we are only receiving the IAP item ID from the store - and thus if you re-use the price in multiple places - we cannot tell what product a customer had purchased (and therefore what rewards to award the user). This situation only gets more complicated when Promotions (Sales) are involved.

We’ve been working to address this challenge - and 5.8 offers some relief - in two parts:

• First of all, the AppStore.GetSalesInventory() call now returns a new “payload” field for each IAP product. This field contains important context information that can be used to derive the user's purchase more accurately.
• The client app can now cache this context information to be used when processing a user’s IAP purchase. Simply call the new CachePurchasePayloadContext() method right before performing an Apple App Store or Google Play purchase, and brainCloud will automatically use the additional context information when processing the purchase receipt.

We highly recommend that all devs adjust their IOS and Google Play purchase flows to cache the new payload context. In the meantime, though, processing of the purchase context is optional as long as the new [x] Allow purchases without requiring a developer payload or cached purchase context compatibility flag is checked.  

Steam Ownership Check

brainCloud’s Steam Authentication has been upgraded to [optionally] confirm that the player owns the game that they are logging into.

To enable this validation, go to the Steam settings section of the App > Design > Core App Info > Application IDs page, and enable “Steam Verify App Ownership”.

Local Datastream

Up until this release, our Datastream system was limited to streaming analytics events to external systems (via Segment or Kafka). 

brainCloud 5.8 adds a new Local Datastream feature - that allows datastream events to be cached locally for a period of time (90 days by default) - for use in deeper analytics by brainCloud itself.

We will be building upon this new capability in future releases. Stay tuned!

Additional Improvements

This release includes many other improvements.

These include:

• App Alerts - Max Server Nodes Reached

  • brainCloud will now raise an alert if the “Max Server Nodes” setting is preventing additional servers from launching.  

• App Icon and Deployments

  • We no longer overwrite the App Icon of the target app during deployment. This change allows devs to more effectively use unique icons for different stages of their app [eg. Dev vs. Staging vs. Production] 

• External Authentication Improvement

  • We have extended the External Auth mechanism to allow auth scripts to set the user’s identityData.  

• Push Notification Optimizations

  • We have refactored our Push Notifications framework to improve performance for Apple and Google push notifications. These optimizations affect both push notifications sent to all users and notifications sent to specific user Segments.
  • Note that there were no API changes associated with these optimizations. 

• Security Improvements

  • Several security improvements have been made to the Portal UI and the underlying portal service calls.

• Server Launch

  • Our new Server Launch API allows devs to launch servers outside of Lobby processing.

Portal Changes

We continue to rapidly evolve and improve our Portal. 

Calendar Screen

As introduced in the Feature Highlights section, our new Calendar screen is front-and-center in the Portal - located just under the Dashboard for your apps.

You’ll actually find multiple views of your Calendar entries here - one in the standard Calendar view, but also a List view that presents the entries in a simpler format (that also works for mobile devices).

Additional Improvements

The following additional portal improvements have been made:

• Chart Colors

  • We have adjusted the colors used for dev-defined items (like Products) to be more attractive  

• App > Design > Cloud Data > User Statistics

  • Stats are now displayed in alphabetical order!

• App > Design > Core App Info > Advanced Settings, Compatibility Settings

  • New “Allow purchases without requiring a developer payload or cached purchase context” flag.

• App > Design > Segmentation > Segments

  • The criteria list is now searchable

• App > Design > Promotions > Scheduled

  • Portal users can now Clone scheduled promotions.
  • The preview blade now shows only the IAP Product prices that have changed.  This change applies to Automated Promotions as well.

• App > Reports > Analytics > Product Category

  • A new screen that breaks down how your IAP sales are going on a category basis.

• User > Data > User Files

  • Portal devs can now upload user files directly from the portal. This is useful in some debugging and corrective scenarios.
  • Screen columns were also re-ordered to be more useful

Plus, for our Private Licensees:

• Super > Manage > Manage Members

  • The member list now shows the difference between regular and read-only Super users.
  • The Invite dialog has also been improved to differentiate it from the Team-scoped invite dialog

Note - in addition to the new screens and polish, we have also upgraded the underlying portal tech to React 18 (from 16). With this upgrade comes valuable code and performance improvements (and the reduction of technical debt) - but it does mean that there is a greater than normal chance of regressions across the Portal. Please report any issues to support if you encounter them!

API Changes

The following changes/additions have affected the brainCloud API:

• AppStore

  • New CachePurchasePayloadContext() call added to supplement Apple and Google Play receipt verification - providing additional context.

• Authentication

  • AuthenticateExternal() - the external auth script can now set the custom identityData JSON associated with the identity. 

• Leaderboard

  • Updated SysListLeaderboardConfigs() - now allows devs to specify the divSetId to query on if filterType is ”divisions”.  ← Makes it easy to find all division instances for a particular set

• RoomServer

  • The new RoomServer service has been added to allow direct launching of hosted servers. This service and its APIs are reachable by cloud code and S2S only.
  • The new SysLaunchServer() method is used to launch a server of the named server type (as defined in My Servers). The dev must provide the ID of a callback script to handle events as the server launches.
  • The service also includes additional calls to support server interactions: SysGetRoomMember(), SysRoomEvent(), SysRoomReady(), SysRoomSessionEnded() and SysRoomSessionStarted().

Libraries and Examples

Client Libraries

All Libraries

• New CachePurchasePayloadContext()  call added to the AppStore Service API
• Fixed a discrepancy in RelayService.SetPingInterval() to consistently use seconds instead of milliseconds
• Removed deprecated functions

Unreal

• Fixed compatibility with UE 5.6
• Deprecated the FindLobby() function that was still using the in_timeoutsecs parameter, replaced with FindLobby() function without that parameter

Examples

Unity

• Authentication Unity example added iOS Advertising Support as an option to enable full Facebook login
• Marketplace Unity example showcases CachePurchasePayloadContext for Android and iOS in-app purchases
• Tic Tac Toe now supports online matchmaking to find matches in real-time.

Documentation and Tutorials

Documentation

• All the latest API additions and changes have been incorporated into our new doc site at docs.braincloudservers.com !

We sat down with CEO Mohammad Agha and Lead Developer Tri Truong to gain insights into Magmic’s adoption of brainCloud as the primary backend of their games.

Part 1 discussed the decision-making process and benefits of moving to brainCloud.

In Part 2 we discuss the process of migrating their apps to brainCloud.

How did you approach migrating to brainCloud?

We started with an initial pilot of our Scattergories Blitz game.  

It took 2 to 3 months to integrate brainCloud into the game fully. Overall, the transition went smoothly, thanks to brainCloud’s well-documented APIs and responsive support team. 

One of the most essential services we leveraged was the Turn-by-Turn Async Multiplayer system, which was a perfect fit for our game. This feature enabled players to take their turns at their convenience, keeping the gameplay engaging and interactive. Additionally, brainCloud’s flexible backend architecture made it easy to integrate leaderboards, player data management, and matchmaking, ensuring a seamless experience for both new and existing players.

And after the pilot?

After the initial pilot, we began migrating our key titles to brainCloud, including Phase 10, Spite & Malice, Passport Rummy, and Idle Pet Paradise.

The migration process for our key titles proceeded relatively smoothly, with Phase 10 and Passport Rummy taking approximately 1 to 2 months to integrate with brainCloud fully.

For Spite & Malice, we leveraged brainCloud’s Replay Service (i.e. PlaybackStream API) to develop a robust multiplayer function, ensuring a seamless and engaging player experience. This enabled us to implement an asynchronous turn-based system, allowing players to replay past moves and strategize effectively.

In Idle Pet Paradise, we leveraged brainCloud’s Cloud Code to integrate a Web3 platform, enabling blockchain-based interactions such as NFT ownership and in-game asset management.

Did you encounter any hurdles during the migration, and how were they resolved?

During the integration process, one of the challenges we faced was querying large datasets in our game. Handling big data efficiently was initially difficult, as performance and response times became a concern. However, the brainCloud support team was incredibly helpful — they provided us with key insights, including best practices for using Custom Entities and how to optimize queries by adding indexes. With their guidance, we were able to implement a more efficient data structure, which allowed us to develop features related to big data without performance bottlenecks. Their support made a huge difference in overcoming this challenge and ensuring our game runs smoothly at scale.

Was there a specific capability that delivered above and beyond your expectations?

One capability of brainCloud that truly exceeded our expectations is its Real-Time Technology (RTT). It enables us to develop real-time games and instantly send messages to online players, resulting in a smooth and engaging experience. We successfully leveraged RTT in Spite and Malice and Scattergories Blitz to build turn-based gameplay with seamless player interactions.

Was the transition disruptive for your players?

Transitioning to brainCloud has been seamless for our players. When we migrated our backend, we ensured that player accounts, game progress, and in-game purchases remained intact, ensuring no disruption to their experience. brainCloud’s robust authentication and data management tools made the migration smooth, and players were able to continue playing without even noticing the backend change. The reliability of brainCloud also improved server stability, reducing downtime and ensuring a smoother gaming experience overall.

Has brainCloud enabled product improvements that benefit your players?

Absolutely! Moving to brainCloud has allowed us to introduce several new features that enhance the player experience. For example, we leveraged brainCloud’s Real-Time Technology (RTT) to enable faster matchmaking and instant in-game notifications. Additionally, its cloud-based leaderboard and analytics tools helped us fine-tune game balancing and personalize rewards for players. We also improved scalability, ensuring that the game runs smoothly even during peak hours or special events, without lag or connection issues. These improvements have led to increased engagement and a better overall experience for our players.

Has the usage-based pricing of brainCloud been good or bad for you?

Usage-based pricing resulted in significant overall cost savings. Magmic has a library of games in various stages in their life cycle, and usage-based pricing ensures that a game’s costs are proportional to the size of its active player community. 

Usage-based pricing also had an interesting side effect for Magmic: More optimized coding. 

Usage based pricing created an incentive for us to more intelligently make calls in batches so as to reduce the cost. It drove us also to write better server code, to optimize what code resided on the server vs. on the client. By optimizing our code in these areas, we have achieved even greater savings in usage. And the user experience improved too - it’s win:win!

[For more information on cost savings, see Part 1 of this case study.]

Has brainCloud affected your approach to building games?

Before integrating brainCloud, our development team was split into two separate groups — backend and frontend. This separation often led to communication challenges and slowed down feature development, as frontend developers had to wait for back-end engineers to build the necessary infrastructure before implementing new gameplay elements.

After adopting brainCloud, our workflow became much more efficient. Now, each Magmic developer can work seamlessly across both brainCloud and Unity, allowing us to implement new features without bottlenecks or dependencies on a dedicated backend team. This has significantly reduced development time and enabled faster iteration on ideas.

How has brainCloud impacted your team's overall efficiency?

brainCloud has significantly boosted our team’s productivity by streamlining backend development, allowing us to focus on what matters most: building great gameplay experiences. With its powerful backend-as-a-service capabilities, we can quickly implement new features without having to allocate extra resources to backend infrastructure. This has enabled our team to iterate more quickly, experiment with new ideas, and bring features to market faster. 

[Note - start time has been updated from 8pm -> 6:30pm Eastern.]

brainCloud BaaS will be upgraded to MongoDB 8.0 on Monday, July 7th, starting at 6:30 p.m. Eastern. This rolling upgrade may take up to 3 hours to complete. All API and Portal services will be fully available during the upgrade; the portal will NOT be disabled.

[Full disclosure: It will take longer than usual because we are first upgrading to MongoDB 7.0, and then immediately upgrading to MongoDB 8.0.]

Note that all brainCloud Private Instances will be upgraded in the weeks before the end of July 2025.

Compatibility

brainCloud 5.7 has been tested to be fully compatible with MongoDB 8.0.

Important Change (READ THIS!)

MongoDB 8.0 contains an Important Change that brainCloud developers must be aware of.

Starting in MongoDB 8.0, comparisons to null in equality match expressions don't match undefined values.

Consider the following table:

In MongoDB 6, a query for { "name": null } would return all 4 records, as per these conditions:

• The name field is null (_id: 1)
• The name field is undefined or contains an undefined array element (_id: 2 and _id: 3)
• The name field does not exist (_id: 4)

But in MongoDB 8, the query for { "name": null } only returns 2 of the records:

• The name field is null or contains a null array element (_id: 1)
• The name field does not exist (_id: 4)

Note that this change in query behaviour also affects $eq, $in, and $lookup operations.

For full details on MongoDB compatibility changes:

• MongoDB 7 - https://www.mongodb.com/docs/manual/release-notes/7.0-compatibility/
• MongoDB 8 - https://www.mongodb.com/docs/manual/release-notes/8.0-compatibility/

brainCloud Customer Impact

This change only affects brainCloud's list and paging-style calls (which accept custom query JSON) - and ONLY apply if the JSON data itself somehow had undefined values -- which would be pretty unusual.

The affected calls include:

• Custom Entity - GetEntityPage(), SysGetEntityPage()
• Entity - GetList(), GetListCount(), GetPage()
• Global Entity - GetList(), GetListCount(), GetPage(), GetSystemEntityList() GetSystemEntityListCount(), GetSystemEntityPage()
• Group - ListGroupsPage(), GetRandomGroupsMatching(), ReadGroupEntitiesPage(), SysGetRandomGroupsMatching(), SysListGroupsPage(), SysReadGroupEntitiesPage()
• Item Catalog - GetCatalogItemsPage(), SysGetCatalogItemsPage()
• Leaderboard - SysGetLeaderboardConfigsPage()
• Messaging - GetMessagesPage(), SysGetMessagesPage()
• RedemptionCode - SysGetCodeTypePage()
• User - SysGetPage()
• User Items - GetUserItemsPage()

So - this is ONLY an issue if:

• Your app has "undefined" values in its JSON entities
• AND it is querying on those fields with "undefined" values
• AND it is specifically querying those fields for "null" and expects "undefined" values to be included with the query results.

Take action!

If you do feel that this issue may affect your app, reach out to us in support with the following information:

• appId
• category of entity affected (eg, User, Global, Custom, etc).
• entityType field
• field name

We may be able to help you prepare the data so that "undefined" fields are replaced with "null" values to ensure that queries continue to work.

This release adds an improved Team Dashboard, Self-Service Delete & Branding, Node Resource Monitoring, Online Matchmaking Improvements, and more. It also readies the platform for MongoDB 8.

Compatibility Notes

All brainCloud releases emphasize preserving stability and backward compatibility for existing apps. That said, developers should be aware of the following changes:

• Lobbies

  • Join In Progress change

    • The system no longer allows additional members to be added to a lobby while it is in the STARTING state. 
    • If Join In Progress is enabled, new members can join once the lobby moves to the ACTIVE state.
    • This change addresses a race condition whereby it was possible for the lobby members to have "readied up" but for a new lobby member to be joined to the lobby in a non-ready state before the associated room instance was completely launched.

Release Highlights

Improved Team Dashboard

We have reworked the Team Dashboard to make it more useful (and prettier!), especially for teams with multiple apps.

Improvements include:

• New Live Apps widget - displays Daily Active Users, New Users, Revenue, and Purchase Count charts for the last 14 days
• New Recently Active Members widget - so you know who has been online in the system recently

Plus improvements to the look-and-feel of the existing widgets. 

Self-Service Branding

As a backend service, brainCloud provides very little UI for end-users. That said, we do provide a few web screens to:

• Verify email addresses
• Enable password resets
• Unsubscribe from tournament emails

The existing screens were functional but plain. brainCloud’s development community has been wishing for the ability to customize the look-and-feel of those screens.

And in 5.7 you get your wish! We have re-designed the screens and tied them to a new Self-Service Branding feature that controls their look and feel.  Using the new system, developers have a lot more control over the screens, including:

• Separate studio and app branding
• Control of header, background, font, and button colors
• Multiple header layout options
• Add custom buttons to screens
• Optional footer section - with links to privacy page, support, etc.
• And more…

The new App > Design > Self-Service > Branding page customizes this look and feel and features a Live Preview so developers can see how their choices will look in Mobile or Desktop browsers.

Self-Service Account Deletion

We built the branding feature (above) so that we could build this feature properly! 😀  

Some app stores (Google) now require that devs provide an URL for web-based account deletion. We have created this new feature to give developers a head start on that requirement. It’s a complete solution for apps using email identity and/or contact emails. Devs using other forms of authentication can use the new APIs and Portal functionality to satisfy the Google requirement.

Scenario 1 - For email-based accounts (fully automated)

The Self-Service Account Deletion feature provides an URL for end-users to delete their accounts.

To delete their accounts, end-users will:

• Navigate to the provided self-service deletion URL
• Provide the email address associated with their account
• The system will then send an email(s) to that address, with a link to click to delete their account. Note that multiple emails will be sent if there is more than one account associated with an email (which can happen with contact emails).
• The user receives the deletion email and clicks the link. Note that the link for account deletion is valid for a limited period of time ← set to 2 hours currently.
• The user follows the prompts to complete the deletion of their account.

Developers can enable and configure this feature from the new App > Design > Self-Service > Delete Account page.

A few important notes:

• The template used to create the email sent to the user is customized with the other Sendgrid email templates, on the App > Design > Authentication > Email Authentication page.  Instructions for creating a template can be found here.
• CSRs can also manually trigger the sending of the deletion email to users directly from the Portal. Choose “Send Deletion Email…” from the Action menu of the user's User Summary page.

Scenario 2 - API-based Automation (For non-Email Identity Types)

Devs can use this feature and associated APIs to build a custom site for deleting accounts. 

The use case would look something like:

• The custom site would prompt the user for their login info, and then, using brainCloud APIs, log in and retrieve the profileId of the associated account.
• The site would then call the new User.SysCreateSelfServiceDeletionUrlForUser() method to create a deletion URL.
• The site would then redirect the end-user to that URL so the user could complete the deletion steps.

Scenario 3 - Manual Via CSR (Customer Support Representative)

CSRs can support the deletion requirements via the new Design Portal features.

The use case looks something like this:

• A form or customer service application prompts the user for the information to identify their account.
• A CSR looks up the user’s account and navigates to the User Summary page of that user.
• The CSR then clicks the Copy Deletion URL… button on the action menu to create and copy the deletion URL for that user.
• The CSR then sends the end-user a response, with the URL to click on for the user to delete their account.

Node Resource Monitoring

The Server Monitor now allows developers to monitor the resource utilization of individual nodes. Including these metrics marks the Server Monitor’s graduation from [Beta] to official release!

Clicking on a node and selecting the Usage tab displays the following charts:

• Containers - the number of containers running on the node
• CPU - the % cpu utilization of the node (across all containers)
• Memory - the % memory utilization of the node (across all containers)
• Storage - the % storage used by the node

The CPU, Memory, and Storage metrics are retrieved from our New Relic monitoring system. There can be an initial lag of up to 5 minutes for newly launched servers in retrieving these metrics. The Container Count metric is received directly from our Room Server Framework via RTT. Still, there is no history, so the data is retrieved and available only while the Server Monitor screen is displayed.

Additional Improvements

brainCloud 5.7 includes a ton of other improvements as well. These include:

• App Alerts

  • We have added a new alert to warn users when their Tournament auto-claim settings are out of sync with the required compatibility flag.

• Builder API

  • The Builder API has been enhanced to support new Dynamic API Keys, which are dynamically created and are good for only 16 hours
  • Dynamic API keys can be created as part of the new SSO functionality that we have built into the platform.  

• Edgegap Hosting

  • The control of the skip_telemetry option is now configurable by devs. Previously, it was hard-coded  true for faster server launches (but at the expense of perfect placement of servers).

• GameLift Hosting

  • There is a new AWS EventBridge option for more scalable reporting of hosted server status. Configuring this is optional, but highly recommended for production deployments.

• Item Catalog Images (via API)

  • New API methods have been added to allow Item Catalog images to be set via Global or User Files. See the API section for more details.

• Online Matchmaking

  • Has improved support for adding groups of players to a lobby
  • Previously, all players would be placed on the same team if a team was specified in the matchmaking call, but if not, the provided players would be dispersed between the available teams.
  • The extension allows developers to ensure players are placed together on a team without having to specify which team.
  • See the API section for more details.

Portal Changes

This release adds some significant quality-of-life improvements to the Portal.

Live Lock

We have made the live lock more convenient. Devs can now drag the app’s name instead of re-typing it into the confirmation field.

Redemption Codes

We have added additional functionality and polish to the design and monitoring Redemption Code screens:

• App > Design > Marketplace > Redemption Codes

  • Now includes a new Search option
  • The list now shows the number of redemptions redeemed - instead of the number available for redemption…. (which is a bit more consistent when showing expired codes)

• App > Global > Marketplace > Redemption Codes

  • If there has been no activity in the past 30 days, the Campaign Activity widget now displays a new [Show the most recent activity] button, which automatically adjusts the chart's date settings when clicked. 

Personalized Pricing

The User > Marketplace > Personalized Pricing screen has been completely reworked to help developers understand which prices a user sees and why. 

This greatly aids in understanding and debugging automated promotions.

Additional Improvements

The following additional portal improvements have been made:

• Login, Registration, and Recovery

  • The screens for user login, new user registration, and account recovery have been improved

• Team > Manage > Apps

  • The [+ New App] dialog has been redesigned to make selecting supported platforms easier.

  • Platforms are now separated into the following categories:

    • Mobile & Web
    • Desktop & Console
    • Legacy

• Team > Manage > Members

  • The Builder API key permission has changed somewhat. It now indicates whether the team member has permission to create and use Static API Keys. The label has been adjusted to reflect this change.

• Team > Setup > Team Info

  • The Builder API access permissions have been slightly refactored. There are now separate permissions for general access to the Builder API and for allowing the use of static keys.

• App > Design > Admin Tools > Deployment

  • This includes a new option for preserving self-service branding during deployment. Useful if the branding for development and production versions of apps is different (for testing purposes)

• App > Design > Notifications > Settings

  • Now supports deleting Apple Push Notification certificates

• App > Global > Leaderboards > Leaderboards

  • The leaderboard entry preview blade shows the user’s profile image, if available.

• App > Design > Self-Service

  • New section for setting Self-Service feature options. See feature description in the Release Highlights section.

• User > User Browser, Search

  • Searching by email now searches for emails in the Contact Email field and Profile Identities, in addition to the Email Identity

• User > Summary > User Summary

  • Screen action buttons have been reorganized under a new Action menu

  • Includes new actions for the new Self-Service Account Deletion feature:

    • Send Deletion Email…
    • Copy Deletion URL…

• User > Gamification > Milestones

  • Refactored and separated from the old Milestones & Quests screen
  • Supports new filtering and searching options

• User > Gamification > Quests

  • Refactored and separated from the old Milestones & Quests screen
  • Supports new filtering and searching options

API Changes

The following calls have been added to the brainCloud API:

• ItemCatalog

  • Added two new methods (cloud code & S2S-only) for copying image files to the item catalog programmatically:

    • SysCopyItemImageFromGlobalFile() - copies (or moves) a file from Global Files to be used as the image for an Item Catalog entry.
    • SysCopyItemImageFromUserFile() - copies (or moves) a file from User Files to be used as the image for an Item Catalog entry.

• Lobby

  • The lobby matchmaking APIs have been extended to support additional options for team selection when dealing with groups of players (as specified using the otherUserCxIds parameter).

  • This new behaviour is controlled by new special “team names” that can be passed into the teamCode parameters of the API calls:

    • “team1” - all players will be assigned to the specified team (existing functionality)
    • ““ or null - players will be individually (and randomly) assigned to teams that have [x] Auto assign players enabled. Players are NOT guaranteed to be kept together on the same team. (existing functionality)
    • “___” (three underscores) - assign all provided players as a group to any team at random.  Note that only teams with [x] Auto assign players enabled are considered. Players are kept together. (New functionality!)
    • “___:team1,team2,…” - attempt to join `team1`, attempt to join `team2`, etc. until the list is exhausted. Players are kept together. (New functionality!)
  • The FindLobby(), FindLobbyWithPingData(), FindOrCreateLobby(), FindOrCreateLobbyWithPingData(), JoinLobby(), JoinLobbyWithPingData(), SysAddMember(), and SysAddMemberWithPingData() have all been extended to accept these new team codes

• User

  • Added a new S2S call for creating the self-service deletion URL for a user:

    • SysCreateSelfServiceDeletionUrlForUser() 

Client Libraries

All Libraries

• Increased the amount of time the client library waits for a CONNECT message from the Relay Server before resending its connection request. Timeout is now 2 seconds (up from 0.5 seconds).

Unity, C#, and Godot

• Fixed bug that caused empty notification tokens to be saved if an end-user denied push notifications

Unreal

• Fixed issue where the WebSocket object is not cleaned up properly on destroy
• Fixed issue with the OnRecv function passing in a reference to the json message, it is now passing a copy of that json message instead of a reference to account for a crash issue happening where the reference points to a null value on rare occasions.
• Fixed bug that caused empty notification tokens to be saved if an end-user denied push notifications (STILL IN PROGRESS)

C++

• Fixed bug that caused empty notification tokens to be saved if an end-user denied push notifications

Java

• Fixed bug that caused empty notification tokens to be saved if an end-user denied push notifications 

JavaScript

• Fixed bug that caused empty notification tokens to be saved if an end-user denied push notifications

Objective-C

• Fixed bug that caused empty notification tokens to be saved if an end-user denied push notifications

Examples

• Invaders Demo greatly improved with Replay Functionality

Documentation and Tutorials

Documentation

• All the latest API additions and changes have been incorporated into our new doc site at docs.braincloudservers.com !

Tutorials

• A new Knowledge Base article discusses how to add a Replay System to your game using brainCloud Playback Streams. Find it here. 
• New Knowledge Base article on creating a custom Room Server Manager (RSM). Find it here.

Marvellous Multiplayer! Release 5.6 brings additional polish and performance to the brainCloud platform, with an emphasis on improved multiplayer services and developer quality-of-life!

Compatibility Notes

There are no API changes in this release. 

There is, however, a change to how often brainCloud retrieves docker images for Hosted Room Servers. brainCloud used to retrieve a fresh image with every container launch - but this is both slow and expensive. Starting in 5.6, if the named image already exists on the node, brainCloud will re-use that image - avoiding the unnecessary "pull" from Docker. For devs who don't set unique tags for each production build, this behavior can be modified so that brainCloud will retrieve a fresh image if the cached image on the node is older than hours. See the Hosted Server Optimizations section for more information.

Release Highlights 

Matchmaking Monitor - Official Release

brainCloud 5.6 marks the official release of our Matchmaking Monitor.

The Matchmaking Monitor is a unique feature of brainCloud that gives developer and designer-friendly insights into an app’s matchmaking performance - and how it impacts the player experience.

This release re-arranges our panels to be more intuitive and mobile-friendly - and adds two new performance metrics: Matches Per Minute and Lobbies Created Per Minute. 

We have also added an Average Steps metric to give developers additional insight when optimizing their matchmaking criteria.

Developers can now click on the Lobby Type panel to trigger a Preview Blade showing its configuration.

The Matchmaking Monitor can be found in the Design Portal under App > Global > Multiplayer > Matchmaking Monitor.

Hosted Server Optimizations

brainCloud has built-in support for hosting Room [i.e., Game] and Relay Servers.

This release brings significant optimizations to hosted server orchestration, including:

• Faster container launches: We have refactored our region and node-locking approaches to speed up the parallel launching of nodes and containers.
• Faster container cleanups: The system will now clean up completed containers faster, making server slots available for new matches sooner. As a bonus, this saves money!
• Optimized image pulls: brainCloud now only retrieves the image for your container once when a new node starts. All subsequent container launches on that node take advantage of the previously retrieved image. This strategy is best for devs who use unique tags [e.g., “1.0.0-1”] for every server build. For devs re-using tags across builds [e.g., “latest”], there is an option to pull a fresh image if the previous image is older than the specified number of hours. This speeds up container launches - and reduces Docker usage - saving money!
• Optimized log retrievals: brainCloud now uses a separate thread to retrieve the logs when cleaning up containers. Also note that by default, brainCloud now only retrieves the logs for containers that complete with a non-zero exit code.

Leaderboard Optimizations

Our Leaderboard system is one of brainCloud’s most popular features. As such, it gets used a lot - by many games in different ways.

A common use case is using our Leaderboards as the basis of Tournaments — both for our built-in Tournament system and for more customized systems that devs have built using Cloud Code. 

Although the system overall performs well, one part of it performs “less well” than the rest: counting all the entries in a leaderboard. Due to MongoDB's limitations, this operation is slower than we’d like. And under some circumstances (e.g., at the end of a tournament, when everyone wants their tournament results), those slowdowns can add up! 

brainCloud 5.6 introduces several improvements to target this very use case:

Leaderboard counts are now being pre-calculated and stored for two high-usage scenarios:

1. Tournament results: When a tournament is completed, and rewards are calculated, we now count and store the total number of players once and use it for batched and real-time processing of tournament rewards.
2. Rotated leaderboards: When a leaderboard rotates, we now count the entries and store them in the leaderboard version history - automatically using that value when the app calls GetGlobalLeaderboardEntryCountByVersion(). 

Both of these improvements are entirely in the background — no changes to Client APIs.

NEVER ROTATION leaderboard cache

The previous two scenarios calculate and store the count for leaderboards that have been completed. Since these leaderboards are no longer live, the number of entries is no longer growing.

The same cannot be said for NEVER rotation leaderboards. These leaderboards are active forever - and can grow to millions of players.  As they do, dynamically counting the entries can take some time.

To improve performance for these leaderboards - we have added a new system that periodically (every 2-5 minutes) counts the number of records and caches the result. This cached count is also dynamically incremented/decremented as new scores are added and deleted. As such - this cached count closely tracks the exact number of entries – though it isn’t guaranteed to be 100% accurate.

When a leaderboard is very large - the difference between 1,500,000 or 1,500,001 isn’t significant…  though apps with this caching enabled should take care to ensure that they can handle the situation where the system says the player’s rank is 1,500,001 – but also says there are only 1,500,000 entries in the leaderboard. [Hint - in that case - artificially inflate the number of entries to 1,500,001 for display purposes.]

Important notes:

• Most apps do not need the NEVER ROTATION cache. Thus, it is turned OFF by default for all apps.
• Our support team must enable the NEVER ROTATION cache on a case-by-case basis.
• After 5.6 is released, our support team will contact teams with apps where we think this should be enabled.
• Contact support if you have questions about whether we should enable it for your app! 

Additional Improvements

brainCloud 5.6 includes a number of smaller improvements as well. These include:

• App Alerts

  • Dangerous Compatibility Flag — We have added a special alert for the "Include shared objects in Owned Custom Entity GetEntityPage queries" compatibility flag, which can significantly slow app performance for apps using Custom Entities. We highly advise that this flag be disabled for all apps. More info here. 
  • Unreachable Web Service — We have added a new alert for when Web Services are not reachable from brainCloud’s servers. This alert may indicate that the target servers are down, the endpoint has changed, or their SSL Cert has expired.

• Database

  • brainCloud now has basic/experimental support for AWS DocumentDB. This is most interesting for our Private Licensees (as an alternative to Atlas) - though we are also considering moving some Public BaaS services to it (e.g., some logs). 

• Logs

  • We have added new Security Log views at the App, User, and Super system levels. These logs mainly capture bad login attempts - at the Client and S2S API levels.

• Relay Server

  • We have added new MD5 and hex dump capabilities to the logging. The two new settings are:

    • PACKET_LOG_ENABLED_WITH_MD5: Set to “true” to enable MD5 hash logging of incoming and outgoing relay packet payloads.
    • PAYLOAD_LOG_AS_HEX: Set to “true” to log the incoming packet payload as a hex dump rather than an ASCII string.
  • The relay server also now exits with a code of 11 if MEMBER_TIMEOUT expires before any players connect. 

Portal Changes

We continue to evolve our Portal. In addition to the Matchmaking Monitor enhancements described above, we have added the following improvements:

Billing Plan Dialog

For users on our Public BaaS, the Billing Plan dialog has been updated to facilitate easier plan comparison and selection. This dialog is accessed from the Team > Manage > Apps page. 

Global Properties

The Global Properties screen (App > Design > Cloud Data > Global Properties), which is used for managing remote config settings for apps, now allows values to be edited inline for convenience. 

Note that JSON-based properties will pop-up a small dialog window for easier editing.

Reference Currency

brainCloud is used by developers across the globe - and thus doesn’t make any assumptions about the base currency that your app uses. The reference price of a Product is simply a number that we sum up when presenting revenues.

Prior releases of brainCloud have displayed a $ next to revenue numbers - which obviously isn’t correct for apps that aren’t using a dollar-based currency.

brainCloud now allows developers to specify the reference currency for apps - so that we can display revenue numbers appropriately.

Navigate to App > Design > Portal > Reference Currency Settings to configure your currency!

Sample Data Mode

Most of our analytics screens now feature Sample Data modes - which are designed to give new devs a feeling for what the screen would display if the related data were available.

Note that when in “Sample Data” mode - the screen contains a prominent brown border with the words “(Sample Data)” after the screen title.

Additional Improvements

In addition, the following additional quality-of-life improvements have been made:

• App > Design > Cloud Code > Web Services 

  • now displays an icon indicating whether the services displayed are reachable by brainCloud

• App > Design > Gamification > XP Levels

  • Changed the default chart display format to Linear (instead of Logarithmic)

• App > Design > Leaderboards > Tournament Templates

  • Greatly improved display and editing of Tournament Prizes!

• App > Design > Multiplayer > Lobbies

  • Re-designed Lobby Preview blade. Now, it shows a summary of the rules.
  • You can also quickly navigate to the associated Server for a Lobby Type from its Preview Blade.

• App > Design > Servers > My Servers

  • Room Servers - Devs can now configure if and how often to refresh Docker images when launching containers. 

• App > Global > Global Data > Custom Entities

  • Added [Apply] button to the editor to allow for easy checkpoint-saving for long editing sessions

• App > Global > Global Data > Global Entities

  • Added [Apply] button to the editor to allow for easy checkpoint-saving for long editing sessions

• App > Global > Leaderboards > Leaderboards

  • The leaderboards page has been updated with improved column order — rank is now placed first, and the score is right after the player’s name.
  • A [Refresh] button was added for convenience.
  • Can now only [Reset] current leaderboards - not prior versions.

• App > Global > Multiplayer > Server Monitor

  • New details were added to the Server Preview Blade. Now shows custom environment settings and Max Nodes.

• User > User Browser

  • A new button on the User Preview Blade will allow you to view the selected user in a new tab.

• User > Social > Friends

  • The screen now displays the platform that a friend originates from

Plus, there have been significant improvements to the usability of the Design Portal on mobile devices.

API Changes

brainCloud 5.6 has no changes to APIs.

Libraries and Examples

Client Libraries

Release window - Updated Client and S2S libraries are made available within two weeks of the launch of the updated server software. Updated examples are made available in the two weeks after the client lib updates.

Unity

• The default API endpoint changed to api.braincoudservers.com instead of the legacy sharedprod.braincloudservers.com endpoint.

Unreal

• Compression is now enabled by default.
• The default API endpoint changed to api.braincoudservers.com instead of the legacy sharedprod.braincloudservers.com endpoint.

Java

• Implemented gzip compression to allow for requests and/or responses from the server to be compressed (disabled by default)

  • use compressRequests (boolean compressRequests) to compress requests before they are sent to the server
  • use compressResponses (boolean compressResponses) to tell the server to compress responses
  • use enableCompression (boolean enableCompression) to turn on compressed requests AND responses

JavaScript

• Fixed bug in canReconnect() – Previously, only empty (““ or length == 0) anonymous/profile IDs were being detected

  • Now properly checks for null and empty IDs

• Implemented gzip compression to allow for requests and/or responses from the server to be compressed (disabled by default)

  •  use enableCompressRequests = function(compressedRequestsEnabled) to compress requests before they are sent to the server
  • use compressResponses = function(compressedResponsesEnabled) to tell the server to compress responses
  • use enableCompression = function(boolean enableCompression) to turn on compressed requests AND responses

C++

• Implemented GZip compression to allow for requests and/or responses from the server to be compressed (disabled by default)

  • Currently tested on Windows / Linux / MacOS and Android (Still untested on iOS)

Example/Demo Libraries

Unity Examples

• Invaders

  • Username is now displayed on the main menu upon successful authentication

Documentation and Tutorials

Documentation

• All the latest API additions and changes have been incorporated into our doc site at docs.braincloudservers.com !
• We have started migrating our Knowledge Base at help.braincloudservers.com to French!

We sat down with CEO Mohammad Agha and Lead Developer Tri Truong to gain insights into Magmic’s decision to adopt brainCloud as the primary backend for their games.

About Magmic

Established in 2002, Magmic has developed and published over 100 mobile games, many of which have reached #1 in the Card and Board game categories on the App Stores. Some works include Mattel’s Phase 10, Blokus, and Hasbro’s Scattergories. With 250 million game downloads over 18 years, Magmic has a player base of millions of monthly active users. Across Magmic’s game library, the player base has accumulated billions of hours of play. Currently, Magmic is focused on developing AAA quality Free-to-Play casual games aimed at the mid-core market. Magmic games employ a proprietary event management system, full Live Operations capabilities, and a sophisticated Cross-Promotion SDK.

What were the primary challenges you faced before migrating to brainCloud?

We had a highly fragmented backend infrastructure:

• We had different versions of backends that we had to maintain as we were not necessarily updating older games but we had to keep them active. So we had lots of duplication.
• With all the duplicate backends our AWS bill was pushing $30K+ USD per month and that’s not including salaries of a four person backend team.
• When we were developing Texas Hold’Em King Live for the iPhone, we ran into many sync and latency issues with our legacy tech.
• We had different generations of our legacy backend built on different technologies - which required different developer skillsets to maintain. There was just a lot of inefficiency and lack-of-standardization in our backend code.

What tipped you over to deciding to migrate everything to a new BaaS?

We were spending well north of $400K USD per year on hosting fees, and the system wasn’t 100% reliable.  Add to that the management of servers crashing / going down in the middle of the night and we just always seemed to have an issue to deal with.

During the assessment process, were there any features of brainCloud that stood out as especially valuable for your business?

One of the standout features of brainCloud for our business is the Cloud Code functionality: It gives us the flexibility to develop our products in a way that fully meets our specific requirements. With Cloud Code, we can implement custom logic on the server side, streamline workflows, and optimize performance without needing to manage our own backend infrastructure. This has been invaluable for ensuring scalability, maintaining security, and integrating seamlessly with other cloud services and blockchain solutions. Overall, it allows us to stay agile and focus on delivering the best experience to our users.

What was the key feature or aspect of brainCloud that won the bid?

The real-time multiplayer aspects were what we were looking for initially but then we found a host of other features in there that we also found extremely useful, including Leaderboards, Data Downloads, In-App Purchase configuration and management, and User Login and management.

Is there a ballpark estimate that you would feel comfortable saying is a standard “time savings” that you get from having a standardized backend?

Yes, we no longer need to rebuild backend foundation features like authentication, leaderboards, multiplayer, and cloud storage from scratch, which saves us a significant amount of time—easily 2 to 3 months per project. Instead of allocating resources to backend infrastructure, we can focus more on developing innovative features. For example, in MLB Diamond Inc., our developers were able to shift their focus to building new online functions such as PvP gameplay, Marketplace, and Auction systems.

Can you summarize some of the qualitative outcomes of migrating to brainCloud?

We have seen the following benefits:

• Lower Costs: We estimate we are saving approximately $400K USD/year for AWS bill + $300K USD/year in dev salary for a total of $700K USD/year savings across all our titles.
• Higher Revenues: We started doing a lot more sales and player in-app time went up because our system was more reliable, we estimate 15% increase in IAP revenues.
• Server Reliability → DAU Increase: What we see is DAU [Daily Active Users] increasing more smoothly over time since we are experiencing no downtime. Previously it was common to have servers crash at 2AM – and every time the server goes down, the game loses users due to that. That does not happen anymore.
• Development Time: We estimate over 60%+ decrease in time spent on server development, and no more headaches due to server issues or downtime.

What was your top reservation or concern before the migration, and how did brainCloud meet that concern?

Our top concern was, “Will brainCloud do what we need it to do reliably, cheaply, and consistently? The answer was “yes” on all counts. Moving to brainCloud was clearly the right decision.”

Continue with Part 2 of this case study here.

Ready to try brainCloud for yourself?  Create a free account on our Public BaaS - or jump on a call with our Sales Team for more info!