Reactive UI - Godot - VS Code (GUITKX)

Language support for .guitkx, the JSX-like markup of ReactiveUI for Godot — a React-style reactive UI library for Godot 4.x — plus a full, headless GDScript language service for your plain .gd files. Everything runs in-process via gdscript-analyzer: no running Godot editor, no TCP connection, works fully offline.

Features

• Syntax highlighting for .guitkx — hand-tuned TextMate grammar; embedded GDScript inside {expr}, setup blocks, and @if/@for conditions gets real GDScript colouring.
• Markup IntelliSense — completion and hover for tags, attributes, attribute values, directives, hooks, and events (React-style aliases like onPressed plus the verbatim on_<signal> escape hatch), plus live diagnostics for structural markup errors and dangling component references as you type.
• Formatting — the same formatter the in-Godot editor uses, configured by a Prettier-style guitkx.config.json walk-up (printWidth, indentStyle, indentSize, singleAttributePerLine, insertSpaceBeforeSelfClose); Format on Save is on by default for .guitkx. When gdformat is installed, embedded GDScript is reflowed too — semantics-guarded, so formatting never changes behavior.
• Embedded-GDScript IntelliSense — the GDScript inside your markup is projected into a synthetic virtual document with a length-preserving source map and analyzed by gdscript-analyzer, so {expr} and setup code get typed completion, hover, and go-to-definition at the exact right positions.
• Full .gd language service — with guitkx.enableGdscriptAnalysis (on by default) your plain .gd files get the analyzer's whole surface, headless: diagnostics, completion, hover, navigation, project-wide rename, formatting, semantic highlighting, inlay hints, code actions, and document symbols.
• Configurable — guitkx.enableEmbeddedAnalysis, guitkx.enableGdscriptAnalysis, and guitkx.useGdformat toggle each analysis layer independently; this extension's .gd analysis runs alongside the godot-tools extension — disable godot-tools' language server, or turn this extension's off, to avoid duplicate diagnostics.
• Shares its compiler with the in-Godot editor — the Reactive UI Editor addon is a native in-Godot .guitkx editor with the same language features; both editors share the same compiler, formatter, and diagnostic codes, and the runtime addon (reactive_ui) compiles .guitkx to plain .gd on save with hot reload (Fast Refresh).

Requirements

• None — everything ships in the extension. The language server runs on VS Code's own built-in Node runtime (no Node.js install needed), and embedded-GDScript intelligence is fully offline: no Godot editor, no TCP/language-server connection required.

Changelog

[0.11.0] - 2026-07-18

• ES modules 0.11.0 (rides the library 0.11.0 — see MIGRATION-0.11.md): plain, signature-classified declarations replace the component/hook/module wrapper keywords — Name(p) -> RUIVNode {} is a component, use_x(p) {} a hook, any other callable a util, name := expr a value export — and the import surface grows to the full ES set ({ a as b } renames, * as X namespaces, default imports/exports, deferred export { … } lists). Highlighting, the tokenizer, the workspace/declaration index, outline, live header diagnostics, markup windows, and the virtual-doc analyzer all classify the plain forms; wrapper syntax keeps working for the deprecation window with a live GUITKX2320 warning, and the new 232x diagnostics (2321 cross-guard, 2323–2327 export/import-marker errors) surface live. The TextMate grammar and schema teach the new forms; as/default/from join the keyword faces.

[0.10.3] - 2026-07-16

• Requirements corrected on both marketplace pages: there is nothing to install — VS Code runs the language server on its own built-in Node runtime, and the VS2022 VSIX bundles a Node runtime of its own. The "Node.js on your PATH" requirement was a stale pre-bundling claim.

[0.10.2] - 2026-07-16

• Extension descriptions now link the repo (github.com/yanivkalfa/ReactiveUI-Godot) and the community Discord (discord.gg/Knedqu4Wyv), so both marketplace listing pages point back to the project and its community from the very top.

