In June, Beamable released SDK version 1.16.0, which includes support for Unity version 2022 LTS alongside a range of improvements. A few highlights from the month of June include:

Unity SDK Improvements

Beamable SDK 1.16.0 brings support for the latest Long Term Support (LTS) version. Unity 2022.3.0f1 LTS was released at the very end of May and is now fully supported by the Beamable SDK. Beamable is committed to supporting the latest three LTS versions. As such, Beamable 1.16.0 drops support for Unity 2019 LTS.

Besides that, we also added the ability to send gifts to players through Announcements, and fixed compilation bugs when using the `com.unity.mobile.notifcations` package.

Microservice Improvements

1.16.0 marks the introduction of the Scheduler API that allows for scheduling jobs for later execution. We’ll add support for managing scheduled jobs inside the LiveOps Portal, in an upcoming release.

Additionally, we also fixed an issue with Docker installations.

In recent versions, much of our focus has been given to the Standalone Microservices and CLI tools that allow you to interact with SAMS (Standalone Microservices). You can now create new Standalone Microservice projects, add additional microservices to a project using the `beam project add` command, or even create a new Beamable organization with `beam org new`.

Full changelogs can be found at https://beamable.github.io/changes

We are proud to announce a partnership with Zebedee in the Beamable Marketplace to simplify Bitcoin integration for game developers dramatically.

ZEBEDEE is a next-generation payments processor pioneering instant, low-fee, borderless and currency-agnostic microtransactions for the global digital era.

BEAMABLE allows game developers to integrate server-side features into their games without requiring extensive server-side development resources or knowledge and empowers them to effortlessly integrate server-side features into their games through a framework that can easily be imported into client-side game code.

Together, both companies can accelerate the development of the next generation of Bitcoin-integrated gaming by dramatically simplifying the process of integrating Bitcoin transactions into games by removing the need for a server or systems operations team.

Check out the full press release for more information.

Check out the Beamable Marketplace to learn more about Zebedee.

Spielworks is launching a Web3 gaming accelerator, Wombat X, to empower Web3 gaming projects. They are bringing together tools, education, and funding to help Web3 game developers accelerate their projects and grow their audiences by leveraging the Wombat ecosystem.

We are proud to be an initial partner in the Wombat X Accelerator ecosystem. At Beamable, we are committed to improving the workflow for game developers to implement meta-game systems and build out complex item economies that drive profound social and gameplay experiences. A partnership with Wombat X offers game projects the ability to take full early and discounted advantage of Beamable’s range of capabilities:

• Integrated player authentication with wallet capability
• A reactive game content system to propagate content changes across game clients
• An interoperable inventory later to manage both on-chain and off-chain assets.
• Unity and Unreal engine integration, along with advanced Cloud Code capabilities to build, extend, and integrate 3rd party game assets via the Beamable Live Services Marketplace.

You can learn more about how Beamable supports Web3 on our website.

If you have a Web3 project and want to take advantage of the Wombat X Accelerator program, head over to the website to learn more and sign up today!

In April, Beamable released SDK versions 1.14.1, and 1.15.0. Here are the highlights from the previous month of releases. 

Our changelogs can be found at https://beamable.github.io/changes

Microservice Performance 

In Beamable 1.15.0, the Microservice performance has been dramatically improved for long-running services receiving game-level traffic in production environments.

Two major issues were addressed. Firstly, a multi-threaded access violation could occur during high-traffic periods in the deserialization pathway of a Microservice. The deserialization bug would cause seemingly random requests to fail for seemingly unknown reasons. Secondly, a running service’s max CPU utilization levels would periodically jump to 100% and stay there until a redeploy event. Microservices running at 100% CPU utilization cause extreme failure cases because there is no wiggle room for the service to process new requests.

The root cause of this error was traced to a bug during the secure websocket authorization process that happened when the remote Beamable host needed to reset the connection. Both of these issues have been fixed in 1.15.0 and result in a much more reliable deployed Microservice. 

Standalone Microservices and Storage

We’ve been working towards an advanced workflow for Microservice and Microstorage.

Previously, Beamable Microservices were tied to the Unity development environment, which brought many challenges to developers. Microservices would compile in the same dotnet framework that Unity used. Using Nuget or recent dotnet features was not possible. Additionally, it was not possible to modify the .csproj or Dockerfile files that control the Microservice.

In Beamable 1.15.0, you can use Standalone Microservices. These allow you to create a Microservice in a separate dotnet solution. You can manage your own dependencies with Nuget, customize your .csproj to use advanced capabilities, and even modify the Dockerfile if you need to. Beamable has a command line interface tool called beam you can use to create and deploy standalone Microservices. You can run the Microservice directly from your IDE of choice or run it as a docker container to closely mirror the production environment. Microstorage is also available in this standalone format.

We are still developing these workflows, but you can check out the early documentation.

Sign up to give these and many more features a try today!

Also, check out our expanding marketplace of game server solutions!

In March, Beamable released SDK versions 1.12.0, 1.13.0, and 1.14.0. Here are the highlights from the previous month of releases. 

Our changelogs can be found at https://beamable.github.io/changes

Microservice Publish Window

In Beamable 1.14.0, we released a new Microservice Publish experience. You can read about it in our documentation. The new flow shows the publication status of each service and has a large banner explaining each step of the publishing process. We received lots of feedback that enabling and disabling services in the old flow was confusing, so we’ve re-hauled the experience for 1.14.0. Every time Microservices are published, every single Microservice is set to be “On” or “Off.” If the service is configured as “Off,” then the service will be turned off when the publication finishes.

Microservice Build Hooks

In Beamable 1.12.0, we introduced a way to run custom code before a Microservice is built. The primary use case was to facilitate a way for Microservices to copy custom files into the final runtime environment. You can read about building hooks in our documentation. At Beamable, we used this feature internally to develop the Polygon sample integration project. The project needed to copy the Solidity Compiler from the Unity project to the Microservice Docker build context and, finally, into the built Docker image. Build hooks can also be used to modify the Docker build context, run custom checks, or whatever else you can think of.

Config Defaults 

In Beamable 1.12.0, we changed the behavior of the config-defaults.txt file. The file contained connection settings for a specific Beamable Realm. Previously, the Unity editor, Unity editor playmode, and the built Unity game would all reference the single realm in the config-defaults.txt file. In Beamable 1.12.0, the connection settings in config-defaults.txt only control the connection settings for the built Unity game. The Unity editor and playmode find their connection values elsewhere, controlled by a new file in Library/BeamableEditor. The config-defaults.txt file can be written to manually or by clicking the “Save Config Defaults” button on the account summary page. 

Change Logs

Beamable 1.12.0, 1.13.0, and 1.14.0 also include a lot of bug fixes that you can review in our changelogs.

March 21, 2023 (San Francisco, CA) — Today, Beamable announces the Live Services Marketplace: the world’s first destination for game developers to create and share interoperable backend software that helps them build, grow and operate live games.

“Our vision is to accomplish for the cloud what Unity and Unreal accomplished with the front-end of game development,” said Jon Radoff, CEO of Beamable. “To do so, we had to create more than a place to download files: we had to create the software interfaces to compose backend gaming software in the cloud–and to interoperate with each other.”

The marketplace is built around components using the Beamable Live Services Marketplace SDK. This includes features such as:

• A cloud-native execution environment for running code that is maintainable, debuggable and automatically scalable
• A “data fabric” for representing the objects that exist in persistent worlds and online game economies
• A set of off-the-shelf methods for important use cases such as scheduling events and messaging campaigns.

The Live Services Marketplace is launching with support for a number of ready-to-use integrations, as well as announcements from partners who have announced forthcoming support. Included are examples for real-time interaction (Foundry, Photon), Generative AI (Scenario, Common Sense Machines, MobGames.ai), analytics forwarding (Amplitude, Mixpanel), blockchain (Solana, Polygon, Venly, Recur, Lamina1), and monetization (GoPlay.io).

To gain access to the Live Services Marketplace SDK or see the components already available, visit https://beamable.com/marketplace. 

About Beamable

Beamable provides a platform for building and scaling the operations of live games, available as both a Software-as-a-Service (SaaS) version and a “bring your own infrastructure” Private Cloud deployment. The platform is tightly integrated with Unity and Unreal game engines, enabling game developers to focus on the creativity and differentiation of their products. Led by a team of game-industry and software veterans, Beamable is based in the Boston area, and has raised $14M from investors including Permit Ventures, Companyon Ventures, GrandBanks Capital and Defy.vc. For more information, visit beamable.com.

Today, Beamable is announcing support for Polygon developers. In addition, we’re pleased to share that Beamable has received an investment from Polygon to support integration between the Beamable and Polygon ecosystems.

Polygon is an “out of the box” integration for the Beamable Managed Inventory service. We’re also releasing the source code for people who want to see how we built it, or use it as a template for your own Beamable extension.

Our goal with Beamable’s preview release of Polygon integration is to make it the easiest and most powerful way to build a game on the Polygon blockchain. Rather than spending your time working on backend code, building homebrew live ops tools, or linking your game’s logic back to blockchain–we made it so you can focus on creativity. 

Polygon integration is built as an extension to the Managed Inventory service, so you gain access to:

• Powerful tools to manage the live services for a blockchain-based economy: account management, customer support, event configuration, and content management.
• Develop, update and manage item schemas and game systems using the tools developers prefer–whether that’s a game designer who likes spreadsheets, or a programmer who prefers Unity or Unreal.
• A fully-integrated development environment that lets you work with items, access data, debug–whether in the game client or in the cloud

Next steps:

• Get started on Beamable today
• Read more about Beamable’s Managed Inventory service
• How Beamable Web3 integration works
• Visit the Github repository for the Beamable<->Polygon integration

Today, we’re announcing that the Beamable Live Services SDK for Unreal Engine 5 is now available as a public preview. All of the source code for our Unreal Engine support is available.

For the last year, we’ve been working towards making it easy for Unreal developers to add live services to their games. And in December, Beamable received an Epic Megagrant to support our work.

Beamable’s approach to live services is to make it possible for Unreal developers to focus on the creativity and experience of their game without the headaches of provisioning, coding, and managing servers. We’ve wrapped Beamable’s rich set of live services into Unreal Blueprints so that implementing a sophisticated online game–whether a virtual world, an MMO, or games of any scale–is as easy as the node-based interfaces available.

Here are some of the things you can do with Beamable + Unreal Engine 5:

• Store and manage persistent data about identity, accounts, inventories, events, tournaments, and any other attributes you need to store
• Invoke microservices that implement server-authoritative game-specific systems and behaviors from player clients or dedicated GameServers.
• A wide range of “off the shelf” systems for live events, schedules, leaderboards, stores, and other Live Ops systems
• A complete game economy built on Beamable Managed Inventory
• Incrementally opt-in to only the features you need by experimenting with Blueprints and then transition into C++.

Beamable’s Live Services are modular, easy to get started with, and scale as big as your game can get. We’re excited to welcome Unreal Engine developers to the platform.

Next steps

• Access the GitHub repo for the Beamable Live Services SDK for UE5
• Building a game for UE5 that needs live services? We’d love to support you.

Today, we’ve released an “out of the box” integration for Solana to the Beamable Managed Inventory service. We’re also releasing the source code for people who want to see how we built it or adapt it to your own extensions.

Beamable’s Solana integration is the easiest way for Solana developers to build a live game: no more messing around with smart contracts, coding backends and linking them to frontends, or dealing with the complexity of making these systems work within an overall live ops environment. The Solana integration is built as an extension to the Managed Inventory service, so you gain access to:

• Powerful tools to manage the live services for a blockchain-based economy: account management, customer support, event configuration, and content management.
• Develop, update, and manage item schemas and game systems using the tools developers prefer–whether that’s a game designer who likes spreadsheets, or a programmer who prefers Unity or Unreal.
• A fully-integrated development environment that lets you work with items, access data, and debug–whether in the game client or in the cloud

Next steps:

• Get started on Beamable today
• Read more about Beamable’s Managed Inventory service
• How Beamable Web3 integration works
• Visit the Github repository for the Beamable<->Solana integration

Blockchain integration is entirely optional–drop it in, or leave it out according to your game’s requirements. When you do choose to build a blockchain game with Beamable, we established several guiding principles to ensure your success:

• Authority of the chain. The blockchain becomes the source of truth about who owns what in your game’s economy
• Automation. As ownership changes occur on-chain, these changes are automatically reflected in your game servers. Similarly, when something in the game results in an ownership change (such as gaining something from a treasure chest, or players trading with each other) these changes are automatically transacted on-chain
• Performance. Your high-performing game servers built with Beamable provide moment-to-moment data about items–so that you can deal with thousands of API calls/second without being concerned about blockchain bottlenecks
• Optionality. Giving you flexibility around your blockchain options while you’re still developing your game–making it possible to build around interfaces that will adapt to different blockchains.
• Security. Robust access controls limit which game realms can record on-chain changes, and who has the authority to grant items to players.

From the game development standpoint, we wanted to achieve the same simplicity as with other Beamable systems. Beamable is built around people–meaning we think first in terms of the developer experience, and making it easy for the right people to interact according to the workflows that are mostly native to them. For example:

• Designers can parameterize items through spreadsheets, or through form-based interfaces built into Unity and Unreal.
• Programmers can add features to the parts that touch items from within Unity Editor or Unreal Studio, without fussing with backend code or implementing middleware.
• Live Ops personnel can use browser-based interfaces to set up events that grant item rewards, schedule content, perform customer service duties, etc.

Every software module that interacts with items–such as account management, inventory, campaign messaging, and events–all use the same interfaces whether for an on-chain or non-chain asset. That’s because our Web3 support is built on top of the Managed Inventory service, which provides an interoperability layer around the items in your game economy.

Here are some example screens of what the support looks like for a game built on the Solana blockchain (keeping in mind that the experience is reasonably identical for any other chain that has a Beamable integration):

Here, a programmer works inside Unity–using drag-and-drop tools to add account management buttons, wallet federation, and item use to a game:

The above only takes minutes to add to a game, because everything is performed visually inside Unity Editor.

What if customer support needs to review the history of one of your players? They can just look at a player account through the Beamable Portal:

Similarly, if a customer service person has the authorization to grant an item to a player, they could do that through the Web interface as well:

In the above example, you can look at the block explorer to confirm that the player’s wallet is appropriately updated:

Get Started Now

To get started with Beamable, sign up at beamable.com and visit our github repo for the latest web3 sample code & SDKs

This article is about Managed Inventory: how it simplifies life for game developers and live ops staff–getting your game to market faster, managing things easier, and ensuring that you’re equipped with an extensible, scalable platform for operating your online game.

Managed Inventory is part of the Beamable Data Fabric: it provides an extensible, unified means of managing the items that comprise your game’s virtual economy. The benefit of Managed Inventory is that you gain access to a network of business features to boost lifetime value–without spending valuable time on data-adaptation projects, addressing permission systems, ETLs, and other bridges between game systems and important business systems.

All of the Beamable core systems “just work” with your items–and as new modules are created (either stock components from Beamable, or from the growing marketplace of third-party integrations), those advantages just snap into place. Let’s take a look at what we mean by this; the following diagram shows the many modules and people who interact with a game’s economy:

From this, we can see a number of systems are needed:

• Designing and maintaining the schema of items in the game
• Validators that check to make sure parameters assigned to items are within the appropriate bounds
• Connecting the game items to servers (to maintain state in the persistent world, enforce game rules in a server-authoritative manner, and update records atomically)
• Connecting the game items to the player experience (attaching them to front-end behaviors, UI, graphics)
• Facilitating Quality Assurance procedures (setting up test cases with specific item load-outs, investigating issues, etc.)
• Customer Service operations like looking at the item history for a player, adding/removing items and currencies, etc.
• Dashboards for analytics & user segmentation related to item utilization
• Forwarding of item data to sophisticated data science modules for applications like AI-driven offer optimization, advanced predictive modeling, lifetime value (LTV) prediction, etc.
• Messaging campaigns (targeting players with messages or device notifications who have obtained certain items–or gifting items as rewards to players)

Similarly, the types of people who need access to these systems–and the ideal interfaces for accessing these systems–are varied:

• Programmers usually prefer to work within their 3D engine environments
• Game designers might configure item schemas and attributes in a spreadsheet
• QA personnel may need access to a “cheat code” interface that grants/removes items
• Customer service needs a web-browser interface that lets them inspect account histories and make adjustments
• Product managers and data scientists need access to a combination of high-level dashboards as well as access to underlying item utilization data
• Marketing and live ops staff need to be able to create messaging campaigns that target specific segments of players

Off-the-Shelf Services

Beamable comes equipped with a number of stock services that make it easy to manage your game. Assigning items to events; account management interfaces for customer support to assign/revoke items; QA interfaces; and developer interfaces for Unity and Unreal are a few of these examples.

Deployment Process

Developers work on individual features that flow into a continuous integration (CI) process, while designers; content-creators make new items, and assign items to rewards, events, and systems; and all of these new items need to be tested, and then synchronized with live updates for players.

This progression from development to testing to production frequently involves a large number of manual processes and scripts which are usually brittle, cumbersome, and error-prone. Beamable deploys all of the item information alongside other code and content changes to ensure that the live game environment receives tested and appropriate updates–when and where you want them.

Access Controls

Since there are a variety of interfaces and user types, you’ll need an access control system to control who is able to perform specific actions across the various user populations–spanning all of the realms

Validations

When a lot of people are involved in updating item data, errors can easily propagate–requiring complicated testing procedures. While testing is always a good idea, Beamable mitigates a lot of risk to your item economy by establishing validations. Because items are treated like another form of “content” in Beamable, they benefit from the same robust content validators that are built-in to the platform.

Full-stack Visibility and Extensibility

With Beamable, you have visibility into the entire software stack–including how you interact with data such as items. No more working with multiple IDEs, different data exploration UIs, or disconnected debugging processes. This is because the cloud-native microservices architecture Beamable is built around allows developers to locally instantiate the managed inventory environment, perform integrated debugging across both game frontend and backend, and add their own powerful extensions to how your game utilizes items.

Extensibility

Because the Beamable environment is flexible and extensible, you can add your own capabilities–or easily integrate third-party functionality. Some of these use cases include:

• Automated integration of managed inventory with blockchains for Web3 games
• Hooks into Generative AI APIs to generate item art and descriptions as part of the production process–or live, while players enjoy the game
• Hooks into offer-optimization systems that look at purchasing histories and structure item bundles that maximize lifetime values
• Forwarding important events related to item assignment, consumption or economic transactions to analytics and data-science modules

Further Reading

Managed Inventory is just one part of Beamable’s fully-integrated platform for live services: an end-to-end system to accelerate the creation and operation of live games. Here are some ways to learn more about Beamable:

• Start playing with Beamable for free in our multi-tenant cloud
• Learn more about the Private Cloud edition–where you can run the entire Beamable software on your own infrastructure
• Download the Beamable Technology White Paper

A variety of changes have been released for the Beamable Liveops Portal. Here is a collection of improvements, fixes, and additions.

General Improvements & Bug Fixes

• “Promote Realm” with the production realm as the source is now possible (with a warning displayed)
• Message Campaigns In-Game Mail campaigns support specifying an optional Category (similar to channel in Announcements)

Analytics Dashboard

• Retention table now distinguishes between 0% retention and unavailable data
• Retention table default date range window now only shows full days and no longer suffers from off by one
• Message Campaigns for Announcements now properly handle legacy Entitlement Attachments

Events & Leaderboards

• Player Events page will always show rewards
• Players > Events page now renders the event id as a link which takes you to the corresponding event details page
• Players > Events page now shows the leaderboard Id that a player has been assigned to (if available) and renders it as a link
• Clearing an entire leaderboard will no longer result in a 404 Error
• Removing player from leaderboard in Players > Leaderboards page no longer results in a malformed and failed request
• Players > Leaderboards section will load dramatically faster for customers with large numbers of leaderboards

Demo Project

• Fixed missing Microservices Deployment Status
• Fixed incorrect visualization for Player geolocation

Microservices

• Microservices now show “status” when they are deploying
• Portal users can now disable/enable Microservices and Storage Objects Operate > Microservices section

New Features

Portal Audit Log: Operations performed by Portal users are now logged in analytics and viewable from Realm > Analytics as a new table called client_portal_audit

Download Microservice Logs

New “Download Logs” button will export view of logs into a flat file you can download

