diff --git a/docs/assets/images/MR_Worflow.png b/docs/assets/images/MR_Worflow.png
new file mode 100644
index 0000000000000000000000000000000000000000..b40983c4faed7c18bd82654bfcd3667c36d1e500
--- /dev/null
+++ b/docs/assets/images/MR_Worflow.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:67eedfd1ba44d1f13757356eaf8184aab387674f7b51ba871addff03b4eda26a
+size 136847
diff --git a/docs/assets/videos/Git_Installation&Configuration.mp4 b/docs/assets/videos/Git_Installation&Configuration.mp4
new file mode 100644
index 0000000000000000000000000000000000000000..cb4268bda5a0546a020edef2d02fd8e2afce1031
Binary files /dev/null and b/docs/assets/videos/Git_Installation&Configuration.mp4 differ
diff --git a/docs/assets/videos/Merge_Request_Workflow.mp4 b/docs/assets/videos/Merge_Request_Workflow.mp4
new file mode 100644
index 0000000000000000000000000000000000000000..d443dddb6d74d0ef60e400fd74d6ce3651cf8661
Binary files /dev/null and b/docs/assets/videos/Merge_Request_Workflow.mp4 differ
diff --git a/docs/assets/videos/SSH_Configuration.mp4 b/docs/assets/videos/SSH_Configuration.mp4
new file mode 100644
index 0000000000000000000000000000000000000000..21a747114d1ad4c1351181de906b9d96e5ec8d43
Binary files /dev/null and b/docs/assets/videos/SSH_Configuration.mp4 differ
diff --git a/docs/developer/build-environment/windows.md b/docs/developer/build-environment/windows.md
index 5fb8fa50dfe8b97eb1f6e8a169eec85fd309bb7b..bac92bbda49b266fd7deb80b8c3821ca9bc240d4 100644
--- a/docs/developer/build-environment/windows.md
+++ b/docs/developer/build-environment/windows.md
@@ -84,6 +84,7 @@ The page should look something like this:
 ```{.sh .copy}
 git clone https://github.com/microsoft/vcpkg.git
 ```