[0.10.1] - 2026-07-16

• Marketplace listing overhaul: distinguishable display names — GUITKX (Godot - VS Code) / GUITKX (Godot - VS2022) — and a structured page body (Title / Description / Features / Requirements / Changelog) on both marketplaces + Open VSX.
• README.md is now generated from the centralized changelog — the page body carries the changelog inline.

[0.10.0] - 2026-07-11

• 0.10.0 imports leg: the language server understands cross-file imports. import/export are first-class syntax (no red squiggles); imported names resolve in embedded GDScript analysis via synthesized const/member stubs; the declaration index and completion are export-aware; and the compiler's frozen GUITKX2300–2309 import diagnostics surface from the .guitkx.diags sidecar (schema v3). Imports are OPTIONAL syntax — projects without them stay green.

[0.9.0] - 2026-07-11

• 0.9.0 naming loyalty (BREAKING, rides the library 0.9.0 — see MIGRATION-0.9.md): the language vocabulary is now 1:1 the official Godot names. Tags = class names (shorthands like VBox/Panel removed; ANY instantiable ClassDB Node class is now a valid tag, validated against the bundled dump); factories = V.ClassName verbatim; events = on + PascalCase(signal) derived for EVERY signal from ClassDB (the React alias table is gone — completions, hover, signature help and semantic tokens all speak onPressed/onValueChanged); style-key completion = the exact Godot property/theme/StyleBoxFlat names. Removed pre-0.9 tags get a precise "renamed in 0.9.0: use " diagnostic instead of a generic did-you-mean.

[0.8.8] - 2026-07-10

