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.

✅ 2.3.4. Windows x64 · .NET 10 Desktop Runtime · trusted workspace. Linux, macOS and WSL are not supported.

New in 2.3: Adapter SDK Preview 0.1.0 adds independently built designer actions and scalar property editors. Inspect a local package, explicitly enable its exact hashes in a trusted workspace, and invoke its actions from the canvas Tasks menu or the command palette. Input and dropdown editors use the host's focus, cancellation and Undo workflow. This is trusted author code with no vendor certification or OS sandbox. The public contract and its exact limits are in the SDK guide.

Since 2.3: bounded document history and linked artifacts survive hot exit. Source/resource histories restore native Undo after the last matching saved checkpoint. Histories with ordinary code-behind edits use recovered-action Undo/Redo from the designer. The ordinary code editor keeps its own Undo stack; a changed companion blocks aggregate operations until reconciled. An existing native Redo branch remains recovery data. Choose the owning project explicitly for shared files, inspect the recovery timeline, and review named worker and project-evaluation diagnostics. Toolbox discovery prioritizes project controls and managed EXE outputs. See the release record for tested behavior and public API limits.

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:

Getting started

1. Open an existing form's Form1.cs, or right-click a project folder and choose Add → Windows Form.
2. Click a control to select it, then edit it in Properties or drag/resize it on the canvas.
3. Add controls from the Toolbox; press F4 to focus Properties.
4. Save — only the changed lines are written back into .Designer.cs.

What you get

Canvas. Select, move, resize with 8 handles, nudge with arrows, multi-select and rubber-band, group move/delete, reparent, z-order, copy/paste, duplicate (Ctrl+D), lock, align / distribute / make-same-size, tab-order editor, snaplines, smart tags, right-click menu. Hold Alt during a drag to suppress snapping.

Properties. Primitives, enums, and VS-style editors for Color, Font, flags enums, Anchor/Dock, Cursor and images. Non-default values are bold; right-click Reset restores the default. Component-reference properties become dropdowns of compatible components.

Real controls, really rendered. Your controls — including custom and third-party ones — are instantiated and painted, so the preview matches runtime. Stays crisp on 4K.

.NET Framework & DevExpress. net4x forms render on a bundled .NET Framework 4.8 engine that interprets your live source onto the compiled controls, so classic suites like DevExpress look pixel-accurate. Each form is routed to the right engine automatically.

Menus & toolbars, edited on the canvas. A "Type Here" slot to add, double-click or F2 to rename, click and Delete to remove — including nested submenus, off-tree ContextMenuStrip, and the overflow area. Each item gets its own property grid with an Events tab.

Collection editors. The … button opens a VS-style editor for string collections, ListView.Columns, DataGridView.Columns, TabControl.TabPages ordering, and TreeView.Nodes.

Layout panels. Drag children between live TableLayoutPanel cells or within a FlowLayoutPanel, edit column/row styles, and work through SplitContainer panels.

Tabs. Navigate, rename, add, delete and reorder tab pages; the active page is remembered per form.

Images & .resx. Render images from a form's sibling .resx, and import or clear Image, BackgroundImage and Icon.

Localized forms. Edit Localizable = true forms in the neutral or a chosen culture. Values, geometry, images, RightToLeft and Reset go to the .resx; generated source stays clean.

Data binding. Edit DataBindings, pick a DataSource, and maintain bound DataGridView columns. The preview doesn't evaluate bindings — neither does Visual Studio's.

Events. Wire, unwire and rewire handlers, generate a stub, jump to the body, or double-click a control for its default event.

Toolbox. 69 framework items across Common Controls, Containers, Menus & Toolbars, Data, Components, Dialogs and Printing — including non-visual components (Timer, ImageList, ErrorProvider, BindingSource, ContextMenuStrip, BackgroundWorker, FileSystemWatcher) that land in the component tray, and the common dialogs. Plus controls discovered from your project and its references. The palette follows the open form's runtime, so a net4x form also gets the .NET Framework-only controls that do not work on modern .NET. Choose Toolbox Items hides or restores them and keeps custom tabs.

Component tray & document outline for non-visual components and the control hierarchy, with safe drag/reparent.

Explorer integration. Right-click a folder → Add → Windows Form, User Control, Component or Class. Creating a form is one undoable transaction across .cs / .Designer.cs / .resx.

High-DPI advisor. For a form using AutoScaleMode.None, WinForms: Preview High-DPI Scaling Fix… shows the exact None → Font change as a read-only diff before you apply it.

7 languages. English, Русский, 简体中文, Français, Deutsch, Español, हिन्दी — via winformsDesigner.language.

What it won't do

Safety is the point: an edit the designer can't write correctly is refused with a stated reason, never guessed.

• Saves are byte-local. Only the lines you changed move; everything else is preserved exactly.
• Forms it can't fully regenerate — a binary .resx, an unresolved base type, an unrepresentable statement — stay editable through targeted edits, but whole-file regeneration is refused and the reason is named.
• On the .NET Framework engine, a construct the interpreter can't reproduce falls back to a render of your last build, with the reason disclosed. Never a silent mismatch.
• Not supported: x86, COM and ActiveX projects; arbitrary vendor-specific property editors and hosted designers beyond the framework routes. These refuse before touching your files.
• Windows ARM64: a win32-arm64 package is published and genuinely contains an ARM64 engine, but it has never been run on ARM64 hardware — all testing happens on x64. Treat it as unverified. See ARM64 notes.

If something goes wrong, run WinForms: Export Designer Diagnostics and attach the output to an issue.

Requirements

• Windows x64 — WinForms is Windows-only.
• .NET 10 Desktop Runtime matching the VSIX architecture.
• .NET Framework 4.8 — only for net4x / DevExpress projects. Rendered by a bundled engine.
• A trusted workspace — see below.

Settings

Security & workspace trust

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

Support matrix

DevExpress on the modern engine (a DevExpress net8.0+ build in a net10.0-windows project) is verified with DevExpress 25.2.5: LayoutControl arrangement, Appearance properties and SVG/bitmap images from the project's own Properties.Resources render without skipped statements. DevExpress versions without .NET 10 support (before 25.2) fail inside their own constructors on .NET 10; such a form opens as a disclosed incomplete preview.

Links

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