bubblyui

package module

v0.12.0 Latest Latest Go to latest Published: Dec 3, 2025 License: MIT Imports: 1 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/newbpydev/bubblyui

Links

Open Source Insights

README ¶

BubblyUI

A Vue-inspired TUI framework for Go with type-safe reactivity and component-based architecture

BubblyUI brings the familiar patterns of Vue.js to Go terminal applications, providing a reactive, component-based framework built on Bubbletea. Write beautiful terminal interfaces with the same declarative patterns you're used to from web development.

✨ Features

🔄 Type-Safe Reactivity

Ref[T]: Reactive references with automatic dependency tracking
Computed[T]: Derived values that update automatically
Watch: Side effects that respond to reactive changes
Full Type Safety: Compile-time guarantees with Go generics

🧩 Component System

Vue-Inspired API: Familiar component patterns for Go developers
Zero-Boilerplate Launch: bubbly.Run() eliminates all Bubbletea setup (69-82% less code for async apps!)
Async Auto-Detection: No manual tick wrappers needed - framework handles it automatically
Lifecycle Hooks: onMounted, onUpdated, onUnmounted, onBeforeUpdate, onBeforeUnmount, onCleanup
Composition API: 30 composables (Standard, TUI-Specific, State, Timing, Collections, Development), provide/inject
Auto-Initialization: Automatic component initialization with ctx.ExposeComponent() (33% less boilerplate)

🎨 Template System

Go Functions: Type-safe rendering with Go functions (not string templates)
Lipgloss Integration: Direct styling with Lipgloss for maximum flexibility
Conditional Rendering: If() and Show() directives for conditional logic
List Rendering: ForEach() directive for dynamic lists
Data Binding: Bind() directive for two-way data binding
Event Binding: On() directive for event handling

🧩 Built-in Components (30+)

Atoms: Button, Icon, Badge, Spinner, Text, Toggle
Molecules: Input, TextArea, Checkbox, Radio, Select, Card, List, Menu, Tabs, Accordion
Organisms: Table (with sorting/pagination), Form (with validation), Modal
Templates: PageLayout, AppLayout, PanelLayout, GridLayout

Named routes with parameters (/users/:id)
Route guards (beforeEnter, beforeLeave)
Nested routes and query strings
History navigation (back/forward)

📐 Advanced Layout System (Flexbox-Inspired)

Flex: Container with direction, wrap, justify, align, gap
Stacks: HStack (horizontal), VStack (vertical) with spacing and dividers
Positioning: Center (horizontal/vertical), Container (width-constrained)
Primitives: Box (padding/border), Spacer (fixed/flex), Divider (horizontal/vertical)

🛠️ Development & Testing Tools

State inspector, event timeline, command debugger
TestComponent helper, MockContext for unit tests
Performance profiler (17 components) with pprof, flame graphs, and Prometheus
MCP Server for AI tool integration

🎯 Automation Patterns

Theme System: UseTheme()/ProvideTheme() for 94% less theme boilerplate
Multi-Key Bindings: WithMultiKeyBindings() for 67% less key binding code
Shared Composables: CreateShared() for singleton state across components

🚀 Quick Start

Installation

go get github.com/newbpydev/bubblyui

Basic Example

package main

import (
    "fmt"
    "github.com/newbpydev/bubblyui/pkg/bubbly"
)

func main() {
    counter, _ := bubbly.NewComponent("Counter").
        WithKeyBinding("up", "increment", "Increment").
        WithKeyBinding("down", "decrement", "Decrement").
        WithKeyBinding("q", "quit", "Quit").
        Setup(func(ctx *bubbly.Context) {
            count := ctx.Ref(0)
            ctx.Expose("count", count)

            ctx.On("increment", func(interface{}) {
                count.Set(count.GetTyped().(int) + 1)
            })

            ctx.On("decrement", func(interface{}) {
                count.Set(count.GetTyped().(int) - 1)
            })
        }).
        Template(func(ctx bubbly.RenderContext) string {
            count := ctx.Get("count").(*bubbly.Ref[interface{}])
            comp := ctx.Component()
            return fmt.Sprintf("Count: %d\n\n%s",
                count.GetTyped().(int),
                comp.HelpText())
        }).
        Build()

    // Clean, simple, zero boilerplate! 🎉
    bubbly.Run(counter, bubbly.WithAltScreen())
}

