[FREE DEMO] Game Logs System (GLS) — The Ultimate Solution for Real-Time Logs in Shipping Builds

[FergiusTerro]

Hello, Unreal Engine community!

We are thrilled to introduce our plugin, Game Log System (GLS), designed to revolutionize how you handle logs during development and in shipping builds. Whether you’re an indie developer or part of a large AAA studio, GLS provides a comprehensive and customizable solution for log collection, filtering, and analysis in real-time, even in final game builds.

Why Choose GLS for Your Project?

Debugging and monitoring logs is a vital part of game development, but it often becomes a time-consuming task, especially when working with large projects or across multiple platforms. GLS simplifies this by offering robust log management tools that work seamlessly in both the editor and gameplay environments, including shipping builds.

If you’ve ever felt limited by the default UE_LOG system or needed more control over your logs across different platforms, GLS is the tool you’ve been waiting for.

---

Key Features of Game Log System (GLS)

1. Cross-Platform Support:

GLS is fully compatible with Windows, Linux, Consoles, and Android, and we’re actively working on supporting Mac and iOS in future updates. Whether you’re developing for desktop, mobile, or console platforms, GLS has you covered.

2. Log Viewing in Shipping Builds:

One of the standout features of GLS is the ability to collect and view detailed logs even in shipping builds. Using GLS_LOG macros, you can filter logs by classes, objects, and custom tags, offering much more flexibility than the standard UE_LOG system.

This feature is particularly useful when debugging final game builds, where performance issues or bugs might be hard to track without access to in-game logs.

3. Advanced Filtering Capabilities:

Managing large volumes of logs can be challenging, but GLS makes it easy with advanced filtering options:

• Filter by classes, objects, categories, tags, and verbosity levels.
• Save your custom filters for future use, ensuring you can quickly narrow down the logs you need most.

With these tools, you can filter out the noise and focus on what truly matters for your specific debugging tasks.

4. Customizable Overlay Interface:

GLS includes a powerful in-game overlay for viewing logs in real-time. The overlay is highly customizable, allowing you to create separate tabs for different tasks or logging contexts. Each tab retains its state between sessions, so you don’t need to reconfigure everything after every restart.

The overlay supports both gamepad and touchscreen input, making it incredibly versatile for use across multiple platforms, including consoles and mobile devices.

5. Persistent Settings Across Sessions:

No more resetting your filters or display settings after each restart! GLS saves your configurations so that each time you open the overlay or specific log tabs, they will retain their previous states. This helps streamline your workflow, especially when working on long-term projects.

6. High Performance and Scalability:

When working with large projects or extensive logs, performance becomes a key factor. GLS is optimized for high-performance log processing, capable of handling large volumes of logs without slowing down your project. The plugin can process up to 1000 logs per frame (configurable in settings), ensuring smooth performance even under heavy loads.

7. Session and Role-Based Filtering:

GLS allows you to filter logs based on session type (PIE, Standalone) and network roles (Standalone, Client, Listen Server). This is particularly useful when testing multiplayer games, where specific log details may only be relevant to certain roles.

8. Full UE_LOG Integration:

Even if you’re not using GLS_LOG macros, GLS will automatically intercept and process all UE_LOG messages. This ensures that your existing log setup continues to function as expected while benefiting from GLS’s advanced filtering and analysis tools.

9. Export and Share Logs Easily:

Need to share logs with your team or analyze them later? GLS makes it simple to save logs to files or copy them to the clipboard for further analysis. This feature is particularly helpful for larger teams working in distributed environments or when preparing bug reports.

10. PrintString Support:

Easily display game messages directly in GLS through functions like PrintStringToGLS in Blueprints, complete with custom categories. This allows you to streamline messaging and log output into a unified system for both internal use and debugging purposes.

---

Why GLS Stands Out

With GLS, you get a complete, highly customizable system for managing logs across all stages of development. From its advanced filtering capabilities to the ability to collect logs in shipping builds, GLS is designed to make log management as efficient and user-friendly as possible.

Here’s why GLS is a game-changer for developers:

• Efficiency: Spend less time searching through irrelevant logs and focus on what matters most.
• Flexibility: Use advanced filtering, custom tags, and persistent settings to tailor logs to your project’s needs.
• Performance: Optimized for handling large datasets without compromising game performance.
• Cross-Platform Compatibility: Develop confidently across multiple platforms, knowing your logging system will work seamlessly everywhere.

Whether you’re working on a small indie project or a large-scale production, GLS provides the tools you need to debug efficiently, improve performance, and ultimately deliver a better product.

---

Get Game Logs System (GLS) Today!

Example Builds:
WIN64, Android

Documentation

You can purchase GLS on Fab. We offer quick user support and frequent updates to ensure the best experience across all platforms.

You can download the demo version from the repository on github, please follow the instructions in readme.

---

Screenshots and Video

Video Demonstration (GLS with Lyra Game)

