Bubble Tea v2 Beta: 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?

👹 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 downsampling? 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 super key (aka, the Windows key on Windows and the Command key on macOS), as well as previously unavailable key combinations like the covetted shift+enter.

To enable this feature use the tea.WithKeyboardEnhancements option when creating a new program to get all the keys, in supported terminals only.

You can enable enhanced keyboard support by passing the tea.WithKeyboardEnhancements option to tea.NewProgram or by using the tea.RequestKeyboardEnhancements command.

p := tea.NewProgram(model, tea.WithKeyboardEnhancements())

// Or in your `Init` function:
func (m Model) Init() tea.Cmd {
    return m, tea.RequestKeyboardEnhancements()
}

By default, only key disambiguation is enabled. What does that even mean? 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.

Release events aren't included by default when you enable keyboard enhancements, but you can opt-into them with the tea.WithKeyReleases flag:

opt := tea.WithKeyboardEnhancements(tea.WithKeyReleases)  // ProgramOption
tea.RequestKeyboardEnhancements(tea.WithKeyReleases)      // Cmd

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

func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyboardEnhancementsMsg:
        // Now you can see what's supported:
        //msg.SupportsKeyDisambiguation()
        //msg.SupportsKeyReleases(),
        //msg.SupportsUniformKeyLayout()
    }
}

Note

This feature is enabled by default on Windows due to the fact that we use the Windows Console API to support other Windows features.

Which terminals support progressive enhancement?

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

Uniform Key Handling

When targeting users on different platforms and keyboard layouts, it's important to have a consistent and reliable way to handle key events. With this release, you can now use tea.WithUniformKeyLayout keyboard enhancement to ensure that your program works as expected across different keyboard layouts.

For example, on a multi-layout QWERTY keyboard, ctrl+a should always trigger a ctrl+a event, regardless of the layout language. Similarly, shift+h should send a shift+h event with the letter H as its printable value. But what happens when you press shift+h in a different QWERTY layout?

Let's take the PC-101 QWERTY Arabic layout as an example. In this layout, shift+h corresponds to the Arabic letter أ. If you're building a game or an application that relies on key events where you don't really care about the actual printable value of the key press, you'd want to ensure that shift+h always sends a shift+h event despite the layout language.

This will also respect the keyboard layout and send the correct printable value for the key press. For example, on a US QWERTY keyboard, ctrl+a corresponds to the first letter on the second row of the keyboard. On a French AZERTY keyboard, the same key combinations correspond to ctrl+q.

To achieve this, you can use the tea.WithUniformKeyLayout option and let Bubble Tea handle the rest.

p := tea.NewProgram(model, tea.WithEnhancedKeyboard(
        tea.WithKeyReleases, // Do we want to listen to key releases?
        tea.WithUniformKeyLayout,
    ))

// Later in your program's Update function.
func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyPressMsg:
        switch msg.String() {
        case "ctrl+a":
            // Handle ctrl+a event regardless of the keyboard layout.
        case "shift+h":
            // Handle shift+h event regardless of the keyboard layout and get the correct printable value.
        }
    }
    return m, nil
}

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 += string(msg)
    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)
    }
}

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() (string, *tea.Cursor) {
	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!
		}
	}
	return fmt.Sprintf("Hello, world!"), cur
}

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 system clipboard contents.

    case tea.PrimaryClipboardMsg:
        // Only on X11 and Wayland ;)
    }
}

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, use tea.SetForegroundColor, tea.SetBackgroundColor, and tea.SetCursorColor.

// Read the terminal's colors when the program starts.
func (m Model) Init() 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":
            return m, tea.Batch(
                tea.SetForegroundColor(ansi.Red),
                tea.SetBackgroundColor(ansi.Green),
                tea.SetCursorColor(ansi.Blue),
            )
        case "esc":
            return m, tea.Quit
        }
    }

    return m, nil
}

Terminal version and name

Don't know what terminal you're running in? $TERM is too vague? Bubble Tea now has a tea.TerminalVersion 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.Cmd {
    return m, tea.TerminalVersion
}

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.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 (
    "github.com/charmbraclelet/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.NewProgram(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
    )
}

🍇 Grapheme Clustering

Grapheme what? In short, grapheme clustering is a way to handle Unicode text segmentation and boundaries. It's useful when you want to determine the terminal cell width a string or a grapheme cluster occupies. The algorithm is defined in the Unicode Text Segmentation UAX #29.

For example, '🧑‍🌾' is a single grapheme cluster, but it's made up of 3 UTF-8 codepoints. Terminals that support grapheme clustering will treat this as a 2 cell wide character, while those that don't might treat it as 2, 4, 5, or even 6 cells wide. Our friend Mitchell Hashimoto has a great blog post on this topic: Grapheme Clusters and Terminal Emulators.

We've added grapheme clustering and mode 2027 support in the previous alpha.1 release, and it was on by default. We've noticed that some terminals, like Apple Terminal, don't play well with this feature. Specifically, with the DECRQM control sequence. Not cool.

Now we're making the feature opt-in and off by default. You can still enable it by using the tea.WithGraphemeClustering option.

p := tea.NewProgram(model, tea.WithGraphemeClustering())

// Or in your program's Init function.
func (m model) Init() tea.Cmd {
    return tea.EnableGraphemeClustering
}

Want to learn more about grapheme clusters? Mitchell Hashimoto has a great post about it.

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).