+
### Database Provider Options
@@ -84,7 +84,7 @@ ABP Platform provides tooling to help you in your daily development.
#### ABP CLI
-[ABP CLI](cli.md) is a command-line tool to create new solutions and automate the things with your ABP based solutions.
+[ABP CLI](./cli/index.md) is a command-line tool to create new solutions and automate the things with your ABP based solutions.
### Startup Templates
diff --git a/docs/en/package-version-changes.md b/docs/en/package-version-changes.md
index 84a10fafe9..0312719731 100644
--- a/docs/en/package-version-changes.md
+++ b/docs/en/package-version-changes.md
@@ -7,6 +7,12 @@
# Package Version Changes
+## 10.4.1
+
+| Package | Old Version | New Version | PR |
+|---------|-------------|-------------|-----|
+| MudBlazor | 8.0.0 | 9.4.0 | #25393 |
+
## 10.4.0-rc.2
| Package | Old Version | New Version | PR |
diff --git a/docs/en/release-info/release-notes.md b/docs/en/release-info/release-notes.md
index 3802fe21e3..3a3c89012f 100644
--- a/docs/en/release-info/release-notes.md
+++ b/docs/en/release-info/release-notes.md
@@ -14,9 +14,9 @@ Also see the following notes about ABP releases:
- [ABP Studio release notes](../studio/release-notes.md)
- [Change logs for ABP pro packages](https://abp.io/pro-releases)
-## 10.4 (2026-04-29)
+## 10.4 (2026-05-14)
-ABP v10.4 is currently in the release candidate stage; the stable version has not been released yet. See the detailed **[blog post / announcement](https://abp.io/community/announcements/announcing-abp-10-4-release-candidate-7ukyudm0)** for the v10.4 RC release.
+See the detailed **[blog post / announcement](https://abp.io/community/announcements/announcing-abp-10-4-stable-release-e0u81o2z)** for the v10.4 release.
- URL-Based Localization
- Localization File Splitting
@@ -29,7 +29,7 @@ ABP v10.4 is currently in the release candidate stage; the stable version has no
## 10.3 (2026-04-15)
-See the detailed **[blog post / announcement](https://abp.io/community/announcements/announcing-abp-10-3-release-candidate-hgnpr9jq)** for the v10.3 release.
+See the detailed **[blog post / announcement](https://abp.io/community/announcements/announcing-abp-10-3-stable-release-aryi10am)** for the v10.3 release.
- OpenIddict: `private_key_jwt` Client Authentication + `abp generate-jwks`
- Event Bus: String-Based Event Publishing with Dynamic Payload
diff --git a/docs/en/release-info/road-map.md b/docs/en/release-info/road-map.md
index 1f443a0fa9..154a421da1 100644
--- a/docs/en/release-info/road-map.md
+++ b/docs/en/release-info/road-map.md
@@ -17,12 +17,15 @@ The next planned version will be 10.5, which is scheduled to be released as a st
* Framework
* Token Verification Improvements (Refresh Token Support)
+ * Dynamic Background Worker Scheduler Capabilities
+ * Default Scopes Fallback for OpenIddict Grants
* Upgrading 3rd-party Dependencies
* Enhancements in the Core Points
* ABP Suite
* Improvements on the generated codes for nullability
* Improvements on Master-Detail Page Design (making it more compact)
+ * Low-Code System Integration
* ABP Studio
* Allow to Directly Create New Solutions with ABP's RC (Release Candidate) Versions
@@ -30,10 +33,15 @@ The next planned version will be 10.5, which is scheduled to be released as a st
* Allow to Download ABP Samples from ABP Studio
* Support Multiple Concurrent Kubernetes Deployment/Integration Scenarios
* Improve the Module Installation Experience / Installation Guides
+ * AI Coding Agent and MCP Integration
+ * Modern Solution Wizard with Low-Code Support
+ * ABP Thin UI: React Templates
+ * Theme Builder: Live Preview, Project Integration and Import/Export
* Application Modules
* AI Management: Chat History & Multi-Tenancy Features
* New Module: Chat with your data
+ * Admin Console: Low-Code Designer
* CMS Kit: CodeMirror v6 Compatibility Update
* Payment Module: Email Notification Improvements
* UI/UX Improvements on Existing Application Modules
diff --git a/docs/en/solution-templates/application-module/index.md b/docs/en/solution-templates/application-module/index.md
index 19b2294a76..dec38a1cfa 100644
--- a/docs/en/solution-templates/application-module/index.md
+++ b/docs/en/solution-templates/application-module/index.md
@@ -9,6 +9,8 @@
This document explains how to create a **reusable [application module](../../modules)** based on the [module development best practices & conventions](../../framework/architecture/best-practices).
+This page documents creating a **standalone module solution**. If you are using the modern [Modular Monolith solution template](../modular-monolith/index.md), ABP Studio can also scaffold additional modules during solution creation or later from *Solution Explorer*. The generated module structure still follows the same reusable module concepts explained here.
+
> Notice that the application module that is created in this tutorial is not an executable application. To see the module in action, you should install it into an executable application.
>
> It is advised to see the *[Modular Monolith Application Development Tutorial](../../tutorials/modular-crm/index.md)* to learn how to create application modules, install them into an executable web application, run and test the application. That tutorial uses the *Standard* module template, while this document explains the *DDD* module template.
@@ -21,6 +23,8 @@ First, install the ABP Studio if you haven't installed before. You can follow th
### Creating a New Empty Solution
+This empty-solution flow is for a standalone module repository. It is different from the modern modular monolith wizard, where modules are added to a main application solution.
+
Open the ABP Studio and click the `New solution` button in the welcome page or the `File > New Solution` top menu item. Click the `empty solution` link to select the empty solution template.

@@ -143,7 +147,9 @@ You can still create unit tests for your classes which will be harder to write (
### Host Applications
-The solution doesn't have a host application to run your module. However, you can create a [single-layer](../../get-started/single-layer-web-application.md) or [layered](../../get-started/layered-web-application.md) application and [import](../../studio/solution-explorer.md#imports) the created module into the host application.
+The solution doesn't have a host application to run your module. For a new modern ABP Studio solution, the most direct host choice is the [Modular Monolith solution template](../modular-monolith/index.md). ABP Studio can add the module during solution creation or later from *Solution Explorer*.
+
+Classic single-layer and layered host applications are still valid options. You can create a [single-layer](../../get-started/single-layer-web-application.md) or [layered](../../get-started/layered-web-application.md) application and [import](../../studio/solution-explorer.md#imports) the created module into the host application.
You can also see the *[Modular Monolith Application Development Tutorial](../../tutorials/modular-crm/index.md)* to learn how to create application modules, install them into an executable web application, run and test the application
diff --git a/docs/en/solution-templates/guide.md b/docs/en/solution-templates/guide.md
index 944e503c53..3d51d68fad 100644
--- a/docs/en/solution-templates/guide.md
+++ b/docs/en/solution-templates/guide.md
@@ -1,7 +1,7 @@
```json
//[doc-seo]
{
- "Description": "Explore ABP's guide to selecting the right startup template for your project, covering architectures like Microservices, N-Layered, and more."
+ "Description": "Explore ABP's guide to selecting the right classic or modern startup template for your project, covering Single-Layer, Layered, Modular Monolith, and Microservice architectures."
}
```
@@ -9,11 +9,23 @@
ABP provides several [startup templates](index.md) to you. It is important to start with the right startup template that is suitable for your **project** and **team**. This guide aims to lead you to select the most proper startup template for your requirements.
+ABP currently exposes two closely related template families:
+
+* **Classic templates**, documented with the `Single-Layer` and `Layered` names in this section.
+* **Modern solution wizard architectures**, which use the names `Simple Monolith`, `Layered Monolith`, `Modular Monolith`, and `Microservice`.
+
+Throughout this guide:
+
+* **Single-Layer** corresponds to the modern **Simple Monolith** architecture.
+* **N-Layered** corresponds to the modern **Layered Monolith** architecture.
+* **Modular Monolith** has a dedicated modern solution path in ABP Studio.
+* **Microservice** exists in both families, but the current microservice reference pages describe the modern React-based web structure.
+
The following **architectures** will be discussed based on ABP startup templates:
-* **Single-Layer** (non-layered) application
-* **N-Layered** application
-* **Modular** application
+* **Single-Layer / Simple Monolith** application
+* **N-Layered / Layered Monolith** application
+* **Modular Monolith** application
* **Microservice** solution
## What is a Startup Template?
@@ -24,7 +36,7 @@ In the following section, you will understand what a startup template is and wha
A startup solution template is a **pre-architected** structure. For example, the [layered startup template](layered-web-application/index.md) is a great starting point if you want to build a layered application code-base based on [Domain-Driven Design](../framework/architecture/domain-driven-design/index.md) principles and patterns.
-However, starting with any startup template **doesn't limit you** on adding or removing projects, layers, integration packages, and creating other applications/services. You can even start with a [single-layer application template]() and convert it to a microservice solution. However, if you want to build a microservice solution, starting with the [microservice startup template](microservice/index.md) is the best.
+However, starting with any startup template **doesn't limit you** on adding or removing projects, layers, integration packages, and creating other applications/services. You can even start with a [single-layer application template](single-layer-web-application/index.md) and convert it to a microservice solution. However, if you want to build a microservice solution, starting with the [microservice startup template](microservice/index.md) is the best.
So, it is **best to start with the most suitable startup template** for your purpose and then modify the solution to fit your custom requirements.
@@ -52,7 +64,7 @@ Up to this point, it is explained what a startup template is and the features it
### Single-Layer Application Solution Template
-The [single-layer solution template](single-layer-web-application/index.md) is the simplest. It provides a **minimal solution architecture** while starting a new project. Your .NET solution typically contains a **single, or a few .NET projects** depending on your UI and other preferences while creating your solution.
+The [single-layer solution template](single-layer-web-application/index.md) is the simplest classic option. It provides a **minimal solution architecture** while starting a new project. In the modern solution wizard, the comparable architecture is **Simple Monolith**. Your .NET solution typically contains a **single, or a few .NET projects** depending on your UI and other preferences while creating your solution.
The following figure shows a single-project web application that has [MVC (Razor Pages) UI](../framework/ui/mvc-razor-pages/overall.md) and [Entity Framework Core](../framework/data/entity-framework-core/index.md) database provider with the default configuration:
@@ -85,7 +97,7 @@ These options are not implemented to keep the solution structure as simple as po
### Layered Solution Template
-The [layered application startup template](layered-web-application/index.md) is a .NET solution that consists of several projects.
+The [layered application startup template](layered-web-application/index.md) is the classic layered option. In the modern solution wizard, the comparable architecture is **Layered Monolith**. It is a .NET solution that consists of several projects.
Each project represents a layer of the application or has a specific functionality for the solution.
The exact project count in your solution depends on the options you have selected.
@@ -117,9 +129,11 @@ In the following conditions, you may consider to use the layered solution templa
### Modular Monolith Applications
-ABP does not provide a specific modular monolith application startup template. However, it is not needed. Let us explain why.
+ABP Studio's modern solution wizard includes a dedicated [Modular Monolith solution template](modular-monolith/index.md). It creates a main application, enables modularity automatically, and lets you scaffold additional modules while creating the solution. This is the most direct path for new modular ABP Studio solutions.
+
+Classic ABP solutions can still build a modular monolith by combining a host application and reusable application modules.
-The ABP Framework and [ABP Studio](../studio/index.md) are already designed to support modular application development from their beginning. ABP framework provides all the **necessary infrastructure** for [modularity](../framework/architecture/modularity/basics.md) and all other framework features are **compatible with modular solutions**.
+The ABP Framework and [ABP Studio](../studio/index.md) are designed to support modular application development. ABP framework provides all the **necessary infrastructure** for [modularity](../framework/architecture/modularity/basics.md) and all other framework features are **compatible with modular solutions**.
On the other hand, the main purpose of ABP Studio's [Solution Explorer panel](../studio/solution-explorer.md) is to **architect and build modular and complex software solutions**. You can easily create new modules, arrange dependencies between the modules and import/install these modules into a monolith application. While you can do all these manually yourself, ABP Studio makes it extremely easy to do and understand it.
@@ -131,19 +145,20 @@ A **modular monolith** application consists of a **single host** application and
In this example, `MyCrm.Host` is an almost-empty host application that has package references to other modules. Every module consists of two packages: implementation and contract packages.
-You can follow the steps below to create such a modular solution with ABP Studio:
+You can follow one of the paths below to create such a modular solution with ABP Studio:
-* **Create a new application** using either [single-layer](single-layer-web-application/index.md) or [layered](layered-web-application/index.md) application startup template. That application will be the **host application** of your solution.
-* **Create new modules** (right-click to the solution root, select the *Add* -> *New Module* -> ... command).
-* **Import & Install** these **modules** to the host application.
+* **Modern path**: Choose the [Modular Monolith solution template](modular-monolith/index.md), configure the main application, then add extra modules in the *Modularity* step or later from *Solution Explorer*.
+* **Classic composition path**: Create a host application using either the [single-layer](single-layer-web-application/index.md) or [layered](layered-web-application/index.md) template, create new modules, then import and install these modules into the host application.
> You can follow the **[Modular Monolith Application Development Tutorial](../tutorials/modular-crm/index.md)** to learn how to build a modular application step by step.
#### Which Startup Template should be used for a Modular Application?
-So, both [single-layer](single-layer-web-application/index.md) and [layered](layered-web-application/index.md) application startup templates are inherently modular. Just use one of them and start your modular solution. You may wonder which one to start:
+For a new modern ABP Studio solution, use the dedicated [Modular Monolith solution template](modular-monolith/index.md).
+
+If you are composing a modular monolith by using the classic host + module approach, both [single-layer](single-layer-web-application/index.md) and [layered](layered-web-application/index.md) application startup templates are inherently modular. In that case, you may wonder which one to start:
-* Use the **[single-layer startup template](single-layer-web-application/index.md)** for the host application of your modular monolith if you will leave the host application as empty. It will contain some configuration code of course, but it won't contain any actual application code. **This is the suggested approach.**
+* Use the **[single-layer startup template](single-layer-web-application/index.md)** for the host application of your modular monolith if you will leave the host application as empty. It will contain some configuration code of course, but it won't contain any actual application code. **This is the suggested classic host approach.**
* Use the **[layered application startup template](layered-web-application/index.md)** if you will write some application code into the hosting application. You may want to write some code that makes multiple module operations that are not easy to implement in a particular module. In that case, a layered hosting application will be a better way to organize your codebase. However, this approach can quickly move your solution away from a modular system. So, take your own risk.
#### When Should You Start a Modular Monolith Application?
@@ -164,7 +179,7 @@ Even if you are considering building a microservice architecture, it is usually
### Microservice Solution Template
-ABP's [microservice startup template](microservice/index.md) includes multiple services, API gateways and applications that are well integrated into each other and ready to be a great **base solution for your microservice system**.
+ABP's [microservice startup template](microservice/index.md) includes multiple services, API gateways and applications that are well integrated into each other and ready to be a great **base solution for your microservice system**. The current reference pages describe the modern React-based web structure.
In the following picture, you can see an overall diagram that shows the main components of the solution (they vary based on the options while you are creating your solution):

diff --git a/docs/en/solution-templates/index.md b/docs/en/solution-templates/index.md
index c833b8d508..56969fc6ef 100644
--- a/docs/en/solution-templates/index.md
+++ b/docs/en/solution-templates/index.md
@@ -1,7 +1,7 @@
```json
//[doc-seo]
{
- "Description": "Explore ABP's production-ready startup solution templates for Single-Layer, Layered, and Microservice architectures to kickstart your project!"
+ "Description": "Explore ABP's startup solution templates, from classic Single-Layer and Layered solutions to modern Modular Monolith and Microservice architectures."
}
```
@@ -11,11 +11,14 @@ ABP provides pre-architected and production-ready templates to jump start a new
> **You can see the [Solution Template Selection Guide](guide.md) if you are not sure which solution template is suitable for you.**
+The reference pages below cover both classic and modern ABP Studio template families. The Single-Layer and Layered pages document the classic templates. The Modular Monolith and Microservice pages call out the current modern structure where it differs.
+
The following solution templates are provided out of the box:
-* **[Single-Layer Solution](single-layer-web-application/index.md)**: A single-project solution. Recommended for building an application with a **simpler and easy to understand** architecture.
-* **[Layered Solution](layered-web-application/index.md)**: A fully layered (multiple projects) solution based on [Domain Driven Design](../framework/architecture/domain-driven-design) practices. Recommended for long-term projects that need a **maintainable and extensible** codebase.
-* **[Microservice Solution](microservice/index.md)**: A **distributed solution** to build **microservice systems**. It includes pre-built services, API gateways, web and mobile applications, Kubernetes and Helm configuration, and everything you need to start your large-scale microservice solution.
+* **[Single-Layer Solution](single-layer-web-application/index.md)**: The classic single-project solution. In the modern solution wizard, the closest architecture is **Simple Monolith**.
+* **[Layered Solution](layered-web-application/index.md)**: The classic fully layered (multiple projects) solution based on [Domain Driven Design](../framework/architecture/domain-driven-design) practices. In the modern solution wizard, the closest architecture is **Layered Monolith**.
+* **[Modular Monolith](modular-monolith/index.md)**: The dedicated modern ABP Studio path for a main application plus reusable modules deployed as a single unit.
+* **[Microservice Solution](microservice/index.md)**: A **distributed solution** to build **microservice systems**. The current reference pages describe the modern React-based web structure.
* **[Application Module](application-module/index.md)**: A template that can be used to create a **reusable [application module](../modules/index.md)** based on the [module development best practices & conventions](../framework/architecture/best-practices/index.md). It is also suitable for creating **services** (with or without UI).
* **Others**
- [MAUI Application](../get-started/maui.md)
@@ -25,4 +28,4 @@ The following solution templates are provided out of the box:
## See Also
* [Solution Template Selection Guide](guide.md)
-* [Get Started with ABP Platform](../get-started/index.md)
\ No newline at end of file
+* [Get Started with ABP Platform](../get-started/index.md)
diff --git a/docs/en/solution-templates/microservice/authentication.md b/docs/en/solution-templates/microservice/authentication.md
index f079334a24..05721dee24 100644
--- a/docs/en/solution-templates/microservice/authentication.md
+++ b/docs/en/solution-templates/microservice/authentication.md
@@ -45,4 +45,8 @@ The solution has an authentication server (auth-server) application to provide t
## Authentication Flows
-The applications use several flows to authenticate users based on the application type. The MVC UI web application uses the [hybrid flow](https://openid.net/specs/openid-connect-core-1_0.html#HybridFlowAuth) (OpenID Connect Authentication) to authenticate users, while the SPA and Swagger applications use the [authorization code flow](https://openid.net/specs/openid-connect-core-1_0.html#CodeFlowAuth) to authenticate users. After the user logs into the system and receives the token from the authentication server, the applications (microservices) use [JWT Bearer Authentication](https://jwt.io/introduction/) to authorize users.
\ No newline at end of file
+The current modern microservice template generates React-based web clients and, optionally, a React Native mobile client. The generated authentication flows are:
+
+* `react`, `react-admin-console`, and `react-public-web` (when enabled) use the [authorization code flow](https://openid.net/specs/openid-connect-core-1_0.html#CodeFlowAuth) against the `AuthServer`.
+* `react-native` (when enabled) is configured with its own client id and scopes, uses the password grant plus refresh tokens against the `AuthServer`, and sends bearer tokens to backend APIs through the `MobileGateway`.
+* Backend services, gateways, and other protected APIs use [JWT Bearer Authentication](https://jwt.io/introduction/) to validate the tokens issued by the authentication server.
diff --git a/docs/en/solution-templates/microservice/health-check-configuration.md b/docs/en/solution-templates/microservice/health-check-configuration.md
index 37cd515209..c966b25824 100644
--- a/docs/en/solution-templates/microservice/health-check-configuration.md
+++ b/docs/en/solution-templates/microservice/health-check-configuration.md
@@ -12,7 +12,7 @@
Health Check is a feature that allows applications to monitor their health and diagnose potential issues. The Microservice solution template comes with pre-configured Health Check system.
-In the Microservice solution template, Health Check configuration is applied in all the services, gateways and UI applications (except Blazor Wasm & Blazor WebApp applications UI applications).
+In the current modern microservice template, Health Check configuration is applied to the .NET applications in the solution, such as backend services, gateways, and `auth-server`. The generated React frontend applications (`react`, `react-admin-console`, and `react-public-web` when enabled) do not expose these ASP.NET Core health check endpoints.
### Configuration in `HealthChecksBuilderExtensions.cs`
diff --git a/docs/en/solution-templates/microservice/index.md b/docs/en/solution-templates/microservice/index.md
index 9b4ed6b3a3..9ea6c3e0f1 100644
--- a/docs/en/solution-templates/microservice/index.md
+++ b/docs/en/solution-templates/microservice/index.md
@@ -21,6 +21,8 @@
ABP Studio provides pre-architected and production-ready templates to jump start a new solution. One of them is the Microservice solution template. You can use it to build distributed systems with common microservice patterns. It includes multiple services, API gateways and applications that are well integrated to each other and ready to be a great base solution for your microservice system.
+Unless stated otherwise, the pages in this section describe the current modern ABP Studio microservice template, where the web layer is React-based.
+
> **This document explains the Microservice solution template in every details. So, it is a reference document to fully understand the solution and refer when you have trouble.**
>
> **If you just want to quickly create a microservice solution, please refer to *[Quick Start: Creating a Microservice Solution with ABP Studio](../../get-started/microservice.md)* document.**
@@ -61,4 +63,4 @@ ABP Studio provides pre-architected and production-ready templates to jump start
* [Adding new API gateways](adding-new-api-gateways.md)
* [Mono-repo vs multiple repository approaches](mono-repo-vs-multiple-repository-approaches.md)
* [Authoring unit and integration tests](authoring-unit-and-integration-tests.md)
- * [How to use with ABP Suite](how-to-use-with-abp-suite.md)
\ No newline at end of file
+ * [How to use with ABP Suite](how-to-use-with-abp-suite.md)
diff --git a/docs/en/solution-templates/microservice/localization-system.md b/docs/en/solution-templates/microservice/localization-system.md
index ebc710f840..bc83151c2c 100644
--- a/docs/en/solution-templates/microservice/localization-system.md
+++ b/docs/en/solution-templates/microservice/localization-system.md
@@ -1,7 +1,7 @@
```json
//[doc-seo]
{
- "Description": "Learn how the ABP Framework manages localization in microservice solutions, enhancing resource management across applications seamlessly."
+ "Description": "Learn how localization works in ABP Studio's modern microservice solution template across backend services, React apps, and the optional React Native client."
}
```
@@ -25,7 +25,7 @@ Like the other fundamental feature modules ([Permission Management](permission-m
## Language Management
-> If the dynamic localization option is enabled, then the *Language Management Module** will be removed from the optional modules and a new microservice named `LanguageService` will be created. The `LanguageService` uses *Language Management Module* behind the scene.
+> If the dynamic localization option is enabled, then the *Language Management Module* is removed from the optional modules and a new microservice named `LanguageService` is created. `LanguageService` uses the *Language Management Module* behind the scenes.
The *Administration* microservice provides a set of APIs to manage localization. The localization resources are defined in each microservice, and when a microservice starts, it registers its localization resources to the related localization tables automatically. After that, you can see the localization resources from the [language texts](../../modules/language-management.md#language-texts) and manage them.
@@ -39,106 +39,42 @@ When you create a new microservice solution, you can **enable dynamic localizati

-When you enable this option, a new microservice named **LanguageService** will be added (with the language management module integrated) and you can use its `LanguageServiceResource` class to use the localization entries in your UI application. It's already configured in your final host application, so you don't need to make any configuration related to that. To define a new localization entry you can either use the language files in the `LanguageService` or update the already defined localization entries in the UI (on the *Language Texts* page).
-
-After defining localization entries or updating them, you can inject the `IStringLocalizer<>` or `IHtmlLocalizer<>` services and use the localized values in your pages for MVC/Razor Pages UI, for instance:
-
-```html
-@page
-@using Microsoft.Extensions.Localization
-@inject IStringLocalizer
+The React Native app is not started by the ABP Studio solution runner. Run `AuthServer`, `MobileGateway`, and the required backend services first, then start the mobile app with the standard React Native / Expo toolchain.
-
-### Profile Management
-
-Profile management allows users to view and update their personal profile picture and their passwords. It provides a seamless experience for users to manage their profiles within the mobile application without navigating to the authserver web application.
-
-The following screenshot was taken from the *Profile* page in the MAUI application:
-
-
-
-### Other Features
-
-#### Settings Page
-The settings page allows users to change the language and theme of the application, manage their profiles, change their passwords, and also to logout from the application.
-
-
-
-- **Language**: Applications implements ABP localization logic on the platforms. The language is automatically selected based on the device's language. Users can also change the language manually from the settings page.
-
-- **Dark/Light Theme**: ABP MAUI and React Native applications support both dark and light themes. The theme is automatically selected based on the device's theme. Users can also change the theme manually from the settings page.
-
-## Applications
-
-Following sections explain the structure of MAUI and React Native Applications.
-
-### The MAUI Application
-
-This is the mobile application that is built based on Microsoft's [MAUI framework](https://learn.microsoft.com/en-us/dotnet/maui). It will be in the solution only if you've selected the MAUI as your mobile application option.
-
-#### Project Structure
-Entire MAUI application is built on the AppShell pattern of MAUI. You can find the AppShell class in the `Acme.CloudCrm.Maui` project. It is the entry point of the application. It is responsible for initializing the application and registering the services. You find all the pages and routing information in the `AppShell.xaml` file.
-
-- **Pages**: Pages are located in the `Pages` folder of the project. Each page has a XAML & C# file. XAML file is responsible for the UI and C# file is responsible for the initialization of the page.
-
-- **ViewModels**: ViewModels are located in the `ViewModels` folder of the project. Each ViewModel has a C# file. ViewModels are responsible for the business logic of the pages.
-
-- **Oidc**: Oidc folder contains the logic for the authentication of the application. It contains the `MauiAuthenticationBrowser` class which manages the authentication process of the application.
-
-- **Localization**: Localization folder contains the localization logic of the application. It contains regular ABP Localization logic and the `LocalizationResourceManager` class which is wrapper for the ABP localization logic on MAUI.
-
-- **Messages**: Messages folder contains the message data for the communication inside application. Messages are used to send data between pages and viewmodels. It's designed on the [MVVM Toolkit Messenger](https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/messenger) feature.
-
-- **Storage**: Storage folder contains the storage logic of the application. It contains the `IStorage` class which is wrapper for the [SecureStorage](https://learn.microsoft.com/en-us/dotnet/maui/platform-integration/storage/secure-storage) feature. It is used to store the authentication data of the user and preferences of the application.
-
-_Rest of the folders are MAUI default folders. You can check the [.NET MAUI single project documentatipon](https://learn.microsoft.com/en-us/dotnet/maui/fundamentals/single-project?view=net-maui-8.0) for more information._
-
-#### Running the application
-Before running the MAUI Application, rest of the applications in the solution must be running. Such as AuthServer, MobileGateway and the microservices.
-
-Make sure that you prepared devices for debugging. You can check the following documentation for each platform.
-
-- [Android](https://learn.microsoft.com/en-us/dotnet/maui/android/emulator/)
-- [iOS](https://learn.microsoft.com/en-us/dotnet/maui/ios/pair-to-mac)
-- [MacCatalyst](https://learn.microsoft.com/en-us/dotnet/maui/mac-catalyst/cli)
-- [Windows](https://learn.microsoft.com/en-us/dotnet/maui/windows/setup)
-
-##### Network
-
-All the platforms including iOS, MacCataylst and Windows, runs the applications in the same network of the host. So, you can use the `localhost` address to connect to the applications.
-
-But in the **Android Emulator**, you need to use the `adb reverse` command to connect to the applications. You can use the following command to connect to the AuthServer application:
+For Android emulators or devices, map the development ports before testing:
```bash
-adb reverse tcp:44300 tcp:44300
+adb reverse tcp: