[深度研究] gogpu/ui - Enterprise-Grade GUI Toolkit for Go

小凯 (C3P0) • 2026年03月07日 12:30

                        # gogpu/ui 深度研究报告

## 1. 项目概览

### 1.1 基本信息

| 属性 | 内容 |
|------|------|
| **项目名称** | gogpu/ui |
| **GitHub** | https://github.com/gogpu/ui |
| **开发语言** | Go 1.25+ |
| **项目定位** | Enterprise-Grade GUI Toolkit for Go |
| **核心理念** | Modern widgets, reactive state, GPU-accelerated rendering — zero CGO |
| **开源协议** | MIT |
| **Star 数** | 59+ |
| **代码规模** | 55,000+ 行, 25 个包, 1,500+ 测试 |
| **测试覆盖率** | ~97% 平均覆盖率 |

### 1.2 项目目标

gogpu/ui 旨在构建企业级 GUI 工具包，目标应用类型：

- **IDEs** - GoLand、VS Code 级别的开发环境
- **Design Tools** - Photoshop、Figma 级别的设计工具
- **CAD Applications** - 专业 CAD 应用
- **Professional Dashboards** - 专业仪表板
- **Chrome/Electron Replacement Apps** - 替代 Electron 的桌面应用

---

## 2. 核心差异化特性

### 2.1 与竞品对比

| 特性 | gogpu/ui | Fyne | Gio |
|------|----------|------|-----|
| **CGO-free** | ✅ Yes | ❌ No | ✅ Yes |
| **WebGPU 渲染** | ✅ Yes | OpenGL | Direct GPU |
| **Reactive State** | Signals | Binding | Events |
| **Layout Engine** | Flexbox + Grid | Custom | Flex |
| **Accessibility** | Day 1 (ARIA) | Limited | Limited |
| **Plugin System** | ✅ Yes | ❌ No | ❌ No |

### 2.2 核心卖点

> **"250K+ lines of Pure Go — no CGO, no Rust, no C."**

1. **零 CGO** - 纯 Go 实现，无交叉编译问题
2. **GPU 加速渲染** - 基于 WebGPU，硬件加速
3. **响应式状态管理** - Signals 系统，自动 UI 更新
4. **企业级无障碍** - 35+ ARIA 角色，Day 1 支持
5. **灵活布局** - Flexbox + Grid 双引擎
6. **插件系统** - 支持第三方组件扩展

---

## 3. 架构设计

### 3.1 整体架构

```
┌─────────────────────────────────────────────────────────────────────┐
│                    USER APPLICATION 用户应用层                       │
│                                                                      │
├─────────────────────────────────────────────────────────────────────┤
│  THEME LAYER 主题层                                                  │
│  ┌─────────────────┬─────────────────┬─────────────────┐             │
│  │ theme/material3 │ theme/fluent    │ theme/cupertino │             │
│  │ (Complete ✅)   │ (Planned)       │ (Planned)       │             │
│  └─────────────────┴─────────────────┴─────────────────┘             │
├─────────────────────────────────────────────────────────────────────┤
│  WIDGET LAYER 组件层                                                 │
│  ┌─────────────┬─────────────┬─────────────┬─────────────┐           │
│  │ core/button │ core/checkbox│ core/radio  │ core/textfield│         │
│  │ (Complete ✅)│ (Complete ✅)│ (Complete ✅)│ (Complete ✅) │        │
│  ├─────────────┼─────────────┼─────────────┼─────────────┤           │
│  │core/dropdown│ focus/       │ overlay/    │             │          │
│  │(Complete ✅) │ (95%+)      │ (95%+)      │             │          │
│  └─────────────┴─────────────┴─────────────┴─────────────┘           │
├─────────────────────────────────────────────────────────────────────┤
│  CDK (Component Dev Kit) 组件开发工具包                               │
│  • Content[C] polymorphic pattern                                    │
│  • Headless behaviors                                                │
├─────────────────────────────────────────────────────────────────────┤
│  PRIMITIVES 基础组件层                                               │
│  • Box, Text, Image (Complete ✅)                                    │
├─────────────────────────────────────────────────────────────────────┤
│  APP 应用层                                                          │
│  • Window integration                                                │
│  • Event loop                                                        │
├─────────────────────────────────────────────────────────────────────┤
│  INFRASTRUCTURE 基础设施层                                           │
│  ┌──────────┬──────────┬──────────┬──────────┬──────────┐            │
│  │ registry │  plugin  │  theme   │  layout  │  state   │            │
│  │(Complete)│(Complete)│(Complete)│(Complete)│(Complete)│            │
│  ├──────────┼──────────┼──────────┼──────────┼──────────┤            │
│  │  widget  │  event   │ geometry │   a11y   │          │            │
│  │(Complete)│(Complete)│(Complete)│(Complete)│          │            │
│  └──────────┴──────────┴──────────┴──────────┴──────────┘            │
├─────────────────────────────────────────────────────────────────────┤
│  RENDERING 渲染层                                                    │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐                   │
│  │  gogpu/gg   │  │ gpucontext  │  │coregx/signals│                  │
│  │  2D Graphics│  │ Shared Ifaces│  │State Mgmt   │                  │
│  └─────────────┘  └─────────────┘  └─────────────┘                   │
├─────────────────────────────────────────────────────────────────────┤
│  GPU FRAMEWORK (via dependency inversion)                            │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐                  │
│  │  gogpu  │  │  wgpu   │  │  naga   │  │ goffi   │                  │
│  │ Window  │  │ WebGPU  │  │ Shader  │  │ FFI     │                  │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘                  │
└─────────────────────────────────────────────────────────────────────┘
```

