Bubble Tea v2: What’s New in v2 + How to Upgrade

[meowgorithm]

Welcome to Bubble Tea v2

We're very excited to announce the forthcoming second major release of Bubble Tea! This document outlines the changes and improvements in Bubble Tea v2.0.0 and generally serves as a migration guide.

Note

We don't take API changes lightly and strive to make the upgrade process as simple as possible. We believe the changes bring necessary improvements as well as pave the way for the future. If something feels way off, let us know.

What’s new?

❤️ Charm Land Import Path

We've updated our import paths to use vanity domains and use our domain to import Go packages.

// Before
import tea "github.com/charmbracelet/bubbletea/v2"

// After
import tea "charm.land/bubbletea/v2"

Everything else stays the same 🙂

👾 The Cursed Renderer

Bubble Tea v2 ships with the all-new Cursed Renderer which was built from the ground up. It's based on the ncurses rendering algorithm and is highly optimized for speed, efficiency, and accuracy and is built on an enormous amount of research and development.

Optimized renders also means that Wish users get big performance benefits and lower bandwidth usage by orders of magnitude.

To take advantage of the new Cursed Renderer you don't need to do anything at all except keep on using the Bubble Tea you know and love.

✌️ Key handling is way better now

Newer terminals can now take advantage of all sorts keyboard input via progressive keyboard enhancements. You can now map all sorts of keys and modifiers like shift+enter and super+space. You can also detect key releases (we're looking at you, game developers).

It's easy to detect support for supporting terminals and add fallbacks for those that don't. For details, see keyboard enhancements below.

🥊 No more fighting

In the past, Bubble Tea and Lip Gloss would often fight over i/o. Bubble Tea wanted to read keyboard input and Lip Gloss wanted to query for the background color. This means that things this could get messy. Not anymore! In v2, Lip Gloss is now pure, which means, Bubble Tea manages i/o and gives orders to Lip Gloss. In short, we only need one lib to call the shots call the shots, and in the context of this relationship, that lib is Bubble Tea.

But what about color downasampling? That's a great question.

👨🏻‍🎨 Built-in Color Downsampling

We sneakily released a little library called colorprofile that will detect the terminal's color profile and auto-downsample any ANSI styling that flows through it to the best available color profile. This means that color will "just work" (and not misbehave) no matter where the ANSI styling comes from.

Downsampling is built-into Bubble Tea and is automatically enabled.

API Updates

Keyboard Enhancements

Progressive keyboard enhancements, allow you to receive key events not normally possible in traditional terminals. For example, you can now listen for the ctrl+m key, as well as previously unavailable key combinations like the converted shift+enter.

Bubble Tea v2 will always try to enable basic keyboard enhancements that disambiguate keys. If your terminal supports it, your program will receive a tea.KeyboardEnhancementsMsg message that indicates support for requested features.

func (m Model) View() tea.View {
    var v tea.View
    // ...
    v.KeyboardEnhancements.ReportEventTypes = true           // Enable key release events
    return v
}

Historically, certain key combinations in terminals map to control codes. For example, ctrl+h outputs a backspace by default, which means you can't normally bind a key event to ctrl+h. With key disambiguation, you can now actually bind events to those key combinations.

You can detect if a terminal supports keyboard enhancements by listening for tea.KeyboardEnhancementsMsg.

func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyboardEnhancementsMsg:
        if msg.SupportsKeyDisambiguation() {
            // More keys, please!
        }
    }
}

Which terminals support progressive enhancement?

• Ghostty
• Kitty
• Alacritty
• iTerm2
• Foot
• WezTerm
• Rio
• Contour Terminal

Changed: Key Messages

Key messages are now split into tea.KeyPressMsg and tea.KeyReleaseMsg. Use tea.KeyMsg to match against both.

// Before:
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyMsg:
        // I'm a key press message
    }
}

// After:
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyMsg:
        // I'm a key press or release message
        switch key := msg.(type) {
        case tea.KeyPressMsg:
            // I'm a key press message
            return m, tea.Printf("You pressed %s", key)
        case tea.KeyReleaseMsg:
            // I'm a key release message ;)
            return m, tea.Printf("Key released: %s", key)
        }
    }
}