API & Microservice Usage

New api & microservice usage graphs segmented by realms and services now available in under Account > API Usage

NOTE: Not all api usage is billable. We will be adding a way to filter only billable apis in an upcoming update.

Mutable Event Rewards: Events now support changing Event Rewards for currently running events (as well as upcoming events)

Federated Identity

Player Profile will now show external, custom authentication schemes (such as web3 wallet association) under Player Associations alongside social login

In February, Beamable released SDK versions 1.11.0, and 1.11.1. Here are the highlights from the previous month of releases. 

Our changelogs can be found at https://beamable.github.io/changes

Federated Authentication and Inventory

In Beamable 1.11.0, you can add support for arbitrary external authentication, and manage Inventory state through arbitrary external third parties. Our documentation explains in more detail, but in short, you can use a Beamable Microservice to manage the secure interchange between Beamable authentication and whatever external authentication you need. Federated authentication could be used to integrate with Auth0, custom authentication solutions, or even blockchains. Federated inventory allows you to run custom logic on a Microservice anytime a player’s inventory would be modified, and act as the source of truth for the inventory state. The Federation of inventory enables you to manage a player’s inventory on a blockchain or back it up to a third-party source.

Presence SDK

Beamable 1.11.0 delivers a new Presence API and SDK that allows players to manage their online status. The documentation describes how to manage player presence. Any player can set their status to “invisible”, “do not disturb”, “away”, or “online”. Additionally, the presence update can include a free-text string to describe something unique about the status, such as “Playing level 4”, or “Sitting in the Lobby”. A player can view their friends’ presence status, and receive programmatic updates when the status changes.   

SDK Enhancements and Bug fixes

In Beamable 1.11.0, the Player Inventory SDK received a few bug fixes, as well new methods to make managing inventory easier. There is a new method called UpdateDelayed that will enqueue inventory updates for a player and then send them in batch. For example, instead of sending 3 separate update requests in a short time span, the new method will wait for a short period of time, collect all the updates, combine them into 1 request, and then send the single request. This will help you manage your inventory API call volume. 

Previously, in order to start using Beamable in code, you had to use code similar to the following, 

ar ctx = BeamContext.Default;await ctx.OnReady;

In Beamable 1.11.0, there is a new shortcut to get the BeamContext and await it all in one line, 

var ctx = await BeamContext.Default.Instance;

Change Logs

Beamable 1.11.0 and 1.11.1 also include a variety of bug fixes that you can review in our changelogs. 

In January, Beamable released SDK versions 1.10.0, 1.10.1, 1.10.2, and 1.10.3. Here are the highlights from the previous month of releases. 

Player Account SDK

In Beamable 1.10.0, we added a new accounts SDK that is observable, serializable, and collection based. Previously, in order to switch the active Beamable account, the only way was to use the ApplyToken method. Instead of manually managing TokenResponse structures, you can now use the BeamContext.Accounts. The new SDK exposes critical user stats like alias and avatar, as well as their credential information. Read about the new SDK on the Beamable documentation pages. 

Content SDK Improvements

Previously, Beamable used an AssetDatabase.FindAssets call during Unity domain reloads to fetch and manage local Beamable Content. Now, in Beamable 1.10.0, the FindAssets call has been removed and replaced with a custom solution. The new process uses a class called ContentDatabase which does a single file scan and caches data until the next domain reload. Additionally, large-scale content interactions with the Content Manager are much faster in Beamable 1.10.0. Previously, anytime large sections of content were added or removed, the operation would happen serially for each content object. Now, those operations are done in bulk which improves the performance dramatically. 

Dependency Provider in C#MS

Microservices have supported a form of dependency injection, but in Beamable 1.10.0, you can use the same dependency injection conventions that the Unity SDK uses. The IDependencyBuilder and IDependencyProvider are available in the ConfigureServices and InitializeServices methods. These types allow you to configure singletons or other services and access them from client-callable methods without the use of static keywords. 

Change logs

Our full changelogs can be found at https://beamable.github.io/changes

Goplay’s free and simple platform rewards a gamer’s physical activity to motivate player spend outside of your game. By integrating with Beamable C# Microservices, game developers can effortlessly and securely add Goplay to their game and take advantage of commerce integration to provide in-game items and currencies as rewards to players.

Why Goplay?

Research shows that only a mere 2% of gamers choose to spend money in free-to-play games. Additionally, 80% of gamers do not get enough physical activity. With Goplay, gamers can engage in physical activity in the real world and use the Goplay currency, GoBits, to unlock discounts and rewards within their games. This allows players to earn in-game currency for linked games even when they are not playing, and provides game developers with a source of passive revenue 24 hours a day.

Goplay already integrates with Playfab, Unity Game Services and custom backends, and now it integrates with Beamable to make implementation into your game an easy project for your team.

If you are a Beamable developer or are a game developer looking to increase your conversion metrics (who isn’t?), head over to https://goplay.io/ and check it out!

In December, Beamable released SDK versions 1.7.0, 1.8.0, and 1.9.0, and 1.9.1. Here are the highlights from the previous month of releases. 

Microservice Performance

Microservices received many performance improvements in December. Previous to Beamable 1.7, Microservices logged all inbound and outbound messages, including the request bodies and headers. The volume of log messages for high-scaled services was degrading performance, so going forward, Microservices no longer emit logs for sending and receiving messages. Additionally, logs do not automatically include the request body or header information. Of course, these can be added manually to logs on a case-by-case basis. Regarding logs, Beamable 1.7 introduced limits on max log size. Nested objects are only destructured to a depth of 3. Only 10 objects will be serialized in a collection. The max character size of a destructure operation is 500. These logging changes reduce the memory footprint of deployed Microservices which allows them to run more efficiently.

In Beamable 1.7, each Microservice instance opens multiple WebSocket connections to Beamable. Maintaining multiple connections allows the service to spread the network load across several Beamable Gateway instances, which improves reliability and performance. It is expected that each WebSocket connection may expire, but with multiple connections available, a single connection loss won’t cause a major service outage.

Due to the logging changes, the multiple connection changes, and a variety of smaller improvements to memory management and garbage collection, the overall performance characteristics of Beamable 1.7 are much better than 1.6.2. We used Locust to simulate a stress test on the two Beamable versions. In the stress test, we experimented to see how many requests a Microservice could handle before it started experiencing 504 HTTP timeout errors. 

The key takeaway is that Beamable 1.7 never encountered latency above 2.5 seconds while 1.6.2 had p95 latencies of around 4 seconds and experienced 504 HTTP timeouts due to response times exceeding the 10-second timeout period.

Prefetch Content

In Beamable 1.8, Microservices prefetch all Beamable Content before accepting user traffic. When the service starts up, it will download the entire content manifest. Subsequently, any request to fetch content will be handled by the content cache. 

Cancellation Token

Finally, In Beamable 1.9, we introduced a CancellationToken accessible on the Context property in each [ClientCallable] function. Consider the code snippet below, 

[ClientCallable]
public void SpinForever()
{
  while (true)
  {
     // do nothing.
  }
}

The SpinForever function will never complete due to the non-terminating while loop. This is extremely bad for performance and efficiency, especially in a deployed environment. Every [ClientCallable] function is run in its own Task instance. In dotnet, many Tasks are scheduled per Thread, and then Threads are scheduled by the underlying operating system. If a single Task keeps running, then any other Task scheduled on the same Thread will never get a chance to execute. Essentially, the non-terminating while loop kills an entire Thread instance. This reduces the performance of the service and also causes the CPU to spike to 100%. If you see your deployed service CPU at 100%, you should double-check your code for non-terminating loops or recursion. When the CPU is pinned at 100%, it will cause additional server instances to spawn in the Beamable Cloud. Unfortunately, those new instances will be susceptible to the same underlying issue, and will likely also get pinned at 100% CPU.

In Beamable 1.9, you can change the above code to this snippet. The ThrowIfCancelled function will throw a TaskCancelledException after 20 seconds, and cause the Task to finish. There is also a IsCancelled boolean available on the Context that will return true when the request has timed out.

[ClientCallable]
public void SpinForever()
{
  while (true)
  {
     // do nothing.
     Context.ThrowIfCancelled();
  }
}

Editor Performance

Beamable 1.8 and 1.9 include several performance improvements for the Unity Editor experience, specifically concerning Content and Microservices. From our internal testing using the Editor Iteration Profiler, we saw a 20% speed improvement for domain reloads in a project with 2.5 thousand content objects, and about a 30% speed improvement in projects using several Microservices. 

In both cases, these improvements can be attributed to fewer memory allocations and Reflection operations. Unfortunately, in a few critical places in the Beamable SDK prior to 1.8, System.Linq commands were causing a lot of memory allocation which led to large garbage collection passes. Additionally, we identified several opportunities to cache information instead of recomputing it every domain reload. 

Visual Changes

In Beamable 1.7.0, we continued moving the Beamable tool windows to a modern flat User Interface design. The Content Manager and Toolbox have refined interfaces that make it easier to recognize key features. 

Additionally, in Beamable 1.8, the default avatars have been replaced with grey-box user icons. If you are upgrading from a previous Beamable version, you will continue to see the old avatars until you delete the Assets/Beamable/Resources/AvatarConfiguration file and it is regenerated.

Local Content Mode

Beamable 1.7 introduced Local Content Mode. From the Project Settings, you can enable Local Content Mode, which changes all content fetching in PlayMode to read content from your local disk instead of downloading it from the Beamable Cloud. This can help speed up your workflow when making subtle content changes to custom content objects. 

Change Logs

For a complete list of changes, please review the at https://beamable.github.io/changes

Since the launch of Beamable, we have had the opportunity to connect with thousands of game developers. Most of you tell us how transformative it is to be able to start building your dream game without getting bogged down in backend coding, standing up new servers, or handcrafting the same live services that thousands of other games already have.

But we have also heard from larger developers that you need more: not only the simplicity that Beamable brings but the ability to operate it on your own infrastructure. You need the ability to customize the entire code stack and run it in an environment that you have total control over.

We are pleased to announce that this is now an option with Beamable!

Beamable Private Cloud allows you to take a fork of the Beamable environment and launch it on your own infrastructure. You get all of the simplicity, workflow advantages, and acceleration that Beamable brings to your game development – with the comfort of operating within your own environment, tweaking things however you need.

Our new offering is geared towards AAA developers and others with large audiences. With that in mind, we are also adding a new option: Beamable Co-development. Sometimes you need the support of highly customized features or integrations. We are here to support you! Currently, this option is only available to Beamable Private Cloud customers.

If you have a game with over 1M MAU – or expect to have that many players – we encourage you to get in touch to explore these options. Here’s how: https://beamable.com/why-beamable/beamable-private-cloud

BEAMABLE BRINGS LIVE SERVICES INTO THE UNREAL ECOSYSTEM WITH HELP FROM EPIC MEGAGRANT

Beamable opens Early Access program for Unreal Live Services SDK

December 8, 2022 (Boston,  MA) — Beamable, a platform for adding live services to games, today announced the Early Access program for the Beamable Unreal SDK. This expansion is supported by an Epic MegaGrant from Epic Games.

The vast majority of popular games are built around the games-as-a-service business model. These games need systems for data persistence, custom server code, live content pipelines, identity, social systems, and sophisticated economies. However, these features typically require complicated backend programming and systems integration. Beamable’s mission is to make it easy for developers to focus on the creativity of their games without getting bogged down with the scalability, security, and workflow associated with live services.

“Unreal Engine is at the forefront of gaming and spatial computing,” explained Jon Radoff, CEO of Beamable. “It is the 3D engine used by leading developers who are building immersive, expansive, and visually-stunning games–as well as the emerging applications of the metaverse. Now, Unreal developers may build connected experiences and persistent, virtual worlds more easily than ever before.”

Beamable’s unique advantage is that it makes building games with live services simple and scalable: instead of coding a custom backend and figuring out how to connect all of the pieces, you work inside your 3D engine using drag-and-drop tools. When you need custom server logic, you create composable microservices that extend your 3D engine’s native programming environment. As part of its SDK for Unreal Engine, Beamable’s roadmap includes Blueprints support, as well as integrations for the Epic Games Store and Epic Online Services (EOS).

To join the early access program for the Beamable Unreal SDK, visit https://beamable.com/unreal. 

About Beamable

Beamable provides a Software-as-a-Service platform for the operations of live games. Led by a team of game-industry and Software-as-a-Service veterans, Beamable is based in the Boston area and backed by investors including Permit Ventures, Companyon Ventures, GrandBanks Capital and Defy.vc. For more information, visit beamable.com.

In November, Beamable released SDK versions 1.6.0, 1.6.1, and 1.6.2. Here are the highlights from the previous month of releases. 

Fresh Microservice Manager

The Microservice Manager received a major upgrade in Beamable SDK 1.6.0. The goal was to reduce the complexity of the user experience by removing duplicated information and ambiguous components. The changes include:

• The local status icon that had been in the upper-right corner of each service card has been removed. The local status is indicated by the Play button of each service card.
• The remote status icon has been moved to the upper-left corner of each service card, and is integrated into the service type icon.
• There are new quick access buttons for Local Documentation and opening the C# code in the upper-right of the service cards.
• The checkboxes in each service card have been removed. The play button at the top of the window now spawns a dropdown with a multiselection for which services to run.
• Finally, the log view will automatically truncate and paginate logs above 5000 characters. A new button at the bottom-right of each service card allows you to copy the selected log to the clipboard.

These updates to the Microservice Manager are intended to streamline the user experience and reduce the onscreen complexity.

Bug Fixes

Beamable 1.6.0, 1.6.1, and 1.6.2 also included bug fixes.

• The Microservice publish window had some strange edge cases regarding multiple instances of the window.
• Additionally, the Party SDK events no longer trigger more than once if a player exits and rejoins a party.
• There was an ordering bug with the Observable SDK that caused the OnElementsAdded event to trigger before the elements were available in the observed list.
• Now, when the OnElementsAdded event is triggered, it contains the newly added elements as a parameter, and the underlying list has the new elements. 

Video Demo

Check out this YouTube overview of all these changes and fixes:

Change Logs

Our changelogs can be found at
https://github.com/beamable/Changelogs/blob/production/com-beamable-changelog.md

In October, Beamable released SDK versions 1.4.0 through 1.5.2. Watch this overview with Beamable engineer Chris Hanna for a tour of features, or check out this quick blog post of notable enhancements.

Microservice Stability

We’ve spent a lot of time focusing on Microservice stability over the past month. Several bugs have been addressed, including Microservices being stopped when entering Play mode, errors during Microservice building, DockerNotInstalled exceptions, and various UI glitches. The publish flow for Microservices has also been improved and the TaskCancelled exception and curlError issues have been resolved. 

Party SDK

In Beamable 1.4.0, we released the Party SDK. The Party SDK allows players to invite their friends to groups before entering a Lobby or Matchmaking. Each Party has a leader, and when the leader is placed into a match, the rest of the party will be as well. The party leader can promote or remove other members of the party. The Party SDK is built with Beamable’s observable SDK pattern to make it ergonomic and easy to work with. 

Unity Asset Store 

Beamable is now available to download from the Unity Asset Store. Previously, Beamable could only be downloaded from the Unity Package Manager. You can download and import Beamable into your projects from the Unity Asset Store, without the hassle of needing the old Beamable package installer. Beamable distributions will continue on Unity Package Manager and are still the place to get access to the latest builds and preview releases before they become available on the Asset Store. 

Auto-Generated SDK

The SDK includes an advanced way to communicate with the Beamable servers. The Beamable APIs are documented with the standard Open API specification. The Open API specifications are used to automatically generate C# client code that can be used alongside the regular Beamable SDK. Of course, we recommend that you use the Player-Centric SDK whenever possible, but there may be highly customized scenarios beyond what is already covered by the Player-Centric SDK. In those cases, the auto-generated SDK provides a bare-bones way to communicate with Beamable without introducing any abstractions.  

SDK Enhancements

Between Beamable 1.4.0 and 1.5.0, there have been many usability improvements to the SDK. The Search Stats method accepts more types for query parameters, such as long, to enable searching for stats with the greater-than or less-than operators. The SimNetworkEventStream can be augmented with a custom fault tolerance algorithm. Custom Content C# classes now support nullable primitive types. MailUpdate and MailSend objects support expiration dates. Check out the changelogs below for a full list of improvements! 

Change Logs

Our changelogs can be found at
https://github.com/beamable/Changelogs/blob/production/com-beamable-changelog.md 

 

October 19, 2022 – Boston, MA – Today Beamable is announcing acceptance into the MongoDB for Startups program which targets early-stage, high-growth startups with additional support, co-marketing, and industry connections. MongoDB is at the center of Beamable’s live services platform. Beamable makes heavy use of Mongo Atlas inside of its base services, as well as offers up direct access to native mongo instances with the Beamable persistent microstorage option.

Beamable C# MicroStorage is a tool that enables developers to create, deploy, and manage serverless MongoDB databases all from within Unity. Game teams get full access to a database through Beamable C# Microservices, or through any third-party database tools you prefer. We’ve pre-packaged data snapshot and restoration tools, as well as a data explorer so game devs can visualize, edit, and monitor their data. Beamable also provides a raw connection string to the database so developers can use the workflow and tools that work best for them.

With C# MicroStorage powered by MongoDB, game teams can leverage geospatial queries, time-series data, multiple indexing, and take advantage of the ease of NoSQL document storage techniques to build their games. That could include implementing user-generated content systems (UGC), or any other custom mechanic that requires persistent data.

Beamable is dedicated to delivering the best of MongoDB, without any of the hassles. When a game scales up to support millions of players, Beamable’s MicroStorage will scale with it. Now, as a member of the MongoDB for Startups program, MongoDB will be there to directly assist along the way.

For more information about Beamable’s MicroStorage option, view the documentation.

 

 

Boston, October 11, 2022 – Beamable, a fully managed LiveOps game server platform, announced today that it has joined Unity’s Verified Solutions program and that the Beamable Live Game SDK is now available in the Unity Asset Store. As a Verified Solution, the Beamable Live Game SDK has passed rigorous quality assurance testing by Unity to ensure it is optimized for the Unity editor and enables a seamless workflow for Unity developers to rapidly add game server features like social, commerce, content management, multiplayer, and LiveOps orchestration to any Unity game project. 

Jon Radoff, CEO of Beamable notes, “It is exciting to be approved for this program by Unity as the first verified LiveOps platform in the Unity Asset Store. Our mission is to make it easy for game developers to build live games and becoming a Verified Solution means developers can build game servers faster than ever in C# right inside of Unity. ”

Once installed in a Unity project, the Beamable Live Game SDK comes with an integrated web portal for game, content, and commerce management, custom microservices you can author in C# to power fully managed and scalable game server features, and a range of managed services to rapidly implement stores, inventory, leaderboards, live events, groups, chat, friends, tournaments, and more. 

“Our goal is to eliminate the friction between game client and game server development,” explained Beamable CTO Ali El Rhermoul. “Instead of having to add different paradigms, cloud code languages, and infrastructure on top of your Unity development, with Beamable you can do everything in one language with one developer workflow. All of your game code, client and server, lives together in one repo with integrated DevOps, build process, and content promotion.” 

Download the Beamable Live Game SDK from the Unity Asset Store today to gain access to a LiveOps portal and C# microservices that let you create completely customized backend code that is automatically scalable and fits into your native development processes in Unity.

UPDATE May 2023: Beamable removed its SDK from the Asset Store due to the cost of maintaining a listing. Beamable can be downloaded directly by registering on this website.

About Beamable

Beamable fights for the game makers of the world by enabling them to build faster and operate worry-free. The company’s full-stack LiveOps platform for live games is tightly integrated with the Unity 3D engine, enabling game developers to focus on the creativity and differentiation of their products. Beamable is based in the Boston area and led by a team of game-industry and software-as-a-service veterans and backed by investors including Companyon Ventures and GrandBanks Capital.

Beamable adds funding that expands Web3 live services and receives investment from Solana Foundation

October 04, 2022 (Boston,  MA) —

As of October 2022, over 4,000 unique game projects have started on the Beamable platform. The type of games spans every category of online game experience: mobile games, PC games, virtual reality (VR), and consoles. One of the largest segments of growth has been web3 games: projects that use blockchain for building open economies. Today, Beamable announces its roadmap for web3, as well as an investment from Solana Foundation to support this expansion.

