gohud — a HUD & UI kit for Godot 4

New: arcade, comic, Material 3 and a look for kids

Four new families join default, sci-fi and medieval — fourteen built-in looks now, each in dark and light. Every widget, popup and HUD piece takes them with no change to your code: switch the preset and the whole screen follows.

The gohud gallery in material_light — pill buttons, filled cards and Material 3 colours — `material_light`

The gohud gallery in material_dark — the same Material 3 shapes on the dark baseline — `material_dark`

The gohud gallery in kids_light — chunky jelly buttons in crayon colours on a sunny page — `kids_light`

The gohud gallery in kids_dark — the same toy box on a night-blue page — `kids_dark`

The gohud gallery in comic_light — bold ink outlines and hard shadows on a paper-cream page — `comic_light`

The gohud gallery in comic_dark — cream outlines and a yellow primary on a night page — `comic_dark`

The gohud gallery in arcade_light — painted keys with a gradient and a gloss, a thick blue-framed HUD board on a sky-blue page — `arcade_light`

The gohud gallery in arcade_dark — the same bright keys on a night page — `arcade_dark`

Material 3 — for app screens

Material 3 Expressive, measured against the official M3 tokens: pill buttons with a 40dp plate inside the 48dp touch target, 28dp dialogs and sheets, filled cards, outlined fields and the Expressive slider. The app components — navigation bar, app bar, FAB, search bar, chips, progress and the date picker — follow the M3 component tokens, and titles are set in the bundled Roboto. For shops, settings, inboxes and every screen that should feel like an app.

Kids — the toy box

Made for children: every key, row and panel is a jelly candy with a chunky outline and a solid lip that sinks when pressed, each kind of control in its own crayon colour. Quick slots are candy blocks, badges are stickers, the joystick is a rainbow, windows get a sunny title ribbon and a round candy close button, and a press squishes. Sizes and your project's font stay exactly as they were.

Comic — bold ink

Every face is a comic-book panel: the surface colour inside a bold ink outline, with a hard shadow behind it that goes when the face is pressed. One setting turns every shadow on or off, two more set the outline width and the shadow size, and one call does the same for a single widget. Windows get a yellow title caption.

Arcade — painted keys

Every key is painted — a gradient, a white gloss and a lip that sinks when pressed, in a navy ink outline — and labelled in white with an ink outline: green to play, blue for the rest, red to delete. Boards are thick, a coloured frame round a pale well, and windows get a gold title banner and a round red close key.

GoUi.use_preset(GoThemePresets.MATERIAL_LIGHT)   # or MATERIAL_DARK
GoUi.use_preset(&"kids_light")                   # or &"kids_dark"
GoUi.use_preset(&"comic_light")                  # or &"comic_dark"
GoUi.use_preset(&"arcade_light")                 # or &"arcade_dark"

Material 3 in detail → · Kids in detail → · Arcade, widget by widget ↓ · Comic, widget by widget ↓ · The same popup in all fourteen looks →

Arcade: painted keys and thick boards

The newest look dresses every screen like an arcade cabinet. Every key is a painted pill — a gradient from a light top to a deeper bottom, a candy gloss (a sheen over the upper half and a glint round both top corners) and a lip that sinks when pressed, all inside a navy ink outline — and its label is white with an ink outline. Tabs stand apart, gauges are split into chunks by ink ticks, key hints are keycaps and window titles ride a gold ribbon with swallow tails. Every board is thick: a coloured frame with its own gloss round a pale well. arcade_light puts white boards on a sky-blue page; arcade_dark puts navy boards on a night page. Every picture below is a real gohud screen — the same code, one preset line.

GoUi.use_preset(&"arcade_light")   # or &"arcade_dark"

The gohud gallery in arcade_light — green, blue, red and lavender painted keys and a blue-framed HUD board on a sky-blue page — `arcade_light` · the gallery

A bottom sheet in arcade_light — a thick framed board rising from the bottom edge with key-cap rows — `GoSheet`

