Hey everyone! 
The core concept is done — RPG Engine now has full client-side prediction and much finer replication control.
I’m currently adapting the event system to this new workflow, and then I’ll ship the update 
And yes — all of this is done in Blueprints, with no C++ 
Hey everyone! I’ve finished the core part of the new update
Right now I’m testing the new client-side prediction system under 200 ms latency to see how it behaves under noticeable network delay while still keeping the server-authoritative logic intact.
If everything goes well, the next step is polish and release prep
Hey everyone! 
Today I finished work on the updated D_CharacterStates database 
It now better supports scenarios where some states can react locally on the client first and then be handled by the broader multiplayer logic 
The main goal of this approach is to make gameplay feel faster and more responsive In situations where it makes sense, the player can see an immediate reaction to their action instead of always feeling network delay first, while the system still keeps everything structured and under control 
Right now I’m continuing to integrate this into other mechanics and test how it behaves in real multiplayer conditions 
So far, the direction looks very promising — the game already feels much more responsive, and the overall architecture remains clean and manageable
In short: prediction-side work is moving forward, and the foundation for it is now much stronger 
Working on: BP_StateOrchestratorComponent
Building a routing/decision layer that sits between input/gameplay events and BP_MediatorModule. Its only job — look at the incoming state request, check the NetworkMode, and route it to the right execution path: ServerOnly, PredictedSafe, or Local.
Before this, every input handler had to manually figure out how to activate a state over the network. Now that logic lives in one place — the orchestrator decides, the mediator executes. Clean separation of concerns.
Hey everyone!
Today I added support for seeing shot and explosion effects even while using thermal vision 
We finally got to this feature
Now special vision modes won’t hide important combat effects, which makes battles feel much clearer and more complete visually 
It may seem like a small improvement, but these kinds of details really make the overall experience better
No, the smoke is very hard to see. I’ll improve it now.
Hey everyone! 
Honestly, I don’t even remember what originally triggered the request for this update — but now it’s here: RPG Engine V6.11.1
Thermal vision has now been properly refined, so visual effects remain visible while this mode is active On top of that, if the player was already using night vision or thermal vision through a skill or device before aiming, that visual state now carries over correctly into the scope view 
That means no more overexposed image or doubled visual processing when the same night/thermal effect is applied twice from different sources Overall, this makes special vision modes feel much cleaner, more consistent, and far more polished in actual gameplay
Hey everyone!
Work on the upcoming update is moving fast, and today I finished the full debugging pass of the Character State System.
The best part: the new prediction layer is already showing excellent results. Even under 400 ms latency, gameplay remains responsive enough for the player to stay engaged and keep taking actions — something that would feel dramatically worse without this system in place.
This is a major leap forward for RPG Engine. The project now has a far more advanced prediction-driven multiplayer foundation, pushing it toward a level that is rarely seen in Blueprint-only multiplayer frameworks.
The update is getting very close. RPG Engine is entering a new stage — one defined by better responsiveness, stronger multiplayer architecture, and a much higher standard for systems built without C++.
Hey everyone!
I think the next update should be released next week
Today and tomorrow I’m finishing the prediction layer for vehicles, and after that I’ll do one more full testing pass across the project before shipping the update. At this point, I’m seriously thinking this will be Version 7 — because once again, this has turned into a massive update
This release pushes RPG Engine even further with a much deeper prediction-driven multiplayer foundation, bringing the project to a new level of responsiveness and polish — especially for a Blueprint-only framework
For newcomers:
More updates very soon
A small preview from the upcoming update: DT_CharacterStates and DT_VehicleStates now use a much more compact structure, with a clear way to define how each state should be activated.
There are now four activation types:
To support this, the entire state system architecture was reworked. From now on, all states are stored using two separate GameplayTag containers:
This gives the system a much cleaner foundation, better scalability, and far more control over responsiveness, replication cost, and state behavior across both character and vehicle systems.
RPG Engine V6.12.1
Hey everyone!
You know what? I actually managed to get Mass AI working in multiplayer
This is one of those things I really wanted to crack — and now it’s finally happening. In the next update, I’m going to show how this can be done inside the project and what this opens up for larger-scale gameplay scenarios
A lot of exciting things are coming together right now, and this is definitely one of the biggest ones. More details in the next update
Hey everyone!
Just finished an updated tutorial on integrating Ultra Dynamic Sky into RPG Engine projects 
Going to publish it within the next 5 hours — it covers the full setup process and how to get everything working smoothly with the framework.
More quality-of-life content coming your way
Hey everyone!
Today I’m officially releasing RPG Engine V7 – State Orchestration & Prediction Update
This is one of the biggest architectural updates the project has had so far.
V7 is not just another feature drop — it is a full rework of the State System, including a new activation pipeline, a new orchestration layer, and the introduction of a Prediction workflow designed for real multiplayer gameplay conditions.
The main goal of this update was to move the framework closer to real network-ready gameplay.
Testing a multiplayer system on one machine and testing it across multiple machines with real latency are two completely different things.
V7 was built specifically to improve that second case — where delay, ping, and responsiveness actually matter. 
This update introduces a much stronger foundation for handling state-driven gameplay in multiplayer, especially when fast visual feedback is important for the player experience.
The result is a more responsive and more comfortable gameplay flow under real network conditions, without turning the framework into a client-authoritative mess.
The entire state activation structure has been reworked.
A new component, BP_StateOrchestratorComponent, now acts as the orchestration/routing layer for state activation.
Its job is to determine what kind of activation path should be used for a state request, and then route that request through the correct execution path.
This means the framework now clearly separates:
In practice, this makes the system cleaner, easier to extend, and much more suitable for multiplayer-oriented state handling.
V7 now introduces and uses the following state processing modes:
Each state can now follow a different activation workflow depending on how it is supposed to behave in the networked environment.
Because of that, the database structure for states was changed, new fields were added, and the overall workflow for adding and activating states was redesigned.
For example:
There is also a planned Replicated_PredictedStaged mode, but it is not fully implemented in V7 yet and will be completed later in a smaller patch.
I don’t want to reduce this update to a random list of specific actions, because that would completely miss the point.
In V7, Prediction means that when the player presses a key or triggers a state, the client can receive an immediate visual response instead of waiting for the server to answer first. 
If the server later rejects that state, the predicted local part simply does not become authoritative gameplay state.
That local reaction was only there to improve responsiveness, so it does not break the actual gameplay flow.
This is a very important part of making multiplayer feel good in practice.
A game can look fine in local tests and still feel bad over real network conditions if every action waits too long for confirmation. V7 is a major step toward solving that problem at the framework level.
Another important part of this release: this is not a half-finished prototype layer.
All state types in the project have already been moved to the new activation method.
The full logic was implemented, tested, and cleaned up, including fixes for bugs that appeared during the transition to the new system.
So this release is not just about introducing a concept — it is about shipping a new core workflow that is already integrated across the framework.
V7 is a breaking update.
There is no backward compatibility with the previous state workflow.
This is a new branch of the project and a new direction for how state-driven logic is handled going forward.
Because of that, the documentation for adding new states will also be fully rewritten for Version 7, so buyers can work with the new system using the correct workflow instead of outdated setup steps. 
The biggest reason this update matters is simple:
it helps make RPG Engine much more viable for actual multiplayer game development. 
This is not just about “faster input.”
It is about building a framework that behaves better under real ping, gives players better responsiveness, and still preserves proper multiplayer structure.
That was the core focus of this version, and it is one of the most important technical steps the project has taken so far.
Thanks a lot to everyone who has been following the project and supporting it along the way
More updates, documentation refreshes, and follow-up improvements will come after this release.
RPG Engine 7.1.1 is here
From now on, when a firearm is taken into hands, the project activates a dedicated IMC_OnFootFirearms input context 
It may look like a small upgrade on the surface, but this is exactly the kind of groundwork that makes the framework feel more polished, more scalable, and more ready for deeper shooter mechanics
And yes — this is leading directly into one of the next features I want to add: melee attacks with firearms
This also ties into the upcoming RPG Engine Shooter Edition 
It’s being designed as a more focused and more affordable version of the main RPG Engine — around $150 — with mechanics aimed specifically at shooter projects
A lot of cool things are connecting together right now
More soon
Water Plugin support added 
Look how beautiful!
RPG Engine now fully supports Water Plugin out of the box
RPG Engine 7.3.1