“The big shift in 2022 is that web3 game projects have moved beyond proofs-of-concept,” said Jon Radoff, CEO of Beamable. “Games we’re seeing today have longer development horizons, more experienced game design teams, and a focus on the inherent fun of the experience. These games use next-generation blockchain technology that is scalable, fast, and ecologically responsible.”

Games building on Beamable have used several layer-1 blockchains. These technologies use proof-of-stake algorithms which are energy efficient, fast, and highly scalable. Games built on these blockchains offer access to marketplaces, decentralized trading platforms, and other composable technologies that enable game developers to build games that leverage a vast community of interoperable software.

As part of the expansion into Web3, Solana Foundation has made an investment in Beamable. Recently, at Korea Blockchain Week, Beamable was included as a key element of the Solana GameKit technology stack–intended to accelerate the development of blockchain games built on Solana.

Beamable’s unique advantage is that it makes building games built on live services easy and scalable: instead of coding a custom backend and figuring out how to connect all of the pieces, you build games using Unity–the most widely-used game engine–and use drag-and-drop interfaces to configure your economy, social systems. Similarly, server logic can be created using highly composable C# microservices. Beamable’s vision for Web3 is to make building a game for blockchain as simple as clicking your preferred layer-1 provider, bridging the world of blockchain with the high performance and familiarity of a game server.

To learn more about Beamable’s Web3 technology, visit https://beamable.com/why-beamable/web3-integration. Learn about the company’s vision for live games at https://beamable.com/about 

About Beamable

Beamable provides a Software-as-a-Service platform for the business operations of live games. The platform is tightly integrated with the Unity 3D engine, enabling game developers to focus on the creativity and differentiation of their products. Led by a team of game-industry and Software-as-a-Service veterans, Beamable is based in the Boston area, and backed by investors including Permit Ventures, Companyon Ventures, GrandBanks Capital and Defy.vc. For more information, visit beamable.com.

Why does Beamable price the way that it does? Here is a detailed overview of the goals and details of our subscription and enterprise pricing models.

Pricing Goals

Our pricing is the result of the requirements placed on Beamable to provide business-critical infrastructure. To be successful, we need to succeed at the following:

• Make the problems of game server patchwork, integration, and DevOps go away. 
• Allow teams to orchestrate, operate, and drive the success of their games with advanced LiveOps tools.
• Deliver high performance and low latency at any level of game scale.
• Seamlessly accommodate 3x-10x traffic surges to a game based on marketing, UA, and re-engagement campaigns.
• Provide bulletproof security in different client, server, and hybrid/3rd-party architectures.
• Achieve a minimum of 99.9% uptime at the Enterprise level.
• Provide new and enhanced features that keep pace with the rate of game tech innovation and player expectations.

Pricing Summary

At a high level, here is how our pricing works:

1. Beamable charges $10 per 1M API calls with no-commitment On-Demand pricing.
2. Above the free tier, you agree to a monthly subscription to unlock developer seats, # of allowed microservices, access to custom reporting, and increasing levels of support.
3. Monthly subscriptions are month-to-month and can be canceled or downgraded with a 30-day notice. 
4. If you go above a tier’s included API calls, dev seats, or microservices, you automatically move up to the next tier. You will be notified in advance and have 3 days to reduce usage back to a lower tier level.  
5. For larger games, you can agree to Reserve Pricing on a 12-month contract with additional Enterprise benefits. 

$10 per 1M API calls

This is an all-inclusive price. Beamable does not charge for storage or bandwidth. We do not charge separately for cloud code, LiveOps tools, or DevOps tools. This gives you, the game developer, unprecedented control over your costs by making efficient use of the Beamable APIs and any requests you make over the gateway. 

A Monthly Subscription

You can start a free trial of Beamable. As you scale up your project, team, and usage with additional developer seats, realms, or custom C# Microservices, you’ll be required to tier up your subscription. The higher tiers also come with more support for your implementation. You can see the breakdown of these tiers on the pricing page.

	Free	Indie*	Dev	Studio	Reporting	Pro	Pro Plus
Subscription	$0	$30	$100	$200	$300	$600	$1,000
Dev Seats	1	3	3	10	10	20	30
Included API Calls	100k	3M	10M	20M	30M	60M	100M
API Overage	N/A	$10 per 1M	$10 per 1M	$10 per 1M	$10 per 1M	$10 per 1M	$10 per 1M
Microservices++	3	3	3	9	9	18	27
Addl Microservice	n/a	$30	$20	$20	$20	$20	$20
Athena Access	No	No	No	No	Yes	Yes	Yes
Support	Discord	Discord	Email	Email	Email	Private Chat	Private Chat

Subscriptions are billed for all games and realms at the customer (CID) level.

* Indie tier only available to independent/international game teams with no revenue or funding.

++ Microservices are counted per service per realm. One microservice across three realms (dev, staging, and production) counts as three services. 

Enterprise Pricing

If you have a larger game project with >200M API calls, it makes sense to contact us about Reserved Pricing that has a few advantages:

• Pre-buy 12 months of API calls with a monthly commitment. 
• Any API calls not used in that month do roll over to the next month to offset future overages.
• Any API calls not used in 12 months do not roll at contract renewal. 
• Customers can increase the monthly commitment at any time in the contract term to achieve more savings. 

Contact us to discuss your Enterprise Pricing needs

Summary

• Beamable is free to develop for a single developer with less than 100k API calls per month and up to 3 microservices.  
• Additional Dev seats, Microservices, and API calls are available at Dev ($100 a month) or higher tiers.
• Additional Microservices at any tier can be purchased incrementally for $20 each.
• Custom reporting access is available at the Reporting tier ($300 a month) or higher.
• Private chat and additional support are available for $600+ subscription plans.
• Additional monthly API usage is billed at $10 per 1M API calls.
• Reserve pricing, API call rollover, and additional discounts are available for games making more than 200M API calls per month.  
• Enterprise support (with regular meetings and an SLA) is included with all Reserve Pricing plans.

Beamable has released an update to our LiveOps Portal.

• Trials: It is now more visually obvious how to add “OR” and “AND” conditionals
• Message Campaign table row shows “English (Default)” badge alongside the other languages
• Content Rollback is now possible via the Portal
• Messaging editor supports adding a picture via paste command
• Write access and visibility parameters added to player search by stat.

• You can now Edit User Permissions of newly added users
• Message Campaigns: Fixed how Button Editing Tooltip disappears too quickly
• Join Now link on invites for new game developers/admins added to an account is now fixed
• Punctuation in studio names is now blocked during registration form validation

Sign up for Beamable today and give it a try!

The real challenge in game development isn’t building the game—it’s building the game efficiently. 

Building efficiently means getting your game out into the world faster so you can generate revenue from your players and sustain the game and player experience for years to come. 

The time it takes to develop a game ranges tremendously—anywhere from a few months for a simple game to five years for a more complex one. (Although, if you’re really good, you might be able to build a game in 15 minutes). But besides complexity and budget, what’s the biggest time factor?

How you build and launch it. 

You could create everything from scratch—from the game engine and server infrastructure to the data design and content pipelines. But a better option is to streamline the process by taking advantage of a game development system that takes care of the development infrastructure for you. 

Read on for three ways you can save time and get to profitability faster by launching your next game with Beamable. 

1. Use Unity Frameworks and Prefabs

You want to spend as much time as possible on your core game loop and differentiating factors like story, character, world-building, and compelling gameplay mechanics. But the more time you spend worrying about DevOps, system integration, and server build-outs, the less time you’ll have to focus on your actual game. 

Use a pre-developed architecture to avoid reinventing the wheel. Game development platforms like Beamable let you enjoy robust game server architecture without having to develop it from scratch. It saves you time on backend programming, server scaling, and live operations.

Drag-and-drop prefabs also save you time coding. Rather than building game elements from scratch, you can simply customize a template. For example, game economy prefabs, like inventory, stores, and virtual currency, allow you to quickly build a functional game economy for your users. These aren’t just easy to duplicate since they also make it easier to edit without causing a cascading effect throughout your game code, saving time on testing.  

Create social systems that drive engagement and player retention to drive early growth and initial profitability. For example, in early versions of the game, enable groups or guilds, leaderboards, tournaments, in-game messaging, and time-limited events that build compelling engagement loops. The higher your retention, the faster the game will be financially sustainable.

2. Host and Update Games Live

Launching your game is just the beginning. After that, there are constant updates, optimizations, and adjustments you’ll need to make to stay relevant and increase engagement. 

Live operations (LiveOps) are changes you can make to your game without having to release a new version. They can include changes to gameplay, design, or characters. By doing live updates, you don’t waste time taking your game offline to update it. LiveOps also lets you ship faster because you’ll know that you can make further changes and modifications as you go. 

Save to the cloud. Cloud save automatically syncs player data to the cloud, so you don’t have to worry about servers crashing or losing data if a player’s wifi drops. It’s efficient because it helps keep data in sync even if there are server or player internet connection issues. 

3. Learn About and Delight Players

There’s more to a game’s success than the game itself. There are analytics, sales, and customer feedback. Building your game efficiently means ensuring these are in place from day one so you can make informed product decisions and optimize revenue. 

Implement analytics. Player usage data helps drive business insights and improve your game, which can save you time. Analytics equips you to make the right product decisions so you don’t waste time building the wrong features. 

The fastest way to access this data is with the pre-built tools offered by a game development platform—things like frictionless player authentication and instrumentation. With one line of Beamable’s code, you’ll know everything your players are doing in the game—their sessions, spending, and usage statistics. 

Include the commerce features that drive conversion and revenue. You might want to offer the basic in-app stores and player offers, but you can take your revenue to the next level by also providing segmented offers, timed offers, and a range of localized and customized A/B testing and trials. Including these from the beginning reduces your time to profitability.

All of these features come out of the box with Beamable. Our system comes stocked with full web-based tools to manage in-app sales, host a calendar of events, create engaged communities around your game, and perform critical player support.

Drive Success with Efficient Development

The best games take time to develop—there’s no way around that. But there are ways to work smarter and faster. You get to choose: do you build the in-game chat functionality yourself? Or do you simply use a template and customize the look and feel?

Beamable can help you launch a compelling and revenue-generating game by giving you access to a rapid workflow. It offers a Unity framework with pre-designed game modules to save time during development and gives you LiveOps tools to quickly update games and keep users engaged. You’ll also get the business intelligence tools you need to optimize your game to consistently delight players.

The efficiency pays off. Game studios using Beamable have reduced their required team by up to 5 people just through DevOps and LiveOps tool efficiency. Plus, a Beamable implementation can be fast—it can take only 2-3 months to create your entire game server backend. 

Sign up for Beamable today to build better games faster.

Since 2015, Tiny Digital Factory (TDF) has been an independent developer and publisher specializing in the exciting world of mobile motorsports gaming. By 2017, the experienced team of over 30 game developers looked to Amazon GameSparks to provide critical backend game server infrastructure for free-to-play mobile titles. When TDF was told that GameSparks was going away, they had to rapidly find a new game backend partner. Read on to learn how they chose Beamable.

Challenge

In August of 2021, Amazon announced it was sunsetting GameSparks which sent Tiny Digital Factory on a search for a new game backend-as-a-service (BaaS) partner. The team at TDF was already considering making a backend game server move and the need to migrate off by September of 2022 was the motivation to rapidly and methodically search the market for a new solution for GT Manager and other new projects.  

Tiny Digital Factory faced three main challenges when evaluating backend game solutions:

1. Multiple programming languages – Most game server technologies require you to write your game client code in one language and your game server in another. In the case of TDF, their games are built in Unity using C# and they often have to switch to a cloud code script like Javascript in order to implement game server features. Writing Javascript is not difficult, but without specialized developers, it is hard to optimize. 
2. Performance – Due to the lack of specialization in multiple languages, managing game performance as the number of players increases is a challenge. You can write functional code in a scripting language like Javascript, but as the number of calls by active players increased, scalability became a real challenge. The new solution would need to scale much more predictably. 
3. Timeline – With GameSparks scheduled for sunset in less than 12 months, whatever solution was chosen for migration would need to be rapidly implemented. There had to be solid support and clear parity across critical game features. 

Solution

Tiny Digital Factory found out about Beamable from the GameSparks Migration documentation. There were a number of very clear examples of how Beamable features lined up with GameSparks features which made it easy to understand how the migration would take place. It was also important that whatever game backend TDF moved to next, it should have deep Unity integration and leverage C# as the primary cloud code language.

Beamable checked both boxes. 

Of particular value was Beamable’s C#Microservices with MicroStorage feature. Being able to write C# side-by-side on the client and server, have everything live in the same Github repository, and use the same systems for pull requests and developer workflow was judged very unique and desirable by the TDF team. 

Finally, Beamable’s PRO Support plan checked all the boxes to ensure that the Tiny Digital Factory team had everything they needed for their migration. 

“Every developer working with Beamable is in slack. The fact that we can get a simple answer most of the time and a deeper one in a few hours is really great.” 

Results

Tiny Digital Factory successfully migrated GT Manager within five months and has proceeded to build new projects on Beamable. 

“Working directly in Beamable, it has gone faster than expected. Building, deploying, testing is really fast!” 

One of the biggest surprises working with Beamable has been the speed of new developer onboarding. Since everything is in C#, Tiny Digital Factory can bring on a new Unity engineer, get them set up with their environment, and in one day that developer can create a C# Microservice, make material changes, and start checking in code that moves the game roadmap forward. 

“The onboarding is really, really fast for C# devs. For anyone that needs a backend with Unity, Beamable should be the first one they think about.”

To try Beamable for yourself, sign up for free and see what you can accomplish. Check out our sample projects and contact us with any questions. We are here to help you be as successful as Tiny Digital Factory!

Beamable is happy to announce the release of our Unity SDK 1.3.0. You can read about all of them in the changelogs, and see the highlights below. Also, check out the demo video with Beamable Engineer Chris Hanna as he walks you through the newest features!

Better Microservices

Microservices are a major focus of Beamable 1.3. Perhaps the largest improvement is the ability to archive microservices that you no longer need. When you archive a microservice, you can delete all of the relevant local files, and remove the microservice from your future deployments.

Speaking of deployments, Beamable 1.3 adds a verification phase to the deployment process so that microservices that fail to start won’t be allowed to deploy to the realm. The deployment process can take a long time, so in 1.3, we’ve made sure you can alt-tab away from Unity and focus on other work while the deployment is in progress.

Additionally, if you’ve decided to disable a service, Beamable 1.3 will not upload the service, which saves you time. Beamable will now accept microservices built for ARM and AMD-based CPU architectures. You can select which architecture to use locally as well as for deployments by using the settings in the Project Settings / Beamable / Microservice window. There are also several improvements for local development speed, such as pre-fetching the Beamable base Docker image, caching Dotnet and NuGet restore flows, and consolidating startup actions. 

Workflow Enhancements

Beamable 1.3 has several improvements for the developer workflow in Unity, such as realm permissions, Beamable environment switching, and various bug fixes.

As a team lead, you can use the Live-Ops Portal to manage realm permissions for team members. Beamable will respect these permissions on a per realm basis, so that a developer can be an admin on their personal development realm, allowing them to publish content and microservices, but only be a tester on the production realm.

If a developer wants to experiment with the latest and greatest Beamable packages, they can change their manifest.json file to point to the nightly track of Beamable package releases. However, the nightly Beamable builds use Beamable’s internal development servers. Until Beamable 1.3, this meant that you’d need to create a new customer account on the nightly track to test new features. Now, you can use the Environment Switcher in Window / Beamable / Utilities / Change Environment to select between Beamable’s development or production servers. Learn more about the environment switcher here: https://docs.beamable.com/docs/unity-editor-login

More Functionality

Beamable 1.3 brings new functionality for social interactions between your players. The new managed Friend system allows players to invite, block, or remove other players as friends. Learn more in the docs here: https://docs.beamable.com/docs/friends-feature-overview

The Beamable Party SDK is available as a preview feature and allows your players to form groups before entering the Lobby flow.

Chat SDK capabilities have been added to the Microservices SDK.

Finally, you can access request headers in the Microservice which empowers you to make decisions based on the player’s application version, or Beamable version. Learn more about it here: https://docs.beamable.com/docs/microservices-code

Detailed ChangeLogs

Full changelogs can be found at:

• https://github.com/beamable/Changelogs/blob/production/com-beamable-changelog.md 
• https://github.com/beamable/Changelogs/blob/production/com-beamable-server-changelog.md 

Get Started!

To try Beamable for your game project, sign up for free today!

For over a decade, Old Skull Games has carved out a reputation for developing high-quality, creative games for mobile, PC, consoles, and other cutting-edge platforms. 

But it hasn’t been entirely smooth sailing. As they began to expand their game offerings and player experiences, they realized they needed more than their previous game development infrastructure (Firebase) could handle. After a brief try building their own infrastructure, Old Skull Games found Beamable’s live game platform—and they haven’t looked back.

Read on to learn how Old Skull Games brought Beamable into their game development process.  

Challenge

Old Skull Games began their journey using Google’s Firebase as their primary game development infrastructure. It was successful for several years, and Old Skull used it to create several popular and well-loved games. But eventually, the cracks began to be too large to ignore. 

For one thing, Old Skull found that they wanted to be able to update their client’s game more easily than Firebase could allow. They wanted to be able to edit game data live. Unfortunately, their Firebase infrastructure only allowed them to do this through an official game release. Second, Old Skull wanted to have two different environments for the game—one for testing and one for deployment. Firebase was unable to accommodate their need for a double environment.

“Not having two different environments was becoming increasingly problematic in order to test live features before a launch.”

Most critically, Firebase was significantly limited in what it could accommodate in terms of live operations features, like live events, promotions, and announcements. When Old Skull saw that the next games in their development pipeline would require more and more live operations, they recognized a better infrastructure solution was needed. 

“We decided that our current, but especially future games, will rely more and more on Live Operations features in order to be successful.”

Old Skull tried to build their own player cloud save feature, but the results were poor: the feature was buggy and unreliable. It also began to take their developers’ time away from game development. Eventually, they began to look for an alternative solution that could accommodate their Live Ops needs.

Solution

Beamable was recommended to Old Skull by Amazon through the Amazon Partner Network membership. They chose it because the Beamable platform had all the key features that their games needed to operate in a live, connected game context: the Live Game Platform, player authorization, and cloud save.

Old Skull implemented Beamable’s solution over four months. This quick implementation was possible because of Beamable’s integration with Unity, the game engine that powers Old Skulls’ games. The solution immediately worked as intended, freeing the Old Skull team up enough that they began to consider additional Beamable features, like A/B offer trials and player segmentation. 

Old Skull also signed up for Beamable’s PRO Support service. This hooked them up with on-demand support as well as weekly work sessions in a private Slack channel with Beamable’s engineering and customer success teams. They used these sessions to ask questions, identify barriers to development, brainstorm solutions, and report on progress. 

“When we had a major problem with CloudSave, the support team reacted straight away, fixed the issue, and released a new version on the same day to help us address the situation.”

Results

Beamable was exactly the solution Old Skull was looking for:

• Multiple environments. Beamable enabled them to set up several environments so they could have an isolated test environment for new updates. These were particularly useful for Time-Limited Events that are common throughout Old Skull’s games.
• Content manager. Beamable’s content manager allowed Old Skull to modify game data live, without needing to release an entirely new update. 
• Support. Old Skull has been pleased with the level of support they’ve received from Beamable—especially compared to the support they received from Firebase. They have described Beamable’s support as competent, humble, and caring.

Compared to Firebase, Beamable was a massive upgrade. Old Skull not only continues to use Beamable, but they continue to add more features to enhance their game offerings. 

Old Skull’s team of innovative game developers delivers engaging experiences on mobile devices, PC, and console platforms. Increasingly, those games require Live Ops functions that not all game development infrastructure can provide. Beamable’s platform provides everything Old Skull needs to give their players a live gaming experience that keeps them coming back.

Try a sample project yourself and see how Beamable can help you deliver top-tier gaming experiences to your audiences. It’s free to develop and you only pay for what you need at game launch. Download Beamable today.

A group of 4 members of the Beamable development team participated in a game jam last week and were tasked with coming up with a new playable game at the end of two days. The game, built on Beamable and developed in Unity, is called The Last Barbarian and is playable in your browser on PC and MAC here. If you’d like to learn a bit more about the game, keep reading!