A coach mark in arcade_light — a framed callout pointing at a key — `GoCoachMark`

A side drawer in arcade_dark — a navy board of navigation rows over the dimmed screen — `GoDrawer`

A popover in arcade_dark — a framed bubble anchored to the key that opened it — `GoPopover`

An alert in arcade_dark — a gold Level up! banner, a red close key and a green Great key on a navy board framed in blue — `GoDialogs.alert()`

A snackbar in arcade_light — a white board framed in brown along the bottom edge with an Undo action — `GoSnackbar`

Every key painted

Buttons in arcade_light — green Play, blue Details, a white outlined key, coral Delete, red Delete forever, a lavender compact key and a grey disabled key, each painted with a gradient, a gloss and a lip in a navy outline — `GoStyle.button()`

Tabs in arcade_light — the chosen tab a blue painted key, the others lavender keys — `GoStyle.tabs()`

A segmented control in arcade_light — separate painted keys, the chosen one blue and pressed in — Segmented keys

Toggles and check boxes in arcade_light — a green glossy track when on, lavender when off, a green tick box — Toggles and check boxes

Cards in arcade_light — pale wells inside thick blue frames with a gloss and a lip — `GoStyle.card()`

A form in arcade_light — a sunken white field, a toggle and a green Save key — `GoForm`

A choice grid in arcade_light — key caps, the chosen one rimmed in gold over a green tint — `GoStyle.choice_grid()`

A slot grid in arcade_light — an inventory of glossy key caps with stack counts — `GoSlotGrid`

List rows in arcade_light — each row a pale key cap with an icon — List rows

A date picker in arcade_light — key-cap days, the chosen day a painted key — `GoDatePicker`

A slider in arcade_light — a blue glossy tube in an ink groove and a round key-cap knob — `GoStyle.slider()`

A radio group in arcade_light — round key caps, the chosen one with a blue dot — `GoStyle.radio_group()`

Filter chips in arcade_light — key-cap chips, the chosen one tinted blue with a tick, and removable chips with a cross — `GoStyle.filter_chip()`

A search bar in arcade_light — a sunken white field in an ink outline with a search and a filter icon — `GoSearchBar`

A stepper in arcade_light — each step a pale key cap, the open step showing its green Next key — `GoStepper`

A leaderboard table in arcade_light — every other row a raised key cap — `GoTable`

A bottom navigation bar in arcade_light — the chosen tab's icon on a blue key-cap pill, a red count badge — `GoNavBar`

A time picker in arcade_light — the hour and minutes on big key caps, AM and PM keys over a clock dial — `GoTimePicker`

A code input in arcade_light — eight key-cap cells, the one being typed in rimmed in gold — `GoCodeInput`

A wheel picker in arcade_light — the chosen amount on a key-cap band, the others fading above and below — `GoWheelPicker`

At night: `arcade_dark`

On a dark page the ink becomes the page itself, much deeper, and the paints stay just as bright.

Buttons in arcade_dark — the same bright paints on a night page — `GoStyle.button()` at night

HUD bars in arcade_dark — red HP, blue MP and green XP tubes in sunken grooves — `GoBar`

HUD cards in arcade_dark — a navy well in a thick blue frame over the game — `GoStyle.hud_panel()`

Quick slots in arcade_dark — key caps with a stack count, a cooling slot rimmed in gold — `GoSlot`

A virtual joystick in arcade_dark — a glossy pad in an ink ring with four arrows and a key-cap knob — `GoJoystick`

Alerts in arcade_dark — small boards framed in yellow, green, red and blue — Alerts

Floating action buttons in arcade_dark — gold painted keys with a gloss — `GoFab`

A reward calendar in arcade_dark — key-cap days, today rimmed in gold — `GoRewardCalendar`

A segmented control in arcade_dark — the chosen Day key painted blue, Week and Month lavender, every label white — Segmented keys

