Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
- API
  
  Reference documentation for the pkg.go.dev API
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

tui

package module

Go to main page

Versions in this module

v0

v0.1.4

Jul 21, 2026

Changes in this version

type Effect

+ func (e Effect[Message]) WithoutRedraw() Effect[Message]

v0.1.3

Jul 20, 2026

v0.1.2

Jul 20, 2026

v0.1.1

Jul 20, 2026

Changes in this version

type Node

+ func VirtualScrollViewportWithOptions[Message any](id NodeID, contentSize Size, options ScrollViewportOptions[Message], ...) Node[Message]

+ func VirtualScrollViewport[Message any](id NodeID, contentSize Size, ...) Node[Message]

+ type VirtualFragment struct

+ Node Node[Message]

+ Origin ScrollOffset

+ func NewVirtualFragment[Message any](origin ScrollOffset, node Node[Message]) VirtualFragment[Message]

+ type VirtualViewport struct

+ ContentSize Size

+ Offset ScrollOffset

+ Size Size

v0.1.0

Jul 20, 2026

Changes in this version

+ const ColorDefault

+ const ColorIndexed

+ const ColorRGB

+ const DefaultQueueCapacity

+ const DefaultSubscriptionCapacity

+ const DefaultTaskLimit

+ var ErrNegativeFrameInterval = errors.New("runtime minimum frame interval must not be negative")

+ var ErrQueueFull = errors.New("runtime message queue is full")

+ var ErrZeroQueueCapacity = errors.New("runtime queue capacity must be positive")

+ var ErrZeroSubscriptionCapacity = errors.New("runtime subscription capacity must be positive")

+ var ErrZeroTaskLimit = errors.New("runtime task limit must be positive")

+ func RunTerminalContext[Message any](ctx context.Context, app App[Message], options TerminalOptions, ...) error

+ func RunTerminal[Message any](app App[Message], options TerminalOptions, ...) error

+ type ANSITextOptions struct

+ Paragraph ParagraphOptions

+ type App interface

+ Init func() Effect[Message]

+ Subscriptions func() Subscription[Message]

+ Update func(Message) Effect[Message]

+ View func(ViewContext) Node[Message]

+ type Attributes = vt.Attributes

+ type BorderKind uint8

+ const BorderDouble

+ const BorderRounded

+ const BorderSingle

+ const BorderThick

+ type Clock interface

+ Now func() Timestamp

+ type Color = vt.Color

+ func DefaultColor() Color

+ func IndexedColor(index uint8) Color

+ func RGBColor(red, green, blue uint8) Color

+ type ColorKind = vt.ColorKind

+ type DeliveryPolicy struct

+ func BatchDelivery(maximumMessages int, maximumDelay time.Duration) DeliveryPolicy

+ func LatestDelivery() DeliveryPolicy

+ func ReliableDelivery() DeliveryPolicy

+ func (p DeliveryPolicy) BatchLimits() (int, time.Duration, bool)

+ func (p DeliveryPolicy) IsLatest() bool

+ func (p DeliveryPolicy) IsReliable() bool

+ type DuplicateNodeIDError struct

+ ID NodeID

+ func (e *DuplicateNodeIDError) Error() string

+ type DuplicateSubscriptionKeyError struct

+ Key SubscriptionKey

+ func (e *DuplicateSubscriptionKeyError) Error() string

+ type Effect struct

+ func AfterEffect[Message any](delay time.Duration, message Message) Effect[Message]

+ func BatchEffects[Message any](effects ...Effect[Message]) Effect[Message]

+ func CancelEffect[Message any](key TaskKey) Effect[Message]

+ func CancelScopeEffect[Message any](scope ScopeID) Effect[Message]

+ func ExitEffect[Message any]() Effect[Message]

+ func FocusEffect[Message any](id NodeID) Effect[Message]

+ func LatestEffect[Message any](key TaskKey, task Task[Message]) Effect[Message]

+ func NoneEffect[Message any]() Effect[Message]

+ func RunEffect[Message any](task Task[Message]) Effect[Message]

+ func ScopedEffect[Message any](scope ScopeID, effect Effect[Message]) Effect[Message]

+ func ScrollToEffect[Message any](id NodeID, offset ScrollOffset) Effect[Message]

+ func SequenceEffects[Message any](effects ...Effect[Message]) Effect[Message]

+ func (e Effect[Message]) IsNone() bool

+ type EffectDiagnostics struct

+ func (d EffectDiagnostics) Cancellations() uint64

+ func (d EffectDiagnostics) StaleResults() uint64