The game can be played using arrow keys, a mouse or the on-screen touch controls and the objective is to survive waves of enemies and score as high as you can on the leaderboard. As you can see in the below screenshot of the interface, the UI contains information including an exp bar, your health, the number of points you’ve accrued in your run and which enemy wave you are currently on and many of the features within the game are using features that can be added to any game using one click with Beamable.

The game also harnesses to power of Beamable in order to create a Hero Profile which can be accessed between attempts at scoring on the leaderboard and gives players the ability to use the gold they acquire during matches to permanently upgrade their character making them go even further in their next run.

Also powered by Beamable is The Last Barbarian’s live leaderboard, which tracks every player that plays and ranks them by the highest score they’ve achieved while playing. Send the game to some friends and see if you can beat them!

Built in Beamable, The Last Barbarian is playable here. Want to build your own The Last Barbarian? Sign up for free today and start adding features to your game like Leaderboards, Currency and more with the ease of one click!

In today’s blog post our Lead Unity Engineer Chris Hanna is here to help you rapidly build a game in 15 minutes with Beamable and implement features such as Leaderboards, Currency and more!

Want to learn more about Beamable?

Learn more about Beamable’s features here or sign up and try Beamable for free!

Non-developers need a place to go to their operate their game and the Beamable LiveOps Portal gives creators the ability to deploy content error-free without engineering. By using Beamable’s LiveOps Portal, game creators get access to important reports needed to measure the success of your game, including Analytics such as:

• How many unique total players you have per month (MAU)
• How many active players you have per day (DAU)
• How many of those users are returning users that have played previously (Retention)

Beamable even includes KPI’s out of box that will help you determine the success of your game, give you an understand of core player behavior and showing advancement towards key monetization goals for your game.

The portal also gives makers the power to download overall player analytics or dive into the player profile page and go into each individual’s statistics.

Want to try out our LiveOps Portal for free? Sign up for Beamable today.

Beamable, combined with Unity, empowers developers to utilize powerful and flexible solutions to communicate with their players and interact with their game through four LiveOps features: Events, Announcements, Notifications and Mail.

Live Events:

Events give the ability to set up one-time competitions with support for multi-phase events that can be done over a finite time, increasing both social and competitive engagement among players. Beamable can be used to even tell players how they are doing through leaderboards and can be used to distribute rewards to the player base based on their performance during the event.

Announcements:

In-game Announcements increase engagement and revenue, often with a multiplier effect from an engaged player base. Beamable’s Announcement Live Ops feature allows development teams to speak to use their game to speak one-to-many through our unique communication platform. Beamable even supports Announcements as a pre-fab, helping developers save time and integrate announcements as fast as possible.

Notifications:

Beamable’s Notifications system gives developers the power to provide their players real time updates based on server data, and can be used, much like Announcements, to communicate one-to-many.

Mail:

Mail systems are also being used increasingly more in many games, especially on mobile, and Beamable gives devs full access to an in-game Mail system, enabling one-to-one narrowcast communication between a developer and their playerbase.

Want to unlock the power of Beamable Live Ops today? Sign up for free and check out Beamable today!

 

This article examines the value of having experience or a college degree when entering the Video Game Industry. 

In a world swarmed with creative influencers, content creators, and multi-million dollar business owners, who have all graduated with less than a college degree, many have wondered how important a college degree is these days– especially in the Videogame Industry. The idea of a college degree being superior to an experienced individual in any field has shifted to a phenomenon rather than the standard. While rising tuition costs have directly influenced attendance and graduation rates among university students, there is still value behind a college degree. 

I even went through this journey myself recently, as I  am 22 years old and recently graduated from The Pennsylvania State University. While I am fortunate to be working straight out of college many of my friends have not been so lucky, some having double majors. I noticed how many job listings in the Videogame industry required 3-5+ years of experience for an entry-level position, and how many of these positions did not require a college degree. Seeking an answer to the age-long debate of what is better? Experience or a degree, I sought out the perspective of various employees from within Beamable with varying backgrounds in and out of the gaming industry. 

A Beamable representative located in the United States, who holds a degree in Computer Science explained that “Game dev is an intersection of many fields, each with their own rich depths and knowledge bases….[getting a degree] allowed me to focus my skill set on one of the many required skill sets required to develop a game. All that being said, it is still the case that doing is better than anything else.” 

Another Beamable employee, located in the United States, who attended college without receiving a degree explained that “The pros of not attending college are no student debt and having the ability to chart my own path; however the cons of going the experience route is the time it takes to achieve certain milestones is much longer, and it is hard to get an entry-level job without a degree -OR- experience.” They noted that “ One thing I really did like about my time at college, even though I did not receive a degree, was being surrounded by people who were excited about learning.” 

A Beamable representative located in Brazil explained that “I haven’t really seen degrees correlating that well with great professionals. In fact, the best designers/engineers/artists I’ve worked with directly here in Brazil—have no degrees or have ‘low-level degrees.’…Most of the people with great degrees fell on the other end of the spectrum as far as technical skill was concerned.’

Taking an excerpt from a Beamable Representative quoting our CEO Jon Radoff they explain,  “[For engineers and designers], continuous demonstrable curiosity coupled with critical thinking skills (first-principles thinking, etc…) tends to beat out degrees.” Whether college is a good place to gain these traits/skills is another discussion in itself. When asked directly why both experience and degrees matter in the industry Jon Radoff explained, “ What’s actually important in the industry (assuming you’re talking about getting a job at a game studio) is having a portfolio of work that you’ve done. I find the most valuable part of a degree is that it gives you access to a lot of other people to collaborate with, and the space to develop some ideas. So the most important thing to do before graduating is to use every opportunity to build a portfolio. You should do the same while working inside the industry.”

Derek Struble, Director of Product Marketing at Beamable located in Canada, has a unique experience when it comes to attending university. He explained that “I never imagined going into game dev when I was in school because I didn’t get accepted into computer science…However, I did go get a Business Administration degree and what I found when I started as a QA tester is just the fundamental knowledge of how to manage projects, my time, help others, Excel, and all this other information I picked up in school helped me hit the ground running at first. That ability and my degree as the ‘scaffolding’ on which my career was eventually built allowed me to quickly pick up a running team, managing project finances, and my market research experience, brought me to even further new heights in game dev as it allowed me to build a market research arm at one of the companies I worked at…I feel like my degree is invaluable, not for directly getting a job in games..but instead for giving me all the fundamental tools I needed in order to succeed. I just happened to apply those tools to game development because it’s an industry I love.”

Personally, the direction, connections, and opportunities given to me during my time at Penn State helped direct me to my introduction to working in the game industry. Throughout the past four years, my skills were able be cultivated and refined with school, instead of being lost without structure, taking more time to realize what I truly wanted to do. I believe that school is extremely important for those who feel they need it to determine their sense of direction like myself, and it is not a necessary step for many jobs in the industry. I was able to begin my future at Beamable due to Alumni connections from Penn State which is one of the ways I utilized my time during school and building my network portfolio. 

How about you? Has your degree helped you get into the video game industry or did you get in by learning and gaining experience another way? Connect with us on Facebook, or tweet us on Twitter. Join us on our Discord to expand your network and learn more about what we can do for you!

Beamable Game Dev Podcast Ep 31

In episode 31 of the Beamable Game Dev Podcast Chris Hanna gives us the inside scoop on the latest Beamable update. Beamable 1.2.0 is here! Moving forward with Beamable 1.2.0 means you will need to update your game from Unity 2018, but rest assured that you can use Unity 2021. Beamable 1.2.0 will continue to support Unity 2019, 2020, and 2021 until further notice. Click here for all the details on Beamable 1.2.0

Come meet our team in person!

Here are the events that Beamable representatives will be at in June 2022: 

Game Jam – Beamable/Amazon Kick Off – June 21 – 23

 Game Jam Bavaria – AWS/Beamable/Gamejolt – June 24 – July 1

 

Beamable is happy to announce the release of our Unity SDK 1.2.0.

You can read about all of them in the changelogs, and see the highlights below.

Unity 2021 LTS

Beamable 1.2.0 brings support for the latest Unity Long Term Support (LTS) version. Unity 2021 LTS was released in April. Beamable is committed to supporting the latest three LTS versions. As such, Beamable 1.2.0 is dropping support for Unity 2018 LTS. 

Lobby SDK

The Lobby SDK allows players to find, create, and join game lobbies. A player can create a public or private lobby. Other players can join a lobby through a public listing, or use a Join Code to access a specific or private lobby. The Lobby SDK also manages player presence and readiness. Finally, all the players in a lobby can enter the game itself with whatever multiplayer framework you choose. The Beamable Lobby SDK is compatible with Beamable’s own Relay Server, but it can also be used with Photon, Unity’s networking solutions, or a custom multiplayer solution.

Microservice Improvements

Beamable Microservices continue to improve with Beamable 1.2.0. One particularly nice improvement is the ability to use GUID based references in your Microservice dependencies. Previously, the “Use GUID References” checkbox had to be disabled in order for Beamable Microservices to build properly. Now, by using GUIDs, you can rename your assemblies and dependencies without needing to worry about breaking Beamable Microservice references. We’ve also added a few additional methods to the IMicroserviceLeaderboardAPI so that you can get all of the leaderboards associated with a player. Finally, [ClientCallable] methods can now return subclasses of ContentObject directly.

Beamable 1.2.0 also has a breaking change concerning [ClientCallable] method security. Going forward, all HTTP traffic to a [ClientCallable] method must include a valid Authorization header. If it doesn’t, the request will fail with a 401 HTTP error. This breaking change should only affect developers who are using [ClientCallable] methods outside of the Unity game client. For those developers, Beamable 1.2.0 introduces a new attribute, [Callable], which works identically to how [ClientCallable] worked previously. To reiterate, this change only affects you if you’re calling Microservice functions from outside Unity or the LiveOps portal. Otherwise, this change does not affect your game.

Lastly, the EnableDockerBuildKit property in the Project Settings / Beamable / Microservices has been replaced with the DisableDockerBuildKit property. Previously, Beamable did not take advantage of Docker Buildkit, and left it as an opt-in feature. Beamable 1.2.0 reverses this behavior, and makes Docker Buildkit the default. The usage of Docker Buidkit enables developers with ARM based CPU architectures to publish Microservices to the Beamable Cloud.

Stability Improvements

The Beamable 1.2.0 release includes a wide variety of workflow and stability improvements. There is a new way to sort content in the Content Manager window. A dropdown next to the Realm dropdown allows you to sort the content based on id, type, or status. Additionally, the NotificationService now has a C# generic method to subscribe to events. This removes the need to add JSON deserialization code in your game logic. One final improvement to highlight is the addition of the Prevent Addressable Code Stripping setting in the Core Beamable configuration. When you build for Android or iOS, this setting will generate a link.xml file that ensures Unity’s Addressable code assets are not stripped from the build. To read about all the other improvements, check out the full changelog below or on our Github.

Added