We also no longer have key.Type and key.Runes fields. These have been replaced with key.Code and key.Text respectively. A key code is just a rune that represents the key message. It can be a special key like tea.KeyEnter, tea.KeyTab, tea.KeyEscape, or a printable rune.

// Before:
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyMsg:
        switch msg.Type {
        case tea.KeyEnter:
            // Enter key
        case tea.KeyRune:
            // A printable rune
            switch msg.Runes[0] {
            case 'a':
                // The letter 'a'
            }
        }
    }
}

// After:
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyPressMsg:
        switch msg.Code {
        case tea.KeyEnter:
            // Enter key
        case 'a':
            // The letter 'a'
        }
    }
}

The new key.Text field signifies a printable key event. If the key event has a non-empty Text field, it means the key event is a printable key event. In that case, key.Code is always going to be the first rune of key.Text.

// Before:
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyMsg:
        if msg.Type == tea.KeyRune {
            // A printable rune
            switch string(msg.Runes) {
            case "😃":
                // Smiley face
            }
        }
    }
}

// After:
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyPressMsg:
        // A printable rune
        switch msg.Text {
        case "😃":
            // Smiley face
        }
    }
}

Instead of matching against msg.Type == tea.KeyCtrl... keys, key modifiers are now part of the key event itself as key.Mod. Shifted keys now have their own key code in key.ShiftedCode. Typing shift+b will produce key.Code == 'b', key.ShiftedCode == 'B', key.Text == "B", and key.Mod == tea.ModShift.

// Before:
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyMsg:
        switch msg.Type {
        case tea.KeyCtrlC:
            // ctrl+c
        case tea.KeyCtrlA:
            // ctrl+a
        default: // 🙄
            // can i catch all ctrl+<key> combinations?
            if msg.Alt {
                // but i want to catch ctrl+alt+<key> combinations too 🤔
                return m, tea.Printf("idk what to do with '%s'", msg)
            }
            switch msg.Runes[0] {
            case 'B': // shift+a
                // ugh, i forgot caps lock was on
                return m, tea.Printf("You typed '%s'", msg.Runes)
            }
        }
    }
}

// After:
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyPressMsg:
        switch msg.Mod {
        case tea.ModCtrl: // We're only interested in ctrl+<key>
            switch msg.Code {
            case 'c':
                // ctrl+c
            case 'a':
                // ctrl+a
            default:
                return m, tea.Printf("That's an interesting key combo! %s", msg)
            }
        default:
            if msg.Mod.Contains(tea.ModCtrl|tea.ModAlt) {
                return m, tea.Printf("I'm a '%s' 😎!", msg)
            }
            if len(msg.Text) > 0 {
                switch msg.String() {
                case "shift+b":
                    // It doesn't matter if caps lock is on or off, we got your back!
                    return m, tea.Printf("You typed '%s'", msg.Text) // "B"
                }
            }
        }
    }
}

The easiest way to match against key press/release events is to use msg.String():

func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyPressMsg:
        switch msg.String() {
        case "space":
            // Space bar returns "space" now :D
            return m, tea.Println("You pressed the space bar!")
        case "ctrl+c":
            // Copy to the clipboard.
            return m, tea.SetClipboard("Howdy")
        case "ctrl+v":
            // Read the clipboard (not supported by all terminals).
            return m, tea.ReadClipboard()
        case "alt+enter":
            // Fullscreen mode, anyone?
        case "shift+x":
            // Just an upper case 'x'
            return m, tea.Println("You typed %q", msg.Text) // "X"
        case "shift+enter":
            // Awesome, right?
        case "ctrl+alt+super+enter":
            // Yes, you can do that now!
        }
    }
}

Oh, and we finally changed space bar to return "space" instead of " ". In this case, key.Code == ' ' and key.Text == " ".

Paste messages

Bubble Tea v1 supports bracketed-paste mode by default. It sends paste events as a tea.KeyMsg with msg.Paste flag set to true, which to be honest, was pretty confusing.

In Bubble Tea v2, paste events are sent as their own tea.PasteMsg message. You can listen also listen to paste tea.PasteStartMsg and tea.PasteEndMsg events to detect paste start and end events.