+You can also copy the clone command from  [GitHub Page 🔗](https://github.com/microsoft/vcpkg)
 
 - Create the *vcpkg* executable by executing this command in the opened terminal:
 
@@ -91,4 +92,53 @@ git clone https://github.com/microsoft/vcpkg.git
 .\vcpkg\bootstrap-vcpkg.bat
 ```
 
+If you are using Git Bash , use this command
+
+```{.cmd .copy}
+./vcpkg/bootstrap-vcpkg.bat
+``` 
+To check if the vcpkg is installed on your system, you can run the following command in your terminal or command prompt:
+
+```{.cmd .copy}
+vcpkg --version
+``` 
+
+If you get an error like vcpkg: command not found, it means that vcpkg is not properly installed or the executable is not in your system's PATH. Make sure that vcpkg is correctly installed and that the path to the executable is included in the environment variables.
+
 You can get more information how *vcpkg* can be installed in the [Readme :octicons-link-external-16:](https://github.com/microsoft/vcpkg/?tab=readme-ov-file#getting-started){:target="_blank"} of the project itself.
+
+---
+
+## Install CMake
+- Download and Install the latest release of **CMake**: [Download CMake :octicons-link-external-16:](https://cmake.org/download/){:target="_blank"}
+
+!!! important 
+    Install at least version **3.29**!
+
+- Enable the option to make **CMake** available in *PATH*.
+
+---
+
+## Other tools
+
+### Install Python
+- Download and install **Python**: [Download Python :octicons-link-external-16:](https://www.python.org/downloads/windows/){:target="_blank"}
+
+!!! warning
+    Please install version  **3.11**, select all the default options and check the option to add Python to *PATH* & make sure to include the debug binaries!
+
+![Python settings](../../assets/images/developer/python-debug-binaries.png)
+
+#### Python Dependencies
+The only Python dependency we have is `pipenv` which is used to manage the Python environment.
+Install it by executing the following command in a terminal after you have **successfully** installed Python:
+
+```{.sh .copy}
+pip install pipenv
+```
+
+### Install Git
+- Download and Install the latest release of **Git**: [Download Git :octicons-link-external-16:](https://git-scm.com/download/win){:target="_blank"}
+- Enable the option to make **Git** available in *PATH*.
+- Leave the rest of the options to their defaults.
+- Watch the [Git Installation & Configuration tutorial](../../assets/videos/Git_Installation&Configuration.mp4) video for a more detailed explanation on how to download and install Git on a Windows machine.
diff --git a/docs/developer/get-source-code.md b/docs/developer/get-source-code.md
index 62acc576c04a78fe736c02fd92f02500a85e7332..bf7eed777ca656d0920d6267389dac1c9c7b4288 100644
--- a/docs/developer/get-source-code.md
+++ b/docs/developer/get-source-code.md
@@ -5,40 +5,58 @@ authors:
     - Sebastian Oberschwendtner
 date: 2024-04-09
 ---
+# Get UNICADO Source Code
+
 The source code of **UNICADO** is grouped into different repositories.
 You can get an overview of which repository contains which topic [here](../modules/overview.md).
 Whenever one repository needs another repository, we include it as a *Git Submodule*.
 If you are not familiar with *Git Submodules*, please read their [Documentation :octicons-link-external-16:](https://git-scm.com/book/en/v2/Git-Tools-Submodules).
 
-## Get the Source Code
-The repository [:simple-gitlab: Unicado Package :octicons-link-external-16:](https://git.rwth-aachen.de/unicado/unicado-package) contains all necessary source code as submodules to get started compiling **UNICADO** and its installer.
-
-When you clone the repository for the first time use this command:
+## Clone the Unicado Package Repository and update its Submodules
 
-=== "Gitlab"
+The repository [Unicado Package](https://git.rwth-aachen.de/unicado/unicado-package) contains all necessary source code as submodules to get started compiling **UNICADO** and its installer.. It is used to create UNICADO releases and provides a good starting point for development.
+To clone the repository and its submodules, navigate to the desired location on your local machine and run the following commands:
 
-    ```{.sh .copy}
-    git clone --recurse-submodules git@git.rwth-aachen.de/unicado/unicado-package.git
-    ```
+>💡 Open your preferred IDE (e.g., Visual Studio Code). Ensure that Git is integrated within your IDE. Most IDEs, such as VSCode, have built-in Git integration.
 
-=== "Phabricator"
+`git clone --recurse-submodules git@git.rwth-aachen.de:unicado/unicado-package.git`
 
-    ```{.sh .copy}
-    git clone --recurse-submodules ssh://git@unicado.ilr.rwth-aachen.de:2222/source/rUNICADO.git
-    ```
+This command will clone the repository to your local machine. To learn more about the structure of this repository, refer to [this guide](../developer/get-source-code.md).
 
-    !!! note
-        *Phabricator* is deprecated it will be removed in the near future!
+>💡 Login to the UNICADO project on GitLab and copy the SSH clone command directly from there.
 
 Should the default branch not yet contain the submodules or you want to update the submodules afterwards, you can do that with:
+
 ```{.sh .copy}
 git submodule update --init --recursive
 ```
 
-!!! warning
-    Only proceed when all submodules could be checked out successfully. Otherwise the builds will not work!
+>⚠️Only proceed when all submodules could be checked out successfully. Otherwise the builds will not work!
 
-## Where to find what
 In the following instructions we assume, that you cloned the **Unicado Package** as described.
 That means, whenever we talk about building inside the *Aircraft Design* folder, we mean the submodule **inside** the **Unicado Package** repository.
-In general, you should find every mentioned directory or file in one of the submodules of the **Unicado Package**. :point_up:
\ No newline at end of file
+In general, you should find every mentioned directory or file in one of the submodules of the **Unicado Package**. :point_up:
+
+## Update the Repository with the Latest Changes from Remote
+
+Once the repository is cloned, you need to update it with the latest changes from the remote. If your repository includes multiple submodules, follow these steps:
+
+### 1. Checkout the `main` branch of your repository
+
+```bash
+git checkout main
+```
+
+### 2. Fetch the latest updates from the remote repository
+
+```bash
+git fetch
+```
+
+### 3. Pull the latest changes from the remote `main` branch
+
+```bash
+git pull origin main
+```
+
+Watch the first part of [Merge Request Workflow](../assets/videos/Merge_Request_Workflow.mp4) video for a more detailed explanation of above mentioned steps.
\ No newline at end of file
diff --git a/docs/developer/git-installation&configuration.md b/docs/developer/git-installation&configuration.md
new file mode 100644
index 0000000000000000000000000000000000000000..b834c6f6f7dea723a32a1b8883f84f845f263742
--- /dev/null
+++ b/docs/developer/git-installation&configuration.md
@@ -0,0 +1,153 @@
+---
+title: Install & Configure Git on Windows
+summary: Explains how to download, install & configure Git.
+authors:
+    - Alfin Johny
+date: 2024-12-05
+---
+
+# Install & Configure Git on Windows
+
+### Download & Install Git
+
+To begin, download and install Git for Windows from the official [Git website](https://git-scm.com/download/win). You will be provided with an installer file that has a `.exe` extension. Locate the downloaded file in your `Downloads` folder and double-click it to start the installation process. Follow the prompts in the installation wizard. While most of the default options are suitable, make sure you select **Git from the command line and also from 3rd-party software**, so Git is accessible from your terminal/command prompt. Once installed, Git will be added to the System Environment Path variable, making it accessible globally.
+
+After installation, open the Git terminal and verify the installation by typing the following command:
+
+```bash
+git --version
+```
+
+This should return the installed version of Git, confirming that Git is set up correctly.
+
+---
+
+### Configure Git
+
+Once Git is installed, configure your user name and email, which will be associated with your commits. Run the following commands in the terminal to set these configurations:
+
+```bash
+git config --global user.name "Your Name"
+git config --global user.email "your.email@example.com"
+git config --list  # Check if the configuration was successful
+```
+
+This setup ensures that your commits are correctly attributed to your identity.
+
+Now you're ready to start using Git for version control!
+
+---
+
+### SSH Configuration for GitLab
+
+To securely connect with the UNICADO project hosted on GitLab and access its repositories, you'll need to set up SSH keys. Follow the steps below to generate a new SSH key pair, configure an SSH agent, create an SSH config file (optional), and test the SSH connection.
+
+Before starting, ensure that you have read access to the UNICADO project. Access must be granted by the project administrators. Once you have been added as a member, you can proceed with the following steps to configure SSH.
+
+---
+
+#### Step 1: Generate an SSH Key Pair
+
+Open a terminal (or Git Bash on Windows) and run the following command to generate a new SSH key pair. Replace the email with the one associated with your GitLab account:
+
+```bash
+ssh-keygen -t ed25519 -C "your.email@example.com"
+```
+
+- `-t ed25519`: Specifies the key type. ED25519 is the recommended key type for SSH.
+- `-C "your.email@example.com"`: Adds a comment (usually your email) to the key.
+
+When prompted, press Enter to save the key to the default location (`C:\Users\YourName.ssh\id_ed25519` on Windows). You can also specify a different file name or path if desired. Optionally, set a passphrase for extra security (recommended but not required).
+
+---
+
+#### Step 2: Create an SSH Config File (Optional but Recommended)
+
+If you use multiple SSH keys (for different services like GitHub, GitLab, etc.), it's a good idea to create an SSH config file for easier management.
+
+Start by setting `vim` as the default editor for Git (if you haven't already) by running:
+
+```bash
+git config --global core.editor "vim"
+```
+
+Now, open or create the SSH config file using `vim`:
+
+```bash
+vim ~/.ssh/config
+```
+
+If the file doesn’t exist, `vim` will create it. Press `i` to enter insert mode and add the following configuration:
+
+```bash
+Host gitlab.com
+    User git
+    HostName gitlab.com
+    PreferredAuthentications publickey
+    IdentityFile ~/.ssh/id_ed25519
+```
+
+- `Host`: An alias for the connection (use `gitlab.com` to match the GitLab domain).
+- `User`: The SSH user for GitLab (`git`).
+- `HostName`: The GitLab domain (`gitlab.com`).
+- `PreferredAuthentications`: Specifies that public key authentication should be used.
+- `IdentityFile`: The path to your private SSH key (default is `~/.ssh/id_ed25519`).
+
+After adding the configuration, press `Esc` to exit insert mode. Type `:wq` (write and quit) and press Enter to save and exit.
+
+---
+
+#### Step 3: Add SSH Key to SSH Agent
+
+The SSH agent manages your private keys, so you won’t need to enter your passphrase every time you interact with GitLab. Start the SSH agent by running:
+
+```bash
+eval "$(ssh-agent -s)"
+```
+
+On Windows (using Git Bash), the SSH agent may be automatically set up. Add your private key to the agent:
+
+```bash
+ssh-add ~/.ssh/id_ed25519
+```
+
+If you used a different name or location for your key (e.g., `id_rsa_gitlab`), adjust the path accordingly:
+
+```bash
+ssh-add ~/.ssh/id_rsa_gitlab
+```
+
+---
+
+#### Step 4: Add SSH Key to GitLab
+
+GitLab uses SSH to authenticate your identity when interacting with repositories. To set up SSH authentication, you'll need to add the public key to your GitLab account.
+
+First, copy the public key to your clipboard. On Windows (with Git Bash), use the following command to display the public key:
+
+```bash
+cat ~/.ssh/id_ed25519.pub
+```
+
+Next, log in to your GitLab account and navigate to your **Profile Settings**. In the left sidebar, select **SSH Keys**, paste the public key into the **Key** field, and optionally provide a title (e.g., "My Laptop"). Click **Add key** to save it.
+
+---
+
+#### Step 5: Test the SSH Connection
+
+Test whether your SSH key is set up correctly by running the following command:
+
+```bash
+ssh -T git@git.rwth-aachen.de
+```
+
+If the key is set up properly, the output should say:
+
+```
+Welcome to GitLab, @yourusername!
+```
+
+If it’s your first time connecting, GitLab may ask you to confirm the authenticity of the host. Type `yes` to proceed.
+
+By following these steps, you’ve successfully configured SSH for GitLab. You can now securely interact with GitLab repositories over SSH, enabling you to clone, push, and pull using your private key. For a more detailed explanation of the steps mentioned above, watch the [Git_Installation&Configuration](../assets/videos/Git_Installation&Configuration.mp4) video.
+
diff --git a/docs/developer/merge-request.md b/docs/developer/merge-request.md
index 9d0a86081aef3181f090b717c322ce65c7d0ac70..8b2038653d9bed6806a2fadab338dc54674ec16e 100644
--- a/docs/developer/merge-request.md
+++ b/docs/developer/merge-request.md
@@ -11,7 +11,7 @@ date: 2024-09-25
 You have already implemented an improvement to the current code base or intend to? Awesome 😎
 Here are some instructions, on how to to that:
 
-- First, make sure you have read the basics of how to contribute
+- First, make sure you have read [How to contribute to UNICADO](../developer/contribute.md)
 - Read the following instructions:
 
 There are several ways to create a merge request within GitLab, which are explained in detail in the [official GitLab docs](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html).
@@ -21,50 +21,95 @@ However, we will highlight the workflow, we prefer - but feel free to make your
 ## Preferred merge request workflow
 This is the first and preferred way to make a merge request, as it is similar to our previous UNICADO workflow. 
 
-Let's assume you have your own (local) feature branch, where you are developing a new feature. And let's further assume, you have forked this branch from the current main or develop branch. If not, you can do it now:
+Let's assume you have cloned the Unicado Package repoistory and updated all it's submodules following [Get Source Code](get-source-code.md ). Go to the sub module where you want to make the change. Create your own (local) feature branch, where you are developing a new feature.
 
-``` { .sh .copy }
-git checkout develop
-git pull origin develop
-git checkout -b <new-branch-name>
+### 1. Create a New Branch
+
+Create a new branch from `main` to work on your feature or bug fix. The `main` branch contains the stable version of the code and ‘main’ is the default branch (i.e., the branch you check out when cloning the repository). Developers are not allowed to push directly to this branch. All changes must go through the ‘feature’ branch and a merge request process.
+
+```bash
+git checkout -b <new-branch-name>  # Create a new branch
 ```
+Where <new-branch-name> is the branch where developers work on new features or bug fixes. Each developer creates their own feature branch from the `main` branch. After completing changes on a feature branch, a Merge Request (MR) is created to merge the changes into the `main` branch. Once the MR is reviewed and approved, it gets merged into `main`.
+
+Make sure your branch name follows this convention: `feature/your-feature`, `bugfix/your-bugfix`, or `documentation/your_documentation`. This ensures your branch can be pushed successfully. 
 
-*(Of course you can also perform the git operations via your tool of choice, e.g. VSCode)*
+### 2. Make Changes
 
-If you are working on this branch locally, and it is not shared with remote ☁️, then you have to push it ⏫ to remote, first in order to create a merge request. You can do that as simple as:
+Modify the submodule files as needed.
 
-``` { .sh .copy }
-git push origin <new-branch-name>
+### 3. Stage and Commit Your Changes
+
+After making your changes, stage them using the `git add` command:
+
+```bash
+git add .  # Stage all modified files
 ```
 
-On the gitlab page of the repository in the left sidebar select **Code > Merge request** and select **New merge request**
+Next, commit your changes with a meaningful commit message:
 
-- For **Source branch** select your branch `<new-branch-name>`
-- For **Target branch** select in this case `develop`
-- Select **Compare branches and continue**
-- Fill out the description (check out the [commit rules](#commitrules) beforehand!)
-- Enter a **Reviewer**
-- Add labels
-- **Create merge request**
+```bash
+git commit -m "Description of the changes made"
+```
+#### Guidelines for a Good Commit Message 
 
-!!! note 
-    Choose to delete the remote branch after merge, to keep remote clean
+- **Title**: A short description of what the commit does (use present tense).
+- **Body**: Explain why and how the change was made. Include any relevant details, such as specific files changed or issues addressed. Should be clear and concise. Use **English** language.
+- **Reference**: Mention related issues or tickets (if applicable). Use the `#` to close and refer to issues.
+
+Before committing, ensure that your code is working as expected by running local tests (such as static code analysis) and avoid committing code that is not functioning properly.
+
+### 4. Push Your Changes to GitLab
+
+Once your changes are committed, push them to the remote GitLab repository:
+
+```bash
+git push origin <new-branch-name>  # Push your changes to the remote repository
+```
+If you are working on this branch locally, and it is not shared with remote ☁️, then you have to push it ⏫ to remote, first in order to create a merge request. 
 
-!!! note 
-    Choose squash as merge strategy, to keep the git history streamlined
+### 5. Create a Merge Request (MR)
 
+After pushing your branch, GitLab will often suggest creating a Merge Request (MR). To create an MR:
 
-Then you have to wait for the **Merge request pipeline** to pass ✅ (and hopefully not fail🤞) and for the **reviewer** to approve 👍 the request. In case you need to commit adaptions, check the [commit rules](#commitrules) again!
+1. Navigate to your project in GitLab, and GitLab will prompt you to create an MR.
+2. Select your feature branch as the source branch and `main` as the destination branch.
+3. Click "Create Merge Request."
+4. In the MR description, provide additional context regarding the changes made.
+5. Add reviewers (team members who will review your code).
+6. You will receive email notifications about the MR status and any reviewer comments. Make any necessary changes, and push those updates to the remote repository.
 
-Afterwards on the page of the merge request, you can click on **merge**. Then your feature branch will be automatically merged into the remote branch of `develop` (in this example).
+### 6. Review, Approval, and Merging
+
+Then you have to wait for the **Merge request pipeline** to pass ✅ (and hopefully not fail🤞) and for the **reviewer** to approve 👍 the request. In case you need to commit adaptions, check the [Guidelines for a Good Commit Message](#guidelines-for-a-good-commit-message) again! Afterwards on the page of the merge request, you can click on **merge**. Then your feature branch will be automatically merged into `main` (in this example).
+```
+📝 As a reviewer, don't close the merge request. It will be closed automatically, when the merge is completed.
+
+📝 Choose squash as merge strategy, to keep the git history streamlined
+
+```
+### 7. Clean Up After the Merge
+
+Once the MR is merged, it’s common practice to delete the feature branch to keep the repository clean and free from unnecessary branches. GitLab provides an option to automatically delete the source branch after the merge. You can select "Remove source branch" during the merge process, and GitLab will delete the branch for you.
+
+Additionally, you can close the related issue, which should have been resolved by the MR.
+
+By following these steps, you ensure that your contributions are properly tracked, reviewed, and merged with minimal disruption to the project.
+```
+📝 You can also perform the git operations via your tool of choice, e.g. VSCode
+```
+The flowchart below illustrates the Merge Request workflow, along with the commands used at each stage.
 
-!!! note 
-    As a reviewer, **don't close** the merge request. It will be closed automatically, when the merge is completed.
+<style>
+  .center-img {
+    text-align: center;
+  }
+</style>
 
-## Commit rules and messages {#commitrules}
+<p class="center-img">
+  <img src="../../assets/images/MR_Worflow.png" alt="Merge Request Workflow" width="600" />
+  <br>
+  <i>Merge Request Workflow</i>
+</p>
 
-- Commit messages should be clear and concise.
-- Use **English** language.
-- Use the `#` to close and refer to issues. 
-- Please use **present tense** to express what the commit does.
-- **Don't** commit code which you know is not working.
+For a more detailed explanation of the steps mentioned above, watch the [Merge Request Workflow](../assets/videos/Merge_Request_Workflow.mp4) video.
\ No newline at end of file