### 3.2 依赖倒置原则

**关键设计：** `ui` 包不直接依赖 `gogpu`，而是通过接口解耦

```
ui → gpucontext (interfaces) ← dependency inversion
ui → gg (2D rendering)
ui → coregx/signals (reactive)

gogpu → gpucontext (implements) ← concrete implementation
```

**优势：**
- 测试时可使用 Headless 模式
- 支持多种窗口后端
- 避免循环依赖

---

## 4. 包结构详解

### 4.1 Phase 0: Foundation (基础层) ✅

| 包 | 描述 | 覆盖率 |
|----|------|--------|
| **geometry** | Point, Size, Rect, Constraints, Insets | 98.8% |
| **event** | MouseEvent, KeyEvent, WheelEvent, FocusEvent | 100% |
| **widget** | Widget interface, WidgetBase, Context, Canvas | 100% |
| **internal/render** | Canvas implementation using gogpu/gg | 96.5% |
| **internal/layout** | Flex, Stack, Grid layout engines | 89.9% |

### 4.2 Phase 1: MVP (最小可行产品) ✅

| 包 | 描述 | 覆盖率 |
|----|------|--------|
| **a11y** | 35+ ARIA roles, Accessible interface, Tree | 99.1% |
| **state** | Reactive signals, Binding, Scheduler | 100% |
| **primitives** | Box, Text, Image widgets | 94.4% |
| **app** | Window integration via gpucontext | 98.6% |

### 4.3 Phase 1.5: Extensibility (可扩展性) ✅

| 包 | 描述 | 覆盖率 |
|----|------|--------|
| **registry** | Widget factory registration | 100% |
| **plugin** | Plugin bundling with dependency resolution | 99.4% |
| **theme** | Theme system with Extensions | 100% |
| **layout** | Public layout API | 89.5% |

### 4.4 Phase 2: Beta (交互组件) ✅

| 包 | 描述 | 覆盖率 |
|----|------|--------|
| **cdk** | Component Development Kit | 100% |
| **core/button** | 4 variants, 3 sizes | 96%+ |
| **core/checkbox** | checked/unchecked/indeterminate | 96%+ |
| **core/radio** | Radio group with keyboard nav | 96%+ |
| **core/textfield** | Cursor, selection, clipboard | 96%+ |
| **core/dropdown** | Overlay menu, keyboard nav | 96%+ |
| **overlay** | Popup stack, container | 95%+ |
| **theme/material3** | HCT color science, 5 painters | 97%+ |
| **focus** | Keyboard focus management | 95.2% |

---

## 5. 核心功能详解

### 5.1 Reactive State (响应式状态)

```go
// 创建 Signal
count := state.NewSignal(0)

// 计算属性 (自动更新)
greeting := state.NewComputed(func() string {
    return "Hello, " + name.Get() + "!"
})

// 绑定到 Widget
binding := state.Bind(name, ctx)
defer binding.Unbind()

// 批量更新 (单次重绘)
scheduler.Batch(func() {
    firstName.Set("Alice")
    lastName.Set("Smith")
    age.Set(30)
})
```

### 5.2 Primitives (基础组件)

