diff --git a/docs/mvvm/AsyncRelayCommand.md b/docs/mvvm/AsyncRelayCommand.md
new file mode 100644
index 0000000..b59bf5a
--- /dev/null
+++ b/docs/mvvm/AsyncRelayCommand.md
@@ -0,0 +1,87 @@
+---
+title: AsyncRelayCommand
+author: Sergio0694
+description: An asynchronous command whose sole purpose is to relay its functionality to other objects by invoking delegates
+keywords: windows 10, uwp, windows community toolkit, uwp community toolkit, uwp toolkit, mvvm, componentmodel, property changed, notification, binding, command, delegate, net core, net standard
+dev_langs:
+  - csharp
+---
+
+# AsyncRelayCommand and AsyncRelayCommand<T>
+
+The [`AsyncRelayCommand`](https://docs.microsoft.com/dotnet/api/microsoft.toolkit.mvvm.input.AsyncRelayCommand) and [`AsyncRelayCommand<T>`](https://docs.microsoft.com/dotnet/api/microsoft.toolkit.mvvm.input.AsyncRelayCommand-1) are `ICommand` implementations that extend the functionalities offered by `RelayCommand`, with support for asynchronous operations.
+
+## How they work
+
+`AsyncRelayCommand` and `AsyncRelayCommand<T>` have the following main features:
+
+- They extend the functionalities of the non-asynchronous commands included in the library, with support for `Task`-returning delegates.
+- They expose an `ExecutionTask` property that can be used to monitor the progress of a pending operation, and an `IsRunning` that can be used to check when an operation completes. This is particularly useful to bind a command to UI elements such as loading indicators.
+- They implement the `IAsyncRelayCommand` and `IAsyncRelayCommand<T>` interfaces, which means that viewmodel can easily expose commands using these to reduce the tight coupling between types. For instance, this makes it easier to replace a command with a custom implementation exposing the same public API surface, if needed.
+
+## Working with asynchronous commands
+
+Let's imagine a scenario similar to the one described in the `RelayCommand` sample, but a command executing an asynchronous operation:
+
+```csharp
+public class MyViewModel : ObservableObject
+{
+    public MyViewModel()
+    {
+        DownloadTextCommand = new AsyncRelayCommand(DownloadText);
+    }
+
+    public IAsyncRelayCommand DownloadTextCommand { get; }
+
+    private Task<string> DownloadText()
+    {
+        return WebService.LoadMyTextAsync();
+    }
+}
+```
+
+With the related UI code:
+
+```xml
+<Page
+    x:Class="MyApp.Views.MyPage"
+    xmlns:viewModels="using:MyApp.ViewModels">
+    <Page.DataContext>
+        <viewModels:MyViewModel x:Name="ViewModel"/>
+    </Page.DataContext>
+
+    <StackPanel Spacing="8">
+        <TextBlock>
+            <Run Text="Task status:"/>
+            <Run Text="{x:Bind ViewModel.DownloadTextCommand.ExecutionTask.Status, Mode=OneWay}"/>
+            <LineBreak/>
+            <Run Text="Result:"/>
+            <Run
+                xmlns:ex="using:Microsoft.Toolkit.Extensions"
+                Text="{x:Bind ex:TaskExtensions.GetResultOrDefault(ViewModel.DownloadTextCommand.ExecutionTask), Mode=OneWay}"/>
+        </TextBlock>
+        <Button
+            Content="Click me!"
+            Command="{x:Bind ViewModel.DownloadTextCommand}"/>
+        <ProgressRing IsActive="{x:Bind ViewModel.DownloadTextCommand.IsRunning, Mode=OneWay}"/>
+    </StackPanel>
+</Page>
+```
+
+Upon clicking the `Button`, the command is invoked, and the `ExecutionTask` updated. When the operation completes, the property raises a notification which is reflected in the UI. In this case, both the task status and the current result of the task are displayed. Note that to show the result of the task, it is necessary to use the `TaskExtensions.GetResultOrDefault` method - this provides access to the result of a task that has not yet completed without blocking the thread (and possibly causing a deadlock).
+
+## Sample Code
+
+There are more examples in the [unit tests](https://github.com/Microsoft/WindowsCommunityToolkit//blob/master/UnitTests/UnitTests.Shared/Mvvm).
+
+## Requirements
+
+| Device family | Universal, 10.0.16299.0 or higher |
+| --- | --- |
+| Namespace | Microsoft.Toolkit.Mvvm |
+| NuGet package | [Microsoft.Toolkit.Mvvm](https://www.nuget.org/packages/Microsoft.Toolkit.Mvvm/) |
+
+## API
+
+* [AsyncRelayCommand source code](https://github.com/Microsoft/WindowsCommunityToolkit//blob/master/Microsoft.Toolkit.Mvvm/Input/AsyncRelayCommand.cs)
+* [AsyncRelayCommand&lt;T> source code](https://github.com/Microsoft/WindowsCommunityToolkit//blob/master/Microsoft.Toolkit.Mvvm/Input/AsyncRelayCommand{T}.cs)
diff --git a/docs/mvvm/Introduction.md b/docs/mvvm/Introduction.md
new file mode 100644
index 0000000..15e84f1
--- /dev/null
+++ b/docs/mvvm/Introduction.md
@@ -0,0 +1,70 @@
+---
+title: Introduction to the MVVM package
+author: Sergio0694
+description: An overview of how to get started with MVVM package and to the APIs it contains
+keywords: windows 10, uwp, windows community toolkit, uwp community toolkit, uwp toolkit, get started, visual studio, MVVM, net core, net standard
+dev_langs:
+  - csharp
+  - vb 
+---
+
+# Introduction to the MVVM package
+
+The `Microsoft.Toolkit.Mvvm` package is a modern, fast, and modular MVVM library. It is part of the Windows Community Toolkit and is built around the following principles:
+
+- **Platform and Runtime Independent** - **.NET Standard 2.0** 🚀 (UI Framework Agnostic)
+- **Simple to pick-up and use** - No strict requirements on Application structure or coding-paradigms (outside of 'MVVM'ness), i.e., flexible usage.
+- **À la carte** - Freedom to choose which components to use.
+- **Reference Implementation** - Lean and performant, providing implementations for interfaces that are included in the Base Class Library, but lack concrete types to use them directly.
+
+This package targets .NET Standard so it can be used on any app platform: UWP, WinForms, WPF, Xamarin, Uno, and more; and on any runtime: .NET Native, .NET Core, .NET Framework, or Mono. It runs on all of them. The API surface is identical in all cases, making it perfect for building shared libraries.
+
+To install the package from within Visual Studio:
+
+1. In Solution Explorer, right-click on the project and select **Manage NuGet Packages**. Search for **Microsoft.Toolkit.Mvvm** and install it.
+
+    ![NuGet Packages](../resources/images/ManageNugetPackages.png "Manage NuGet Packages Image")
+
+2. Add a using or Imports directive to use the new APIs:
+
+    ```c#
+    using Microsoft.Toolkit.Mvvm;
+    ```
+    ```vb
+    Imports Microsoft.Toolkit.Mvvm
+    ```
+
+3. Code samples are available in the other docs pages for the MVVM package, and in the [unit tests](https://github.com/windows-toolkit/WindowsCommunityToolkit/tree/master/UnitTests/UnitTests.Shared/Mvvm) for the project.
+
+## When should I use this package?
+
+Use this package for access to a collection of standard, self-contained, lightweight types that provide a starting implementation for building modern apps using the MVVM pattern. These types alone are usually enough for many users to build apps without needing additional external references.
+
+The included types are:
+
+- **Microsoft.Toolkit.Mvvm.ComponentModel**
+  - `ObservableObject`
+  - `ObservableRecipient`
+- **Microsoft.Toolkit.Mvvm.DependencyInjection**
+  - `Ioc`
+- **Microsoft.Toolkit.Mvvm.Input**
+  - `RelayCommand`
+  - `RelayCommand<T>`
+  - `AsyncRelayCommand`
+  - `AsyncRelayCommand<T>`
+  - `IRelayCommand`
+  - `IRelayCommand<in T>`
+  - `IAsyncRelayCommand`
+  - `IAsyncRelayCommand<in T>`
+- **Microsoft.Toolkit.Mvvm.Messaging**
+  - `Messenger`
+  - `IMessenger`
+- **Microsoft.Toolkit.Mvvm.Messaging.Messages**
+  - `PropertyChangedMessage<T>`
+  - `RequestMessage<T>`
+  - `AsyncRequestMessage<T>`
+  - `CollectionRequestMessage<T>`
+  - `AsyncCollectionRequestMessage<T>`
+  - `ValueChangedMessage<T>`
+
+This package aims to offer as much flexibility as possible, so developers are free to choose which components to use.  All types are loosely-coupled, so that it's only necessary to include what you use. There is no requirement to go "all-in" with a specific series of all-encompassing APIs, nor is there a set of mandatory patterns that need to be followed when building apps using these helpers. Combine these building blocks in a way that best fits your needs.
diff --git a/docs/mvvm/Ioc.md b/docs/mvvm/Ioc.md
new file mode 100644
index 0000000..e703726
--- /dev/null
+++ b/docs/mvvm/Ioc.md
@@ -0,0 +1,89 @@
+---
+title: Ioc
+author: Sergio0694
+description: A type that facilitates the use of the IServiceProvider type
+keywords: windows 10, uwp, windows community toolkit, uwp community toolkit, uwp toolkit, mvvm, service, dependency injection, net core, net standard
+dev_langs:
+  - csharp
+---
+
+# Ioc ([Inversion of control](https://en.wikipedia.org/wiki/Inversion_of_control))
+
+The [`Ioc`](https://docs.microsoft.com/dotnet/api/microsoft.toolkit.mvvm.DependencyInjection.Ioc) class is a type that facilitates the use of the `IServiceProvider` type. It's powered by the `Microsoft.Extensions.DependencyInjection` package, which provides a fully featured and powerful DI set of APIs, and acts as an easy to setup and use `IServiceProvider`.
+
+## Configure and resolve services
+
+The main entry point is the `ConfigureServices` method, which can be used like so:
+
+```csharp
+// Register the services at startup
+Ioc.Default.ConfigureServices(services =>
+{
+    services.AddSingleton<IFilesService, FilesService>();
+    services.AddSingleton<ISettingsService, SettingsService>();
+    // Other services here...
+});
+
+// Retrieve a service instance when needed
+IFilesService fileService = Ioc.Default.GetService<IFilesService>();
+```
+
+The `Ioc.Default` property offers a thread-safe `IServiceProvider` instance that can be used anywhere in the application to resolve services. The `ConfigureService` method handles the initialization of that service. It is also possible to create different `Ioc` instances and to initialize each with different services.
+
+## Constructor injection
+
+One powerful feature that is available is "constructor injection", which means that the DI service provider is able to automatically resolve indirect dependencies between registered services when creating instances of the type being requested. Consider the following service:
+
+```csharp
+public class ConsoleLogger : ILogger
+{
+    private readonly IFileService FileService;
+    private readonly IConsoleService ConsoleService;
+
+    public FileLogger(
+        IFileService fileService,
+        IConsoleService consoleService)
+    {
+        FileService = fileService;
+        ConsoleService = consoleService;
+    }
+
+    // Methods for the IFileLogger interface here...
+}
+```
+
+Here we have a `ConsoleLogger` implementing the `ILogger` interface, and requiring `IFileService` and `IConsoleService` instances. Constructor injection means the DI service provider will "automagically" gather all the necessary services, like so:
+
+```csharp
+// Register the services at startup
+Ioc.Default.ConfigureServices(services =>
+{
+    services.AddSingleton<IFileService, FileService>();
+    services.AddSingleton<IConsoleService, ConsoleService>();
+    services.AddSingleton<ILogger, ConsoleLogger>();
+});
+
+// Retrieve a console logger with constructor injection
+ConsoleLogger consoleLogger = Ioc.Default.GetService<ConsoleLogger>();
+```
+
+The DI service provider will automatically check whether all the necessary services are registered, then it will retrieve them and invoke the constructor for the registered `ILogger` concrete type, to get the instance to return - all done automatically!
+
+## More docs
+
+For more info about `Microsoft.Extensions.DependencyInjection`, see [here](https://docs.microsoft.com/aspnet/core/fundamentals/dependency-injection).
+
+## Sample Code
+
+There are more examples in the [unit tests](https://github.com/Microsoft/WindowsCommunityToolkit//blob/master/UnitTests/UnitTests.Shared/Mvvm).
+
+## Requirements
+
+| Device family | Universal, 10.0.16299.0 or higher |
+| --- | --- |
+| Namespace | Microsoft.Toolkit.Mvvm |
+| NuGet package | [Microsoft.Toolkit.Mvvm](https://www.nuget.org/packages/Microsoft.Toolkit.Mvvm/) |
+
+## API
+
+* [ObservableObject source code](https://github.com/Microsoft/WindowsCommunityToolkit//blob/master/Microsoft.Toolkit.Mvvm/ComponentModel/ObservableObject.cs)
diff --git a/docs/mvvm/Messenger.md b/docs/mvvm/Messenger.md
new file mode 100644
index 0000000..2de2f4c
--- /dev/null
+++ b/docs/mvvm/Messenger.md
@@ -0,0 +1,120 @@
+---
+title: Messenger
+author: Sergio0694
+description: A type that can be used to exchange messages between different objects
+keywords: windows 10, uwp, windows community toolkit, uwp community toolkit, uwp toolkit, mvvm, service, messenger, messaging, net core, net standard
+dev_langs:
+  - csharp
+---
+
+# Messenger
+
+The [`Messenger`](https://docs.microsoft.com/dotnet/api/microsoft.toolkit.mvvm.Messaging.Messenger) class (with the accompanying [`IMessenger`](https://docs.microsoft.com/dotnet/api/microsoft.toolkit.mvvm.Messaging.IMessenger) interface) can be used to exchange messages between different objects. This can be useful to decouple different modules of an application without having to keep strong references to types being referenced. It is also possible to send messages to specific channels, uniquely identified by a token, and to have different messengers in different sections of an application. 
+
+## How it works
+
+The `Messenger` type is responsible for maintaining links between recipients (receivers of messages) and their registered message types, with relative message handlers. Any object can be registered as a recipient for a given message type using a message handler, which will be invoked whenever the `Messenger` instance is used to send a message of that type. It is also possible to send messages through specific communication channels (each identified by a unique token), so that multiple modules can exchange messages of the same type without causing conflicts. Messages sent without a token use the default shared channel.
+
+There are two ways to perform message registration: either through the `IRecipient<TMessage>` interface, or using an `Action<TMessage>` delegate acting as message handler. The first lets you register all the handlers with a single call to the `RegisterAll` extension, which automatically registers the recipients of all the declared message handlers, while the latter is useful when you need more flexibility or when you want to use a simple lambda expression as a message handler.
+
+Similar to the `Ioc` class, `Messenger` exposes a `Default` property that offers a thread-safe implementation built-in into the package. It is also possible to create multiple `Messenger` instances if needed, for instance if a different one is injected with a DI service provider into a different module of the app (for instance, multiple windows running in the same process).
+
+## Sending and receiving messages
+
+Consider the following:
+
+```csharp
+// Create a message
+public class LoggedInUserChangedMessage : ValueChangedMessage<User>
+{
+    public LoggedInUserChangedMessage(User user) : base(user)
+    {        
+    }
+}
+
+// Register a message in some module
+Messenger.Default.Register<LoggedInUserChangedMessage>(this, m =>
+{
+    // Handle the message here
+});
+
+// Send a message from some other module
+Messenger.Default.Send(new LoggedInUserChangedMessage(user));
+```
+
+Let's imagine this message type being used in a simple messaging application, which displays a header with the user name and profile image of the currently logged user, a panel with a list of conversations, and another panel with messages from the current conversation, if one is selected. Let's say these three sections are supported by the `HeaderViewModel`, `ConversationsListViewModel` and `ConversationViewModel` types respectively. In this scenario, the `LoggedInUserChangedMessage` message might be sent by the `HeaderViewModel` after a login operation has completed, and both those other viewmodels might register handlers for it. For instance, `ConversationsListViewModel` will load the list of conversations for the new user, and `ConversationViewModel` will just close the current conversation, if one is present.
+
+The `Messenger` class takes care of delivering messages to all the registered recipients. Note that a recipient can subscribe to messages of a specific type. Note that inherited message types are not registered in the default `Messenger` implementation.
+
+When a recipient is not needed anymore, you should unregister it so that it will stop receiving messages. You can unregister either by message type, by registration token, or by recipient:
+
+```csharp
+// Unregisters the recipient from a message type
+Messenger.Default.Unregister<LoggedInUserChangedMessage>(this);
+
+// Unregisters the recipient from a message type in a specified channel
+Messenger.Default.Unregister<LoggedInUserChangedMessage, int>(this, 42);
+
+// Unregister the recipient from all messages, across all channels
+Messenger.Default.UnregisterAll(this);
+```
+
+> [!WARNING]
+> The `Messenger` implementation uses strong references to track the registered recipients. This is done for performance reasons, and it means that each registered recipient should manually be unregistered to avoid memory leaks. That is, as long as a recipient is registered, the `Messenger` instance in use will keep an active reference to it, which will prevent the garbage collector from being able to collect that instance. You can either handle this manually, or you can inherit from [`ObservableRecipient`](ObservableRecipient.md), which by default automatically takes care of removing all the message registrations for recipient when it is deactivated (see docs on `ObservableRecipient` for more info about this).
+
+## Using request messages
+
+Another useful feature of messenger instances is that they can also be used to request values from a module to another. In order to do so, the package includes a base `RequestMessage<T>` class, which can be used like so:
+
+```csharp
+// Create a message
+public class LoggedInUserRequestMessage : RequestMessage<User>
+{
+}
+
+// Register the receiver in a module
+Messenger.Default.Register<LoggedInUserRequestMessage>(this, m =>
+{
+    m.Reply(CurrentUser); // Assume this is a private member
+});
+
+// Request the value from another module
+User user = Messenger.Default.Send<LoggedInUserRequestMessage>();
+```
+
+The `RequestMessage<T>` class includes an implicit converter that makes the conversion from a `LoggedInUserRequestMessage` to its contained `User` object possible. This will also check that a response has been received for the message, and throw an exception if that's not the case. It is also possible to send request messages without this mandatory response guarantee: just store the returned message in a local variable, and then manually check whether a response value is available or not. Doing so will not trigger the automatic exception if a response is not received when the `Send` method returns.
+
+The same namespace also includes base requests message for other scenarios: `AsyncRequestMessage<T>`, `CollectionRequestMessage<T>` and `AsyncCollectionRequestMessage<T>`.
+Here's how you can use an async request message:
+
+```csharp
+// Create a message
+public class LoggedInUserRequestMessage : AsyncRequestMessage<User>
+{
+}
+
+// Register the receiver in a module
+Messenger.Default.Register<LoggedInUserRequestMessage>(this, m =>
+{
+    m.Reply(GetCurrentUserAsync()); // We're replying with a Task<User>
+});
+
+// Request the value from another module (we can directly await on the request)
+User user = await Messenger.Default.Send<LoggedInUserRequestMessage>();
+```
+
+## Sample Code
+
+There are more examples in the [unit tests](https://github.com/Microsoft/WindowsCommunityToolkit//blob/master/UnitTests/UnitTests.Shared/Mvvm).
+
+## Requirements
+
+| Device family | Universal, 10.0.16299.0 or higher |
+| --- | --- |
+| Namespace | Microsoft.Toolkit.Mvvm |
+| NuGet package | [Microsoft.Toolkit.Mvvm](https://www.nuget.org/packages/Microsoft.Toolkit.Mvvm/) |
+
+## API
+
+* [Messenger source code](https://github.com/Microsoft/WindowsCommunityToolkit//blob/master/Microsoft.Toolkit.Mvvm/Messaging/Messenger.cs)
+* [IMessenger source code](https://github.com/Microsoft/WindowsCommunityToolkit//blob/master/Microsoft.Toolkit.Mvvm/Messaging/IMessenger.cs)
diff --git a/docs/mvvm/ObservableObject.md b/docs/mvvm/ObservableObject.md
new file mode 100644
index 0000000..738caea
--- /dev/null
+++ b/docs/mvvm/ObservableObject.md
@@ -0,0 +1,100 @@
+---
+title: ObservableObject
+author: Sergio0694
+description: A base class for objects of which the properties must be observable
+keywords: windows 10, uwp, windows community toolkit, uwp community toolkit, uwp toolkit, mvvm, componentmodel, property changed, notification, binding, net core, net standard
+dev_langs:
+  - csharp
+---
+
+# ObservableObject
+
+The [`ObservableObject`](https://docs.microsoft.com/dotnet/api/microsoft.toolkit.mvvm.componentmodel.ObservableObject) is a base class for objects that are observable by implementing the [`INotifyPropertyChanged`](https://docs.microsoft.com/dotnet/api/system.componentmodel.inotifypropertychanged) and [`INotifyPropertyChanging`](https://docs.microsoft.com/dotnet/api/system.componentmodel.inotifypropertychanging) interfaces. It can be used as a starting point for all kinds of objects that need to support property change notifications.
+
+## How it works
+
+`ObservableObject` has the following main features:
+
+- It provides a base implementation for `INotifyPropertyChanged` and `INotifyPropertyChanging`, exposing the `PropertyChanged` and `PropertyChanging` events.
+- It provides a series of `SetProperty` methods that can be used to easily set property values from types inheriting from `ObservableObject`, and to automatically raise the appropriate events.
+- It provides the `SetPropertyAndNotifyOnCompletion` method, which is analogous to `SetProperty` but with the ability to set `Task` properties and raise the notification events automatically when the assigned tasks are completed.
+- It exposes the `OnPropertyChanged` and `OnPropertyChanging` methods, which can be overridden in derived types to customize how the notification events are raised.
+
+## Simple property
+
+Here's an example of how to implement notification support to a custom property:
+
+```csharp
+public class User : ObservableObject
+{
+    private string name;
+
+    public string Name
+    {
+        get => name;
+        set => SetProperty(ref name, value);
+    }
+}
+```
+
+The provided `SetProperty<T>(ref T, T, string)` method checks the current value of the property, and updates it if different, and then also raises the relevant events automatically. The property name is automatically captured through the use of the `[CallerMemberName]` attribute, so there's no need to manually specify which property is being updated.
+
+## Wrapping a non-observable model
+
+A common scenario, for instance, when working with database items, is to create a wrapping "bindable" model that relays properties of the database model, and raises the property changed notifications when needed. This is also needed when wanting to inject notification support to models, that don't implement the `INotifyPropertyChanged` interface. `ObservableObject` provides a dedicated method to make this process simpler. For the following example, `User` is a model directly mapping a database table, without inheriting from `ObservableObject`:
+
+```csharp
+public class ObservableUser : ObservableObject
+{
+    private readonly User user;
+
+    public ObservableUser(User user) => this.user = user;
+
+    public string Name
+    {
+        get => user.Name;
+        set => Set(() => user.Name, value);
+    }
+}
+```
+
+The `SetProperty<T>(Expression<Func<T>>, T, string)` method makes creating these wrapping properties extremely simple, as it takes care of both retrieving and setting the target properties while providing an extremely compact API.
+
+## Handling `Task<T>` properties
+
+If a property is a `Task` it's necessary to also raise the notification event once the task completes, so that bindings are updated at the right time. eg. to display a loading indicator or other status info on the operation represented by the task. `ObservableObject` has an API for this scenario:
+
+```csharp
+public class MyModel : ObservableObject
+{
+    private Task<int> requestTask;
+
+    public Task<int> RequestTask
+    {
+        get => requestTask;
+        set => SetPropertyAndNotifyOnCompletion(ref requestTask, () => requestTask, value);
+    }
+
+    public void RequestValue()
+    {
+        LoadingTask = WebService.LoadMyValueAsync();
+    }
+}
+```
+
+Here the `SetPropertyAndNotifyOnCompletion<TTask>(ref TTask, Expression<Func<TTask>>, TTask, string)` method will take care of updating the target field, monitoring the new task, if present, and raising the notification event when that task completes. This way, it's possible to just bind to a task property and to be notified when its status changes.
+
+## Sample Code
+
+There are more examples in the [unit tests](https://github.com/Microsoft/WindowsCommunityToolkit//blob/master/UnitTests/UnitTests.Shared/Mvvm).
+
+## Requirements
+
+| Device family | Universal, 10.0.16299.0 or higher |
+| --- | --- |
+| Namespace | Microsoft.Toolkit.Mvvm |
+| NuGet package | [Microsoft.Toolkit.Mvvm](https://www.nuget.org/packages/Microsoft.Toolkit.Mvvm/) |
+
+## API
+
+* [ObservableObject source code](https://github.com/Microsoft/WindowsCommunityToolkit//blob/master/Microsoft.Toolkit.Mvvm/ComponentModel/ObservableObject.cs)
diff --git a/docs/mvvm/ObservableRecipient.md b/docs/mvvm/ObservableRecipient.md
new file mode 100644
index 0000000..1dabae2
--- /dev/null
+++ b/docs/mvvm/ObservableRecipient.md
@@ -0,0 +1,71 @@
+---
+title: ObservableRecipient
+author: Sergio0694
+description: A base class for observable objects that also acts as recipients for messages
+keywords: windows 10, uwp, windows community toolkit, uwp community toolkit, uwp toolkit, mvvm, componentmodel, property changed, notification, binding, messenger, messaging, net core, net standard
+dev_langs:
+  - csharp
+---
+
+# ObservableRecipient
+
+The [`ObservableRecipient`](https://docs.microsoft.com/dotnet/api/microsoft.toolkit.mvvm.componentmodel.ObservableRecipient) type is a base class for observable objects that also acts as recipients for messages. This class is an extension of `ObservableObject` which also provides built-in support to use the `IMessenger` type.
+
+## How it works
+
+The `ObservableRecipient` type is meant to be used as a base for viewmodels that also use the `IMessenger` features, as it provides built-in support for it. In particular:
+
+- It has both a parameterless constructor and one that takes an `IMessenger` instance, to be used with dependency injection. It also exposes a `Messenger` property that can be used to send and receive messages in the viewmodel. If the parameterless constructor is used, the `Messenger.Default` instance will be assigned to the `Messenger` property.
+- It exposes an `IsActive` property to activate/deactivate the viewmodel. In this context, to "activate" means that a given viewmodel is marked as being in use, such that eg. it will start listening for registered messages, perform other setup operations, etc. There are two related methods, `OnActivated` and `OnDeactivated`, that are invoked when the property changes value. By default, `OnDeactivated` automatically unregisters the current instance from all registered messages. For best results and to avoid memory leaks, it's recommended to use `OnActivated` to register to messages, and to use `OnDeactivated` to do cleanup operations. This pattern allows a viewmodel to be enabled/disabled multiple times, while being safe to collect without the risk of memory leaks every time it's deactivated. By default, `OnActived` will automatically register all the message handlers defined through the `IRecipient<TMessage>` interface.
+- It exposes a `Broadcast<T>(T, T, string)` method which sends a `PropertyChangedMessage<T>` message through the `IMessenger` instance available from the `Messenger` property. This can be used to easily broadcast changes in the properties of a viewmodel without having to manually retrieve a `Messenger` instance to use. This method is used by the overload of the various `SetProperty` methods, which have an additional `bool broadcast` property to indicate whether or not to also send a message.
+
+Here's an example of a viewmodel that receives `LoggedInUserRequestMessage` messages when active:
+
+```csharp
+public class MyViewModel : ObservableRecipient, IRecipient<LoggedInUserRequestMessage>
+{
+    public void Receive(LoggedInUserRequestMessage message)
+    {
+        // Handle the message here
+    }
+}
+```
+
+In the above, `OnActivated` automatically registers the instance as a recipient for `LoggedInUserRequestMessage` messages, using that method as the action to invoke. Using the `IRecipient<TMessage>` interface is not mandatory, and the registration can also be done manually (even using just an inline lambda expression):
+
+```csharp
+public class MyViewModel : ObservableRecipient
+{
+    protected override void OnActivated()
+    {
+        // Using a method group...
+        Messenger.Register<LoggedInUserRequestMessage>(this, Receive);
+
+        // ...or a lambda expression
+        Messenger.Register<LoggedInUserRequestMessage>(this, m =>
+        {
+            // Handle the message here
+        });
+    }
+
+    private void Receive(LoggedInUserRequestMessage message)
+    {
+        // Handle the message here
+    }
+}
+```
+
+## Sample Code
+
+There are more examples in the [unit tests](https://github.com/Microsoft/WindowsCommunityToolkit//blob/master/UnitTests/UnitTests.Shared/Mvvm).
+
+## Requirements
+
+| Device family | Universal, 10.0.16299.0 or higher |
+| --- | --- |
+| Namespace | Microsoft.Toolkit.Mvvm |
+| NuGet package | [Microsoft.Toolkit.Mvvm](https://www.nuget.org/packages/Microsoft.Toolkit.Mvvm/) |
+
+## API
+
+* [ObservableRecipient source code](https://github.com/Microsoft/WindowsCommunityToolkit//blob/master/Microsoft.Toolkit.Mvvm/ComponentModel/ObservableRecipient.cs)
diff --git a/docs/mvvm/RelayCommand.md b/docs/mvvm/RelayCommand.md
new file mode 100644
index 0000000..789027b
--- /dev/null
+++ b/docs/mvvm/RelayCommand.md
@@ -0,0 +1,83 @@
+---
+title: RelayCommand
+author: Sergio0694
+description: A command whose sole purpose is to relay its functionality to other objects by invoking delegates
+keywords: windows 10, uwp, windows community toolkit, uwp community toolkit, uwp toolkit, mvvm, componentmodel, property changed, notification, binding, command, delegate, net core, net standard
+dev_langs:
+  - csharp
+---
+
+# RelayCommand and RelayCommand&lt;T>
+
+The [`RelayCommand`](https://docs.microsoft.com/dotnet/api/microsoft.toolkit.mvvm.input.RelayCommand) and [`RelayCommand<T>`](https://docs.microsoft.com/dotnet/api/microsoft.toolkit.mvvm.input.RelayCommand-1) are `ICommand` implementations that can expose a method or delegate to the view. These types act as a way to bind commands between the viewmodel and UI elements.
+
+## How they work
+
+`RelayCommand` and `RelayCommand<T>` have the following main features:
+
+- They provide a base implementation of the `ICommand` interface.
+- They also implement the `IRelayCommand` (and `IRelayCommand<T>`) interface, which exposes a `NotifyCanExecuteChanged` method to raise the `CanExecuteChanged` event.
+- They expose constructors taking delegates like `Action` and `Func<T>`, which allow the wrapping of standard methods and lambda expressions.
+
+## Working with `ICommand`
+
+The following shows how to set up a simple command:
+
+```csharp
+public class MyViewModel : ObservableObject
+{
+    public MyViewModel()
+    {
+        IncrementCounterCommand = new RelayCommand(IncrementCounter);
+    }
+
+    private int counter;
+
+    public int Counter
+    {
+        get => counter;
+        private set => Set(ref counter, value);
+    }
+
+    public ICommand IncrementCounterCommand { get; }
+
+    private void IncrementCounter() => Counter++;
+}
+```
+
+And the relative UI could then be (using WinUI XAML):
+
+```xml
+<Page
+    x:Class="MyApp.Views.MyPage"
+    xmlns:viewModels="using:MyApp.ViewModels">
+    <Page.DataContext>
+        <viewModels:MyViewModel x:Name="ViewModel"/>
+    </Page.DataContext>
+
+    <StackPanel Spacing="8">
+        <TextBlock Text="{x:Bind ViewModel.Counter, Mode=OneWay}"/>
+        <Button
+            Content="Click me!"
+            Command="{x:Bind ViewModel.IncrementCounterCommand}"/>
+    </StackPanel>
+</Page>
+```
+
+The `Button` binds to the `ICommand` in the viewmodel, which wraps the private `IncrementCounter` method. The `TextBlock` displays the value of the `Counter` property and is updated every time the property value changes.
+
+## Sample Code
+
+There are more examples in the [unit tests](https://github.com/Microsoft/WindowsCommunityToolkit//blob/master/UnitTests/UnitTests.Shared/Mvvm).
+
+## Requirements
+
+| Device family | Universal, 10.0.16299.0 or higher |
+| --- | --- |
+| Namespace | Microsoft.Toolkit.Mvvm |
+| NuGet package | [Microsoft.Toolkit.Mvvm](https://www.nuget.org/packages/Microsoft.Toolkit.Mvvm/) |
+
+## API
+
+* [RelayCommand source code](https://github.com/Microsoft/WindowsCommunityToolkit//blob/master/Microsoft.Toolkit.Mvvm/Input/RelayCommand.cs)
+* [RelayCommand&lt;T> source code](https://github.com/Microsoft/WindowsCommunityToolkit//blob/master/Microsoft.Toolkit.Mvvm/Input/RelayCommand{T}.cs)
diff --git a/docs/toc.md b/docs/toc.md
new file mode 100644
index 0000000..07edd3d
--- /dev/null
+++ b/docs/toc.md
@@ -0,0 +1,227 @@
+# [Windows Community Toolkit Documentation](index.md)
+
+# Setup
+## [Getting Started with the Windows Community Toolkit](Getting-Started.md)
+## [Windows Community Toolkit Nuget Packages](Nuget-Packages.md)
+## [Adding the Windows Community Toolkit to your Visual Studio Toolbox](Toolbox-Support.md)
+## [Known Issues](knownissues.md)
+
+# Controls
+## Controls for WPF and Windows Forms
+### [InkCanvas](controls/wpf-winforms/InkCanvas.md)
+### [InkToolbar](controls/wpf-winforms/InkToolbar.md)
+### [MapControl](controls/wpf-winforms/MapControl.md)
+### [MediaPlayerElement](controls/wpf-winforms/MediaPlayerElement.md)
+### [WebView](controls/wpf-winforms/WebView.md)
+#### [WebView known issues](controls/wpf-winforms/WebView-known-issues.md)
+### [WebViewCompatible](controls/wpf-winforms/WebViewCompatible.md)
+### [WindowsXamlHost](controls/wpf-winforms/WindowsXamlHost.md)
+## [AdaptiveGridView](controls/AdaptiveGridView.md)
+## [BladeView](controls/BladeView.md)
+## [CameraPreview](controls/CameraPreview.md)
+## [Carousel](controls/Carousel.md)
+## [DataGrid](controls/DataGrid.md)
+### [How to: Add a DataGrid control to a page](controls/datagrid_guidance/datagrid_basics.md)
+### [How to: Customize the DataGrid control using styling and formatting options](controls/datagrid_guidance/styling_formatting_options.md)
+### [How to: Display and configure Row Details](controls/datagrid_guidance/rowdetails.md)
+### [How to: Configure Auto-generated columns in the DataGrid control](controls/datagrid_guidance/customize_autogenerated_columns.md)
+### [How to: Group, sort and filter data using LINQ and the DataGrid control](controls/datagrid_guidance/group_sort_filter.md)
+### [How to: Edit and perform input validation in the DataGrid control](controls/datagrid_guidance/editing_inputvalidation.md)
+### [Sizing options in the DataGrid control](controls/datagrid_guidance/sizing_options.md)
+### [Default keyboard navigation and selection patterns](controls/datagrid_guidance/keyboard_navigation_selection.md)
+## [DockPanel](controls/DockPanel.md)
+## [DropShadowPanel Control](controls/DropShadowPanel.md)
+## [Expander Control](controls/Expander.md)
+## [Eyedropper](controls/Eyedropper.md)
+## [GridSplitter](controls/GridSplitter.md)
+## [HeaderedContentControl](controls/HeaderedContentControl.md)
+## [HeaderedItemsControl](controls/HeaderedItemsControl.md)
+## [HeaderedTextBlock](controls/HeaderedTextBlock.md)
+## [ImageCropper](controls/ImageCropper.md)
+## [ImageEx](controls/ImageEx.md)
+## [InAppNotification](controls/InAppNotification.md)
+## [InfiniteCanvas](controls/InfiniteCanvas.md)
+## [LayoutTransformControl](controls/LayoutTransformControl.md)
+## [Loading](controls/Loading.md)
+## [MarkdownTextBlock](controls/MarkdownTextBlock.md)
+## [MasterDetailsView](controls/MasterDetailsView.md)
+## [Menu Control](controls/Menu.md)
+## [OrbitView](controls/OrbitView.md)
+## [RadialGauge](controls/RadialGauge.md)
+## [RadialProgressBar](controls/RadialProgressBar.md)
+## [RangeSelector](controls/RangeSelector.md)
+## [RemoteDevicePicker](controls/RemoteDevicePicker.md)
+## [RotatorTile](controls/RotatorTile.md)
+## [ScrollHeader](controls/ScrollHeader.md)
+## [StaggeredLayout](controls/layout/StaggeredLayout.md)
+
+## [StaggeredPanel](controls/StaggeredPanel.md)
+## [TabView](controls/TabView.md)
+## [TextToolbar](controls/TextToolbar.md)
+## [TileControl](controls/TileControl.md)
+## [TokenizingTextBox](controls/TokenizingTextBox.md)
+## [UniformGrid](controls/UniformGrid.md)
+## [WrapLayout](controls/layout/WrapLayout.md)
+
+## [WrapPanel](controls/WrapPanel.md)
+
+# Animations
+## [AnimationSet](animations/AnimationSet.md)
+## [Blur](animations/Blur.md)
+## [Composition Animations](animations/CompositionAnimations.md)
+## [Connected Animations](animations/ConnectedAnimations.md)
+## [ExpressionBuilder](animations/Expressions.md)
+## [Fade](animations/Fade.md)
+## [FadeHeader](animations/FadeHeader.md)
+## [Implicit Animations](animations/ImplicitAnimations.md)
+## [Light](animations/Light.md)
+## [Lottie](animations/Lottie.md)
+### [Getting Started with Lottie-Windows](animations/lottie-scenarios/getting_started_json.md)
+### [Using Codegen](animations/lottie-scenarios/getting_started_codegen.md)
+### [JSON versus Codegen](animations/lottie-scenarios/json_codegen.md)
+### [Configuring Animation Playback](animations/lottie-scenarios/playback.md)
+### [Interactive Segments on an Animation Timeline](animations/lottie-scenarios/segments.md)
+### [The Asynchronous Play Method](animations/lottie-scenarios/async_play.md)
+### [Handling Failure and Down-level](animations/lottie-scenarios/fallback.md)
+## [Offset](animations/Offset.md)
+## [ReorderGridAnimation](animations/ReorderGrid.md)
+## [Rotate](animations/Rotate.md)
+## [Saturation](animations/Saturation.md)
+## [Scale](animations/Scale.md)
+
+# Brushes
+## [AcrylicBrush](brushes/AcrylicBrush.md)
+## [BackdropBlurBrush](brushes/BackdropBlurBrush.md)
+## [BackdropGammaTransferBrush](brushes/BackdropGammaTransferBrush.md)
+## [BackdropInvertBrush](brushes/BackdropInvertBrush.md)
+## [BackdropSaturationBrush](brushes/BackdropSaturationBrush.md)
+## [BackdropSepiaBrush](brushes/BackdropSepiaBrush.md)
+## [ImageBlendBrush](brushes/ImageBlendBrush.md)
+## [PipelineBrush](brushes/PipelineBrush.md)
+## [RadialGradientBrush](brushes/RadialGradientBrush.md)
+## [TilesBrush](brushes/TilesBrush.md)
+
+# Extensions
+## [ArrayExtensions](extensions/ArrayExtensions.md)
+## [Composition Visual Layer Extensions](extensions/VisualExtensions.md)
+## [FrameworkElementExtensions](extensions/FrameworkElementExtensions.md)
+## [HyperlinkExtensions](extensions/HyperlinkExtensions.md)
+## [IconMarkupExtensions](extensions/IconMarkupExtensions.md)
+## [ListViewExtensions](extensions/ListViewExtensions.md)
+## [Logical Tree](extensions/LogicalTree.md)
+## [Matrix Extensions](extensions/MatrixExtensions.md)
+### [Extra Matrix Helpers](extensions/MatrixHelperEx.md)
+### [Transform Extensions](extensions/TransformExtensions.md)
+## [Mouse Cursor](extensions/MouseCursor.md)
+## [NullableBoolMarkup](extensions/NullableBoolMarkup.md)
+## [ScrollViewerExtensions](extensions/ScrollViewerExtensions.md)
+## [StringExtensions](extensions/StringExtensions.md)
+## [SurfaceDialTextboxHelper](extensions/SurfaceDialTextboxHelper.md)
+## [TextBoxMask](extensions/TextBoxMask.md)
+## [TextBoxRegex](extensions/TextBoxRegex.md)
+## [UIElementExtensions](extensions/UIElementExtensions.md)
+## [ViewExtensions](extensions/ViewExtensions.md)
+## [Visual Tree](extensions/VisualTree.md)
+## [WebViewExtensions](extensions/WebViewExtensions.md)
+
+# Collections
+## [Observable Groups](collections/ObservableGroups.md)
+
+# Microsoft Graph
+## Controls
+### [LoginButton](graph/controls/LoginButton.md)
+### [PersonView](graph/controls/PersonView.md)
+### [PeoplePicker](graph/controls/PeoplePicker.md)
+## Providers
+### [InteractiveProviderBehavior](graph/providers/InteractiveProviderBehavior.md)
+### [MockProviderBehavior](graph/providers/MockProviderBehavior.md)
+
+# Helpers
+## [AdvancedCollectionView](helpers/AdvancedCollectionView.md)
+## [BackgroundTaskHelper](helpers/BackgroundTaskHelper.md)
+## [BindableValueHolder](helpers/BindableValueHolder.md)
+## [BluetoothLEHelper](helpers/BluetoothLEHelper.md)
+## [CameraHelper](helpers/CameraHelper.md)
+## [Colors](helpers/Colors.md)
+## [Converters](helpers/Converters.md)
+## [DeepLinkParser](helpers/DeepLinkParsers.md)
+## [DispatcherHelper](helpers/DispatcherHelper.md)
+## [HttpHelper](helpers/HttpHelper.md)
+## [HttpHelperRequest](helpers/HttpHelperRequest.md)
+## [HttpHelperResponse](helpers/HttpHelperResponse.md)
+## [ImageCache](helpers/ImageCache.md)
+## [IncrementalLoadingCollection](helpers/IncrementalLoadingCollection.md)
+## [NetworkHelper](helpers/NetworkHelper.md)
+## [ObjectStorage](helpers/ObjectStorage.md)
+## [ObjectSerializer](helpers/ObjectSerializer.md)
+## [PrintHelper](helpers/PrintHelper.md)
+## [RemoteDeviceHelper](helpers/RemoteDeviceHelper.md)
+## [StorageFileHelper](helpers/StorageFiles.md)
+## [Streams Helper](helpers/Streams.md)
+## [SystemInformation](helpers/SystemInformation.md)
+## [ThemeListener](helpers/ThemeListener.md)
+## [Triggers](helpers/Triggers.md)
+## [WeakEventListener](helpers/WeakEventListener.md)
+## [ViewportBehavior](helpers/ViewportBehavior.md)
+
+# Services
+## [Facebook Service](services/Facebook.md)
+## [LinkedIn Service](services/Linkedin.md)
+## [Microsoft Graph Service](services/MicrosoftGraph.md)
+### [GraphLogin (WinForms)](services/GraphLogin.md)
+## [Microsoft Translator Service](services/MicrosoftTranslator.md)
+## [OneDrive Service](services/OneDrive.md)
+## [Twitter Service](services/Twitter.md)
+## [Weibo Service](services/Weibo.md)
+
+# Parsers
+## [MarkdownParser](parsers/MarkdownParser.md)
+## [RSSParser](parsers/RSSParser.md)
+
+# MVVM
+## [Introduction](mvvm/Introduction.md)
+## ComponentModel
+### [ObservableObject](mvvm/ObservableObject.md)
+### [ObservableRecipient](mvvm/ObservableRecipient.md)
+## Input
+### [RelayCommand and RelayCommand<T>](mvvm/RelayCommand.md)
+### [AsyncRelayCommand and AsyncRelayCommand<T>](mvvm/AsyncRelayCommand.md)
+## [Ioc](mvvm/Ioc.md)
+## [Messenger](mvvm/Messenger.md)
+
+# High performance
+## [Introduction](high-performance/Introduction.md)
+## Buffers
+### [MemoryOwner<T>](high-performance/MemoryOwner.md)
+### [SpanOwner<T>](high-performance/SpanOwner.md)
+### [StringPool](high-performance/StringPool.md)
+## [ParallelHelper](high-performance/ParallelHelper.md)
+## [Ref<T> and ReadOnlyRef<T>](high-performance/Ref.md)
+
+# Developer tools
+## [AlignmentGrid](developer-tools/AlignmentGrid.md)
+## [FocusTracker](developer-tools/FocusTracker.md)
+## [Guard](developer-tools/Guard.md)
+
+# [GazeInteractionLibrary](gaze/GazeInteractionLibrary.md)
+
+# [Notifications](notifications/NotificationsOverview.md)
+
+# [Platform Specific Analyzer](platform-specific/PlatformSpecificAnalyzer.md)
+
+# Archive
+## Animations
+### [ParallaxService](archive/ParallaxService.md)
+## Controls
+### [HamburgerMenu](archive/HamburgerMenu.md)
+### [PullToRefreshListView](archive/PullToRefreshListview.md)
+### [SlidableListItem](archive/SlidableListItem.md)
+## Microsoft Graph Controls
+### [AadLogin](archive/graph/AadLogin.md)
+### [PeoplePicker](archive/graph/PeoplePicker.md)
+### [PlannerTaskList](archive/graph/PlannerTaskList.md)
+### [PowerBIEmbedded](archive/graph/PowerBIEmbedded.md)
+### [ProfileCard](archive/graph/ProfileCard.md)
+### [SharePointFileList](archive/graph/SharePointFileList.md)
+## Services
+### [Bing Service](archive/Bing.md)