View Categories

Online Multiplayer Framework

17 min read

Online Multiplayer Framework #

Online Multiplayer Framework – Documentation #

The Hyper Online Multiplayer Framework is a modular system that provides full session management, with optional support for teams, scores, and game settings. It is designed to offer a seamless experience for managing multiplayer sessions, including player connections, transitions between menus and games, and integration with different online subsystems such as Steam or EOS.

OMF allows you to:

  • Host, discover, and join multiplayer games
  • Manage players, teams, scores, and settings
  • Run flexible multi-game playlists
  • Swap online subsystems (e.g. Unreal Subsystem, Steam or EOS) with minimal setup

🔧 Everything is modular and designed for drop-in use across all Games by Hyper assets.


Core Components #

  1. Session Management
  • Central system managing the multiplayer lifecycle.
  • Handles transitions between:
    • Main Menu → Host Screen or Server Browser
    • → Lobby
    • → Game
    • → Next Game (as defined in a Playlist)
  1. Player Management
  • Tracks connected players throughout the session.
  • Optionally extendable with:
    • Team Management – Assign players to teams.
    • Score Management – Track scores per player or per team.
  1. Playlist System
  • A Playlist is a sequence of Games.
  • Each Game has:
    • A specific Game Mode
    • Its own Game Settings, defined relative to the Game Mode
  • Playlists allow flexible configurations (e.g., Game A → Game B → Game C), each with different modes/settings.
  1. Game Settings Management (optional, expandable)
  • Designed to support per-game and per-mode settings.
  • Ideal for rule-based or competitive games.


Online Subsystem Support #

By default, OMF uses Unreal Engine’s built-in Online Subsystem, which supports:

  • Local network discovery
  • Direct IP connections

However, the system is fully subsystem-agnostic, allowing you to switch to external services such as:

  • Steam (via Steam Integration Kit – SIK)
  • Epic Online Services (EOS) (via Epic Integration Kit – EIK)

Subsystems abstract the following functionality:

  • Session discovery (e.g. server browser)
  • Hosting and joining games
  • Logging in and out
  • Leaving sessions

The core session flow in OMF remains the same, regardless of the active subsystem.

OMF does not re-implement full platform integration. Instead, it connects to existing solutions using a compatibility layer.

For more information on supported plugins, how to install them, and how to use our integration files, continue with the following chapters:

  • Before You Start: Everything You Need to Know About Steam or EOS Integration
  • Base Installation – Setting Up Steam or EOS Support


Core Principles and components of OMF #

SessionManager_Base #

  • Manages core multiplayer functionality:
    • Lobby & Session Hosting: Supports lobby-style and session-style games for player gathering
    • State Transitions: Handles flow:
      • Main Menu → Lobby
      • Lobby → Game
      • Game → Lobby
    • Game Settings: Configurable per game type:
      • Match duration
      • AI fill
      • Custom settings
      • Tied to Playlists (maps, game types, parameters; set dynamically or per server)
    • Session Lifecycle: Controls:
      • Start/End
      • Pause/Resume
      • Utility functions for cleanup and session info
    • Online Subsystem Integration: Uses Online Subsystem Component to select:
    • Follow EIK or SIK setup documentation for proper configuration

SessionCommunicator #

  • PlayerController component bridging client and SessionManager:
    • Client Commands: Sends host/join/leave requests via RPCs
    • Server Browser: Searches sessions and integrates into UI
    • Sync & Feedback: Relays SessionManager status/info to client

Session Data Persistence #

  • Uses Session Save Game system to store:
    • Current playlist
    • Active game in playlist
    • Configured settings
    • Session setup data
  • Saves UI changes (e.g., session settings) locally
  • Ensures settings persist across sessions and game closure

Using the System #

Creating and Using Custom Playlists #

  • Start the Game
    • Launch and navigate to Host Game menu
  • Create a Playlist
    • In Host Game menu:
      • Add/remove games (top left)
      • Select game types
      • Customize settings (e.g., match duration, AI fill, custom rules) on right
  • Apply & Save
    • Click Apply to save playlist
    • Playlist becomes available for selection
  • Host with Custom Settings
    • Choose custom playlist
    • Set session settings (e.g., name, password, lobby usage)
    • Host session with playlist settings
  • Game Flow
    • Session progresses to next game in playlist (if defined) after each match

