Skip to content

Releases

v0.23.1

v0.23.1 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 20 Nov 18:33
354e9da

Runic editor extensions 0.23.1

A patch release for the Visual Studio Marketplace only: no functional change to
either extension. The 0.23.0 release
reached the VS Code Marketplace, but the Visual Studio Marketplace refused its
VSIX: VsixPublisher requires the extension's description to be shorter than 280
characters (VsixPub0024), and 0.23.0's had 387. The 0.23.0 VSIX is attested
in its GitHub release and can't change, so 0.23.1 carries the shorter
description. The full description stays in the Marketplace overview.

Asset Extension Version
runic-devkit.vsix VS Code, Runic DevKit (runic-artifex.runic-devkit) 0.23.2000
runic-devkit-vs.vsix Visual Studio 2026, Runic DevKit (RunicArtifex.DevKit.VisualStudio) 0.23.1.1000
SHA256SUMS sha256sum lines of both VSIX files

Visual Studio

  • A Marketplace description under 280 characters. The VSIX manifest's
    description is shortened from 387 to 267 characters; it still says what
    Runic DevKit is and that it replaces Runic MF2 Translations.
  • The release checks it before publishing. package.py --check-source
    (CI) and the release workflow's candidate job, also in a dry run, now refuse
    a Visual Studio VSIX whose description is missing or 280 characters or
    longer, before anything is published.

VS Code

Unchanged. The VS Code Marketplace keeps 0.23.0 (0.23.1000); 0.23.1 is not
published there. This release's runic-devkit.vsix (0.23.2000) has the same
features as 0.23.0's; install either.

Stores

Runic DevKit for Visual Studio is on the Visual Studio Marketplace as
runic-artifex.runic-devkit-vs
(0.23.1.1000), published from this release's VSIX by trusted publishing.
Runic DevKit for VS Code stays on the VS Code Marketplace as
runic-artifex.runic-devkit
(0.23.1000). Runic DevKit isn't on Open VSX: in VSCodium, Cursor or Windsurf,
install runic-devkit.vsix from this release or 0.23.0.

Both extensions are still tested with dotnet-runic-translations 0.15.1, as in
0.23.0.

Verifying

sha256sum --check SHA256SUMS
gh attestation verify runic-devkit.vsix -R Runic-Artifex/runic-editors \
  --signer-workflow Runic-Artifex/runic-editors/.github/workflows/release.yml
gh attestation verify runic-devkit-vs.vsix -R Runic-Artifex/runic-editors \
  --signer-workflow Runic-Artifex/runic-editors/.github/workflows/release.yml

What's Changed

Full Changelog: v0.23.0...v0.23.1

v0.23.0

v0.23.0 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 20 Nov 18:01
f541f74

Runic editor extensions 0.23.0

Part of the Runic 0.23 release train: it belongs to
Runic Translations 0.15.1
and Runic SDK 0.23.0.
Runic DevKit leaves preview: neither Marketplace listing carries the Preview label
any more. Install Runic DevKit from the VS Code Marketplace or the Visual Studio
Marketplace, or a VSIX from this release (see Stores below).

Asset Extension Version
runic-devkit.vsix VS Code, Runic DevKit (runic-artifex.runic-devkit) 0.23.1000
runic-devkit-vs.vsix Visual Studio 2026, Runic DevKit (RunicArtifex.DevKit.VisualStudio) 0.23.0.1000
SHA256SUMS sha256sum lines of both VSIX files

No Preview label