A tab view in arcade_dark — painted tab keys over item rows that are navy key caps — `GoTabView`

A scrolling list in arcade_dark — item rows on navy key caps and a row of filter chips, the chosen one blue — `GoScroll`

Toggles and check boxes in arcade_dark — a green glossy track when on, lavender when off — Toggles and check boxes

Rarity chips in arcade_dark — small painted plates from Common to Cursed — `GoStyle.chip()`

A slot grid in arcade_dark — an inventory of navy key caps with white icons and stack counts — `GoSlotGrid`

A range slider in arcade_dark — a blue run between two glossy knobs in a dark groove — `GoRangeSlider`

Pagination in arcade_dark — the current page a green painted key — `GoPagination`

Badges in arcade_dark — coral plates outlined in ink over the icons — `GoBadge`

How the arcade look works

The face

Every key and board is a GoStyleBoxArcade: an ink outline, a gradient body, a lip and a gloss, drawn inside the control's own rectangle — a key keeps its size from state to state, and a press only sinks it.

Labels that read

A white label with an ink outline reads on any paint the outline stands off — WCAG counts the outline as part of the letter. Every paint is moved until its label clears 4.6:1 at every height of the gradient.

Windows

A window's title sits on a gold banner in white letters outlined in ink, next to a round red close key. Dialogs, sheets, drawers and popovers are thick framed boards.

One key can take its own colour — an orange shop key in a pause menu:

menu.add_child(GoStyle.arcade_paint(GoStyle.button("Shop", _shop), Color("#FF8A1E")))

Arcade in detail → · The same popup in all fourteen looks →

Comic: bold ink and a hard shadow

The comic look draws every face like a panel in a comic book — the surface colour inside a bold ink outline, with a hard, solid shadow dropped down and to the right. comic_light inks black on a paper-cream page with a cobalt primary; comic_dark inks cream on a night page with a yellow primary. Every picture below is a real gohud screen — the same code, one preset line.

GoUi.use_preset(&"comic_light")   # or &"comic_dark"

The gohud gallery in comic_light — inked keys, rows and bars with hard shadows on a paper-cream page — `comic_light` · the gallery

The gohud gallery in comic_dark — cream ink and a yellow primary on a night page — `comic_dark` · the gallery

A bottom sheet in comic_light — an inked panel rising from the bottom edge with inked rows — `GoSheet`

A coach mark in comic_light — an inked callout pointing at a button — `GoCoachMark`

A side drawer in comic_dark — an inked panel of navigation rows over the dimmed screen — `GoDrawer`

A popover in comic_dark — an inked bubble anchored to the button that opened it — `GoPopover`

Buttons, toggles, tabs, sliders, cards, forms, tables, pickers and chips all wear the ink — you do not style them one by one. Press a key and its shadow goes: the face sinks into its place, like a stamp. Disabled faces lose their shadow and fade, so what can be pressed stands out from what cannot.

Buttons in comic_light — primary, secondary, outlined, danger, compact, bare and disabled keys, each in a bold black outline with a hard shadow — `GoStyle.button()` — every kind

Toggles and check boxes in comic_light — an inked track and knob, inked boxes with a tick — Toggles and check boxes

Radio buttons in comic_light — inked rings, the chosen one with a filled dot — Radio buttons

Tabs in comic_light — the chosen tab is an inked panel, the others sit on an ink underline — `GoStyle.tabs()`

A segmented control in comic_light — inked cells, the chosen one filled — Segmented pills

A slider in comic_light — an inked groove, a thin accent fill and an inked handle — `GoStyle.slider()`

Drop-down selects in comic_light — inked keys with a chevron — Selects

A card in comic_light — a white panel in a bold outline with a hard shadow — `GoStyle.card()`

A form in comic_light — an inked field with a hint, a toggle and an inked Save key — `GoForm`

List rows in comic_light — each row an inked strip with an icon, a subtitle or a danger label — List rows