How to Add Your Own Game Setting #

  • Add a Gameplay Tag
    • Open Project Settings → Gameplay Tags
    • Create tag (e.g., CustomSetting_YourName) under game settings parent tag
  • Set Default Values
    • Open Game Mode Defaults for target game type (e.g., team match)
    • Select data asset (e.g., TeamDeathMatchDefaults)
    • Add custom setting and define default values
  • Create a Playlist
    • Open Playlist Menu and create new playlist
    • Custom setting appears for value adjustments
  • For Enum Settings: Add to BFL Session Manager
    • Add to GetEnumValuesBySettingName in BFL Session Manager for auto-population
    • Enables dynamic setting value transfer
  • Implementing Your Game Setting
    • Add BPI_GameSettingsDistributor interface to actor/component
    • Use SendGameSettings event to access settings
  • Accessing Settings in the World
    • For actors in world:
      • Loop over settings, switch on gameplay tag
      • Retrieve setting by tag
  • Accessing Settings without the Actor
    • Use Session Manager’s GetGameSettingFromCachedConfig
    • Input setting name to retrieve value

How to Set Up Your Own Game Type #

  • Add Gameplay Tag
    • Open Project Settings → Gameplay Tags
    • Create tag under GameType parent tag
  • Register Game Type in Session Manager
    • Open SessionManager_Base
    • Add tag to Game Types Gameplay Tag Container
  • Set Default Settings
    • Open BP_SafeSessionConfig blueprint
    • Find GameplayTagToPDA (Gameplay Tag to Data Asset map)
    • Add game type tag and assign new data asset with default settings
    • Create data asset with custom settings
  • Verify
    • Launch game; custom game type appears in session list