+ func (d EffectDiagnostics) TaskPanics() uint64

+ type EventAction struct

+ func ExitAction[Message any]() EventAction[Message]

+ func IgnoreAction[Message any]() EventAction[Message]

+ func MessageAction[Message any](message Message) EventAction[Message]

+ func (a EventAction[Message]) Kind() EventActionKind

+ func (a EventAction[Message]) Message() (Message, bool)

+ type EventActionKind uint8

+ const EventExit

+ const EventIgnore

+ const EventMessage

+ type EventDispatch struct

+ func (d EventDispatch) Consumed() bool

+ func (d EventDispatch) Messages() int

+ func (d EventDispatch) RedrawRequested() bool

+ type EventResult struct

+ func ConsumeResult[Message any]() EventResult[Message]

+ func IgnoreResult[Message any]() EventResult[Message]

+ func MessageResult[Message any](message Message) EventResult[Message]

+ func (r EventResult[Message]) CapturePointer(id NodeID) EventResult[Message]

+ func (r EventResult[Message]) Consume() EventResult[Message]

+ func (r EventResult[Message]) Emit(message Message) EventResult[Message]

+ func (r EventResult[Message]) Focus(id NodeID) EventResult[Message]

+ func (r EventResult[Message]) Redraw() EventResult[Message]

+ func (r EventResult[Message]) ReleaseFocus() EventResult[Message]

+ func (r EventResult[Message]) ReleasePointer() EventResult[Message]

+ type Frame struct

+ func (f Frame) Operations() []vt.TerminalOp

+ func (f Frame) Surface() *surface.Surface

+ func (f Frame) Timestamp() Timestamp

+ type HorizontalAlignment uint8

+ const AlignCenter

+ const AlignEnd

+ const AlignStart

+ type Insets struct

+ Bottom uint32

+ Left uint32

+ Right uint32

+ Top uint32

+ func UniformInsets(cells uint32) Insets

+ type InteractionState struct

+ func NewInteractionState() *InteractionState

+ func (s *InteractionState) Focused() (NodeID, bool)

+ func (s *InteractionState) PointerCapture() (NodeID, bool)

+ func (s *InteractionState) ScrollOffset(id NodeID) ScrollOffset

+ func (s *InteractionState) ScrollState(id NodeID) (ScrollState, bool)

+ func (s *InteractionState) TextInput(id NodeID) (TextInputState, bool)

+ type Length struct

+ func Auto() Length

+ func Fixed(cells uint32) Length

+ func Flex(weight uint32) Length

+ func MinMax(minimum, preferred, maximum uint32) Length

+ func Percent(percent uint32) Length

+ func (l Length) Bounds() (minimum, preferred, maximum uint32, ok bool)

+ func (l Length) Kind() LengthKind

+ func (l Length) Value() (uint32, bool)

+ type LengthKind uint8

+ const LengthAuto

+ const LengthFixed

+ const LengthFlex

+ const LengthMinMax

+ const LengthPercent

+ type Node struct

+ func ANSIText[Message any](input string, options ANSITextOptions) Node[Message]

+ func Align[Message any](child Node[Message], horizontal HorizontalAlignment, ...) Node[Message]

+ func Border[Message any](child Node[Message], style vt.Style) Node[Message]

+ func Clip[Message any](child Node[Message]) Node[Message]

+ func Column[Message any](children ...Node[Message]) Node[Message]

+ func Gap[Message any](cells uint32) Node[Message]

+ func Modal[Message any](id NodeID, child Node[Message]) Node[Message]

+ func Padding[Message any](child Node[Message], insets Insets) Node[Message]

+ func PanelWithOptions[Message any](child Node[Message], title string, options PanelOptions) Node[Message]

+ func Panel[Message any](child Node[Message], title string) Node[Message]

+ func Paragraph[Message any](spans []TextSpan, options ParagraphOptions) Node[Message]

+ func RichText[Message any](spans ...TextSpan) Node[Message]

+ func Row[Message any](children ...Node[Message]) Node[Message]

+ func ScrollViewportWithOptions[Message any](id NodeID, child Node[Message], options ScrollViewportOptions[Message]) Node[Message]

+ func ScrollViewport[Message any](id NodeID, child Node[Message]) Node[Message]

+ func Spacer[Message any](width, height uint32) Node[Message]

+ func Stack[Message any](children ...Node[Message]) Node[Message]

+ func StyledTextInput[Message any](id NodeID, value, placeholder string, style, placeholderStyle vt.Style, ...) Node[Message]

+ func StyledText[Message any](content string, style vt.Style) Node[Message]