// Before:
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyMsg:
        if msg.Paste {
            // That's weird, I'm a paste message
            m.text += string(msg.Runes)
        }
    }
}

// After:
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyMsg:
        // I'm a key message
    case tea.PasteMsg:
        // Here comes a paste!
        m.text += msg.Content
    case tea.PasteStartMsg:
        // The user started pasting.
    case tea.PasteEndMsg:
        // The user stopped pasting.
    }
}

Mouse messages

We've also improved the mouse API, which is a breaking change. Use tea.MouseMsg to match against different types of mouse events. Mouse messages are split into tea.MouseClickMsg, tea.MouseReleaseMsg, tea.MouseWheelMsg, and tea.MouseMotionMsg.

// Before:
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.MouseMsg:
        switch msg.Button {
        case tea.MouseButtonWheelUp:
            // Whee!
        case tea.MouseButtonLeft:
            // Clickety-click
        }
    }
}

// After:
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.MouseMsg:
        mouse := msg.Mouse()
        switch msg := msg.(type) {
        case tea.MouseClickMsg:
            switch msg.Button {
            case tea.MouseLeft:
                // Clickety click
            }
        case tea.MouseReleaseMsg:
            // Release the mouse!
        case tea.MouseWheelMsg:
            // Scroll, scroll, scrollllll
        case tea.MouseMotionMsg:
            // Where did the mouse go?
        }

        return m, tea.Printf("%T: (X: %d, Y: %d) %s", msg, mouse.X, mouse.Y, mouse)
    }
}

A Declarative View

In Bubble Tea v1, the View() method always returned a string. This is
limiting because it doesn't allow for additional metadata to be returned along
with the content to render. Additionally, it made it hard to extend the API in
the future.

In v2, we introduce a new View type that allows you to declare precisely how
your view should behave.

type View struct {
    Layer                     Layer        // Layer represents the content of the view
    Cursor                    *Cursor      // Position, style, color (nil = hidden)
    BackgroundColor           color.Color  // Terminal default background color
    ForegroundColor           color.Color  // Terminal default foreground color
    WindowTitle               string       // Window title
    ProgressBar               *ProgressBar // Progress bar (nil = no progressbar)
    AltScreen                 bool         // Alternate screen buffer (fullscreen mode)
    MouseMode                 MouseMode    // Mouse event mode
    ReportFocus               bool         // Focus/blur events
    DisableBracketedPasteMode bool         // Bracketed paste
    KeyboardEnhancements KeyboardEnhancements  // Keyboard enhancements
}

Now, if you want your program to run in alt-screen mode, you can simply set the
view.AltScreen field to true. No more fighting over options and commands!

// Before:
func (m Model) View() string {
  return fmt.Sprintf("Hello, world!") // No alt-screen
}

// After without alt-screen:
func (m Model) View() tea.View {
  return tea.NewView(fmt.Sprintf("Hello, world!"))
  // Or alternatively:
  // var v tea.View
  // v.SetContent(fmt.Sprintf("Hello, world!"))
  // return v
}

// After with alt-screen:
func (m Model) View() tea.View {
  v := tea.NewView(fmt.Sprintf("Hello, world!"))
  v.AltScreen = true // Enable alt-screen mode
  return v
}

In Bubble Tea v2, the View method returns a tea.View struct. This struct contains the content to render as well as additional metadata like cursor position, style, and visibility.

An Actual Cursor

Another nice feature in Bubble Tea v2 is the ability to control the cursor. Now, the tea.Model interface is split into tea.Model and tea.ViewModel. Or if you're interested in controlling the cursor, you can use the tea.CursorModel interface.

The tea.CursorModel interface returns a *tea.Cursor struct that contains the cursor's position, style, and visibility. Do you want it hidden? Sure, just return nil and everything will be taken care of.

// Before, no cursor control:
func (m Model) View() string {
	return fmt.Sprintf("Hello, world!") // No cursor control
}