Runic Translations 0.15 completes the language server's production work
(large-catalog budgets in CI, a compatibility promise for its standard surface
and the runic protocol), so both extensions are published without the
Marketplace "Preview" label (runic-editors#50). Before 1.0, a minor release can
still change commands and settings; the release notes list every change.

Both extensions

  • Frontend errors as problems. With dotnet-runic 0.23, dotnet runic dev
    prints each Vite error as an MSBuild-form RUNICP008 line and a clear line
    once the modules compile again. Both extensions show these errors as problems
    (the Error List in Visual Studio, Problems in VS Code) at their file and line,
    and remove them at the clear line. A successful .NET build no longer removes a
    .tsx error. RUNICP codes link to runic-sdk's diagnostics reference
    (runic-editors#52).
  • The forced stop reaches dev. When dotnet runic dev doesn't stop on its
    input within 10 seconds, it is ended by force. Off Windows, VS Code now signals
    the whole process group of the dotnet launcher, so dev, its frontend
    server and its Window end too; before, only the launcher was killed
    (runic-editors#53). On Windows, Visual Studio's job now also holds processes
    dev started before the job was assigned, and taskkill /T runs before the
    job is ended, so none of them is left running (runic-editors#58).

Visual Studio

  • Visual Studio closes while a page attach is stuck. Debug the Window and
    Attach to the Page now start the JavaScript debugger with a js-debug attach
    configuration (IVsDebugger4.LaunchDebugTargets4), which returns at once,
    instead of Process2.Attach2, whose nested wait kept Visual Studio from
    closing when the attach never completed. If the attach doesn't complete within
    60 seconds, or Visual Studio starts closing, DevKit ends the waiting adapter.
    JavaScript adapters left over from an earlier Visual Studio are ended before
    an attach (runic-editors#44).
  • Break All in Debug the Window stops only the .NET Window. While Debug the
    Window debugs a WebView2 Window and its page, Debug → Break All breaks the
    Window's .NET process alone. The page keeps running and its breakpoints still
    stop it. Visual Studio no longer repeats "The script document cannot be
    opened" (runic-editors#43).
  • The page attach uses 127.0.0.1 and checks the port's owner. The attach
    never falls back to localhost, which can resolve to [::1]. Before it
    attaches, DevKit checks that the DevTools port belongs to the Window, a
    process the Window started, or a process of yours started after the Window.
    When another program holds the port (such as CS-WebUI's fixed 9225), the
    attach stops and names that program. Attach to the Page no longer offers an
    endpoint that the dev session lists as unavailable.
  • The language server asks before it starts outside the solution. A tool
    manifest in the open solution's folder starts the Translations language
    server as before. For a manifest anywhere else (above the solution, or for a
    document opened without a solution), DevKit first asks whether you trust that
    folder, because dotnet uses its global.json, NuGet configuration and tool
    manifest. A Yes is remembered for the folder. After a No, Tools → Runic →
    Restart Language Server
    asks again. VS Code already runs only in trusted
    workspaces.
  • Known limits name the remaining case of the WebView2 spike
    (runic-sdk#1192). A C# breakpoint hit while the page has the focus makes the
    page's DevTools endpoint and input wait until Continue. Visual Studio doesn't
    hang.

Runic Translations

Both extensions are tested with dotnet-runic-translations 0.15.1 from NuGet
(the repository's tool manifest), which fixes a flaw in 0.15.0's pack loading
(GHSA-24g5-pcc5-4fg7).
The 0.15 language server speaks only protocol 2,
which Runic DevKit has asked for since 0.22, so runic-editors 0.21 and earlier
can't use it. Workspaces on Translations 0.14.0 keep working. The bundled
runic.json schema is unchanged. Use the version of the project's
Runic.Translations packages:

dotnet tool install dotnet-runic-translations --version 0.15.1

Stores

Runic DevKit for VS Code is on the VS Code Marketplace as
runic-artifex.runic-devkit
(0.23.1000). Runic DevKit for Visual Studio is on the Visual Studio Marketplace
as runic-artifex.runic-devkit-vs
(0.23.0.1000), which gets final versions only. Both are published from this
release's VSIX files by trusted publishing. Runic DevKit isn't on Open VSX: in
VSCodium, Cursor or Windsurf, install runic-devkit.vsix from this release.

Verifying

sha256sum --check SHA256SUMS
gh attestation verify runic-devkit.vsix -R Runic-Artifex/runic-editors \
  --signer-workflow Runic-Artifex/runic-editors/.github/workflows/release.yml
gh attestation verify runic-devkit-vs.vsix -R Runic-Artifex/runic-editors \
  --signer-workflow Runic-Artifex/runic-editors/.github/workflows/release.yml

The release workflow takes both VSIX files from the successful CI run of the
released commit and checks them by hash before attesting them. A store-only
dispatch now publishes the files of an existing GitHub release after checking
their hashes and attestations.

What's Changed

  • Release: VsixPublisher restores on Windows; a store-only dispatch publishes the existing release's VSIX by @ViktorJannicke in #45
  • Release: exchange the Marketplace OIDC token ourselves for the Visual Studio job (VsixPub0047) by @ViktorJannicke in #46
  • Release: VsixPublisher from VSSDK 18.11.1098 (18.12.1606 lacks the MSAL binding redirects, VsixPub0031) by @ViktorJannicke in #47
  • Docs: Runic DevKit for Visual Studio is on the Visual Studio Marketplace since 0.22.0 by @ViktorJannicke in #48
  • Record the 0.22.0 release; main is 0.23.0 by @ViktorJannicke in #51
  • Visual Studio: attach the page without trapping Visual Studio's close (editors#44) by @ViktorJannicke in #54
  • Visual Studio: Break All in Debug the Window stops only the .NET Window (editors#43) by @ViktorJannicke in #55
  • DevKit: the forced stop reaches dotnet runic dev, not only its launcher (editors#53) by @ViktorJannicke in #56
  • DevKit: dev's frontend errors (RUNICP008) as problems, cleared at their clear line (editors#52) by @ViktorJannicke in #57
  • Visual Studio: the dev job takes children started before it, and taskkill runs first (editors#58) by @ViktorJannicke in #59
  • DevKit: the page attach uses 127.0.0.1 and checks who holds the port by @ViktorJannicke in #60
  • Visual Studio: ask before starting the language server outside the open solution by @ViktorJannicke in #61
  • Runic DevKit drops the Preview label (#50) by @ViktorJannicke in #62
  • Docs: DevKit Known limits names the page wait during a C# break by @ViktorJannicke in #63
  • Translations 0.15.0: the tool pin and the supported versions by @ViktorJannicke in #64
  • Translations 0.15.1: the tool pin and the supported versions by @ViktorJannicke in #65
  • Release 0.23.0 by @ViktorJannicke in #66

Full Changelog: v0.22.0...v0.23.0

v0.22.0

v0.22.0 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 19 Nov 05:15
bab8f78

Runic editor extensions 0.22.0

Part of the Runic 0.22 release train: it belongs to
Runic Translations 0.14.0
and Runic SDK 0.22.0.
Runic DevKit for Visual Studio reaches parity with VS Code in this release. Install
Runic DevKit from the VS Code Marketplace or the Visual Studio Marketplace, or a
VSIX from this release (see Stores below).

Asset Extension Version
runic-devkit.vsix VS Code, Runic DevKit (runic-artifex.runic-devkit) 0.22.1000
runic-devkit-vs.vsix Visual Studio 2026, Runic DevKit (RunicArtifex.DevKit.VisualStudio) 0.22.0.1000
SHA256SUMS sha256sum lines of both VSIX files

Both extensions are Runic DevKit

Both extensions are now named Runic DevKit and have new identities, the ones
they will keep on the VS Code Marketplace and the Visual Studio Marketplace
(D070.5):

Editor Until 0.21 Since 0.22
VS Code Runic, runic-artifex.runic, runic.vsix Runic DevKit, runic-artifex.runic-devkit, runic-devkit.vsix
Visual Studio 2026 Runic MF2 Translations, Runic.Artifex.Translations.Rmf2, runic-translations-visualstudio.vsix Runic DevKit, RunicArtifex.DevKit.VisualStudio, runic-devkit-vs.vsix

Command IDs (runic.*), settings, views and command titles are unchanged. Each
editor installs Runic DevKit next to the former extension, so uninstall the
former one
: while both are installed, both register the same commands and start
a language server for the same files.

  • VS Code: on activation Runic DevKit finds Runic (runic-artifex.runic) and
    the older Runic MF2 Translations (runic-artifex.runic-translations) and offers,
    in one notification, to uninstall them; then reload the window. See Moving from
    Runic or Runic MF2 Translations
    .
  • Visual Studio: when a solution is open, Runic DevKit finds Runic MF2
    Translations through the extension manager and shows an InfoBar: Extensions >
    Manage Extensions > Installed
    , select Runic MF2 Translations, Uninstall,
    restart. Keyboard shortcuts assigned to the former Tools-menu commands need to
    be assigned again. See Moving from Runic MF2
    Translations
    .

VS Code

With Translations 0.14, the Translations refactorings use F2 and the light bulb:
F2 renames inputs ($name) and slot references (ref=) as well as resources and
MF2 locals, and the light bulb offers Extract group on a group's name and
Inline into ../en.rmf2 in a feature-local resource. The palette commands
remain and open the same rename box or code action; with Translations 0.13 they
work as in 0.21. A resource rename in a workspace with application sources asks
first (Rename in resource sources or Cancel). When the server rejects a
light-bulb refactoring as outdated (files changed between the code action and
its resolve, such as a save's file-watcher event), the extension resolves it
once more and, if it is still outdated, shows a warning instead of applying
nothing (runic-editors#32). In a multi-root workspace, each folder's language server now
starts even when several folders hold Translations projects.

With dotnet-runic 0.22, the extension's dev task passes --debug-endpoint to
a dev with its Window, so a CS-WebUI Window opens its DevTools Protocol port
(D070.17), and Stop dotnet runic dev asks dev to stop on its standard input
(RUNIC_DEV_STOP_ON_INPUT), so it marks its session stopped and removes its
development pages, on Windows too; after 10 seconds it is ended by force. Older
tools run as in 0.21. The extension's dev terminal ends when the dev process
exits, even while a child it started still holds its output.

When a dev was killed (the session file still says starting or ready, but its
process is gone), the extension now touches obj/runic/dev-stopped once, as
dev does when it stops, so the next build restores the production frontend in
www/ (runic-editors#29).

A light-bulb refactoring the server refuses for another reason (such as Extract
Group while a locale lacks the group) shows the server's reason as a warning,
and the palette's Extract Group and Inline Resource work right after a save:
the extension asks again for a few seconds when the server answers that the
document changed while the request was pending. dotnet runic dev's build
errors open their file again (the $runic-dev matchers skip dev's [host]
label), and with dotnet-runic 0.22 a fixed C# error leaves Problems once dev
prints [dev] Ready again, while warnings stay (runic-editors#36, #38, #40).

Visual Studio

The Visual Studio commands move to a Tools → Runic submenu (their command
names Tools.RunicPreviewMessage and Tools.RunicRestartLanguageServer stay), and
Preview Message is also in the .mf2/.rmf2 editor context menu.
View → Other Windows → Runic opens the new Runic tool window.

Tools → Options → Runic DevKit sets the .NET executable, the language server
assembly and the language server trace (VS Code's runic.dotnetPath,
runic.translations.serverAssembly and runic.translations.trace.server); the
RUNIC_DOTNET and RUNIC_TRANSLATIONS_SERVER environment variables still apply
while an option is empty. The language server's output and trace go to a
Runic Translations Output pane (the Runic SDK commands write to a Runic SDK pane). When the server cannot start, an InfoBar says why once per solution
(no tool manifest, tool not restored, missing .NET runtime, a tool without lsp),
with Show output and How to install the tool. Runic DevKit now loads only
in a solution with a Runic project (the RunicApplication capability, a Runic
Translations build, a runic.json or a tool manifest with
dotnet-runic-translations) or when an .mf2/.rmf2 file is open, and the
Tools → Runic menu shows only there.

The Runic tool window shows, for the solution's Runic SDK projects, the
ViewModels of the development source map (runic-bridge/sources.json) with
their Bridge members; double-click a member, or choose Open C# Member, to go
to its C# source. Run dotnet runic doctor (Tools → Runic, the tool window's
toolbar, the Error List's context menu) shows the checks in the Doctor
section and puts failing and warning checks into the Error List on the project
file, with a help link (F1) to the doctor documentation, as VS Code's Doctor view
and Problems do.

Start dotnet runic dev, Start dotnet runic dev --no-window and Stop
dotnet runic dev
(Tools → Runic, the tool window's toolbar) run dev as VS
Code's tasks do: its output goes to the Runic SDK Output pane and its
diagnostics, read as VS Code's $runic-dev problem matcher reads them, to the
Error List with a help link (F1) for Runic codes. The extension follows each
project's obj/runic/dev-session.json and checks that its dev still runs by
process ID and start time. A dev started in a terminal is followed but stopped
there with Ctrl+C. Open the Development Server and Open the dev Session
File
open the session's server and file. When F5 or Ctrl+F5 starts a Runic
startup project and no dev --no-window runs for it, Visual Studio asks first:
start dev --no-window and launch once it is ready, or continue without it
(D070.6). The doctor and dev use the .NET executable option, and the doctor's
output now goes to the Runic SDK pane.

The tool window's Dev Session section shows each project's dev state and,
while it runs, the development server, the Window's owner or process, the pages,
the debug endpoints and the generated clients, as VS Code's Dev Session view does.
The toolbar enables Start and Stop by state, and state changes appear in the
status bar.

Debug the Window (Tools → Runic, the tool window's toolbar) debugs the .NET
code and the page in one session: it starts dev --no-window, builds, launches
the Window under the .NET debugger with the session file's environment and a
DevTools Protocol port (a free one in WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS for
WebView2, the session's for CS-WebUI), and attaches the JavaScript debugger over
CDP once the page is up, with no 30-second limit. Attach to the Page
(JavaScript)
attaches to a running page from the session file's
debugEndpoints. When DevKit starts dev with its Window, it passes
--debug-endpoint to dotnet-runic 0.22 and later, so CS-WebUI Windows open
their port. TSX breakpoints need runic-sdk 0.22's vite-plugin-runic; this
replaces the template's (WebView2 script debugging) profile, which does not
work in Visual Studio. While Debug the Window or Attach to the Page debugs a
WebView2 page, DevKit turns off Visual Studio's Break all processes when one
process breaks
(otherwise a TSX breakpoint would also stop the .NET Window
that hosts the page, and Visual Studio would hang), says so in the Runic SDK
Output pane, and turns it on again when debugging stops, also after a crash.

With dotnet-runic 0.22, Stop dotnet runic dev asks dev to stop on its
standard input instead of ending its process tree, so the session file says
stopped and the development pages leave www/; after 10 seconds it ends the tree
as before. DevKit runs dev in a Windows job object, so whatever dev leaves
running when it exits or is ended (its Vite server, runic-translations serve)
is ended too, and the Runic SDK pane says how many processes it ended. Start
dotnet runic dev
right after Stop works at once; during a stop it waits up to
30 seconds and otherwise names what is still running. ...

Read more

v0.21.0

v0.21.0 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 17 Nov 00:37
add22ab

Runic editor extensions 0.21.0

Part of the Runic 0.21 release train: it belongs to
Runic Translations 0.13.0
and Runic SDK 0.21.0.
Update the extensions together with the SDK: Runic SDK 0.21.0 renames the format ID
of the development source map, which the ViewModels view reads from 0.21.0 on.
Nothing is published to an extension marketplace: install a VSIX from this release.

Asset Extension Version
runic.vsix VS Code, Runic (runic-artifex.runic) 0.21.1000
runic-translations-visualstudio.vsix Visual Studio 2026, Runic MF2 Translations (Runic.Artifex.Translations.Rmf2) 0.21.0.1000
SHA256SUMS sha256sum lines of both VSIX files

VS Code

  • The ViewModels view reads the development source map in both of its format IDs:
    runic.views.bridge-sources/1, which runic-sdk 0.21 writes, and
    runic-bridge-sources/1, which 0.20 apps write. Other versions are still rejected.
    Apps built with either SDK version show their ViewModels and Bridge members
    (#8).

Visual Studio

No changes; the Visual Studio 2026 extension is released with the train's version.

Language server

Neither extension bundles a language server: each runs the workspace's
dotnet-runic-translations tool. This release is tested against
dotnet-runic-translations 0.13.0 from NuGet, and the VS Code extension bundles
that release's runic.json schema (unchanged from 0.12.0). Translations 0.13.0
changes nothing the extensions use in the lsp protocol or the settings. Its
xliff import takes the document with --input; the Import XLIFF (dry run)
command still passes --source, which 0.13.0 keeps as a hidden alias, so it works
with both 0.12.0 and 0.13.0. Use the version of the project's Runic.Translations
packages:

dotnet tool install dotnet-runic-translations --version 0.13.0

Compatibility

  • Runic SDK: apps built with 0.20 and 0.21 both work, including the ViewModels view.
  • Runic Translations: tested with 0.13.0; 0.12.0 workspaces keep working. For 0.11.0
    and older, use the VSIX files attached to that Translations release.

Verifying

sha256sum --check SHA256SUMS
gh attestation verify runic.vsix -R Runic-Artifex/runic-editors \
  --signer-workflow Runic-Artifex/runic-editors/.github/workflows/release.yml
gh attestation verify runic-translations-visualstudio.vsix -R Runic-Artifex/runic-editors \
  --signer-workflow Runic-Artifex/runic-editors/.github/workflows/release.yml

The release workflow takes both VSIX files from the successful CI run of the
released commit and checks them by hash before attesting them.

What's Changed

Full Changelog: v0.20.0...v0.21.0

v0.20.0

v0.20.0 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 16 Nov 00:53
1990c95

Runic editor extensions 0.20.0

The first release from runic-editors. Up to 0.11.0 the extensions were released
with Runic Translations;
they now follow the Runic release train. 0.20.0 belongs to
Runic Translations 0.12.0
and Runic SDK 0.20.0.
Nothing is published to an extension marketplace: install a VSIX from this release.

Asset Extension Version
runic.vsix VS Code, Runic (runic-artifex.runic) 0.20.1000
runic-translations-visualstudio.vsix Visual Studio 2026, Runic MF2 Translations (Runic.Artifex.Translations.Rmf2) 0.20.0.1000
SHA256SUMS sha256sum lines of both VSIX files

VS Code: one Runic extension

(runic-editors#2, #5)
The Translations extension, Runic MF2 Translations (runic-artifex.runic-translations,
runic-translations.vsix), became Runic (runic-artifex.runic, runic.vsix),
which adds Runic SDK features in workspaces with a Runic SDK project: the Dev Session
view and status bar item for dotnet runic dev, F5 of the Window, the Doctor view,
quick fixes for Runic diagnostic codes and the ViewModels view. A Translations view
shows runic-translations status coverage per locale.

VS Code installs Runic next to the former extension; uninstall
runic-artifex.runic-translations afterwards. The former runicTranslations.*
settings still apply while the new runic.* ones are not set, and the former
command IDs still run. See Moving from Runic MF2 Translations
and the changelog.

Visual Studio

The Visual Studio 2026 extension keeps its identity and features; it is now built,
tested and released here.

Language server

Neither extension bundles a language server: each runs the workspace's
dotnet-runic-translations tool. This release is tested against
dotnet-runic-translations 0.12.0 from NuGet, and the VS Code extension bundles
that release's runic.json schema (unchanged from 0.11.0). Use the version of
the project's Runic.Translations packages:

dotnet tool install dotnet-runic-translations --version 0.12.0

Verifying

sha256sum --check SHA256SUMS
gh attestation verify runic.vsix -R Runic-Artifex/runic-editors \
  --signer-workflow Runic-Artifex/runic-editors/.github/workflows/release.yml
gh attestation verify runic-translations-visualstudio.vsix -R Runic-Artifex/runic-editors \
  --signer-workflow Runic-Artifex/runic-editors/.github/workflows/release.yml

The release workflow takes both VSIX files from the successful CI run of the
released commit and checks them by hash before attesting them.

What's Changed

New Contributors

Full Changelog: https://github.com/Runic-Artifex/runic-editors/commits/v0.20.0