diff --git a/src/GitReleaseManager.Cli/Program.cs b/src/GitReleaseManager.Cli/Program.cs
index fdc36e1a..dc44e89c 100644
--- a/src/GitReleaseManager.Cli/Program.cs
+++ b/src/GitReleaseManager.Cli/Program.cs
@@ -8,11 +8,13 @@
 using GitReleaseManager.Core.Commands;
 using GitReleaseManager.Core.Configuration;
 using GitReleaseManager.Core.Helpers;
+using GitReleaseManager.Core.Model;
 using GitReleaseManager.Core.Options;
 using GitReleaseManager.Core.Provider;
 using GitReleaseManager.Core.ReleaseNotes;
 using GitReleaseManager.Core.Templates;
 using Microsoft.Extensions.DependencyInjection;
+using NGitLab;
 using Octokit;
 using Serilog;
 
@@ -96,7 +98,6 @@ private static void RegisterServices(BaseSubOptions options)
                 .AddSingleton<IFileSystem>(fileSystem)
                 .AddSingleton<IReleaseNotesExporter, ReleaseNotesExporter>()
                 .AddSingleton<IReleaseNotesBuilder, ReleaseNotesBuilder>()
-                .AddSingleton<IVcsProvider, GitHubProvider>()
                 .AddSingleton<IVcsService, VcsService>();
 
             if (options is BaseVcsOptions vcsOptions)
@@ -106,9 +107,7 @@ private static void RegisterServices(BaseSubOptions options)
                     throw new Exception("The token option is not defined");
                 }
 
-                var gitHubClient = new GitHubClient(new ProductHeaderValue("GitReleaseManager")) { Credentials = new Credentials(vcsOptions.Token) };
-                serviceCollection = serviceCollection
-                    .AddSingleton<IGitHubClient>(gitHubClient);
+                RegisterVcsProvider(vcsOptions, serviceCollection);
             }
 
             serviceCollection = serviceCollection
@@ -197,5 +196,23 @@ private static Task<int> ExecuteCommand<TOptions>(TOptions options)
 
         private static void LogOptions(BaseSubOptions options)
             => Log.Debug("{@Options}", options);
+
+        private static void RegisterVcsProvider(BaseVcsOptions vcsOptions, IServiceCollection serviceCollection)
+        {
+            Log.Information("Using {Provider} as VCS Provider", vcsOptions.Provider);
+            if (vcsOptions.Provider == VcsProvider.GitLab)
+            {
+                serviceCollection
+                    .AddSingleton<IGitLabClient>((_) => new GitLabClient("https://gitlab.com", vcsOptions.Token))
+                    .AddSingleton<IVcsProvider, GitLabProvider>();
+            }
+            else
+            {
+                // default to Github
+                serviceCollection
+                    .AddSingleton<IGitHubClient>((_) => new GitHubClient(new ProductHeaderValue("GitReleaseManager")) { Credentials = new Credentials(vcsOptions.Token) })
+                    .AddSingleton<IVcsProvider, GitHubProvider>();
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/src/GitReleaseManager.Core.Tests/Provider/GitHubProviderTests.cs b/src/GitReleaseManager.Core.Tests/Provider/GitHubProviderTests.cs
index 501300cf..a9e1c563 100644
--- a/src/GitReleaseManager.Core.Tests/Provider/GitHubProviderTests.cs
+++ b/src/GitReleaseManager.Core.Tests/Provider/GitHubProviderTests.cs
@@ -20,6 +20,7 @@
 using NotFoundException = GitReleaseManager.Core.Exceptions.NotFoundException;
 using RateLimit = GitReleaseManager.Core.Model.RateLimit;
 using Release = GitReleaseManager.Core.Model.Release;
+using ReleaseAsset= GitReleaseManager.Core.Model.ReleaseAsset;
 using ReleaseAssetUpload = GitReleaseManager.Core.Model.ReleaseAssetUpload;
 
 namespace GitReleaseManager.Core.Tests.Provider
@@ -31,7 +32,8 @@ public class GitHubProviderTests
         private const string REPOSITORY = "repository";
         private const string BASE = "0.1.0";
         private const string HEAD = "0.5.0";
-        private const int MILESTONE_NUMBER = 1;
+        private const int MILESTONE_PUBLIC_NUMBER = 1;
+        private const int MILESTONE_INTERNAL_NUMBER = 123;
         private const string MILESTONE_NUMBER_STRING = "1";
         private const string MILESTONE_TITLE = "0.1.0";
         private const int ISSUE_NUMBER = 1;
@@ -43,7 +45,11 @@ public class GitHubProviderTests
         private const string NOT_FOUND_MESSAGE = "NotFound";
         private const bool SKIP_PRERELEASES = false;
 
-        private readonly Release _release = new Release();
+        private readonly Release _release = new Release { Id = RELEASE_ID };
+        private readonly Issue _issue = new Issue { PublicNumber = ISSUE_NUMBER };
+        private readonly Milestone _milestone = new Milestone { PublicNumber = MILESTONE_PUBLIC_NUMBER, InternalNumber = MILESTONE_INTERNAL_NUMBER };
+        private readonly Label _label = new Label { Name = LABEL_NAME };
+        private readonly ReleaseAsset _asset = new ReleaseAsset { Id = ASSET_ID };
         private readonly ReleaseAssetUpload _releaseAssetUpload = new ReleaseAssetUpload();
         private readonly Octokit.NewLabel _newLabel = new Octokit.NewLabel(LABEL_NAME, "ffffff");
         private readonly Octokit.NewRelease _newRelease = new Octokit.NewRelease(TAG_NAME);
@@ -69,7 +75,7 @@ public async Task Should_Delete_Asset()
             _gitHubClient.Repository.Release.DeleteAsset(OWNER, REPOSITORY, ASSET_ID)
                 .Returns(Task.FromResult);
 
-            await _gitHubProvider.DeleteAssetAsync(OWNER, REPOSITORY, ASSET_ID).ConfigureAwait(false);
+            await _gitHubProvider.DeleteAssetAsync(OWNER, REPOSITORY, _asset).ConfigureAwait(false);
 
             await _gitHubClient.Repository.Release.Received(1).DeleteAsset(OWNER, REPOSITORY, ASSET_ID).ConfigureAwait(false);
         }
@@ -80,7 +86,7 @@ public async Task Should_Throw_An_Exception_On_Deleting_Asset_For_Non_Existing_I
             _gitHubClient.Repository.Release.DeleteAsset(OWNER, REPOSITORY, ASSET_ID)
                 .Returns(Task.FromException(_notFoundException));
 
-            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.DeleteAssetAsync(OWNER, REPOSITORY, ASSET_ID)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.DeleteAssetAsync(OWNER, REPOSITORY, _asset)).ConfigureAwait(false);
             ex.Message.ShouldBe(_notFoundException.Message);
             ex.InnerException.ShouldBe(_notFoundException);
         }
@@ -91,7 +97,7 @@ public async Task Should_Throw_An_Exception_On_Deleting_Asset()
             _gitHubClient.Repository.Release.DeleteAsset(OWNER, REPOSITORY, ASSET_ID)
                 .Returns(Task.FromException(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.DeleteAssetAsync(OWNER, REPOSITORY, ASSET_ID)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.DeleteAssetAsync(OWNER, REPOSITORY, _asset)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
@@ -230,7 +236,7 @@ public async Task Should_Create_Issue_Comment()
             _gitHubClient.Issue.Comment.Create(OWNER, REPOSITORY, ISSUE_NUMBER, ISSUE_COMMENT)
                 .Returns(Task.FromResult(new Octokit.IssueComment()));
 
-            await _gitHubProvider.CreateIssueCommentAsync(OWNER, REPOSITORY, ISSUE_NUMBER, ISSUE_COMMENT).ConfigureAwait(false);
+            await _gitHubProvider.CreateIssueCommentAsync(OWNER, REPOSITORY, _issue, ISSUE_COMMENT).ConfigureAwait(false);
 
             await _gitHubClient.Issue.Comment.Received(1).Create(OWNER, REPOSITORY, ISSUE_NUMBER, ISSUE_COMMENT).ConfigureAwait(false);
         }
@@ -241,7 +247,7 @@ public async Task Should_Throw_An_Exception_On_Creating_Issue_Comment_For_Non_Ex
             _gitHubClient.Issue.Comment.Create(OWNER, REPOSITORY, ISSUE_NUMBER, ISSUE_COMMENT)
                 .Returns(Task.FromException<Octokit.IssueComment>(_notFoundException));
 
-            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.CreateIssueCommentAsync(OWNER, REPOSITORY, ISSUE_NUMBER, ISSUE_COMMENT)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.CreateIssueCommentAsync(OWNER, REPOSITORY, _issue, ISSUE_COMMENT)).ConfigureAwait(false);
             ex.Message.ShouldBe(_notFoundException.Message);
             ex.InnerException.ShouldBe(_notFoundException);
         }
@@ -252,7 +258,7 @@ public async Task Should_Throw_An_Exception_On_Creating_Issue_Comment()
             _gitHubClient.Issue.Comment.Create(OWNER, REPOSITORY, ISSUE_NUMBER, ISSUE_COMMENT)
                 .Returns(Task.FromException<Octokit.IssueComment>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.CreateIssueCommentAsync(OWNER, REPOSITORY, ISSUE_NUMBER, ISSUE_COMMENT)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.CreateIssueCommentAsync(OWNER, REPOSITORY, _issue, ISSUE_COMMENT)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
@@ -270,7 +276,7 @@ public async Task Should_Get_Issues_For_Milestone(ItemStateFilter itemStateFilte
             _mapper.Map<IEnumerable<Issue>>(Arg.Any<object>())
                 .Returns(issues);
 
-            var result = await _gitHubProvider.GetIssuesAsync(OWNER, REPOSITORY, MILESTONE_NUMBER, itemStateFilter).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetIssuesAsync(OWNER, REPOSITORY, _milestone, itemStateFilter).ConfigureAwait(false);
             result.ShouldBeSameAs(issues);
 
             await _gitHubClient.Issue.Received(1).GetAllForRepository(
@@ -288,7 +294,7 @@ public async Task Should_Throw_An_Exception_On_Getting_Issues_For_Non_Existent_M
             _gitHubClient.Issue.GetAllForRepository(OWNER, REPOSITORY, Arg.Any<RepositoryIssueRequest>(), Arg.Any<ApiOptions>())
                 .Returns(Task.FromException<IReadOnlyList<Octokit.Issue>>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.GetIssuesAsync(OWNER, REPOSITORY, 1)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.GetIssuesAsync(OWNER, REPOSITORY, _milestone)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
@@ -304,7 +310,7 @@ public async Task Should_Get_Issue_Comments()
             _mapper.Map<IEnumerable<IssueComment>>(Arg.Any<object>())
                 .Returns(comments);
 
-            var result = await _gitHubProvider.GetIssueCommentsAsync(OWNER, REPOSITORY, ISSUE_NUMBER).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetIssueCommentsAsync(OWNER, REPOSITORY, _issue).ConfigureAwait(false);
             result.ShouldBeSameAs(comments);
 
             await _gitHubClient.Issue.Comment.Received(1).GetAllForIssue(OWNER, REPOSITORY, ISSUE_NUMBER, Arg.Any<ApiOptions>()).ConfigureAwait(false);
@@ -317,7 +323,7 @@ public async Task Should_Throw_An_Exception_On_Getting_Issue_Comments_For_Non_Ex
             _gitHubClient.Issue.Comment.GetAllForIssue(OWNER, REPOSITORY, ISSUE_NUMBER, Arg.Any<ApiOptions>())
                 .Returns(Task.FromException<IReadOnlyList<Octokit.IssueComment>>(_notFoundException));
 
-            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.GetIssueCommentsAsync(OWNER, REPOSITORY, ISSUE_NUMBER)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.GetIssueCommentsAsync(OWNER, REPOSITORY, _issue)).ConfigureAwait(false);
             ex.Message.ShouldBe(_notFoundException.Message);
             ex.InnerException.ShouldBe(_notFoundException);
         }
@@ -328,7 +334,7 @@ public async Task Should_Throw_An_Exception_On_Getting_Issue_Comments()
             _gitHubClient.Issue.Comment.GetAllForIssue(OWNER, REPOSITORY, ISSUE_NUMBER, Arg.Any<ApiOptions>())
                 .Returns(Task.FromException<IReadOnlyList<Octokit.IssueComment>>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.GetIssueCommentsAsync(OWNER, REPOSITORY, ISSUE_NUMBER)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.GetIssueCommentsAsync(OWNER, REPOSITORY, _issue)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
@@ -371,7 +377,7 @@ public async Task Should_Delete_Label()
             _gitHubClient.Issue.Labels.Delete(OWNER, REPOSITORY, LABEL_NAME)
                 .Returns(Task.FromResult);
 
-            await _gitHubProvider.DeleteLabelAsync(OWNER, REPOSITORY, LABEL_NAME).ConfigureAwait(false);
+            await _gitHubProvider.DeleteLabelAsync(OWNER, REPOSITORY, _label).ConfigureAwait(false);
 
             await _gitHubClient.Issue.Labels.Received(1).Delete(OWNER, REPOSITORY, LABEL_NAME).ConfigureAwait(false);
         }
@@ -382,7 +388,7 @@ public async Task Should_Throw_An_Exception_On_Deleting_Label_For_Non_Existing_L
             _gitHubClient.Issue.Labels.Delete(OWNER, REPOSITORY, LABEL_NAME)
                 .Returns(Task.FromException<IReadOnlyList<Octokit.Label>>(_notFoundException));
 
-            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.DeleteLabelAsync(OWNER, REPOSITORY, LABEL_NAME)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.DeleteLabelAsync(OWNER, REPOSITORY, _label)).ConfigureAwait(false);
             ex.Message.ShouldBe(_notFoundException.Message);
             ex.InnerException.ShouldBe(_notFoundException);
         }
