Commit fc8cb54

@@ -129,7 +129,9 @@ func (e *Extractor) deployFile(path string, d fs.DirEntry, err error) error {
 			return nil
 		}
 
+		// Generate diff
 		diff := udiff.Unified(path, dstPath, string(srcData), string(dstData))
+		
 		result.Status = _statusModified
 		result.Details = diff
 		result.Err = ErrFileModified
@@ -145,6 +147,7 @@ func (e *Extractor) deployFile(path string, d fs.DirEntry, err error) error {
 	return nil
 }
 
+
 func (e *Extractor) LogResults(logger *slog.Logger, ctx context.Context) {
 	for _, r := range e.Results {
 		level := slog.LevelInfo

@@ -3,6 +3,7 @@ package golang
 import (
 	_ "embed"
 	"text/template"
+	"time"
 
 	"archive/tar"
 	"bytes"
@@ -12,11 +13,117 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+
+	"github.com/charmbracelet/bubbles/progress"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
 )
 
 //go:embed go1.*.linux-amd64.tar.gz
 var goSrc []byte
 
+type progressModel struct {
+	progress progress.Model
+	current  int
+	total    int
+	done     bool
+	spinner  int
+}
+
+var spinnerFrames = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
+
+func (m progressModel) Init() tea.Cmd {
+	return tea.Tick(time.Millisecond*100, func(time.Time) tea.Msg {
+		return tickMsg{}
+	})
+}
+
+func (m progressModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		return m, tea.Quit
+	case tickMsg:
+		if !m.done {
+			m.spinner = (m.spinner + 1) % len(spinnerFrames)
+			return m, tea.Tick(time.Millisecond*100, func(time.Time) tea.Msg {
+				return tickMsg{}
+			})
+		}
+		return m, nil
+	case progressMsg:
+		m.current = msg.current
+		m.total = msg.total
+		if m.current >= m.total {
+			m.done = true
+			return m, tea.Quit
+		}
+		return m, nil
+	}
+	return m, nil
+}
+
+func (m progressModel) View() string {
+	if m.done {
+		// Completion style
+		checkmark := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#00ff00")).
+			Bold(true).
+			Render("✓")
+		
+		title := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#ffffff")).
+			Bold(true).
+			Render("Go Installation Complete")
+		
+		stats := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#666666")).
+			Render(fmt.Sprintf("(%d files extracted)", m.total))
+		
+		return fmt.Sprintf("\n  %s %s %s\n\n", checkmark, title, stats)
+	}
+	
+	// Progress bar styling
+	percentage := float64(m.current) / float64(m.total)
+	
+	// Styled spinner
+	spinner := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#00ffff")).
+		Bold(true).
+		Render(spinnerFrames[m.spinner])
+	
+	// Styled title
+	title := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#ffffff")).
+		Bold(true).
+		Render("Installing Go")
+	
+	// Progress bar with custom styling
+	progressBar := m.progress.ViewAs(percentage)
+	
+	// Styled stats
+	stats := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#888888")).
+		Render(fmt.Sprintf("%d/%d files (%.1f%%)", m.current, m.total, percentage*100))
+	
+	// File rate calculation (rough estimate)
+	rate := ""
+	if m.current > 100 {
+		rate = lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#ffff00")).
+			Render(" • extracting...")
+	}
+	
+	return fmt.Sprintf("\n  %s %s\n  %s\n  %s%s\n", 
+		spinner, title, progressBar, stats, rate)
+}
+
+type progressMsg struct {
+	current int
+	total   int
+}
+
+type tickMsg struct{}
+
 func bashrcd() error {
 	// TODO: installDir
 	homeDir := os.Getenv("HOME")
@@ -57,46 +164,110 @@ func Install() error {
 		return fmt.Errorf("cleaning up old install: %w", err)
 	}
 
-	gr, err := gzip.NewReader(bytes.NewReader(goSrc))
+	// Count total files first
+	totalFiles, err := countTarFiles(goSrc)
 	if err != nil {
-		return fmt.Errorf("setting up gzip reader: %w", err)
+		return fmt.Errorf("counting files: %w", err)
 	}
-	tr := tar.NewReader(gr)
 
-	for {
-		header, err := tr.Next()
+	// Setup enhanced progress bar with custom styling
+	p := progress.New(
+		progress.WithScaledGradient("#ff7700", "#ffdd00"),
+		progress.WithWidth(50),
+		progress.WithoutPercentage(),
+	)
+	
+	model := progressModel{
+		progress: p,
+		total:    totalFiles,
+	}
+
+	program := tea.NewProgram(model)
+	go func() {
+		gr, err := gzip.NewReader(bytes.NewReader(goSrc))
 		if err != nil {
-			if errors.Is(err, io.EOF) {
-				break
-			}
-			return err
+			program.Quit()
+			return
 		}
-		mode := os.FileMode(header.Mode)
+		defer gr.Close()
+		tr := tar.NewReader(gr)
 
-		target := filepath.Join(installDir, header.Name)
-		switch header.Typeflag {
-		case tar.TypeDir:
-			err = os.MkdirAll(target, mode)
+		fileCount := 0
+		for {
+			header, err := tr.Next()
 			if err != nil {
-				return err
+				if errors.Is(err, io.EOF) {
+					break
+				}
+				program.Quit()
+				return
 			}
+			fileCount++
 
-		case tar.TypeReg:
-			flag := os.O_CREATE | os.O_WRONLY | os.O_TRUNC
-			f, err := os.OpenFile(target, flag, mode)
-			if err != nil {
-				return err
-			}
-			_, err = io.Copy(f, tr)
-			if err != nil {
-				return err
-			}
-			err = f.Close()
-			if err != nil {
-				return err
+			// Send progress update
+			program.Send(progressMsg{current: fileCount, total: totalFiles})
+
+			mode := os.FileMode(header.Mode)
+			target := filepath.Join(installDir, header.Name)
+			switch header.Typeflag {
+			case tar.TypeDir:
+				err = os.MkdirAll(target, mode)
+				if err != nil {
+					program.Quit()
+					return
+				}
+
+			case tar.TypeReg:
+				flag := os.O_CREATE | os.O_WRONLY | os.O_TRUNC
+				f, err := os.OpenFile(target, flag, mode)
+				if err != nil {
+					program.Quit()
+					return
+				}
+				_, err = io.Copy(f, tr)
+				if err != nil {
+					f.Close()
+					program.Quit()
+					return
+				}
+				err = f.Close()
+				if err != nil {
+					program.Quit()
+					return
+				}
 			}
 		}
+
+		// Signal completion
+		program.Send(progressMsg{current: totalFiles, total: totalFiles})
+	}()
+
+	_, err = program.Run()
+	if err != nil {
+		return fmt.Errorf("running progress: %w", err)
 	}
 
 	return nil
 }
+
+func countTarFiles(data []byte) (int, error) {
+	gr, err := gzip.NewReader(bytes.NewReader(data))
+	if err != nil {
+		return 0, err
+	}
+	defer gr.Close()
+	tr := tar.NewReader(gr)
+
+	count := 0
+	for {
+		_, err := tr.Next()
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				break
+			}
+			return 0, err
+		}
+		count++
+	}
+	return count, nil
+}

@@ -3,6 +3,7 @@ package nvim
 import (
 	_ "embed"
 	"text/template"
+	"time"
 
 	"archive/tar"
 	"bytes"
@@ -14,12 +15,136 @@ import (
 	"path/filepath"
 	"strings"
 
+	"github.com/charmbracelet/bubbles/progress"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
 	"github.com/go-git/go-git/v5"
 )
 
 //go:embed nvim-linux-x86_64.tar.gz
 var nvimSrc []byte
 
+type progressModel struct {
+	progress progress.Model
+	current  int
+	total    int
+	done     bool
+	phase    string
+	spinner  int
+}
+
+var spinnerFrames = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
+
+func (m progressModel) Init() tea.Cmd {
+	return tea.Tick(time.Millisecond*120, func(time.Time) tea.Msg {
+		return tickMsg{}
+	})
+}
+
+func (m progressModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		return m, tea.Quit
+	case tickMsg:
+		if !m.done {
+			m.spinner = (m.spinner + 1) % len(spinnerFrames)
+			return m, tea.Tick(time.Millisecond*120, func(time.Time) tea.Msg {
+				return tickMsg{}
+			})
+		}
+		return m, nil
+	case progressMsg:
+		m.current = msg.current
+		m.total = msg.total
+		m.phase = msg.phase
+		if m.current >= m.total && m.phase == "complete" {
+			m.done = true
+			return m, tea.Quit
+		}
+		return m, nil
+	}
+	return m, nil
+}
+
+func (m progressModel) View() string {
+	if m.done {
+		// Completion style with vim colors
+		checkmark := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#00ff00")).
+			Bold(true).
+			Render("✓")
+		
+		title := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#ffffff")).
+			Bold(true).
+			Render("Nvim + Kickstart Installation Complete")
+		
+		stats := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#666666")).
+			Render(fmt.Sprintf("(%d files + kickstart.nvim config)", m.total))
+		
+		return fmt.Sprintf("\n  %s %s %s\n\n", checkmark, title, stats)
+	}
+	
+	// Progress bar styling with vim-inspired colors
+	percentage := float64(m.current) / float64(m.total)
+	
+	// Styled spinner
+	spinnerColor := "#00ff00" // Green like vim
+	if m.phase == "git" {
+		spinnerColor = "#ff6600" // Orange for git phase
+	}
+	
+	spinner := lipgloss.NewStyle().
+		Foreground(lipgloss.Color(spinnerColor)).
+		Bold(true).
+		Render(spinnerFrames[m.spinner])
+	
+	// Styled title
+	status := "Installing Nvim"
+	titleColor := "#ffffff"
+	if m.phase == "git" {
+		status = "Cloning kickstart.nvim"
+		titleColor = "#ff9900"
+	}
+	
+	title := lipgloss.NewStyle().
+		Foreground(lipgloss.Color(titleColor)).
+		Bold(true).
+		Render(status)
+	
+	// Progress bar with custom styling
+	progressBar := m.progress.ViewAs(percentage)
+	
+	// Styled stats
+	stats := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#888888")).
+		Render(fmt.Sprintf("%d/%d files (%.1f%%)", m.current, m.total, percentage*100))
+	
+	// Phase indicator
+	phaseIndicator := ""
+	if m.phase == "git" {
+		phaseIndicator = lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#ffaa00")).
+			Render(" • configuring editor...")
+	} else if m.current > 50 {
+		phaseIndicator = lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#00aa00")).
+			Render(" • extracting runtime...")
+	}
+	
+	return fmt.Sprintf("\n  %s %s\n  %s\n  %s%s\n", 
+		spinner, title, progressBar, stats, phaseIndicator)
+}
+
+type progressMsg struct {
+	current int
+	total   int
+	phase   string
+}
+
+type tickMsg struct{}
+
 func bashrcd() error {
 	homeDir := os.Getenv("HOME")
 	installDir := filepath.Join(homeDir, ".local")
@@ -50,8 +175,7 @@ func Install() error {
 
 	err := bashrcd()
 	if err != nil {
-		err := fmt.Errorf("installing bashrc.d env helper: %w", err)
-		return err
+		return fmt.Errorf("installing bashrc.d env helper: %w", err)
 	}
 
 	nvimShareDir := filepath.Join(installDir, "share/nvim")
@@ -64,84 +188,168 @@ func Install() error {
 		}
 	}
 
-	gr, err := gzip.NewReader(bytes.NewReader(nvimSrc))
+	// Count total files first
+	totalFiles, err := countTarFiles(nvimSrc)
 	if err != nil {
-		return fmt.Errorf("setting up gzip reader: %w", err)
+		return fmt.Errorf("counting files: %w", err)
 	}
-	tr := tar.NewReader(gr)
 
-	for {
-		header, err := tr.Next()
-		if err != nil {
-			if errors.Is(err, io.EOF) {
-				break
-			}
-			return err
-		}
-		mode := os.FileMode(header.Mode)
-
-		target := filepath.Join(installDir, header.Name)
+	// Setup enhanced progress bar with vim-inspired colors
+	p := progress.New(
+		progress.WithScaledGradient("#00ff00", "#88ff88"),
+		progress.WithWidth(45),
+		progress.WithoutPercentage(),
+	)
+	
+	model := progressModel{
+		progress: p,
+		total:    totalFiles + 1, // +1 for git clone step
+	}
 
-		// Strip the first component (nvim-linux-x86_64/)
-		parts := strings.Split(header.Name, "/")
-		if len(parts) > 0 {
-			parts = parts[1:]
-			if len(parts) == 0 {
-				continue
-			}
-			target = filepath.Join(append([]string{installDir}, parts...)...)
+	program := tea.NewProgram(model)
+	var installErr error
+	
+	go func() {
+		gr, err := gzip.NewReader(bytes.NewReader(nvimSrc))
+		if err != nil {
+			installErr = fmt.Errorf("setting up gzip reader: %w", err)
+			program.Quit()
+			return
 		}
+		defer gr.Close()
+		tr := tar.NewReader(gr)
 
-		switch header.Typeflag {
-		case tar.TypeDir:
-			err = os.MkdirAll(target, mode)
+		fileCount := 0
+		for {
+			header, err := tr.Next()
 			if err != nil {
-				return err
+				if errors.Is(err, io.EOF) {
+					break
+				}
+				installErr = err
+				program.Quit()
+				return
 			}
+			fileCount++
 
-		case tar.TypeReg:
-			// Ensure parent directory exists
-			dir := filepath.Dir(target)
-			err = os.MkdirAll(dir, 0755)
-			if err != nil {
-				return err
-			}
+			// Send progress update
+			program.Send(progressMsg{current: fileCount, total: totalFiles + 1, phase: "extract"})
 
-			flag := os.O_CREATE | os.O_WRONLY | os.O_TRUNC
-			f, err := os.OpenFile(target, flag, mode)
-			if err != nil {
-				return err
-			}
-			_, err = io.Copy(f, tr)
-			if err != nil {
-				return err
+			mode := os.FileMode(header.Mode)
+			target := filepath.Join(installDir, header.Name)
+
+			// Strip the first component (nvim-linux-x86_64/)
+			parts := strings.Split(header.Name, "/")
+			if len(parts) > 0 {
+				parts = parts[1:]
+				if len(parts) == 0 {
+					continue
+				}
+				target = filepath.Join(append([]string{installDir}, parts...)...)
 			}
-			err = f.Close()
-			if err != nil {
-				return err
+
+			switch header.Typeflag {
+			case tar.TypeDir:
+				err = os.MkdirAll(target, mode)
+				if err != nil {
+					installErr = err
+					program.Quit()
+					return
+				}
+
+			case tar.TypeReg:
+				// Ensure parent directory exists
+				dir := filepath.Dir(target)
+				err = os.MkdirAll(dir, 0755)
+				if err != nil {
+					installErr = err
+					program.Quit()
+					return
+				}
+
+				flag := os.O_CREATE | os.O_WRONLY | os.O_TRUNC
+				f, err := os.OpenFile(target, flag, mode)
+				if err != nil {
+					installErr = err
+					program.Quit()
+					return
+				}
+				_, err = io.Copy(f, tr)
+				if err != nil {
+					f.Close()
+					installErr = err
+					program.Quit()
+					return
+				}
+				err = f.Close()
+				if err != nil {
+					installErr = err
+					program.Quit()
+					return
+				}
 			}
 		}
-	}
 
-	// Clone kickstart.nvim configuration
-	configDir := os.Getenv("XDG_CONFIG_HOME")
-	if configDir == "" {
-		configDir = filepath.Join(homeDir, ".config")
+		// Clone kickstart.nvim configuration
+		program.Send(progressMsg{current: totalFiles, total: totalFiles + 1, phase: "git"})
+		
+		configDir := os.Getenv("XDG_CONFIG_HOME")
+		if configDir == "" {
+			configDir = filepath.Join(homeDir, ".config")
+		}
+		nvimConfigDir := filepath.Join(configDir, "nvim")
+		
+		// Remove existing nvim config if it exists
+		err = os.RemoveAll(nvimConfigDir)
+		if err != nil {
+			installErr = fmt.Errorf("cleaning up existing nvim config: %w", err)
+			program.Quit()
+			return
+		}
+
+		_, err = git.PlainClone(nvimConfigDir, false, &git.CloneOptions{
+			URL: "https://github.com/nvim-lua/kickstart.nvim.git",
+		})
+		if err != nil {
+			installErr = fmt.Errorf("cloning kickstart.nvim: %w", err)
+			program.Quit()
+			return
+		}
+
+		// Signal completion
+		program.Send(progressMsg{current: totalFiles + 1, total: totalFiles + 1, phase: "complete"})
+	}()
+
+	_, err = program.Run()
+	if err != nil {
+		return fmt.Errorf("running progress: %w", err)
 	}
-	nvimConfigDir := filepath.Join(configDir, "nvim")
 	
-	// Remove existing nvim config if it exists
-	err = os.RemoveAll(nvimConfigDir)
-	if err != nil {
-		return fmt.Errorf("cleaning up existing nvim config: %w", err)
+	if installErr != nil {
+		return installErr
 	}
 
-	_, err = git.PlainClone(nvimConfigDir, false, &git.CloneOptions{
-		URL: "https://github.com/nvim-lua/kickstart.nvim.git",
-	})
+	return nil
+}
+
+func countTarFiles(data []byte) (int, error) {
+	gr, err := gzip.NewReader(bytes.NewReader(data))
 	if err != nil {
-		return fmt.Errorf("cloning kickstart.nvim: %w", err)
+		return 0, err
 	}
+	defer gr.Close()
+	tr := tar.NewReader(gr)
 
-	return nil
+	count := 0
+	for {
+		_, err := tr.Next()
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				break
+			}
+			return 0, err
+		}
+		count++
+	}
+	return count, nil
 }

@@ -3,6 +3,7 @@ package zig
 import (
 	_ "embed"
 	"text/template"
+	"time"
 
 	"archive/tar"
 	"bytes"
@@ -13,12 +14,118 @@ import (
 	"path/filepath"
 	"strings"
 
+	"github.com/charmbracelet/bubbles/progress"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
 	"github.com/ulikunitz/xz"
 )
 
 //go:embed zig-linux-x86_64.tar.xz
 var zigSrc []byte
 
+// Total files in the zig archive (hardcoded to avoid pre-counting delay)
+// To update: tar -tf internal/zig/zig-linux-x86_64.tar.xz | wc -l
+const zigTotalFiles = 16391
+
+type progressModel struct {
+	progress progress.Model
+	current  int
+	total    int
+	done     bool
+	spinner  int
+}
+
+var spinnerFrames = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
+
+func (m progressModel) Init() tea.Cmd {
+	return tea.Tick(time.Millisecond*100, func(time.Time) tea.Msg {
+		return tickMsg{}
+	})
+}
+
+func (m progressModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		return m, tea.Quit
+	case tickMsg:
+		if !m.done {
+			m.spinner = (m.spinner + 1) % len(spinnerFrames)
+			return m, tea.Tick(time.Millisecond*150, func(time.Time) tea.Msg {
+				return tickMsg{}
+			})
+		}
+		return m, nil
+	case progressMsg:
+		m.current = msg.current
+		m.total = msg.total
+		if m.current >= m.total {
+			m.done = true
+			return m, tea.Quit
+		}
+		return m, nil
+	}
+	return m, nil
+}
+
+func (m progressModel) View() string {
+	if m.done {
+		// Completion style with zig colors (orange theme)
+		checkmark := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#f7a41d")).
+			Bold(true).
+			Render("⚡")
+
+		title := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#ffffff")).
+			Bold(true).
+			Render("Zig Installation Complete")
+
+		stats := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#666666")).
+			Render(fmt.Sprintf("(%d files extracted)", m.total))
+
+		return fmt.Sprintf("\n  %s %s %s\n\n", checkmark, title, stats)
+	}
+
+	// Progress bar styling with zig-inspired colors (orange theme)
+	percentage := float64(m.current) / float64(m.total)
+
+	// Styled spinner
+	spinner := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#f7a41d")).
+		Bold(true).
+		Render(spinnerFrames[m.spinner])
+
+	// Styled title
+	title := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#ffffff")).
+		Bold(true).
+		Render("Installing Zig")
+
+	// Progress bar with custom styling
+	progressBar := m.progress.ViewAs(percentage)
+
+	// Styled stats
+	stats := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#888888")).
+		Render(fmt.Sprintf("%d/%d files (%.1f%%)", m.current, m.total, percentage*100))
+
+	// Performance indicator
+	perfIndicator := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#ff8800")).
+		Render(" • extracting...")
+
+	return fmt.Sprintf("\n  %s %s\n  %s\n  %s%s\n",
+		spinner, title, progressBar, stats, perfIndicator)
+}
+
+type progressMsg struct {
+	current int
+	total   int
+}
+
+type tickMsg struct{}
+
 func bashrcd() error {
 	homeDir := os.Getenv("HOME")
 	installDir := filepath.Join(homeDir, ".local")
@@ -58,62 +165,112 @@ func Install() error {
 		return fmt.Errorf("cleaning up old install: %w", err)
 	}
 
-	xzReader, err := xz.NewReader(bytes.NewReader(zigSrc))
-	if err != nil {
-		return fmt.Errorf("setting up xz reader: %w", err)
+	// Setup enhanced progress bar with zig-inspired colors (orange/lightning theme)
+	p := progress.New(
+		progress.WithScaledGradient("#f7a41d", "#ff8800"),
+		progress.WithWidth(48),
+		progress.WithoutPercentage(),
+	)
+
+	model := progressModel{
+		progress: p,
+		total:    zigTotalFiles,
 	}
-	tr := tar.NewReader(xzReader)
 
-	for {
-		header, err := tr.Next()
+	program := tea.NewProgram(model)
+	var installErr error
+
+	go func() {
+		xzReader, err := xz.NewReader(bytes.NewReader(zigSrc))
 		if err != nil {
-			if errors.Is(err, io.EOF) {
-				break
-			}
-			return err
+			installErr = fmt.Errorf("setting up xz reader: %w", err)
+			program.Quit()
+			return
 		}
-		mode := os.FileMode(header.Mode)
-
-		// Strip the first component (zig-linux-x86_64-0.13.0/)
-		parts := strings.Split(header.Name, "/")
-		if len(parts) > 0 {
-			parts = parts[1:]
-			if len(parts) == 0 {
-				continue
-			}
-			target := filepath.Join(append([]string{zigDir}, parts...)...)
+		tr := tar.NewReader(xzReader)
 
-			switch header.Typeflag {
-			case tar.TypeDir:
-				err = os.MkdirAll(target, mode)
-				if err != nil {
-					return err
+		fileCount := 0
+		for {
+			header, err := tr.Next()
+			if err != nil {
+				if errors.Is(err, io.EOF) {
+					break
 				}
+				installErr = err
+				program.Quit()
+				return
+			}
+			fileCount++
 
-			case tar.TypeReg:
-				// Ensure parent directory exists
-				dir := filepath.Dir(target)
-				err = os.MkdirAll(dir, 0755)
-				if err != nil {
-					return err
-				}
+			// Send progress update
+			program.Send(progressMsg{current: fileCount, total: zigTotalFiles})
 
-				flag := os.O_CREATE | os.O_WRONLY | os.O_TRUNC
-				f, err := os.OpenFile(target, flag, mode)
-				if err != nil {
-					return err
-				}
-				_, err = io.Copy(f, tr)
-				if err != nil {
-					return err
+			mode := os.FileMode(header.Mode)
+
+			// Strip the first component (zig-linux-x86_64-0.13.0/)
+			parts := strings.Split(header.Name, "/")
+			if len(parts) > 0 {
+				parts = parts[1:]
+				if len(parts) == 0 {
+					continue
 				}
-				err = f.Close()
-				if err != nil {
-					return err
+				target := filepath.Join(append([]string{zigDir}, parts...)...)
+
+				switch header.Typeflag {
+				case tar.TypeDir:
+					err = os.MkdirAll(target, mode)
+					if err != nil {
+						installErr = err
+						program.Quit()
+						return
+					}
+
+				case tar.TypeReg:
+					// Ensure parent directory exists
+					dir := filepath.Dir(target)
+					err = os.MkdirAll(dir, 0755)
+					if err != nil {
+						installErr = err
+						program.Quit()
+						return
+					}
+
+					flag := os.O_CREATE | os.O_WRONLY | os.O_TRUNC
+					f, err := os.OpenFile(target, flag, mode)
+					if err != nil {
+						installErr = err
+						program.Quit()
+						return
+					}
+					_, err = io.Copy(f, tr)
+					if err != nil {
+						f.Close()
+						installErr = err
+						program.Quit()
+						return
+					}
+					err = f.Close()
+					if err != nil {
+						installErr = err
+						program.Quit()
+						return
+					}
 				}
 			}
 		}
+
+		// Signal completion
+		program.Send(progressMsg{current: zigTotalFiles, total: zigTotalFiles})
+	}()
+
+	_, err = program.Run()
+	if err != nil {
+		return fmt.Errorf("running progress: %w", err)
+	}
+
+	if installErr != nil {
+		return installErr
 	}
 
 	return nil
-}
\ No newline at end of file
+}

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Ayman Bagabas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

@@ -0,0 +1,305 @@
+// OSC52 is a terminal escape sequence that allows copying text to the clipboard.
+//
+// The sequence consists of the following:
+//
+//	OSC 52 ; Pc ; Pd BEL
+//
+// Pc is the clipboard choice:
+//
+//	c: clipboard
+//	p: primary
+//	q: secondary (not supported)
+//	s: select (not supported)
+//	0-7: cut-buffers (not supported)
+//
+// Pd is the data to copy to the clipboard. This string should be encoded in
+// base64 (RFC-4648).
+//
+// If Pd is "?", the terminal replies to the host with the current contents of
+// the clipboard.
+//
+// If Pd is neither a base64 string nor "?", the terminal clears the clipboard.
+//
+// See https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Operating-System-Commands
+// where Ps = 52 => Manipulate Selection Data.
+//
+// Examples:
+//
+//	// copy "hello world" to the system clipboard
+//	fmt.Fprint(os.Stderr, osc52.New("hello world"))
+//
+//	// copy "hello world" to the primary Clipboard
+//	fmt.Fprint(os.Stderr, osc52.New("hello world").Primary())
+//
+//	// limit the size of the string to copy 10 bytes
+//	fmt.Fprint(os.Stderr, osc52.New("0123456789").Limit(10))
+//
+//	// escape the OSC52 sequence for screen using DCS sequences
+//	fmt.Fprint(os.Stderr, osc52.New("hello world").Screen())
+//
+//	// escape the OSC52 sequence for Tmux
+//	fmt.Fprint(os.Stderr, osc52.New("hello world").Tmux())
+//
+//	// query the system Clipboard
+//	fmt.Fprint(os.Stderr, osc52.Query())
+//
+//	// query the primary clipboard
+//	fmt.Fprint(os.Stderr, osc52.Query().Primary())
+//
+//	// clear the system Clipboard
+//	fmt.Fprint(os.Stderr, osc52.Clear())
+//
+//	// clear the primary Clipboard
+//	fmt.Fprint(os.Stderr, osc52.Clear().Primary())
+package osc52
+
+import (
+	"encoding/base64"
+	"fmt"
+	"io"
+	"strings"
+)
+
+// Clipboard is the clipboard buffer to use.
+type Clipboard rune
+
+const (
+	// SystemClipboard is the system clipboard buffer.
+	SystemClipboard Clipboard = 'c'
+	// PrimaryClipboard is the primary clipboard buffer (X11).
+	PrimaryClipboard = 'p'
+)
+
+// Mode is the mode to use for the OSC52 sequence.
+type Mode uint
+
+const (
+	// DefaultMode is the default OSC52 sequence mode.
+	DefaultMode Mode = iota
+	// ScreenMode escapes the OSC52 sequence for screen using DCS sequences.
+	ScreenMode
+	// TmuxMode escapes the OSC52 sequence for tmux. Not needed if tmux
+	// clipboard is set to `set-clipboard on`
+	TmuxMode
+)
+
+// Operation is the OSC52 operation.
+type Operation uint
+
+const (
+	// SetOperation is the copy operation.
+	SetOperation Operation = iota
+	// QueryOperation is the query operation.
+	QueryOperation
+	// ClearOperation is the clear operation.
+	ClearOperation
+)
+
+// Sequence is the OSC52 sequence.
+type Sequence struct {
+	str       string
+	limit     int
+	op        Operation
+	mode      Mode
+	clipboard Clipboard
+}
+
+var _ fmt.Stringer = Sequence{}
+
+var _ io.WriterTo = Sequence{}
+
+// String returns the OSC52 sequence.
+func (s Sequence) String() string {
+	var seq strings.Builder
+	// mode escape sequences start
+	seq.WriteString(s.seqStart())
+	// actual OSC52 sequence start
+	seq.WriteString(fmt.Sprintf("\x1b]52;%c;", s.clipboard))
+	switch s.op {
+	case SetOperation:
+		str := s.str
+		if s.limit > 0 && len(str) > s.limit {
+			return ""
+		}
+		b64 := base64.StdEncoding.EncodeToString([]byte(str))
+		switch s.mode {
+		case ScreenMode:
+			// Screen doesn't support OSC52 but will pass the contents of a DCS
+			// sequence to the outer terminal unchanged.
+			//
+			// Here, we split the encoded string into 76 bytes chunks and then
+			// join the chunks with <end-dsc><start-dsc> sequences. Finally,
+			// wrap the whole thing in
+			// <start-dsc><start-osc52><joined-chunks><end-osc52><end-dsc>.
+			// s := strings.SplitN(b64, "", 76)
+			s := make([]string, 0, len(b64)/76+1)
+			for i := 0; i < len(b64); i += 76 {
+				end := i + 76
+				if end > len(b64) {
+					end = len(b64)
+				}
+				s = append(s, b64[i:end])
+			}
+			seq.WriteString(strings.Join(s, "\x1b\\\x1bP"))
+		default:
+			seq.WriteString(b64)
+		}
+	case QueryOperation:
+		// OSC52 queries the clipboard using "?"
+		seq.WriteString("?")
+	case ClearOperation:
+		// OSC52 clears the clipboard if the data is neither a base64 string nor "?"
+		// we're using "!" as a default
+		seq.WriteString("!")
+	}
+	// actual OSC52 sequence end
+	seq.WriteString("\x07")
+	// mode escape end
+	seq.WriteString(s.seqEnd())
+	return seq.String()
+}
+
+// WriteTo writes the OSC52 sequence to the writer.
+func (s Sequence) WriteTo(out io.Writer) (int64, error) {
+	n, err := out.Write([]byte(s.String()))
+	return int64(n), err
+}
+
+// Mode sets the mode for the OSC52 sequence.
+func (s Sequence) Mode(m Mode) Sequence {
+	s.mode = m
+	return s
+}
+
+// Tmux sets the mode to TmuxMode.
+// Used to escape the OSC52 sequence for `tmux`.
+//
+// Note: this is not needed if tmux clipboard is set to `set-clipboard on`. If
+// TmuxMode is used, tmux must have `allow-passthrough on` set.
+//
+// This is a syntactic sugar for s.Mode(TmuxMode).
+func (s Sequence) Tmux() Sequence {
+	return s.Mode(TmuxMode)
+}
+
+// Screen sets the mode to ScreenMode.
+// Used to escape the OSC52 sequence for `screen`.
+//
+// This is a syntactic sugar for s.Mode(ScreenMode).
+func (s Sequence) Screen() Sequence {
+	return s.Mode(ScreenMode)
+}
+
+// Clipboard sets the clipboard buffer for the OSC52 sequence.
+func (s Sequence) Clipboard(c Clipboard) Sequence {
+	s.clipboard = c
+	return s
+}
+
+// Primary sets the clipboard buffer to PrimaryClipboard.
+// This is the X11 primary clipboard.
+//
+// This is a syntactic sugar for s.Clipboard(PrimaryClipboard).
+func (s Sequence) Primary() Sequence {
+	return s.Clipboard(PrimaryClipboard)
+}
+
+// Limit sets the limit for the OSC52 sequence.
+// The default limit is 0 (no limit).
+//
+// Strings longer than the limit get ignored. Settting the limit to 0 or a
+// negative value disables the limit. Each terminal defines its own escapse
+// sequence limit.
+func (s Sequence) Limit(l int) Sequence {
+	if l < 0 {
+		s.limit = 0
+	} else {
+		s.limit = l
+	}
+	return s
+}
+
+// Operation sets the operation for the OSC52 sequence.
+// The default operation is SetOperation.
+func (s Sequence) Operation(o Operation) Sequence {
+	s.op = o
+	return s
+}
+
+// Clear sets the operation to ClearOperation.
+// This clears the clipboard.
+//
+// This is a syntactic sugar for s.Operation(ClearOperation).
+func (s Sequence) Clear() Sequence {
+	return s.Operation(ClearOperation)
+}
+
+// Query sets the operation to QueryOperation.
+// This queries the clipboard contents.
+//
+// This is a syntactic sugar for s.Operation(QueryOperation).
+func (s Sequence) Query() Sequence {
+	return s.Operation(QueryOperation)
+}
+
+// SetString sets the string for the OSC52 sequence. Strings are joined with a
+// space character.
+func (s Sequence) SetString(strs ...string) Sequence {
+	s.str = strings.Join(strs, " ")
+	return s
+}
+
+// New creates a new OSC52 sequence with the given string(s). Strings are
+// joined with a space character.
+func New(strs ...string) Sequence {
+	s := Sequence{
+		str:       strings.Join(strs, " "),
+		limit:     0,
+		mode:      DefaultMode,
+		clipboard: SystemClipboard,
+		op:        SetOperation,
+	}
+	return s
+}
+
+// Query creates a new OSC52 sequence with the QueryOperation.
+// This returns a new OSC52 sequence to query the clipboard contents.
+//
+// This is a syntactic sugar for New().Query().
+func Query() Sequence {
+	return New().Query()
+}
+
+// Clear creates a new OSC52 sequence with the ClearOperation.
+// This returns a new OSC52 sequence to clear the clipboard.
+//
+// This is a syntactic sugar for New().Clear().
+func Clear() Sequence {
+	return New().Clear()
+}
+
+func (s Sequence) seqStart() string {
+	switch s.mode {
+	case TmuxMode:
+		// Write the start of a tmux escape sequence.
+		return "\x1bPtmux;\x1b"
+	case ScreenMode:
+		// Write the start of a DCS sequence.
+		return "\x1bP"
+	default:
+		return ""
+	}
+}
+
+func (s Sequence) seqEnd() string {
+	switch s.mode {
+	case TmuxMode:
+		// Terminate the tmux escape sequence.
+		return "\x1b\\"
+	case ScreenMode:
+		// Write the end of a DCS sequence.
+		return "\x1b\x5c"
+	default:
+		return ""
+	}
+}

@@ -0,0 +1,83 @@
+
+# go-osc52
+
+<p>
+    <a href="https://github.com/aymanbagabas/go-osc52/releases"><img src="https://img.shields.io/github/release/aymanbagabas/go-osc52.svg" alt="Latest Release"></a>
+    <a href="https://pkg.go.dev/github.com/aymanbagabas/go-osc52/v2?tab=doc"><img src="https://godoc.org/github.com/golang/gddo?status.svg" alt="GoDoc"></a>
+</p>
+
+A Go library to work with the [ANSI OSC52](https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Operating-System-Commands) terminal sequence.
+
+## Usage
+
+You can use this small library to construct an ANSI OSC52 sequence suitable for
+your terminal.
+
+
+### Example
+
+```go
+import (
+  "os"
+  "fmt"
+
+  "github.com/aymanbagabas/go-osc52/v2"
+)
+
+func main() {
+  s := "Hello World!"
+
+  // Copy `s` to system clipboard
+  osc52.New(s).WriteTo(os.Stderr)
+
+  // Copy `s` to primary clipboard (X11)
+  osc52.New(s).Primary().WriteTo(os.Stderr)
+
+  // Query the clipboard
+  osc52.Query().WriteTo(os.Stderr)
+
+  // Clear system clipboard
+  osc52.Clear().WriteTo(os.Stderr)
+
+  // Use the fmt.Stringer interface to copy `s` to system clipboard
+  fmt.Fprint(os.Stderr, osc52.New(s))
+
+  // Or to primary clipboard
+  fmt.Fprint(os.Stderr, osc52.New(s).Primary())
+}
+```
+
+## SSH Example
+
+You can use this over SSH using [gliderlabs/ssh](https://github.com/gliderlabs/ssh) for instance:
+
+```go
+var sshSession ssh.Session
+seq := osc52.New("Hello awesome!")
+// Check if term is screen or tmux
+pty, _, _ := s.Pty()
+if pty.Term == "screen" {
+  seq = seq.Screen()
+} else if isTmux {
+  seq = seq.Tmux()
+}
+seq.WriteTo(sshSession.Stderr())
+```
+
+## Tmux
+
+Make sure you have `set-clipboard on` in your config, otherwise, tmux won't
+allow your application to access the clipboard [^1].
+
+Using the tmux option, `osc52.TmuxMode` or `osc52.New(...).Tmux()`, wraps the
+OSC52 sequence in a special tmux DCS sequence and pass it to the outer
+terminal. This requires `allow-passthrough on` in your config.
+`allow-passthrough` is no longer enabled by default
+[since tmux 3.3a](https://github.com/tmux/tmux/issues/3218#issuecomment-1153089282) [^2].
+
+[^1]: See [tmux clipboard](https://github.com/tmux/tmux/wiki/Clipboard)
+[^2]: [What is allow-passthrough](https://github.com/tmux/tmux/wiki/FAQ#what-is-the-passthrough-escape-sequence-and-how-do-i-use-it)
+
+## Credits
+
+* [vim-oscyank](https://github.com/ojroques/vim-oscyank) this is heavily inspired by vim-oscyank.

@@ -0,0 +1,365 @@
+// Package progress provides a simple progress bar for Bubble Tea applications.
+package progress
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/harmonica"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/x/ansi"
+	"github.com/lucasb-eyer/go-colorful"
+	"github.com/muesli/termenv"
+)
+
+// Internal ID management. Used during animating to assure that frame messages
+// can only be received by progress components that sent them.
+var lastID int64
+
+func nextID() int {
+	return int(atomic.AddInt64(&lastID, 1))
+}
+
+const (
+	fps              = 60
+	defaultWidth     = 40
+	defaultFrequency = 18.0
+	defaultDamping   = 1.0
+)
+
+// Option is used to set options in New. For example:
+//
+//	    progress := New(
+//		       WithRamp("#ff0000", "#0000ff"),
+//		       WithoutPercentage(),
+//	    )
+type Option func(*Model)
+
+// WithDefaultGradient sets a gradient fill with default colors.
+func WithDefaultGradient() Option {
+	return WithGradient("#5A56E0", "#EE6FF8")
+}
+
+// WithGradient sets a gradient fill blending between two colors.
+func WithGradient(colorA, colorB string) Option {
+	return func(m *Model) {
+		m.setRamp(colorA, colorB, false)
+	}
+}
+
+// WithDefaultScaledGradient sets a gradient with default colors, and scales the
+// gradient to fit the filled portion of the ramp.
+func WithDefaultScaledGradient() Option {
+	return WithScaledGradient("#5A56E0", "#EE6FF8")
+}
+
+// WithScaledGradient scales the gradient to fit the width of the filled portion of
+// the progress bar.
+func WithScaledGradient(colorA, colorB string) Option {
+	return func(m *Model) {
+		m.setRamp(colorA, colorB, true)
+	}
+}
+
+// WithSolidFill sets the progress to use a solid fill with the given color.
+func WithSolidFill(color string) Option {
+	return func(m *Model) {
+		m.FullColor = color
+		m.useRamp = false
+	}
+}
+
+// WithFillCharacters sets the characters used to construct the full and empty components of the progress bar.
+func WithFillCharacters(full rune, empty rune) Option {
+	return func(m *Model) {
+		m.Full = full
+		m.Empty = empty
+	}
+}
+
+// WithoutPercentage hides the numeric percentage.
+func WithoutPercentage() Option {
+	return func(m *Model) {
+		m.ShowPercentage = false
+	}
+}
+
+// WithWidth sets the initial width of the progress bar. Note that you can also
+// set the width via the Width property, which can come in handy if you're
+// waiting for a tea.WindowSizeMsg.
+func WithWidth(w int) Option {
+	return func(m *Model) {
+		m.Width = w
+	}
+}
+
+// WithSpringOptions sets the initial frequency and damping options for the
+// progress bar's built-in spring-based animation. Frequency corresponds to
+// speed, and damping to bounciness. For details see:
+//
+// https://github.com/charmbracelet/harmonica
+func WithSpringOptions(frequency, damping float64) Option {
+	return func(m *Model) {
+		m.SetSpringOptions(frequency, damping)
+		m.springCustomized = true
+	}
+}
+
+// WithColorProfile sets the color profile to use for the progress bar.
+func WithColorProfile(p termenv.Profile) Option {
+	return func(m *Model) {
+		m.colorProfile = p
+	}
+}
+
+// FrameMsg indicates that an animation step should occur.
+type FrameMsg struct {
+	id  int
+	tag int
+}
+
+// Model stores values we'll use when rendering the progress bar.
+type Model struct {
+	// An identifier to keep us from receiving messages intended for other
+	// progress bars.
+	id int
+
+	// An identifier to keep us from receiving frame messages too quickly.
+	tag int
+
+	// Total width of the progress bar, including percentage, if set.
+	Width int
+
+	// "Filled" sections of the progress bar.
+	Full      rune
+	FullColor string
+
+	// "Empty" sections of the progress bar.
+	Empty      rune
+	EmptyColor string
+
+	// Settings for rendering the numeric percentage.
+	ShowPercentage  bool
+	PercentFormat   string // a fmt string for a float
+	PercentageStyle lipgloss.Style
+
+	// Members for animated transitions.
+	spring           harmonica.Spring
+	springCustomized bool
+	percentShown     float64 // percent currently displaying
+	targetPercent    float64 // percent to which we're animating
+	velocity         float64
+
+	// Gradient settings
+	useRamp    bool
+	rampColorA colorful.Color
+	rampColorB colorful.Color
+
+	// When true, we scale the gradient to fit the width of the filled section
+	// of the progress bar. When false, the width of the gradient will be set
+	// to the full width of the progress bar.
+	scaleRamp bool
+
+	// Color profile for the progress bar.
+	colorProfile termenv.Profile
+}
+
+// New returns a model with default values.
+func New(opts ...Option) Model {
+	m := Model{
+		id:             nextID(),
+		Width:          defaultWidth,
+		Full:           '█',
+		FullColor:      "#7571F9",
+		Empty:          '░',
+		EmptyColor:     "#606060",
+		ShowPercentage: true,
+		PercentFormat:  " %3.0f%%",
+		colorProfile:   termenv.ColorProfile(),
+	}
+
+	for _, opt := range opts {
+		opt(&m)
+	}
+
+	if !m.springCustomized {
+		m.SetSpringOptions(defaultFrequency, defaultDamping)
+	}
+
+	return m
+}
+
+// NewModel returns a model with default values.
+//
+// Deprecated: use [New] instead.
+var NewModel = New
+
+// Init exists to satisfy the tea.Model interface.
+func (m Model) Init() tea.Cmd {
+	return nil
+}
+
+// Update is used to animate the progress bar during transitions. Use
+// SetPercent to create the command you'll need to trigger the animation.
+//
+// If you're rendering with ViewAs you won't need this.
+func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case FrameMsg:
+		if msg.id != m.id || msg.tag != m.tag {
+			return m, nil
+		}
+
+		// If we've more or less reached equilibrium, stop updating.
+		if !m.IsAnimating() {
+			return m, nil
+		}
+
+		m.percentShown, m.velocity = m.spring.Update(m.percentShown, m.velocity, m.targetPercent)
+		return m, m.nextFrame()
+
+	default:
+		return m, nil
+	}
+}
+
+// SetSpringOptions sets the frequency and damping for the current spring.
+// Frequency corresponds to speed, and damping to bounciness. For details see:
+//
+// https://github.com/charmbracelet/harmonica
+func (m *Model) SetSpringOptions(frequency, damping float64) {
+	m.spring = harmonica.NewSpring(harmonica.FPS(fps), frequency, damping)
+}
+
+// Percent returns the current visible percentage on the model. This is only
+// relevant when you're animating the progress bar.
+//
+// If you're rendering with ViewAs you won't need this.
+func (m Model) Percent() float64 {
+	return m.targetPercent
+}
+
+// SetPercent sets the percentage state of the model as well as a command
+// necessary for animating the progress bar to this new percentage.
+//
+// If you're rendering with ViewAs you won't need this.
+func (m *Model) SetPercent(p float64) tea.Cmd {
+	m.targetPercent = math.Max(0, math.Min(1, p))
+	m.tag++
+	return m.nextFrame()
+}
+
+// IncrPercent increments the percentage by a given amount, returning a command
+// necessary to animate the progress bar to the new percentage.
+//
+// If you're rendering with ViewAs you won't need this.
+func (m *Model) IncrPercent(v float64) tea.Cmd {
+	return m.SetPercent(m.Percent() + v)
+}
+
+// DecrPercent decrements the percentage by a given amount, returning a command
+// necessary to animate the progress bar to the new percentage.
+//
+// If you're rendering with ViewAs you won't need this.
+func (m *Model) DecrPercent(v float64) tea.Cmd {
+	return m.SetPercent(m.Percent() - v)
+}
+
+// View renders an animated progress bar in its current state. To render
+// a static progress bar based on your own calculations use ViewAs instead.
+func (m Model) View() string {
+	return m.ViewAs(m.percentShown)
+}
+
+// ViewAs renders the progress bar with a given percentage.
+func (m Model) ViewAs(percent float64) string {
+	b := strings.Builder{}
+	percentView := m.percentageView(percent)
+	m.barView(&b, percent, ansi.StringWidth(percentView))
+	b.WriteString(percentView)
+	return b.String()
+}
+
+func (m *Model) nextFrame() tea.Cmd {
+	return tea.Tick(time.Second/time.Duration(fps), func(time.Time) tea.Msg {
+		return FrameMsg{id: m.id, tag: m.tag}
+	})
+}
+
+func (m Model) barView(b *strings.Builder, percent float64, textWidth int) {
+	var (
+		tw = max(0, m.Width-textWidth)                // total width
+		fw = int(math.Round((float64(tw) * percent))) // filled width
+		p  float64
+	)
+
+	fw = max(0, min(tw, fw))
+
+	if m.useRamp {
+		// Gradient fill
+		for i := 0; i < fw; i++ {
+			if fw == 1 {
+				// this is up for debate: in a gradient of width=1, should the
+				// single character rendered be the first color, the last color
+				// or exactly 50% in between? I opted for 50%
+				p = 0.5
+			} else if m.scaleRamp {
+				p = float64(i) / float64(fw-1)
+			} else {
+				p = float64(i) / float64(tw-1)
+			}
+			c := m.rampColorA.BlendLuv(m.rampColorB, p).Hex()
+			b.WriteString(termenv.
+				String(string(m.Full)).
+				Foreground(m.color(c)).
+				String(),
+			)
+		}
+	} else {
+		// Solid fill
+		s := termenv.String(string(m.Full)).Foreground(m.color(m.FullColor)).String()
+		b.WriteString(strings.Repeat(s, fw))
+	}
+
+	// Empty fill
+	e := termenv.String(string(m.Empty)).Foreground(m.color(m.EmptyColor)).String()
+	n := max(0, tw-fw)
+	b.WriteString(strings.Repeat(e, n))
+}
+
+func (m Model) percentageView(percent float64) string {
+	if !m.ShowPercentage {
+		return ""
+	}
+	percent = math.Max(0, math.Min(1, percent))
+	percentage := fmt.Sprintf(m.PercentFormat, percent*100) //nolint:mnd
+	percentage = m.PercentageStyle.Inline(true).Render(percentage)
+	return percentage
+}
+
+func (m *Model) setRamp(colorA, colorB string, scaled bool) {
+	// In the event of an error colors here will default to black. For
+	// usability's sake, and because such an error is only cosmetic, we're
+	// ignoring the error.
+	a, _ := colorful.Hex(colorA)
+	b, _ := colorful.Hex(colorB)
+
+	m.useRamp = true
+	m.scaleRamp = scaled
+	m.rampColorA = a
+	m.rampColorB = b
+}
+
+func (m Model) color(c string) termenv.Color {
+	return m.colorProfile.Color(c)
+}
+
+// IsAnimating returns false if the progress bar reached equilibrium and is no longer animating.
+func (m *Model) IsAnimating() bool {
+	dist := math.Abs(m.percentShown - m.targetPercent)
+	return !(dist < 0.001 && m.velocity < 0.01)
+}