• Unity 2021 LTS support.
• PreventAddressableCodeStripping Core Configuration setting that automatically generates a link.xml file that will preserve addressable types.
• TryClaim method in EventService to attempt a claim, even if one is not invalid.
• GetDeviceId method in AuthService to retrieve the current device id.
• deviceIds field on User object that provides all associated device ids.
• Content sorting option in Content Manager.
• Documentation to IBeamableAPI and all related accessors.
• Subscribe<T> method to INotificationService to avoid awkward serialization handling.
• Implicit conversion operators from Optional<T> objects wrapping a value type to matching Nullable<T> types.
• Inline style editor in BUSS theme manager.
• Added LobbyService and PlayerLobby to support new Lobby functionality.
• Support for GUID based assembly references.
• CallableAttribute for exposing C#MS methods that are meant to be publicly accessible (without authentication required).
• ListLeaderboards method to IMicroserviceLeaderboardsApi will return lists of leaderboard ids.
• GetPlayerLeaderboards method to IMicroserviceLeaderboardsApi will return leaderboards for a given player.
• lbId` field to the LeaderboardView response class.
• DisableDockerBuildkit property to the MicroserviceConfiguration. By default, Docker buildkit will now be enabled.

Changed

• ManifestSubscription subscription no longer accepts the scope field
• AccountHud logs a warning when pressed if there isn’t an AccountManagementFlow in the scene.
• Increased the AdminFlow scroll speed
• InventoryFlow can now be configured at the GameObject level.
• Edit mode for Buss Style Card has been removed in favor of context menus for selector label, variables and properties.
• Claiming an event that a player never submitted a score for will report an accurate error message.
• Added tooltips to Microservice Manager elements which didn’t have them.
• Microservice Manager buttons now highlight on hover.
• Microservices will be built specifically for linux/amd64 architecture. For developers with ARM based CPU architectures, enable to the DockerBuildkit setting in the Microservice Configuration to publish microservices.
• Building a microservice will always stop the microservice and its source generator if they are running. After the build, the source generator will be reset.
• Beamable third party context systems register with a default order of -1000.
• Global style sheet is turned now into a list of global style sheets.
• Content tags are split on ‘,’ characters in addition to ‘ ‘s.
• HeartBeat will now send heartbeat requests faster for our newer live backend services such as Lobbies
• Content validation for ID fields will now accept IDs without the prefix
• It is now possible to set background sprite as a main texture in SDF Image.
• It is now possible to choose 9-slice source and Pixels Per Unit multiplier in SDF image.

Fixed

• StoreView prefab now works in landscape mode.
• Playmode ContentObject refresh with disabled domain reload on Unity 2019 and 2020.
• Reading content in offline mode will no longer throw an exception if there is offline cache available
• Android sign-in will always allow user to select an account.
• Editor time Content downloads ignore content where no C# class exists.
• Account management will no longer log an error after pressing change password button more than once.
• Content Manager no longer logs inaccurate warning after renaming content.
• Notification handling for multiple BeamContext instances.
• Listing ‘sku’ price type was incorrect. Fixed to ‘skus’.
• The player’s location is detected automatically
• Matchmaking no longer breaks after user switches from Account Management flow.
• Client code can handle receiving a ContentObject response from a ClientCallable.
• Removed Microstorage related null reference errors on Unity startup.
• IMicroserviceNotificationsApi can now send strings with spaces in them for messages.
• IMicroserviceLeaderboardsApi will now respect HasValue flag of Optional<T> derived types in all cases.
• Fixed issue with Publish flow that caused an invalid Manifest data to exist when publishing any services along a service whose source code was no longer in the project
• Fixed issue that made it possible to start a remote service without its dependencies up and running (only happened in cases where the service was only remote — ie: the source code for it was not present in the project)

Removed

• Unity 2018 LTS support.
• EnableDockerBuildkit property from the MicroserviceConfiguration. By default, Docker buildkit will now be enabled. Disable it again with the new DisableDockerBuildkit field.

Our changelogs can be found at
https://github.com/beamable/Changelogs/blob/production/com-beamable-changelog.md

Meet Eva Ramirez from the Beamable Customer Success Team

This episode of the Beamable Game Dev Podcast it’s all about getting to know Eva Ramirez from the Beamable Customer Success Team. Eva’s role at Beamable is to make sure our customers are taken care of in a timely fashion. If a customer hits a snag Eva will make sure they get connected with the correct engineer to remove any blockers.

Outside of Beamable Eva creates content on Twitch as a V-tuber.

If you have any questions about Beamable jump into our discord here

Try Beamable for free here

 

The team at Beamable puts security first and foremost when we work on upcoming releases and we are making a change in how the ClientCallable function works in our upcoming 1.2 release.

Starting in 1.2, if you use ClientCallable you will need to ensure that all requests have a valid Authorization header, or else your request will not work anymore and fail with a 401 or 403 error. This is especially important if your project uses third-party webhooks as those requests will now need to be made using the new Callable function added in 1.2, which replicates how ClientCallable used to work.

If you are only using Beamable Microservices from within a Unity game client, this change should not affect your game in any way.

If you have any questions regarding any of the above or concerns about how this might effect you, please contact us at support@beamable.com

GamesBeat Summit 2022 took place about a month ago starting on April 26th and Beamable was there! In addition to our team walking the show floor our CEO, Jon Radoff, hosted two really unique panels. Both panels can be watched for completely free (after a short registration process) over at the GamesBeat Summit 2022 registration page.

The Changing Face Of Live Ops 2022 – Link

Jon sat down with Josh Yguando, Co-Founder and President of Jam City, and Jason Bailey, Co-Founder and CEO of East Side Games , to discuss the evolution of Live Ops in 2022 and where Live Ops will be going in 2023 and beyond. They also discussed player retention and how your average player has more entertainment choices in 2022 than ever before, so the bar for success continues to shift upwards and become more challenging, especially as player expectations rise when they play a game for the first time. The talk also dove into how publishers and game developers can optimize the live operations experience for their players to keep them engaged and form a community around the game.

The NFT Debate – Link

Jon also hosted a fiery debate panel regarding NFTs with panelists David Kim, Head of Publishing at WAX studios, and Rami Ismail, Strategic Director and Co-Founder of Vlambeer. The panel aimed to bring to the surface a lot of the debate points surrounding NFTs and the role they might play in video games both now and in the future as well as how the online conversation around NFTs can be so polarizing. Overall this panel ended up being the talk of the summit, and is well worth checking out if you are even moderately interested in the subject!

In closing, the Beamable team had a ton of fun at GamesBeat 2022 forging new friendships, moderating interesting panels and connecting with people around the industry. We hope to see you there next year!

 

If you’ve ever wondered what Beamable can do for your Unity game project or how to get started, we have good news: We now have a 10 minute video walkthrough of Beamable from our Chief Technology Office Ali El Rhermoul. If you’d like to know more about what is in the video, scroll down to learn more or if you’d rather just watch the video yourself, you can find it at the bottom of this post!

This video covers:

• Getting Up And Running With Beamable In Unity
• How Data Automatically Syncs Between Servers, Game Clients and Dashboards
• Creating Server Authoritative Microservices
• Microstorage
• Managing and Monitoring Microservices Using Dashboards

If you’d like to know even more about Beamable, sign-up today and start your free trial.

 

What it means for you:

DataSakura and Beamable are announcing a development partnership to help game developers with full cycle development, maintenance, support, and implementation of the Beamable Live Game Platform to power LiveOps and multiplayer experiences. 

DataSakura was founded in 2018 and has spent 10s of thousands of hours building and maintaining hit titles like Cut The Rope, Fruit Ninja, and Jetpack Joyride. They have deep experience with live game backend development, and a partnership with Beamable will allow them to get games to players faster, and operate more sophisticated LiveOps and content design. 

“We are inspired to collaborate with Beamable,” stated Andrey Vengerskiy, CEO of DataSakura, “they offer a powerful game server option for any new title or any title wanted to migrate off of a legacy backend.” 

Jon Radoff, CEO of Beamable explains, “DataSakura and Beamable both focus on helping game makers create the best games possible while accelerating game development and lowering costs. This partnership will help us take that focus to a new level.”

About DataSakura:

Founded in 2018, DataSakura offers full cycle game development services with a focus on excellence, full transparency and giving customers total control to scale up or down depending on project requirements. In addition to full cycle development, DataSakura also offers maintenance and support so that developers can reduce their development costs and enjoy step-by-step development acceleration for their projects.

About Beamable:

Beamable is a gateway to powerful game server functionality, enabling player authentication, rich game analytics, content management, player CRM, and much more utilizing one line of code. Led by a team of game-industry and software-as-a-service veterans and backed by investors including Companyon Ventures and GrandBanks Capital, Beamable fights for the game makers of the world by enabling them to build faster and operate worry-free.

Want to learn more about this partnership? Sign up for Beamable today or reach out for an introduction to the DataSakura team.

Beamable is part of the Saudi Arabia Game Jam

Allister sits down with Josh in this week’s podcast to update us on Saudi Arabia Game Jam. The Game Jam Fast Art is happening May 12-14. The theme for this game jam is hyper-casual. Allister introduced Beamable to the teams via a live presentation, but most of the teams will be seeing it at a later date due to the time difference. Microservices were the main talking point of the presentation and how it’s so easy to implement into their game.

Get to know Beamable before you jam.

With more game jams on their way, we are encouraging jammers to try to jump into Beamable before jams start. It is free to use and you can implement a leader or multiplayer with very few lines of code.

For more updates on what is going on check out our Beamable Around the World post.

 

Come Meet The Team In Person!

The Beamable team has a very busy May ahead and representatives from Beamable will be at the following events this month:

Pocket Gamer Connects Seattle – May 9th & 10th (Going on right now!)

Digital Dragons (Poland) – May 16th & 17th

Nordic Game Conference (Sweden) – May 17th, 18th, 19th, and 20th

Game Access Conference (Brno, Czechia) – May 27th & 28th

If you have any questions about where our team will be at these events so you can meet us in person, come join our Discord and ask!

 

Game Jam Support

In addition to attending events in person we also remotely support game jams, with the highlight this month being:

Game Jam Fast Art (Saudi Arabia) – May 12th, 13th, and 14th.

 

 

How to master Tiktok when marketing your game

With TikTok growing at a staggering rate many game developers are being left behind by not using the platform to its full potential. As social media platforms grow their organic reach diminishes, so right now is prime time to take advantage of that organic reach. We hear from people all the time that they don’t know what to post, let’s get into what you should be posting to seize the full potential of TikTok.

Create Less, Document More

“I have no idea what to create” is a common thought we hear when TikTok is brought up.” Our answer is always “Be authentic and document your journey, don’t put energy into creating.” We hear you thinking “but I am not interesting or what I am doing isn’t interesting.” You have to shift that mindset when trying to reach the gaming community and think about what they are into. Gamers love gaming news, updates, etc. Documenting your development process will allow your fanbase greater connection to you and your game and get your potential customers that much more excited to purchase it at launch. Documenting your game development doesn’t need to be high production or tons of editing. The perfect TikTok has a hook, engaging content, and sometimes a call to action.

Hook Your Audience

Questions make great hooks, something that is visually stimulating is another great hook. You want the viewer to linger on the content. Using text will also help your viewer engage with the video longer which helps boost you in TikTok’s algorithm.

• Do you want to see the newest enemy, power up, ship, weapon, etc?
• Do you want to see a funny or crazy bug in the game?
• If you have a world to explore asking “where would you travel first?”
• Want to meet this team member?

Your hook can become your shtick, allowing you to take the guesswork out of what you’re going to create. With that hurdle out of the way, let’s get into the content.

Create engaging content

After the hook, it’s time to show them what you’ve been working on. This can be very grandiose depending on where you are in your game, or it may be a character model. What may seem uninteresting to you is a peek behind the curtain for those following along. The content could focus on your team, bite-sized updates on who they are and what they are working on, allowing your team’s personality to shine. Keeping things simple avoids the common pitfall of overthinking because all you are doing is documenting your game development journey. Showing as much of the process as you can help teach and inform others about how games are made. Did you finally squash a bug that was driving you crazy? Share how you were able to fix it. The most important thing is creating a connection with your fan base and in some cases may even inspire the next generation of game developers.

An effective call to action

A call to action can be as simple as “hit the follow button for all our updates!” and often does not have to be more complicated than that when first starting out. As you get closer to launch the call to action may be directing your audience to your Steam page so potential buyers can either wishlist or preorder your game. Use a call to action to grow a discord server for your game, your brand, and possible future games as well. You can also let your audience know about your live streams if you decide to stream on Twitch or TikTok.

Live streaming on TikTok

As TikTok grows as a platform live streaming is becoming more prevalent. Streams can be as simple as pointing your phone at your computer screen and hitting the go-live button. If you want to get a little fancier you can build a scene in OBS and set the canvas to 1080 x 1920, then point your phone at OBS. We would go live like that on the regular because we didn’t have a stream key for TikTok. This is a great way to engage with a much broader audience. We’ve had streams where 150,000 have come through in one stream.

Start your TikTok journey

TikTok is no longer just dancing and lipsyncing, it is proving itself as a powerful marketing tool. Take advantage of the organic reach it offers while it’s hot.

 

Beamable is happy to announce the release of our Unity SDK 1.1.0.

It is full of various workflow enhancements, and some fixes to bugs that were too large to fit in a patch release. You can read about all of them in the changelogs, and see the highlights below.

Microservice Workflow Enhancements

Beamable 1.1.0 brings several workflow improvements to the Microservice development process. The largest change is that Microservices now take advantage of Dotnet 6’s Hot Module Reload feature. You won’t need to keep stopping, and restarting your Microservices after each code iteration. When you make a local code update, the Microservice will automatically reload the latest code into your running Microservice. You can opt-out of the automatic reload by disabling the Project Settings / Beamable / Microservices / Enable Hot Module Reload property. 

We’ve also fixed a usability issue with the Microservice’s auto-generated C# client code. Previously, Beamable would generate a C# file anytime the Client Callable methods changed on a Microservice type. However, the generation was using the latest successful compiled type information from Unity. If Unity encountered a compilation error, then it would pass a stale version of the Microservice type to the client generator. In Beamable 1.1.0, we’ve moved the code generation into a separate dockerized process. Now, anytime the Microservice changes, the dockerized client generator will compile the Microservice code directly, and output the auto-generated file. This also speeds up your Unity compile times, because now Unity can capture the updated Microservice and updated client code in one compilation pass. 

If you’ve been using Microservices for a while, you may have noticed that Beamable’s docker integration was taking a significant amount of disk space. In Beamable 1.1.0, there is an automatic process to remove stale Microservice docker images from your computer. You can disable this behavior with the Project Settings / Beamable / Microservices / Enable Auto Prune property. 

The Microservice Manager window has been visually updated to be more Unity centric. The debug setting moved into the advanced settings for each Microservice. The play and stop buttons have been collapsed into one Play button, similar to Unity’s game Play button. If you are debugging your Microservice with Rider, you can also use the Project Settings / Beamable / Microservices / Rider Debug Tools property to preload the Rider debug tools. If you enable this, you’ll need to match the debug tool download URL with the version of Rider you’re using. You can find these versioned URLs on Rider’s documentation. Once enabled, when you connect Rider to debug a running Microservice, you’ll be able to skip the Custom Tools download step. 

Microservice SDK Updates

The Microservice SDK has also been improved in Beamable 1.1.0. We’ve added the ability for a Microservice to send notifications to players. You can use the Services.Notifications.NotifyPlayer() method to send a json payload to a player, or to multiple players. You can use this to notify a group of players when one player takes an action, or you can send messages to your players via an AdminCallable route. We’ve also updated the AssumeUser function so that a non-administrator player can assume the role of another player. This can be useful if you need to have one player’s action mutate the state of another player’s inventory in a server authoritative way. 

Theming and Beamable Unity Style Sheets Preview

Beamable 1.1.0 brings us more features for Beamable Theming Preview. We are constantly trying to improve the experience of using Buss Theme Manager. One of the elements we emphasize is the smooth use of this tool without having to switch between windows and that’s the reason why we’ve added the Selected Buss Element section. It can be found just below the Navigation section. You’ll find all necessary details like Id and Class strings, as well as the currently referenced Buss Style Sheet. No more switching to the Inspector tab. 

Another improvement is enabling the possibility to edit selected Buss Style Sheet directly from the Inspector window. The Theme Manager only shows the styles that are referenced in the current scene hierarchy, but now you can also edit all of the styles by opening the Inspector window on the Buss Style Sheet asset. This improvement can be helpful when you are designing a set of styles more holistically.

We’ve also included various bug fixes and internal updates to the BUSS system. We are still building out this feature and the greater skinning capabilities, so stay tuned for the next update.

Here is the complete changelog for 1.1.0

Added 

• Added `RecoverWith` extension method overloads to `Promise<T>` that allow for configuring a promise to recover from failure over multiple attempts.
• Selected Buss Element section in Buss Theme Manager
• Added `AddAsChild(VisualElement, string, params string[])` to `BeamHintVisualsInjectionBag` to allow `BeamHintDetailConverter` functions to build and inject dynamically created `VisualElements` into Hint Details.
• `BeamServicesCodeWatcher` detects any change that makes it necessary to rebuild C#MS images as well as cleaning up Auto-Generated files whenever a C#MS AsmDef is deleted. This makes the easiest way to delete a C#MS’s code from your project simply to delete its folder.
• Beam hint that warns users entering play mode that there are stale services that must be rebuilt. Avoids wasting time when making quick changes to microservices and forgetting to regenerate the local image during development.
• `EnableAutoPrune` configuration setting that will remove old unused docker image layers. This should limit the disk space requirements of Beamable Microservices on developer machines.
• `EnableHotModuleReload` configuration setting that will enable dotnet 6 hot module reloading for all Microservices.
• Added `IMicroserviceNotificationApi` to list of services accessible from `ClientCallable` and `AdminOnlyCallable` methods of Microservices. These can be used for server-to-client communication.
• `RiderDebugTools` configuration setting to preload Rider debugging tools onto Microservice development images

Changed

• Behavior of Add Style button in Buss Theme Manager
• Add Style button moved above Buss Style Cards section in Buss Theme Manager
• Buss Element selection improvement in Buss Theme Manager  
• Application will check if there are redundant files in content disk cache on each start. All files but the one needed will be deleted to free disk space.
• All implementations of `[BeamContextSystem]` or `[RegisterBeamableDependencies]` will be preserved during Unity code stripping
• Properties in Buss Style Card sorted alphabetically by default
• When exiting Unity, all related Microservices and Microstorage containers are closed
• Microservice client code is generated in a dockerized dotnet runtime instead of Unity
• Added docstrings to `StatsService.SearchStats` to clarify correct usage of the `Criteria` parameter.
• `AssumeUser` takes an optional boolean parameter to disable the Admin access token check
• Service name must be a valid C# class without culture-specific characters
• Updated Microservice Publish window UI/UX

Fixed

• Constant “Invalid token, trying again” errors in the Editor after 10 days.
• Compilation error when using new `com.unity.inputsystem`
• Deferred retry of failed uploads to the poll coroutine, to eliminate an infinite loop that could crash the app.
• Content string fields can contain escaped characters, and won’t be double escaped after download
• Fixed issue with `ReflectionCache` that happened on certain platforms when `IEnumerable` returning functions had to be parsed for `AttributesOfInterest`.
• Fixed issue that caused the `ReflectionCache` to run an extra unnecessary time when a `.cs` or `.asmdef` file were changed.
• Fixed issue on Re-Import All with `BeamableAssistantWindow` opened that required reopening the window for it to work.
• Fixed issue that caused `StatsService.SearchStats` to fail whenever a match occurred.
• Cannot create invalid service name before validation occurs
• Progress bar in publish window now correctly displays the progress of services publication

Our changelogs can be found at
https://github.com/beamable/Changelogs/blob/production/com-beamable-changelog.md 

 

Use CrocoMobi with Beamable to accelerate development and LiveOps across a wide spectrum of games including BlockChain, NFT, and 2D.

April 12, 2022- Boston, MA– Today Beamable is announcing a partnership with CrocoMobi. This partnership allows game developers building on Beamable to use CrocoMobi to accelerate the creation of additional options in existing games, and in the development of new games. Beamable developers can augment their teams and take advantage of game design, technology, and operations expertise. 

Beamable is a gateway to powerful game server functionality, enabling player authentication, rich game analytics, content management, player CRM, and much more utilizing one line of code. With CrocoMobi, game studios will be able to be paired with a development partner that can rapidly implement a new game on Beamable from scratch, or migrate an existing game from another platform or engine. 

Dmitriy Belenkiy, COO of CrocoMobi explains, “Our experience in translating games to Unity allows us to implement joint projects with Beamable, using the experience and best practices of both companies.” 

Jon Radoff, CEO of Beamable added, “Getting a game to market is hard. We are always looking for talented teams like CrocoMobi to help us make it easier for game dev studios to implement their vision, get to market quickly and impress players. We look forward to working with CrocoMobi on many exciting projects.” 

To get started with Beamable, sign up today or reach out for an introduction to the CrocoMobi team. 

 

 

Live economy features + live service economy platform = a win for game devs everywhere

Massachusetts – April 12, 2022 | Metanomic, the real-time economy-as-a-service platform for developers,  and Beamable, a live operations platform for game developers,  have announced a new strategic partnership. Together, the technology leaders will provide game developers with a unique end-to-end solution to create, implement, and manage in-game inventories and economies of scale. This new partnership provides a seamless operation for studios of all shapes and sizes. 

 Imagine an integrated solution that allows game designers and developers to upload their games and player items from Beamable’s fully managed player inventory support into Metanomic’s live service economy platform. Key stakeholders in game design will be able to build, test, and power real-time game economies seamlessly. 

 The combination of Beamable’s mission to streamline the creation, operation, and orchestration of game tech and live operations with Metanomic’s tool – which eliminates spreadsheets from game design and provides economic simulation, AI, and sophisticated planning capabilities – is a game-changer for designers.

Theo Priestley, CEO of Metanomic said, “Beamable’s live service economy features, particularly its fully managed player inventory support, will natively integrate with Metanomic’s live service economy platform, allowing game designers and developers to upload the game and player items from Beamable into Metanomic, thus giving them the ability to build, test and power fully balanced, real-time game economies in one seamless operation. All without ever using a spreadsheet again.”

Trapper Markelz, Co-Founder and COO of Beamable added, “Beamable focuses on the technical directors that have to make build decisions and the LiveOps directors that have to make game operation decisions. Metanomic brings in technology that helps game designers make design decisions. Together, we offer something for every stakeholder in the game prototype/pre-production planning and solution process.”

The new initiative is aiming in the future to work with game developers around the world to provide this unique service. 

Editors: Representatives from both Metanomic and Beamable are available for further comment, and we can organize an interview as well. These can be conducted via email or virtually.  

 

Social Media – Metanomic – LinkedIn / Twitter

Social Media – Beamable – Discord / Twitter / Facebook / YouTube / LinkedIn / Instagram / TikTok

About Beamable

Beamable fights for the game makers of the world by enabling them to build faster and operate worry-free. The company’s full-stack liveops platform for live games is tightly integrated with the Unity 3D engine, enabling game developers to focus on the creativity and differentiation of their products. Beamable is based in the Boston area and led by a team of game-industry and software-as-a-service veterans and backed by investors including Companyon Ventures and GrandBanks Capital. For more information visit, https://beamable.com.

About Metanomic

Metanomic is the first and only complete real-time economy as a service platform for developers. Built by professional economists and game designers, the platform utilizes patented algorithms to easily deploy plug and play, interoperable and infinitely scalable game and creator economies ready for web3, metaverse, and play-and-earn games. The platform allows developers to easily and quickly build a fully-scalable and configurable play-and-earn economy that features asset creation engines and fully balanced player markets. Hyperspace is the first game to run on the platform’s web3 interoperable and chain-agnostic economic engine.

PR Contact

Derek Struble

Derek@Beamable.com

Use Athena access in Beamable to build custom dashboards for your game

March 28, 2022 – Boston, MA – Today Beamable is announcing a partnership withPopSQL, a leading collaborative SQL editor and business reporting platform for teams. This partnership allows game developers building on Beamable to implement custom dashboards using direct access to their game data stored in Athena. Any Beamable game studio that uses PopSQL can receive discounts on a paid plan:

• 50% off Premium or Business for Beamable Indie teams (less than 2 years old, and fewer than 10 employees) for up to 1 year
• 25% off Premium or Business for everyone else for up to 1 year

To claim the discount, any contact at a Beamable game studio can email support@popsql.com or open up a ticket through the popsql.com chat widget. Once your Beamable CID is verified, the discount will be applied to the account. 

Beamable is a gateway to powerful game server functionality, enabling player auth, rich game analytics, content management, player CRM, and much more with one line of code. Adding PopSQL allows game studios to build on top of default LiveOps portal telemetry by adding deep custom reporting. 

Paiman Vahdati, Head of Business Development at PopSQL, explained the value of the partnership, saying, “We are excited to partner with Beamable so that game developers can use Beamable’s deep analytics and our collaborative query and dashboard system to extract powerful and actionable insights for their games.” 

“It’s a partnership that makes so much sense,” explained Ali El Rhermoul, CTO of Beamable. He continued, “With PopSQL you can write queries, share them to your entire game team, and construct rich custom dashboards off the analytics events that Beamable automatically collects. You can see retention reports, DAU/MAU counts, installs, revenue, essentially all the important metrics you need to observe and orchestrate your game live operations.” 

To get access to your PopSQL discounts with Beamable, sign up for Beamable today,

 

Beamable Announces Support for AWS for Games, Microstorage, and Improved Pathways for GameSparks Migrations

March 23, 2022 – Boston, MA – Today Beamable is announcing support for the AWS for Games Initiative from Amazon Web Services, Inc. In addition to Beamable’s support for AWS, the launch of Microstorage, enabling developers to create, deploy and manage within Unity allowing for an easier migration path for GameSparks storage APIs. 

Built specifically for games customers, AWS for Games is an initiative featuring services and solutions from AWS and AWS Partners. AWS for Games makes it easier for game developers, publishers, and platforms to select the right tools and partners to build, run, and grow their games. For customers looking to accelerate deployments with solution-specific support, AWS for Games also identifies dedicated AWS Game Tech industry specialists, AWS services, and leading AWS Partners in each solution area.

Jon Radoff, CEO of Beamable, states “We’re thrilled to work with AWS.” He continues his support by explaining how Beamable and AWS together are the best of both worlds stating, “together, Beamable, and AWS provide a best-in-class platform for building amazing live games. Studios get AWS’s renowned scalability combined with Beamable’s workflows, industry-leading admin tools, and powerful serverless computing. This hyper-efficient platform enables developers to build fast and orchestrate great experiences for players.”

Lucien Parsons, Global Partner Leader at AWS Game Tech explains, “We’re excited to work with Beamable to further empower game developers to build amazing, successful, and fun games.” He continues his support for the partnership explaining the growing requirements of the industry and the tools needed to meet customers’ needs, “As more games offer live services and connected experiences in their games, developers need a diverse set of solutions to use. Working with Beamable on AWS for Games gives developers more solutions to use so teams can focus more on creating fun player experiences.”

Create, deploy, and manage your game all with the confidence of AWS security and scalability.

Beamable’s integrated LiveOps platform helps game studios to develop and scale games faster while reducing the cost and resource challenges of ongoing game management. This easy-to-adopt platform works directly inside the Unity editor enabling game makers to efficiently add social, multiplayer, commerce, and content management features to their projects. In addition, having already worked with world-class studios on their GameSparks migrations, Beamable is well positioned to efficiently help game developers take their games to the next level.

“Beamable’s AWS integrated solution for LiveOps allowed Old Skull Games to implement important game infrastructure rapidly saving our team more time to focus on creating awesome player experiences,” states Herve Sohm, Chief Business Officer of Old Skull Games, a joint customer of Beamable and AWS. 

Sean Durkan, Chief Executive Officer of backend game development company SuperNimbus explains, “The ability to set up the backend and write backend code from the editor is hugely powerful…Developers utilizing AWS’s powerful infrastructure are going to love building on Beamable.”

Game studios looking to learn more about the benefits of a combined Beamable and AWS solution are encouraged to visit Beamable’s AWS Marketplace listing. Beamable’s platform is free to use while games are in development.

ABOUT BEAMABLE, INC.

Beamable fights for the game makers of the world by enabling them to build faster and operate worry-free. The company’s full-stack LiveOps platform for live games is tightly integrated with the Unity 3D engine, enabling game developers to focus on the creativity and differentiation of their products. Beamable is based in the Boston area, and led by a team of game-industry and software-as-a-service veterans, and backed by investors including Companyon Ventures and GrandBanks Capital. For more information visit, https://beamable.com.

Get a copy of Architecture for Scalable, Reliable and Efficient Game Operations today!

Beamable is excited to announce the release of a new technical whitepaper for game studios. In the paper, we cover how one line of code launches our Integrated, Full Stack LiveOps platform for Unity games.

var beamable = BeamContext.Default;

Live games need engagement, social features, and the ability to deliver new content continuously to players. The team at Beamable created this paper after learning what it takes to scale games to millions of players.

“I was excited to work on this paper for game developers and explore the common challenges to shipping games and rapidly scaling them to grow a community of committed players,” shared Ali El Rhermoul, CTO of Beamable. “Our goal is to give developers an understanding of the kinds of workflows that make for scalable games, both operational and technical, as well as solutions both conceptual and practical. We worked to cover the tradeoffs of each approach, as well as introduce Beamable’s capabilities.”

What you will learn from Beamable White Paper:  

• How a full-stack, integrated approach to LiveOps helps you build and iterate faster 
• What we learned from the lifecycle of several live game projects
• The core issues that contribute to complexity, mistakes and lost opportunities
• Beamable’s architecture, built around microservices and a highly-scalable Serverless Game Backend

Download your copy of the white paper now!

Beamable will be at GDC 2022 this year!

 If you are in San Francisco, March 21-25, we would love to meet up with you. There are two ways you can connect with us:

Set up a meeting with Beamable

Beamable will have a number of people at GDC including the co-founders of the company CEO Jon Radoff, COO Trapper Markelz, and CTO Ali El Rhermoul. Also attending is Director of Strategic Partnerships Aladin Ben, and VP of Sales John Goodale. 

To coordinate a meeting, please reach out to us at sales@beamable.com or contact us now!

Attend our Beamable Reception!

Beamable is hosting our first annual evening reception at GDC this year. It is co-sponsored by Beamable and Venly, with appearances by Amazon Game Tech, as well as Hashbang demoing a new Beamable/Photon project called Light Violence! 

Here are the details! We would love to see you there!

Wed, March 23, 2022

5:00 PM – 8:00 PM PDT

The Chapel 

777 Valencia Street

San Francisco, CA 94110

Stop by for music, free food, drinks, and conversation about the future of live games, LiveOps, and multiplayer game development. 

Space is limited. RSVP Today!

Today we’re celebrating with our friends at Game Jolt! A fantastic place for gamers and game devs to meet and interact. Recently they launched their mobile app on IOS and Android incentivizing players to log on each day to earn golden tickets.

You can install GameJolt for iOS or Android using the App Store or the Google Play store. Participate in daily challenges to win a PlayStation 5, Alienware x15 gaming laptop and more prizes!

After installing the Game Jolt mobile app, remember to log in each day to collect your ‘Golden Ticket’ sticker. Once you use it on any post, comment or fireside on Game Jolt, you’ll automatically be entered to win! Be sure to check your inbox and notifications daily to see what you’ve won! Want to increase your chances of winning? Invite friends to sign up for Game Jolt, or view your quest log to complete various tasks for additional stickers.

To learn more about the Golden Ticket giveaway, head on over to GameJolt to learn more!

Looking for more?

The Preservation of Videogames: How Nintendo is eliminating access to digital games.

Built On Beamable: The Office Somehow We Managed

Beamable Release Unity SDK 1.0.1

 

 

Beamable 1.0.1 is available!

This is a patch release and contains bug fixes, performance improvements, and usability improvements.

Performance Improvements

Through a few mechanisms, we’ve improved the Beamable initialization times by roughly a factor of 2, and content resolve times by multiple orders of magnitude. When Beamable initializes, there are 4 general networking steps that need to occur;

1. User initialization,
2. Session creation,
3. Notification setup,
4. Potentially purchaser initialization.

In Beamable 1.0.0, those 4 steps were happening in sequence. Now, in this patch release, the last 3 steps all begin at the same time, and execute in parallel. In high latency network conditions, this is a major speed improvement. Additionally, Beamable switched the internal representation of access token expiration from a date string, to a numeric-based timestamp. The numeric representation prevents the need to do any date parsing, which saves about a quarter of a second in initialization speeds on a Google Pixel 4A. Additionally, games with lots of content can take advantage of the Content Baking feature, which is now supported on all platforms. In 1.0.1, the content manifest is baked alongside the content objects and included as a resource in builds.

Stability Improvements

There were several UI glitches in the Microservice Manager UI/UX that have been fixed, including some broken icons, broken text wrapping, and inconsistent texts between windows. Critically, the ResolveAll() function that was used for Content downloading has been fixed. Previously, the implementation of ResolveAll() would trigger a stack overflow under certain conditions. The method would actively try to run up to 50 content downloads in parallel. As soon as one download finished, the method would start a new download. However, the new download was represented as a recursive call from the original download’s Promise success callback. Depending on network conditions, it was possible for one chain of method execution to reach the stack frame limit and trigger a fatal crash. Our new solution uses a batch mechanism internally instead of a rolling recursive mechanism. Instead of using callback recursion to schedule all the downloads, the new method creates a data structure to represent the downloads and enumerates it over time. Lastly, there was a bug in the micro-storage feature where document Ids weren’t being set correctly when using the mongo driver’s replacement functions.

Apple IDFA Handling

Apple has changed how they entrust the player’s device id to developers. You can read about it here. Beamable is not creating a workaround for this behavioral update starting in iOS 14.5. However, if a Beamable customer wants to change the internal deviceId that will be reported to the Beamable backend, they can use the updates in 1.0.1. Please reference this code to override the deviceId. In general, you can unregister the standard IDeviceIdResolver implementation, and register your own custom implementation.

Community Requests

A few community members on the Beamable Discord brought up some great points about our package. We’ve changed our internal usage of the AssetDatabase.FindAssets function to use fully qualified class names. This should limit the cases where Beamable accidentally loads types of assets defined in customer projects. We’ve also configured all of our assembly definition files to “overrideReferences” which should stop them from automatically referencing every assembly in a customer’s project.

The full changelog history can be found on our Github, here…

1. https://github.com/beamable/Changelogs/blob/production/com-beamable-changelog.md
2. https://github.com/beamable/Changelogs/blob/production/com-beamable-server-changelog.md

While there are many debates on whether or not people should play emulated games there is one thing that is widely agreed upon: emulators do not support the creators of the game.

(What I Saw 2.0 is licensed under CC BY-NC-SA 2.0)

Recently Nintendo decided to stop support for eshop on the Wii U and 3DS platforms. This action made the games on the eshop unable to be purchased and re-downloaded, even if a player had already bought a particular game. The Video Game History Foundation, a non-profit aiming to protect the lifespan of video games, had much to say on Nintendo’s decision. Although they understand the business perspective from Nintendo in stoping the eshop from further purchases they stated, “preventing institutional work to preserve these titles on top of that is actively destructive to video game history.”

Nintendo’s comments on the removal of the eshop for the WiiU and 3DS platforms was simple, “This is part of the natural lifecycle for any product line as it becomes less used by consumers over time.” While the company noted that the Nintendo Switch Online Membership shows much promise in allowing for many players access to retro games, there is still a much bigger problem with Nintendo’s decision.

Since the release of the Nintendo Switch, many players have opted to utilize the Switch’s eshop to purchase digital copies of their favorite games and have moved away from physical copies of games. While physical copies of games have started to decline in popularity due to copies being easily accessed through online shops, Nintendo’s move in eliminating older e-shops may show a rise in physical copy ownership. Many have also noted the inability to sell back a digital copy of a game after playing as you can do with a physical copy, and not having to worry about packaging and cartridges, yet having to pay the same price.

For more information on the work being done to preserve the history of video games, head to The Video Game History Foundation. To read more about Nintendo’s move to eliminate the e-shop for the Wii U and 3DS, head to Nintendo Announces Closure of Wii U and 3DS eShop.

The Office Somehow We Manage

The Office Somehow We Manage is the latest game release that is built on Beamable.

Congratulations to the team at East Side Games on the successful launch of The Office Somehow We Manage. Seeing Michael, Jim, and Dwight back in action makes for some good times.

Launching a game built on Beamable

The video below will give you some insight into what it’s like to launch a game on our platform. You will get a behind-the-scenes look at what happens in the war room and how we monitor and prepare launch day.

A smooth game launch is our top priority for games Built On Beamable.

“It is critical to our success that the games launched on our platform are successful”

– Brandon Bateman Dev Ops

BEAMABLE 1.0

Beamable is happy to announce the release of our Unity SDK 1.0.0. We’ve been working towards this milestone for a long time, and it’s completely full of new features to help Game Makers. The full changelogs can be found below. Here are the highlights of the release.

Microstorage and Microservices

In Beamable 0.17.0, we released the Microstorage preview, which allowed you to experiment with connecting local persistent storage to your Microservices. Now, you can deploy those storage layers alongside your Microservices to the Beamable Cloud. You get full access to read and write your data, as well as to view metrics and performance suggestions to keep your games moving fast. When you create a Microstorage object from the Beamable Microservices Manager Window, you can mark it as a dependency of a Microservice, and start writing your data C# classes in Assets/Beamable/Common right away. You have full access to the Mongo C# Driver, so you can take advantage of the powerful capabilities Mongo provides. In Beamable 1.0, we’ve also updated our Microservices to take advantage of Dotnet 6, which will make your apps faster and more secure.

If you’ve already added Storage Objects through the 0.17.0 preview release, you’ll see a few errors when you upgrade to Beamable 1.0.0. To fix these issues, you need to do the following steps for each Storage Object

1. Identify the assembly definition for the Storage Object, which should be located next to the Storage Object’s class file.
2. Add a reference to the Unity.Beamable.Server.Runtime.Common assembly
3. Add a reference to the Unity.Beamable.Server.Runtime.Mocks assembly

Brand New Portal and Documentation

Beamable 1.0 has an entirely new Live Operations Portal. The Portal is designed to make operating and managing your live games easier. You can control your Analytics, Player Data, Beamable Cloud Resources, Content, Realm Data, and more from the new Portal. We are always looking for feedback, so please share your thoughts and experiences about the Portal with us. Oh, and it has Dark Mode. Our documentation page has also been redesigned and updated to reflect many of the new features in 1.0. You can give us feedback or suggest an edit from within the new documentation pages.

Beamable Assistant

Making games is hard. Using Beamable shouldn’t be. We’ve added a brand new window called the Beamable Assistant. It’ll automatically analyze your project and codebase for common Beamable usage errors and suggest fixes or performance improvements. The hints that the Assistant reports are configurable and extendable. Your own team can leverage the analytization pipeline and offer custom suggestions that fit your project’s needs. If you’re worried that this sounds vaguely similar to a certain metal paperclip from the late 1990’s, don’t worry, you can always disable this feature if you want to. In future Beamable releases, we’ll be adding and improving the hints and suggestions so that you can rely on Beamable Assistant giving you reliable and insightful feedback.

Theme Manager Preview

Beamable 1.0 has a brand new way to manage theming prefabs. We call it Beamable Unity Style Sheets, or BUSS for short. If you have a new Leaderboard prefab in your scene, and you open the Skinning page from the Toolbox, you’ll be put into a new theming experience where you can override the look and feel of the Leaderboard. BUSS uses a Signed Distance Field rendering technique under the hood to deliver crisp and rich UI visuals. BUSS empowers the developer to express their styles with CSS concepts like selectors, properties, and variables. The new Theme Manager window is still in Preview, and we will be listening to your feedback and improving it in future releases. As we build more prefabs powered by BUSS, the style decisions you make once will be reused over and over again so that you can spend more time building your game instead of wrestling with UI code.

Player Centric SDK Preview

We’ve added new SDK capabilities to Beamable so that you can access your Player Data as easily as possible. In previous releases, every code interaction you had with Beamable started with Beamable.API.Instance. That will still work, but starting with Beamable 1.0, you can also use BeamContext.Default.Api instead. The BeamContext is a class that represents a Player and all their code dependencies. Internally, we are using a Dependency Injection framework to power the context, instead of hard coding a list of service initializations. You can take advantage of this by having multiple BeamContexts in memory at once, which allows you to support couch co-op or hot seat gaming using Beamable player accounts. You can inject your own context sensitive services as well, modify the existing Beamable ones, or even replace them with your own implementations. Once you have a BeamContext instance, you can access player data directly, or in an observable pattern. You never need to worry about promise callbacks ever again if you don’t want to. We are going to keep working on improving the BeamContext and adding more convenient SDK functionality to it in future releases of Beamable. However, as part of this transition, we have removed the capability to use the ServiceManager class with Beamable.

Here is the complete changelog for 1.0.0

Added

• BeamContext classes and new player centric SDK types like PlayerInventory
• Beamable Assistant window
• BUSS Theme Manager window
• StorageDocument base class for storage data classes that automatically handle document ID assignment.
• Automatic Mongo serialization for basic Unity structs like Vector2, Color, and Quaternion
• Automatically generate a client-server shared asmdef, and new Microservices automatically reference it

Changed

• All Beamable Portal interactions use the new Beta Portal
• Consolidated internal assembly type scanning into ReflectionCache system. This improves editor time performance by an order of magnitude.
• ServiceManager no longer provides Beamable types. Use BeamContext instead.
• Beamable.API.Instance now returns BeamContext.Default.Api after waiting for the context initialization
• Upgraded Microservices to dotnet 6.0 instead of 5.0
• Microstorage is out of Preview. Storage Objects can now be published and used in a remote environment.
• Microstroage GetCollection method must now take subclass of StorageDocument
• Return values from ClientCallable methods are serialized using Unity style serialization
• Microservice Publish window has improved performance and User Experience

Fixed

• Deleting all items from an inventory subscription notifies client
• Immediately failed promises throw uncaught errors on access
• Disabling multiple content namespaces setting will disable both
• Publish button dropdown and content namespace dropdown
• Content baking will process correct number of objects regardless of local changes
• Baked content meta file warning should not appear anymore
• Immutable prefabs are no longer dirtied by the legacy skinning system
• The Reset command works on unsaved scenes
• EventContent.StartDate is kept in sync with schedule definition
• Swagger docs handle generic types instead of failing to load
• C#MS Log View stay attached to the bottom of the scroller

 

Our changelogs can be found at https://github.com/beamable/Changelogs/blob/production/com-beamable-changelog.md

Every creator has experienced the dreaded stage of burnout. For many, it consists of a loss of hope, exhausted resources, and a dry spell of creativity. In the videogame world, many Game Developers recite their heroic triumph over burnout, and their story often ends in a massive success with the creation of a game like Stardew Valley. In this article, we’re going to delve into the process of how indie games will change your life, but it is not as easy as it seems.

Please be advised that the content in this article will comment on Game Dev Unlocked’s Youtube video.

 

After graduating as a film student, David Wehle had no idea that he would eventually be the creator of a live monetized game. Wehle had started out by modding Star Wars Jedi knight into various settings like casinos, hotels, and movie sets. Although he wanted to follow his dream of video games, he ended up settling for a film company that eventually fizzled out. Wehle started working in the architecture field where he came in contact with, Unity. “As a visual and art-oriented person learning code sounded impossible” (Wehle) He learned from his co-worker a visual scripting tool called Playmaker which allowed him to see the abstract images he was creating in code. Although he felt pressured by code-snobs to not use Playmaker because ‘it will never create a good game’, Wehle did just that he created a game using Playmaker. His first game, Home is where One Starts…, although it was a simple 30 minute game with an in-depth story Wehle had achieved his dream: he released his first game.

But this game was not the reason for his massive success today as an Indie Developer. However, this game allowed him to gain an interview at VOID and allowed for him to become a technical engineer. As someone who started his journey by creating mods for Star Wars: Jedi Knight, he was now officially partnered with Lucas Film through VOID. During this time he realized there were some major mistakes for the launch of his first game, mainly marketing. Through research, learning, and a heightened perspective, Wehle created The First Tree netting $150,000 after its first year on steam. The game was later ported to Xbox, Playstation, and even the Nintendo Switch garnering the game more traction in the industry. Wehle was able to not only leave his job at VOID to become a full-time Indie Game Developer, but he was able to pursue his passion.

David Wehle’s story is extremely important for Indie Devs dreaming of a groundbreaking first game. It’s a rarity, but it does not mean that your first game wont be a success. Indie Games will change your life, the industry will change your life, only if you take the time to enhance your perspective, connect with the community, and research the best approach strategies.

Looking for how to create a successful Indie Game? Read our article series on that here:

1.) Why Content Matters

2.) Monetization

3.) Timed Events

Be sure to visit David Wehle’s Youtube Channel Game Dev Unlocked to learn more about his story.

Looking to make friends? This article will act as a comprehensive list of online groups to join in order to expand your network and meet more game makers like you!

Slack

While many companies utilize slack to keep their employees organized and connected (like us!) Slack can also be used to join and create various communities. For indie developers looking to learn more from their peers, indiegamedevs.slack.com, is the place to be. With slack you can start networking immediately into channels and send those in the group a direct message to create stronger connections.

Facebook

Another fantastic place to meet creators online is through Facebook groups. There are groups for specific interests, as well as broader topics, and of course there are groups created for Indie Developers. These are a few of the communities we reccomend joining:

Indie Game Developers – A public group that has a few subset groups including:

• Indie Game Promos – A place to post promos and teasers of your game as well as interact with others work.
• Indie Game Chat – a casual place to talk to game developers about their game to interact and make friends.
• Game Industry Talent – this is a group to not only self-advertise, but find other talented creators in the community who you could use to create your game.
• GameDev Assets & Tools – this is a fantastic space to find tools and assets other game developers are using that may help you create your game.

Discord

If you’re looking to join a fantastic community look no further than our very own Beamable discord! Join here to connect with us and the developers behind some of our games. Looking for more resources? Have some to add to our list? Tweet us @Beamable and let us know how we can help you!

For more content check out Josh and Erin’s Podcast Episode (#22) where they talk about some of their favorite Indie Games they’ve been playing.

Here at Beamable, we provide you with all of the tools to create your future game, but what if this is your first game? Working in Unity can be easy while working with our support teams, but if you’ve never launched Unity before this can seem like a daunting task. In this article, you’ll be able to see our resource recommendations as well as advice from Game Developers here at Beamable.

Step One: Download Unity

One of the most important things you’ll need to work in Unity is… Unity. There are four different types of subscriptions, and assuming you’re a first-timer at game creation, all you’ll need is a free subscription. ( Click here to set up your free Unity account)

 

 

 

Each subscription has its perks, and if you’re looking to upgrade use this link to compare each subscription.

Step Two: Research, Research, Research!

While Unity downloads on your computer, you’re going to want to familiarize yourself with the software before diving in. We highly recommend watching Brackey’s How To Make A Video Game playlist that consists of 11 videos that cover the basics of game creation including Programming, Movement, and Camera Flow. ( For more information on how to Zoom a Camera in Unity read our article here.) Brackey’s in-depth How To Make A Video Game series allows for any beginner to become more familiar with Unity before opening the software.

Step Three: Sample Projects Saves Lives

We know what you’re thinking. “When can I START making MY game?!” In order to start your own project, it is important that you’ve not only watched educational videos on Unity but that you have some hands-on experience before diving into creating your dinosaur-princess-zombie-adventure game.

Upon entering the software you will be met with this page:

This is your Unity Hub and is where your projects will be stored.

If you look to the left panel you’ll notice there are four separate tabs. One for Projects, one for Installments, one that says Learn, and the final one says Community.

The Install tab will show all content that you have installed into Unity that you are using for your project.

The Community Tab allows for you to connect to the Unity Blog, Answers to common questions, Forums, Live Help, Unity Play, and Unity Pulse. Think of this tab as your helper tab, if you have a question you can ask Unity developers through a live Chat or connect with other Unity creators for inspiration.

The Learn Tab will be the most helpful tab when starting to be hands-on with the platform. This is what the tab looks like:

Step Four: Sample Projects

In the Learn tab, you will find an array of projects to choose from. Each project is a tutorial for a specific mechanic that can be used to create your own game. There are various levels to these projects from a Beginner Project, to an Intermediate Tutorial. Each Sample project takes a certain time to complete ranging from 5 minutes to 840 minutes. ( Don’t worry there are various tutorials that are 5-30 minutes long so that you can get to creating your own game faster, although we recommend taking on one of the larger projects before diving into your own) When selecting a sample project to work on, you will be prompted with downloading Unity’s editor ( when using the Unity Hub), make sure to download the most recent version in order to utilize all of their tools!

Step Five: Start your OWN Project

It is time young padawan, you are on your way to becoming a Game Dev Jedi! ( and a master of Unity Software!) To start your own project, return to the projects tab and select “New Project”. From here you will be met with a similar page that you have worked with during the Sample Projects.

Here are resources recommended by Software Engineer Chris Hanna:

GDC: https://www.youtube.com/c/Gdconf  https://www.gdcvault.com/free “These are a bit more advanced, and have less to do with game-dev specifically, but are great resources for math and computing in general. They’re fun!” – Hanna, 2021

• https://www.youtube.com/c/Blackthornprod/videos
• https://www.youtube.com/c/JonasTyroller

• https://www.youtube.com/c/TheArtofCodeIsCool (a channel about writing shaders)
• https://www.youtube.com/c/SebastianLague

Looking for more?

Join our discord at beamable.com/discord and come and talk to our team, as well as other Unity creators!

Here are our Top 10 Tips for Indie Game Developers

The Indie Gamer Magazine is hosting their 2nd Game Awards on January 8th 2022!

There are ten areas where you can vote for your favorite Indie Game Nominees. The Nominees for each category are listed below:

Most Improved Game

 

7 Days to Die

 

GTFO

 

Dead Cells Everyone is Here

 

Tribes of Midgard

Best Cosplay Creator

 

Bebe Alkaid

 

Nate Nook

 

Svjankoppe

 

Redchaos

Best Soundtrack

 

Kena: Bridge of Spirits

 

Sable

 

Little Nightmares 2

 

Ender Lilies

 

Best Voice Performance

 

Lorenzo Polin

 

Dewa Ayu Dewi Lorassanti

 

David Flepp

 

Mike Bodie

 

Best Solo Developer

 

Dani

 

FYQD-Studio

 

Aarne Hunziker

 

Fabraz

 

Best Early Access

 

Potion Craft

 

Wartales

 

Hellish Quart

 

Valheim

 

Best Team Developer

Hidden Fields

 

Acid Nerve

 

Black Matter Pty

 

Norsfell

 

Best Storytelling

 

Mundaun

 

Kena: Bridge of Spirits

 

Little Nightmares 2

 

Death’s Door

 

Best Gameplay

 

Hell Let Loose

 

Kena: Bridge of Spirits

 

Tribes of Midgard

 

Valheim

 

Game of the Year

 

Mundaun

 

Genesis Noir

 

Cyber Shadow

 

Valheim

 

See your favorite Indie Game from this year on the list? You can vote for them here before the awards on January 8th 2022.

 

Good Luck to all the Nominees!

 

Looking for more indie game content? Here’s our Top 3 Games for the Holidays.

Beamable is happy to announce the release of our Unity SDK 0.18.0. The full changelogs can be found below. Here are the highlights of the release.

Content Baking

Beamable 0.18.0 introduces a new feature called Content Baking. Previously, the first time players launched a Beamable game, they’d have to download every piece of Beamable content to their devices. For games that had significant amounts of content, the download could cause considerable lag time in-game startup speeds. Now with Content Baking, you can bundle an initial version of content with your game, removing the need for users to download anything. You can configure how the content is bundled with the application, choosing either GZIP compression, or no compression. To enable automatic Content Baking, go to the Content section of your Project Settings. Or, to do it manually, use Window / Toolbox / Beamable / Utilities / Bake Content. Content Baking lets your users start playing your game faster, which reduces friction in your onboarding process. No one likes loading screens.

Webhooks and APIs as Content

Microservices can be used to implement features specific to your game’s needs. In Beamable 0.18.0, we’ve added the ability to represent your own [ClientCallable] methods as Beamable Content. Our vision is to allow you to attach these API Content Objects to Beamable events, like when a player claims their Tournament rewards, reads an announcement, or makes an in-game purchase. Today, you can register a custom API Content as a reward in an Announcement. You can use this feature to execute custom logic when a player claims the gifts in an Announcement. For example, you could write a custom C# function that increments an item’s property value, or resets a stat timer for a player. We’ll be expanding the places you can use API Content so that you have as much control over your game’s logic, flow, and state as possible.

Leaderboard Prefab and BUSS Preview

Beamable is dedicated to giving you fully functioning prefabs that leverage entire Beamable feature sets. In Beamable 0.18.0, we’ve added a new Leaderboard prefab that is more performant, scalable, and configurable than the previous. Similar to the old Leaderboard, all you need to do is assign a Leaderboard Content Ref to the prefab, and you’re ready to go. The new prefab is built using our new User Interface technology. We call it the Beamable Unity Style Sheet, or BUSS for short. BUSS is a tool that gives you full control over the styling and theming of your drag-and-drop prefabs while optimizing performance. It uses a Signed Distance Field rendering technology under the hood to give your UI’s modern aesthetics like drop shadow, borders, gradients, and more. We are going to continue building tools for BUSS so that you have easy and powerful ways to customize and personalize your game’s look and feel.

Workflow Improvements

Beamable 0.18.0 is bursting with various workflow improvements and SDK enhancements. In the Unity Editor, you’ll notice that you see less Asset Importing as you enter and exit Playmode. We’ve fixed a bug deep in our Content system that was erroneously causing asset imports.

The schedule editor for Listing and Event Content has also been extended to support more of the cron syntax. In fact, you can now enter your schedules as cron strings directly in the Inspector if you need to express a more nuanced schedule than the UI can represent. If you aren’t familiar with cron, check out this excellent third-party website, https://crontab.guru/.

Beamable 0.18.0 also moves the BeamableEnvironment class from the Editor namespace, to the Runtime namespace. The BeamableEnvironment class contains data about the Beamable package you are using, like what version you have, what API URL you are using, and more. You can use this information to write robust code that responds to Beamable’s version number.

C# Microservice Enhancements

The Microservice feature continues to mature and offer more ways to configure your workflows. In Beamable 0.18.0, you can use the [InitializeServicesAttribute] to decorate a static method as an application startup method. If your method is static, returns a Task or a Promise, and accepts a single IServiceInitializer as a parameter, then it will be invoked exactly once when the Microservice starts up. The method will be called before the service can receive traffic from players, but after a secure connection to Beamable has been established. This means that you can reference Beamable data as part of your initialization. There are a few other Microservice improvements, such as the ability to collapse the log view in the Unity Editor, and the ability to return simple Dictionary types from your [ClientCallable] methods.

Added

• Content can be prebaked with game builds to speed up content initialization
• ScheduleDefinition now supports CRON expression
• Minute support for scheduled listings
• Announcement content includes gifts in addition to attachments. Gifts support webhook calls.
• scheduleInstancePurchaseLimit field to the ListingContent to enable setting a purchase limit scoped to the schedule instance
• SearchStats() admin method is usable from client and microservice code.
• ApiContent classes and execution methods allow you to invoke microservices with data
• InitializeServicesAttribute can now be used over static methods to declare initialization hooks in microservices. Supported signatures are async/regular Task(IServiceInitializer), async/regular Promise<Unit>(IServiceInitializer) and synchronous void(IServiceInitializer). void methods must be fully synchronous — it is not possible to guarantee that any promises started within a void initialization method will have been completed by the time the microservice is receiving traffic.
• Exposed CreateLeaderboard methods in IMicroserviceLeaderboardsApi to enable the dynamic creation of leaderboards in microservices (can take a LeaderboardRef as a template or explicit parameters).
• Folding/Unfolding services cards in Microservice Manager
• Added clearer unsupported message for microservice’s implementation of IAuthService.GetUser(TokenResponse)
• Added support for Dictionary serialization in ClientCallable methods using SmallerJSON
  

  Changed

  • BeamableEnvironment has moved to the Runtime to enable SDK version checking at runtime
  • Removed unnecessary Unity asset reimport for identical content data.
  • list_content Admin Command displays limited results. You can specify start index for list_content command
  • Renamed build and run to play buttons in Microservice Manager to be more intuitive
• Can have multiple ConfigureServicesAttribute and InitializeServicesAttribute explicitly ordered via ExecutionOrder property of the attributes.
  

  Fixed

  • Renamed Beamable’s iOS plugin for Google Sign-In from GoogleSignIn to BeamableGoogleSignIn to prevent name collisions with public plugins.
  • InventoryService.GetCurrent is no longer limited by URI length
• only use InitializeOnEnterPlayMode in Unity 2019.3 or higher
  

  Our changelogs can be found at

  https://github.com/beamable/Changelogs/blob/production/com-beamable-changelog.md

We’re one week out from the Christmas Holiday and we wanted to share our favorite holiday movies! Here is the list of our top five holiday movies.

Elf

Who could forget the iconic spaghetti and syrup platter? Or the infamous snowball fight? And of course, SANTA! Elf was released in 2003 with Will Ferrell playing Buddy the Elf. Today it still runs frequently during the Christmas Season and remains one of our favorite Christmas Movies. Elf also had a video game created after the movie. This videogame was for the Game boy Advance and allowed players to explore 10 action-packed missions following the movie storyline.

The Polar Express

All Aboard! Tickets please, tickets! The Polar Express has the power to have adults believe in the magic of Christmas again. Released in 2004, The Polar Express follows a young boys’ adventure to the North Pole on a magical train filled with other kids and hot chocolate! This film also inspired a videogame released for the Gameboy advance, Ps2, and the Gamecube, where players follow the events of the movie on their own.

Home Alone

A friendly spider, two robbers, and a kid home alone for the holiday season– what could go wrong? Released in 1990 Home Alone follows a bratty 8-year-old Kevin McCallister whose wish for not having a family seemingly comes true after his family forgets him at home for their trip to Paris. This classic holiday movie has an interesting videogame paired with it. Released for the Nintendo Entertainment System (NES), the Super Nintendo Entertainment System (SNES), the Master System, Sega Genesis, Game gear, Amiga, and MS-DOS platforms. The gameplay of the game follows Kevin McCallister using household objects as traps and weapons to prevent Harry and Marv from burgling his home.

Die Hard

Yes, there is no debate Die Hard is a Christmas Movie. As New York City policeman John McClane is visiting his estranged wife and kids on Christmas Eve, he joins her at a holiday party in the headquarters of the Japanese-owned business she works for. Just as the fun begins, the party is crashed by terrorists taking over the high-rise and keeping the guests as hostages. Released for the Commodore 64, the TurboGrafx 16, and for the Nintendo Entertainment System (NES), Die Hard ( the videogame) allows for players to rescue hostages and battle terrorists from a top view perspective at Nakatomi Plaza.

The Santa Clause Movies

All of the Santa Clause Movies, starring Tim Allen as Santa, are essential to the holiday season. In each of these movies, Santa fights to save Christmas and ensure the safety of the North Pole from various outsiders. For the Santa Clause 3 movie, there was a videogame created for the Gameboy advance that allows players to relive memorable moments from the film.

Still unsure what to get your favorite gamers and game makers this holiday season? Here’s our Beamable Gift Guide created using our workers’ favorite picks.

Looking for that perfect gift for your fellow game creator? Wondering what tools you might need to start creating games? We asked our co-workers here at Beamable what’s on their list this year. Below are our top 10 picks for gifts this holiday season. 1.) Blood, Sweat, and Pixel: The Triumphant, Turbulent Stories Behind How Video Games Are Made. by Jason Schreier $12.99 USD

Its always important to have an understanding of the world you want to work in before getting hands on with creating. One of our workers here at Beamble suggested this book to allow for people to get an inside look at the highs and lows of game creation.

2.) Aeron Chair $1,645.00 USD

While our next item is expensive, it’s for good reason. A worker here at Beamable explains their recommendation: “ Game Makers, and everyone whose work includes a lot of siting at computers, will get a lot of comfort ( and possibly healthier sitting!) from a really good chair. The Herman Miller Aeron is super expensive, yes, but you can often find discounts and perfectly good refurbished units. Would you rather have a really good $1500 chair for 20 years, or ten merely adequate $150 chairs that you need to replace every couple of years?”

 

3.) Makey Makey $49.95 USD

 

Looking to use Bananas as controllers for your next game? Now you can with Makey Makey! Try out new ways of learning the mechanics and circuits of controls with video games. 4.) Pico-8 $14.99 USD

Meet Pico-8! This downloadable fantasy console allows for you to create small games in an 8-bit style. 5.) A Rubber Duck $2.24 USD

Yes, we’re serious. This Rubber Duck is not all its QUACK-ed up to be. The Beamable worker that recommended this explains the mythical powers of the duck: “ When you’ve been staring at the same block of code for hours and hours, sometimes you just need to explain the problem to a friendly duck. The duck will know what to do.” We like to call this rubber duck debugging 6.) Camtasia $299.99 USD

 

Already have a fantastic game? Looking to show off gameplay or make an epic trailer? Camtasia, although on the pricier end of our list, allows for creators to easily create content to promote their games. 7.) Playdate $179.00 USD

Playdate is currently on pre-order, and would be a great gift for a gamer with a nostalgic mind. Playdate allows for any game-dev to create games for their Playdate and play games created  by other owners of a Playdate. 8.) Elgato Stream Deck XL– $249.99

Looking for new ways to amp up your setup? Whether you stream or not, a stream deck can help you easily create projects in an organized fashion 9.) SwissGear Laptop – $89.99 USD

The worker that recommended this item explains that “A sturdy backpack with plenty of room for a laptop, books, mobile devices, cables, and peripherals is essential if you are making games on the go. SwissGear makes really solid bags that are comfy to wear and carry.” 10.) Another Castle: Enjoying the Journey – $0.00 with audible sign up/ $9.99 paperback

Our last item on this list is created by our very own Josh Schmidt! In Josh’s book, Another Castle, he outlines his personal journey into working in the games industry and the importance of enjoying both the highs and the lows. Josh’s book is available for free when signing up with Audible, and is $9.99 when purchasing paperback from Amazon. We hope you’ve enjoyed the roundup of our top 10 gift ideas for this holiday season. For more ideas take a look at last year’s round-up here: https://www.beamable.com/blog/beamable-gift-guide-for-game-makers-2020

Music and the Metaverse with Lucas Wilson

If you’ve wondered how music will fit into the metaverse you don’t want to miss this episode of Building the Metaverse with Jon Radoff. This fireside chat with Lucas Wilson touches on how music is already playing a part in the metaverse. Lucas has worked with Post Malone, Billie Eilish, and more to bring their music to more fans via the metaverse. You will also learn how NFT’s are shaking up the music industry and putting more money in the hands of artists.

If you have any questions for Jon please leave a comment on the video.

During the Holiday Season, we all have that one person who has every game to ever exist, plus the remastered-deluxe-ultra-rare edition. As you pursue the online aisles of Amazon, we bring to you three games on our wish list this holiday season.

Starting at number 3 we have Fobia, a HARD puzzle-platformer game. ( did we say hard? We mean HARD!!) If you’re looking for a challenge this game is for you. With stunning aesthetics, beautiful creatures, and an environment where everything can kill you — including your own two feet.

 

At number 2 we have The Last Campfire. Illuminated by stunning flames, orbs, and glowing water, The Last Campfire is a puzzle game with a story to tell. As you traverse this immersive world you’ll stumble upon lost souls and attempt to reunite them with their path. By completing puzzles you’ll achieve the impossible and may just reunite with your own path.

At number 1 we have Gris, a stunning platform adventure game. As you traverse this mystical world you’ll uncover new abilities, friends, and bring color back into the environment. The story is told through the colors, environment, and music throughout the game.

Each of these games are available on Steam, Nintendo Switch, Playstation 4, and Xbox One.

Enjoy this list? Looking for your favorite game, or maybe YOUR game? Tweet us @Beamable with your recommendations.

Here are more games we’ve enjoyed highlighting: Cozy Games on Our Radar

New to game creation? Not sure exactly where to begin? Here are our top ten tips Game Developers want new Indie Game Developers to know starting out.

Tip #1: Start Small

While creating your first game is exciting, invigorating, albeit also exhausting, don’t let your rush of creativity get the best of you. While you may have a million and one ideas to push into a project, its better to avoid starting big projects while you are a newbie.

You’ll have the time to cultivate and refine your ideas over many projects, so relax and take things one at a time.

Tip #2: 1 Step at A Time.

Small steps eventually combine together to output a polished product. By focusing on the current step and phase of the project you are in you are more likely to not only complete the project but also avoid burn-out.

Tip #3: Get a foundation.

You’ll need some knowledge and experience before diving straight into a new project. Luckily here at Beamable, we have engineers and developers eager to connect and consult on your various projects and aspirations. If you’re looking for advice join our discord at www.beamable.com/discord to chat with us.

Tip #4: Have a goal in mind

It is extremely important to Always keep your audience in mind. While this is your game, they will be the ones playing it and you want to ensure that the player relationship with the game is the best it can be. Make sure to incorporate lifestyle changes, updates, and camera angles that can help the quality of your game. If you’re unsure on how to utilize camera angles to the fullest read our article here: Zooming a Camera in Unity

Tip #5 Your plans are going to change

When Animal Crossing was first created, it was named Animal Forest. Our point is, plans change, games evolve, you and your project will grow alongside one another. While having a dinosaur named Larry shooting laser beams out of its eyes is a super cool idea, it may need to be put away for your cozy-home-deco game.

Tip #6 You’re going to need help

Glitches, Bugs, and Online issues are not only common, they’re normal. When you’re met with these struggles do not be afraid. You have access to many willing communities through Reddit, Twitter, and Discord that are more than willing to help you with these technical issues. Don’t be afraid to reach out!

Tip #7 Recognize when something just isn’t worth it.

Larry the laser beam dinosaur is super cool, but his shading is wrong, every time we try to put him in the game he glitches out, and he’s slowing production time by a month. Maybe Larry isn’t worth it, and that’s okay. Some things are meant for later projects, don’t try to squeeze something in that is not fitting into the bigger picture.

Tip #8 You Might Fail, and Fail Hard

Larry the dinosaur? Yeah, he just erased 45% of your progress. How? We don’t know. It happens, and it is not fun, but it is very normal to experience failure in a project. Keep pushing and realize every failure is an opportunity to learn from for your next venture.

Tip #9 Don’t Give Up! Remember What You’re Trying to Make

With every obstacle you face, there’s a new opportunity for something to be learned. Sure the water mechanics in your game have failed over and over again, but now you know how to fix it and make waterfalls. Every experience can be learned from in-game creation. Just ask our devs!

Tip #10 Have Fun!

This is not just a project, this is your passion. Creating games can be an extremely fun and fulfilling process if you let it. Be inspired by the games you love, and the community that surrounds you. We’re sure as heck inspired by you.

Looking for more tips? Here are some insightful articles below:

How to Add a Leaderboard To Your Game

Do You Have a Program to Build Videogames?

Code Your First Video Game in 6 Steps!

Get Started on your Game and Download Beamable Today:

https://www.beamable.com/free

Searching for a platform that can handle volume and large-scale projects? Beamable can do both! Over the past few months, we’ve noticed a trend of creators struggling to find support for high-volume and large-scale projects. Here at Beamable we have the team to provide you with the best support in improving your scalability and supporting high volume.

Volume

We strive to support high volume on our platform. A large amount of Concurrent Users (CCU) is something we can support for your game. When your Daily Active Users (DAU) evolve into Monthy Active Users (MAU) it’s important to ensure that your game is supported on every front. Since Beamable is built to be scalable, we are able to grow our serves flexibly and support DAU, MAU, and CCU with no cap!

Scalability

By utilizing various servers, Beamable is able to ensure your game will work as anticipated. Being able to add or remove servers when the traffic grows or shrinks allows us to mitigate and track traffic passing through our servers for your game.

More Features

To learn more about our recent updates to our program, we wrote about our latest release in this article.

Live from PAX West with PM Studio and Grave Rave Games

This episode of the Beamable Game Dev Podcast is live from PAX West. PM Studio shares some of the amazing games they are publishing. Paul from PM Studio shares some great tips for pitching a publisher. You will also hear from Grave Rave Games and learn about their game Squish. It is Tetris meets Smash Bros to create a fantastic party game that will be playable online. I hope you enjoy this interview and you can catch our last episode here.

To learn more about Beamable check out some of our sample projects here.

Grab a blanket and a cup of coffee and get cozy with these indie games.

As we near closer to the holiday season, there is a multitude of cozy games to wishlist releasing in 2022. In this week’s blog post we’re revealing three games that have caught our attention.

Rainboy

Our first game is Rainboy, a precision platformer displaying hundreds of levels. Cast into the universe knowing nothing prior to the world, you’ll explore the seven wondrous worlds and adventure through sleepy pandas and treacherous bosses. The brightly lit aesthetic, and wondrous sounds, will force you to search for your purpose in the world and what it means to be alive.

Aka

The second game that caught our eye is Aka. With hand-drawn elements, you’ll traverse a small open-world game where you can feed baby dragons, nap on a giant monster, and take care of the environment that surrounds you. As you explore you’ll be reminded of demons from your past you try to forget and are forced to confront.

Naiad

Our final cozy game for this week is Naiad. Setting to release during Q2 of 2022, Naiad is simply “A game about nature.” Curated in a beautiful art style, you’ll be able to sink into the clarifying waters to relax and explore various environments.

For more information on these games follow:

@Sealllio for Rainboy wishlist here: https://store.steampowered.com/app/1758250/Rainboy/

 

@BarthelemyNamra for Aka wishlist here: https://store.steampowered.com/app/1591450/Aka/

 

@HiWarp for Naiad wishlist here: https://store.steampowered.com/app/1813860/NAIAD

Unleash your inner budpreneur in B-Real Monster Buds!

Soar higher than you’ve been before with the latest game from LDRLY. Grow your plants, make cash, and take the throne of the finest pot botanist around in B-Real Monster Buds.

Multiplayer Connectivity

With multiplayer connectivity, you’ll be able to grow the best buds with your best buds from Facebook! Earn rewards from each in-game event to boost your lab to the next level! As you level up you’ll unlock new rewards to achieve and events to explore.

Exclusive Features

Hire and manage your crew and collect new cards and gain more customers! Grow insane strains and make insane cash by the gram! B-Real Monster Buds will have you explore the wild events of B-Real and his alter ego Dr. Greenthumb; as well as interact with the coolest game characters out there. B-Real Monster Buds is sure to take your breath away.

B-Real Monster Buds has dedicated customer support teams working closely with the players; LDRLY invites you to contact LDRLY directly through each game’s help function. More information about B-Real Monster Buds can be located here. All images were taken from LDRLY.

Beamable has expanded its equity funding to over $10M

Read the official press release at PRWEB

Beamable has expanded its equity funding to over $10M. New investor Gutbrain Ventures joined a round led by Companyon Ventures and GrandBanks Capital, with participation from other current investors including Defy. Beamable provides game makers with the tools to deliver and continually optimize their live games with infrastructure, features, and content.

Beamable has significantly expanded its platform over the last year based on product input from over 1,000 game developers and the interactions of over 10 million players. The growing, globally-distributed team now has 41 people who have built a platform to make live games easy to build, operate and scale. Unity developers can drag-and-drop social features, virtual items and dynamic content updates to their games with simple, visual tools.

“Making a live game should be as easy as publishing a web page,” said Jon Radoff, CEO of Beamable. “Although engines like Unity and Unreal have made it easier to author 3D experiences, the workflow and infrastructure to enable games with sophisticated economies and communities has lagged far behind. We empower game makers of all sizes to go directly from their imagination to a game of any scale.”

Beamable’s backend is based on microservices, an architecture used by some of the largest online companies including Shopify and Netflix. This architecture equips studios to rapidly scale to millions of active players while retaining a high degree of agility in their game design–without worrying about the high cost of ownership related to server engineering and DevOps.

“The best development platforms are built by teams who have deep domain experience,” said Bob Davoli, Managing Director at Gutbrain Ventures. “The Beamable team clearly understands the needs of game developers. We were impressed by how the company is creating an authentic culture of making game studios successful.”

To learn more about Beamable, visit https://beamable.com — a complete media kit that includes images and the company’s vision for live games may be found at https://beamable.com/media.

About Beamable

Beamable fights for the game makers of the world by helping them turn their game ideas into thriving businesses with a low-code, serverless Live Game platform. Beamable enables anyone who builds, updates, and maintains a live game to save time and earn more money. Beamable is a global, remote-first company led by a team of game-industry and enterprise-technology veterans, backed by investors including Companyon Ventures, GrandBanks Capital, Defy and Gutbrain Ventures. For more information visit https://beamable.com.

About Gutbrain Ventures

​​Gutbrain Ventures is an independent venture firm that invests primarily in software companies and has been making investments for thirty years. Gutbrain looks for passionate and driven founders with innovative and disruptive ideas. Managing Director Bob Davoli has appeared on the Forbes Midas List five times.

Meet some of the team behind Beamable update 0.17.0

In the Beamable Game Dev Podcast episode 15, we get to meet some of the team behind the latest update. Each member of the team shares what they are most excited about with Beamable 0.17.0. Chris’s cat also makes an appearance so make sure to check out the video. You can find the complete rundown of Beamable update 0.170.0 here

This week we’re celebrating Wishlist Wednesday in a new way. For the first time, we’re showing you our top three picks from games that have been interacting with us for the past few Wishlist Wednesdays.

Starting at number 3 on our list, Impious Pumpkins is a Real-Time-Strategy game where you fend off hordes of evil pumpkins attacking you and your ghost pal’s resting places. This game will give you pumpk-in to talk about.

At number 2 on our list awaits The vagabond, Emperor. With the perfect timing of a curse, you’ll be able to traverse the life as a vagabond working to become an emperor. Explore dungeons and fend off armies to create your empire!

Bo sits at our number one spot this month. Showcasing beautifully hand-drawn animations laced with the beauties of Japanese folklore, you’ll traverse this mysterious world as a tiny fox using its earring as its weapon.

Each of these games is available to pre-order on Steam! Check them out in our personal Steam wishlist library. Wishing your game was mentioned or not seeing your game on our Steam wishlist? Let us know on Twitter @Beamable

Steam Wishlist Link: https://store.steampowered.com/wishlist/?snr=1_wishlist_4__12

Creating and publishing games

If you are early in the game dev journey this is an episode you won’t want to miss. Mattlekim shares some great insights on game development. He shares where he finds inspiration when creating his games. How to prototype games and use your friends to test the games to see if they’re any good. Creating games isn’t all he does, he has also been working with some friends on the publishing side. Helping them get their games on the Nintendo Switch. His latest game, Fly Johnny Fly will be released soon so keep an eye out for it.

Game Jolt Announces Spoopy Jam Publisher Panel

With all the fun we’re having in Spooktober and Spoopy Jam with Game Jolt, we’d like to welcome more to the party! Game Jolt announced that Team17, Developer Digital, TLM Partners, Ludus, tinyBuild, Lunar Owl, and Amazon Games are joining the Spoopy Jam team!

Spoopy Jam allows creative minds to use their magical powers and formulate a cute and spooky multiplayer game within 15 days. In addition to a prize pool of $10,000, 3 winners will have the opportunity to pitch their creations to the Spoopy Jam team of investors for funding and publishing their game. The winners will also have the chance to play their creation on the home page of Twitch. tv!

Remember to follow us @Beamable on Twitter for continuous updates throughout the duration of Spoopy Jam.

Beamable is happy to announce the release of our Unity SDK 0.17.0. The full changelogs can be found below.

Here are the highlights of the release.

Microstorage Local Preview Beamable 0.17.0 brings a brand new database capability to the microservices feature. In addition to creating C# Microservices in Unity, now you can create and manage a Mongo database from the Microservices Manager window. You can create and restore database snapshots, explore your data using Mongo Express, and filter database logs from within Unity. This feature is only available in preview, so you’ll need to enable it in Project Settings / Beamable / Microservices / Enable Storage Preview. Once you’ve enabled the preview feature, you can create a Storage Object from the Microservice Manager, configure a Microservice to depend on the Storage Object, and then automatically receive a pre-built and connected database client in your Microservice code. You have full access to the Mongo C# Driver, so you can take advantage of the powerful capabilities Mongo provides. While the feature is in Preview, you won’t be able to deploy any databases, but you can get an early look at the workflow and capabilities of Beamable Microstorage.

Microservice Enhancements

We’ve improved the Microservices feature in several ways. Your ClientCallable methods can now return Promise types. You can also return List types directly from a ClientCallable as well. The Microservice Manager window has a few workflow improvements, such as being able to see Remote-Only services, and tailing service logs more accurately. The final major enhancement in Beamable 0.17.0 is the addition of container-level health checks for deployed Microservices. If you have deployed a Microservice, and for whatever reason any particular cloud instance becomes unresponsive, the instance will automatically restart. This will help ensure that your Microservices have maximum uptime.

More Authorization Support

Beamable 0.17.0 adds support for two new seamless player log-in methods; Steam and Device authentication. If your player is already logged into Steam, they can associate the Steam login with Beamable effortlessly. Similarly, Device authentication registers your player’s unique device id to Beamable. You can use Device authentication to help remember player data through app reinstall events. In addition to these new authentication schemes, players can now also unlink a third-party authorization. The RemoveThirdPartyAssociation method in the AuthService will let players remove an association from Steam, Facebook, Google, Apple, or their Device id.

Schedulable Events, Listings, and Content Improvements

The 0.17.0 release includes the ability to schedule Events and Listings on a recurring basis. Events have traditionally been one-off competitions where players can participate and receive rewards based on their performance. Now, you can configure your Event to repeat on an ongoing basis, or to repeat a specific number of times. Similarly, the Beamable Commerce capability lets you assign active periods to store Listings. Now, you can customize when a Listing is active, schedule it to repeat on an ongoing basis, or a specific set of dates and times. The Event and Listing schedules both come with easy-to-use scheduling workflows, but both use cron strings under the hood. If you need to create an advanced schedule, you can alter the raw cron strings directly from Unity, publish your content, and you’ll be all set. In addition to schedulable Events and Listings, the Event system now supports player cohorting.

Workflow Improvements

This release includes several workflow improvements around the development process. When you use the Beamable 0.17.0 Admin console, you’ll be able to see command suggestions, use the Tab key to autocomplete and cycle your command inputs, and use the Up/Down arrow keys to scroll through your command history. We’ve also added a variant of the Promise class that doesn’t require a generic type. Lastly, all of our subscription-based SDKs have a new method called Fetch that gives you the raw network data. You can use it to get direct access to the API results without going through the Beamable subscription layer.

Added

• Device id authentication support
• Steam third party authentication support
• Auto-complete text feature for AdminFlow prefab
• New default currency.coins currency that demonstrates client writable currency.
• Ability to remove a third-party authorization with RemoveThirdPartyAssociation method in AuthService
• Cohort Settings for EventContent that support partitioning by player stats
• Event schedules for repeating events
• Listing schedules for repeating listings
• Support for archiving manifest namespaces.
• A Fetch() method to all subscribable SDKs that requests and returns the raw subscription data
• Microservices- Local Mongo Storage Preview
• Microservices- Ability to use Promises as a return type for ClientCallable methods
• Microservices- RemoteOnly Microservices visible in Miscroservice window
• Microservices- Deployed Microservice instances will be automatically re-run if they become unhealthy

Changed

• An optional force refresh parameter to all subscribable SDK’s GetCurrent() method that forces a network request
• API.Instance. Requester is now an IBeamableRequester
• The Promise class is no longer static, and extends from Promise<Unit>
• The realm dropdown now has a loading spinner on realm switches
• Content Inspector date picker with no user given value no longer constantly updates
• Content deletion popup opens as a separate window
• Microservices- Generated services no longer include the class name in the namespace

Fixed

• If no internet connection exists on startup, API.Instance() will retry every 2 seconds until a connection is established
• Able to build games to device
• Microservice clients can now deserialize Json lists
• Microservice log view stays focused on the bottom of log feed Our changelogs can be found at https://github.com/beamable/Changelogs/blob/production/com-beamable-changelog.md

Erin was at Too Many Games

Last Weekend our Junior Marketing Manager, Erin McCarrie, attended the Too Many Games Convention celebrating Indie Games. Our content creator and video producer here at Beamable, Josh Schmidt, sat down with Erin to talk about her experiences on our Game Dev Podcast.

She wanted to share some of the photos she took at the convention, and her excitement about the indie games she interacted with.

“ It was such an invigorating experience all around. The thing that inspired me the most was the drive of the creators of Seahorse Saga. It originally started as a senior school project, and developed over the course of the pandemic into a full-fledged game!” She also was able to play Fish Heads, a one-button game that allows you to traverse through the depths of the sea dodging various creatures.

A live game that Erin interacted with was Retro Mania. “ They had a table featuring multiple copies of the game across various platforms like PlayStation and Xbox. The game was launched a year ago and features some great fighting characters.”

Erin shared some of the highlights of her experience on our Podcast with Josh like meeting Charles Martinet, Meeting Kim and Wood from BeatemUps, and even connecting with Miss Click. Below are some photos that encapsulate these features of her experience.

 

 

 

Happy Spooktober!

Update

Game Jolt has just announced a $10,000 prize pool for the Spoopy Jam!

To kick off October we’re announcing our partnership with Game Jolt in the SpoopyJam! You’ll have the opportunity to not only create your own game with Beamable but also win exclusive prizes! Spoopy Jam not only helps provide a space for creation, but it also enables the ability to network and collaborate with companies fighting for you, the game maker.

Throughout the next few weeks stay tuned for updates as we have a lot of surprises in store. We’ll not only be announcing the prizes, but we’ll also extend a special invitation to a network of resources. From AMA’s (Ask Me Anything), to exclusive webinars, and mentoring sessions, we aim to ensure that you and your game have the best chance of winning Spoopy Jam and having a spooktacular time while doing it! We also have a super special surprise for those implementing Beamable into the creation of their game.

This is our second partnership with Amazon and Gamejolt following on the heels of Party Jam earlier this year where hundreds of game teams built dozens of exciting multiplayer games. We’re excited to continue the collaboration with Amazon and GameJolt to continue creating interactive and rewarding spaces for game developers.

Make sure to follow us on Twitter @Beamable and @GameJolt and turn on notifications to not miss a beat! You’ll wanna go big or gourd home for these prizes!

Every new game maker provides their own wonderous perspective on gaming. While each creator starts their journey with a flourishing of ideas, eventually the plateau happens. What then?

We’ve gathered three ways to help you create a game in Unity with the help of Beamable.

What’s better than creating a game? Creating a game with friends! Building your community will help you connect with creators going through the same struggles as you but can help inspire you with more ideas for your game’s creation, story, and technical elements. Two communities we recommend joining for support are our Discord and Unity’s Community. In our discord, you’re not only able to interact with other creators, but also have access to our team for support! ( insert link and picture of our discord sync with josh on that) Unity also has created its own community forums to help its creators interact, and produce with each other. Looking for more? Check out the #madewithunity hashtag on Twitter to connect to other unity creators for inspiration, connection, and support! Tag us in your current projects, we love seeing what you create!

Beamable Game Dev Podcast Episode 10: Adding a leaderboard with Beamable

Have you wondered how to add a leaderboard to the game you’re developing in Unity? The answer is Beamable. In episode 10 of the Beamable Game Dev Podcast, it’s all about the leaderboard. Adding a leaderboard to your game adds a social element that can prolong the life of your game. It can also work as a tool for word of mouth. Leaderboards in your game give your community a chance to compete. Streamers can compete with their community, which could lead to more users, sales, etc.

Beamable leaderboard sample project

If you want to learn more about adding a leaderboard to your Unity game with Beamable check out our samp project here

Beamamable Leaderboard Sample Project

Beamable is happy to announce the release of our Unity SDK 0.16.0. The full changelogs can be found below. Here are the highlights of the release. 

New Microservices Experience

The Microservices window has been completely rebuilt. You can create, manage, monitor, and deploy your services all from the new window. Each microservice has its own log container that can be docked anywhere in the Unity Editor. We’ve also added support for executing Docker Snyk tests, viewing the microservice’s build directory, and attaching a Command Line Interface directly to the microservice Docker container.

Disable Unity Domain Reloading

Unity has offered the ability to increase your Playmode entrance speeds by disabling domain reloading since Unity 2019. Now, Beamable 0.16.0 supports disabling domain reloading as well, which can dramatically speed up your workflow. To try it out, enable Enter Playmode Settings in the Editor section of Project Settings, but don’t enable any reloading options. You should be aware that you may need to adapt your own code to support this workflow.

Leaderboard Cohorting

Beamable has always offered leaderboards as a core capability. Now you can control how your players are grouped into leaderboards by using cohorts. Cohorts can be configured based on player stats, or percentage splits. Beamable uses your configuration to distribute players amongst the various cohorts. The leaderboards SDK automatically aligns the cohorts with leaderboards, so players in the same cohorts exist in the same leaderboards. You can use this feature to group your players based on their gameplay, business logic, or spend.

Content Workflow Enhancements

Content is a central Beamable feature, and in 0.16.0, we’ve added a few improvements to make your workflow faster and more efficient. In the Unity Editor, you can now reset your local content files by going to Window/Beamable/Utilities/Reset Content. If you need to create a new content class, we’ve added a menu item at Create/Beamale/Content Types that will automatically generate you a content class with the associated Content Ref and Content Link classes. When you enter playmode, the Admin Console has a few new commands to help you investigate and verify your content. LIST_CONTENT will print your current content manifest, and GET_CONTENT will display the serialized version of a piece of content. These commands can help you discover issues or validate your content flows.

Automatic Network Compression

Beamable 0.16.0 automatically compresses network traffic between your game and Beamable’s servers. If any request or response exceeds 1KB, the traffic will be GZipped. GZip compression can reduce the payload size of your network traffic by an order of magnitude. Megabytes become kilobytes. This will speed up your game’s connection to Beamable, and increase the size of messages you can send.

Added

• Support for disabling Unity Domain Reload
• Content console commands (GET_CONTENT, LIST_CONTENT, CONTENT_NAMESPACE, SET_CONTENT_NAMESPACE)
• Easy custom content class creation in Create/Beamable/Content Types
• Resetting content to the server state under Window/Beamable/Utilities/Reset Content
• MustBeSlugString content validation with configurable option to allow underscores
• OptionalBoolean type for content
• Leaderboard Apis that supports fetching partition/cohort cached assignment transparently
• Ability to disable VIP currency awards on Mail Rewards
• PlayerSettings scripting define symbols are saved in the Diagnostics file
• Beamable package version Toolbox announcement
• Microservices- New Microservices Manager window
• Microservices- Local microservice health checks are accessible on container port 6565
• Microservices- Snyk testing for microservices
• Microservices- Ability to categorize [ClientCallable] methods in documentation with [SwaggerCategory]

Changed

• Request and Responses to and from Beamable are GZipped if larger than 1K
• Leaderboard Content supports partitioning, max size, and cohorting
• Leaderboard Update API will transparently fetch cached assignment
• PlayerStatRequirements now support providing the domain and access to stats
• MustBeOneOf content validation attribute now supports Optional types
• Beamable Platform errors all extend from RequesterException in Unity Client and microservice code
• Redesigned internal Toolbox announcements
• Content Manager publish flow shows Realm and Namespace for confirmation

Fixed

• Added missing attributes for content classes
• SocialService SocialList serialization
• Account Management Flow third party login buttons use correct third parties
• Microservices- Visual Studio Code debug configuration source maps are now correct
• Microservices- AssumeUser() no longer throws null reference

Our changelogs can be found at https://github.com/beamable/Changelogs/blob/production/com-beamable-changelog.md

The road ahead

Here at Beamable, we pride ourselves on transparency for our customers, employees, and investors. We are extremely excited to announce the publication of our Public Beamabel RoadMap!  https://beamable.com/roadmap 

This roadmap includes information about our latest release notes, recently shipped items, updates on our Backend Services, Unity SDK, C# MicroServices, and more. We are using a public Trello board to make it easy to maintain and update.

We value transparency in our product communication, creative partnerships, and through all aspects of our customer support team. This roadmap will ensure we take accountability for our own progress, as well as update everyone on the latest ideas and breakthroughs in the Beamable service.

By providing a view into our roadmap, we hope you will gain an understanding of what we are working on now, what we are working on next, and the exciting things to come for Beamable.

We also hope that you will reach out with any questions, comments, feedback, and input as we continue to define, design, and plan new features. This roadmap is a reflection of all the conversations we’ve had with you the game developers as we ambitiously expand Beamable and wake up every day to fight for the gamemaker!

If you have any questions, please reach out via our contact form at https://beamable.com/contact-us or through your customer success representative!

A Night At The Races, a point and click, action platformer.

In episode 9 of the Beamable Game Dev Podcast, I sit down with Umut the developer of A Night At The Races. The game hit the Switch eShop on Sept 3rd after being on PC. From the moment I fired up this game, I could tell it was something special. As Umut peels back the curtain on the story behind the game you will see why it’s so special. Learning about the early prototypes that he showed his friends, to finding himself in a dark place mentally, and how it shaped the final game.

A game within a game.

This is a game within a game that does a great job of making you care for the main character. You play a part in helping the character get out of a bad situation by mastering a platforming game and trying to win a gaming tournament. Now, this isn’t your typical platformer because of Umut’s game dev history. A Night At The Races is a hybrid platformer that combines endless runner mechanics with platforming, and it just works.

Listen to the full episode here.

Watch the full episode here.

Have you played A Night At The Races? I would love to hear your thoughts in the comments below.