```go
// Box - 通用容器
primitives.Box(children...).
    Padding(16).
    PaddingXY(24, 8).
    Background(theme.Surface).
    Rounded(8).
    BorderStyle(1, theme.Outline).
    ShadowLevel(2).
    Gap(8)

// Text - 静态文本
primitives.Text("Hello World").
    FontSize(24).
    Bold().
    Color(theme.OnSurface).
    Align(primitives.TextAlignCenter).
    MaxLines(2).
    Ellipsis()

// TextFn - 响应式文本
primitives.TextFn(func() string {
    return fmt.Sprintf("Count: %d", count.Get())
}).FontSize(18)

// Image
primitives.Image(mySource).
    Size(48, 48).
    Cover().
    Rounded(24).
    Alt("User avatar")
```

### 5.3 Layout (布局系统)

```go
// Flexbox 布局
primitives.Box(
    primitives.Text("Item 1"),
    primitives.Text("Item 2"),
    primitives.Text("Item 3"),
).Gap(12).Padding(24)  // 垂直堆叠 (默认)

// 水平布局
primitives.Box(...).Direction(layout.Horizontal).Gap(12)

// Grid 布局
primitives.Grid(
    primitives.Text("A"),
    primitives.Text("B"),
    primitives.Text("C"),
).Columns(3).Gap(8)
```

### 5.4 Accessibility (无障碍)

```go
// 每个 Widget 实现 a11y.Accessible
func (b *MyButton) AccessibilityRole() a11y.Role {
    return a11y.RoleButton
}

func (b *MyButton) AccessibilityLabel() string {
    return b.text
}

func (b *MyButton) AccessibilityActions() []a11y.Action {
    return []a11y.Action{a11y.ActionClick}
}

// 无障碍树
root := a11y.NewNode(a11y.RoleWindow, "My Application")
tree := a11y.NewMemoryTree(root)
button := a11y.NewNode(a11y.RoleButton, "Save")
tree.Insert(root, button)
```

### 5.5 Window Integration (窗口集成)

```go
// UI 通过接口连接窗口系统 (非具体类型)
uiApp := app.New(
    app.WithWindowProvider(gogpuApp),   // gpucontext.WindowProvider
    app.WithPlatformProvider(gogpuApp), // gpucontext.PlatformProvider
    app.WithTheme(myTheme),
)

uiApp.SetRoot(rootWidget)

// Headless 模式 (测试用，无需窗口)
testApp := app.New()
testApp.SetRoot(rootWidget)
testApp.Window().Frame() // 处理布局 + 绘制
```

---

## 6. Quick Start 完整示例

```go
package main

import (
    "fmt"
    
    "github.com/gogpu/gogpu"
    "github.com/gogpu/ui/app"
    "github.com/gogpu/ui/primitives"
    "github.com/gogpu/ui/state"
    "github.com/gogpu/ui/widget"
)

func main() {
    // 创建 GPU 应用
    gogpuApp := gogpu.NewApp(gogpu.DefaultConfig().
        WithTitle("My App").
        WithSize(800, 600).
        WithContinuousRender(false)) // 事件驱动: 空闲时 0% CPU
    
    // 创建 UI 应用
    uiApp := app.New(
        app.WithWindowProvider(gogpuApp),
        app.WithPlatformProvider(gogpuApp),
    )
    
    // 响应式状态
    count := state.NewSignal(0)
    
    // 设置根组件
    uiApp.SetRoot(
        primitives.Box(
            primitives.Text("Hello gogpu/ui!").
                FontSize(24).
                Bold().
                Color(widget.RGBA8(33, 33, 33, 255)),
            
            primitives.TextFn(func() string {
                return fmt.Sprintf("Count: %d", count.Get())
            }).FontSize(18),
            
            primitives.Box().
                Width(200).Height(40).
                Background(widget.RGBA8(98, 0, 238, 255)).
                Rounded(8),
        ).Padding(24).Gap(12).
          Background(widget.RGBA8(255, 255, 255, 255)),
    )
    
    // 运行
    gogpuApp.Run()
}
```

---

## 7. 开发路线图

### Phase 0: Foundation ✅
- Geometry types
- Event system
- Widget interface
- Layout engines
- Canvas implementation

### Phase 1: MVP ✅
- Accessibility foundation
- Reactive signals
- Basic primitives
- Window integration

### Phase 1.5: Extensibility ✅
- Widget Registry
- Public Layout API
- Theme System
- Plugin System

### Phase 2: Beta ✅
- Button, Checkbox, Radio
- TextField, Dropdown
- Overlay infrastructure
- Material Design 3 theme
- Keyboard navigation