A table in comic_light — a header over an ink rule, and every score row an inked strip — `GoTable`

A date picker in comic_light — inked day cells, the chosen day filled — `GoDatePicker`

A time picker in comic_light — inked hour and minute boxes, AM and PM keys and a clock dial — `GoTimePicker`

A stepper in comic_light — inked step rows, the done step ticked and the coming step faded — `GoStepper`

Filter and input chips in comic_light — inked pills, the chosen filter tinted with a tick — Filter chips

A navigation bar in comic_light — an ink rule on top, the current tab in an inked pill and a badge on Alerts — `GoNavBar`

An input group in comic_light — a field and its Send key welded into one inked shape — `GoInputGroup`

A split button in comic_light — an action and a menu arrow as two inked halves — `GoSplitButton`

Pagination in comic_light — the current page is an inked key with a hard shadow — `GoPagination`

At night: `comic_dark`

On a dark page a black outline would vanish, so comic_dark draws it in cream and drops a faint shadow tinted with the same ink. The HUD pieces — quick slots, bars, the joystick and the reward calendar — follow the same rules.

Buttons in comic_dark — cream outlines, a yellow primary and faint hard shadows on a night page — `GoStyle.button()` at night

Quick slots in comic_dark — inked blocks with a stack count and a cooldown, the lit slots rimmed in yellow — `GoSlot`

HUD bars in comic_dark — HP, MP and XP in cream-inked grooves — `GoBar`

A virtual joystick in comic_dark — a cream ring and a knob that casts a shadow — `GoJoystick`

Alerts in comic_dark — info, success, warning and danger panels in cream ink — Alerts

A slot grid in comic_dark — an inventory of inked blocks — `GoSlotGrid`

A reward calendar in comic_dark — inked day cells, claimed days ticked and today rimmed in yellow — `GoRewardCalendar`

Rarity chips in comic_dark — inked pills, each tinted with its own colour — Chips

A range slider in comic_dark — two inked handles on an inked groove — `GoRangeSlider`

A search bar in comic_dark — an inked bar with search and filter icons — `GoSearchBar`

Floating action buttons in comic_dark — yellow keys in cream ink with hard shadows — `GoFab`

How the comic look works

One StyleBox for every face

Every face is a GoStyleBoxComic: a fill, an outline and a shadow, drawn inside the control’s own rectangle. It reads the outline and shadow sizes from GoConfig each time it draws, so one setting changes the whole screen at once.

Pressed means flat

A pressed key drops its shadow and moves into its place. Hover keeps the shadow; focus adds an inner ink ring that never covers the outline; disabled faces lose the shadow and fade.

The skin inks the rest

GoSkinComic inks what code draws: quick slots, chips, badges, avatars, notices, the navigation bar, the FAB, the date cells and the joystick, whose knob casts a shadow.

Windows get a caption

A window’s title sits on a yellow caption, like the narration box of a comic, next to an inked round close button. Dialogs, sheets, drawers and popovers are opaque inked panels.

Readable day and night

Both palettes pass the same WCAG contrast checks as every other preset, including pressed and disabled keys. When a caption colour would sit too close to the page, its outline falls back to the page colour.

No layout changes

The outline and shadow fit inside each control and the padding stays as the theme gave it, so a screen laid out in another look keeps its layout — and your project’s font.

Three settings and one call

Three GoConfig settings change every comic face at once. Nothing is rebuilt — the screen redraws as you set them.

GoUi.config.comic_border_width = 2.0   # the outline (dp) — 3 by default
GoUi.config.comic_shadow_size = 6.0    # the shadow (dp) — 4 by default
GoUi.config.comic_shadow = false       # no shadows anywhere

One widget can go its own way, whatever the settings say. Pass true as the last argument to include everything inside it.

GoStyle.comic_shadow(skip_button, false)     # this button sits flat
GoStyle.comic_shadow(card, true, true)       # this card and everything in it keep their shadow
GoStyle.comic_border(title, 5.0)             # a thicker outline on this one

