---
title: "How to merge a local branch to main"
slug: "how-to-merge-a-local-branch-to-main"
description: "Click here and learn how to merge a local development branch to main."
updated: 2023-09-27T19:22:08Z
published: 2023-09-27T19:22:08Z
canonical: "learn.allspice.io/how-to-merge-a-local-branch-to-main"
---

> ## Documentation Index
> Fetch the complete documentation index at: https://learn.allspice.io/llms.txt
> Use this file to discover all available pages before exploring further.

# How to merge a local branch to main

## Background

          TLDR

          

[Jump to solution](/v1/docs/how-to-merge-a-local-branch-to-main#merging-a-local-branch-to-main)

Merging a local `dev` branch directly into `main` without creating a pull request might not be the standard practice in team-based or open-source projects. However, there are scenarios where this can make sense. Here are five reasons:

1. **Extremely large merges**: Often when migrating repositories, users will want to merge development branches into the main branch. Due to the large size, you may want to merge locally. This can benefit file transfer, as well as avoid server timeouts.
2. **Simple Projects & Solo Development**: If someone is working on a personal project or a simple project where they are the only developer, there might not be a need for the formal process of a pull request. Directly merging the `dev` branch into `main` can streamline the development process.
3. **Rapid Iteration & Testing**: In situations where rapid changes are necessary, such as bug fixes during a live event or during an urgent production issue, one might choose to merge changes directly to expedite the process, though this comes with its risks.
4. **Internal or Temporary Branches**: Sometimes developers create branches not for features or bug fixes but for experimental changes, trying out new ideas, or other internal purposes. When these changes are deemed stable and it's time to integrate them, the developer might choose to merge them directly, especially if these branches weren't pushed to a remote repository.
5. **Limited or No Network Access**: If a developer is working in an environment with limited or no internet access and cannot easily push their branch and create a pull request through a remote platform (like GitHub or GitLab), they might choose to merge branches locally. Once network access is available again, they can push the updated `main` branch.

That said, for collaborative projects, especially with multiple team members, design reviews (pull requests) provide an opportunity for code review, discussion, and testing before changes are merged into the main branch. This process is valuable for ensuring code quality and project stability.

## Merging a local branch to main

[Embedded content](https://www.youtube.com/embed/slapzSSvlEY)

**1. Check your current branch** Before making any changes, always verify which branch you're on:

```
git branch
```

**2. Make sure your local branches are up to date** Fetch any updates from the remote repository:

```
git fetch origin
```

**3. Switch to the branch you want to merge into** Since you want to merge into the `main` branch, you first need to switch to it:

```
git checkout main
```

**4. Update the `main` branch** It's good practice to make sure your `main` branch has the latest updates from the remote repository:

```
git pull origin main
```

**5. Merge the `dev` branch into `main`** Now you can merge the `dev` branch into `main`:

```
git merge dev
```

If there are no merge conflicts, the branches will be merged successfully.

**6. If you encounter merge conflicts** Should there be any conflicts between the branches, Git will notify you. You'll then need to resolve these conflicts manually by editing the conflicting files. Look for lines marked with `<<<<<<<`, `=======`, and `>>>>>>>` to identify and resolve differences.

After resolving conflicts, mark the files as resolved with:

```
git add <filename>
```

Then, continue with the merge by committing the changes:

```
git commit
```

**7. Push the updated `main` branch to the remote repository** Now that your local `main` branch has been updated, you'll want to reflect these changes in the remote repository:

```
git push origin main
```

**8. (Optional) Clean up** If you're done with the `dev` branch and it's been merged successfully, you might consider deleting it locally and/or on the remote:

*Delete locally:*

```
git branch -d dev
```

*Delete on the remote (be careful with this step, ensure that the branch is no longer needed):*

```
git push origin --delete dev
```

That's it! Your `dev` branch has now been merged into the `main` branch.