Blazor Server – EnableRtl works globally, cannot be applied per user

[Kadir Boylu]

Title

Blazor Server – EnableRtl works globally, cannot be applied per user

---

Product

Syncfusion Blazor Components

---

Environment

• Framework: Blazor Server

• Syncfusion Blazor version: 31.2.5

• .NET version: 9

---

Issue Description

In a Blazor Server application, we need to support user-based language direction (LTR / RTL).

However, RTL can only be enabled via:

AddSyncfusionBlazor(options => options.EnableRtl = true);

or

SyncfusionBlazorService.EnableRtl(true);

Both approaches apply RTL globally and affect all connected users.

This makes it impossible to support different users simultaneously, for example:

• User A → RTL (Arabic)

• User B → LTR (English)

in the same Blazor Server application.

---

Expected Behavior

RTL should be configurable per user / per circuit in Blazor Server applications, or there should be a supported way to scope RTL to the current user only.

---

Actual Behavior

EnableRtl is global and applies to all users, regardless of individual user language or culture settings.

---

Request

• Is this a known limitation of Syncfusion Blazor?

• Is there a recommended approach for applying RTL per user in Blazor Server?

• If not currently supported, can this be considered as a feature request?

[Karthikeyan Palanisamy]

Hi Kadir Boylu,

Greetings from syncfusion support!

We have reviewed your query regarding the EnableRtl option in Blazor Server for per user. 

Request

Is this a known limitation of Syncfusion Blazor?

Yes. The EnableRtl setting in Syncfusion Blazor is designed as a global configuration. When enabled using:

AddSyncfusionBlazor(options => options.EnableRtl = true);

   or

SyncfusionBlazorService.EnableRtl(true);

it applies RTL (Right-to-Left) layout across all components in the application and affects all connected users. Currently, there is no built-in concept of “per-user global RTL” at the framework level in Syncfusion Blazor. If you need per-user behavior, it must be implemented at the application level.

Is there a recommended approach for applying RTL per user in Blazor Server?

Applying RTL globally per user is not supported. However, you can achieve similar behavior using localization with dynamic culture settings, allowing each user to select their preferred language with RTL support.

For example:

• User A can choose Arabic (RTL layout).
• User B can choose English (LTR layout).

Please refer to the complete guidelines for setting localization dynamically: https://blazor.syncfusion.com/documentation/common/localization#dynamically-set-the-culture

The above documentation explains how to set localization for all components dynamically. To enable RTL for Arabic, add the following logic in your CultureSwitcher.razor file:


@using System.Globalization @inject NavigationManager NavigationManager @inject HttpClient Http @inject SyncfusionBlazorService SyncfusionService <p> <label> Select your locale: <select @bind="Culture"> @foreach (var culture in supportedCultures) { <option value="@culture">@culture.DisplayName</option> } </select> </label> </p> @code { private CultureInfo[] supportedCultures = new[] { new CultureInfo("en-US"), new CultureInfo("de-DE"), new CultureInfo("fr-FR"), new CultureInfo("ar-AE"), new CultureInfo("zh-HK") }; protected override void OnInitialized() { Culture = CultureInfo.CurrentCulture; EnableRtlBasedOnCulture(Culture.Name); }
private CultureInfo Culture { get => CultureInfo.CurrentCulture; set { if (CultureInfo.CurrentCulture != value) { var uri = new Uri(NavigationManager.Uri) .GetComponents(UriComponents.PathAndQuery, UriFormat.Unescaped); var cultureEscaped = Uri.EscapeDataString(value.Name); var uriEscaped = Uri.EscapeDataString(uri); NavigationManager.NavigateTo( $"Culture/SetCulture?culture={cultureEscaped}&redirectUri={uriEscaped}", forceLoad: true); } } } private void EnableRtlBasedOnCulture(string culture)​ { if (culture == "ar-AE") { bool isRtl = true; SyncfusionService.EnableRtl(isRtl); } else​ { bool isRtl = false; SyncfusionService.EnableRtl(isRtl); } } }

Also you can enable RTL for individual components, allowing you to control RTL on a component-by-component basis based on the user’s preference: https://blazor.syncfusion.com/documentation/common/right-to-left#enable-rtl-for-an-individual-component

If not currently supported, can this be considered as a feature request?

Currently, we do not have plans to include per-user global RTL support as a built-in feature, as this functionality can be implemented using the provided sample. For your convenience, we have attached a sample demonstrating how to enable localization with RTL support. If you need further details or assistance, please feel free to reach out. 

Regards,
Karthikeyan P

Attachment: EnableRtlServer_fb9e2009.zip

[Kadir Boylu]

Hello Karthikeyan,

Thank you for the clarification and for sharing the sample project.

We have tested the attached ZIP sample (EnableRtlServer_fb9e2009.zip) exactly as provided.

When running the sample in a Blazor Server environment with multiple users/circuits, we are observing the same behavior:

• Calling SyncfusionBlazorService.EnableRtl(true/false) affects all connected users
• The RTL state is still global, and reflects the last change made by any user
• There is no per-user or per-circuit isolation, even in the provided sample

So while the sample demonstrates localization and RTL switching, it does not solve the core requirement of having different users simultaneously see different layout directions.

Our requirement remains:

• User A (ar-AE) → RTL
• User B (en-US) → LTR
• Both active at the same time in the same Blazor Server application

As suggested, we also understand that RTL can be enabled at the individual component level using EnableRtl="@IsRtl".

However, this approach is not practical for large-scale enterprise applications, because:

• Syncfusion components are used extensively across many pages and layouts
• Applying `EnableRtl` manually to every component (or wrapping all components) creates significant maintenance overhead
• This does not scale well for real-world applications with hundreds of Syncfusion components