📖 Documentation

Core Concepts

Reactivity System - Type-safe reactive state with Ref[T], Computed[T], Watch
Component Model - Vue-inspired component architecture
Lifecycle Hooks - 6 lifecycle hooks for component management
Composition API - Composables and provide/inject
Directives - If, ForEach, Bind, On, Show
Built-in Components - 30+ ready-to-use UI components
Router - SPA-style navigation for TUI
Automatic Bridge - Zero-boilerplate Bubbletea integration
Development Tools - State inspector and debugging
Testing Utilities - Component testing helpers
Performance Profiler - CPU/memory profiling
MCP Server - AI tool integration
Layout System - Flexbox-inspired layouts

Features & Guides

Framework Run API - Zero-boilerplate application launcher (⭐ NEW!)
Auto-Initialization - Automatic component initialization
Migration: Manual to Run API - Upgrade to bubbly.Run() (⭐ RECOMMENDED)
Migration: Manual to Auto-Init - Upgrade to auto-initialization

API Reference

Package Documentation - Complete API reference
Examples - Comprehensive usage examples
Migration from Bubbletea - Guide for Bubbletea users

🛠️ Development

Prerequisites

Go 1.22+ (required for generics)
Make (for development tools)
Git (for version control)

Setup

# Clone the repository
git clone https://github.com/newbpydev/bubblyui.git
cd bubblyui

# Install development tools
make install-tools

# Run tests to verify setup
make test lint build

Project Structure

bubblyui/
├── cmd/examples/           # Example applications (organized by feature)
│   ├── 01-reactivity-system/    # Reactivity examples
│   ├── 02-component-model/      # Component examples
│   ├── 03-lifecycle-hooks/      # Lifecycle examples
│   ├── 04-composables/          # Composables examples
│   ├── 05-directives/           # Directives examples
│   ├── 06-built-in-components/  # Component library demos
│   ├── 07-router/               # Router examples
│   ├── 08-automatic-bridge/     # Zero-boilerplate examples
│   ├── 09-devtools/             # Development tools demos
│   ├── 10-testing/              # Testing examples
│   ├── 11-profiler/             # Performance profiling demos
│   ├── 14-advanced-layouts/     # Layout system examples
│   └── 16-ai-chat-demo/         # AI chat integration demo
├── pkg/
│   ├── bubbly/           # Core framework package
│   │   ├── composables/  # Composable functions
│   │   ├── devtools/     # Development tools
│   │   ├── directives/   # Template directives
│   │   ├── monitoring/   # Metrics & profiling
│   │   ├── profiler/     # Performance profiling
│   │   ├── router/       # Navigation system
│   │   └── testing/      # Test utilities
│   └── components/       # Built-in UI components
├── specs/                # Feature specifications (00-16)
└── docs/                 # Documentation and guides

Development Workflow

Follow the systematic Ultra-Workflow for all feature development:

🎯 Understand - Read ALL specification files in feature directory
🔍 Gather - Research Go/Bubbletea patterns using available tools
📝 Plan - Create actionable task breakdown with sequential thinking
🧪 TDD - Red-Green-Refactor with table-driven tests
🎯 Focus - Verify alignment with specifications and integration
🧹 Cleanup - Run all quality gates and validation
📚 Document - Update specs, godoc, README, and CHANGELOG

Quality Gates

All contributions must pass these automated checks:

make test-race    # Tests with race detector
make lint         # golangci-lint (zero warnings)
make fmt          # gofmt + goimports
make build        # Compilation succeeds
go test -cover    # >80% coverage maintained

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

Quick Contribution

Fork the repository
Create a feature branch: git checkout -b feature/amazing-feature
Make your changes following TDD practices
Run quality gates: make test-race lint fmt build
Submit a pull request with a comprehensive description

Development Standards

