diff --git a/Cargo.lock b/Cargo.lock
index 4e8df11306..852078c590 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2447,6 +2447,7 @@ dependencies = [
  "gitbutler-url",
  "gitbutler-user",
  "gix",
+ "itertools 0.13.0",
  "log",
  "resolve-path",
  "serde",
diff --git a/apps/desktop/src/lib/commit/CommitCard.svelte b/apps/desktop/src/lib/commit/CommitCard.svelte
index 8266aa3648..6fc9530227 100644
--- a/apps/desktop/src/lib/commit/CommitCard.svelte
+++ b/apps/desktop/src/lib/commit/CommitCard.svelte
@@ -4,10 +4,12 @@
 	import { BaseBranch } from '$lib/baseBranch/baseBranch';
 	import CommitMessageInput from '$lib/commit/CommitMessageInput.svelte';
 	import { persistedCommitMessage } from '$lib/config/config';
+	import { featureBranchStacking } from '$lib/config/uiFeatureFlags';
 	import { draggableCommit } from '$lib/dragging/draggable';
 	import { DraggableCommit, nonDraggable } from '$lib/dragging/draggables';
 	import BranchFilesList from '$lib/file/BranchFilesList.svelte';
 	import { ModeService } from '$lib/modes/service';
+	import TextBox from '$lib/shared/TextBox.svelte';
 	import { copyToClipboard } from '$lib/utils/clipboard';
 	import { getContext, getContextStore, maybeGetContext } from '$lib/utils/context';
 	import { openExternalUrl } from '$lib/utils/url';
@@ -48,6 +50,8 @@
 
 	const currentCommitMessage = persistedCommitMessage(project.id, branch?.id || '');
 
+	const branchStacking = featureBranchStacking();
+
 	let draggableCommitElement: HTMLElement | null = null;
 	let files: RemoteFile[] = [];
 	let showDetails = false;
@@ -82,6 +86,20 @@
 	let commitMessageValid = false;
 	let description = '';
 
+	let createRefModal: Modal;
+	let createRefName = $baseBranch.remoteName + '/';
+
+	function openCreateRefModal(e: Event, commit: DetailedCommit | Commit) {
+		e.stopPropagation();
+		createRefModal.show(commit);
+	}
+
+	function pushCommitRef(commit: DetailedCommit) {
+		if (branch && commit.remoteRef) {
+			branchController.pushChangeReference(branch.id, commit.remoteRef);
+		}
+	}
+
 	function openCommitMessageModal(e: Event) {
 		e.stopPropagation();
 
@@ -156,6 +174,29 @@
 	{/snippet}
 </Modal>
 
+<Modal bind:this={createRefModal} width="small">
+	{#snippet children(commit)}
+		<TextBox label="Remote branch name" id="newRemoteName" bind:value={createRefName} focus />
+		<Button
+			style="pop"
+			kind="solid"
+			onclick={() => {
+				branchController.createChangeReference(
+					branch?.id || '',
+					'refs/remotes/' + createRefName,
+					commit.changeId
+				);
+				createRefModal.close();
+			}}
+		>
+			Ok
+		</Button>
+	{/snippet}
+	{#snippet controls(close)}
+		<Button style="ghost" outline type="reset" onclick={close}>Cancel</Button>
+	{/snippet}
+</Modal>
+
 <div
 	class="commit-row"
 	class:is-commit-open={showDetails}
@@ -315,6 +356,14 @@
 						<span class="commit__subtitle-divider">•</span>
 
 						<span>{getTimeAndAuthor()}</span>
+
+						{#if $branchStacking && commit instanceof DetailedCommit}
+							<div
+								style="background-color:var(--clr-core-pop-80); border-radius: 3px; padding: 2px;"
+							>
+								{commit?.remoteRef}
+							</div>
+						{/if}
 					</div>
 				{/if}
 			</div>
@@ -352,6 +401,26 @@
 										icon="edit-small"
 										onclick={openCommitMessageModal}>Edit message</Button
 									>
+									{#if $branchStacking && commit instanceof DetailedCommit && !commit.remoteRef}
+										<Button
+											size="tag"
+											style="ghost"
+											outline
+											icon="branch"
+											onclick={(e: Event) => {openCreateRefModal(e, commit)}}>Create ref</Button
+										>
+									{/if}
+									{#if $branchStacking && commit instanceof DetailedCommit && commit.remoteRef}
+										<Button
+											size="tag"
+											style="ghost"
+											outline
+											icon="remote"
+											onclick={() => {
+												pushCommitRef(commit);
+											}}>Push ref</Button
+										>
+									{/if}
 								{/if}
 								{#if canEdit() && project.succeedingRebases}
 									<Button size="tag" style="ghost" outline onclick={editPatch}>
diff --git a/apps/desktop/src/lib/config/uiFeatureFlags.ts b/apps/desktop/src/lib/config/uiFeatureFlags.ts
index 41df11a8fa..f72b07f71b 100644
--- a/apps/desktop/src/lib/config/uiFeatureFlags.ts
+++ b/apps/desktop/src/lib/config/uiFeatureFlags.ts
@@ -15,3 +15,8 @@ export function featureInlineUnifiedDiffs(): Persisted<boolean> {
 	const key = 'inlineUnifiedDiffs';
 	return persisted(false, key);
 }
+
+export function featureBranchStacking(): Persisted<boolean> {
+	const key = 'branchStacking';
+	return persisted(false, key);
+}
diff --git a/apps/desktop/src/lib/vbranches/branchController.ts b/apps/desktop/src/lib/vbranches/branchController.ts
index 22ff7d0310..4212741390 100644
--- a/apps/desktop/src/lib/vbranches/branchController.ts
+++ b/apps/desktop/src/lib/vbranches/branchController.ts
@@ -96,6 +96,44 @@ export class BranchController {
 		}
 	}
 
+	/*
+	 * Creates a new GitButler change reference associated with a branch.
+	 * @param branchId
+	 * @param reference in the format refs/remotes/origin/my-branch (must be remote)
+	 * @param changeId The change id to point the reference to
+	 */
+	async createChangeReference(branchId: string, referenceName: string, changeId: string) {
+		try {
+			await invoke<void>('create_change_reference', {
+				projectId: this.projectId,
+				branchId: branchId,
+				name: referenceName,
+				changeId: changeId
+			});
+		} catch (err) {
+			showError('Failed to create branch reference', err);
+		}
+	}
+
+	/*
+	 * Pushes a change reference to (converted to a git reference to a commit) to the remote
+	 * @param branchId
+	 * @param reference in the format refs/remotes/origin/my-branch (must be remote)
+	 * @param changeId The change id that is being pushed
+	 */
+	async pushChangeReference(branchId: string, referenceName: string, withForce: boolean = false) {
+		try {
+			await invoke<void>('push_change_reference', {
+				projectId: this.projectId,
+				branchId: branchId,
+				name: referenceName,
+				withForce: withForce
+			});
+		} catch (err) {
+			showError('Failed to push change reference', err);
+		}
+	}
+
 	async updateBranchRemoteName(branchId: string, upstream: string) {
 		try {
 			await invoke<void>('update_virtual_branch', {
diff --git a/apps/desktop/src/lib/vbranches/types.ts b/apps/desktop/src/lib/vbranches/types.ts
index 4095aae72e..53ab7fd6ff 100644
--- a/apps/desktop/src/lib/vbranches/types.ts
+++ b/apps/desktop/src/lib/vbranches/types.ts
@@ -177,6 +177,8 @@ export class DetailedCommit {
 	isSigned!: boolean;
 	relatedTo?: Commit;
 	conflicted!: boolean;
+	// Set if a GitButler branch reference pointing to this commit exists. In the format of "refs/remotes/origin/my-branch"
+	remoteRef?: string | undefined;
 
 	prev?: DetailedCommit;
 	next?: DetailedCommit;
diff --git a/apps/desktop/src/routes/settings/experimental/+page.svelte b/apps/desktop/src/routes/settings/experimental/+page.svelte
index 225e66b2b1..4fe8c8e6e8 100644
--- a/apps/desktop/src/routes/settings/experimental/+page.svelte
+++ b/apps/desktop/src/routes/settings/experimental/+page.svelte
@@ -2,13 +2,15 @@
 	import SectionCard from '$lib/components/SectionCard.svelte';
 	import {
 		featureBaseBranchSwitching,
-		featureInlineUnifiedDiffs
+		featureInlineUnifiedDiffs,
+		featureBranchStacking
 	} from '$lib/config/uiFeatureFlags';
 	import ContentWrapper from '$lib/settings/ContentWrapper.svelte';
 	import Toggle from '$lib/shared/Toggle.svelte';
 
 	const baseBranchSwitching = featureBaseBranchSwitching();
 	const inlineUnifiedDiffs = featureInlineUnifiedDiffs();
+	const branchStacking = featureBranchStacking();
 </script>
 
 <ContentWrapper title="Experimental features">
@@ -45,6 +47,19 @@
 			/>
 		</svelte:fragment>
 	</SectionCard>
+	<SectionCard labelFor="branchStacking" orientation="row">
+		<svelte:fragment slot="title">Branch stacking</svelte:fragment>
+		<svelte:fragment slot="caption">
+			Allows for branch / pull request stacking. The user interface for this is still very crude.
+		</svelte:fragment>
+		<svelte:fragment slot="actions">
+			<Toggle
+				id="branchStacking"
+				checked={$branchStacking}
+				on:click={() => ($branchStacking = !$branchStacking)}
+			/>
+		</svelte:fragment>
+	</SectionCard>
 </ContentWrapper>
 
 <style>
diff --git a/crates/gitbutler-branch-actions/src/actions.rs b/crates/gitbutler-branch-actions/src/actions.rs
index 7b428d835b..9a47e5dbc8 100644
--- a/crates/gitbutler-branch-actions/src/actions.rs
+++ b/crates/gitbutler-branch-actions/src/actions.rs
@@ -1,5 +1,7 @@
 use anyhow::{Context, Result};
-use gitbutler_branch::{BranchCreateRequest, BranchId, BranchOwnershipClaims, BranchUpdateRequest};
+use gitbutler_branch::{
+    BranchCreateRequest, BranchId, BranchOwnershipClaims, BranchUpdateRequest, ChangeReference,
+};
 use gitbutler_command_context::CommandContext;
 use gitbutler_operating_modes::assure_open_workspace_mode;
 use gitbutler_oplog::{
@@ -356,6 +358,30 @@ impl VirtualBranchActions {
         branch::insert_blank_commit(&ctx, branch_id, commit_oid, offset).map_err(Into::into)
     }
 
+    pub fn create_change_reference(
+        &self,
+        project: &Project,
+        branch_id: BranchId,
+        name: ReferenceName,
+        change_id: String,
+    ) -> Result<ChangeReference> {
+        let ctx = open_with_verify(project)?;
+        assure_open_workspace_mode(&ctx).context("Requires an open workspace mode")?;
+        gitbutler_repo::create_change_reference(&ctx, branch_id, name, change_id)
+    }
+
+    pub fn push_change_reference(
+        &self,
+        project: &Project,
+        branch_id: BranchId,
+        name: ReferenceName,
+        with_force: bool,
+    ) -> Result<()> {
+        let helper = Helper::default();
+        let ctx = open_with_verify(project)?;
+        gitbutler_repo::push_change_reference(&ctx, branch_id, name, with_force, &helper)
+    }
+
     pub fn reorder_commit(
         &self,
         project: &Project,
diff --git a/crates/gitbutler-branch-actions/src/base.rs b/crates/gitbutler-branch-actions/src/base.rs
index 526b7378e7..fce18420d9 100644
--- a/crates/gitbutler-branch-actions/src/base.rs
+++ b/crates/gitbutler-branch-actions/src/base.rs
@@ -251,6 +251,7 @@ pub(crate) fn set_base_branch(
                 applied: true,
                 in_workspace: true,
                 not_in_workspace_wip_change_id: None,
+                references: vec![],
             };
 
             vb_state.set_branch(branch)?;
diff --git a/crates/gitbutler-branch-actions/src/branch_manager/branch_creation.rs b/crates/gitbutler-branch-actions/src/branch_manager/branch_creation.rs
index bbf226f7c8..ec47113ca0 100644
--- a/crates/gitbutler-branch-actions/src/branch_manager/branch_creation.rs
+++ b/crates/gitbutler-branch-actions/src/branch_manager/branch_creation.rs
@@ -112,6 +112,7 @@ impl BranchManager<'_> {
             in_workspace: true,
             not_in_workspace_wip_change_id: None,
             source_refname: None,
+            references: vec![],
         };
 
         if let Some(ownership) = &create.ownership {
@@ -256,6 +257,7 @@ impl BranchManager<'_> {
                 applied: true,
                 in_workspace: true,
                 not_in_workspace_wip_change_id: None,
+                references: vec![],
             }
         };
 
diff --git a/crates/gitbutler-branch-actions/src/commit.rs b/crates/gitbutler-branch-actions/src/commit.rs
index c0ba6c289c..8ff3f3e9b9 100644
--- a/crates/gitbutler-branch-actions/src/commit.rs
+++ b/crates/gitbutler-branch-actions/src/commit.rs
@@ -6,6 +6,8 @@ use anyhow::{Context, Result};
 use gitbutler_branch::{Branch, BranchId};
 use gitbutler_command_context::CommandContext;
 use gitbutler_commit::commit_ext::CommitExt;
+use gitbutler_reference::ReferenceName;
+use gitbutler_repo::list_branch_references;
 use gitbutler_serde::BStringForFrontend;
 use serde::Serialize;
 
@@ -34,10 +36,11 @@ pub struct VirtualBranchCommit {
     pub change_id: Option<String>,
     pub is_signed: bool,
     pub conflicted: bool,
+    pub remote_ref: Option<ReferenceName>,
 }
 
 pub(crate) fn commit_to_vbranch_commit(
-    repository: &CommandContext,
+    ctx: &CommandContext,
     branch: &Branch,
     commit: &git2::Commit,
     is_integrated: bool,
@@ -46,8 +49,7 @@ pub(crate) fn commit_to_vbranch_commit(
     let timestamp = u128::try_from(commit.time().seconds())?;
     let message = commit.message_bstr().to_owned();
 
-    let files =
-        list_virtual_commit_files(repository, commit).context("failed to list commit files")?;
+    let files = list_virtual_commit_files(ctx, commit).context("failed to list commit files")?;
 
     let parent_ids: Vec<git2::Oid> = commit
         .parents()
@@ -56,6 +58,15 @@ pub(crate) fn commit_to_vbranch_commit(
             c
         })
         .collect::<Vec<_>>();
+    let remote_ref = list_branch_references(ctx, branch.id)
+        .map(|references| {
+            references
+                .into_iter()
+                .find(|r| Some(r.change_id.clone()) == commit.change_id())
+        })
+        .ok()
+        .flatten()
+        .map(|r| r.name);
 
     let commit = VirtualBranchCommit {
         id: commit.id(),
@@ -70,6 +81,7 @@ pub(crate) fn commit_to_vbranch_commit(
         change_id: commit.change_id(),
         is_signed: commit.is_signed(),
         conflicted: commit.is_conflicted(),
+        remote_ref,
     };
 
     Ok(commit)
diff --git a/crates/gitbutler-branch/src/branch.rs b/crates/gitbutler-branch/src/branch.rs
index 5a0b5bc431..e71a97cf3a 100644
--- a/crates/gitbutler-branch/src/branch.rs
+++ b/crates/gitbutler-branch/src/branch.rs
@@ -5,7 +5,7 @@ use gitbutler_reference::{normalize_branch_name, Refname, RemoteRefname, Virtual
 use serde::{Deserialize, Serialize, Serializer};
 use std::ops::Deref;
 
-use crate::ownership::BranchOwnershipClaims;
+use crate::{ownership::BranchOwnershipClaims, reference::ChangeReference};
 
 pub type BranchId = Id<Branch>;
 
@@ -67,6 +67,8 @@ pub struct Branch {
     pub in_workspace: bool,
     #[serde(default)]
     pub not_in_workspace_wip_change_id: Option<String>,
+    #[serde(default)]
+    pub references: Vec<ChangeReference>,
 }
 
 fn default_true() -> bool {
diff --git a/crates/gitbutler-branch/src/lib.rs b/crates/gitbutler-branch/src/lib.rs
index 773036604d..05394dbe36 100644
--- a/crates/gitbutler-branch/src/lib.rs
+++ b/crates/gitbutler-branch/src/lib.rs
@@ -16,6 +16,8 @@ pub use ownership::{reconcile_claims, BranchOwnershipClaims, ClaimOutcome};
 pub mod serde;
 mod target;
 pub use target::Target;
+mod reference;
+pub use reference::ChangeReference;
 
 mod state;
 use lazy_static::lazy_static;
diff --git a/crates/gitbutler-branch/src/reference.rs b/crates/gitbutler-branch/src/reference.rs
new file mode 100644
index 0000000000..24860392ff
--- /dev/null
+++ b/crates/gitbutler-branch/src/reference.rs
@@ -0,0 +1,20 @@
+use gitbutler_reference::ReferenceName;
+use serde::{Deserialize, Serialize};
+
+use crate::BranchId;
+
+/// GitButler reference associated with a change (commit) on a virtual branch.
+/// These are not the same as regular Git references, but rather app-managed refs.
+/// Represent a deployable / reviewable part of a virtual branch that can be pushed to a remote
+/// and have a "Pull Request" created for it.
+#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
+pub struct ChangeReference {
+    /// Branch id of the virtual branch this reference belongs to
+    /// Multiple references may belong to the same virtual branch, representing separate deployable / reviewable parts of the vbranch.
+    pub branch_id: BranchId,
+    /// Fully qualified reference name.
+    /// The reference must be a remote reference.
+    pub name: ReferenceName,
+    /// The change id this reference points to.
+    pub change_id: String,
+}
diff --git a/crates/gitbutler-branch/tests/ownership.rs b/crates/gitbutler-branch/tests/ownership.rs
index 9c29288aeb..2adf54ef6c 100644
--- a/crates/gitbutler-branch/tests/ownership.rs
+++ b/crates/gitbutler-branch/tests/ownership.rs
@@ -39,6 +39,7 @@ fn reconcile_ownership_simple() {
         in_workspace: true,
         not_in_workspace_wip_change_id: None,
         source_refname: None,
+        references: vec![],
     };
     let branch_b = Branch {
         name: "b".to_string(),
@@ -67,6 +68,7 @@ fn reconcile_ownership_simple() {
         in_workspace: true,
         not_in_workspace_wip_change_id: None,
         source_refname: None,
+        references: vec![],
     };
     let all_branches: Vec<Branch> = vec![branch_a.clone(), branch_b.clone()];
     let claim: Vec<OwnershipClaim> = vec![OwnershipClaim {
diff --git a/crates/gitbutler-repo/Cargo.toml b/crates/gitbutler-repo/Cargo.toml
index 80dac4ce2e..cf9daf6568 100644
--- a/crates/gitbutler-repo/Cargo.toml
+++ b/crates/gitbutler-repo/Cargo.toml
@@ -36,6 +36,7 @@ gitbutler-commit.workspace = true
 gitbutler-url.workspace = true
 gitbutler-cherry-pick.workspace = true
 uuid.workspace = true
+itertools = "0.13"
 
 [[test]]
 name = "repo"
diff --git a/crates/gitbutler-repo/src/change_reference.rs b/crates/gitbutler-repo/src/change_reference.rs
new file mode 100644
index 0000000000..cd923fe772
--- /dev/null
+++ b/crates/gitbutler-repo/src/change_reference.rs
@@ -0,0 +1,206 @@
+use std::str::FromStr;
+
+use crate::credentials::Helper;
+use crate::{LogUntil, RepoActionsExt};
+use anyhow::Context;
+use anyhow::{anyhow, Result};
+use gitbutler_branch::ChangeReference;
+use gitbutler_branch::VirtualBranchesHandle;
+use gitbutler_branch::{Branch, BranchId};
+use gitbutler_command_context::CommandContext;
+use gitbutler_commit::commit_ext::CommitExt;
+use gitbutler_reference::ReferenceName;
+use itertools::Itertools;
+
+/// Given a branch id, returns the the GitButler references associated with the branch.
+/// References within the same branch effectively represent a stack of sub-branches.
+pub fn list_branch_references(
+    ctx: &CommandContext,
+    branch_id: BranchId,
+) -> Result<Vec<ChangeReference>> {
+    let handle = VirtualBranchesHandle::new(ctx.project().gb_dir());
+    let vbranch = handle.get_branch(branch_id)?;
+    Ok(vbranch.references)
+}
+
+/// Creates a new virtual branch reference and associates it with the branch.
+/// However this will return an error if:
+///   - a reference for the same commit already exists, an error is returned.
+///   - the reference name already exists, an error is returned.
+pub fn create_change_reference(
+    ctx: &CommandContext,
+    branch_id: BranchId,
+    name: ReferenceName,
+    change_id: String,
+) -> Result<ChangeReference> {
+    // The reference must be parseable as a remote reference
+    gitbutler_reference::RemoteRefname::from_str(&name)
+        .context("Failed to parse the provided reference")?;
+    let handle = VirtualBranchesHandle::new(ctx.project().gb_dir());
+
+    // The branch must exist
+    let mut vbranch = handle.get_branch(branch_id)?;
+
+    // Enusre that the commit acutally exists
+    let commit = commit_by_branch_id_and_change_id(ctx, &vbranch, &handle, change_id)?;
+
+    let change_id = commit
+        .change_id()
+        .ok_or(anyhow!("Commit {} does not have a change id", commit.id()))?;
+
+    let branch_reference = ChangeReference {
+        name,
+        branch_id,
+        change_id: change_id.clone(),
+    };
+    let all_references = handle
+        .list_all_branches()?
+        .into_iter()
+        .flat_map(|branch| branch.references)
+        .collect_vec();
+    // Ensure the reference name does not already exist
+    if all_references
+        .iter()
+        .any(|r| r.name == branch_reference.name)
+    {
+        return Err(anyhow!(
+            "A reference {} already exists",
+            branch_reference.name
+        ));
+    }
+    // Ensure the change is not already referenced
+    if all_references.iter().any(|r| r.change_id == change_id) {
+        return Err(anyhow!(
+            "A reference for change {} already exists",
+            change_id
+        ));
+    }
+    validate_commit(&vbranch, commit.id(), ctx, &handle)?;
+    vbranch.references.push(branch_reference.clone());
+    handle.set_branch(vbranch)?;
+    Ok(branch_reference)
+}
+
+/// Updates an existing branch reference to point to a different commit.
+/// Only the commit and change_id can be updated.
+/// The reference is identified by the branch id and the reference name.
+/// This function will return an error if:
+/// - this reference does not exist
+/// - the reference exists, but the commit id is not in the branch
+/// - the reference exists, but the commit id is already associated with another reference
+///
+/// If the commit ID is the same as the current commit ID, the function is a no-op.
+pub fn update_change_reference(
+    ctx: &CommandContext,
+    branch_id: BranchId,
+    name: ReferenceName,
+    new_change_id: String,
+) -> Result<ChangeReference> {
+    // The reference must be parseable as a remote reference
+    gitbutler_reference::RemoteRefname::from_str(&name)
+        .context("Failed to parse the provided reference")?;
+    let handle = VirtualBranchesHandle::new(ctx.project().gb_dir());
+    // The branch must exist
+    let mut vbranch = handle.get_branch(branch_id)?;
+
+    // Enusre that the commit acutally exists
+    let new_commit =
+        commit_by_branch_id_and_change_id(ctx, &vbranch, &handle, new_change_id.clone())
+            .context(anyhow!("Commit for change_id {} not found", new_change_id))?;
+
+    // Fail early if the commit is not valid
+    validate_commit(&vbranch, new_commit.id(), ctx, &handle)?;
+
+    let reference = vbranch
+        .references
+        .iter_mut()
+        .find(|r| r.name == name)
+        .ok_or(anyhow!(
+            "Reference {} not found for branch {}",
+            name,
+            branch_id
+        ))?;
+    reference.change_id = new_change_id;
+    let new_reference = reference.clone();
+    handle.set_branch(vbranch)?;
+    Ok(new_reference)
+}
+
+/// Pushes a gitbutler branch reference to the remote repository.
+pub fn push_change_reference(
+    ctx: &CommandContext,
+    branch_id: BranchId,
+    name: ReferenceName,
+    with_force: bool,
+    credentials: &Helper,
+) -> Result<()> {
+    let handle = VirtualBranchesHandle::new(ctx.project().gb_dir());
+    let vbranch = handle.get_branch(branch_id)?;
+    let reference = vbranch
+        .references
+        .iter()
+        .find(|r| r.name == name)
+        .ok_or_else(|| anyhow!("Reference {} not found", name))?;
+    let upstream_refname = gitbutler_reference::RemoteRefname::from_str(&reference.name)
+        .context("Failed to parse the provided reference")?;
+    let commit =
+        commit_by_branch_id_and_change_id(ctx, &vbranch, &handle, reference.change_id.clone())?;
+    ctx.push(
+        &commit.id(),
+        &upstream_refname,
+        with_force,
+        credentials,
+        None,
+        Some(Some(branch_id)),
+    )
+}
+
+/// Given a branch id and a change id, returns the commit associated with the change id.
+// TODO: We need a more efficient way of getting a commit by change id.
+fn commit_by_branch_id_and_change_id<'a>(
+    ctx: &'a CommandContext,
+    vbranch: &Branch,
+    handle: &VirtualBranchesHandle,
+    change_id: String,
+) -> Result<git2::Commit<'a>> {
+    let target = handle.get_default_target()?;
+    // Find the commit with the change id
+    let commit = ctx
+        .log(vbranch.head, LogUntil::Commit(target.sha))?
+        .iter()
+        .map(|c| c.id())
+        .find(|c| {
+            let commit = ctx.repository().find_commit(*c).expect("Commit not found");
+            commit.change_id().as_deref() == Some(&change_id)
+        })
+        .and_then(|c| ctx.repository().find_commit(c).ok())
+        .ok_or_else(|| anyhow!("Commit with change id {} not found", change_id))?;
+    Ok(commit)
+}
+
+/// Validates a commit in the following ways:
+/// - The reference does not already exists for any other branch
+/// - There is no other reference already pointing to the commit
+/// - The commit is between the branch base and the branch head
+fn validate_commit(
+    vbranch: &Branch,
+    commit_id: git2::Oid,
+    ctx: &CommandContext,
+    handle: &VirtualBranchesHandle,
+) -> Result<()> {
+    let target = handle.get_default_target()?;
+    let branch_commits = ctx
+        .log(vbranch.head, LogUntil::Commit(target.sha))?
+        .iter()
+        .map(|c| c.id())
+        .collect_vec();
+
+    // Assert that the commit is between the branch base and the branch head
+    if !branch_commits.contains(&commit_id) {
+        return Err(anyhow!(
+            "The commit {} is not between the branch base and the branch head",
+            commit_id
+        ));
+    }
+    Ok(())
+}
diff --git a/crates/gitbutler-repo/src/lib.rs b/crates/gitbutler-repo/src/lib.rs
index 2f19da60f5..46ba6fc802 100644
--- a/crates/gitbutler-repo/src/lib.rs
+++ b/crates/gitbutler-repo/src/lib.rs
@@ -17,4 +17,9 @@ pub use config::Config;
 
 pub mod askpass;
 
+mod change_reference;
+
+pub use change_reference::{
+    create_change_reference, list_branch_references, push_change_reference, update_change_reference,
+};
 pub mod temporary_workdir;
diff --git a/crates/gitbutler-repo/tests/change_reference.rs b/crates/gitbutler-repo/tests/change_reference.rs
new file mode 100644
index 0000000000..10ab86fe6a
--- /dev/null
+++ b/crates/gitbutler-repo/tests/change_reference.rs
@@ -0,0 +1,254 @@
+use anyhow::Result;
+use gitbutler_branch::VirtualBranchesHandle;
+use gitbutler_command_context::CommandContext;
+use gitbutler_commit::commit_ext::CommitExt;
+use gitbutler_repo::{
+    create_change_reference, credentials::Helper, list_branch_references, push_change_reference,
+    update_change_reference, LogUntil, RepoActionsExt,
+};
+use tempfile::TempDir;
+
+#[test]
+fn create_success() -> Result<()> {
+    let (ctx, _temp_dir) = command_ctx("multiple-commits")?;
+    let test_ctx = test_ctx(&ctx)?;
+    let reference = create_change_reference(
+        &ctx,
+        test_ctx.branch.id,
+        "refs/remotes/origin/success".into(),
+        test_ctx.commits.first().unwrap().change_id().unwrap(),
+    )?;
+    assert_eq!(reference.branch_id, test_ctx.branch.id);
+    assert_eq!(reference.name, "refs/remotes/origin/success".into());
+    assert_eq!(
+        reference.change_id,
+        test_ctx.commits.first().unwrap().change_id().unwrap()
+    );
+    Ok(())
+}
+
+#[test]
+fn create_multiple() -> Result<()> {
+    let (ctx, _temp_dir) = command_ctx("multiple-commits")?;
+    let test_ctx = test_ctx(&ctx)?;
+    let first = create_change_reference(
+        &ctx,
+        test_ctx.branch.id,
+        "refs/remotes/origin/first".into(),
+        test_ctx.commits.first().unwrap().change_id().unwrap(),
+    )?;
+    assert_eq!(first.branch_id, test_ctx.branch.id);
+    assert_eq!(first.name, "refs/remotes/origin/first".into());
+    assert_eq!(
+        first.change_id,
+        test_ctx.commits.first().unwrap().change_id().unwrap()
+    );
+    let last = create_change_reference(
+        &ctx,
+        test_ctx.branch.id,
+        "refs/remotes/origin/last".into(),
+        test_ctx.commits.last().unwrap().change_id().unwrap(),
+    )?;
+    assert_eq!(last.branch_id, test_ctx.branch.id);
+    assert_eq!(last.name, "refs/remotes/origin/last".into());
+    assert_eq!(
+        last.change_id,
+        test_ctx.commits.last().unwrap().change_id().unwrap()
+    );
+    Ok(())
+}
+
+#[test]
+fn create_fails_with_non_remote_reference() -> Result<()> {
+    let (ctx, _temp_dir) = command_ctx("multiple-commits")?;
+    let test_ctx = test_ctx(&ctx)?;
+    let result = create_change_reference(
+        &ctx,
+        test_ctx.branch.id,
+        "foo".into(),
+        test_ctx.commits.first().unwrap().change_id().unwrap(),
+    );
+    assert_eq!(
+        result.unwrap_err().to_string(),
+        "Failed to parse the provided reference",
+    );
+    Ok(())
+}
+
+#[test]
+fn create_fails_when_branch_reference_with_name_exists() -> Result<()> {
+    let (ctx, _temp_dir) = command_ctx("multiple-commits")?;
+    let test_ctx = test_ctx(&ctx)?;
+    create_change_reference(
+        &ctx,
+        test_ctx.branch.id,
+        "refs/remotes/origin/taken".into(),
+        test_ctx.commits.first().unwrap().change_id().unwrap(),
+    )?;
+    let result = create_change_reference(
+        &ctx,
+        test_ctx.branch.id,
+        "refs/remotes/origin/taken".into(),
+        test_ctx.commits.last().unwrap().change_id().unwrap(),
+    );
+    assert_eq!(
+        result.unwrap_err().to_string(),
+        format!("A reference refs/remotes/origin/taken already exists",),
+    );
+
+    Ok(())
+}
+
+#[test]
+fn create_fails_when_commit_already_referenced() -> Result<()> {
+    let (ctx, _temp_dir) = command_ctx("multiple-commits")?;
+    let test_ctx = test_ctx(&ctx)?;
+    create_change_reference(
+        &ctx,
+        test_ctx.branch.id,
+        "refs/remotes/origin/one".into(),
+        test_ctx.commits.first().unwrap().change_id().unwrap(),
+    )?;
+    let result = create_change_reference(
+        &ctx,
+        test_ctx.branch.id,
+        "refs/remotes/origin/two".into(),
+        test_ctx.commits.first().unwrap().change_id().unwrap(),
+    );
+    assert_eq!(
+        result.unwrap_err().to_string(),
+        format!(
+            "A reference for change {} already exists",
+            test_ctx.commits.first().unwrap().change_id().unwrap()
+        ),
+    );
+
+    Ok(())
+}
+
+#[test]
+fn create_fails_when_commit_in_anothe_branch() -> Result<()> {
+    let (ctx, _temp_dir) = command_ctx("multiple-commits")?;
+    let test_ctx = test_ctx(&ctx)?;
+    let wrong_change = test_ctx.other_commits.first().unwrap().change_id().unwrap();
+    let result = create_change_reference(
+        &ctx,
+        test_ctx.branch.id,
+        "refs/remotes/origin/asdf".into(),
+        wrong_change.clone(),
+    );
+    assert!(result.is_err());
+    Ok(())
+}
+
+#[test]
+fn create_fails_when_change_id_not_found() -> Result<()> {
+    let (ctx, _temp_dir) = command_ctx("multiple-commits")?;
+    let test_ctx = test_ctx(&ctx)?;
+    let result = create_change_reference(
+        &ctx,
+        test_ctx.branch.id,
+        "refs/remotes/origin/baz".into(),
+        "does-not-exist".into(),
+    );
+    assert!(result.is_err());
+    Ok(())
+}
+
+#[test]
+fn list_success() -> Result<()> {
+    let (ctx, _temp_dir) = command_ctx("multiple-commits")?;
+    let test_ctx = test_ctx(&ctx)?;
+    let first_ref = create_change_reference(
+        &ctx,
+        test_ctx.branch.id,
+        "refs/remotes/origin/first".into(),
+        test_ctx.commits.first().unwrap().change_id().unwrap(),
+    )?;
+    let second_ref = create_change_reference(
+        &ctx,
+        test_ctx.branch.id,
+        "refs/remotes/origin/second".into(),
+        test_ctx.commits.last().unwrap().change_id().unwrap(),
+    )?;
+    let result = list_branch_references(&ctx, test_ctx.branch.id)?;
+    assert_eq!(result.len(), 2);
+    assert_eq!(result[0], first_ref);
+    assert_eq!(result[1], second_ref);
+    Ok(())
+}
+
+#[test]
+fn update_success() -> Result<()> {
+    let (ctx, _temp_dir) = command_ctx("multiple-commits")?;
+    let test_ctx = test_ctx(&ctx)?;
+    create_change_reference(
+        &ctx,
+        test_ctx.branch.id,
+        "refs/remotes/origin/first".into(),
+        test_ctx.commits.first().unwrap().change_id().unwrap(),
+    )?;
+    let updated = update_change_reference(
+        &ctx,
+        test_ctx.branch.id,
+        "refs/remotes/origin/first".into(),
+        test_ctx.commits.last().unwrap().change_id().unwrap(),
+    )?;
+    assert_eq!(
+        updated.change_id,
+        test_ctx.commits.last().unwrap().change_id().unwrap()
+    );
+    let list = list_branch_references(&ctx, test_ctx.branch.id)?;
+    assert_eq!(list.len(), 1);
+    assert_eq!(
+        list[0].change_id,
+        test_ctx.commits.last().unwrap().change_id().unwrap()
+    );
+    Ok(())
+}
+
+#[test]
+fn push_success() -> Result<()> {
+    let (ctx, _temp_dir) = command_ctx("multiple-commits")?;
+    let test_ctx = test_ctx(&ctx)?;
+    let reference = create_change_reference(
+        &ctx,
+        test_ctx.branch.id,
+        "refs/remotes/origin/first".into(),
+        test_ctx.commits.first().unwrap().change_id().unwrap(),
+    )?;
+    let result = push_change_reference(
+        &ctx,
+        reference.branch_id,
+        reference.name,
+        false,
+        &Helper::default(),
+    );
+    assert!(result.is_ok());
+    Ok(())
+}
+
+fn command_ctx(name: &str) -> Result<(CommandContext, TempDir)> {
+    gitbutler_testsupport::writable::fixture("stacking.sh", name)
+}
+
+fn test_ctx(ctx: &CommandContext) -> Result<TestContext> {
+    let handle = VirtualBranchesHandle::new(ctx.project().gb_dir());
+    let branches = handle.list_all_branches()?;
+    let branch = branches.iter().find(|b| b.name == "virtual").unwrap();
+    let other_branch = branches.iter().find(|b| b.name != "virtual").unwrap();
+    let target = handle.get_default_target()?;
+    let branch_commits = ctx.log(branch.head, LogUntil::Commit(target.sha))?;
+    let other_commits = ctx.log(other_branch.head, LogUntil::Commit(target.sha))?;
+    Ok(TestContext {
+        branch: branch.clone(),
+        commits: branch_commits,
+        // other_branch: other_branch.clone(),
+        other_commits,
+    })
+}
+struct TestContext<'a> {
+    branch: gitbutler_branch::Branch,
+    commits: Vec<git2::Commit<'a>>,
+    other_commits: Vec<git2::Commit<'a>>,
+}
diff --git a/crates/gitbutler-repo/tests/fixtures/stacking.sh b/crates/gitbutler-repo/tests/fixtures/stacking.sh
new file mode 100644
index 0000000000..d8ec072899
--- /dev/null
+++ b/crates/gitbutler-repo/tests/fixtures/stacking.sh
@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+set -eu -o pipefail
+CLI=${1:?The first argument is the GitButler CLI}
+
+function tick () {
+  if test -z "${tick+set}"; then
+    tick=1675176957
+  else
+    tick=$(($tick + 60))
+  fi
+  GIT_COMMITTER_DATE="$tick +0100"
+  GIT_AUTHOR_DATE="$tick +0100"
+  export GIT_COMMITTER_DATE GIT_AUTHOR_DATE
+}
+tick
+
+git init remote
+(cd remote
+  echo first > file
+  git add . && git commit -m "init"
+)
+
+export GITBUTLER_CLI_DATA_DIR=../user/gitbutler/app-data
+git clone remote multiple-commits 
+(cd multiple-commits
+  $CLI project add --switch-to-integration "$(git rev-parse --symbolic-full-name @{u})"
+
+  $CLI branch create --set-default first_branch
+  echo asdf >> foo
+  tick
+  $CLI branch commit first_branch -m "some commit"
+
+  $CLI branch create --set-default virtual
+  echo change >> file
+  tick
+  $CLI branch commit virtual -m "first commit"
+  echo change2 >> file
+  tick
+  $CLI branch commit virtual -m "second commit"
+  echo change3 >> file
+  tick
+  $CLI branch commit virtual -m "third commit"
+)
diff --git a/crates/gitbutler-repo/tests/mod.rs b/crates/gitbutler-repo/tests/mod.rs
index bb5fd604b5..116e0b3730 100644
--- a/crates/gitbutler-repo/tests/mod.rs
+++ b/crates/gitbutler-repo/tests/mod.rs
@@ -1 +1,2 @@
+mod change_reference;
 mod credentials;
diff --git a/crates/gitbutler-tauri/src/main.rs b/crates/gitbutler-tauri/src/main.rs
index 5bef549318..9953e865cd 100644
--- a/crates/gitbutler-tauri/src/main.rs
+++ b/crates/gitbutler-tauri/src/main.rs
@@ -172,6 +172,8 @@ fn main() {
                     virtual_branches::commands::move_commit_file,
                     virtual_branches::commands::undo_commit,
                     virtual_branches::commands::insert_blank_commit,
+                    virtual_branches::commands::create_change_reference,
+                    virtual_branches::commands::push_change_reference,
                     virtual_branches::commands::reorder_commit,
                     virtual_branches::commands::update_commit_message,
                     virtual_branches::commands::list_remote_branches,
diff --git a/crates/gitbutler-tauri/src/virtual_branches.rs b/crates/gitbutler-tauri/src/virtual_branches.rs
index 5eda70b4d8..caf346fd92 100644
--- a/crates/gitbutler-tauri/src/virtual_branches.rs
+++ b/crates/gitbutler-tauri/src/virtual_branches.rs
@@ -396,6 +396,38 @@ pub mod commands {
         Ok(())
     }
 
+    #[tauri::command(async)]
+    #[instrument(skip(projects, windows), err(Debug))]
+    pub fn create_change_reference(
+        windows: State<'_, WindowState>,
+        projects: State<'_, projects::Controller>,
+        project_id: ProjectId,
+        branch_id: BranchId,
+        name: ReferenceName,
+        change_id: String,
+    ) -> Result<(), Error> {
+        let project = projects.get(project_id)?;
+        VirtualBranchActions.create_change_reference(&project, branch_id, name, change_id)?;
+        emit_vbranches(&windows, project_id);
+        Ok(())
+    }
+
+    #[tauri::command(async)]
+    #[instrument(skip(projects, windows), err(Debug))]
+    pub fn push_change_reference(
+        windows: State<'_, WindowState>,
+        projects: State<'_, projects::Controller>,
+        project_id: ProjectId,
+        branch_id: BranchId,
+        name: ReferenceName,
+        with_force: bool,
+    ) -> Result<(), Error> {
+        let project = projects.get(project_id)?;
+        VirtualBranchActions.push_change_reference(&project, branch_id, name, with_force)?;
+        emit_vbranches(&windows, project_id);
+        Ok(())
+    }
+
     #[tauri::command(async)]
     #[instrument(skip(projects, windows), err(Debug))]
     pub fn reorder_commit(
diff --git a/crates/gitbutler-testsupport/src/lib.rs b/crates/gitbutler-testsupport/src/lib.rs
index 90af71f646..41c134d78f 100644
--- a/crates/gitbutler-testsupport/src/lib.rs
+++ b/crates/gitbutler-testsupport/src/lib.rs
@@ -60,40 +60,48 @@ pub fn init_opts_bare() -> git2::RepositoryInitOptions {
     opts
 }
 
-pub mod read_only {
-    use std::{
-        collections::BTreeSet,
-        path::{Path, PathBuf},
-    };
+pub mod writable {
+    use crate::DRIVER;
+    use gitbutler_command_context::CommandContext;
+    use gitbutler_project::{Project, ProjectId};
+    use tempfile::TempDir;
+
+    pub fn fixture(
+        script_name: &str,
+        project_directory: &str,
+    ) -> anyhow::Result<(CommandContext, TempDir)> {
+        let (project, tempdir) = fixture_project(script_name, project_directory)?;
+        let ctx = CommandContext::open(&project)?;
+        Ok((ctx, tempdir))
+    }
+    pub fn fixture_project(
+        script_name: &str,
+        project_directory: &str,
+    ) -> anyhow::Result<(Project, TempDir)> {
+        let root = gix_testtools::scripted_fixture_writable_with_args(
+            script_name,
+            Some(DRIVER.display().to_string()),
+            gix_testtools::Creation::ExecuteScript,
+        )
+        .expect("script execution always succeeds");
 
+        let project = Project {
+            id: ProjectId::generate(),
+            title: project_directory.to_owned(),
+            path: root.path().join(project_directory),
+            ..Default::default()
+        };
+        Ok((project, root))
+    }
+}
+
+pub mod read_only {
+    use crate::DRIVER;
     use gitbutler_command_context::CommandContext;
     use gitbutler_project::{Project, ProjectId};
     use once_cell::sync::Lazy;
     use parking_lot::Mutex;
-
-    static DRIVER: Lazy<PathBuf> = Lazy::new(|| {
-        let mut cargo = std::process::Command::new(env!("CARGO"));
-        let res = cargo
-            .args(["build", "-p=gitbutler-cli"])
-            .status()
-            .expect("cargo should run fine");
-        assert!(res.success(), "cargo invocation should be successful");
-
-        let path = Path::new("../../target")
-            .join("debug")
-            .join(if cfg!(windows) {
-                "gitbutler-cli.exe"
-            } else {
-                "gitbutler-cli"
-            });
-        assert!(
-            path.is_file(),
-            "Expecting driver to be located at {path:?} - we also assume a certain crate location"
-        );
-        path.canonicalize().expect(
-            "canonicalization works as the CWD is valid and there are no symlinks to resolve",
-        )
-    });
+    use std::collections::BTreeSet;
 
     /// Execute the script at `script_name.sh` (assumed to be located in `tests/fixtures/<script_name>`)
     /// and make the command-line application available to it. That way the script can perform GitButler
@@ -138,6 +146,31 @@ pub mod read_only {
     }
 }
 
+use once_cell::sync::Lazy;
+use std::path::{Path, PathBuf};
+pub(crate) static DRIVER: Lazy<PathBuf> = Lazy::new(|| {
+    let mut cargo = std::process::Command::new(env!("CARGO"));
+    let res = cargo
+        .args(["build", "-p=gitbutler-cli"])
+        .status()
+        .expect("cargo should run fine");
+    assert!(res.success(), "cargo invocation should be successful");
+
+    let path = Path::new("../../target")
+        .join("debug")
+        .join(if cfg!(windows) {
+            "gitbutler-cli.exe"
+        } else {
+            "gitbutler-cli"
+        });
+    assert!(
+        path.is_file(),
+        "Expecting driver to be located at {path:?} - we also assume a certain crate location"
+    );
+    path.canonicalize()
+        .expect("canonicalization works as the CWD is valid and there are no symlinks to resolve")
+});
+
 /// A secrets store to prevent secrets to be written into the systems own store.
 ///
 /// Note that this can't be used if secrets themselves are under test as it' doesn't act