How does MergeBoard work?

MergeBoard can be easily integrated into almost any software development workflow. Once MergeBoard is configured, all you need to do is tell your team members to use MergeBoard to create and review merge requests in the future. You can continue to use all other functions of your code hosting platform as before.

In practice, the new workflow could look like this: After a team member pushes their changes to a feature branch, they open the project’s MergeBoard and create a merge request. Another member of your team (reviewer) will be notified and can take a look at it. Typically they either provide feedback or approve the merge request. If a merge request fulfills all requirements (enough approvals, CI passed, etc.) it can be merged into the target branch.

Technical Integration: In the background MergeBoard mimics the actions of someone manually merging two branches. MergeBoard fetches the changes from your source git repository, creates a merge commit and pushes it to the target git repository. In most cases the source and target repository (git remote) will be the same.

No, MergeBoard only handles the code review workflow and does not include any support for hosting git repositories. Our aim is to provide a great code review experience that you can integrate into your existing workflow, without forcing you to switch away from the tools you are used to. As minimum requirement you need to provide access to a git repository via network (e.g., via SSH, HTTP(S) or the git protocol).

Please note that your choice of git hosting service/software might also have influence on the available integration, e.g., issuetracker and CI integration is only available for a few git hosting services so far.

Yes, you can install and run MergeBoard on your own servers if you prefer. Nevertheless, we would like to emphasize that we make great efforts to secure your data on our SaaS instances. Our staff will never access the source code stored in your MergeBoard instance unless you grant us permission as part of a support ticket or we are required to do so by law. Another advantage of the SaaS version is that you do not have to take care of the setup and maintenance of the software yourself.

If you enable the InspecDiff mode in MergeBoard, the software parses your source code into an abstract syntax tree (AST). This tree contains all tokens from the source code in a structured way. For example, parsing if (a) { b(); } might create a tree similar to:

 [If Node]
  if ( [condition]  )  [statement]
            │          ┌────┴───┬────────┐
            a          { [Function Call] }
                              b ( )

MergeBoard parses the old and new version of the source code in this way and then compares the generated trees instead of the text representation. This immediately provides some advantages over traditional diff algorithms.

Many styling related changes are directly filtered out. The tree is the same regardless of whether you write if (a) { b(); } in a single line or split it up over multiple lines. The AST also makes it much easier to detect how the code has been modified, since we know the structure of the source code. MergeBoard can distinguish between a renamed function or variable. This allows us to implement some exciting features that would be very hard to replicate and more error prone when treating everything just as text.

MergeBoard also contains language-specific rules to hide certain changes that would not affect the program flow. For example, removing the curly brackets (i.e. if (a) b();) would not yield a change in the diff.

Yes, but also no. MergeBoard supports any number of upstream and downstream repositories, but there are some features missing yet to make the fork and pull model really usable. In order to create a merge request, the project owner or a maintainer would need to manually add the remote of the fork and either convince the fork author to setup a webhook or pull the changes manually whenever the repo is updated. This can work if you have a small number of contributors but would alienate first time contributors.

We are aware of this issue and plan to resolve it in the near future. We haven’t decided on a final solution yet, so if you are affected by this, drop us a mail. We would like to hear how you would imagine the collaboration with your contributors.

Feel free to schedule a call with us, we are happy to tell you more about our product! You can also visit our documentation at for more details.

Which features does MergeBoard support?

The basic diff functions are available for all text files and even some image formats. The more advanced features (InspecDiff) are available for the following languages:

  • Fully supported: C++ C CSS3 Go JavaScript JSON Lua Python Rust SCSS TypeScript
  • Beta support: HTML Java Latex Vue.js
  • Coming soon: Bash C# Common Lisp CUDA DOT Elm Emacs Lisp ERB / EJS Fennel GLSL (OpenGL Shading Language) HCL Make Markdown OCaml PHP R Ruby SPARQL Svelte SystemRDL TOML Turtle Verilog VHDL WASM WGSL WebGPU Shading Language YAML Agda Dockerfile Erlang Go mod Hack Haskell Julia Kotlin Nix Objective-C Perl Scala Sourcepawn SQL Swift

Your language is labelled as “Coming soon” or you don’t see it at all? Contact us and we will figure something out.

MergeBoard can interact with any git hosting service that provides network access to the repository via SSH, HTTP(S) or the Git protocol. MergeBoard supports authentication via SSH key or username/password. Please note that this only ensures that you can fetch changes and merge them. Further integrations (CI, issue tracker, etc.) are only supported for certain hosters.

If you are looking for the best overall integration, you might want to check out GitLab or GitHub. We will extend our integrations based on user feedback, so please contact us if you think MergeBoard could be enhanced by adding support for a third-party software.

We currently support GitLab, GitHub and Bugzilla. We plan to extend this list based on user feedback, so please contact us if your issue tracker is not yet supported.

The basic concepts of CI and the MergeBoard scanners are very similar. Both execute tools on the source code in a sandboxed environment and their results affect whether a merge request can be merged. The main difference is that scanners do not just return a success or failure state, but instead create change requests for any issues found.

These requests can then either be resolved by altering the code or they can be marked as false positive or intentional. MergeBoard only takes scan results into account that were introduced by the source code changes and ignores those that were already present. This makes scanners the optimal candidate for static code analyzers with a small number of false positives or if you want to enforce new tools without fixing all the existing code.

Please note that MergeBoard does not implement it’s own CI and only supports the integration with external CIs. You can also not add your own scanners but are limited to ones implemented in MergeBoard.

We currently only support GitLab CIs, but plan to integrate further ones based on user feedback. Please contact us if your CI pipeline is not yet supported.


Yes, if you are a maintainer of an open source project, you and your contributors will be able to use MergeBoard Cloud free of charge! We are currently working on the last details to integrate MergeBoard into the workflow of open source projects. Feel free to contact us and tell us more about how you would like to use MergeBoard in your open source project.

You won’t be able to create new merge requests. Merge requests that are already open can still be worked on, e.g., you can comment on them, merge them, etc.

MergeBoard Cloud: In case you are using our SaaS product (MergeBoard Cloud), your instance will enter a grace period in which you will be able to renew your license. If this period expires as well and you didn’t buy a new license, your instance and all data associated with it will be permanently deleted.