What we are missing is a per-user / per-circuit global RTL mechanism, similar to how culture is already scoped per user in Blazor Server.

Could you please confirm:

1. Is SyncfusionBlazorService.EnableRtl() backed by a shared/global state across all circuits?

2. Is there any officially supported or recommended approach to achieve per-user RTL in Blazor Server without setting EnableRtl on every individual component?

If this is a known limitation and there is no supported workaround, we would like to formally request this as a feature enhancement:

per-user (or per-circuit) global RTL support for Blazor Server.

Regards,

Kadir Boylu

[Karthikeyan Palanisamy]

Hi Kadir Boylu,

Thank you for sharing your detailed observations and requirements.
​

We have reviewed the scenario and tested the provided sample by hosting it on an Azure server with multiple machines and users. In our tests, switching the application culture to Arabic correctly applied RTL for that specific user session, and did not impact other users working with different cultures. Based on this, we were unable to reproduce the global RTL behavior you described.

To clarify:

• Enabling RTL in Program.cs applies RTL globally, affecting all users.
• In our implementation, we handle SyncfusionBlazorService.EnableRtl() within the CultureSwitcher.razor file. This approach checks localization conditions and applies RTL per user session, ensuring it does not affect other users.
• This approach allows per-user RTL in a Blazor Server application without requiring EnableRtl to be set on every individual component.
  
  

We understand your concern regarding scalability for large enterprise applications. While the current implementation does not provide a built-in global per-user RTL mechanism, a workaround can be implemented at the sample level to achieve this behavior. Therefore, we do not consider this as a feature request at this time.

 

We have included a video reference demonstrating the per-user RTL behavior. Please let us know if you require any further assistance or have additional details to share.

Regards,
Karthikeyan P

Attachment: EnableRTL_493d5ea8.zip

[Kadir Boylu]

Hello Karthikeyan,

Thank you for your response and for sharing your test results.

To avoid any environment differences, we tested the same application instance that you deployed.

We opened the deployed application:

• once in a normal browser session

• once in an incognito/private session

Both sessions were active simultaneously.

By switching the culture between Arabic (RTL) and English (LTR) in these two sessions, we were able to reproduce the issue, where the RTL state leaks across sessions and affects the other user.

We have recorded a video demonstrating this behavior clearly, and are attaching it here for reference.

This confirms that:

• The issue is not related to local setup

• The behavior occurs on the deployed environment as well

• SyncfusionBlazorService.EnableRtl() does not provide reliable per-user / per-circuit isolation

Even though the sample may appear to work under certain conditions, the RTL state is still shared and order-dependent, which becomes visible under concurrent usage.

Please let us know if you need any additional details from our side.
We would appreciate clarification on how per-user RTL isolation can be guaranteed in Blazor Server with the current architecture.

Regards,
Kadir Boylu

Attachment: enablertl_179f1158.zip

[Karthikeyan Palanisamy]

Hi Kadir Boylu,

Thank you for sharing the detailed analysis and the video demonstration. We appreciate the effort you’ve taken to validate this scenario and provide clear evidence.

Based on your findings, we have re-tested using the same approach and were able to reproduce the issue with our current EnableRtl implementation. We have prioritized this for further investigation and are actively working on identifying a reliable solution to ensure proper per-user RTL isolation in Blazor Server.

We will share our progress and next steps with you within two business days. In the meantime, if you have any additional insights or requirements that could help us address this effectively, please feel free to let us know.

Thank you for your collaboration and patience as we work toward resolving this.

Regards,
Karthikeyan P

[Kadir Boylu]

Hello Karthikeyan,

Thank you for the update and for confirming that the issue has been reproduced on your side.

We appreciate the time and effort your team has put into re-testing this scenario and prioritizing it for further investigation. It is good to hear that work is underway to identify a reliable solution for proper per-user RTL isolation in Blazor Server.

At this stage, we do not have additional requirements beyond ensuring deterministic per-user (per-circuit) RTL behavior without relying on shared/global state. We will be happy to review any proposed solution or approach once available and provide feedback if needed.

Looking forward to your next update.

Regards,
Kadir Boylu

[Karthikeyan Palanisamy]

Hi Kadir Boylu,

Thank you for your patience and continued collaboration.

We have completed our validation and confirmed the issue on our end. Additionally, we have logged this as an improvement request, which you can track here:
https://www.syncfusion.com/feedback/72069/need-to-provide-per-user-per-circuit-rtl-enablement-in-blazor

Our plan is to include this enhancement in the upcoming Volume 1 main release, scheduled for mid of March 2026. We will keep you informed as we progress toward this timeline.

Please let us know if you need any additional details or assistance in the meantime.

Regards,
Karthikeyan P

[Kadir Boylu]

Hello Karthikeyan,

Thank you for the update and for your efforts in addressing this issue.

I would like to inform you that when I open the feedback link you provided, I am receiving an Access Denied error and am unable to view the page.

Thank you for your continued collaboration.

Regards,
Kadir Boylu

[Karthikeyan Palanisamy]

Hi Kadir, 

We apologies for the inconvenience caused. We have checked and provided you the access to view the feedback link. Kindly check and get back to us if you need further assistance. 

Regards,
Karthikeyan P 

[Karthikeyan Palanisamy]

Hi Kadir Boylu,

Thank you for your continued patience and constructive collaboration throughout this investigation.

We’re happy to inform you that the issue you reported per-user / per-circuit RTL state leaking across Blazor Server circuits has now been resolved in our latest Syncfusion Blazor NuGet package. We recommend upgrading your application to version 33.1.45 to resolve the issue.

If you need guidance on upgrading, validation steps, or have any follow-up questions, please feel free to reach out. We’ll be glad to assist.

Regards,
Karthikeyan P