@@ -393,7 +399,7 @@ public async Task Should_Throw_An_Exception_On_Deleting_Label()
             _gitHubClient.Issue.Labels.Delete(OWNER, REPOSITORY, LABEL_NAME)
                 .Returns(Task.FromException<IReadOnlyList<Octokit.Label>>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.DeleteLabelAsync(OWNER, REPOSITORY, LABEL_NAME)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.DeleteLabelAsync(OWNER, REPOSITORY, _label)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
@@ -508,21 +514,21 @@ public async Task Should_Throw_An_Exception_On_Getting_Milestones()
         [TestCase(ItemState.Open)]
         public async Task Should_Set_Milestone_State(ItemState itemState)
         {
-            _gitHubClient.Issue.Milestone.Update(OWNER, REPOSITORY, MILESTONE_NUMBER, Arg.Any<MilestoneUpdate>())
+            _gitHubClient.Issue.Milestone.Update(OWNER, REPOSITORY, MILESTONE_PUBLIC_NUMBER, Arg.Any<MilestoneUpdate>())
                 .Returns(Task.FromResult(new Octokit.Milestone()));
 
-            await _gitHubProvider.SetMilestoneStateAsync(OWNER, REPOSITORY, MILESTONE_NUMBER, itemState).ConfigureAwait(false);
+            await _gitHubProvider.SetMilestoneStateAsync(OWNER, REPOSITORY, _milestone, itemState).ConfigureAwait(false);
 
-            await _gitHubClient.Issue.Milestone.Received(1).Update(OWNER, REPOSITORY, MILESTONE_NUMBER, Arg.Is<MilestoneUpdate>(o => o.State == (Octokit.ItemState)itemState)).ConfigureAwait(false);
+            await _gitHubClient.Issue.Milestone.Received(1).Update(OWNER, REPOSITORY, MILESTONE_PUBLIC_NUMBER, Arg.Is<MilestoneUpdate>(o => o.State == (Octokit.ItemState)itemState)).ConfigureAwait(false);
         }
 
         [Test]
         public async Task Should_Throw_An_Exception_On_Setting_Milestone_State_For_Non_Existent_Number()
         {
-            _gitHubClient.Issue.Milestone.Update(OWNER, REPOSITORY, MILESTONE_NUMBER, Arg.Any<MilestoneUpdate>())
+            _gitHubClient.Issue.Milestone.Update(OWNER, REPOSITORY, MILESTONE_PUBLIC_NUMBER, Arg.Any<MilestoneUpdate>())
                 .Returns(Task.FromException<Octokit.Milestone>(_notFoundException));
 
-            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.SetMilestoneStateAsync(OWNER, REPOSITORY, MILESTONE_NUMBER, ItemState.Closed)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.SetMilestoneStateAsync(OWNER, REPOSITORY, _milestone, ItemState.Closed)).ConfigureAwait(false);
             ex.Message.ShouldBe(_notFoundException.Message);
             ex.InnerException.ShouldBeSameAs(_notFoundException);
         }
@@ -530,10 +536,10 @@ public async Task Should_Throw_An_Exception_On_Setting_Milestone_State_For_Non_E
         [Test]
         public async Task Should_Throw_An_Exception_On_Setting_Milestone_State()
         {
-            _gitHubClient.Issue.Milestone.Update(OWNER, REPOSITORY, MILESTONE_NUMBER, Arg.Any<MilestoneUpdate>())
+            _gitHubClient.Issue.Milestone.Update(OWNER, REPOSITORY, MILESTONE_PUBLIC_NUMBER, Arg.Any<MilestoneUpdate>())
                 .Returns(Task.FromException<Octokit.Milestone>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.SetMilestoneStateAsync(OWNER, REPOSITORY, MILESTONE_NUMBER, ItemState.Closed)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.SetMilestoneStateAsync(OWNER, REPOSITORY, _milestone, ItemState.Closed)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBeSameAs(_exception);
         }
@@ -581,25 +587,21 @@ public async Task Should_Throw_An_Exception_On_Creating_Release()
         [Test]
         public async Task Should_Delete_Release()
         {
-            var id = 1;
-
-            _gitHubClient.Repository.Release.Delete(OWNER, REPOSITORY, id)
+            _gitHubClient.Repository.Release.Delete(OWNER, REPOSITORY, RELEASE_ID)
                 .Returns(Task.CompletedTask);
 
-            await _gitHubProvider.DeleteReleaseAsync(OWNER, REPOSITORY, id).ConfigureAwait(false);
+            await _gitHubProvider.DeleteReleaseAsync(OWNER, REPOSITORY, _release).ConfigureAwait(false);
 
-            await _gitHubClient.Repository.Release.Received(1).Delete(OWNER, REPOSITORY, id).ConfigureAwait(false);
+            await _gitHubClient.Repository.Release.Received(1).Delete(OWNER, REPOSITORY, RELEASE_ID).ConfigureAwait(false);
         }
 
         [Test]
         public async Task Should_Throw_An_Exception_On_Deleting_Release_For_Non_Existent_Id()
         {
-            var id = 1;
-
-            _gitHubClient.Repository.Release.Delete(OWNER, REPOSITORY, id)
+            _gitHubClient.Repository.Release.Delete(OWNER, REPOSITORY, RELEASE_ID)
                 .Returns(Task.FromException(_notFoundException));
 
-            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.DeleteReleaseAsync(OWNER, REPOSITORY, id)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.DeleteReleaseAsync(OWNER, REPOSITORY, _release)).ConfigureAwait(false);
             ex.Message.ShouldBe(_notFoundException.Message);
             ex.InnerException.ShouldBeSameAs(_notFoundException);
         }
@@ -607,12 +609,10 @@ public async Task Should_Throw_An_Exception_On_Deleting_Release_For_Non_Existent
         [Test]
         public async Task Should_Throw_An_Exception_On_Deleting_Release()
         {
-            var id = 1;
-
-            _gitHubClient.Repository.Release.Delete(OWNER, REPOSITORY, id)
+            _gitHubClient.Repository.Release.Delete(OWNER, REPOSITORY, RELEASE_ID)
                 .Returns(Task.FromException(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.DeleteReleaseAsync(OWNER, REPOSITORY, id)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.DeleteReleaseAsync(OWNER, REPOSITORY, _release)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBeSameAs(_exception);
         }
@@ -688,7 +688,7 @@ public async Task Should_Publish_Release()
             _gitHubClient.Repository.Release.Edit(OWNER, REPOSITORY, RELEASE_ID, Arg.Any<ReleaseUpdate>())
                 .Returns(Task.FromResult(new Octokit.Release()));
 
-            await _gitHubProvider.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, RELEASE_ID).ConfigureAwait(false);
+            await _gitHubProvider.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, _release).ConfigureAwait(false);
 
             await _gitHubClient.Repository.Release.Received(1).Edit(OWNER, REPOSITORY, RELEASE_ID, Arg.Is<ReleaseUpdate>(o =>
                 o.Draft == false &&
@@ -701,7 +701,7 @@ public async Task Should_Throw_An_Exception_On_Publishing_Release_For_Non_Existe
             _gitHubClient.Repository.Release.Edit(OWNER, REPOSITORY, RELEASE_ID, Arg.Any<ReleaseUpdate>())
                 .Returns(Task.FromException<Octokit.Release>(_notFoundException));
 
-            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, RELEASE_ID)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<NotFoundException>(() => _gitHubProvider.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, _release)).ConfigureAwait(false);
             ex.Message.ShouldBe(_notFoundException.Message);
             ex.InnerException.ShouldBe(_notFoundException);
         }
@@ -712,7 +712,7 @@ public async Task Should_Throw_An_Exception_On_Publishing_Release()
             _gitHubClient.Repository.Release.Edit(OWNER, REPOSITORY, RELEASE_ID, Arg.Any<ReleaseUpdate>())
                 .Returns(Task.FromException<Octokit.Release>(_exception));
 
-            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, RELEASE_ID)).ConfigureAwait(false);
+            var ex = await Should.ThrowAsync<ApiException>(() => _gitHubProvider.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, _release)).ConfigureAwait(false);
             ex.Message.ShouldBe(_exception.Message);
             ex.InnerException.ShouldBe(_exception);
         }
diff --git a/src/GitReleaseManager.Core.Tests/VcsServiceTests.cs b/src/GitReleaseManager.Core.Tests/VcsServiceTests.cs
index 8b3ebe96..86306af7 100644
--- a/src/GitReleaseManager.Core.Tests/VcsServiceTests.cs
+++ b/src/GitReleaseManager.Core.Tests/VcsServiceTests.cs
@@ -26,7 +26,8 @@ public class VcsServiceTests
     {
         private const string OWNER = "owner";
         private const string REPOSITORY = "repository";
-        private const int MILESTONE_NUMBER = 1;
+        private const int MILESTONE_PUBLIC_NUMBER = 1;
+        private const int MILESTONE_INTERNAL_NUMBER = 123;
         private const string MILESTONE_TITLE = "0.1.0";
         private const string TAG_NAME = "0.1.0";
         private const string RELEASE_NOTES = "Release Notes";
@@ -126,7 +127,7 @@ public async Task Should_Add_Assets()
             await _vcsService.AddAssetsAsync(OWNER, REPOSITORY, TAG_NAME, _assets).ConfigureAwait(false);
 
             await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
-            await _vcsProvider.DidNotReceive().DeleteAssetAsync(OWNER, REPOSITORY, Arg.Any<int>()).ConfigureAwait(false);
+            await _vcsProvider.DidNotReceive().DeleteAssetAsync(OWNER, REPOSITORY, Arg.Any<ReleaseAsset>()).ConfigureAwait(false);
             await _vcsProvider.Received(assetsCount).UploadAssetAsync(release, Arg.Any<ReleaseAssetUpload>()).ConfigureAwait(false);
 
             _logger.DidNotReceive().Warning(Arg.Any<string>(), Arg.Any<string>());
@@ -149,7 +150,7 @@ public async Task Should_Add_Assets_With_Deleting_Existing_Assets()
             await _vcsService.AddAssetsAsync(OWNER, REPOSITORY, TAG_NAME, _assets).ConfigureAwait(false);
 
             await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
-            await _vcsProvider.Received(releaseAssetsCount).DeleteAssetAsync(OWNER, REPOSITORY, releaseAsset.Id).ConfigureAwait(false);
+            await _vcsProvider.Received(releaseAssetsCount).DeleteAssetAsync(OWNER, REPOSITORY, releaseAsset).ConfigureAwait(false);
             await _vcsProvider.Received(assetsCount).UploadAssetAsync(release, Arg.Any<ReleaseAssetUpload>()).ConfigureAwait(false);
 
             _logger.Received(releaseAssetsCount).Warning(Arg.Any<string>(), Arg.Any<string>());
@@ -172,7 +173,7 @@ public async Task Should_Throw_Exception_On_Adding_Assets_When_Asset_File_Not_Ex
             ex.Message.ShouldContain(assetFilePath);
 
             await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
-            await _vcsProvider.DidNotReceive().DeleteAssetAsync(OWNER, REPOSITORY, Arg.Any<int>()).ConfigureAwait(false);
+            await _vcsProvider.DidNotReceive().DeleteAssetAsync(OWNER, REPOSITORY, Arg.Any<ReleaseAsset>()).ConfigureAwait(false);
             await _vcsProvider.DidNotReceive().UploadAssetAsync(release, Arg.Any<ReleaseAssetUpload>()).ConfigureAwait(false);
         }
 