Type Safety: Use generics, avoid any without constraints
Testing: Table-driven tests, >80% coverage, race detector clean
Documentation: Godoc comments on all exports
Style: Follow Google Go Style Guide conventions
Architecture: Maintain Bubbletea Model/Update/View patterns

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

Bubbletea: The excellent TUI framework this is built on
Vue.js: Inspiration for the component and reactivity patterns
Go Community: For the amazing ecosystem and conventions
Contributors: Everyone who helps make BubblyUI better

📞 Support

Issues: GitHub Issues
Discussions: GitHub Discussions
Documentation: Check the specs/ directory for detailed specifications
Examples: Browse the cmd/examples/ directory for usage patterns

Made with ❤️ for the Go community

Documentation ¶

Overview ¶

Package bubblyui provides a Vue-inspired TUI framework for Go.

BubblyUI brings reactive state management and component-based architecture to terminal applications built on Bubbletea. It offers type-safe reactive primitives, a powerful component system, lifecycle hooks, and composables.

Quick Start ¶

import "github.com/newbpydev/bubblyui"

func main() {
    counter, _ := bubblyui.NewComponent("Counter").
        Setup(func(ctx *bubblyui.Context) {
            count := ctx.Ref(0)
            ctx.Expose("count", count)
        }).
        Template(func(ctx bubblyui.RenderContext) string {
            return fmt.Sprintf("Count: %v", ctx.Get("count"))
        }).
        Build()

    bubblyui.Run(counter)
}

Core Types ¶

The following types are re-exported from pkg/bubbly for convenience:

Component: A BubblyUI component instance
ComponentBuilder: Fluent API for constructing components
Ref[T]: A reactive reference holding a mutable value
Computed[T]: A derived reactive value that auto-updates
Context: The component setup context
RenderContext: The template rendering context

Subpackages ¶

For additional functionality, import the subpackages directly:

import "github.com/newbpydev/bubblyui/pkg/bubbly/router"      // Navigation
import "github.com/newbpydev/bubblyui/pkg/bubbly/composables" // Composables
import "github.com/newbpydev/bubblyui/pkg/bubbly/directives"  // Directives
import "github.com/newbpydev/bubblyui/pkg/components"          // UI components

Index ¶

Variables
func Watch[T any](ref *Ref[T], callback func(newVal, oldVal T)) func()
type Component
type ComponentBuilder
type Computed
- func NewComputed[T any](fn func() T) *Computed[T]
type Context
type Ref
- func NewRef[T any](value T) *Ref[T]
type RenderContext
type RunOption

Constants ¶

This section is empty.

Variables ¶

View Source

var NewComponent = bubbly.NewComponent

NewComponent creates a new ComponentBuilder with the given name. Use the builder's fluent API to configure the component, then call Build().

Example:

component, err := bubblyui.NewComponent("Counter").
    Setup(func(ctx *bubblyui.Context) {
        // Initialize reactive state
    }).
    Template(func(ctx bubblyui.RenderContext) string {
        return "Hello, World!"
    }).
    Build()

View Source

var Run = bubbly.Run

Run starts the Bubbletea application with the given component. This is the main entry point for BubblyUI applications. Options can be passed to configure the application behavior.

Example:

err := bubblyui.Run(app,
    bubblyui.WithAltScreen(),
    bubblyui.WithMouseAllMotion(),
)

View Source

var WatchEffect = bubbly.WatchEffect

WatchEffect creates a side-effect watcher that tracks dependencies automatically. The effect runs immediately and re-runs whenever any accessed reactive value changes. Returns a cleanup function that stops the effect when called.

Example:

cleanup := bubblyui.WatchEffect(func() {
    fmt.Printf("Current count: %d\n", count.Get())
})
defer cleanup()

View Source

var WithAltScreen = bubbly.WithAltScreen

WithAltScreen enables the alternate screen buffer for full-screen applications. This is the most common option for TUI applications.

View Source

var WithAsyncRefresh = bubbly.WithAsyncRefresh

WithAsyncRefresh enables async refresh with the specified interval. This is useful for components that update from goroutines.

View Source

var WithContext = bubbly.WithContext