---

If you have any questions, feel free to ask in the comments. We’d love to hear your feedback and are always here to help!

[abuhanzala5]

GLS sounds like a game-changer for anyone dealing with complex log management, especially with the ability to view logs in shipping builds and the advanced filtering options. The cross-platform support and customizable overlay are standout features too. Definitely seems like a valuable tool for both indie and large-scale projects. I’m curious, how does the performance hold up with extremely large log volumes in a multiplayer environment? Great work on this!

[FergiusTerro]

Thank you for the kind feedback! We’ve put a lot of effort into optimizing performance, especially for multiplayer projects with large volumes of logs.

1. Optimization using UListView: We made a deliberate choice to display each log as a single element. This ensures that only the logs that fit on the screen are shown at any given time, with the rest loading as you scroll. This prevents overwhelming the interface with too many logs at once, which is crucial when handling large datasets.
2. Log processing and filtering: These processes have been optimized to minimize CPU usage. The system handles complex filtering and log management efficiently, maintaining performance even with a high number of logs.
3. Log retrieval limit per frame: We’ve set a limit of 1000 logs per frame to prevent freezing. This ensures that the overlay remains responsive and clickable, even during periods of high log volume.
4. Memory optimization: We’ve also focused on minimizing memory usage, which is especially important in multiplayer environments with large amounts of data.

So, performance holds up well even with massive log volumes in multiplayer projects. We’ve worked hard to ensure GLS runs smoothly and efficiently in all scenarios. Thanks again for your feedback!

[FergiusTerro]

We’re currently looking to expand our network and are seeking:

Collaborators – YouTube channels, content creators, or Unreal Engine experts who would be interested in showcasing GLS or collaborating on interactive demos. Our goal is to demonstrate how GLS can be used to address common development issues and improve workflows in a fun and informative way.

Testers – Unreal Engine developers who want early access to GLS and can help us refine it by providing feedback. We’re looking for testers who are working on different types of projects (single-player, multiplayer, etc.) to help us make sure the plugin performs well across a variety of use cases.

If you’re interested in collaborating with us or testing the plugin, we’d love to hear from you! We’re excited to work together to make GLS an even better tool for developers.

[FergiusTerro]

A short video demonstration of the GLS interface. An overlay with logs and filters opens on top of the Lyra Game.

[Zuriel_1]

Does the Plugin work with android builds for distribution?, My game is too big to be able to compile a debuggame/development build, Because of the 2GB/4GB limitation,
I need to test a Google release build

[FergiusTerro]

Yes, it’s possible.

The Game Logs System (GLS) plugin is compiled for all configuration modes and activates at runtime based on the settings. To enable the plugin in the shipping configuration, go to Project Settings → Plugins → Game Logs System → Enable Logs In Shipping builds in the editor.

To ensure that GLS captures logs in a distribution build, use GLS_LOG instead of UE_LOG. Unreal completely removes UE_LOG calls in shipping builds, so GLS needs to intercept logs differently.

In a shipping build, you can open the GLS overlay panel by holding two fingers on the screen of the mobile device during gameplay. This will display the logs in a tab on-screen, where you can filter them by specific categories as needed.

Additionally, make sure to set the following in your DefaultGame.ini file:

[/Script/GLS.GLSSettings]
bEnableLogsInShippingBuilds=True

These settings need to be applied when packaging the build.

[FergiusTerro]

To ensure logs are available in the shipping configurations of your game, you can add the following setting in your game’s repository:

DefaultGame.ini
[/Script/GLS.GLSSettings]
bEnableLogsInShippingBuilds=True

However, it’s essential to closely monitor the distribution builds submitted to the store.

When packaging these builds, you must include the -gls_disable build flag. This flag will disable the GLS plugin, preventing the overlay from appearing in the game and ensuring that logs are not collected, even if bEnableLogsInShippingBuilds=True is set to true.

By integrating the -gls_disable build flag into your build pipeline for final builds, you can effectively disable the overlay and log collection, ensuring compliance with the store’s requirements while still enabling logs during development and testing.

[Psychocist (foreverastudent)]

Is there any overhead for the logging nodes if GLS is disabled in particular builds?

I ask because the usual print/log has “Development Only” on the node, whereas GLS does not. Are there any performance implications for this?

[FergiusTerro]

GLS is designed with performance in mind. If GLS is disabled for a specific build (e.g., via Project Settings → Plugins → Game Logs System), all GLS subsystems remain inactive, ensuring that no GLS-specific logic or processing runs. This prevents any overhead in builds where GLS is not needed.

Additionally, the GLS_LOG macro is designed to seamlessly redirect logs to the default UE_LOG system if GLS subsystems are inactive. This ensures that log functionality remains intact while avoiding unnecessary processing by GLS.

Here’s how this is achieved:

1. Subsystem Activation Check:
   GLS subsystems are initialized only if GLS is enabled. If GLS is disabled, none of its subsystems (e.g., UGLSSubsystem) are activated, effectively bypassing all GLS-related code.

bool UGLSSubsystem::ShouldCreateSubsystem(UObject* Outer) const
{
    return FGLSUtils::IsGLSEnabled();
}

2. Macro Redirection:
   The GLS_LOG macro checks subsystem status. If GLS is inactive, it directly redirects logs to UE_LOG, ensuring minimal overhead.

#define GLS_LOG(CategoryName, Verbosity, Format, ...) \
if (FGLSUtils::IsGLSEnabled()) \
{ \
        GLSSubsystem->Log(CategoryName, Verbosity, Format, ##__VA_ARGS__); \
} 
else \
{ \
        UE_LOG(CategoryName, Verbosity, Format, ##__VA_ARGS__); \
}

Thanks for the great question!

[FergiusTerro]

Demo Version of Game Logs System (GLS) UE5 Plugin Now Available!

We’re excited to announce that a demo version of the Game Logs System (GLS) plugin is now available! After careful consideration, we decided to give users a chance to try out the plugin before purchasing. This will allow us to gather more feedback, fix any issues, and make the plugin even better for everyone.

Game Log System (GLS) Plugin is a powerful tool designed to enhance logging in Unreal Engine. It provides real-time log display directly in the game, making it easier to track and debug issues during development. GLS features intelligent filtering, customizable log categories, and an in-game overlay that allows developers to monitor logs without interrupting gameplay. It supports multiple platforms, including mobile and console, and is optimized for performance, ensuring minimal impact on frame rates even with large amounts of log data. Ideal for testing, debugging, and development, GLS simplifies log management and streamlines the debugging process.

For more details, visit our dev blog.

Here are some key details about the demo version:

• Platform: Available for Windows.
• Configurations: Works with Development and Debug builds.
• No Source Code: The demo does not include the source code.
• Installation: You need to integrate the plugin into the engine downloaded from the Epic Games Launcher. It will not work with a custom engine build compiled from source.

We believe this approach will give you a better idea of how the GLS plugin can enhance your development process. We’re looking forward to your feedback and suggestions!

Try it out and let us know what you think! Your input is invaluable, and we want to ensure GLS meets the needs of developers across different platforms.

You can download the demo version from the repository on github, please follow the instructions in readme.

[FergiusTerro]

Quick Start Guide

1. To open the GLS overlay in the editor or during gameplay, press and hold Alt + Shift + G.
2. To open the overlay on a mobile device, press and hold two fingers on an empty area of the screen.
3. To open the overlay on a console, press and hold the Gamepad Special Right button.
4. Configure necessary settings in Project Settings → Plugins → Game Logs System (GLS). You can set up key bindings to open the GLS log overlay during runtime.

[FergiusTerro]

Challenges of Creating a Free Demo Version of the c++ UE5 Plugin Without Source Code

Hey Unreal Developers!

We wanted to share some insights into our journey of creating a demo version of our Game Logs System (GLS) plugin for Unreal Engine. The idea was simple: offer a free, limited version to let users experience its full functionality before committing to a purchase. However, the process came with its own set of challenges that we weren’t prepared for!

If you’re interested in more details or facing similar challenges, check out our full dev blog where we dive deeper into the process.

You can try the demo version of the GLS plugin by cloning it from GitHub.

Here are some key takeaways from our experience:

Why a Demo Version?

We wanted users to try out the plugin’s full capabilities without cutting any features. The demo version is limited to Windows and Development/Debug builds, but it lets users see the plugin in action without needing to compile or access the source code.

Renaming the Plugin

To make the main and demo versions co-exist, we had to rename the plugin from GLS to GLSDemo. It sounds simple, but Unreal Engine doesn’t allow plugins with the same name to exist at once, which led to some unexpected challenges, like module conflicts and hardcoded asset references.

Asset Migration Woes

After renaming the module, all our blueprints failed to compile due to hardcoded references to the old module. We ended up migrating assets with Unreal’s Migrate tool, which saved us from manually fixing each one, but it’s clear there’s room for improvement in this area.

Demo Version Limitations

To protect our source code and control the demo, we precompiled it into a binary form. Some limitations were added:

• A shipping build message reminds users that it’s a demo version.
• GLS subsystems always return false in shipping builds.
• The demo only works for developemnt and debug configurations.

Data Type Redirects

Renaming also caused issues with data type redirects in blueprints. Even though we set up redirects, Unreal still didn’t transfer enums correctly, which we’re still trying to solve.

Key Lessons Learned

1. Keep Logic in C++ – Critical system logic should always reside in C++, not in blueprints.
2. Asset Migration – Migrating assets with the Migrate tool was key to keeping everything intact.
3. Distribution Ease – The demo version was made as plug-and-play as possible, ensuring users didn’t have to troubleshoot just to try it out.