Make a comic of your own. tools/new_theme.py inked --from comic_light copies the palette; change the paper, ink and primary colours and run tools/make_theme.py inked. The ink, the shadow and the skin come along.

Comic in detail → · The same popup in all fourteen looks →

What it looks like in a game

The medieval and sci-fi presets — character sheets, inventories and quests; forms, grids and prompt cards; angular panels and touch controls. Switching presets is one line of code.

gohud medieval theme — a character sheet with health, mana and stamina bars, a satchel of quick slots and a quest journal in forged gold frames — **Medieval** — character, inventory and quests

gohud medieval theme — an input panel with a name field, toggle, checkboxes and volume slider, a grid of tiles, and a party-invite prompt card with Accept and Decline — **Medieval** — forms, grids and prompt cards

gohud sci-fi theme — a chamfered touch-controls panel with a hexagonal joystick, a Fixed / Follow / Relative switch and round action buttons — **Sci-fi** — angular panels and touch controls

All fourteen presets and how to switch them →

What it takes off your hands

What costs the most time in game UI is not the shape of a button — it is everything that drifts apart between devices. gohud handles that drift in one place.

Every measurement is a token

Spacing, corners and text sizes are called by name, not written as numbers. Swap the theme and the whole screen moves with it.

Visible size ≠ pressable size

A close button looks 36dp but its touch target is 48dp. Where crowded slots overlap, the one whose centre is nearer takes the press.

Notches and keyboards

HUD pieces sit inside the safe area, and an input rises above the virtual keyboard when it appears.

Back closes one thing

Escape and Android Back close only the topmost surface. Stacked windows do not vanish together.

Notices never steal input

Press through a snackbar and the button underneath receives it. Focus is not taken either.

Icons are asked for by name

Widgets only know GoIconSet.CLOSE. Swap the set and every drawing changes without touching a line of code. Icons →

Fourteen looks, one line

GoUi.use_preset() swaps theme, skin and icons together — rounded, chamfered sci-fi, forged medieval frames, Material 3 app components, kids' jelly candies, comic ink or arcade paint.

Legible by measurement

Every theme is checked against WCAG, including button states and translucent HUD panels over pure white and pure black.

Everything works without enabling the plugin. Enabling it adds a GoRuntime autoload that tracks window size, dp scale and keyboard height, plus project settings for the config resource and the preset — conveniences, not requirements.

Install gohud

Two ways in. Let your AI agent do it, or drop the folder into your project — there is nothing else to set up.

Install

Quick start

Five lines put a themed screen on the display. See the whole walk-through on the install page.

Quick start

Change the look — colours and shape

A Theme can only restyle what the engine draws. Rounded corners are the only corners StyleBoxFlat has, and the joystick, quick slots and coach mark are drawn by code — so a theme alone can never change their shape. gohud therefore ships presets: a theme, a skin and an icon set picked as one unit.

GoUi.use_preset(GoThemePresets.MEDIEVAL_DARK)   # theme, skin and icons together

Preset	Look
`default_dark`	The original gohud — rounded corners, soft blue accent
`default_light`	The same shapes on a light palette
`scifi_dark`	Chamfered corners, cyan neon edges and glow, hexagonal joystick, targeting brackets
`scifi_light`	The same angular shapes in a bright blueprint palette
`medieval_dark`	Dark iron and leather, antique-gold frames, rivets, engraved icons, Cinzel headings
`medieval_light`	Parchment, ink and bronze with the same forged frames
`material_light` New	Material 3 for app screens — pill buttons, 28dp dialogs, filled cards, an app's navigation bar, FAB and search bar, Roboto
`material_dark` New	The same Material 3 shapes on the dark baseline
`kids_light` New	The toy box for children — jelly-candy keys with a chunky outline and a lip that sinks when pressed, crayon colours, a sunny page
`kids_dark` New	The same toy box on a night-blue page
`comic_light` New	Comic-book panels — a bold ink outline and a hard shadow on every face, white panels on a paper-cream page; the shadow, its size and the outline width are settings
`comic_dark` New	The same ink on a night page — cream outlines and a yellow primary
`arcade_light` New	An arcade cabinet — every key painted with a gradient, a gloss and a lip, labelled in white with an ink outline; thick framed boards on a sky-blue page, a gold title banner on windows
`arcade_dark` New	The same bright keys on navy boards and a night page