WithContext sets a context for the program. The program will exit when the context is canceled.

View Source

var WithEnvironment = bubbly.WithEnvironment

WithEnvironment sets custom environment variables for the program. This is useful for controlling terminal behavior.

View Source

var WithFPS = bubbly.WithFPS

WithFPS sets the target frames per second for rendering. Default is 60 FPS. Higher values provide smoother animations but use more CPU.

View Source

var WithInput = bubbly.WithInput

WithInput sets a custom input source for the program. By default, the program reads from os.Stdin.

View Source

var WithInputTTY = bubbly.WithInputTTY

WithInputTTY forces the program to use a TTY for input. This is useful when running in non-interactive environments.

View Source

var WithMouseAllMotion = bubbly.WithMouseAllMotion

WithMouseAllMotion enables mouse support with all motion events. This captures all mouse movements, clicks, and scroll events.

View Source

var WithMouseCellMotion = bubbly.WithMouseCellMotion

WithMouseCellMotion enables mouse support with cell motion events. This captures mouse events only when the mouse moves between cells.

View Source

var WithOutput = bubbly.WithOutput

WithOutput sets a custom output destination for the program. By default, the program writes to os.Stdout.

View Source

var WithReportFocus = bubbly.WithReportFocus

WithReportFocus enables focus reporting. The program will receive messages when the terminal gains/loses focus.

View Source

var WithoutAsyncAutoDetect = bubbly.WithoutAsyncAutoDetect

WithoutAsyncAutoDetect disables automatic async detection. By default, Run() auto-detects if async refresh is needed.

View Source

var WithoutBracketedPaste = bubbly.WithoutBracketedPaste

WithoutBracketedPaste disables bracketed paste mode. This is useful for terminals that don't support bracketed paste.

View Source

var WithoutCatchPanics = bubbly.WithoutCatchPanics

WithoutCatchPanics disables panic catching. Use this during development to see full panic stack traces.

View Source

var WithoutSignalHandler = bubbly.WithoutSignalHandler

WithoutSignalHandler disables the default signal handler. Use this if you want to handle signals (like SIGINT) manually.

Functions ¶

func Watch ¶

func Watch[T any](ref *Ref[T], callback func(newVal, oldVal T)) func()

Watch creates a watcher that executes the callback when the watched value changes. Returns a cleanup function that stops the watcher when called.

Example:

cleanup := bubblyui.Watch(count, func(newVal, oldVal int) {
    fmt.Printf("Count changed from %d to %d\n", oldVal, newVal)
})
defer cleanup()

Types ¶

type Component ¶

type Component = bubbly.Component

Component represents a BubblyUI component with reactive state, lifecycle hooks, and template rendering. It extends Bubbletea's tea.Model interface with additional methods for component identification, props management, and event handling.

type ComponentBuilder ¶

type ComponentBuilder = bubbly.ComponentBuilder

ComponentBuilder provides a fluent API for constructing components. Use NewComponent() to create a builder, then chain configuration methods and call Build() to create the component.

type Computed ¶

type Computed[T any] = bubbly.Computed[T]

Computed is a derived reactive value that automatically recomputes when its dependencies change. Computed values are cached and only recalculate when necessary.

Example:

count := bubblyui.NewRef(10)
doubled := bubblyui.NewComputed(func() int {
    return count.Get() * 2
})

func NewComputed ¶

func NewComputed[T any](fn func() T) *Computed[T]

NewComputed creates a new computed value with the given computation function. The computed value automatically tracks dependencies accessed within the function and recomputes when they change.

Example:

total := bubblyui.NewComputed(func() int {
    return price.Get() * quantity.Get()
})

type Context ¶

type Context = bubbly.Context

Context provides access to component state and utilities during setup. It allows creating reactive state (Ref, Computed), registering lifecycle hooks, and exposing values for template rendering.

type Ref ¶

type Ref[T any] = bubbly.Ref[T]

Ref is a reactive reference that holds a mutable value of type T. Changes to the value automatically trigger dependent computations and watchers.

Example:

count := bubblyui.NewRef(0)
count.Set(count.Get() + 1)