+ func SurfaceNode[Message any](source *surface.Surface) Node[Message]

+ func TextInput[Message any](id NodeID, value string, onChange func(string) Message) Node[Message]

+ func Text[Message any](content string) Node[Message]

+ func (n Node[Message]) Focusable(id NodeID) Node[Message]

+ func (n Node[Message]) OnEvent(id NodeID, handler func(vt.Event) EventResult[Message]) Node[Message]

+ func (n Node[Message]) TabStop(enabled bool) Node[Message]

+ func (n Node[Message]) WithFocusedStyle(style vt.Style) Node[Message]

+ func (n Node[Message]) WithID(id NodeID) Node[Message]

+ func (n Node[Message]) WithLength(length Length) Node[Message]

+ type NodeID string

+ func NewNodeID(value string) NodeID

+ func (id NodeID) String() string

+ type OptionalColor = vt.OptionalColor

+ func SomeColor(color Color) OptionalColor

+ type PanelOptions struct

+ Border BorderKind

+ Padding Insets

+ Style PanelStyle

+ func DefaultPanelOptions() PanelOptions

+ type PanelStyle struct

+ Background vt.Style

+ Border vt.Style

+ Title vt.Style

+ type ParagraphOptions struct

+ Alignment HorizontalAlignment

+ Wrap WrapMode

+ func DefaultParagraphOptions() ParagraphOptions

+ type Point = surface.Point

+ type Rect = surface.Rect

+ type Runtime struct

+ func NewRuntimeWithClock[Message any](app App[Message], config RuntimeConfig, clock Clock) (*Runtime[Message], error)

+ func NewRuntime[Message any](app App[Message], size Size) (*Runtime[Message], error)

+ func (r *Runtime[Message]) ActiveSubscriptions() int

+ func (r *Runtime[Message]) ActiveTasks() int

+ func (r *Runtime[Message]) App() App[Message]

+ func (r *Runtime[Message]) ClearFocus()

+ func (r *Runtime[Message]) Close()

+ func (r *Runtime[Message]) DispatchEvent(event vt.Event) (EventDispatch, error)

+ func (r *Runtime[Message]) EffectDiagnostics() EffectDiagnostics

+ func (r *Runtime[Message]) Enqueue(message Message) error

+ func (r *Runtime[Message]) ExitRequested() bool

+ func (r *Runtime[Message]) Interaction() *InteractionState

+ func (r *Runtime[Message]) PendingEffectMessages() int

+ func (r *Runtime[Message]) PendingSubscriptionMessages() int

+ func (r *Runtime[Message]) PendingTasks() int

+ func (r *Runtime[Message]) PollEffects() int

+ func (r *Runtime[Message]) PollSubscriptions() int

+ func (r *Runtime[Message]) ProcessPending() (int, error)

+ func (r *Runtime[Message]) ProcessPendingWith(observe func(Message)) (int, error)

+ func (r *Runtime[Message]) QueuedMessages() int

+ func (r *Runtime[Message]) RenderIfDirty() (*Frame, error)

+ func (r *Runtime[Message]) RequestFocus(id NodeID) (bool, error)

+ func (r *Runtime[Message]) RequestFrame()

+ func (r *Runtime[Message]) Resize(size Size)

+ func (r *Runtime[Message]) RunningSubscriptionStreams() int

+ func (r *Runtime[Message]) RunningTasks() int

+ func (r *Runtime[Message]) SetScrollOffset(id NodeID, offset ScrollOffset) bool

+ func (r *Runtime[Message]) SetTextCursor(id NodeID, cursor int) bool

+ func (r *Runtime[Message]) Size() Size

+ func (r *Runtime[Message]) Step() (*Frame, error)

+ func (r *Runtime[Message]) SubscriptionActive(key SubscriptionKey) bool

+ func (r *Runtime[Message]) SubscriptionDiagnostics() SubscriptionDiagnostics

+ func (r *Runtime[Message]) SubscriptionGeneration(key SubscriptionKey) uint64

+ func (r *Runtime[Message]) TaskGeneration(key TaskKey) uint64

+ func (r *Runtime[Message]) TimeUntilEffectDeadline() (time.Duration, bool)

+ func (r *Runtime[Message]) TimeUntilFrameDeadline() (time.Duration, bool)

+ func (r *Runtime[Message]) TimeUntilSubscriptionDeadline() (time.Duration, bool)

+ type RuntimeConfig struct

+ MinimumFrameInterval time.Duration

+ QueueCapacity int

+ Size Size

+ SubscriptionCapacity int