The gohud gallery with the default_dark preset — rounded corners, blue accent — `default_dark` — rounded corners, soft blue accent

default_light preset — the same shapes on a light palette — `default_light` — same shapes, light palette

scifi_dark preset — chamfered corners and cyan neon — `scifi_dark` — chamfered corners, cyan neon

scifi_light preset — the same angular shapes in a blueprint palette — `scifi_light` — same angular shapes, blueprint palette

Those four are the same gallery screen. Not a line of code differs — only the preset name. Button corners, toggle shapes, list rows and input borders all move together.

Medieval collection

medieval_dark pairs iron and leather with antique gold; medieval_light uses parchment and ink. Menu frames carry a rivet and a small corner ornament while the always-visible HUD stays quiet; 16 engraved icons redraw the item names, and only titles and subtitles use the bundled Cinzel font.

medieval_dark — character sheet, satchel of quick slots and quest journal — `medieval_dark` — iron and leather

medieval_light — the same character, satchel and quest screens on parchment — `medieval_light` — parchment and ink

Both shots are examples/medieval/medieval.tscn, built from the standard widgets. The medieval guide and how to make your own kingdom →

The same screen on a phone and on a desktop

The gallery shots are a phone in portrait. Below is the same code at 1280×800 — the content stops at a readable width (480dp) and centres, while the HUD stays in the corners. The form steps around floating HUD pieces, but does not move when it is already clear of them: pushing anyway would throw the content off-centre on a wide screen.

default_dark at 1280x800 — content centred, HUD in the corners — `default_dark` · 1280×800

scifi_dark at 1280x800 — same layout with chamfered panels and neon — `scifi_dark` · 1280×800

The same sheet, a different look

A bottom sheet in default_dark — Default — rounded card, sticky search row and footer

A bottom sheet in scifi_dark — neon accent edge along the top — Sci-fi — top accent edge, cut corners, glow

Pick one from Project Settings → gohud → Theme → Preset, or set GoConfig.preset. Filling in theme, skin or icons explicitly wins over the preset, so you can take a preset and override just one of them.

A new theme is one JSON file. new_theme.py kingdom --from medieval_dark writes a palette that spells out every inherited value; make_theme.py kingdom builds the theme, its control artwork and its skin dials, and the preset appears in the picker. Every setting and dial →

Skins — where a Theme cannot reach

A skin owns the joystick, quick-slot faces, the coach-mark ring, chips, skeletons, alerts, dividers and section headings. Subclass it and override only what you want changed.

class_name MySkin extends GoSkin

func slot_box(accent: Color, lit: bool) -> StyleBox:
    var box := GoStyleBoxCut.new()
    box.bg_color = accent
    box.cut = 6.0
    box.edge_color = accent
    return box

Class	Shapes it can make
`GoStyleBoxCut`	Diagonally cut corners (chamfer), one thickened accent edge, an outer glow
`GoStyleBoxBracket`	Corner marks only, without enclosing the content
`GoStyleBoxMedieval`	A forged frame with rivets, corner engraving, a bevel highlight and material grain
`GoStyleBoxJelly`	A jelly candy — a chunky outline, a solid lip that sinks when pressed, a body lighter on top and a white shine
`GoStyleBoxComic`	A comic-book panel — a bold ink outline and a hard drop shadow, both sized by `GoConfig` while the game runs
`GoStyleBoxArcade`	An arcade key or board — a gradient body, a white gloss, a lip that sinks when pressed and an ink outline; a board adds a thick coloured frame round a pale well

