WinForms Designer for VS Code

A Visual Studio–style WinForms form designer, running natively inside VS Code.

Open a form's Form1.cs and get a live, interactive preview of the rendered form — click controls, edit properties, drag and resize, wire events, and save minimal changes back into .Designer.cs. No round-trip through Visual Studio.

✅ 1.8.0. Requires Windows x64 or Windows ARM64 and the matching .NET 10 Desktop Runtime. Linux, macOS, WSL and Linux remote workspaces are not supported. The .NET Framework 4.8 engine (for net4x / DevExpress) is native on x64 and a reduced-feature x64 compatibility fallback on Windows ARM64; it renders your live source through an IR interpreter — the Visual Studio model, which never constructs the form you are editing — with a disclosed compiled fallback for constructs it can't yet reproduce. An open designer never holds your build output and never puts a window on your screen - see Support matrix & limitations.

Drag & drop, live

Drop a control from the toolbox onto a DevExpress form and it lands where you put it — snaplines, selection handles and all — while the change goes back into .Designer.cs as a minimal edit.

Screenshots

A DevExpress form, designed in VS Code. The canvas is your live .Designer.cs replayed onto the real vendor controls; the property grid is the XtraForm itself, not a stand-in.

Vendor smart tags — the control's own designer verbs, read off the compiled type:

Choose Toolbox Items — framework, project and browsed assemblies, with sortable columns:

Zoom, snaplines and your own controls — a custom gauge painted by its real OnPaint at 214%:

A real production form — hundreds of controls, a third-party suite, and an honest disclosure when a construct falls outside what the designer can replay:

Features