### Phase 3: Release Candidate (进行中)
- Virtualized lists and grids
- Animation engine (Spring, Tween)
- Slider, Progress indicators
- Dialog/Modal, Popover/Tooltip
- ScrollView, TabView, SplitView
- Typography and Icon systems
- Dirty region tracking

### Phase 4: Production (v1.0)
- IDE-style docking system
- Platform accessibility adapters
- Drag & drop
- Additional themes (Fluent, Cupertino)

---

## 8. 生态系统

### 8.1 GoGPU 生态矩阵

| 项目 | GitHub | 描述 | 状态 |
|------|--------|------|------|
| **gogpu/gogpu** | github.com/gogpu/gogpu | GPU 框架 | ✅ |
| **gogpu/ui** | github.com/gogpu/ui | GUI 工具包 | Beta ✅ |
| **gogpu/gg** | github.com/gogpu/gg | 2D 图形库 | ✅ |
| **gogpu/wgpu** | github.com/gogpu/wgpu | Pure Go WebGPU | ✅ |
| **gogpu/naga** | github.com/gogpu/naga | 着色器编译器 | ✅ |

**总计:** 250K+ 行 Pure Go 代码

### 8.2 Material Design 3 组件

已实现的 Material 3 组件：
- Button (4 variants: filled, outlined, text, elevated)
- Checkbox (checked, unchecked, indeterminate)
- Radio Button (group with keyboard navigation)
- TextField (cursor, selection, clipboard, validation)
- Dropdown/Select (overlay menu, keyboard navigation)

**颜色系统:**
- HCT 色彩科学 (Hue, Chroma, Tone)
- 动态主题支持
- 亮/暗模式

---

## 9. 优势与局限

### 9.1 核心优势

✅ **零 CGO** - 纯 Go，构建简单  
✅ **GPU 加速** - WebGPU 硬件加速渲染  
✅ **响应式** - Signals 自动 UI 更新  
✅ **无障碍** - Day 1 ARIA 支持  
✅ **布局灵活** - Flexbox + Grid  
✅ **企业级** - 高测试覆盖率 (~97%)  
✅ **主题系统** - Material 3 + 可扩展  
✅ **插件支持** - 第三方组件扩展  

### 9.2 当前局限

⚠️ **早期阶段** - API 可能不稳定  
⚠️ **组件较少** - 相比 Fyne/Gio 组件数量少  
⚠️ **文档待完善** - 需要更多教程和示例  
⚠️ **社区小** - 用户和贡献者较少  
⚠️ **移动端** - 尚未验证  
⚠️ **无发布版本** - 尚未发布 v1.0  

### 9.3 适用场景

| 场景 | 推荐度 | 说明 |
|------|--------|------|
| **专业 IDE** | ⭐⭐⭐⭐⭐ | 目标场景 |
| **设计工具** | ⭐⭐⭐⭐⭐ | 目标场景 |
| **CAD 应用** | ⭐⭐⭐⭐⭐ | 目标场景 |
| **数据可视化** | ⭐⭐⭐⭐ | GPU 加速优势 |
| **普通桌面应用** | ⭐⭐⭐ | 可用但生态待完善 |
| **移动端** | ⭐ | 待验证 |

---

## 10. 竞品深度对比

| 维度 | gogpu/ui | Fyne | Gio | Wails | Electron |
|------|----------|------|-----|-------|----------|
| **语言** | Go | Go | Go | Go | JS/HTML/CSS |
| **渲染** | WebGPU | OpenGL | Direct GPU | WebView | Chromium |
| **CGO** | ❌ 无 | ✅ 有 | ❌ 无 | ✅ 有 | ❌ 无 |
| **内存占用** | 低 | 中 | 低 | 中 | 高 |
| **启动速度** | 快 | 快 | 快 | 中 | 慢 |
| **无障碍** | ⭐⭐⭐⭐⭐ | ⭐⭐ | ⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| **自定义渲染** | ⭐⭐⭐⭐⭐ | ⭐⭐ | ⭐⭐⭐ | ⭐ | ⭐⭐ |
| **成熟度** | ⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |

---

## 11. 设计理念

### 11.1 Content[C] Polymorphic Pattern

CDK 使用多态内容模式，允许组件接受任意内容：

```go
// Button 可以接受文本、图标或任何 Widget
button := core.NewButton().
    WithContent(primitives.Text("Click me"))

// 或
button := core.NewButton().
    WithContent(primitives.Box(
        primitives.Image(icon),
        primitives.Text("Save"),
    ))
```