+ TaskLimit int

+ func NewRuntimeConfig(size Size) RuntimeConfig

+ type ScopeID string

+ func NewScopeID(value string) ScopeID

+ func (s ScopeID) String() string

+ type ScrollAxis uint8

+ const ScrollAxisBoth

+ const ScrollAxisHorizontal

+ const ScrollAxisVertical

+ type ScrollOffset struct

+ X uint32

+ Y uint32

+ type ScrollState struct

+ AtEnd bool

+ AtStart bool

+ Maximum ScrollOffset

+ Offset ScrollOffset

+ type ScrollViewportOptions struct

+ Axis ScrollAxis

+ EnsureFocusedVisible bool

+ OnScroll func(ScrollState) Message

+ StickToEnd bool

+ func DefaultScrollViewportOptions[Message any]() ScrollViewportOptions[Message]

+ type Size = surface.Size

+ type Style = vt.Style

+ type Subscription struct

+ func BatchSubscriptions[Message any](subscriptions ...Subscription[Message]) Subscription[Message]

+ func EverySubscription[Message any](key SubscriptionKey, interval time.Duration, policy DeliveryPolicy, ...) Subscription[Message]

+ func NoneSubscription[Message any]() Subscription[Message]

+ func StreamSubscription[Message any](key SubscriptionKey, policy DeliveryPolicy, stream SubscriptionStream[Message]) Subscription[Message]

+ func (s Subscription[Message]) IsNone() bool

+ func (s Subscription[Message]) String() string

+ type SubscriptionDiagnostics struct

+ func (d SubscriptionDiagnostics) BatchFlushes() uint64

+ func (d SubscriptionDiagnostics) BlockedSends() uint64

+ func (d SubscriptionDiagnostics) DiscardedMessages() uint64

+ func (d SubscriptionDiagnostics) LatestReplacements() uint64

+ func (d SubscriptionDiagnostics) ProducerPanics() uint64

+ func (d SubscriptionDiagnostics) Starts() uint64

+ func (d SubscriptionDiagnostics) Stops() uint64

+ type SubscriptionKey string

+ func NewSubscriptionKey(value string) SubscriptionKey

+ func (k SubscriptionKey) String() string

+ type SubscriptionSink struct

+ func (s SubscriptionSink[Message]) Closed() bool

+ func (s SubscriptionSink[Message]) Done() <-chan struct{}

+ func (s SubscriptionSink[Message]) Send(message Message) bool

+ type SubscriptionStream func(context.Context, SubscriptionSink[Message])

+ type SystemClock struct

+ func NewSystemClock() SystemClock

+ func (c SystemClock) Now() Timestamp

+ type Task func(context.Context) Message

+ type TaskKey string

+ func NewTaskKey(value string) TaskKey

+ func (k TaskKey) String() string

+ type TerminalOptions struct

+ Capabilities vt.Capabilities

+ EscapeTimeout time.Duration

+ FocusFirst bool

+ MaximumIdleWait time.Duration

+ MinimumFrameInterval time.Duration

+ MouseTracking *vt.MouseTracking

+ QueueCapacity int

+ SubscriptionCapacity int

+ TaskLimit int

+ func DefaultTerminalOptions() TerminalOptions

+ type TextInputState struct

+ func (s TextInputState) Cursor() int

+ type TextSpan struct

+ Style vt.Style

+ Text string

+ func NewTextSpan(text string, style vt.Style) TextSpan

+ type TimedInputDecoder struct

+ func NewTimedInputDecoder(clock Clock, escapeTimeout time.Duration) *TimedInputDecoder

+ func (d *TimedInputDecoder) Feed(input []byte) []vt.Event

+ func (d *TimedInputDecoder) Flush() []vt.Event

+ func (d *TimedInputDecoder) HasPending() bool

+ func (d *TimedInputDecoder) Poll() []vt.Event

+ func (d *TimedInputDecoder) TimeUntilDeadline() (time.Duration, bool)

+ type Timestamp uint64

+ func (t Timestamp) Add(duration time.Duration) Timestamp

+ func (t Timestamp) Nanoseconds() uint64

+ type VerticalAlignment uint8

+ const AlignBottom

+ const AlignMiddle

+ const AlignTop

+ type ViewContext struct

+ Size Size

+ type VirtualClock struct

+ func NewVirtualClock() *VirtualClock

+ func (c *VirtualClock) Advance(duration time.Duration) Timestamp

+ func (c *VirtualClock) Now() Timestamp

+ type WrapMode uint8

+ const WrapHard

+ const WrapNone

+ const WrapWord