func NewRef ¶

func NewRef[T any](value T) *Ref[T]

NewRef creates a new reactive reference with the given initial value. The reference is type-safe thanks to Go generics.

Example:

name := bubblyui.NewRef("Alice")
count := bubblyui.NewRef(0)
items := bubblyui.NewRef([]string{"a", "b"})

type RenderContext ¶

type RenderContext = bubbly.RenderContext

RenderContext provides access to component state during template rendering. It allows retrieving exposed values, accessing props, and getting the component instance.

type RunOption ¶

type RunOption = bubbly.RunOption

RunOption configures the behavior of the Run function. Use With* functions to create options.

Source Files ¶

View all Source files

bubblyui.go

Directories ¶

Path	Synopsis
cmd
bubbly-mcp-config command
examples/00-quickstart command Package main demonstrates the BubblyUI quickstart example.	Package main demonstrates the BubblyUI quickstart example.
examples/00-quickstart/components Package components provides UI components for the quickstart example.	Package components provides UI components for the quickstart example.
examples/00-quickstart/composables Package composables provides reusable reactive logic for the quickstart example.	Package composables provides reusable reactive logic for the quickstart example.
examples/01-reactivity-system/async-data command
examples/01-reactivity-system/form-validation command
examples/01-reactivity-system/reactive-counter command
examples/01-reactivity-system/reactive-todo command
examples/01-reactivity-system/watch-computed command Package main demonstrates watching computed values in BubblyUI.	Package main demonstrates watching computed values in BubblyUI.
examples/01-reactivity-system/watch-effect command Package main demonstrates WatchEffect with automatic dependency tracking.	Package main demonstrates WatchEffect with automatic dependency tracking.
examples/02-component-model/button command
examples/02-component-model/counter command
examples/02-component-model/form command
examples/02-component-model/nested command
examples/02-component-model/nested2 command
examples/02-component-model/nested3 command
examples/02-component-model/todo command
examples/03-lifecycle-hooks/lifecycle-basic command
examples/03-lifecycle-hooks/lifecycle-data-fetch command
examples/03-lifecycle-hooks/lifecycle-subscription command
examples/03-lifecycle-hooks/lifecycle-timer command
examples/04-composables/async-data command
examples/04-composables/counter command
examples/04-composables/form command
examples/04-composables/form-wizard command
examples/04-composables/monitoring-dashboard command
examples/04-composables/performance-tuning command
examples/04-composables/profiling-demo command
examples/04-composables/provide-inject command
examples/04-composables/todo-composables command
examples/04-composables/user-dashboard command
examples/05-directives/basic command
examples/05-directives/complex command
examples/05-directives/form command
examples/05-directives/list command
examples/06-built-in-components/components-showcase command
examples/06-built-in-components/dashboard command
examples/06-built-in-components/form-builder command
examples/06-built-in-components/table-navigation command
examples/07-router/basic command
examples/07-router/guards command
examples/07-router/nested command
examples/08-automatic-bridge/01-counters/01-counter command
examples/08-automatic-bridge/01-counters/01-counter-bubbletea command
examples/08-automatic-bridge/02-todos/02-todo command
examples/08-automatic-bridge/02-todos/02-todo-bubbletea command
examples/08-automatic-bridge/02-todos/02-todo-components command
examples/08-automatic-bridge/02-todos/02-todo-components/components
examples/09-devtools/01-basic-enablement command
examples/09-devtools/01-basic-enablement/components
examples/09-devtools/01-basic-enablement/composables
examples/09-devtools/02-component-inspection command
examples/09-devtools/02-component-inspection/components
examples/10-testing/01-counter command
examples/10-testing/01-counter/components
examples/10-testing/01-counter/composables
examples/10-testing/02-todo command
examples/10-testing/02-todo/components
examples/10-testing/02-todo/composables
examples/10-testing/03-form command
examples/10-testing/03-form/components
examples/10-testing/03-form/composables
examples/10-testing/04-async command
examples/10-testing/04-async/components
examples/10-testing/04-async/composables
examples/11-advanced-patterns/01-shared-state command
examples/11-advanced-patterns/01-shared-state/components
examples/11-advanced-patterns/01-shared-state/composables
examples/11-profiler/basic command Package main provides the entry point for the basic profiler example.	Package main provides the entry point for the basic profiler example.
examples/11-profiler/basic/components Package components provides UI components for the profiler example.	Package components provides UI components for the profiler example.
examples/11-profiler/basic/composables Package composables provides reusable reactive logic for the profiler example.	Package composables provides reusable reactive logic for the profiler example.
examples/11-profiler/cpu command Package main provides the entry point for the CPU profiler example.	Package main provides the entry point for the CPU profiler example.
examples/11-profiler/cpu/components Package components provides focused UI components for the CPU profiler example.	Package components provides focused UI components for the CPU profiler example.
examples/11-profiler/cpu/composables Package composables provides reusable reactive logic for the CPU profiler example.	Package composables provides reusable reactive logic for the CPU profiler example.
examples/12-mcp-server/01-basic-stdio command
examples/12-mcp-server/02-http-server command
examples/14-advanced-layouts command Package main provides the Advanced Layout System example application.	Package main provides the Advanced Layout System example application.
examples/14-advanced-layouts/components Package components provides demo components for the layout showcase.	Package components provides demo components for the layout showcase.
examples/14-advanced-layouts/composables Package composables provides shared state composables for the layout demo.	Package composables provides shared state composables for the layout demo.
examples/15-responsive-layouts command Package main provides the Responsive Layouts example application.	Package main provides the Responsive Layouts example application.
examples/15-responsive-layouts/components Package components provides responsive demo components for the layout showcase.	Package components provides responsive demo components for the layout showcase.
examples/15-responsive-layouts/composables Package composables provides shared state and logic for the responsive layouts example.	Package composables provides shared state and logic for the responsive layouts example.
examples/16-ai-chat-demo command Package main provides the AI Chat Demo application.	Package main provides the AI Chat Demo application.
examples/16-ai-chat-demo/components Package components provides UI components for the AI chat demo.	Package components provides UI components for the AI chat demo.
examples/16-ai-chat-demo/composables Package composables provides shared state and logic for the AI chat demo.	Package composables provides shared state and logic for the AI chat demo.
examples/17-enhanced-composables command Package main provides the Enhanced Composables Demo application.	Package main provides the Enhanced Composables Demo application.
examples/17-enhanced-composables/components Package components provides UI components for the enhanced composables demo.	Package components provides UI components for the enhanced composables demo.
examples/17-enhanced-composables/composables Package composables provides shared composables for the enhanced composables demo.	Package composables provides shared composables for the enhanced composables demo.
examples/17-enhanced-composables/demos Package demos provides demo views for each composable.	Package demos provides demo views for each composable.
examples/error-tracking/console-reporter command
examples/error-tracking/custom-reporter command
examples/error-tracking/sentry-reporter command
commands Package commands provides command generation, batching, and debugging for BubblyUI.	Package commands provides command generation, batching, and debugging for BubblyUI.
components Package components provides pre-built UI components for BubblyUI.	Package components provides pre-built UI components for BubblyUI.
composables Package composables provides Vue-inspired composable functions for BubblyUI.	Package composables provides Vue-inspired composable functions for BubblyUI.
devtools Package devtools provides development tools for BubblyUI applications.	Package devtools provides development tools for BubblyUI applications.
mcp Package mcp provides Model Context Protocol (MCP) server integration for BubblyUI DevTools.	Package mcp provides Model Context Protocol (MCP) server integration for BubblyUI DevTools.
directives Package directives provides Vue-inspired template directives for BubblyUI.	Package directives provides Vue-inspired template directives for BubblyUI.
monitoring Package monitoring provides pluggable metrics collection for BubblyUI composables.	Package monitoring provides pluggable metrics collection for BubblyUI composables.
observability Package observability provides error tracking, breadcrumbs, and monitoring for BubblyUI.	Package observability provides error tracking, breadcrumbs, and monitoring for BubblyUI.
pkg
bubbly Package bubbly provides a Vue-inspired reactive state management system for Go TUI applications.	Package bubbly provides a Vue-inspired reactive state management system for Go TUI applications.
bubbly/commands Package commands provides debugging and inspection capabilities for the Automatic Reactive Bridge feature in BubblyUI.	Package commands provides debugging and inspection capabilities for the Automatic Reactive Bridge feature in BubblyUI.
bubbly/composables Package composables provides Vue 3-inspired reusable composition functions for BubblyUI.	Package composables provides Vue 3-inspired reusable composition functions for BubblyUI.
bubbly/composables/reflectcache Package reflectcache provides optional reflection caching for optimizing UseForm's SetField performance.	Package reflectcache provides optional reflection caching for optimizing UseForm's SetField performance.
bubbly/composables/timerpool Package timerpool provides an optional timer pool for optimizing UseDebounce and UseThrottle composables.	Package timerpool provides an optional timer pool for optimizing UseDebounce and UseThrottle composables.
bubbly/devtools Package devtools provides a comprehensive developer tools system for debugging and inspecting BubblyUI applications in real-time.	Package devtools provides a comprehensive developer tools system for debugging and inspecting BubblyUI applications in real-time.
bubbly/devtools/mcp
bubbly/devtools/migrations
bubbly/directives Package directives provides Vue-inspired directive types for declarative template manipulation.	Package directives provides Vue-inspired directive types for declarative template manipulation.
bubbly/monitoring Package monitoring provides pluggable metrics collection for BubblyUI composables.	Package monitoring provides pluggable metrics collection for BubblyUI composables.
bubbly/observability Package observability provides error tracking, breadcrumbs, and monitoring for BubblyUI applications.	Package observability provides error tracking, breadcrumbs, and monitoring for BubblyUI applications.
bubbly/profiler Package profiler provides comprehensive performance profiling for BubblyUI applications.	Package profiler provides comprehensive performance profiling for BubblyUI applications.
bubbly/router Package router provides path matching and routing functionality for BubblyUI applications.	Package router provides path matching and routing functionality for BubblyUI applications.
bubbly/testing Package btesting provides testing utilities for BubblyUI composables.	Package btesting provides testing utilities for BubblyUI composables.
bubbly/testutil Package testutil provides testing utilities for BubblyUI components.	Package testutil provides testing utilities for BubblyUI components.
components Package components provides layout components for the BubblyUI framework.	Package components provides layout components for the BubblyUI framework.
profiler Package profiler provides comprehensive performance profiling for BubblyUI applications.	Package profiler provides comprehensive performance profiling for BubblyUI applications.
router Package router provides Vue Router-inspired navigation for BubblyUI.	Package router provides Vue Router-inspired navigation for BubblyUI.
testing
btesting Package btesting provides testing helpers for BubblyUI components and composables.	Package btesting provides testing helpers for BubblyUI components and composables.
testutil Package testutil provides comprehensive test utilities for BubblyUI applications.	Package testutil provides comprehensive test utilities for BubblyUI applications.

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL

README ¶

BubblyUI

✨ Features

🔄 Type-Safe Reactivity

🧩 Component System

🎨 Template System

🧩 Built-in Components (30+)

🧭 Router (SPA-Style Navigation)

📐 Advanced Layout System (Flexbox-Inspired)

🛠️ Development & Testing Tools

🎯 Automation Patterns

🚀 Quick Start

Installation

Basic Example

📖 Documentation

Core Concepts

Features & Guides

API Reference

🛠️ Development

Prerequisites

Setup

Project Structure

Development Workflow

Quality Gates

🤝 Contributing

Quick Contribution

Development Standards

📄 License

🙏 Acknowledgments

📞 Support

Documentation ¶

Overview ¶

Quick Start ¶

Core Types ¶

Subpackages ¶

Index ¶

Constants ¶

Variables ¶

Functions ¶

func Watch ¶

Types ¶

type Component ¶

type ComponentBuilder ¶

type Computed ¶

func NewComputed ¶

type Context ¶

type Ref ¶

func NewRef ¶

type RenderContext ¶

type RunOption ¶

Source Files ¶

Directories ¶