@@ -182,7 +183,7 @@ public async Task Should_Do_Nothing_On_Missing_Assets(IList<string> assets)
             await _vcsService.AddAssetsAsync(OWNER, REPOSITORY, TAG_NAME, assets).ConfigureAwait(false);
 
             await _vcsProvider.DidNotReceive().GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
-            await _vcsProvider.DidNotReceive().DeleteAssetAsync(OWNER, REPOSITORY, Arg.Any<int>()).ConfigureAwait(false);
+            await _vcsProvider.DidNotReceive().DeleteAssetAsync(OWNER, REPOSITORY, Arg.Any<ReleaseAsset>()).ConfigureAwait(false);
             await _vcsProvider.DidNotReceive().UploadAssetAsync(Arg.Any<Release>(), Arg.Any<ReleaseAssetUpload>()).ConfigureAwait(false);
         }
 
@@ -205,7 +206,7 @@ public async Task Should_Create_Labels()
             _vcsProvider.GetLabelsAsync(OWNER, REPOSITORY)
                 .Returns(Task.FromResult((IEnumerable<Label>)labels));
 
-            _vcsProvider.DeleteLabelAsync(OWNER, REPOSITORY, Arg.Any<string>())
+            _vcsProvider.DeleteLabelAsync(OWNER, REPOSITORY, Arg.Any<Label>())
                 .Returns(Task.CompletedTask);
 
             _vcsProvider.CreateLabelAsync(OWNER, REPOSITORY, Arg.Any<Label>())
@@ -214,7 +215,7 @@ public async Task Should_Create_Labels()
             await _vcsService.CreateLabelsAsync(OWNER, REPOSITORY).ConfigureAwait(false);
 
             await _vcsProvider.Received(1).GetLabelsAsync(OWNER, REPOSITORY).ConfigureAwait(false);
-            await _vcsProvider.Received(labels.Count).DeleteLabelAsync(OWNER, REPOSITORY, Arg.Any<string>()).ConfigureAwait(false);
+            await _vcsProvider.Received(labels.Count).DeleteLabelAsync(OWNER, REPOSITORY, Arg.Any<Label>()).ConfigureAwait(false);
             await _vcsProvider.Received(_configuration.Labels.Count).CreateLabelAsync(OWNER, REPOSITORY, Arg.Any<Label>()).ConfigureAwait(false);
 
             _logger.Received(1).Verbose(Arg.Any<string>(), OWNER, REPOSITORY);
@@ -235,61 +236,65 @@ public async Task Should_Log_An_Warning_When_Labels_Not_Configured()
         [Test]
         public async Task Should_Close_Milestone()
         {
-            var milestone = new Milestone { Number = MILESTONE_NUMBER };
+            var milestone = new Milestone { PublicNumber = MILESTONE_PUBLIC_NUMBER, InternalNumber = MILESTONE_INTERNAL_NUMBER };
 
             _vcsProvider.GetMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ItemStateFilter.Open)
                 .Returns(Task.FromResult(milestone));
 
-            _vcsProvider.SetMilestoneStateAsync(OWNER, REPOSITORY, milestone.Number, ItemState.Closed)
+            _vcsProvider.SetMilestoneStateAsync(OWNER, REPOSITORY, milestone, ItemState.Closed)
                 .Returns(Task.CompletedTask);
 
             await _vcsService.CloseMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
 
             await _vcsProvider.Received(1).GetMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ItemStateFilter.Open).ConfigureAwait(false);
-            await _vcsProvider.Received(1).SetMilestoneStateAsync(OWNER, REPOSITORY, milestone.Number, ItemState.Closed).ConfigureAwait(false);
+            await _vcsProvider.Received(1).SetMilestoneStateAsync(OWNER, REPOSITORY, milestone, ItemState.Closed).ConfigureAwait(false);
         }
 
         [Test]
         public async Task Should_Log_An_Warning_On_Closing_When_Milestone_Cannot_Be_Found()
         {
+            var milestone = new Milestone { PublicNumber = MILESTONE_PUBLIC_NUMBER, InternalNumber = MILESTONE_INTERNAL_NUMBER };
+
             _vcsProvider.GetMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ItemStateFilter.Open)
                 .Returns(Task.FromException<Milestone>(_notFoundException));
 
             await _vcsService.CloseMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
 
             await _vcsProvider.Received(1).GetMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ItemStateFilter.Open).ConfigureAwait(false);
-            await _vcsProvider.DidNotReceive().SetMilestoneStateAsync(OWNER, REPOSITORY, MILESTONE_NUMBER, ItemState.Closed).ConfigureAwait(false);
+            await _vcsProvider.DidNotReceive().SetMilestoneStateAsync(OWNER, REPOSITORY, milestone, ItemState.Closed).ConfigureAwait(false);
             _logger.Received(1).Warning(UNABLE_TO_FOUND_MILESTONE_MESSAGE, "open", MILESTONE_TITLE, OWNER, REPOSITORY);
         }
 
         [Test]
         public async Task Should_Open_Milestone()
         {
-            var milestone = new Milestone { Number = MILESTONE_NUMBER };
+            var milestone = new Milestone { PublicNumber = MILESTONE_PUBLIC_NUMBER, InternalNumber = MILESTONE_INTERNAL_NUMBER };
 
             _vcsProvider.GetMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ItemStateFilter.Closed)
                 .Returns(Task.FromResult(milestone));
 
-            _vcsProvider.SetMilestoneStateAsync(OWNER, REPOSITORY, milestone.Number, ItemState.Open)
+            _vcsProvider.SetMilestoneStateAsync(OWNER, REPOSITORY, milestone, ItemState.Open)
                 .Returns(Task.CompletedTask);
 
             await _vcsService.OpenMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
 
             await _vcsProvider.Received(1).GetMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ItemStateFilter.Closed).ConfigureAwait(false);
-            await _vcsProvider.Received(1).SetMilestoneStateAsync(OWNER, REPOSITORY, milestone.Number, ItemState.Open).ConfigureAwait(false);
+            await _vcsProvider.Received(1).SetMilestoneStateAsync(OWNER, REPOSITORY, milestone, ItemState.Open).ConfigureAwait(false);
             _logger.Received(2).Verbose(Arg.Any<string>(), MILESTONE_TITLE, OWNER, REPOSITORY);
         }
 
         [Test]
         public async Task Should_Log_An_Warning_On_Opening_When_Milestone_Cannot_Be_Found()
         {
+            var milestone = new Milestone { PublicNumber = MILESTONE_PUBLIC_NUMBER, InternalNumber = MILESTONE_INTERNAL_NUMBER };
+
             _vcsProvider.GetMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ItemStateFilter.Closed)
                 .Returns(Task.FromException<Milestone>(_notFoundException));
 
             await _vcsService.OpenMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE).ConfigureAwait(false);
 
             await _vcsProvider.Received(1).GetMilestoneAsync(OWNER, REPOSITORY, MILESTONE_TITLE, ItemStateFilter.Closed).ConfigureAwait(false);
-            await _vcsProvider.DidNotReceive().SetMilestoneStateAsync(OWNER, REPOSITORY, MILESTONE_NUMBER, ItemState.Open).ConfigureAwait(false);
+            await _vcsProvider.DidNotReceive().SetMilestoneStateAsync(OWNER, REPOSITORY, milestone, ItemState.Open).ConfigureAwait(false);
             _logger.Received(1).Warning(UNABLE_TO_FOUND_MILESTONE_MESSAGE, "closed", MILESTONE_TITLE, OWNER, REPOSITORY);
         }
 
@@ -556,13 +561,13 @@ public async Task Should_Delete_Draft_Release()
             _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromResult(release));
 
-            _vcsProvider.DeleteReleaseAsync(OWNER, REPOSITORY, release.Id)
+            _vcsProvider.DeleteReleaseAsync(OWNER, REPOSITORY, release)
                 .Returns(Task.CompletedTask);
 
             await _vcsService.DiscardReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
 
             await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
-            await _vcsProvider.Received(1).DeleteReleaseAsync(OWNER, REPOSITORY, release.Id).ConfigureAwait(false);
+            await _vcsProvider.Received(1).DeleteReleaseAsync(OWNER, REPOSITORY, release).ConfigureAwait(false);
         }
 
         [Test]
@@ -576,7 +581,7 @@ public async Task Should_Not_Delete_Published_Release()
             await _vcsService.DiscardReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
 
             await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
-            await _vcsProvider.DidNotReceive().DeleteReleaseAsync(OWNER, REPOSITORY, release.Id).ConfigureAwait(false);
+            await _vcsProvider.DidNotReceive().DeleteReleaseAsync(OWNER, REPOSITORY, release).ConfigureAwait(false);
             _logger.Received(1).Warning(Arg.Any<string>(), TAG_NAME);
         }
 
@@ -601,13 +606,13 @@ public async Task Should_Publish_Release()
             _vcsProvider.GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME)
                 .Returns(Task.FromResult(release));
 
-            _vcsProvider.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, release.Id)
+            _vcsProvider.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, release)
                 .Returns(Task.CompletedTask);
 
             await _vcsService.PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
 
             await _vcsProvider.Received(1).GetReleaseAsync(OWNER, REPOSITORY, TAG_NAME).ConfigureAwait(false);
-            await _vcsProvider.Received(1).PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, release.Id).ConfigureAwait(false);
+            await _vcsProvider.Received(1).PublishReleaseAsync(OWNER, REPOSITORY, TAG_NAME, release).ConfigureAwait(false);
             _logger.Received(1).Verbose(Arg.Any<string>(), TAG_NAME, OWNER, REPOSITORY);
             _logger.Received(1).Debug(Arg.Any<string>(), Arg.Any<Release>());
         }