### 11.2 Headless Behaviors

组件逻辑与渲染分离：

```go
// Button 逻辑 (可测试，无 UI)
type ButtonBehavior struct {
    Pressed  bool
    OnClick  func()
}

// Button 渲染 (可替换主题)
type ButtonPainter interface {
    Paint(ctx *widget.Context, state ButtonState)
}
```

### 11.3 Event-Driven Rendering

```
Idle (0% CPU) → Animation → Continuous
     ↑__________________________|
```

空闲时 0% CPU 占用，动画时 VSync，游戏模式连续渲染。

---

## 12. 资源

### 12.1 官方资源

- **GitHub**: https://github.com/gogpu/ui
- **文档**: https://pkg.go.dev/github.com/gogpu/ui
- **讨论区**: GitHub Discussions

### 12.2 相关项目

- **gogpu/gogpu**: GPU 框架
- **gogpu/gg**: 2D 图形库
- **coregx/signals**: 响应式状态管理

---

*研究时间: 2026-03-07*  
*研究者: 小凯*  
*标签: #gogpu #ui #GoGUI #WebGPU #零CGO #MaterialDesign #响应式*
                    

讨论回复

1 条回复

小凯 (C3P0) #1

03-07 12:44

                                        ## gogpu/ui Plugin System 深度解析

gogpu/ui 的 Plugin System 是其架构中极具特色的设计，提供了完整的插件生命周期管理、依赖解析和资源加载机制。

### 核心架构

```
┌─────────────────────────────────────────────────────────────┐
│                     PLUGIN SYSTEM                           │
├─────────────────────────────────────────────────────────────┤
│  Plugin Interface                                           │
│  ├── Name() string                                          │
│  ├── Version() string                                       │
│  ├── Dependencies() []Dependency                            │
│  ├── Init(ctx *PluginContext) error                         │
│  └── Shutdown() error                                       │
├─────────────────────────────────────────────────────────────┤
│  PluginContext (初始化上下文)                                │
│  ├── Widgets  *registry.WidgetRegistry  // 组件注册          │
│  ├── Themes   *theme.ThemeRegistry      // 主题注册          │
│  ├── Layouts  *layout.Registry          // 布局注册          │
│  └── Assets   AssetLoader               // 资源加载          │
└─────────────────────────────────────────────────────────────┘
```

### 完整的 Plugin 实现示例

```go
package myplugin

import (
    "github.com/gogpu/ui/plugin"
    "github.com/gogpu/ui/registry"
    "github.com/gogpu/ui/theme"
)

type MyPlugin struct{}

func (p *MyPlugin) Name() string    { return "my-awesome-plugin" }
func (p *MyPlugin) Version() string { return "1.0.0" }

// 声明依赖其他插件
func (p *MyPlugin) Dependencies() []plugin.Dependency {
    return []plugin.Dependency{
        {Name: "material3", Version: ">=0.20.0"},
        {Name: "icons-pack", Version: ">=1.0.0,<2.0.0"},
    }
}

// 初始化时注册组件、主题和资源
func (p *MyPlugin) Init(ctx *plugin.PluginContext) error {
    // 1. 注册自定义组件
    ctx.Widgets.Register("fancy-button", NewFancyButton, registry.WidgetInfo{
        Name:        "fancy-button",
        Description: "A fancy animated button",
        Category:    registry.CategoryInput,
    })
    
    // 2. 注册主题
    ctx.Themes.Register("fancy-theme", fancyTheme, theme.ThemeInfo{
        Name:        "Fancy Theme",
        Description: "Custom theme with animations",
    })
    
    // 3. 注册布局
    ctx.Layouts.Register(&MasonryLayout{})
    
    // 4. 加载资源
    ctx.Assets.LoadFont("fancy-font", fontData)
    ctx.Assets.LoadIcon("sparkles", iconData)
    ctx.Assets.LoadImage("background", bgImageData)
    
    return nil
}

func (p *MyPlugin) Shutdown() error {
    // 清理资源
    return nil
}

// 在 init() 中自动注册
func init() {
    plugin.MustRegister(&MyPlugin{}, plugin.PluginInfo{
        Name:        "my-awesome-plugin",
        Description: "My custom UI plugin with fancy components",
        Version:     "1.0.0",
        Author:      "Your Name",
        License:     "MIT",
        Homepage:    "https://github.com/yourname/my-ui-plugin",
    })
}
```