• Picks up the runtime compiler's markup brace-matching fix (see its CHANGELOG.md for full detail): a parenthetical comment split across two #/## lines inside a component/directive body's setup code no longer desyncs delimiter matching -- previously it surfaced as a bogus GUITKX0304 "unclosed component body" anchored at the component's own {, far from the offending comment, in both editors' live diagnostics. Body content mode is now tracked per delimiter-stack level with per-line classification: setup statements (and their # comments) scan as GDScript, markup-shaped lines and return ( ... ) windows keep markup lexis (a literal # in element text stays literal). The same fix covers keyword bait ("# early return (see docs") and # comments inside multi-line array literals. Also faster markup parsing on large files: the parser's per-element line lookup is now a binary search over a prebuilt line-start table instead of an O(n) scan per element -- this runs on every keystroke.

[0.8.7] - 2026-07-06

• Picks up a batch of compiler/formatter correctness fixes from the runtime addon (see its CHANGELOG.md for the full detail): markup-lexis brace/paren matching, so a literal # in element text (e.g. "Score #3") or a markup comment (////* *//<!-- -->) containing }/) can no longer miscount the delimiters the compiler uses to find a component/directive body or a return ( ... ) window -- previously a silent miscompile risk, not just a parse error. The formatter no longer re-indents or collapses spaces inside a triple-quoted string's interior, and no longer drops interior blank lines when re-anchoring a directive body's prep code. A handful of smaller hardenings: a truncated closing tag at the very end of a window now fails cleanly instead of scanning past it; format() now reports when it fell back to verbatim (a syntax error) instead of looking identical to "nothing to format" -- surfaced as a one-time warning per file in both editors.
• The embedded-GDScript reflow safety net (BUG-1) now treats comments as part of the token stream it compares before and after reflowing -- a gdscript-fmt bug that deleted or mangled a comment used to normalize identically to the original (both "nothing"), so the guard called it safe and applied the reflow anyway, silently deleting the comment. A dropped or mangled comment is now rejected exactly like any other structural change; trailing whitespace inside a comment still doesn't count.
• guitkx.* settings (enableEmbeddedAnalysis, useGdformat, enableGdscriptAnalysis) now apply live: the language server re-reads them on a workspace/didChangeConfiguration notification instead of only once at startup, so a toggle no longer needs a server restart to take effect. enableGdscriptAnalysis is also now enforced server-side across every request handler (VS2022 previously had no way to actually turn off plain-.gd analysis at all -- the option was persisted but silently unenforced; VS Code already gated it client-side by not registering the .gd document selector).
• A closed file's diagnostics no longer linger in the Problems panel until it's reopened. .guitkx typing defaults (both editors) now match the formatter's canonical spaces-at-2 style -- previously tabs/4, which meant every hand-typed line got rewritten by the next format-on-save. The shipped package no longer bundles the language server's compiled test code (pure size, never needed at runtime).
• Toggling guitkx.enableGdscriptAnalysis now takes effect immediately -- the language client rebuilds itself with the new .gd document selector -- instead of silently doing nothing until the window was reloaded.

[0.8.6] - 2026-07-04

• Folder deletions now reach both diagnostic tiers. Deleting a component's folder removes its compiled outputs along with it, so nothing looked stale and the dangling-reference check (GUITKX2107) waited for an unrelated save or editor focus-in -- the addon's watch poll (0.8.2) now goes hot on a sidecar-state mismatch instead of only on stale mtimes. Separately, the extension's folder-delete handling shipped in 0.8.5 was correct but unreachable: the dynamic watcher registered per-extension file globs, and VS Code only delivers folder-delete events to a pattern that matches the folder path itself. Watcher registration is now a single ** glob.

[0.8.5] - 2026-07-04

• Deleting a component's whole folder now evicts everything under it. VS Code coalesces a bulk delete into one folder-level event, which previously only closed each file's analyzer library -- the .guitkx index entries and their harvested generated classes survived, so the component never left the project universe and no squiggle ever appeared. The folder-deleted path now evicts every indexed .guitkx under it, un-harvests every generated class under it (path keys normalized, since the harvest source and the delete event spell paths differently), and re-validates open documents -- including the reverse case, a moved-in folder clearing stale squiggles.
• Single-file deletions un-harvest the generated sibling's class immediately instead of waiting ~2 seconds for the Godot addon's own orphan sweep to delete the .gd and produce a second event -- the squiggle now lands on the watcher tick, not on the compiler's schedule.

[0.8.4] - 2026-07-04

• Deleting a component whose tab is open now squiggles its consumers immediately. The index refused to touch files with open buffers -- right for edits (the buffer is the source of truth), wrong for deletions: VS Code keeps a deleted file's tab alive, so the component never left the index and dangling references stayed clean until some unrelated save. Deletions now evict regardless; re-saving the open buffer recreates the file and re-indexes it right back.

[0.8.3] - 2026-07-04

• Deleting/renaming a component now squiggles its dangling references live. Two fixes: the server re-validates every open document when the component universe changes (previously only the edited file itself recomputed diagnostics, so a deletion elsewhere never updated your open tabs), and generated .gd classes are un-harvested when their file vanishes (the class-name set was grow-only, which permanently suppressed the unknown-component check for anything that had ever existed). Pairs with the addon's GUITKX2107 compile-tier error. (Server 0.8.3.)

[0.8.2] - 2026-07-04

• Compiler errors now reach VS Code after the save. The Godot addon's watch poll compiles a saved .guitkx ~2 seconds after the save and writes its verdict into the .diags.json sidecar -- but the server never watched sidecars, so a compiler-only error (e.g. GUITKX0105: unknown element in setup-value markup, which the live tier doesn't scan yet) could never become a squiggle: the save-time validation read the previous sidecar, and the next keystroke hash-diverges the buffer, which suppresses compiler entries by design. The server now watches **/*.guitkx.diags.json and re-validates the matching open document the moment Godot writes or clears a verdict. Smoke-pinned. (Server 0.8.2.)

[0.8.1] - 2026-07-04

• Fixed bogus GUITKX0108 ... (got 3) on correct directive bodies. A pre-0.8 live scanner pass still parsed directive bodies as bare markup, counting the return ( / ) lines as extra roots -- every correctly-migrated body squiggled as a multi-root error. The scanner now walks only each return's markup span (the same body model the compiler and formatter use), which also stops body prep code (if a < b: ...) from ever false-flagging GUITKX0300 or polluting duplicate-key scopes. Correct bodies are now diagnostic-free; the smoke suite pins it. (Server 0.8.1; pairs with addon 0.7.1's watcher liveness rework.)

[0.8.0] - 2026-07-04

• Directive bodies are code blocks (pairs with addon 0.7.0, BREAKING): prep GDScript + return ( <markup> ) in every @if/@for/@while/@case body, recursively -- full Unity-parity. The old bare-markup body flags GUITKX2103 live with the migration message; a hook call inside a body flags GUITKX2104. Markup in prep values (var badge = ( <HBox/> )) gets full intelligence.
• Format-on-save ships enabled for .guitkx (defaultFormatter bound, tab size 2, spaces) -- the formatter emits the Unity-exact spaces-2 canonical style, embedded GDScript reflowed to the same unit.
• Fixed a reformat corruption: nested code at spaces-2 could lose a level (a return dedented out of its if) because the indent unit was inferred from the base offset; all three reindenters now infer from the step between indent widths.

[0.7.1] - 2026-07-03

• Enter after a closing tag no longer over-indents. The increase-indent rule matched any line ending in > -- </VBox> included -- so a new line after a closing tag gained an extra level; it now aligns with the tag itself. Opening tags, multi-line opening tags, and /> self-closers indent exactly as before.
• Pairs with addon 0.6.1 (root CHANGELOG): the compiler vocabulary is embedded in the addon and held compiles auto-retry, so the GUITKX2507 cold-open wall -- and the stale "unknown element" sidecar squiggles it pinned in VS Code -- can no longer occur.

[0.7.0] - 2026-07-03

• Early markup returns (pairs with addon 0.6.0): if not ready: return ( <Label /> ) is legal guitkx now, React-style -- and the guard's markup gets full live intelligence: parse errors, unknown-tag did-you-means, key checks, highlighting, everything the final return has.
• An unconditional early markup return dims the dead code after it (including the unreachable final return), exactly like the Unity toolchain.
• The "a component's setup cannot return before the final markup return" error is gone; GUITKX2102 now only means "the final return isn't markup".
• Diagnostics docs page gains the GUITKX2102 and GUITKX2508 reference rows.

[0.6.1] - 2026-07-03

• Fixed the host-tag storm: , , and every vocabulary alias no longer squiggle as "unknown component" once the workspace scan completes; a typo'd host tag now gets a did-you-mean for the host tag itself.
• An early markup return (return <s></a> before the final return) no longer sprays four bogus embedded-GDScript errors over the line. It shows the real thing instead -- a live GUITKX2102 with honest wording (only returning markup early is banned; return null guards are fine) that appears and clears as you type, Godot editor open or not.
• Garbage directive headers (@for (i in 2: int5)) flag live as GUITKX2508 (new, mirrored in the compiler) instead of passing silently into an invalid generated .gd.
• Stale compiler-sidecar diagnostics collapse into one file-level note while you edit -- they used to pile up at drifted offsets and never clear without the Godot editor recompiling.
• Packaging: prepublish now verifies the bundled server is complete and current; a publish without a fresh bundle could previously ship a server that died on startup.
• Pairs with addon 0.5.1 (root CHANGELOG): the ~250-line red wall on a cold Godot editor open is two warning lines now, with generated outputs preserved and quiet self-healing.

[0.6.0] - 2026-07-03

• Diagnostic codes renumbered onto the Unity-shared table (addon 0.5.0): most visibly, unreachable-after-return dimming is now GUITKX0107 (was 0114), missing-declaration is GUITKX2101 (was 0102), and duplicate keys (GUITKX0026, was 0113) are errors.
• Bundles gdscript-analyzer 0.6.0: embedded-GDScript diagnostics now use Godot's own verbatim message texts (probed against the real 4.7 binary), calls with the wrong number of arguments or a definitely-wrong argument type are errors, unused/unreachable code dims in the editor, every analyzer diagnostic carries a real code with a link to its reference page, and the warning profile matches the engine's defaults.
• Names declared in sibling .guitkx files feed the analyzer as virtual libraries: cross-file references resolve on a fresh clone, a typo'd usse_state is an error again, and a broken lambda initializer shows its syntax error instead of a false UNDEFINED_IDENTIFIER on later uses.
• Unknown PascalCase component tags squiggle live with a did-you-mean, checked against the full project (.guitkx bindings + class_name scripts) once the workspace scan completes.

[0.5.5] - 2026-07-02

• Bundles gdscript-analyzer 0.5.4: a typo'd method on a built-in value — sliced[1].casll(1) on a useState pair, s.upper() on a String (a Godot-3 rename), v.zzz on a Vector2 — is now an error with a precise squiggle, exactly where Godot itself errors. Works through plain untyped var s = useState(0) locals (the analyzer narrows single-assignment locals to their initializer's type), and Dictionary d.key sugar now types as the value and can never false-flag.

[0.5.4] - 2026-07-02

• A typo'd hook call (usseState(0)) is now flagged live as an error, mapped onto the typo. The bundled analyzer (0.5.3) proves a name is defined nowhere only when it holds the whole project: the server feeds every .gd at startup, keeps the view current through a file watcher (created/edited/deleted files and folders, plus project.godot autoload changes), and re-checks open files once armed. Names declared only in a sibling .guitkx (whose generated .gd isn't on disk yet) are never false-flagged.
• GUITKX0108 (a @for/@while body with more than one root element) and GUITKX0102 (a component with no return ( ... )) now fire live while typing, precisely ranged — previously they appeared only after a save, pinned to line 1 via the compiler sidecar.
• useState/useReducer/useTransition returns are now typed pairs end-to-end: s := useState(0) makes s[1] a checkable Callable (hover, inlay hints, and future setter-typo checking), via ## @return-tuple(...) tags in hooks.gd and real wrapper-func hook stubs in the virtual document. Hook declarations also keep their parameters and -> Hint in the analysis view, so hovering or navigating a hook parameter works.
• Fixed a formatter/compiler regression family around indentation anchoring: one outlier-shallow setup line, or an over-indented leading comment, no longer shifts the rest of the block (which produced an invalid generated .gd and could dedent an if body during Format Document). Module members are analyzed under their real names, so a sibling component's bare call to a module-local hook resolves.

[0.5.3] - 2026-07-02

• Formatting a .guitkx file now normalizes embedded GDScript indentation to real tabs by depth. A nested setup line — most visibly a lambda body — could previously come out as a tab followed by spaces (\t ), which renders like two tabs but is a byte-level tab/space mix; the formatter now re-indents it to clean tabs, matching the compiler's _reindent_setup. Applies to component setup and hook bodies.
• A misspelled declaration keyword no longer blacks out the rest of the file. The language server now recovers a near-miss component/hook/module header (e.g. comssponent Foo {) for analysis, so markup diagnostics, embedded-GDScript checks, tag highlighting, and completion keep working while you fix the typo — instead of every other error silently vanishing. Markup diagnostics are also resilient to a malformed tag now: one bad < a> no longer collapses the whole component's markup window. And a misspelled @class_name directive (e.g. @clasaas_name) is flagged as GUITKX0300 with a did-you-mean, instead of being silently ignored.

[0.5.2] - 2026-07-02

• A misspelled declaration keyword (e.g. comssponent instead of component) or an invalid @class_name value is now reported live — GUITKX0102 / GUITKX0300 — instead of silently blacking out the whole file. Previously the editor skipped ALL analysis whenever it could not find a valid component/hook/module header, so one typo in the header made every other error (and hover/completion) vanish with no indication why. A < followed by whitespace inside markup is also flagged live now as an invalid tag name.

[0.5.1] - 2026-07-02

• .guitkx files that mix tabs and spaces in a component's setup — a tab followed by spaces renders identically to tabs, so the difference is invisible in the editor — no longer trigger a spurious Mixed use of tabs and spaces / expected a declaration error cascade. The embedded-GDScript virtual document now normalizes setup indentation by depth (a tab and the inferred space-unit each count as one level), matching the compiler.

[0.5.0] - 2026-07-01

• Hooks are now camelCase (React parity): completion, hover, go-to-definition, and the embedded-GDScript virtual document all use the camelCase names — useState, useEffect, useRef, useMemo, useContext, createContext, … (23 hooks). Existing snake_case hook code must be migrated (a snake→camel rename over the 23 hook names).
• Hovering a hook now shows its signature — e.g. useState(initial) → [value, setter] — instead of a bare Callable. Host-element hover drops the internal V.* factory detail and keeps the Godot class reference.
• Unreachable code after a component's return (...) is now dimmed (faded) live, the same way dead code is shown for GDScript — via an Unnecessary-tagged diagnostic.
• Duplicate-key detection now covers expression keys (key={ str(i) }), not only literal key="x" — two siblings sharing the same key expression collide on every iteration.
• The markup parser now reports a < followed by whitespace (e.g. < a>) as an invalid tag name, instead of silently treating it as a fragment plus an attribute.

[0.4.0] - 2026-07-01

• Event handlers in .guitkx now use React-style camelCase names — onClick, onChange, onSubmit, onFocus, onBlur, onPointerDown/onPointerUp/onPointerEnter/onPointerLeave, onResize — and the editor understands them everywhere: completion offers the right events per control, hover shows the underlying Godot signal and its argument signature, signature help fires inside the handler, unknown-attribute validation accepts them, and they are semantically highlighted as events. onChange is polymorphic — it is offered for (and binds to) whichever value/selection signal the control actually exposes (text_changed, value_changed, item_selected, tab_changed, or toggled). The native on_<signal> spelling is still recognized as an escape hatch to any Godot signal.
• Prop spread {...obj} is now recognized in markup: it is highlighted, never flagged as an unknown attribute, and preserved (and kept idempotent) by the formatter — matching the compiler, which merges a spread with explicit props left-to-right (later wins), on both host elements and components.

[0.3.1] - 2026-07-01

• Hover, completion, and go-to-definition now work for embedded GDScript in a component's setup block (the lines before return (...)). They were returning nothing — including hooks like use_state — because the setup region's source map was dropped on CRLF files or when the block ended in a blank line; it is now mapped line by line.
• Hover in markup now resolves the full identifier under the cursor against host elements, your own components, and the host element's ClassDB properties and signals. Previously it only matched a host tag at the exact end of its name, so attributes (text, separation, on_pressed, …) and component tags hovered to nothing. A component tag's hover also shows its parameter signature.
• Completion now fires at a blank markup position — an empty child slot or inside an @for/@if body — and offers your project's components as <Tag> suggestions. Those positions were being misread as embedded GDScript, so nothing was offered.
• Go-to-definition, find-references, and rename now work from a component's <Tag> usage (including with the cursor on the opening <), from the component declaration name, AND from its @class_name directive — previously F12 / ctrl+click on the declaration or the @class_name reported 'no definition found' and find-references came up empty. A GDScript comparison such as a < Name is never mistaken for a tag.
• Renaming a component that declares @class_name now rewrites the @class_name directive, the declaration, and every <Tag> usage together. It previously left @class_name stale, so the renamed usages reported a dangling GUITKX0105 'unknown element' error.
• Embedded GDScript inside .guitkx is now semantically highlighted by the analyzer (type-aware), the same way a real .gd file is, instead of grammar-only colouring.
• Embedded GDScript inside .guitkx is now formatted by the bundled analyzer — the same gdscript-fmt that formats plain .gd files — so a snippet formats identically in a .gd and in .guitkx. The optional external gdformat dependency is gone.
• Pressing Enter after a multi-line opening tag (the <Label line, with its attributes on the following lines) now indents the attributes one level instead of jumping back to the tag's column; the line after a self-closing /> outdents back.

[0.3.0] - 2026-06-30

• The extension now drives plain .gd files through gdscript-analyzer, not just .guitkx markup: diagnostics, completion, hover, go-to-definition, project-wide find-references and rename, signature help, inlay hints, code actions, document symbols, formatting, and semantic highlighting, all headless with no running Godot editor. It is ON by default; the new guitkx.enableGdscriptAnalysis setting turns it off. Because it runs alongside the godot-tools extension, disable godot-tools' language server to avoid duplicate diagnostics on .gd files.
• Embedded GDScript inside .guitkx now also gets find-references, project-wide rename (correct-or-refuse), signature help, inlay hints, and code actions, on top of the existing completion, hover, diagnostics, and go-to-definition.
• Upgraded the bundled GDScript analyzer to 0.5.2, which exposes GDScript formatting and semantic highlighting, now wired for .gd via Format Document and semantic tokens.

[0.2.6] - 2026-06-28

• Go-to-definition now resolves across files fully offline (no running Godot editor): a library symbol such as a hook's use_ref now jumps to its real implementation in core/hooks.gd, landing on the declaration in that file. Previously only same-file symbols resolved headlessly; cross-file navigation required a running Godot editor.
• Upgraded the bundled GDScript analyzer to 0.4.0: navigation and diagnostics now cross the extension boundary as native objects, and each navigation target reports its file directly, making cross-file go-to-definition faster and more robust.

[0.2.5] - 2026-06-27

• Embedded-GDScript intelligence (completion, hover, and go-to-definition inside {expr}/setup blocks) is now analyzed in-process by gdscript-analyzer, with no running Godot editor or TCP connection required, so it works fully offline. Go-to-definition now resolves same-file symbols (the previous Godot-proxy path could not). The guitkx.enableGodotProxy and guitkx.godotLanguageServerPort settings are replaced by a single guitkx.enableEmbeddedAnalysis toggle (the legacy enableGodotProxy value is still honored for back-compat).
• Embedded-GDScript type and parse diagnostics (e.g. integer division, type mismatch, syntax errors) now surface as squiggles inside {expr}/setup blocks, mapped back into the .guitkx source. Unresolved library/cross-file symbols never warn (the analyzer treats them as the Unknown seam), so this adds real diagnostics with no false positives.
• The VS Code extension now ships as platform-specific .vsix packages (one per OS/arch), so the bundled native analyzer always matches the user's machine — no manual setup, no node on PATH, fully offline.

[0.2.4] - 2026-06-22

• Formatting: an authored blank line at the start or end of a component/hook setup block is now preserved (it was being stripped), and runs of 2+ spaces in embedded GDScript are collapsed to one outside strings/comments (e.g. if x == null becomes if x == null).
• Diagnostics: an unknown element (GUITKX0105) and an unknown host attribute (GUITKX0107) are now reported as Errors (a red squiggle) instead of a faint hint / a warning.
• Completion: style-dict keys (bg_color, corner_radius, pad, separation, expand_h, font_size, the theme channels, the per-state slots, …) are offered inside a style={ {…} } (or *_style) dictionary; common built-in constants (Color.WHITE, Vector2.ZERO, …) complete after Type.; and go-to-definition on an embedded GDScript symbol now forwards to Godot's language server (jumping to the library .gd, e.g. use_ref → core/hooks.gd) when the editor is running.
• Pressing Enter after a self-closing tag (<Label … />) no longer indents one level too deep (the indentation rule was matching any line ending in >, including />).

[0.2.3] - 2026-06-22

• Formatting now always uses tab indentation for .guitkx (the embedded GDScript requires tabs, and the compiler emits tabs), so the markup and the embedded setup no longer mix indentation units — previously, with an editor configured for spaces, a deeper setup line kept its authored tab and produced a "2 spaces + tab" indent. Diagnostics: unknown attributes on a host element are now flagged (e.g. a typo'd te / xt on <Label>) with a did-you-mean suggestion, validated against the bundled Godot ClassDB property + signal data; component tags (which take arbitrary props) are not flagged, and the check is skipped when the ClassDB dump is unavailable so it never false-flags.
• Formatter configuration: a project guitkx.config.json (Prettier-style walk-up, the analogue of ReactiveUIToolKit's uitkx.config.json) now overrides the formatter — printWidth, indentStyle ("tab" | "space"), indentSize, singleAttributePerLine, insertSpaceBeforeSelfClose. Tab indentation is the default when no config is present.

[0.2.2] - 2026-06-22

• Fixed the published VSIX shipping without its vscode-languageclient runtime dependency (a vsce package --no-dependencies bug — there is no bundler in the pipeline, so the flag dropped the dependency), which made the extension fail to activate: no formatting, completion, or hover. The dependency is now bundled. Also added the missing onLanguage:guitkx activation event, editor defaults for .guitkx (format-on-save + the GUITKX document formatter + tab indentation), and a "Restart Language Server" command.

[0.2.1] - 2026-06-22

• Renamed the extension to just "GUITKX" (it was "GUITKX (ReactiveUI for Godot)", which truncated to "GUITKX (React..." in the editor UI) and added the Godot logo as the extension / marketplace icon.

[0.2.0] - 2026-06-22

• Formatter: components whose render is guarded by an early return null (e.g. if not ready: return null before the real markup return) are now formatted instead of being left verbatim, and the multi-attribute wrap path honors the insertSpaceBeforeSelfClose option (it previously always inserted the space).
• Language server: hover and completion inside a hook body now map to the correct embedded-GDScript offset (the body is no longer mis-mapped after re-indentation); a <>...</> fragment no longer raises a false GUITKX0104 duplicate-key warning across its siblings; and parameter completion is now noncode-aware, so a string default containing a comma or colon (e.g. label: String = "a, b") no longer drops the parameters declared after it.
• find-references and rename now use the exact jsx-as-value keyword boundaries the compiler uses (return / else / and only), so they never edit a <Name that the compiler reads as a less-than comparison (e.g. after if, in, not, await, yield, or or).
• Control-flow inside an embedded expression that cannot be lowered to an expression (@while / @match) now reports GUITKX0113 through the compiler-diagnostics sidecar; @if/@elif/@else and @for inside a {expression} or a lambda now compile correctly (inline ternary / .map).
• Fixed file-path resolution on Linux/macOS: go-to-definition and the compiler-diagnostics sidecar no longer drop the leading slash when converting a file:// URI to a filesystem path (the POSIX path was previously relative, so cross-file reads failed).

[0.1.0] - 2026-06-21

• Initial release. Syntax highlighting and language intelligence for .guitkx markup (ReactiveUI for Godot): a self-contained TextMate grammar that colors both the JSX-like markup and the embedded GDScript; markup completion and hover for host-element tags, structural/common attributes, control-flow directives (@if/@elif/@else/@for/@while/@match/@case/@default) and per-element event handlers, served from the bundled schema; and embedded-GDScript completion/hover forwarded to Godot's built-in GDScript language server (TCP, engine port 6005) through a synthetic virtual .gd document with a length-preserving source map. Structural diagnostics (unbalanced braces) ship today; the Godot proxy degrades gracefully when the editor is not running so the markup features always work.
• VS Code extension drives the TypeScript language server over stdio; configurable via guitkx.godotLanguageServerPort and guitkx.enableGodotProxy. Packages to a self-contained .vsix (the Node server is bundled, no runtime to install).