How to switch between playlist and Single Game mode #

  • Most shooter like games, you would like to setup Playlist like hosting.
    • By default, it is setup to playlis type game.
  • If you want to switch to Single Game type hosting (e.g. more like The Forest or something simular), you can switch it.
    • This can also support save and load hosted games if combined with our other systems like MST Pro.
  • To switch the Host Type, simple click on your session manager base (set in the gamestate (where it should be placed) and click on Host Type and select single or playlist.
    • Do this both on the main menu as in the game Game State.

Integrating with other projects of us like MST Pro? #

(optional if not using OMF playable map – Make sure your game mode is set correctly

Your game mode that you use in your playable map, requires to have BP_GameMode_PlayerConnection set as the parrent. We advise to simply use our OMF Gamemode and make sure the other code of the gamemode is also in your used game mode. In our OMF project we have done so by default. In other projects, e.g. like MST Pro, we have not and needs to be manually set. So there you need to set the following:

Once you have done so, in the game mode, make sure to add cal to parent function in your event graph on the On PostLingin and OnLogout

How to use Steam or EOS – Introduction #

OMF (Online Multiplayer Framework) is designed to work out of the box using Unreal Engine’s default local Online Subsystem. This supports LAN play and direct IP connections.

If you want full online functionality via Steam or Epic Online Services (EOS), we recommend integrating one of the well-supported third-party plugins listed below.

This chapter explains what those plugins do, what we support, and how integration works.

Why We Use Third-Party Plugins

OMF focuses on:

  • Session and team management
  • Playlist-based game flow
  • Player and score tracking
  • Game configuration systems

We intentionally do not reimplement what other trusted plugins already provide. For online platform integration, we rely on:

  • SIK – Steam Integration Kit
  • EIK – Epic Integration Kit (EOS)

Both plugins are developed by Betide Studio and offer full Blueprint access to login, session discovery, and platform authentication.

OMF includes a compatibility layer that connects our systems to these subsystems without altering any gameplay logic.

Why We Don’t Include Plugin Files

We do not include the SIK or EIK plugin files directly for licensing reasons.

These plugins are:

  • Freely available via GitHub
  • Available for purchase on Fab.com (recommended to support the developer)

OMF builds on top of them, but does not replace or modify them.


Scope of Support #

We provide support for:

  • OMF core systems (SessionManager, playlists, team/score/player handling, etc.)
  • Our subsystem compatibility layer

We do not provide support for:

  • Installing or configuring the SIK/EIK plugins
  • Setting up Steamworks or the EOS Developer Portal
  • Credential errors, login failures, or build/package troubleshooting related to subsystem setup

For any of the above, refer to the official plugin documentation:

Subsystem integration often requires:

  • Steam App ID configuration via Steamworks
  • EOS Product and Client setup via the Dev Portal
  • Correct use of FIDs, artifacts, and environment settings
  • Testing in packaged builds (not in-editor PIE mode)

Make sure to follow their setup instructions carefully.

Feature Scope

OMF implements only the core multiplayer features required to get your game online:

  • Login and logout
  • Hosting
  • Session discovery
  • Joining and leaving games

Other features available in Steam or EOS such as achievements, matchmaking queues, in-game purchases, voice chat, etc. — are not implemented or supported by OMF.

However, OMF is designed to be modular and extendable. You can implement additional platform features inside:

  • GameInstance
  • The SessionManager or SessionCommunicator
  • Custom player states or controllers

This gives you a stable base without locking you out of advanced functionality.

How to use Steam or EOS – Prerequisites #

This chapter walks you through the general steps needed to integrate OMF with Steam or Epic Online Services (EOS). These steps are shared across both platforms.

Step 1 – Install the Plugin (SIK or EIK) #

  • Download either SIK or EIK:

SIK (Steam Integration Kit)

EIK (Epic Integration Kit)

⚠️ Note on Marketplace vs GitHub Versions

Both SIK and EIK are available as:

  • A free version on GitHub (requires manual compilation)
  • A paid version on Fab.com (precompiled and more user-friendly)

We recommend the Fab.com version for most users, as it:

  • Does not require recompiling the plugin
  • Includes quality-of-life features and priority support
  • Supports newer Steam SDK versions (SIK only)

If you choose the GitHub version:

  • You must manually compile the plugin from source
  • We do not provide support for compiling, SDK integration, or resolving build errors

Step 2 – Install OMF Subsystem Compatibility Files #

OMF provides a set of prebuilt files to link OMF to the selected subsystem (SIK or EIK). These handle:

  • Login
  • Session discovery
  • Join/leave events

To access these files:

And for EOS

Step 3 – Apply the Correct Components in Maps #

  • In the AC_SessionManager_Base search in the Class Defaults for Custom Online Sub System Component and select the subsystem that you would like. If None is selected, it uses the default Unreal Subsystem.

  • Do the same in AC_Session_Communicator

  • These components will now route subsystem logic through the new integration files

Step 4 – Set the Correct GameInstance #

You must configure the correct GameInstance based on your chosen online subsystem.

Make sure to have the game instance files of your subsystem added

  • Go to:
    Edit → Project Settings → Maps & Modes → Game Instance Class
  • Choose the appropriate class:
    • BP_GameInstance_EOS → for EOS via EIK
    • BP_GameInstance_Steam → for Steam via SIK

❗ Do not use BP_GameInstance_Base unless you're working purely offline or in LAN-only mode.

Step 5 – Continue With Platform-Specific Setup #

At this point, the plugin is installed and OMF is prepared for integration. When you compile the manually added components it should be successful.

  • If you are using Steam, continue with:
    → Using Steam via SIK
  • If you are using Epic Online Services, continue with:
    → Using EOS via EIK

These chapters will guide you through the platform-specific configuration needed to complete the setup.


Step 3 Alternative and check if it does not seem to be working

  • Alternatively, you need to check or are able to override the variable in your GameState and Playercontroller classes in all the maps you are using session management (Main Menu, Lobby, Game Map)
    • Navigate to your selected game mode in your Menu, Lobby and Game map and open the Game State And Player Controller

    • In both components (Game state and Player Controller), select your used subsystem

Using EOS via EIK (Epic Integration Kit) #

Before You Start

Before continuing, make sure you’ve completed the following setup:

  • Read: How to use Steam or EOS – Prerequisites
  • Completed: Base Installation – Setting Up Steam or EOS Support
  • Installed the Epic Integration Kit (EIK) plugin
  • Installed OMF’s compatibility files for EOS
  • Assigned the correct components (SessionManager, SessionCommunicator) in your maps

If not, return to those chapters before continuing.

EOS Integration Steps #

OMF does not replace or modify EIK. It simply routes multiplayer logic through it. Proper configuration of EIK is required for EOS integration to function correctly in your project.

Step 1 – Follow the Official EIK Documentation #

Use the official Betide Studio documentation for installation and configuration:

You will need to configure:

  • EOS Product ID
  • EOS Sandbox ID
  • EOS Client ID
  • (Optional) EOS Client Secret
  • Auto-login behavior
  • Lobbies (if needed)

This process requires access to the Epic Online Services Developer Portal and may involve several configuration steps.

For community-based help, visit the Betide Studio Discord:
https://discord.gg/Jh6FJxjyYm


Step 2 – Apply Configuration Snippet #

Follow the configuration steps as described here.

Copy the contents of that into your project's Config/DefaultEngine.ini. or use the auto setup.

Replace the placeholder values (e.g., ProductId, SandboxId) with the actual values from your EOS project. Make sure to maintain proper formatting and include the settings in the correct sections.

Step 3 – Test the Integration #

Once everything is configured:

  • Run the project in Standalone Mode (not PIE) using the editor’s Play dropdown
  • Or launch the EOS client using the following batch file:
  • YourProject/Bats/OMF/EOS/RunClientEOS.bat

Confirm that login and session creation behave as expected. If you encounter issues, revisit your configuration and credentials.


Optional – Dedicated Server Setup (Advanced Users Only) #

We do not offer support for dedicated server setups. Please do not expect assistance in our forums regarding internet architecture, port forwarding, Python environments, Linux configurations, source builds, or similar systems.

Why? Dedicated server deployment involves many low-level, project-specific technical details that fall outside the scope of OMF. Providing support would require troubleshooting each user's infrastructure and environment, which is not feasible for us to support.

If you are an advanced user, you likely do not need guidance at this level. However, for your convenience, we provide some experimental scripts to get started.

OMF Scripts for EOS Dedicated Servers

OMF includes a folder with helper files to set up EOS-based dedicated servers:

YourProject/Bats/OMF/EOS

This folder is added automatically when installing or migrating the Online Multiplayer Framework.

Key files:

  • Config_eos.py – Defines server/game configuration
  • RunDedicatedServers_EOS.py – Launches one or more EOS-based dedicated servers
  • RunClientEOS.bat – Launches a test client with the correct EOS configuration

Python 3 is required to run the Python scripts. You can alternatively use standard command-line execution and manually edit the .ini files if preferred.

Configuration Instructions

  • Open Config_eos.py and define:
    • Number of servers
    • Ports
    • Playlist or game mode
    • EOS authentication data (must match your server artifact)
  • Run RunDedicatedServers_EOS.py to launch your servers
  • Use RunClientEOS.bat to test the connection


Port Configuration (for Dedicated Server Hosting)

If you're running dedicated EOS servers, make sure the following ports are open for inbound and outbound traffic:

  • UDP: 7777-7785
    Used for gameplay traffic between clients and your dedicated server instances.
  • UDP: 15000
    Required for backend communication with the EOS services, including authentication and session management.

These are the only required ports for dedicated server setups when using OMF with EOS.

Optional – Only if Using EOS P2P or Relay Features

If your project uses EOS peer-to-peer features, voice chat, or relay servers (not the case for OMF by default), you may also need to open:

  • UDP: 9000-9999
    Used by EOS for NAT punchthrough and relay functionality.

If you're not using P2P or voice features, this range is not needed.

Note on Shipping Builds

If you're building shipping-level dedicated servers for EOS (especially for deployment on Linux), you'll most likely need a custom engine build. This includes EOS SDK support and proper build configurations Unreal Engine doesn’t provide by default.

Further Read
For complete official documentation on EOS dedicated server setup, refer to:
https://eik.betide.studio/multiplayer/dedicatedservers/configuration

Using Steam via SIK (Steam integration Kit) #

Before You Continue

Before continuing, make sure you’ve completed:

  • How to use Steam or EOS – Prerequisites
  • Base Installation – Setting Up Steam or EOS Support

You should already have:

  • Installed the Steam Integration Kit (SIK) plugin
  • Installed OMF’s compatibility files for Steam
  • Assigned the correct components (SessionManager, SessionCommunicator) in your maps

If not, return to those chapters before continuing.

SIK Integration Steps #

OMF does not replace or modify SIK — it simply routes multiplayer logic through it. For Steam platform integration, follow the official SIK documentation thoroughly.

Step 1 – Follow the Official SIK Setup #

SIK documentation
Documentation: https://sik.betide.studio/
Official GitHub: https://github.com/betidestudio/SteamIntegrationKit
Fab Listing: https://www.fab.com/listings/0d3b4a43-d7cf-4412-b24d-e3f844277f9c

Key SIK setup requirements:

  • Steam App ID
  • Online Subsystem Steam config
  • Logged-in Steam client
  • Ensure bUseSteam is set to true in your config
  • Required project settings (see SIK documentation for details)

For community-based help, you can also visit the Betide Studio Discord:
https://discord.gg/Jh6FJxjyYm

Step 2 – Apply the Configuration Snippet #

After following the official SIK setup guide, paste the correct configuration snippet into your DefaultEngine.ini. The required snippet is located here: https://sik.betide.studio/gettingstarted/Configuration

Copy and paste this snippet into your DefaultEngine.ini, replacing any placeholder values (e.g. SteamDevAppId) with your own. Be sure to maintain proper formatting and place the snippet in the correct section.

Step 3 – Test the Integration #

You can now test your Steam setup.

To verify basic functionality:

  • Click Play → Standalone Game from within Unreal Engine (do not use PIE).
  • Ensure the Steam client is running in the background.
  • Alternatively, use:
  • YourProject/Bats/OMF/Steam/RunClientSteam.bat

Check the following:

  • Steam overlay opens when running the game
  • Player auto-login is working
  • Sessions can be hosted and joined using the in-game menu


Optional – Dedicated Server Setup (Advanced Users Only) #

We do not offer support for dedicated server setups. Please do not expect assistance in our forums regarding internet architecture, port configurations, Python environments, Linux builds, SteamCMD, or similar low-level configurations.

Why?
Running and debugging dedicated servers involves many technical factors that vary per project. Troubleshooting these setups is beyond the scope of our support and would overwhelm our channels with case-specific help requests.

If you're an advanced user, you likely won’t need help on this level. However, for those users, we provide the following pointers:

OMF Scripts for Steam

OMF includes pre-made batch files to help you launch Steam-based dedicated servers. These are located at:

YourProject/Bats/OMF/Steam

When migrating the Online Multiplayer Framework, this folder is added to your project automatically.

Inside this folder, you’ll find:

  • RunDedicatedServer_Steam_01.bat
  • RunDedicatedServer_Steam_02.bat

These launch dedicated server instances with different ports or parameters. You can duplicate and modify them to run multiple server instances or match your preferred map, game mode, and session settings.

Manual Setup

You may also launch your Steam dedicated servers manually using command-line arguments and .ini configuration.

Refer to the SIK documentation and Steam developer docs for platform-specific instructions.

Port Requirements

Make sure the following ports are open on any public server:

  • UDP: 27015-27030
  • TCP: 27036-27037

These ports are required by Steam for matchmaking, server communication, and NAT punchthrough. If these are blocked, players may not be able to host or join your servers reliably.

Note on Shipping Builds

If you're building shipping-level dedicated servers for Steam (especially for deployment on Linux), you'll most likely need a custom engine build. This includes Steam SDK support and proper build configurations Unreal Engine doesn’t provide by default.

More Information

For full details on how to configure and launch Steam dedicated servers with the Steam Integration Kit, see Betide Studio’s official guide:

🔗 https://sik.betide.studio/multiplayer/dedicatedserver

What are your Feelings