• Live form rendering from .Designer.cs — your controls (including custom/3rd-party ones) are really instantiated and painted, so the preview matches runtime. A DPI-aware backing capture stays crisp on 4K / high-DPI screens while layout and hit-testing remain in logical WinForms pixels.
• .NET Framework & DevExpress support — forms whose controls target .NET Framework (net4x) render on a dedicated bundled .NET Framework 4.8 engine that interprets your live source (the Visual Studio model) onto the compiled controls, so classic component suites (e.g. DevExpress) look pixel-accurate. Each form is auto-routed to the right engine; the property grid, drag/resize/align, add/remove, z-order, cut/paste, tab-page add/rename/delete/reorder, dropping the project's own vendor controls from the toolbox, and the collection editors apply live on the interpreted picture. A construct the interpreter can't yet reproduce falls back to a disclosed compiled render of the last build.
• VS Code–native workflow — opening Form.cs opens the designer; View Code switches back to text.
• Property grid — primitives, enums, safe complex values, and bounded metadata-driven TypeConverter expansion, plus VS-style Color, Font, flags-enum, Anchor/Dock, Cursor, and image editors. Supported framework Color/Font UITypeEditor dialogs run in a cancellable isolated process; arbitrary vendor editors remain disabled. Component-reference properties become compatible-component dropdowns, non-default values are bold, and right-click Reset restores the default.
• Data-bound forms — edit canonical DataBindings entries (target property, component source, data member, formatting, update mode, and format string), choose a supported DataSource as (none), a compatible component, or typeof(T), and maintain bound DataGridView columns including DataPropertyName, format, alignment, and literal null-display values. Editing is source-first and exact on both engines; the preview does not evaluate bindings (neither does Visual Studio's), so a DataBindings.Add(…) statement is disclosed as a skipped construct — and on the .NET Framework engine a bound form previews from your last build.
• Collection editors — the … button opens a VS-style Collection Editor for string collections, string arrays, allowlisted scalar/enum/complex IList / IList<T> values, ListView.Columns, DataGridView.Columns, and recursive TreeView.Nodes. Unsupported item types and non-canonical expressions stay read-only. A panel "Type Here" editor also reorders / adds / removes / renames MenuStrip / ToolStrip items.
• On-canvas menu & toolbar editing — edit MenuStrip / ToolStrip items directly on the strip: a "Type Here" slot to add (with a type picker), double-click / F2 to rename, click to select and Delete — including nested submenus, an off-tree ContextMenuStrip (from its tray chip), and the overflow area. Selecting an item opens its own property grid with an Events tab. On both engines.
• Images & .resx — render images from a form's sibling .resx, and import / clear Image / BackgroundImage / Icon back into both files.
• Localized forms — edit Localizable = true / ApplyResources forms in the neutral or a selected culture .resx. Scalar/Color/Font/geometry edits, localized images/icons, RightToLeft, and RightToLeftLayout use lossless, conflict-checked resource transactions; Reset removes the override and restores ResourceManager fallback.
• Tabbed forms — standard WinForms tab headers support view-only navigation, double-click rename, Add/Delete, and one-position Move Left/Right on both engines. Reordering swaps only canonical adjacent Controls/TabPages.Add[Range] references and refuses ambiguous source. The active page is remembered per form on modern and net48 live-source canvases without changing generated source; a disclosed net48 compiled fallback remains build-derived and mirrors supported moves live.
• Layout panels — edit TableLayoutPanel cells & column/row styles, SplitContainer splitter distance, and FlowLayoutPanel order.
• Toolbox - ~39 System.Windows.Forms controls (with native icons) plus controls lazily discovered from the open form's owning project/reference outputs, including concrete custom output roots. Discovery is budgeted, cancellable, metadata-only, cached, and incrementally refreshed; Choose Toolbox Items hides/restores discovered controls and keeps chosen items/custom tabs in workspace state, migrating existing pre-1.8 curation once. A control-source picker still handles explicit custom / 3rd-party assemblies. COM/WPF toolbox pages are explicitly unsupported and inert.
• Direct manipulation - select, move, resize (8 handles), keyboard nudge (arrow keys), multi-select + rubber-band, group move/delete, reparent, z-order, copy/paste, duplicate (Ctrl+D), lock controls, align / distribute / make-same-size, tab-order editor, snaplines, on-canvas smart-tags, and a right-click menu. Hold Alt during one move/resize to suppress snapping and see exact live bounds; the configurable override never bypasses geometry authorization. Modern final free-control bounds are corrected by the real WinForms graph before source is accepted. Cross-form paste validates typed binding and extender dependencies before changing source.
• Events — wire / unwire / rewire handlers, generate a stub, navigate to the handler body.
• Component tray and document outline for non-visual components and the control hierarchy. Editable outline nodes support safe drag/reparent and keyboard/context z-order changes; inherited or unresolved nodes remain visible and read-only. Tray components show framework icons, support inline field rename, retain compatible references, and expose common ToolTip, ErrorProvider, and HelpProvider extender properties.
• Localized UI (7 languages) — the designer surface, dialogs and messages can be shown in English, Русский, 简体中文, Français, Deutsch, Español or हिन्दी via the winformsDesigner.language setting.
• Safe save — targeted, byte-minimal text edits; everything outside the change is preserved exactly.

Requirements

• Windows x64 or Windows ARM64 (WinForms is Windows-only).
• .NET 10 Desktop Runtime matching the VSIX architecture. The SDK is only required when building the extension from source.
• .NET Framework projects (net4x, e.g. DevExpress) render through a bundled .NET Framework 4.8 engine on x64. On Windows ARM64 this is a reduced-feature x64 compatibility fallback, not a native ARM64 engine; vendor controls and targeting packs must work under Windows x64 emulation.
• A trusted workspace (see below).

Since version 1.4.0, packaging produces separate win32-x64 and win32-arm64 VSIX artifacts. The ARM64 package bundles the modern engine with dotnet publish -r win-arm64; it does not make the .NET Framework 4.8/vendor-control path native ARM64. See Windows ARM64 support.

Getting started

1. Open a form's Form1.cs (with its generated Form1.Designer.cs sibling). The designer opens automatically.
2. Click a control to select it, then edit it in the Properties panel or drag/resize it directly.
3. Add controls from the Toolbox; press F4 to focus Properties.
4. Save to write minimal changes back into .Designer.cs.

For a localized form, run WinForms: Select Localization Culture, choose (Default), an existing culture, or create one such as fr-FR/ar-SA, then edit normally. Supported localization edits are written immediately to the selected .resx and participate in the designer's single undo/redo history without dirtying generated source.

Settings

Language

The designer surface, property grid, toolbox, dialogs and status/notification messages are localized and follow the winformsDesigner.language setting — chosen here, not from the VS Code display language. Changing it takes full effect after a Reload Window (you'll be prompted). Note: the VS Code command palette titles and the settings page itself follow VS Code's own Display Language (a platform limitation), so those pieces of "chrome" may stay in a different language than the designer UI.

Security & Workspace Trust

Rendering a designer loads and runs your project's control assemblies (constructors and OnPaint execute on preview), so the extension is disabled in untrusted workspaces. The engine interprets .Designer.cs through strict allowlists rather than executing arbitrary code from the file. Only open projects you trust.

Support matrix & limitations

1.0 guarantees safe persistence. Supported edits are written as byte-local, conflict-checked source splices; anything the designer can't persist safely is refused with a stated reason, never guessed. The modern engine renders your current source buffer. The .NET Framework engine interprets your live source (the VS model), and its property panel + live edits re-derive from that interpreted picture; a construct it can't yet reproduce falls back to a compiled render of your last build with a disclosed, named reason — never a silent mismatch — and your source edits stay byte-local either way.

A capability preflight classifies every form (safe / localizable / binaryResx / unresolvedType / lostStatements / unrepresentable), so a form it can't whole-file regenerate — binary .resx, an unresolved base type, or an unrepresentable statement — is refused that regenerate, with the reason named, rather than saved unsafely. Ordinary limited forms use targeted byte-surgical source splices. Localizable = true forms use the v1.5 resource-first route: supported value, geometry, RTL, Color/Font, image/icon, and Reset edits touch only the selected .resx, with set-wide exact preflight, undo/redo, conflict-safe compensation, and preservation of unknown/binary nodes. Generated-source structural edits on localized forms remain refused. The engines have bounded automatic crash recovery, and WinForms: Export Designer Diagnostics reports capabilities, ping time, memory, PID, and lifecycle/crash state. net4x builds: the compiled preview holds the project's build output open while it renders, but a build — inside VS Code or in an external Visual Studio — is detected and the output handed back before the build needs it; WinForms: Release .NET Framework Assembly (for Rebuild) remains as a manual control. Not yet: arbitrary vendor-specific property editors beyond the supported framework Color/Font pair and a full vendor design-time service host. Please report issues with the generated diagnostics.

Links

• Source, issues & contributing: https://github.com/SkivHisink/winforms-designer-vscode
• License: MIT