diff --git a/src/GitReleaseManager.Core/Commands/AddAssetsCommand.cs b/src/GitReleaseManager.Core/Commands/AddAssetsCommand.cs
index 3073bc33..d8531c63 100644
--- a/src/GitReleaseManager.Core/Commands/AddAssetsCommand.cs
+++ b/src/GitReleaseManager.Core/Commands/AddAssetsCommand.cs
@@ -17,6 +17,14 @@ public AddAssetsCommand(IVcsService vcsService, ILogger logger)
 
         public async Task<int> ExecuteAsync(AddAssetSubOptions options)
         {
+            var vcsOptions = options as BaseVcsOptions;
+
+            if (vcsOptions?.Provider == Model.VcsProvider.GitLab)
+            {
+                _logger.Error("The 'addasset' command is currently not supported when targeting GitLab.");
+                return 1;
+            }
+
             _logger.Information("Uploading assets");
             await _vcsService.AddAssetsAsync(options.RepositoryOwner, options.RepositoryName, options.TagName, options.AssetPaths).ConfigureAwait(false);
 
diff --git a/src/GitReleaseManager.Core/Commands/ExportCommand.cs b/src/GitReleaseManager.Core/Commands/ExportCommand.cs
index b61ec0e6..9cde1f8e 100644
--- a/src/GitReleaseManager.Core/Commands/ExportCommand.cs
+++ b/src/GitReleaseManager.Core/Commands/ExportCommand.cs
@@ -18,7 +18,15 @@ public ExportCommand(IVcsService vcsService, ILogger logger)
 
         public async Task<int> ExecuteAsync(ExportSubOptions options)
         {
-            _logger.Information("Exporting release {TagName}", options.TagName);
+            if (string.IsNullOrWhiteSpace(options.TagName))
+            {
+                _logger.Information("Exporting all releases.");
+            }
+            else
+            {
+                _logger.Information("Exporting release {TagName}.", options.TagName);
+            }
+
             var releasesContent = await _vcsService.ExportReleasesAsync(options.RepositoryOwner, options.RepositoryName, options.TagName, options.SkipPrereleases).ConfigureAwait(false);
 
             using (var sw = new StreamWriter(File.Open(options.FileOutputPath, FileMode.OpenOrCreate)))
diff --git a/src/GitReleaseManager.Core/Commands/LabelCommand.cs b/src/GitReleaseManager.Core/Commands/LabelCommand.cs
index da12d955..63786d6b 100644
--- a/src/GitReleaseManager.Core/Commands/LabelCommand.cs
+++ b/src/GitReleaseManager.Core/Commands/LabelCommand.cs
@@ -17,6 +17,14 @@ public LabelCommand(IVcsService vcsService, ILogger logger)
 
         public async Task<int> ExecuteAsync(LabelSubOptions options)
         {
+            var vcsOptions = options as BaseVcsOptions;
+
+            if (vcsOptions?.Provider == Model.VcsProvider.GitLab)
+            {
+                _logger.Error("The label command is currently not supported when targeting GitLab.");
+                return 1;
+            }
+
             _logger.Information("Creating standard labels");
             await _vcsService.CreateLabelsAsync(options.RepositoryOwner, options.RepositoryName).ConfigureAwait(false);
 
diff --git a/src/GitReleaseManager.Core/Configuration/Config.cs b/src/GitReleaseManager.Core/Configuration/Config.cs
index 9df3e365..15083cc2 100644
--- a/src/GitReleaseManager.Core/Configuration/Config.cs
+++ b/src/GitReleaseManager.Core/Configuration/Config.cs
@@ -12,7 +12,7 @@ public class Config
 
 - [GitHub release](https://github.com/{owner}/{repository}/releases/tag/{milestone})
 
-Your **[GitReleaseManager](https://github.com/GitTools/GitReleaseManager)** bot :package::rocket:";
+Your **[GitReleaseManager](https://github.com/GitTools/GitReleaseManager)** bot :package: :rocket:";
 
         public Config()
         {
diff --git a/src/GitReleaseManager.Core/Extensions/MilestoneExtensions.cs b/src/GitReleaseManager.Core/Extensions/MilestoneExtensions.cs
index 41578201..f919a6ad 100644
--- a/src/GitReleaseManager.Core/Extensions/MilestoneExtensions.cs
+++ b/src/GitReleaseManager.Core/Extensions/MilestoneExtensions.cs
@@ -1,5 +1,4 @@
 using System;
-using Octokit;
 using Serilog;
 
 namespace GitReleaseManager.Core.Extensions
@@ -8,7 +7,30 @@ public static class MilestoneExtensions
     {
         public static readonly ILogger _logger = Log.ForContext(typeof(MilestoneExtensions));
 
-        public static Version Version(this Milestone ver)
+        public static Version Version(this Octokit.Milestone ver)
+        {
+            if (ver is null)
+            {
+                throw new ArgumentNullException(nameof(ver));
+            }
+
+            var nameWithoutPrerelease = ver.Title.Split('-')[0];
+            if (nameWithoutPrerelease.StartsWith("v", StringComparison.OrdinalIgnoreCase))
+            {
+                _logger.Debug("Removing version prefix from {Name}.", ver.Title);
+                nameWithoutPrerelease = nameWithoutPrerelease.Remove(0, 1);
+            }
+
+            if (!System.Version.TryParse(nameWithoutPrerelease, out Version parsedVersion))
+            {
+                _logger.Warning("No valid version was found on {Title}.", ver.Title);
+                return new Version(0, 0);
+            }
+
+            return parsedVersion;
+        }
+
+        public static Version Version(this NGitLab.Models.Milestone ver)
         {
             if (ver is null)
             {
diff --git a/src/GitReleaseManager.Core/GitReleaseManager.Core.csproj b/src/GitReleaseManager.Core/GitReleaseManager.Core.csproj
index e25f50b6..d96ec6ba 100644
--- a/src/GitReleaseManager.Core/GitReleaseManager.Core.csproj
+++ b/src/GitReleaseManager.Core/GitReleaseManager.Core.csproj
@@ -23,6 +23,7 @@
           <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
           <PrivateAssets>all</PrivateAssets>
         </PackageReference>
+        <PackageReference Include="NGitLab" Version="6.39.0" />
         <PackageReference Include="Octokit" Version="7.1.0" />
         <PackageReference Include="Scriban" Version="5.7.0" />
         <PackageReference Include="seriloganalyzer" Version="0.15.0" />
diff --git a/src/GitReleaseManager.Core/MappingProfiles/GitHubProfile.cs b/src/GitReleaseManager.Core/MappingProfiles/GitHubProfile.cs
index 87a73462..dff999dc 100644
--- a/src/GitReleaseManager.Core/MappingProfiles/GitHubProfile.cs
+++ b/src/GitReleaseManager.Core/MappingProfiles/GitHubProfile.cs
@@ -1,3 +1,4 @@
+using System;
 using AutoMapper;
 using GitReleaseManager.Core.Extensions;
 
@@ -7,7 +8,11 @@ public class GitHubProfile : Profile
     {
         public GitHubProfile()
         {
-            CreateMap<Model.Issue, Octokit.Issue>().ReverseMap();
+            CreateMap<Octokit.Issue, Model.Issue>()
+                .ForMember(dest => dest.PublicNumber, act => act.MapFrom(src => src.Number))
+                .ForMember(dest => dest.InternalNumber, act => act.MapFrom(src => src.Id))
+                .ForMember(dest => dest.IsPullRequest, act => act.MapFrom(src => src.HtmlUrl.IndexOf("/pull/", StringComparison.OrdinalIgnoreCase) >= 0))
+                .ReverseMap();
             CreateMap<Model.IssueComment, Octokit.IssueComment>().ReverseMap();
             CreateMap<Model.ItemState, Octokit.ItemState>().ReverseMap();
             CreateMap<Model.ItemStateFilter, Octokit.ItemStateFilter>().ReverseMap();
@@ -20,6 +25,8 @@ public GitHubProfile()
             CreateMap<Model.Label, Octokit.NewLabel>().ReverseMap();
             CreateMap<Model.Milestone, Octokit.Milestone>();
             CreateMap<Octokit.Milestone, Model.Milestone>()
+                .ForMember(dest => dest.PublicNumber, act => act.MapFrom(src => src.Number))
+                .ForMember(dest => dest.InternalNumber, act => act.MapFrom(src => src.Number))
                 .AfterMap((src, dest) => dest.Version = src.Version());
         }
     }
diff --git a/src/GitReleaseManager.Core/MappingProfiles/GitLabProfile.cs b/src/GitReleaseManager.Core/MappingProfiles/GitLabProfile.cs
new file mode 100644
index 00000000..c209654d
--- /dev/null
+++ b/src/GitReleaseManager.Core/MappingProfiles/GitLabProfile.cs
@@ -0,0 +1,48 @@
+namespace GitReleaseManager.Core.MappingProfiles
+{
+    using System;
+    using AutoMapper;
+    using GitReleaseManager.Core.Extensions;
+
+    public class GitLabProfile : Profile
+    {
+        public GitLabProfile()
+        {
+            CreateMap<NGitLab.Models.Milestone, Model.Milestone>()
+                .ForMember(dest => dest.PublicNumber, act => act.MapFrom(src => src.Iid))
+                .ForMember(dest => dest.InternalNumber, act => act.MapFrom(src => src.Id))
+                .AfterMap((src, dest) => dest.Version = src.Version());
+            CreateMap<NGitLab.Models.ReleaseInfo, Model.Release>()
+                .ForMember(dest => dest.Draft, act => act.MapFrom(src => src.ReleasedAt > DateTime.UtcNow))
+                .ForMember(dest => dest.Body, act => act.MapFrom(src => src.Description))
+                .ForMember(dest => dest.Assets, act => act.MapFrom(src => src.Assets.Links))
+                .ReverseMap();
+            CreateMap<NGitLab.Models.ReleaseLink, Model.ReleaseAsset>().ReverseMap();
+            CreateMap<NGitLab.Models.Issue, Model.Issue>()
+                .ForMember(dest => dest.InternalNumber, act => act.MapFrom(src => src.Id))
+                .ForMember(dest => dest.PublicNumber, act => act.MapFrom(src => src.IssueId))
+                .ForMember(dest => dest.HtmlUrl, act => act.MapFrom(src => src.WebUrl))
+                .ForMember(dest => dest.IsPullRequest, act => act.MapFrom(src => false))
+                .ReverseMap();
+            CreateMap<NGitLab.Models.MergeRequest, Model.Issue>()
+                .ForMember(dest => dest.InternalNumber, act => act.MapFrom(src => src.Id))
+                .ForMember(dest => dest.PublicNumber, act => act.MapFrom(src => src.Iid))
+                .ForMember(dest => dest.HtmlUrl, act => act.MapFrom(src => src.WebUrl))
+                .ForMember(dest => dest.IsPullRequest, act => act.MapFrom(src => true))
+                .ReverseMap();
+            CreateMap<string, Model.Label>().ForMember(dest => dest.Name, act => act.MapFrom(src => src));
+            CreateMap<Model.Release, NGitLab.Models.ReleaseCreate>()
+                .ForMember(dest => dest.Description, act => act.MapFrom(src => src.Body))
+                .ForMember(dest => dest.Ref, act => act.MapFrom(src => src.TargetCommitish))
+                .ForMember(dest => dest.Milestones, act => act.MapFrom(src => new string[] { src.TagName }))
+                .ForMember(dest => dest.ReleasedAt, act => act.MapFrom(src => src.Draft ? DateTime.UtcNow.AddYears(1) : DateTime.UtcNow))
+                .ForMember(dest => dest.Assets, act => act.Ignore())
+                .ReverseMap();
+            CreateMap<NGitLab.Models.ProjectIssueNote, Model.IssueComment>()
+                .ForMember(dest => dest.Id, act => act.MapFrom(src => src.NoteId))
+                .ReverseMap();
+            CreateMap<NGitLab.Models.MergeRequestComment, Model.IssueComment>()
+                .ReverseMap();
+        }
+    }
+}
diff --git a/src/GitReleaseManager.Core/Model/Issue.cs b/src/GitReleaseManager.Core/Model/Issue.cs
index 5af76d1b..7914672f 100644
--- a/src/GitReleaseManager.Core/Model/Issue.cs
+++ b/src/GitReleaseManager.Core/Model/Issue.cs
@@ -6,10 +6,14 @@ public sealed class Issue
     {
         public string Title { get; set; }
 
-        public int Number { get; set; }
+        public int InternalNumber { get; set; }
+
+        public int PublicNumber { get; set; }
 
         public string HtmlUrl { get; set; }
 
         public IReadOnlyList<Label> Labels { get; set; }
+
+        public bool IsPullRequest { get; set; }
     }
 }
\ No newline at end of file
diff --git a/src/GitReleaseManager.Core/Model/Milestone.cs b/src/GitReleaseManager.Core/Model/Milestone.cs
index c719186b..13e1098a 100644
--- a/src/GitReleaseManager.Core/Model/Milestone.cs
+++ b/src/GitReleaseManager.Core/Model/Milestone.cs
@@ -8,7 +8,9 @@ public sealed class Milestone
 
         public string Description { get; set; }
 
-        public int Number { get; set; }
+        public int PublicNumber { get; set; }
+
+        public int InternalNumber { get; set; }
 
         public string HtmlUrl { get; set; }
 
diff --git a/src/GitReleaseManager.Core/Model/VcsProvider.cs b/src/GitReleaseManager.Core/Model/VcsProvider.cs
new file mode 100644
index 00000000..565b218e
--- /dev/null
+++ b/src/GitReleaseManager.Core/Model/VcsProvider.cs
@@ -0,0 +1,8 @@
+namespace GitReleaseManager.Core.Model
+{
+    public enum VcsProvider
+    {
+        GitHub = 0,
+        GitLab = 1,
+    }
+}
diff --git a/src/GitReleaseManager.Core/Options/BaseVcsSubOptions.cs b/src/GitReleaseManager.Core/Options/BaseVcsSubOptions.cs
index 35b994bd..90faca2a 100644
--- a/src/GitReleaseManager.Core/Options/BaseVcsSubOptions.cs
+++ b/src/GitReleaseManager.Core/Options/BaseVcsSubOptions.cs
@@ -1,5 +1,6 @@
 using CommandLine;
 using Destructurama.Attributed;
+using GitReleaseManager.Core.Model;
 
 namespace GitReleaseManager.Core.Options
 {
@@ -14,5 +15,8 @@ public abstract class BaseVcsOptions : BaseSubOptions
 
         [Option('r', "repository", HelpText = "The name of the repository.", Required = true)]
         public string RepositoryName { get; set; }
+
+        [Option("provider", HelpText = "Version Control System provider", Default = VcsProvider.GitHub)]
+        public VcsProvider Provider { get; set; }
     }
 }
\ No newline at end of file
diff --git a/src/GitReleaseManager.Core/Provider/GitHubProvider.cs b/src/GitReleaseManager.Core/Provider/GitHubProvider.cs
index d0960073..68d19c4a 100644
--- a/src/GitReleaseManager.Core/Provider/GitHubProvider.cs
+++ b/src/GitReleaseManager.Core/Provider/GitHubProvider.cs
@@ -16,6 +16,7 @@
 using NotFoundException = GitReleaseManager.Core.Exceptions.NotFoundException;
 using RateLimit = GitReleaseManager.Core.Model.RateLimit;
 using Release = GitReleaseManager.Core.Model.Release;
+using ReleaseAsset = GitReleaseManager.Core.Model.ReleaseAsset;
 using ReleaseAssetUpload = GitReleaseManager.Core.Model.ReleaseAssetUpload;
 
 namespace GitReleaseManager.Core.Provider
@@ -34,11 +35,11 @@ public GitHubProvider(IGitHubClient gitHubClient, IMapper mapper)
             _mapper = mapper;
         }
 
-        public Task DeleteAssetAsync(string owner, string repository, int id)
+        public Task DeleteAssetAsync(string owner, string repository, ReleaseAsset asset)
         {
             return ExecuteAsync(async () =>
             {
-                await _gitHubClient.Repository.Release.DeleteAsset(owner, repository, id).ConfigureAwait(false);
+                await _gitHubClient.Repository.Release.DeleteAsset(owner, repository, asset.Id).ConfigureAwait(false);
             });
         }
 
@@ -84,21 +85,21 @@ public string GetCommitsUrl(string owner, string repository, string head, string
             return url;
         }
 
-        public Task CreateIssueCommentAsync(string owner, string repository, int issueNumber, string comment)
+        public Task CreateIssueCommentAsync(string owner, string repository, Issue issue, string comment)
         {
             return ExecuteAsync(async () =>
             {
-                await _gitHubClient.Issue.Comment.Create(owner, repository, issueNumber, comment).ConfigureAwait(false);
+                await _gitHubClient.Issue.Comment.Create(owner, repository, issue.PublicNumber, comment).ConfigureAwait(false);
             });
         }
 
-        public Task<IEnumerable<Issue>> GetIssuesAsync(string owner, string repository, int milestoneNumber, ItemStateFilter itemStateFilter = ItemStateFilter.All)
+        public Task<IEnumerable<Issue>> GetIssuesAsync(string owner, string repository, Milestone milestone, ItemStateFilter itemStateFilter = ItemStateFilter.All)
         {
             return ExecuteAsync(async () =>
             {
                 var openIssueRequest = new RepositoryIssueRequest
                 {
-                    Milestone = milestoneNumber.ToString(CultureInfo.InvariantCulture),
+                    Milestone = milestone.PublicNumber.ToString(CultureInfo.InvariantCulture),
                     State = (Octokit.ItemStateFilter)itemStateFilter,
                 };
 
@@ -120,7 +121,7 @@ public Task<IEnumerable<Issue>> GetIssuesAsync(string owner, string repository,
             });
         }
 
-        public Task<IEnumerable<IssueComment>> GetIssueCommentsAsync(string owner, string repository, int issueNumber)
+        public Task<IEnumerable<IssueComment>> GetIssueCommentsAsync(string owner, string repository, Issue issue)
         {
             return ExecuteAsync(async () =>
             {
@@ -131,7 +132,7 @@ public Task<IEnumerable<IssueComment>> GetIssueCommentsAsync(string owner, strin
                 do
                 {
                     var options = GetApiOptions(startPage);
-                    results = await _gitHubClient.Issue.Comment.GetAllForIssue(owner, repository, issueNumber, options).ConfigureAwait(false);
+                    results = await _gitHubClient.Issue.Comment.GetAllForIssue(owner, repository, issue.PublicNumber, options).ConfigureAwait(false);
 
                     comments.AddRange(results);
                     startPage++;
@@ -152,11 +153,11 @@ public Task CreateLabelAsync(string owner, string repository, Label label)
             });
         }
 
-        public Task DeleteLabelAsync(string owner, string repository, string labelName)
+        public Task DeleteLabelAsync(string owner, string repository, Label label)
         {
             return ExecuteAsync(async () =>
             {
-                await _gitHubClient.Issue.Labels.Delete(owner, repository, labelName).ConfigureAwait(false);
+                await _gitHubClient.Issue.Labels.Delete(owner, repository, label.Name).ConfigureAwait(false);
             });
         }
 
@@ -187,14 +188,14 @@ public Task<Milestone> GetMilestoneAsync(string owner, string repository, string
             return ExecuteAsync(async () =>
             {
                 var milestones = await GetMilestonesAsync(owner, repository, itemStateFilter).ConfigureAwait(false);
-                var milestone = milestones.FirstOrDefault(m => m.Title == milestoneTitle);
+                var foundMilestone = milestones.FirstOrDefault(m => m.Title == milestoneTitle);
 
-                if (milestone is null)
+                if (foundMilestone is null)
                 {
                     throw new NotFoundException(NOT_FOUND_MESSGAE);
                 }
 
-                return milestone;
+                return foundMilestone;
             });
         }
 
@@ -222,12 +223,12 @@ public Task<IEnumerable<Milestone>> GetMilestonesAsync(string owner, string repo
             });
         }
 
-        public Task SetMilestoneStateAsync(string owner, string repository, int milestoneNumber, ItemState itemState)
+        public Task SetMilestoneStateAsync(string owner, string repository, Milestone milestone, ItemState itemState)
         {
             return ExecuteAsync(async () =>
             {
                 var update = new MilestoneUpdate { State = (Octokit.ItemState)itemState };
-                await _gitHubClient.Issue.Milestone.Update(owner, repository, milestoneNumber, update).ConfigureAwait(false);
+                await _gitHubClient.Issue.Milestone.Update(owner, repository, milestone.PublicNumber, update).ConfigureAwait(false);
             });
         }
 
@@ -242,11 +243,11 @@ public Task<Release> CreateReleaseAsync(string owner, string repository, Release
             });
         }
 
-        public Task DeleteReleaseAsync(string owner, string repository, int id)
+        public Task DeleteReleaseAsync(string owner, string repository, Release release)
         {
             return ExecuteAsync(async () =>
             {
-                await _gitHubClient.Repository.Release.Delete(owner, repository, id).ConfigureAwait(false);
+                await _gitHubClient.Repository.Release.Delete(owner, repository, release.Id).ConfigureAwait(false);
             });
         }
 
@@ -299,7 +300,7 @@ public Task<IEnumerable<Release>> GetReleasesAsync(string owner, string reposito
             });
         }
 
-        public Task PublishReleaseAsync(string owner, string repository, string tagName, int releaseId)
+        public Task PublishReleaseAsync(string owner, string repository, string tagName, Release release)
         {
             return ExecuteAsync(async () =>
             {
@@ -309,7 +310,7 @@ public Task PublishReleaseAsync(string owner, string repository, string tagName,
                     TagName = tagName,
                 };
 
-                await _gitHubClient.Repository.Release.Edit(owner, repository, releaseId, update).ConfigureAwait(false);
+                await _gitHubClient.Repository.Release.Edit(owner, repository, release.Id, update).ConfigureAwait(false);
             });
         }
 
@@ -345,6 +346,16 @@ public RateLimit GetRateLimit()
             }
         }
 
+        public string GetMilestoneQueryString()
+        {
+            return "closed=1";
+        }
+
+        public string GetIssueType(Issue issue)
+        {
+            return issue.IsPullRequest ? "Pull Request" : "Issue";
+        }
+
         private async Task ExecuteAsync(Func<Task> action)
         {
             try
diff --git a/src/GitReleaseManager.Core/Provider/GitLabProvider.cs b/src/GitReleaseManager.Core/Provider/GitLabProvider.cs
new file mode 100644
index 00000000..c2371c72
--- /dev/null
+++ b/src/GitReleaseManager.Core/Provider/GitLabProvider.cs
@@ -0,0 +1,440 @@
+namespace GitReleaseManager.Core.Provider
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Linq;
+    using System.Threading.Tasks;
+    using AutoMapper;
+    using NGitLab;
+    using NGitLab.Models;
+    using Serilog;
+    using ApiException = GitReleaseManager.Core.Exceptions.ApiException;
+    using Issue = GitReleaseManager.Core.Model.Issue;
+    using IssueComment = GitReleaseManager.Core.Model.IssueComment;
+    using ItemState = GitReleaseManager.Core.Model.ItemState;
+    using ItemStateFilter = GitReleaseManager.Core.Model.ItemStateFilter;
+    using Label = GitReleaseManager.Core.Model.Label;
+    using Milestone = GitReleaseManager.Core.Model.Milestone;
+    using NotFoundException = GitReleaseManager.Core.Exceptions.NotFoundException;
+    using RateLimit = GitReleaseManager.Core.Model.RateLimit;
+    using Release = GitReleaseManager.Core.Model.Release;
+    using ReleaseAsset = GitReleaseManager.Core.Model.ReleaseAsset;
+    using ReleaseAssetUpload = GitReleaseManager.Core.Model.ReleaseAssetUpload;
+
+    public class GitLabProvider : IVcsProvider
+    {
+        private const string NOT_FOUND_MESSGAE = "NotFound";
+        private const string COMMITS_FORMAT_STRING = "https://gitlab.com/{0}/{1}/-/commits/{2}";
+        private const string COMPARE_FORMAT_STRING = "https://gitlab.com/{0}/{1}/-/compare/{2}...{3}";
+        private const string MILESTONES_FORMAT_STRING = "https://gitlab.com/{0}/{1}/-/milestones/{2}#tab-issues";
+        private const string RELEASES_FORMAT_STRING = "https://gitlab.com/{0}/{1}/-/releases/{2}";
+
+        private readonly IGitLabClient _gitLabClient;
+        private readonly IMapper _mapper;
+        private readonly ILogger _logger;
+
+        private int? _projectId;
+
+        public GitLabProvider(IGitLabClient gitLabClient, IMapper mapper, ILogger logger)
+        {
+            _gitLabClient = gitLabClient;
+            _mapper = mapper;
+            _logger = logger;
+        }
+
+        public Task DeleteAssetAsync(string owner, string repository, ReleaseAsset asset)
+        {
+            // TODO: This is a discussion here:
+            // https://github.com/ubisoft/NGitLab/discussions/511
+            // about what is necessary to implement the required functionality in NGitLab
+            throw new NotImplementedException();
+        }
+
+        public Task UploadAssetAsync(Release release, ReleaseAssetUpload releaseAssetUpload)
+        {
+            return ExecuteAsync(() =>
+            {
+                _logger.Warning("Uploading of assets is not currently supported when targeting GitLab.");
+                return Task.CompletedTask;
+            });
+        }
+
+        public Task<int> GetCommitsCountAsync(string owner, string repository, string @base, string head)
+        {
+            return ExecuteAsync(() =>
+            {
+                // TODO: This is waiting on a PR being merged...
+                // https://github.com/ubisoft/NGitLab/pull/444
+                // Once it is, we might be able to implement what is necessary here.
+                return Task.FromResult(0);
+            });
+        }
+
+        public string GetCommitsUrl(string owner, string repository, string head, string @base = null)
+        {
+            Ensure.IsNotNullOrWhiteSpace(owner, nameof(owner));
+            Ensure.IsNotNullOrWhiteSpace(repository, nameof(repository));
+            Ensure.IsNotNullOrWhiteSpace(head, nameof(head));
+
+            return string.IsNullOrWhiteSpace(@base)
+                ? string.Format(CultureInfo.InvariantCulture, COMMITS_FORMAT_STRING, owner, repository, head)
+                : string.Format(CultureInfo.InvariantCulture, COMPARE_FORMAT_STRING, owner, repository, @base, head);
+        }
+
+        public Task CreateIssueCommentAsync(string owner, string repository, Issue issue, string comment)
+        {
+            return ExecuteAsync(() =>
+            {
+                var projectId = GetGitLabProjectId(owner, repository);
+
+                if (issue.IsPullRequest)
+                {
+                    var mergeRequestClient = _gitLabClient.GetMergeRequest(projectId);
+                    var commentsClient = mergeRequestClient.Comments(issue.PublicNumber);
+                    var mergeRequestComment = new MergeRequestCommentCreate
+                    {
+                        Body = comment,
+                    };
+
+                    commentsClient.Add(mergeRequestComment);
+                }
+                else
+                {
+                    var issueNotesClient = _gitLabClient.GetProjectIssueNoteClient(projectId);
+                    var issueComment = new ProjectIssueNoteCreate
+                    {
+                        IssueId = issue.PublicNumber,
+                        Body = comment,
+                    };
+
+                    issueNotesClient.Create(issueComment);
+                }
+
+                return Task.CompletedTask;
+            });
+        }
+
+        public Task<IEnumerable<Issue>> GetIssuesAsync(string owner, string repository, Milestone milestone, ItemStateFilter itemStateFilter = ItemStateFilter.All)
+        {
+            return ExecuteAsync(() =>
+            {
+                var issuesClient = _gitLabClient.Issues;
+
+                var query = new IssueQuery();
+                query.Milestone = milestone.Title;
+
+                if (itemStateFilter == ItemStateFilter.Open)
+                {
+                    query.State = IssueState.opened;
+                }
+                else if (itemStateFilter == ItemStateFilter.Closed)
+                {
+                    query.State = IssueState.closed;
+                }
+
+                var projectId = GetGitLabProjectId(owner, repository);
+
+                var issues = issuesClient.GetAsync(projectId, query);
+
+                var mergeRequestsClient = _gitLabClient.GetMergeRequest(projectId);
+
+                var mergeRequestQuery = new MergeRequestQuery();
+                mergeRequestQuery.Milestone = milestone.Title;
+
+                if (itemStateFilter == ItemStateFilter.Open)
+                {
+                    mergeRequestQuery.State = MergeRequestState.opened;
+                }
+                else if (itemStateFilter == ItemStateFilter.Closed)
+                {
+                    mergeRequestQuery.State = MergeRequestState.merged;
+                }
+
+                var mergeRequests = mergeRequestsClient.Get(mergeRequestQuery);
+
+                var issuesAndMergeRequests = new List<Issue>();
+                issuesAndMergeRequests.AddRange(_mapper.Map<IEnumerable<Issue>>(issues));
+                issuesAndMergeRequests.AddRange(_mapper.Map<IEnumerable<Issue>>(mergeRequests));
+
+                return Task.FromResult(issuesAndMergeRequests.AsEnumerable());
+            });
+        }
+
+        public Task<IEnumerable<IssueComment>> GetIssueCommentsAsync(string owner, string repository, Issue issue)
+        {
+            return ExecuteAsync(() =>
+            {
+                IEnumerable<IssueComment> issueComments = Enumerable.Empty<IssueComment>();
+                var projectId = GetGitLabProjectId(owner, repository);
+
+                if (issue.IsPullRequest)
+                {
+                    var mergeRequestClient = _gitLabClient.GetMergeRequest(projectId);
+                    var commentsClient = mergeRequestClient.Comments(issue.PublicNumber);
+                    var comments = commentsClient.All;
+                    issueComments = _mapper.Map<IEnumerable<IssueComment>>(comments);
+                }
+                else
+                {
+                    var issueNotesClient = _gitLabClient.GetProjectIssueNoteClient(projectId);
+                    var comments = issueNotesClient.ForIssue(issue.PublicNumber);
+                    issueComments = _mapper.Map<IEnumerable<IssueComment>>(comments);
+                }
+
+                return Task.FromResult(issueComments);
+            });
+        }
+
+        public Task CreateLabelAsync(string owner, string repository, Label label)
+        {
+            // The label functionality in GitLab already provides more than
+            // what is possible in GRM. As such, the decision was taken to not
+            // implement the creation of labels for the GitLab provider.
+            throw new NotImplementedException();
+        }
+
+        public Task DeleteLabelAsync(string owner, string repository, Label label)
+        {
+            // The label functionality in GitLab already provides more than
+            // what is possible in GRM. As such, the decision was taken to not
+            // implement the deletion of labels for the GitLab provider.
+            throw new NotImplementedException();
+        }
+
+        public Task<IEnumerable<Label>> GetLabelsAsync(string owner, string repository)
+        {
+            // The label functionality in GitLab already provides more than
+            // what is possible in GRM. As such, the decision was taken to not
+            // implement the fetching of labels for the GitLab provider.
+            throw new NotImplementedException();
+        }
+
+        public Task<Milestone> GetMilestoneAsync(string owner, string repository, string milestoneTitle, ItemStateFilter itemStateFilter = ItemStateFilter.All)
+        {
+            return ExecuteAsync(async () =>
+            {
+                var milestones = await GetMilestonesAsync(owner, repository, itemStateFilter).ConfigureAwait(false);
+                var foundMilestone = milestones.FirstOrDefault(m => m.Title == milestoneTitle);
+
+                if (foundMilestone is null)
+                {
+                    throw new NotFoundException(NOT_FOUND_MESSGAE);
+                }
+
+                return foundMilestone;
+            });
+        }
+
+        public Task<IEnumerable<Milestone>> GetMilestonesAsync(string owner, string repository, ItemStateFilter itemStateFilter = ItemStateFilter.All)
+        {
+            return ExecuteAsync(() =>
+            {
+                var query = new MilestoneQuery();
+
+                if (itemStateFilter == ItemStateFilter.Open)
+                {
+                    query.State = MilestoneState.active;
+                }
+                else if (itemStateFilter == ItemStateFilter.Closed)
+                {
+                    query.State = MilestoneState.closed;
+                }
+
+                var mileStoneClient = _gitLabClient.GetMilestone(GetGitLabProjectId(owner, repository));
+
+                var milestones = mileStoneClient.Get(query);
+                var mappedMilestones = _mapper.Map<IEnumerable<Milestone>>(milestones);
+
+                foreach (var mappedMilestone in mappedMilestones)
+                {
+                    mappedMilestone.HtmlUrl = string.Format(CultureInfo.InvariantCulture, MILESTONES_FORMAT_STRING, owner, repository, mappedMilestone.PublicNumber);
+                }
+
+                return Task.FromResult(mappedMilestones);
+            });
+        }
+
+        public Task SetMilestoneStateAsync(string owner, string repository, Milestone milestone, ItemState itemState)
+        {
+            return ExecuteAsync(() =>
+            {
+                var mileStoneClient = _gitLabClient.GetMilestone(GetGitLabProjectId(owner, repository));
+
+                if (itemState == ItemState.Open)
+                {
+                    mileStoneClient.Activate(milestone.InternalNumber);
+                }
+                else if (itemState == ItemState.Closed)
+                {
+                    mileStoneClient.Close(milestone.InternalNumber);
+                }
+
+                return Task.CompletedTask;
+            });
+        }
+
+        public Task<Release> CreateReleaseAsync(string owner, string repository, Release release)
+        {
+            return ExecuteAsync(() =>
+            {
+                var releaseClient = _gitLabClient.GetReleases(GetGitLabProjectId(owner, repository));
+
+                var newRelease = _mapper.Map<ReleaseCreate>(release);
+                var nGitLabRelease = releaseClient.Create(newRelease);
+                var mappedRelease = _mapper.Map<Release>(nGitLabRelease);
+
+                if (mappedRelease != null)
+                {
+                    mappedRelease.HtmlUrl = string.Format(CultureInfo.InvariantCulture, RELEASES_FORMAT_STRING, owner, repository, release.TagName);
+                }
+
+                return Task.FromResult(mappedRelease);
+            });
+        }
+
+        public Task DeleteReleaseAsync(string owner, string repository, Release release)
+        {
+            return ExecuteAsync(() =>
+            {
+                var releaseClient = _gitLabClient.GetReleases(GetGitLabProjectId(owner, repository));
+
+                releaseClient.Delete(release.TagName);
+                return Task.CompletedTask;
+            });
+        }
+
+        public Task<Release> GetReleaseAsync(string owner, string repository, string tagName)
+        {
+            return ExecuteAsync(() =>
+            {
+                var releaseClient = _gitLabClient.GetReleases(GetGitLabProjectId(owner, repository));
+
+                var releases = releaseClient.GetAsync();
+
+                var release = releases.FirstOrDefault(r => r.TagName == tagName);
+                var mappedRelease = _mapper.Map<Release>(release);
+
+                if (mappedRelease != null)
+                {
+                    mappedRelease.HtmlUrl = string.Format(CultureInfo.InvariantCulture, RELEASES_FORMAT_STRING, owner, repository, tagName);
+                }
+
+                return Task.FromResult(mappedRelease);
+            });
+        }
+
+        public Task<IEnumerable<Release>> GetReleasesAsync(string owner, string repository, bool skipPrereleases)
+        {
+            return ExecuteAsync(() =>
+            {
+                var releaseClient = _gitLabClient.GetReleases(GetGitLabProjectId(owner, repository));
+
+                var releases = _mapper.Map<IEnumerable<Release>>(releaseClient.GetAsync());
+
+                return Task.FromResult(releases);
+            });
+        }
+
+        public Task PublishReleaseAsync(string owner, string repository, string tagName, Release release)
+        {
+            return ExecuteAsync(() =>
+            {
+                var releaseClient = _gitLabClient.GetReleases(GetGitLabProjectId(owner, repository));
+
+                var update = new ReleaseUpdate
+                {
+                    ReleasedAt = DateTime.UtcNow,
+                    TagName = tagName,
+                };
+
+                releaseClient.Update(update);
+                return Task.CompletedTask;
+            });
+        }
+
+        public Task UpdateReleaseAsync(string owner, string repository, Release release)
+        {
+            return ExecuteAsync(() =>
+            {
+                var releaseClient = _gitLabClient.GetReleases(GetGitLabProjectId(owner, repository));
+
+                var update = new ReleaseUpdate
+                {
+                    Description = release.Body,
+                    ReleasedAt = release.Draft ? DateTime.UtcNow.AddYears(1) : DateTime.UtcNow,
+                    Name = release.Name,
+                    TagName = release.TagName,
+                    Milestones = new string[] { release.TagName },
+                };
+
+                releaseClient.Update(update);
+                return Task.CompletedTask;
+            });
+        }
+
+        public RateLimit GetRateLimit()
+        {
+            // TODO: There doesn't currently seem to be a way to get the remaining
+            // rate limit for GitLab using the library we are using, so for now,
+            // let's just hard code it.
+            return new RateLimit { Limit = 600, Remaining = 100 };
+        }
+
+        public string GetMilestoneQueryString()
+        {
+            return "state=closed";
+        }
+
+        public string GetIssueType(Issue issue)
+        {
+            return issue.IsPullRequest ? "Merge Request" : "Issue";
+        }
+
+        private int GetGitLabProjectId(string owner, string repository)
+        {
+            if (_projectId.HasValue)
+            {
+                return _projectId.Value;
+            }
+
+            var projectName = string.Format(CultureInfo.InvariantCulture, "{0}/{1}", owner, repository);
+            var project = _gitLabClient.Projects[projectName];
+            _projectId = project.Id;
+
+            return _projectId.Value;
+        }
+
+        private async Task ExecuteAsync(Func<Task> action)
+        {
+            try
+            {
+                await action().ConfigureAwait(false);
+            }
+            catch (AggregateException ae) when (ae.InnerException != null)
+            {
+                throw new ApiException(ae.InnerException.Message, ae.InnerException);
+            }
+            catch (Exception ex) when (!(ex is NotFoundException))
+            {
+                throw new ApiException(ex.Message, ex);
+            }
+        }
+
+        private async Task<T> ExecuteAsync<T>(Func<Task<T>> action)
+        {
+            try
+            {
+                return await action().ConfigureAwait(false);
+            }
+            catch (AggregateException ae) when (ae.InnerException != null)
+            {
+                throw new ApiException(ae.InnerException.Message, ae.InnerException);
+            }
+            catch (Exception ex) when (!(ex is NotFoundException))
+            {
+                throw new ApiException(ex.Message, ex);
+            }
+        }
+    }
+}
diff --git a/src/GitReleaseManager.Core/Provider/IVcsProvider.cs b/src/GitReleaseManager.Core/Provider/IVcsProvider.cs
index 32616f38..a7bf82a8 100644
--- a/src/GitReleaseManager.Core/Provider/IVcsProvider.cs
+++ b/src/GitReleaseManager.Core/Provider/IVcsProvider.cs
@@ -6,7 +6,7 @@ namespace GitReleaseManager.Core.Provider
 {
     public interface IVcsProvider
     {
-        Task DeleteAssetAsync(string owner, string repository, int id);
+        Task DeleteAssetAsync(string owner, string repository, ReleaseAsset asset);
 
         Task UploadAssetAsync(Release release, ReleaseAssetUpload releaseAssetUpload);
 
@@ -14,15 +14,15 @@ public interface IVcsProvider
 
         string GetCommitsUrl(string owner, string repository, string head, string @base = null);
 
-        Task CreateIssueCommentAsync(string owner, string repository, int issueNumber, string comment);
+        Task CreateIssueCommentAsync(string owner, string repository, Issue issue, string comment);
 
-        Task<IEnumerable<Issue>> GetIssuesAsync(string owner, string repository, int milestoneNumber, ItemStateFilter itemStateFilter = ItemStateFilter.All);
+        Task<IEnumerable<Issue>> GetIssuesAsync(string owner, string repository, Milestone milstone, ItemStateFilter itemStateFilter = ItemStateFilter.All);
 
-        Task<IEnumerable<IssueComment>> GetIssueCommentsAsync(string owner, string repository, int issueNumber);
+        Task<IEnumerable<IssueComment>> GetIssueCommentsAsync(string owner, string repository, Issue issue);
 
         Task CreateLabelAsync(string owner, string repository, Label label);
 
-        Task DeleteLabelAsync(string owner, string repository, string labelName);
+        Task DeleteLabelAsync(string owner, string repository, Label label);
 
         Task<IEnumerable<Label>> GetLabelsAsync(string owner, string repository);
 
@@ -30,20 +30,24 @@ public interface IVcsProvider
 
         Task<IEnumerable<Milestone>> GetMilestonesAsync(string owner, string repository, ItemStateFilter itemStateFilter = ItemStateFilter.All);
 
-        Task SetMilestoneStateAsync(string owner, string repository, int milestoneNumber, ItemState itemState);
+        Task SetMilestoneStateAsync(string owner, string repository, Milestone milestone, ItemState itemState);
 
         Task<Release> CreateReleaseAsync(string owner, string repository, Release release);
 
-        Task DeleteReleaseAsync(string owner, string repository, int id);
+        Task DeleteReleaseAsync(string owner, string repository, Release release);
 
         Task<Release> GetReleaseAsync(string owner, string repository, string tagName);
 
         Task<IEnumerable<Release>> GetReleasesAsync(string owner, string repository, bool skipPrereleases);
 
-        Task PublishReleaseAsync(string owner, string repository, string tagName, int releaseId);
+        Task PublishReleaseAsync(string owner, string repository, string tagName, Release release);
 
         Task UpdateReleaseAsync(string owner, string repository, Release release);
 
         RateLimit GetRateLimit();
+
+        string GetMilestoneQueryString();
+
+        string GetIssueType(Issue issue);
     }
 }
\ No newline at end of file
diff --git a/src/GitReleaseManager.Core/ReleaseNotes/ReleaseNotesBuilder.cs b/src/GitReleaseManager.Core/ReleaseNotes/ReleaseNotesBuilder.cs
index 3f8c7d50..79273145 100644
--- a/src/GitReleaseManager.Core/ReleaseNotes/ReleaseNotesBuilder.cs
+++ b/src/GitReleaseManager.Core/ReleaseNotes/ReleaseNotesBuilder.cs
@@ -60,7 +60,7 @@ public async Task<string> BuildReleaseNotesAsync(string user, string repository,
 
             if (issues.Count == 0)
             {
-                var logMessage = string.Format("No closed issues have been found for milestone {0}, or all assigned issues are meant to be excluded from release notes, aborting creation of release.", _milestoneTitle);
+                var logMessage = string.Format(CultureInfo.CurrentCulture, "No closed issues have been found for milestone {0}, or all assigned issues are meant to be excluded from release notes, aborting release creation.", _milestoneTitle);
                 throw new InvalidOperationException(logMessage);
             }
 
@@ -68,6 +68,8 @@ public async Task<string> BuildReleaseNotesAsync(string user, string repository,
 
             var issuesDict = GetIssuesDict(issues);
 
+            var milestoneQueryString = _vcsProvider.GetMilestoneQueryString();
+
             var templateModel = new
             {
                 Issues = new
@@ -84,6 +86,7 @@ public async Task<string> BuildReleaseNotesAsync(string user, string repository,
                 {
                     Target = _targetMilestone,
                     Previous = previousMilestone,
+                    QueryString = milestoneQueryString,
                 },
                 IssueLabels = issuesDict.Keys.ToList(),
             };
@@ -103,7 +106,7 @@ private Dictionary<string, List<Issue>> GetIssuesDict(List<Issue> issues)
                 .Where(o => issueLabels.Any(il => string.Equals(il, o.Label, StringComparison.OrdinalIgnoreCase)))
                 .GroupBy(o => o.Label, o => o.Issue)
                 .OrderBy(o => o.Key)
-                .ToDictionary(o => GetValidLabel(o.Key, o.Count()), o => o.OrderBy(issue => issue.Number).ToList());
+                .ToDictionary(o => GetValidLabel(o.Key, o.Count()), o => o.OrderBy(issue => issue.PublicNumber).ToList());
 
             return issuesByLabel;
         }
@@ -181,7 +184,7 @@ private async Task LoadMilestonesAsync()
 
         private async Task<List<Issue>> GetIssuesAsync(Milestone milestone)
         {
-            var allIssues = await _vcsProvider.GetIssuesAsync(_user, _repository, milestone.Number, ItemStateFilter.Closed).ConfigureAwait(false);
+            var allIssues = await _vcsProvider.GetIssuesAsync(_user, _repository, milestone, ItemStateFilter.Closed).ConfigureAwait(false);
 
             var result = CheckIssuesForValidLabels(allIssues);
 
diff --git a/src/GitReleaseManager.Core/Templates/default/issue-note.sbn b/src/GitReleaseManager.Core/Templates/default/issue-note.sbn
index ddfdb2c5..218ae3cb 100644
--- a/src/GitReleaseManager.Core/Templates/default/issue-note.sbn
+++ b/src/GitReleaseManager.Core/Templates/default/issue-note.sbn
@@ -1 +1,6 @@
-- [__#{{ issue.number }}__]({{ issue.html_url }}) {{ issue.title }}
+{{
+    if issue.is_pull_request
+}}- [__!{{ issue.public_number }}__]({{ issue.html_url }}) {{ issue.title }}
+{{  else
+}}- [__#{{ issue.public_number }}__]({{ issue.html_url }}) {{ issue.title }}
+{{  end -}}
diff --git a/src/GitReleaseManager.Core/Templates/default/release-info.sbn b/src/GitReleaseManager.Core/Templates/default/release-info.sbn
index 6a1084a5..c8f7e8e2 100644
--- a/src/GitReleaseManager.Core/Templates/default/release-info.sbn
+++ b/src/GitReleaseManager.Core/Templates/default/release-info.sbn
@@ -1,9 +1,9 @@
 {{
     if issues.count > 0
         if commits.count > 0
-}}As part of this release we had [{{ commits.count }} {{ commits.count | string.pluralize "commit" "commits" }}]({{ commits.html_url }}) which resulted in [{{ issues.count }} {{ issues.count | string.pluralize "issue" "issues" }}]({{ milestone.target.html_url }}?closed=1) being closed.
+}}As part of this release we had [{{ commits.count }} {{ commits.count | string.pluralize "commit" "commits" }}]({{ commits.html_url }}) which resulted in [{{ issues.count }} {{ issues.count | string.pluralize "issue" "issues" }}]({{ milestone.target.html_url }}?{{ milestone.query_string }}) being closed.
 {{      else
-}}As part of this release we had [{{ issues.count }} {{ issues.count | string.pluralize "issue" "issues" }}]({{ milestone.target.html_url }}?closed=1) closed.
+}}As part of this release we had [{{ issues.count }} {{ issues.count | string.pluralize "issue" "issues" }}]({{ milestone.target.html_url }}?{{ milestone.query_string }}) closed.
 {{      end
     else if commits.count > 0
 }}As part of this release we had [{{ commits.count }} {{ commits.count | string.pluralize "commit" "commits" }}]({{ commits.html_url }}).
diff --git a/src/GitReleaseManager.Core/VcsService.cs b/src/GitReleaseManager.Core/VcsService.cs
index f9499f44..601a20b3 100644
--- a/src/GitReleaseManager.Core/VcsService.cs
+++ b/src/GitReleaseManager.Core/VcsService.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Security.Cryptography;
@@ -114,7 +115,7 @@ public async Task DiscardReleaseAsync(string owner, string repository, string ta
 
                 if (release.Draft)
                 {
-                    await _vcsProvider.DeleteReleaseAsync(owner, repository, release.Id).ConfigureAwait(false);
+                    await _vcsProvider.DeleteReleaseAsync(owner, repository, release).ConfigureAwait(false);
                 }
                 else
                 {
@@ -141,7 +142,7 @@ private async Task AddAssetsAsync(string owner, string repository, string tagNam
                     {
                         if (!File.Exists(asset))
                         {
-                            var message = string.Format("Requested asset to be uploaded doesn't exist: {0}", asset);
+                            var message = string.Format(CultureInfo.CurrentCulture, "The requested asset to be uploaded doesn't exist: {0}", asset);
                             throw new FileNotFoundException(message);
                         }
 
@@ -151,7 +152,15 @@ private async Task AddAssetsAsync(string owner, string repository, string tagNam
                         if (existingAsset != null)
                         {
                             _logger.Warning("Requested asset to be uploaded already exists on draft release, replacing with new file: {AssetPath}", asset);
-                            await _vcsProvider.DeleteAssetAsync(owner, repository, existingAsset.Id).ConfigureAwait(false);
+
+                            if (_vcsProvider is GitLabProvider)
+                            {
+                                _logger.Error("Deleting assets is not currently supported when targeting GitLab.");
+                            }
+                            else
+                            {
+                                await _vcsProvider.DeleteAssetAsync(owner, repository, existingAsset).ConfigureAwait(false);
+                            }
                         }
 
                         var upload = new ReleaseAssetUpload
@@ -177,7 +186,7 @@ private async Task AddAssetsAsync(string owner, string repository, string tagNam
                         if (!release.Body.Contains(_configuration.Create.ShaSectionHeading))
                         {
                             _logger.Debug("Creating SHA section header");
-                            stringBuilder.AppendLine(string.Format("### {0}", _configuration.Create.ShaSectionHeading));
+                            stringBuilder.AppendFormat(CultureInfo.InvariantCulture, "### {0}", _configuration.Create.ShaSectionHeading).AppendLine();
                         }
 
                         foreach (var asset in assets)
@@ -191,7 +200,7 @@ private async Task AddAssetsAsync(string owner, string repository, string tagNam
 
                             _logger.Debug("Creating SHA checksum for {Name}.", file.Name);
 
-                            stringBuilder.AppendFormat(_configuration.Create.ShaSectionLineFormat, file.Name, ComputeSha256Hash(asset));
+                            stringBuilder.AppendFormat(CultureInfo.InvariantCulture, _configuration.Create.ShaSectionLineFormat, file.Name, ComputeSha256Hash(asset));
                             stringBuilder.AppendLine();
                         }
 
@@ -246,7 +255,7 @@ public async Task CloseMilestoneAsync(string owner, string repository, string mi
                 var milestone = await _vcsProvider.GetMilestoneAsync(owner, repository, milestoneTitle, ItemStateFilter.Open).ConfigureAwait(false);
 
                 _logger.Verbose("Closing milestone '{Title}' on '{Owner}/{Repository}'", milestoneTitle, owner, repository);
-                await _vcsProvider.SetMilestoneStateAsync(owner, repository, milestone.Number, ItemState.Closed).ConfigureAwait(false);
+                await _vcsProvider.SetMilestoneStateAsync(owner, repository, milestone, ItemState.Closed).ConfigureAwait(false);
 
                 if (_configuration.Close.IssueComments)
                 {
@@ -267,7 +276,7 @@ public async Task OpenMilestoneAsync(string owner, string repository, string mil
                 var milestone = await _vcsProvider.GetMilestoneAsync(owner, repository, milestoneTitle, ItemStateFilter.Closed).ConfigureAwait(false);
 
                 _logger.Verbose("Opening milestone '{Title}' on '{Owner}/{Repository}'", milestoneTitle, owner, repository);
-                await _vcsProvider.SetMilestoneStateAsync(owner, repository, milestone.Number, ItemState.Open).ConfigureAwait(false);
+                await _vcsProvider.SetMilestoneStateAsync(owner, repository, milestone, ItemState.Open).ConfigureAwait(false);
             }
             catch (NotFoundException)
             {
@@ -284,7 +293,7 @@ public async Task PublishReleaseAsync(string owner, string repository, string ta
                 _logger.Verbose("Publishing release '{TagName}' on '{Owner}/{Repository}'", tagName, owner, repository);
                 _logger.Debug("{@Release}", release);
 
-                await _vcsProvider.PublishReleaseAsync(owner, repository, tagName, release.Id).ConfigureAwait(false);
+                await _vcsProvider.PublishReleaseAsync(owner, repository, tagName, release).ConfigureAwait(false);
             }
             catch (NotFoundException)
             {
@@ -313,7 +322,7 @@ public async Task CreateLabelsAsync(string owner, string repository)
 
                 _logger.Verbose("Removing existing labels");
                 _logger.Debug("{@Labels}", labels);
-                var deleteLabelsTasks = labels.Select(label => _vcsProvider.DeleteLabelAsync(owner, repository, label.Name));
+                var deleteLabelsTasks = labels.Select(label => _vcsProvider.DeleteLabelAsync(owner, repository, label));
                 await Task.WhenAll(deleteLabelsTasks).ConfigureAwait(false);
 
                 _logger.Verbose("Creating new standard labels");
@@ -374,8 +383,8 @@ private async Task AddIssueCommentsAsync(string owner, string repository, Milest
             const string detectionComment = "<!-- GitReleaseManager release comment -->";
             var issueComment = detectionComment + "\n" + _configuration.Close.IssueCommentFormat.ReplaceTemplate(new { owner, repository, Milestone = milestone.Title });
 
-            _logger.Verbose("Finding issues with milestone: '{Milestone}", milestone.Number);
-            var issues = await _vcsProvider.GetIssuesAsync(owner, repository, milestone.Number, ItemStateFilter.Closed).ConfigureAwait(false);
+            _logger.Verbose("Finding issues with milestone: '{Milestone}", milestone.PublicNumber);
+            var issues = await _vcsProvider.GetIssuesAsync(owner, repository, milestone, ItemStateFilter.Closed).ConfigureAwait(false);
 
             foreach (var issue in issues)
             {
@@ -383,28 +392,29 @@ private async Task AddIssueCommentsAsync(string owner, string repository, Milest
 
                 try
                 {
-                    if (!await CommentsIncludeStringAsync(owner, repository, issue.Number, detectionComment).ConfigureAwait(false))
+                    var issueType = _vcsProvider.GetIssueType(issue);
+                    if (!await CommentsIncludeStringAsync(owner, repository, issue, detectionComment).ConfigureAwait(false))
                     {
-                        _logger.Information("Adding release comment for issue #{IssueNumber}", issue.Number);
-                        await _vcsProvider.CreateIssueCommentAsync(owner, repository, issue.Number, issueComment).ConfigureAwait(false);
+                        _logger.Information("Adding release comment for {IssueType} #{IssueNumber}", issueType, issue.PublicNumber);
+                        await _vcsProvider.CreateIssueCommentAsync(owner, repository, issue, issueComment).ConfigureAwait(false);
                     }
                     else
                     {
-                        _logger.Information("Issue #{IssueNumber} already contains release comment, skipping...", issue.Number);
+                        _logger.Information("{IssueType} #{IssueNumber} already contains release comment, skipping...", issueType, issue.PublicNumber);
                     }
                 }
                 catch (ForbiddenException)
                 {
-                    _logger.Error("Unable to add comment to issue #{IssueNumber}. Insufficient permissions.", issue.Number);
+                    _logger.Error("Unable to add a comment to issue #{IssueNumber}. Insufficient permissions.", issue.PublicNumber);
                     break;
                 }
             }
         }
 
-        private async Task<bool> CommentsIncludeStringAsync(string owner, string repository, int issueNumber, string comment)
+        private async Task<bool> CommentsIncludeStringAsync(string owner, string repository, Issue issue, string comment)
         {
-            _logger.Verbose("Finding issue comment created by GitReleaseManager for issue #{IssueNumber}", issueNumber);
-            var issueComments = await _vcsProvider.GetIssueCommentsAsync(owner, repository, issueNumber).ConfigureAwait(false);
+            _logger.Verbose("Finding issue comment created by GitReleaseManager for issue #{IssueNumber}", issue.PublicNumber);
+            var issueComments = await _vcsProvider.GetIssueCommentsAsync(owner, repository, issue).ConfigureAwait(false);
 
             return issueComments.Any(c => c.Body.Contains(comment));
         }
diff --git a/src/GitReleaseManager.IntegrationTests/GitHubProviderIntegrationTests.cs b/src/GitReleaseManager.IntegrationTests/GitHubProviderIntegrationTests.cs
index 272eb943..9c7483ad 100644
--- a/src/GitReleaseManager.IntegrationTests/GitHubProviderIntegrationTests.cs
+++ b/src/GitReleaseManager.IntegrationTests/GitHubProviderIntegrationTests.cs
@@ -6,7 +6,6 @@
 using GitReleaseManager.Core.Provider;
 using NUnit.Framework;
 using Octokit;
-using Serilog;
 using Shouldly;
 using Issue = GitReleaseManager.Core.Model.Issue;
 using Milestone = GitReleaseManager.Core.Model.Milestone;
@@ -24,7 +23,6 @@ public class GitHubProviderIntegrationTests
         private GitHubProvider _gitHubProvider;
         private IGitHubClient _gitHubClient;
         private IMapper _mapper;
-        private ILogger _logger;
 
         private string _token;
         private string _releaseBaseTag;
@@ -43,7 +41,6 @@ public void OneTimeSetUp()
             }
 
             _mapper = AutoMapperConfiguration.Configure();
-            _logger = new LoggerConfiguration().WriteTo.Console().CreateLogger();
             _gitHubClient = new GitHubClient(new ProductHeaderValue("GitReleaseManager")) { Credentials = new Credentials(_token) };
             _gitHubProvider = new GitHubProvider(_gitHubClient, _mapper);
         }
@@ -63,14 +60,14 @@ public async Task Should_Get_Milestones()
             var result = await _gitHubProvider.GetMilestonesAsync(OWNER, REPOSITORY).ConfigureAwait(false);
             result.Count().ShouldBeGreaterThan(0);
 
-            _milestone = result.OrderByDescending(m => m.Number).First();
+            _milestone = result.OrderByDescending(m => m.PublicNumber).First();
         }
 
         [Test]
         [Order(3)]
         public async Task Should_Get_Issues()
         {
-            var result = await _gitHubProvider.GetIssuesAsync(OWNER, REPOSITORY, _milestone.Number).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetIssuesAsync(OWNER, REPOSITORY, _milestone).ConfigureAwait(false);
             result.Count().ShouldBeGreaterThan(0);
 
             _issue = result.First();
@@ -80,7 +77,7 @@ public async Task Should_Get_Issues()
         [Order(4)]
         public async Task Should_Get_Issue_Comments()
         {
-            var result = await _gitHubProvider.GetIssueCommentsAsync(OWNER, REPOSITORY, _issue.Number).ConfigureAwait(false);
+            var result = await _gitHubProvider.GetIssueCommentsAsync(OWNER, REPOSITORY, _issue).ConfigureAwait(false);
             result.Count().ShouldBeGreaterThan(0);
         }
 
diff --git a/src/GitReleaseManager.IntegrationTests/GitLabProviderIntegrationTests.cs b/src/GitReleaseManager.IntegrationTests/GitLabProviderIntegrationTests.cs
new file mode 100644
index 00000000..91306939
--- /dev/null
+++ b/src/GitReleaseManager.IntegrationTests/GitLabProviderIntegrationTests.cs
@@ -0,0 +1,103 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using AutoMapper;
+using GitReleaseManager.Core;
+using GitReleaseManager.Core.Provider;
+using NGitLab;
+using NUnit.Framework;
+using Serilog;
+using Shouldly;
+using Issue = GitReleaseManager.Core.Model.Issue;
+using Milestone = GitReleaseManager.Core.Model.Milestone;
+
+namespace GitReleaseManager.IntegrationTests
+{
+    [TestFixture]
+    [Explicit]
+    public class GitLabProviderIntegrationTests
+    {
+        private const string OWNER = "gep13";
+        private const string REPOSITORY = "grm-test";
+        private const bool SKIP_PRERELEASES = false;
+
+        private GitLabProvider _gitLabProvider;
+        private IGitLabClient _gitLabClient;
+        private IMapper _mapper;
+        private ILogger _logger;
+
+        private string _token;
+        private string _releaseBaseTag;
+        private string _releaseHeadTag;
+        private Issue _issue;
+        private Milestone _milestone;
+
+        [OneTimeSetUp]
+        public void OneTimeSetUp()
+        {
+            _token = Environment.GetEnvironmentVariable("GITTOOLS_GITLAB_TOKEN");
+
+            if (string.IsNullOrWhiteSpace(_token))
+            {
+                Assert.Inconclusive("Unable to locate credentials for accessing GitLab API");
+            }
+
+            _mapper = AutoMapperConfiguration.Configure();
+            _logger = new LoggerConfiguration().WriteTo.Console().CreateLogger();
+            _gitLabClient = new GitLabClient("https://gitlab.com", _token);
+            _gitLabProvider = new GitLabProvider(_gitLabClient, _mapper, _logger);
+        }
+
+        [Test]
+        [Order(1)]
+        public async Task Should_Get_Milestones()
+        {
+            var result = await _gitLabProvider.GetMilestonesAsync(OWNER, REPOSITORY).ConfigureAwait(false);
+            result.Count().ShouldBeGreaterThan(0);
+
+            _milestone = result.OrderByDescending(m => m.PublicNumber).First();
+        }
+
+        [Test]
+        [Order(2)]
+        public async Task Should_Get_Issues()
+        {
+            var result = await _gitLabProvider.GetIssuesAsync(OWNER, REPOSITORY, _milestone).ConfigureAwait(false);
+            result.Count().ShouldBeGreaterThan(0);
+
+            _issue = result.First();
+        }
+
+        [Test]
+        [Order(3)]
+        public async Task Should_Get_Issue_Comments()
+        {
+            var result = await _gitLabProvider.GetIssueCommentsAsync(OWNER, REPOSITORY, _issue).ConfigureAwait(false);
+            result.Count().ShouldBeGreaterThan(0);
+        }
+
+        [Test]
+        [Order(4)]
+        public async Task Should_Get_Releases()
+        {
+            var result = await _gitLabProvider.GetReleasesAsync(OWNER, REPOSITORY, SKIP_PRERELEASES).ConfigureAwait(false);
+            result.Count().ShouldBeGreaterThan(0);
+
+            var orderedReleases = result.OrderByDescending(r => r.Id).ToList();
+
+            _releaseBaseTag = orderedReleases[1].TagName;
+            _releaseHeadTag = orderedReleases[0].TagName;
+        }
+
+        [Test]
+        [Order(5)]
+        public async Task Should_Get_Commits_Count()
+        {
+            // TODO: This is waiting on a PR being merged...
+            // https://github.com/ubisoft/NGitLab/pull/444
+            // Once it is, we might be able to implement what is necessary here.
+            // var result = await _gitLabProvider.GetCommitsCountAsync(OWNER, REPOSITORY, _releaseBaseTag, _releaseHeadTag).ConfigureAwait(false);
+            // result.ShouldBeGreaterThan(0);
+        }
+    }
+}
diff --git a/src/GitReleaseManager.Tests/ReleaseNotesBuilderTests.cs b/src/GitReleaseManager.Tests/ReleaseNotesBuilderTests.cs
index 3d6007db..7b3126e6 100644
--- a/src/GitReleaseManager.Tests/ReleaseNotesBuilderTests.cs
+++ b/src/GitReleaseManager.Tests/ReleaseNotesBuilderTests.cs
@@ -231,12 +231,15 @@ private static void AcceptTest(int commits, Config config, Milestone milestone,
             vcsProvider.GetCommitsUrl(owner, repository, Arg.Any<string>(), Arg.Any<string>())
                 .Returns(o => new GitHubProvider(null, null).GetCommitsUrl((string)o[0], (string)o[1], (string)o[2], (string)o[3]));
 
-            vcsProvider.GetIssuesAsync(owner, repository, milestoneNumber, ItemStateFilter.Closed)
+            vcsProvider.GetIssuesAsync(owner, repository, milestone, ItemStateFilter.Closed)
                 .Returns(Task.FromResult((IEnumerable<Issue>)vcsService.Issues));
 
             vcsProvider.GetMilestonesAsync(owner, repository, Arg.Any<ItemStateFilter>())
                 .Returns(Task.FromResult((IEnumerable<Milestone>)vcsService.Milestones));
 
+            vcsProvider.GetMilestoneQueryString()
+                .Returns("closed=1");
+
             var builder = new ReleaseNotesBuilder(vcsProvider, logger, fileSystem, configuration, new TemplateFactory(fileSystem, configuration, TemplateKind.Create));
             var notes = builder.BuildReleaseNotesAsync(owner, repository, milestone.Title, ReleaseTemplates.DEFAULT_NAME).Result;
 
@@ -249,7 +252,8 @@ private static Milestone CreateMilestone(string version, string description = nu
             {
                 Title = version,
                 Description = description,
-                Number = 1,
+                PublicNumber = 1,
+                InternalNumber = 123,
                 HtmlUrl = "https://github.com/gep13/FakeRepository/issues?q=milestone%3A" + version,
                 Version = new Version(version),
             };
@@ -259,7 +263,7 @@ private static Issue CreateIssue(int number, params string[] labels)
         {
             return new Issue
             {
-                Number = number,
+                PublicNumber = number,
                 Labels = labels.Select(l => new Label { Name = l }).ToList(),
                 HtmlUrl = "http://example.com/" + number,
                 Title = "Issue " + number,
diff --git a/src/GitReleaseManager.Tool/GitReleaseManager.Tool.csproj b/src/GitReleaseManager.Tool/GitReleaseManager.Tool.csproj
index 99fad416..205bb31c 100644
--- a/src/GitReleaseManager.Tool/GitReleaseManager.Tool.csproj
+++ b/src/GitReleaseManager.Tool/GitReleaseManager.Tool.csproj
@@ -38,6 +38,7 @@
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         <PrivateAssets>all</PrivateAssets>
         </PackageReference>
+        <PackageReference Include="NGitLab" Version="6.39.0" />
         <PackageReference Include="Octokit" Version="7.1.0" />
         <PackageReference Include="Serilog.Sinks.Console" Version="4.1.0" />
         <PackageReference Include="Serilog.Sinks.Debug" Version="2.0.0" PrivateAssets="All" />