diff --git a/pkg/gui/presentation/authors/authors.go b/pkg/gui/presentation/authors/authors.go
index 28c375f75..5b939d76d 100644
--- a/pkg/gui/presentation/authors/authors.go
+++ b/pkg/gui/presentation/authors/authors.go
@@ -21,7 +21,7 @@ type authorNameCacheKey struct {
 var (
 	authorInitialCache = make(map[string]string)
 	authorNameCache    = make(map[authorNameCacheKey]string)
-	authorStyleCache   = make(map[string]style.TextStyle)
+	authorStyleCache   = make(map[string]*style.TextStyle)
 )
 
 const authorNameWildcard = "*"
@@ -73,7 +73,7 @@ func AuthorWithLength(authorName string, length int) string {
 	return LongAuthor(authorName, length)
 }
 
-func AuthorStyle(authorName string) style.TextStyle {
+func AuthorStyle(authorName string) *style.TextStyle {
 	if value, ok := authorStyleCache[authorName]; ok {
 		return value
 	}
@@ -85,9 +85,9 @@ func AuthorStyle(authorName string) style.TextStyle {
 
 	value := trueColorStyle(authorName)
 
-	authorStyleCache[authorName] = value
+	authorStyleCache[authorName] = &value
 
-	return value
+	return &value
 }
 
 func trueColorStyle(str string) style.TextStyle {
diff --git a/pkg/gui/presentation/branches.go b/pkg/gui/presentation/branches.go
index dfb363bc7..1e4e9dc35 100644
--- a/pkg/gui/presentation/branches.go
+++ b/pkg/gui/presentation/branches.go
@@ -20,7 +20,7 @@ import (
 )
 
 type colorMatcher struct {
-	patterns map[string]style.TextStyle
+	patterns map[string]*style.TextStyle
 	isRegex  bool // NOTE: this value is needed only until the deprecated branchColors config is removed and only regex color patterns are used
 }
 
@@ -142,14 +142,14 @@ func (m *colorMatcher) match(name string) (*style.TextStyle, bool) {
 	if m.isRegex {
 		for pattern, style := range m.patterns {
 			if matched, _ := regexp.MatchString(pattern, name); matched {
-				return &style, true
+				return style, true
 			}
 		}
 	} else {
 		// old behavior using the deprecated branchColors behavior matching on branch type
 		branchType := strings.Split(name, "/")[0]
 		if value, ok := m.patterns[branchType]; ok {
-			return &value, true
+			return value, true
 		}
 	}
 
diff --git a/pkg/gui/presentation/commits.go b/pkg/gui/presentation/commits.go
index 0e1530415..63c2b3c9b 100644
--- a/pkg/gui/presentation/commits.go
+++ b/pkg/gui/presentation/commits.go
@@ -258,7 +258,7 @@ func loadPipesets(commits []*models.Commit) [][]graph.Pipe {
 	if !ok {
 		// pipe sets are unique to a commit head. and a commit count. Sometimes we haven't loaded everything for that.
 		// so let's just cache it based on that.
-		getStyle := func(commit *models.Commit) style.TextStyle {
+		getStyle := func(commit *models.Commit) *style.TextStyle {
 			return authors.AuthorStyle(commit.AuthorName)
 		}
 		pipeSets = graph.GetPipeSets(commits, getStyle)
diff --git a/pkg/gui/presentation/graph/cell.go b/pkg/gui/presentation/graph/cell.go
index cc2ad53c3..a890613f0 100644
--- a/pkg/gui/presentation/graph/cell.go
+++ b/pkg/gui/presentation/graph/cell.go
@@ -25,7 +25,7 @@ type Cell struct {
 	up, down, left, right bool
 	cellType              cellType
 	rightStyle            *style.TextStyle
-	style                 style.TextStyle
+	style                 *style.TextStyle
 }
 
 func (cell *Cell) render(writer io.StringWriter) {
@@ -44,7 +44,7 @@ func (cell *Cell) render(writer io.StringWriter) {
 
 	var rightStyle *style.TextStyle
 	if cell.rightStyle == nil {
-		rightStyle = &cell.style
+		rightStyle = cell.style
 	} else {
 		rightStyle = cell.rightStyle
 	}
@@ -59,7 +59,7 @@ func (cell *Cell) render(writer io.StringWriter) {
 		styledSecondChar = cachedSprint(*rightStyle, second)
 	}
 
-	_, _ = writer.WriteString(cachedSprint(cell.style, adjustedFirst))
+	_, _ = writer.WriteString(cachedSprint(*cell.style, adjustedFirst))
 	_, _ = writer.WriteString(styledSecondChar)
 }
 
@@ -104,19 +104,19 @@ func (cell *Cell) reset() {
 	cell.right = false
 }
 
-func (cell *Cell) setUp(style style.TextStyle) *Cell {
+func (cell *Cell) setUp(style *style.TextStyle) *Cell {
 	cell.up = true
 	cell.style = style
 	return cell
 }
 
-func (cell *Cell) setDown(style style.TextStyle) *Cell {
+func (cell *Cell) setDown(style *style.TextStyle) *Cell {
 	cell.down = true
 	cell.style = style
 	return cell
 }
 
-func (cell *Cell) setLeft(style style.TextStyle) *Cell {
+func (cell *Cell) setLeft(style *style.TextStyle) *Cell {
 	cell.left = true
 	if !cell.up && !cell.down {
 		// vertical trumps left
@@ -126,15 +126,15 @@ func (cell *Cell) setLeft(style style.TextStyle) *Cell {
 }
 
 //nolint:unparam
-func (cell *Cell) setRight(style style.TextStyle, override bool) *Cell {
+func (cell *Cell) setRight(style *style.TextStyle, override bool) *Cell {
 	cell.right = true
 	if cell.rightStyle == nil || override {
-		cell.rightStyle = &style
+		cell.rightStyle = style
 	}
 	return cell
 }
 
-func (cell *Cell) setStyle(style style.TextStyle) *Cell {
+func (cell *Cell) setStyle(style *style.TextStyle) *Cell {
 	cell.style = style
 	return cell
 }
diff --git a/pkg/gui/presentation/graph/graph.go b/pkg/gui/presentation/graph/graph.go
index b769e6db5..fdb587772 100644
--- a/pkg/gui/presentation/graph/graph.go
+++ b/pkg/gui/presentation/graph/graph.go
@@ -28,7 +28,7 @@ type Pipe struct {
 	fromHash *string
 	toHash   *string
 	kind     PipeKind
-	style    style.TextStyle
+	style    *style.TextStyle
 }
 
 var (
@@ -45,7 +45,7 @@ func (self Pipe) right() int {
 	return max(self.fromPos, self.toPos)
 }
 
-func RenderCommitGraph(commits []*models.Commit, selectedCommitHashPtr *string, getStyle func(c *models.Commit) style.TextStyle) []string {
+func RenderCommitGraph(commits []*models.Commit, selectedCommitHashPtr *string, getStyle func(c *models.Commit) *style.TextStyle) []string {
 	pipeSets := GetPipeSets(commits, getStyle)
 	if len(pipeSets) == 0 {
 		return nil
@@ -56,12 +56,12 @@ func RenderCommitGraph(commits []*models.Commit, selectedCommitHashPtr *string,
 	return lines
 }
 
-func GetPipeSets(commits []*models.Commit, getStyle func(c *models.Commit) style.TextStyle) [][]Pipe {
+func GetPipeSets(commits []*models.Commit, getStyle func(c *models.Commit) *style.TextStyle) [][]Pipe {
 	if len(commits) == 0 {
 		return nil
 	}
 
-	pipes := []Pipe{{fromPos: 0, toPos: 0, fromHash: &StartCommitHash, toHash: commits[0].HashPtr(), kind: STARTS, style: style.FgDefault}}
+	pipes := []Pipe{{fromPos: 0, toPos: 0, fromHash: &StartCommitHash, toHash: commits[0].HashPtr(), kind: STARTS, style: &style.FgDefault}}
 
 	return lo.Map(commits, func(commit *models.Commit, _ int) []Pipe {
 		pipes = getNextPipes(pipes, commit, getStyle)
@@ -106,7 +106,7 @@ func RenderAux(pipeSets [][]Pipe, commits []*models.Commit, selectedCommitHashPt
 	return lo.Flatten(chunks)
 }
 
-func getNextPipes(prevPipes []Pipe, commit *models.Commit, getStyle func(c *models.Commit) style.TextStyle) []Pipe {
+func getNextPipes(prevPipes []Pipe, commit *models.Commit, getStyle func(c *models.Commit) *style.TextStyle) []Pipe {
 	maxPos := 0
 	for _, pipe := range prevPipes {
 		if pipe.toPos > maxPos {
@@ -293,10 +293,10 @@ func renderPipeSet(
 	isMerge := startCount > 1
 
 	cells := lo.Map(lo.Range(maxPos+1), func(i int, _ int) *Cell {
-		return &Cell{cellType: CONNECTION, style: style.FgDefault}
+		return &Cell{cellType: CONNECTION, style: &style.FgDefault}
 	})
 
-	renderPipe := func(pipe *Pipe, style style.TextStyle, overrideRightStyle bool) {
+	renderPipe := func(pipe *Pipe, style *style.TextStyle, overrideRightStyle bool) {
 		left := pipe.left()
 		right := pipe.right()
 
@@ -352,9 +352,9 @@ func renderPipeSet(
 		}
 	}
 	for _, pipe := range selectedPipes {
-		renderPipe(&pipe, highlightStyle, true)
+		renderPipe(&pipe, &highlightStyle, true)
 		if pipe.toPos == commitPos {
-			cells[pipe.toPos].setStyle(highlightStyle)
+			cells[pipe.toPos].setStyle(&highlightStyle)
 		}
 	}
 
diff --git a/pkg/gui/presentation/graph/graph_test.go b/pkg/gui/presentation/graph/graph_test.go
index 56ae2cb95..13709267e 100644
--- a/pkg/gui/presentation/graph/graph_test.go
+++ b/pkg/gui/presentation/graph/graph_test.go
@@ -221,7 +221,7 @@ func TestRenderCommitGraph(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			hashPool := &utils.StringPool{}
 
-			getStyle := func(c *models.Commit) style.TextStyle { return style.FgDefault }
+			getStyle := func(c *models.Commit) *style.TextStyle { return &style.FgDefault }
 			commits := lo.Map(test.commitOpts,
 				func(opts models.NewCommitOpts, _ int) *models.Commit { return models.NewCommit(hashPool, opts) })
 			lines := RenderCommitGraph(commits, hashPool.Add("blah"), getStyle)
@@ -270,8 +270,8 @@ func TestRenderPipeSet(t *testing.T) {
 		{
 			name: "single cell",
 			pipes: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("a"), toHash: pool("b"), kind: TERMINATES, style: cyan},
-				{fromPos: 0, toPos: 0, fromHash: pool("b"), toHash: pool("c"), kind: STARTS, style: green},
+				{fromPos: 0, toPos: 0, fromHash: pool("a"), toHash: pool("b"), kind: TERMINATES, style: &cyan},
+				{fromPos: 0, toPos: 0, fromHash: pool("b"), toHash: pool("c"), kind: STARTS, style: &green},
 			},
 			prevCommit:     models.NewCommit(hashPool, models.NewCommitOpts{Hash: "a"}),
 			expectedStr:    "◯",
@@ -280,8 +280,8 @@ func TestRenderPipeSet(t *testing.T) {
 		{
 			name: "single cell, selected",
 			pipes: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("a"), toHash: pool("selected"), kind: TERMINATES, style: cyan},
-				{fromPos: 0, toPos: 0, fromHash: pool("selected"), toHash: pool("c"), kind: STARTS, style: green},
+				{fromPos: 0, toPos: 0, fromHash: pool("a"), toHash: pool("selected"), kind: TERMINATES, style: &cyan},
+				{fromPos: 0, toPos: 0, fromHash: pool("selected"), toHash: pool("c"), kind: STARTS, style: &green},
 			},
 			prevCommit:     models.NewCommit(hashPool, models.NewCommitOpts{Hash: "a"}),
 			expectedStr:    "◯",
@@ -290,10 +290,10 @@ func TestRenderPipeSet(t *testing.T) {
 		{
 			name: "terminating hook and starting hook, selected",
 			pipes: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("a"), toHash: pool("selected"), kind: TERMINATES, style: cyan},
-				{fromPos: 1, toPos: 0, fromHash: pool("c"), toHash: pool("selected"), kind: TERMINATES, style: yellow},
-				{fromPos: 0, toPos: 0, fromHash: pool("selected"), toHash: pool("d"), kind: STARTS, style: green},
-				{fromPos: 0, toPos: 1, fromHash: pool("selected"), toHash: pool("e"), kind: STARTS, style: green},
+				{fromPos: 0, toPos: 0, fromHash: pool("a"), toHash: pool("selected"), kind: TERMINATES, style: &cyan},
+				{fromPos: 1, toPos: 0, fromHash: pool("c"), toHash: pool("selected"), kind: TERMINATES, style: &yellow},
+				{fromPos: 0, toPos: 0, fromHash: pool("selected"), toHash: pool("d"), kind: STARTS, style: &green},
+				{fromPos: 0, toPos: 1, fromHash: pool("selected"), toHash: pool("e"), kind: STARTS, style: &green},
 			},
 			prevCommit:  models.NewCommit(hashPool, models.NewCommitOpts{Hash: "a"}),
 			expectedStr: "⏣─╮",
@@ -304,10 +304,10 @@ func TestRenderPipeSet(t *testing.T) {
 		{
 			name: "terminating hook and starting hook, prioritise the terminating one",
 			pipes: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("a"), toHash: pool("b"), kind: TERMINATES, style: red},
-				{fromPos: 1, toPos: 0, fromHash: pool("c"), toHash: pool("b"), kind: TERMINATES, style: magenta},
-				{fromPos: 0, toPos: 0, fromHash: pool("b"), toHash: pool("d"), kind: STARTS, style: green},
-				{fromPos: 0, toPos: 1, fromHash: pool("b"), toHash: pool("e"), kind: STARTS, style: green},
+				{fromPos: 0, toPos: 0, fromHash: pool("a"), toHash: pool("b"), kind: TERMINATES, style: &red},
+				{fromPos: 1, toPos: 0, fromHash: pool("c"), toHash: pool("b"), kind: TERMINATES, style: &magenta},
+				{fromPos: 0, toPos: 0, fromHash: pool("b"), toHash: pool("d"), kind: STARTS, style: &green},
+				{fromPos: 0, toPos: 1, fromHash: pool("b"), toHash: pool("e"), kind: STARTS, style: &green},
 			},
 			prevCommit:  models.NewCommit(hashPool, models.NewCommitOpts{Hash: "a"}),
 			expectedStr: "⏣─│",
@@ -318,11 +318,11 @@ func TestRenderPipeSet(t *testing.T) {
 		{
 			name: "starting and terminating pipe sharing some space",
 			pipes: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("a1"), toHash: pool("a2"), kind: TERMINATES, style: red},
-				{fromPos: 0, toPos: 0, fromHash: pool("a2"), toHash: pool("a3"), kind: STARTS, style: yellow},
-				{fromPos: 1, toPos: 1, fromHash: pool("b1"), toHash: pool("b2"), kind: CONTINUES, style: magenta},
-				{fromPos: 3, toPos: 0, fromHash: pool("e1"), toHash: pool("a2"), kind: TERMINATES, style: green},
-				{fromPos: 0, toPos: 2, fromHash: pool("a2"), toHash: pool("c3"), kind: STARTS, style: yellow},
+				{fromPos: 0, toPos: 0, fromHash: pool("a1"), toHash: pool("a2"), kind: TERMINATES, style: &red},
+				{fromPos: 0, toPos: 0, fromHash: pool("a2"), toHash: pool("a3"), kind: STARTS, style: &yellow},
+				{fromPos: 1, toPos: 1, fromHash: pool("b1"), toHash: pool("b2"), kind: CONTINUES, style: &magenta},
+				{fromPos: 3, toPos: 0, fromHash: pool("e1"), toHash: pool("a2"), kind: TERMINATES, style: &green},
+				{fromPos: 0, toPos: 2, fromHash: pool("a2"), toHash: pool("c3"), kind: STARTS, style: &yellow},
 			},
 			prevCommit:  models.NewCommit(hashPool, models.NewCommitOpts{Hash: "a1"}),
 			expectedStr: "⏣─│─┬─╯",
@@ -333,11 +333,11 @@ func TestRenderPipeSet(t *testing.T) {
 		{
 			name: "starting and terminating pipe sharing some space, with selection",
 			pipes: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("a1"), toHash: pool("selected"), kind: TERMINATES, style: red},
-				{fromPos: 0, toPos: 0, fromHash: pool("selected"), toHash: pool("a3"), kind: STARTS, style: yellow},
-				{fromPos: 1, toPos: 1, fromHash: pool("b1"), toHash: pool("b2"), kind: CONTINUES, style: magenta},
-				{fromPos: 3, toPos: 0, fromHash: pool("e1"), toHash: pool("selected"), kind: TERMINATES, style: green},
-				{fromPos: 0, toPos: 2, fromHash: pool("selected"), toHash: pool("c3"), kind: STARTS, style: yellow},
+				{fromPos: 0, toPos: 0, fromHash: pool("a1"), toHash: pool("selected"), kind: TERMINATES, style: &red},
+				{fromPos: 0, toPos: 0, fromHash: pool("selected"), toHash: pool("a3"), kind: STARTS, style: &yellow},
+				{fromPos: 1, toPos: 1, fromHash: pool("b1"), toHash: pool("b2"), kind: CONTINUES, style: &magenta},
+				{fromPos: 3, toPos: 0, fromHash: pool("e1"), toHash: pool("selected"), kind: TERMINATES, style: &green},
+				{fromPos: 0, toPos: 2, fromHash: pool("selected"), toHash: pool("c3"), kind: STARTS, style: &yellow},
 			},
 			prevCommit:  models.NewCommit(hashPool, models.NewCommitOpts{Hash: "a1"}),
 			expectedStr: "⏣───╮ ╯",
@@ -348,10 +348,10 @@ func TestRenderPipeSet(t *testing.T) {
 		{
 			name: "many terminating pipes",
 			pipes: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("a1"), toHash: pool("a2"), kind: TERMINATES, style: red},
-				{fromPos: 0, toPos: 0, fromHash: pool("a2"), toHash: pool("a3"), kind: STARTS, style: yellow},
-				{fromPos: 1, toPos: 0, fromHash: pool("b1"), toHash: pool("a2"), kind: TERMINATES, style: magenta},
-				{fromPos: 2, toPos: 0, fromHash: pool("c1"), toHash: pool("a2"), kind: TERMINATES, style: green},
+				{fromPos: 0, toPos: 0, fromHash: pool("a1"), toHash: pool("a2"), kind: TERMINATES, style: &red},
+				{fromPos: 0, toPos: 0, fromHash: pool("a2"), toHash: pool("a3"), kind: STARTS, style: &yellow},
+				{fromPos: 1, toPos: 0, fromHash: pool("b1"), toHash: pool("a2"), kind: TERMINATES, style: &magenta},
+				{fromPos: 2, toPos: 0, fromHash: pool("c1"), toHash: pool("a2"), kind: TERMINATES, style: &green},
 			},
 			prevCommit:  models.NewCommit(hashPool, models.NewCommitOpts{Hash: "a1"}),
 			expectedStr: "◯─┴─╯",
@@ -362,11 +362,11 @@ func TestRenderPipeSet(t *testing.T) {
 		{
 			name: "starting pipe passing through",
 			pipes: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("a1"), toHash: pool("a2"), kind: TERMINATES, style: red},
-				{fromPos: 0, toPos: 0, fromHash: pool("a2"), toHash: pool("a3"), kind: STARTS, style: yellow},
-				{fromPos: 0, toPos: 3, fromHash: pool("a2"), toHash: pool("d3"), kind: STARTS, style: yellow},
-				{fromPos: 1, toPos: 1, fromHash: pool("b1"), toHash: pool("b3"), kind: CONTINUES, style: magenta},
-				{fromPos: 2, toPos: 2, fromHash: pool("c1"), toHash: pool("c3"), kind: CONTINUES, style: green},
+				{fromPos: 0, toPos: 0, fromHash: pool("a1"), toHash: pool("a2"), kind: TERMINATES, style: &red},
+				{fromPos: 0, toPos: 0, fromHash: pool("a2"), toHash: pool("a3"), kind: STARTS, style: &yellow},
+				{fromPos: 0, toPos: 3, fromHash: pool("a2"), toHash: pool("d3"), kind: STARTS, style: &yellow},
+				{fromPos: 1, toPos: 1, fromHash: pool("b1"), toHash: pool("b3"), kind: CONTINUES, style: &magenta},
+				{fromPos: 2, toPos: 2, fromHash: pool("c1"), toHash: pool("c3"), kind: CONTINUES, style: &green},
 			},
 			prevCommit:  models.NewCommit(hashPool, models.NewCommitOpts{Hash: "a1"}),
 			expectedStr: "⏣─│─│─╮",
@@ -377,11 +377,11 @@ func TestRenderPipeSet(t *testing.T) {
 		{
 			name: "starting and terminating path crossing continuing path",
 			pipes: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("a1"), toHash: pool("a2"), kind: TERMINATES, style: red},
-				{fromPos: 0, toPos: 0, fromHash: pool("a2"), toHash: pool("a3"), kind: STARTS, style: yellow},
-				{fromPos: 0, toPos: 1, fromHash: pool("a2"), toHash: pool("b3"), kind: STARTS, style: yellow},
-				{fromPos: 1, toPos: 1, fromHash: pool("b1"), toHash: pool("a2"), kind: CONTINUES, style: green},
-				{fromPos: 2, toPos: 0, fromHash: pool("c1"), toHash: pool("a2"), kind: TERMINATES, style: magenta},
+				{fromPos: 0, toPos: 0, fromHash: pool("a1"), toHash: pool("a2"), kind: TERMINATES, style: &red},
+				{fromPos: 0, toPos: 0, fromHash: pool("a2"), toHash: pool("a3"), kind: STARTS, style: &yellow},
+				{fromPos: 0, toPos: 1, fromHash: pool("a2"), toHash: pool("b3"), kind: STARTS, style: &yellow},
+				{fromPos: 1, toPos: 1, fromHash: pool("b1"), toHash: pool("a2"), kind: CONTINUES, style: &green},
+				{fromPos: 2, toPos: 0, fromHash: pool("c1"), toHash: pool("a2"), kind: TERMINATES, style: &magenta},
 			},
 			prevCommit:  models.NewCommit(hashPool, models.NewCommitOpts{Hash: "a1"}),
 			expectedStr: "⏣─│─╯",
@@ -392,11 +392,11 @@ func TestRenderPipeSet(t *testing.T) {
 		{
 			name: "another clash of starting and terminating paths",
 			pipes: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("a1"), toHash: pool("a2"), kind: TERMINATES, style: red},
-				{fromPos: 0, toPos: 0, fromHash: pool("a2"), toHash: pool("a3"), kind: STARTS, style: yellow},
-				{fromPos: 0, toPos: 1, fromHash: pool("a2"), toHash: pool("b3"), kind: STARTS, style: yellow},
-				{fromPos: 2, toPos: 2, fromHash: pool("c1"), toHash: pool("c3"), kind: CONTINUES, style: green},
-				{fromPos: 3, toPos: 0, fromHash: pool("d1"), toHash: pool("a2"), kind: TERMINATES, style: magenta},
+				{fromPos: 0, toPos: 0, fromHash: pool("a1"), toHash: pool("a2"), kind: TERMINATES, style: &red},
+				{fromPos: 0, toPos: 0, fromHash: pool("a2"), toHash: pool("a3"), kind: STARTS, style: &yellow},
+				{fromPos: 0, toPos: 1, fromHash: pool("a2"), toHash: pool("b3"), kind: STARTS, style: &yellow},
+				{fromPos: 2, toPos: 2, fromHash: pool("c1"), toHash: pool("c3"), kind: CONTINUES, style: &green},
+				{fromPos: 3, toPos: 0, fromHash: pool("d1"), toHash: pool("a2"), kind: TERMINATES, style: &magenta},
 			},
 			prevCommit:  models.NewCommit(hashPool, models.NewCommitOpts{Hash: "a1"}),
 			expectedStr: "⏣─┬─│─╯",
@@ -407,8 +407,8 @@ func TestRenderPipeSet(t *testing.T) {
 		{
 			name: "commit whose previous commit is selected",
 			pipes: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("selected"), toHash: pool("a2"), kind: TERMINATES, style: red},
-				{fromPos: 0, toPos: 0, fromHash: pool("a2"), toHash: pool("a3"), kind: STARTS, style: yellow},
+				{fromPos: 0, toPos: 0, fromHash: pool("selected"), toHash: pool("a2"), kind: TERMINATES, style: &red},
+				{fromPos: 0, toPos: 0, fromHash: pool("a2"), toHash: pool("a3"), kind: STARTS, style: &yellow},
 			},
 			prevCommit:  models.NewCommit(hashPool, models.NewCommitOpts{Hash: "selected"}),
 			expectedStr: "◯",
@@ -419,8 +419,8 @@ func TestRenderPipeSet(t *testing.T) {
 		{
 			name: "commit whose previous commit is selected and is a merge commit",
 			pipes: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("selected"), toHash: pool("a2"), kind: TERMINATES, style: red},
-				{fromPos: 1, toPos: 1, fromHash: pool("selected"), toHash: pool("b3"), kind: CONTINUES, style: red},
+				{fromPos: 0, toPos: 0, fromHash: pool("selected"), toHash: pool("a2"), kind: TERMINATES, style: &red},
+				{fromPos: 1, toPos: 1, fromHash: pool("selected"), toHash: pool("b3"), kind: CONTINUES, style: &red},
 			},
 			prevCommit:  models.NewCommit(hashPool, models.NewCommitOpts{Hash: "selected"}),
 			expectedStr: "◯ │",
@@ -431,9 +431,9 @@ func TestRenderPipeSet(t *testing.T) {
 		{
 			name: "commit whose previous commit is selected and is a merge commit, with continuing pipe inbetween",
 			pipes: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("selected"), toHash: pool("a2"), kind: TERMINATES, style: red},
-				{fromPos: 1, toPos: 1, fromHash: pool("z1"), toHash: pool("z3"), kind: CONTINUES, style: green},
-				{fromPos: 2, toPos: 2, fromHash: pool("selected"), toHash: pool("b3"), kind: CONTINUES, style: red},
+				{fromPos: 0, toPos: 0, fromHash: pool("selected"), toHash: pool("a2"), kind: TERMINATES, style: &red},
+				{fromPos: 1, toPos: 1, fromHash: pool("z1"), toHash: pool("z3"), kind: CONTINUES, style: &green},
+				{fromPos: 2, toPos: 2, fromHash: pool("selected"), toHash: pool("b3"), kind: CONTINUES, style: &red},
 			},
 			prevCommit:  models.NewCommit(hashPool, models.NewCommitOpts{Hash: "selected"}),
 			expectedStr: "◯ │ │",
@@ -444,10 +444,10 @@ func TestRenderPipeSet(t *testing.T) {
 		{
 			name: "when previous commit is selected, not a merge commit, and spawns a continuing pipe",
 			pipes: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("a1"), toHash: pool("a2"), kind: TERMINATES, style: red},
-				{fromPos: 0, toPos: 0, fromHash: pool("a2"), toHash: pool("a3"), kind: STARTS, style: green},
-				{fromPos: 0, toPos: 1, fromHash: pool("a2"), toHash: pool("b3"), kind: STARTS, style: green},
-				{fromPos: 1, toPos: 0, fromHash: pool("selected"), toHash: pool("a2"), kind: TERMINATES, style: yellow},
+				{fromPos: 0, toPos: 0, fromHash: pool("a1"), toHash: pool("a2"), kind: TERMINATES, style: &red},
+				{fromPos: 0, toPos: 0, fromHash: pool("a2"), toHash: pool("a3"), kind: STARTS, style: &green},
+				{fromPos: 0, toPos: 1, fromHash: pool("a2"), toHash: pool("b3"), kind: STARTS, style: &green},
+				{fromPos: 1, toPos: 0, fromHash: pool("selected"), toHash: pool("a2"), kind: TERMINATES, style: &yellow},
 			},
 			prevCommit:  models.NewCommit(hashPool, models.NewCommitOpts{Hash: "selected"}),
 			expectedStr: "⏣─╯",
@@ -492,43 +492,43 @@ func TestGetNextPipes(t *testing.T) {
 	}{
 		{
 			prevPipes: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("a"), toHash: pool("b"), kind: STARTS, style: style.FgDefault},
+				{fromPos: 0, toPos: 0, fromHash: pool("a"), toHash: pool("b"), kind: STARTS, style: &style.FgDefault},
 			},
 			commit: models.NewCommit(hashPool, models.NewCommitOpts{
 				Hash:    "b",
 				Parents: []string{"c"},
 			}),
 			expected: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("a"), toHash: pool("b"), kind: TERMINATES, style: style.FgDefault},
-				{fromPos: 0, toPos: 0, fromHash: pool("b"), toHash: pool("c"), kind: STARTS, style: style.FgDefault},
+				{fromPos: 0, toPos: 0, fromHash: pool("a"), toHash: pool("b"), kind: TERMINATES, style: &style.FgDefault},
+				{fromPos: 0, toPos: 0, fromHash: pool("b"), toHash: pool("c"), kind: STARTS, style: &style.FgDefault},
 			},
 		},
 		{
 			prevPipes: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("a"), toHash: pool("b"), kind: TERMINATES, style: style.FgDefault},
-				{fromPos: 0, toPos: 0, fromHash: pool("b"), toHash: pool("c"), kind: STARTS, style: style.FgDefault},
-				{fromPos: 0, toPos: 1, fromHash: pool("b"), toHash: pool("d"), kind: STARTS, style: style.FgDefault},
+				{fromPos: 0, toPos: 0, fromHash: pool("a"), toHash: pool("b"), kind: TERMINATES, style: &style.FgDefault},
+				{fromPos: 0, toPos: 0, fromHash: pool("b"), toHash: pool("c"), kind: STARTS, style: &style.FgDefault},
+				{fromPos: 0, toPos: 1, fromHash: pool("b"), toHash: pool("d"), kind: STARTS, style: &style.FgDefault},
 			},
 			commit: models.NewCommit(hashPool, models.NewCommitOpts{
 				Hash:    "d",
 				Parents: []string{"e"},
 			}),
 			expected: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("b"), toHash: pool("c"), kind: CONTINUES, style: style.FgDefault},
-				{fromPos: 1, toPos: 1, fromHash: pool("b"), toHash: pool("d"), kind: TERMINATES, style: style.FgDefault},
-				{fromPos: 1, toPos: 1, fromHash: pool("d"), toHash: pool("e"), kind: STARTS, style: style.FgDefault},
+				{fromPos: 0, toPos: 0, fromHash: pool("b"), toHash: pool("c"), kind: CONTINUES, style: &style.FgDefault},
+				{fromPos: 1, toPos: 1, fromHash: pool("b"), toHash: pool("d"), kind: TERMINATES, style: &style.FgDefault},
+				{fromPos: 1, toPos: 1, fromHash: pool("d"), toHash: pool("e"), kind: STARTS, style: &style.FgDefault},
 			},
 		},
 		{
 			prevPipes: []Pipe{
-				{fromPos: 0, toPos: 0, fromHash: pool("a"), toHash: pool("root"), kind: TERMINATES, style: style.FgDefault},
+				{fromPos: 0, toPos: 0, fromHash: pool("a"), toHash: pool("root"), kind: TERMINATES, style: &style.FgDefault},
 			},
 			commit: models.NewCommit(hashPool, models.NewCommitOpts{
 				Hash:    "root",
 				Parents: []string{},
 			}),
 			expected: []Pipe{
-				{fromPos: 1, toPos: 1, fromHash: pool("root"), toHash: pool(models.EmptyTreeCommitHash), kind: STARTS, style: style.FgDefault},
+				{fromPos: 1, toPos: 1, fromHash: pool("root"), toHash: pool(models.EmptyTreeCommitHash), kind: STARTS, style: &style.FgDefault},
 			},
 		},
 	}
@@ -537,7 +537,7 @@ func TestGetNextPipes(t *testing.T) {
 	defer color.ForceSetColorLevel(oldColorLevel)
 
 	for _, test := range tests {
-		getStyle := func(c *models.Commit) style.TextStyle { return style.FgDefault }
+		getStyle := func(c *models.Commit) *style.TextStyle { return &style.FgDefault }
 		pipes := getNextPipes(test.prevPipes, test.commit, getStyle)
 		// rendering cells so that it's easier to see what went wrong
 		actualStr := renderPipeSet(pipes, pool("selected"), nil)
@@ -557,7 +557,7 @@ func BenchmarkRenderCommitGraph(b *testing.B) {
 	hashPool := &utils.StringPool{}
 
 	commits := generateCommits(hashPool, 50)
-	getStyle := func(commit *models.Commit) style.TextStyle {
+	getStyle := func(commit *models.Commit) *style.TextStyle {
 		return authors.AuthorStyle(commit.AuthorName)
 	}
 	b.ResetTimer()
diff --git a/pkg/utils/color.go b/pkg/utils/color.go
index 05e0aa9bc..17e400337 100644
--- a/pkg/utils/color.go
+++ b/pkg/utils/color.go
@@ -57,11 +57,12 @@ func IsValidHexValue(v string) bool {
 	return true
 }
 
-func SetCustomColors(customColors map[string]string) map[string]style.TextStyle {
-	return lo.MapValues(customColors, func(c string, key string) style.TextStyle {
+func SetCustomColors(customColors map[string]string) map[string]*style.TextStyle {
+	return lo.MapValues(customColors, func(c string, key string) *style.TextStyle {
 		if s, ok := style.ColorMap[c]; ok {
-			return s.Foreground
+			return &s.Foreground
 		}
-		return style.New().SetFg(style.NewRGBColor(color.HEX(c, false)))
+		value := style.New().SetFg(style.NewRGBColor(color.HEX(c, false)))
+		return &value
 	})
 }