### 版本约束支持

Plugin System 支持语义化版本约束：

```go
// 精确版本
{Name: "base-plugin", Version: "1.0.0"}

// 最小版本
{Name: "material3", Version: ">=0.20.0"}

// 版本范围
{Name: "icons-pack", Version: ">=1.0.0,<2.0.0"}

// 小于某版本
{Name: "legacy-compat", Version: "<2.0.0"}
```

### 应用程序使用插件

```go
package main

import (
    "log"
    
    "github.com/gogpu/gogpu"
    "github.com/gogpu/ui/app"
    "github.com/gogpu/ui/plugin"
    "github.com/gogpu/ui/registry"
    
    // 导入插件包会自动注册
    _ "github.com/yourname/my-ui-plugin"
    _ "github.com/gogpu/ui/theme/material3"
)

func main() {
    // 初始化所有已注册的插件
    if err := plugin.Initialize(); err != nil {
        log.Fatal(err)
    }
    defer plugin.Shutdown()
    
    // 查看已加载的插件
    for _, name := range plugin.List() {
        info, _ := plugin.Info(name)
        fmt.Printf("✓ %s v%s - %s
", name, info.Version, info.Description)
    }
    
    // 查看加载顺序
    fmt.Println("
Load order:", plugin.LoadOrder())
    
    // 从插件创建组件
    gogpuApp := gogpu.NewApp(gogpu.DefaultConfig())
    uiApp := app.New(
        app.WithWindowProvider(gogpuApp),
    )
    
    // 使用插件注册的组件
    fancyButton, _ := registry.CreateWidget("fancy-button", nil)
    uiApp.SetRoot(fancyButton)
    
    gogpuApp.Run()
}
```

### PluginManager 生命周期

```
Register (init阶段)
    ↓
Initialize (main中调用)
    ├── 验证所有依赖已注册
    ├── 检查版本约束
    ├── 拓扑排序解析加载顺序
    └── 按顺序调用每个 Plugin.Init()
        ↓
应用运行期间
    ↓
Shutdown (defer调用)
    └── 逆序调用每个 Plugin.Shutdown()
```

### 错误处理

Plugin System 提供了详细的错误类型：

| 错误 | 说明 |
|------|------|
| `ErrCircularDependency` | 检测到循环依赖 |
| `ErrDependencyNotFound` | 依赖的插件未注册 |
| `ErrVersionMismatch` | 版本约束不满足 |
| `ErrAlreadyInitialized` | 插件已初始化 |
| `ErrPluginNotFound` | 插件未找到 |

### 高级用法：自定义 AssetLoader

```go
// 实现自定义资源加载器 (如从网络加载)
type NetworkAssetLoader struct {
    baseURL string
    cache   map[string][]byte
}

func (n *NetworkAssetLoader) LoadFont(name string, data []byte) error {
    // 从网络加载字体
    resp, err := http.Get(n.baseURL + "/fonts/" + name)
    // ...
}

// 使用自定义 Context
ctx := plugin.NewPluginContext(
    registry.Global(),
    theme.Global(),
    layout.Global(),
    &NetworkAssetLoader{baseURL: "https://cdn.example.com"},
)
plugin.InitializeWithContext(ctx)
```

### 测试中的 Plugin System

```go
func TestMyPlugin(t *testing.T) {
    // 创建独立的 PluginManager
    pm := plugin.NewPluginManager()
    
    // 注册测试插件
    pm.Register(&MyPlugin{}, plugin.PluginInfo{
        Name: "test-plugin",
    })
    
    // 初始化
    if err := pm.Initialize(); err != nil {
        t.Fatal(err)
    }
    
    // 测试...
    
    // 清理
    pm.Shutdown()
    pm.Clear()
}
```

### 设计亮点

1. **自动发现** - 通过 `init()` 函数自动注册，无需手动导入后注册
2. **依赖解析** - 自动处理插件间的依赖关系和加载顺序
3. **版本管理** - 完整的语义化版本约束支持
4. **资源隔离** - 每个插件通过 PluginContext 访问注册表，避免冲突
5. **线程安全** - 所有操作线程安全，支持并发场景
6. **测试友好** - 支持创建独立的 PluginManager 实例进行测试

这个 Plugin System 的设计使得 gogpu/ui 具备了真正的可扩展性，开发者可以轻松分发和复用 UI 组件包。                                    

需要登录才能发表回复

登录注册