All six serialise into a Theme resource — which is what lets a theme change shape, not just colour. GoSkinSciFi, GoSkinMedieval, GoSkinMaterial, GoSkinKids, GoSkinComic and GoSkinArcade are the shipped subclasses.

Quick slots, a joystick and a chip drawn by each shipped skin — default, kids, Material, medieval and sci-fi — What a skin draws — default, kids, Material, medieval, sci-fi

Quick slots, a joystick and a chip drawn by the comic skin — inked outlines and hard shadows — …and the comic skin

Quick slots, a joystick and a chip drawn by the arcade skin — glossy key caps and a pad with four arrows — …and the arcade skin

GoStyle.box() always returns a StyleBoxFlat, because calling code receives it and adjusts bg_color or corner_radius. Use GoStyle.surface() when a custom shape has to survive.

Widgets

The pieces, in one table. Each one in detail → · Every widget with a picture → · Popups and dialogs, the full guide →

Class	Base	What it does
`GoSurface`	Control	Floating card shell — centre, bottom or anchored placement, sticky header and footer, scrolling body, drag-to-resize
`GoSheet`	CanvasLayer	Pages rising from the bottom, on their own layer so they sit above the HUD
`GoDialogs`	Node	Confirmations and alerts you `await`; `destructive` for irreversible actions
`GoForm`	MarginContainer	Width-capped forms that avoid the virtual keyboard and, with `avoid_hud`, the HUD
`GoScroll`	ScrollContainer	Touch scrolling; the scrollbar tucks into the card padding
`GoNotice`	PanelContainer	A snackbar that takes neither input nor focus
`GoPromptCard`	PanelContainer	A question that does not block the game
`GoCoachMark`	Control	A guided tour that points at real controls; pressing the target advances
`GoHudAnchor`	Control	Pins HUD pieces to one of nine safe-area spots
`GoBar`	Control	Health, mana and experience bars with eased changes
`GoSlot`	Button	A quick slot — icon, quantity, cooldown and shortcut on one face
`GoJoystick`	Control	Virtual stick in fixed, follow or relative mode
`GoIconButton`	Button	Looks small, presses large
`GoStyle`	static	Buttons, list rows, inputs, chips, tables, tabs and more, made one consistent way

Waiting, telling, counting

Class	Base	What it does
`GoSnackbar`	Node	the message that places itself
`GoSpinner`	Control	a wait with no end in sight
`GoBadge`	PanelContainer	the unread dot, the NEW tag, the 99+

Forms and lists

Class	Base	What it does
`GoField`	VBoxContainer	the row that can be wrong
`GoInputGroup`	HBoxContainer	an input welded to its button
`GoCombobox`	Button	a picker that searches
`GoCodeInput`	VBoxContainer	coupon and gift codes
`GoTable`	VBoxContainer	sortable headers, selectable rows
`GoPagination`	HBoxContainer	pages, or a More row

Shapes games actually use

Class	Base	What it does
`GoRewardCalendar`	VBoxContainer	daily attendance
`GoRadar` · `GoDonut`	Control	stats at a glance
`GoCarousel`	VBoxContainer	banners and character select
`GoKbd`	HBoxContainer	key hints that do not lie

Over the screen

Class	Base	What it does
`GoDrawer`	CanvasLayer	the side panel
`GoPopover`	RefCounted	the anchored card
`GoContextMenu`	RefCounted	long-press and right-click
`GoConsole`	CanvasLayer	the developer console

Go HUD Skill

gohud ships an AI skill: the whole API, runnable templates and a preview launcher. Paste one block into your coding agent and it installs gohud and knows how to use it.

Go HUD Skill

Readability is measured, not eyeballed

"Pretty" is taste; "legible" can be measured. Faint grey text looks fine on a good monitor and disappears on a phone in daylight — picking by eye guarantees it eventually.