// After with cursor control:
func (m Model) View() tea.View {
  var v tea.View
	var cur *tea.Cursor
	if m.showCursor {
		cur = &tea.Cursor{
			X: 14,                  // At the 14th column
			Y: 0,                   // On the first row
			Style: tea.CursorBlock, // Just give me a block cursor '█'
			Blink: true,            // Blink baby, blink!
			Color: lipgloss.Green,     // Green cursor, because why not?
		}
	}
	v.SetContent(fmt.Sprintf("Hello, world!"))
  v.Cursor = cur
  return v
}

Progress Bar Support

Now you can ask Bubble Tea to render a native progress bar for your
application. Doing some async work and want to show progress? Just set the
view.ProgressBar field and Bubble Tea will take care of the rest.

func (m Model) View() tea.View {
    var v tea.View
    v.SetContent("Downloading...")

    // Show a progress bar with the current download progress.
    v.ProgressBar = tea.NewProgressBar(tea.ProgressBarDefault, m.downloadProgress)

    return v
}

Synchronized Updates (Mode 2026)

Now, Bubble Tea will try and use mode 2026 to push updates to the terminal. This mode helps reduce tearing and cursor flickering by atomically updating the terminal window once all the update sequences are pushed out and read by the terminal. This is enabled by default and there's nothing you need to do.

Other new things

Native clipboard support

Bubble Tea now supports native clipboard operations, also known as OSC52. This means you can even copy and paste over SSH!

func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyMsg:
        switch msg.String() {
        case "ctrl+c":
            // Copy to the clipboard.
            return m, tea.SetClipboard("Howdy")

        case "ctrl+v":
            // Read the clipboard (not supported by all terminals).
            return m, tea.ReadClipboard()
        }

    case tea.ClipboardMsg:
        // Here's the clipboard contents.
        fmt.Printf("Clipboard contents: %s\n", msg.String())
    }
}

X11 and Wayland users can also use tea.SetPrimaryClipboard to set the primary clipboard. Note that this is a very niche sort of thing and may or may not work on macOS, Windows, and other platforms without the notion of more than one clipboard.

Terminal colors

You can now read and set the terminal's foreground, background, and cursor colors. This is useful for creating advanced terminal applications.

To change the terminal's colors, set view.ForegroundColor, view.BackgroundColor, and view.Cursor.Color in your View() function.

// Read the terminal's colors when the program starts.
func (m Model) Init() (tea.Model, tea.Cmd) {
    return m, tea.Batch(
        tea.RequestForegroundColor,
        tea.RequestBackgroundColor,
        tea.RequestCursorColor,
    )
}

// Change the terminal's colors when the user presses enter and reset on exit.
func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.BackgroundColorMsg:
        return m, tea.Printf("Background color: %s\n", msg)
    case tea.ForegroundColorMsg:
        return m, tea.Printf("Foreground color: %s\n", msg)
    case tea.CursorColorMsg:
        return m, tea.Printf("Cursor color: %s\n", msg)
    case tea.KeyPressMsg:
        switch msg.String() {
        case "enter":
            m.fg, m.bg, m.cursor = ansi.Red, ansi.Green, ansi.Blue
        case "esc":
            return m, tea.Quit
        }
    }

    return m, nil
}

// Set the colors in the View.
func (m Model) View() tea.View {
    var v tea.View
    v.SetContent("\nPress Enter to change terminal colors, Esc to quit.")
    v.ForegroundColor = m.fg
    v.BackgroundColor = m.bg
    if m.cursor != nil {
        // Only show the cursor if we have a color for it.
        v.Cursor = tea.NewCursor(0, 1) // First column, second row
        v.Cursor.Color = m.cursor
    }
    return v
}

Terminal version and name

Don't know what terminal you're running in? $TERM is too vague? Bubble Tea now has a tea.RequestTerminalVersion command that queries the terminal for its name and version using XTVERSION control sequence.

Note

This feature is not supported by all terminals.

func (m Model) Init() (tea.Model, tea.Cmd) {
    return m, tea.RequestTerminalVersion
}

func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.TerminalVersionMsg:
        fmt.Printf("Terminal: %s\n", string(msg))
    }
}

Terminfo and Termcap capabilities

Sometimes you need to know what capabilities the terminal has. Bubble Tea now has a tea.RequestCapability command that queries the terminal for a specific terminfo/termcap capability.