python3 addons/gohud/tools/check_contrast.py

Every colour pair and every button state's label over the panel it sits on is measured against WCAG, in all fourteen themes. Translucent colours are composited over their real backdrop first — measuring them directly reports a better ratio than the screen shows.

Text colours are therefore derived, not chosen: the builder takes the palette entry as a starting point and pushes its lightness until it clears the threshold on every surface it can land on. Change the palette and the contrast follows. The rules and the traps behind them →

Checks, releases and this site

One entry point runs every check; each part sees something the others cannot.

bash addons/gohud/tools/check_all.sh

Check	What it catches
`run_tests.sh` at four screen sizes	Widget behaviour and layout, RTL positions, keyboard focus, runtime skin contrast, every preset
`new_project_check.sh`	Hidden dependencies on a host project; with `--zip` the release as shipped, with `--export` a Web build
`check_contrast.py`	WCAG contrast of every theme file, button states and translucent panels included
`check_generated.py` · `check_scaffold.sh`	Generated themes match their palettes; a throwaway theme builds and passes contrast
`check_package.py`	The version taken from package.json, changelog moves and ZIP contents, in temporary copies
`check_site.py`	This site's links, anchors, page language, glossary and dial tables

Latest recorded run — 2026-09-13, Godot 4.7.2, macOS, Compatibility renderer. 438 of 438 checks at 390×844, 844×390, 768×1024 and 1280×800 in an empty project; 438 of 438 again with the GoRuntime autoload; a Web export; zero contrast failures across the six themes. Physical Android or iOS devices were not part of this run.

Release versions

cat addons/gohud/package.json       # { "version": "1.1.0" }
bash addons/gohud/tools/release.sh  # every check → ZIP → that ZIP in an empty project
bash addons/gohud/tools/package.sh  # 1.1.0 → builds/1.1.0/gohud-1.1.0.zip

The version is the one written in package.json — packaging never raises it. To release a new version, change that number first. A successful run sets plugin.cfg and GoUi.VERSION to it and, the first time that version is packaged, moves the Unreleased notes of CHANGELOG.md into a dated entry. Packaging the same version again rebuilds its ZIP and replaces the old one. A failed run changes nothing. The ZIP leaves out this website, the tests, the tools and package.json.

This site

python3 addons/gohud/tools/make_site.py            # glossary and skin-dial tables, generated from source
python3 addons/gohud/tools/check_site.py           # links, anchors, language, glossary, generated tables
bash addons/gohud/tools/site_shots.sh /tmp/shots   # desktop and phone screenshots of every page

The pages are plain HTML in www/ — English at the root, Korean in ko/. A GitHub Actions workflow publishes that folder as the site root.

Game UI, driven by one resource

New: arcade, comic, Material 3 and a look for kids

Material 3 — for app screens

Kids — the toy box

Comic — bold ink

Arcade — painted keys

Arcade: painted keys and thick boards

Every key painted

At night: arcade_dark

How the arcade look works

The face

Labels that read

Windows

Comic: bold ink and a hard shadow

Every widget, inked

At night: comic_dark

How the comic look works

One StyleBox for every face

Pressed means flat

The skin inks the rest

Windows get a caption

Readable day and night

No layout changes

Three settings and one call

What it looks like in a game

What it takes off your hands

Every measurement is a token

Visible size ≠ pressable size

Notches and keyboards

Back closes one thing

Notices never steal input

Icons are asked for by name

Fourteen looks, one line

Legible by measurement

Install gohud

Quick start

Change the look — colours and shape

Medieval collection

The same screen on a phone and on a desktop

The same sheet, a different look

Skins — where a Theme cannot reach

Widgets

Waiting, telling, counting

Forms and lists

Shapes games actually use

Over the screen

Go HUD Skill

Readability is measured, not eyeballed

Checks, releases and this site

Release versions

This site

At night: `arcade_dark`

At night: `comic_dark`