Note

This feature is not supported by all terminals.

func (m Model) Init() (tea.Model, tea.Cmd) {
    return m, tea.RequestCapability("RGB") // RGB is the terminfo capability for direct colors
}

Detecting the color profile

Need to use the detected color profile in your app? Listen to
tea.ColorProfileMsg in Update:

func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.ColorProfileMsg:
        m.colorProfile = msg.Profile // gottem!
    }
    return m, nil
}

Manually applying a color profile

What's that you say? You want to manually set a color profile for testing? Now you can, on the program level.

import (
    "charm.land/bubbletea/v2"
    "github.com/charmbraclelet/colorprofile"
)

p := colorprofile.TrueColor // i love colors. lets' use 16,777,216 of 'em
p = colorprofile.ANSI256    // jk, 256 colors are plenty
p = colorprofile.ANSI       // actually let's juse use 16 colors
p = colorprofile.Ascii      // nm, no colors, but keep things like bold, italics, etc.
p = colorprofile.NoTTY      // lol actually strip all ANSI sequences

prog := tea.Program(tea.WithColorProfile(p))

Want to hard detect the color profile in Wish? We bet you do.

func main() {
    var s ssh.Session
    pty, _, _ := s.Pty()

    // Get the environment...
    envs := append(s.Environ(), "TERM="+pty.Term)

    // ...and give it to Bubble Tea so it can detect the color profile.
    opt := tea.WithEnvironment(envs)

    p := tea.NewProgram(model,
        tea.WithInput(pty.Slave),
        tea.WithOutput(pty.Slave),
        opt, // wow
    )
}

Use the Terminal's TTY

Sometimes your program will write to stdout while it's being piped or
redirected. In these cases, you might want to write directly to the terminal's
TTY instead of stdout because stdout might not be a terminal. Or your program
expects to read from stdin but stdin is being piped from another program.

In Bubble Tea v1, there wasn't a good way to do this. In the later case, you
could use the WithInputTTY() option to read from the terminal's TTY instead
of stdin. However, there was no easy way to write to the terminal's TTY instead
of stdout without fiddling with file descriptors.

In Bubble Tea v2, you can now use simply use the global OpenTTY() to open the
terminal's TTY for reading and writing. You can then pass the TTY file handles
to the WithInput() and WithOutput() options.

ttyIn, ttyOut, err := tea.OpenTTY()
if err != nil {
    log.Fatal(err)
}

p := tea.NewProgram(model,
    tea.WithInput(ttyIn),
    tea.WithOutput(ttyOut),
)

🌈 More on Bubble Tea v2

Just getting into Bubble Tea v2? Check out the full v2 release notes and upgrade guide.

Feedback

Have thoughts on Bubble Tea v2 Alpha? We’d love to hear about it. Let us know on…

• Discord
• Matrix
• Email

---

Part of Charm.

Charm热爱开源 • Charm loves open source • نحنُ نحب المصادر المفتوحة

[desertwitch]

Congratulations on the release, just a quick question - are bugfixes for main branch (V1) code still actively wanted or should pull requests be tailored directly to v2-exp branch (V2) code? Just asking for problems that may exist both in V1 and V2 code - would you like respective pull requests for both branches or just V2? Is V1 now EOL or are there still going to be (bugfix) releases? 😉

[aymanbagabas]

Hi @desertwitch! Thank you for your recent awesome work on Bubble Tea, we look forward to merging them 🙂

As for v2, we are going to push bugfixes and releases to the main branch (v1) until v2 is merged into main and the first stable release is pushed. That being said, we regularly merge main back into v2-exp to keep both branches up-to-date.
Feel free to send us a PR merging main into v2-exp once we get both #1372 and #1373 in.

[juanibiapina]

Looking forward to upgrade!

But, the link full v2 release notes and upgrade guide. is pointing to example.com

[aymanbagabas]

Thank you, @juanibiapina, for pointing this out. Actually, this is the upgrade guide 😅, so I updated the link to point to this discussion. Though, we might change that in the future.

[mikesmithgh]

FYI I tried go get github.com/charmbracelet/bubbletea/v2 and receive the following:

go: downloading github.com/charmbracelet/bubbletea/v2 v2.0.0-beta.1
go: github.com/charmbracelet/bubbletea/[email protected]: verifying module: checksum mismatch
	downloaded: h1:AOXhvsZa/VZhuBbrUR8GWbYloAkMw2OeHWWgFjKYPA0=
	sum.golang.org: h1:RvpXiXuPAuaKCHPCsE/lK5+zztnNDTSCa0CpeeIKdDU=

SECURITY ERROR
This download does NOT match the one reported by the checksum server.
The bits may have been replaced on the origin server, or an attacker may
have intercepted the download attempt.

For more information, see 'go help module-auth'.

From https://proxy.golang.org/github.com/charmbracelet/bubbletea/v2/@v/v2.0.0-beta.1.info it looks like the go proxy has the second most recent commit cached on that tag.

{
  "Version": "v2.0.0-beta.1",
  "Time": "2025-03-26T18:11:28Z",
  "Origin": {
    "VCS": "git",
    "URL": "https://github.com/charmbracelet/bubbletea",
    "Hash": "9c9f0231712a8254babc5105878f92492f54a1b2",
    "Ref": "refs/tags/v2.0.0-beta.1"
  }
}

The following works without any issues:

by commit:

go get github.com/charmbracelet/bubbletea/v2@9c9f023

by branch:

go get github.com/charmbracelet/bubbletea/v2@v2-exp

[caarlos0]

another q: what's on your GOSUMDB and GOPROXY?

$ go env GOSUMDB GOPROXY
sum.golang.org
https://proxy.golang.org,direct

[mikesmithgh]

@caarlos0

My current values:

go env GOSUMDB GOPROXY

sum.golang.org
direct

If I do go get github.com/charmbracelet/bubbletea/v2 I get the checksum error.

If I update them to:

go env GOSUMDB GOPROXY

sum.golang.org
https://proxy.golang.org,direct

then go get github.com/charmbracelet/bubbletea/v2 works without issues 🙌

So, this looks like it was just my config sorry about that 😂 .

The version cached in the proxy is correct. Since I was pulling directly from the repo, the checksum didn't match what was in sum.golang.org.

I think I may have previously ran go env -w GOPROXY=direct in the past and it stored it as the default. Then I didn't realize since it wasn't in my dotfiles.

Running go env -u GOPROXY reset it back to the real default https://proxy.golang.org,direct.

Thanks for the help!

[caarlos0]

nice! glad we figured it out :D

[desertwitch]

FWIW I did also observe this issue in some more recent CI builds/runs:
https://github.com/charmbracelet/bubbletea/actions/runs/14177694471/job/39716410112
https://github.com/charmbracelet/bubbletea/actions/runs/14429105474/job/40501844311
https://github.com/charmbracelet/bubbletea/actions/runs/14274968386/job/40016214713

[meowgorithm]

Appreciate you flagging, @desertwitch. Odd that it's happening with Glamour here.

@aymanbagabas @caarlos0 maybe something's awry in our GoReleaser config?

[GeenDutchman]

I'm kinda sad that the other bubbles/related libraries don't have v2 stuff yet 😦 I wanna use both! Guess I'll have to either make PRs or switch to just the central charm libraries.

(Yes I'm using beta libraries right now, and yes patience is a virtue lol)

[meowgorithm]

Do you mean third party libraries? (Bubbles has a v2 beta).

[aymanbagabas]

We just announced Bubble Tea beta 5! Get it while it's hot!

go get github.com/charmbracelet/bubbletea/[email protected]

Have thoughts on Bubble Tea v2 beta 5? We’d love to hear about it.

[cg219]

Now v6 of the beta is out is out!

go get github.com/charmbracelet/bubbletea/[email protected]

[aymanbagabas]

Hey everyone, we just released the second RC release! We're getting there, expect v2.0.0 very soon!!

go get github.com/charmbracelet/bubbletea/[email protected]

[caarlos0]

go get charm.land/bubbletea/[email protected]

[cg219]

go get charm.land/bubbletea/v2

This worked for me. No need to specify the version (unless you want to)