ICS — Indented C# for VS Code

Edit your existing C# with indentation instead of braces. Changes flow between the C# and ICS panes, while your project keeps standard .cs files. Live editing is free; Pro adds optional automation.

The same file, with and without braces

Recorded in VS Code. Playback is edited for pace.

Both panes are editable and stay in step. The .cs file remains the canonical source on disk; the ICS view presents the same code with indentation in place of structural braces.

Start with a C# file

Install ICS — Indented C#, open a .cs file, then run ICS: Open C# as ICS from VS Code's Command Palette (F1). An editable ICS view opens beside the C# file.

Type in either pane; after a short pause, the other updates when the code is convertible. Your project continues using ordinary .cs files.

To toggle the view using the keyboard, press Ctrl+K, release both keys, then press I. On Mac, press Cmd+K, release both keys, then press I.

Why ICS

• Less punctuation, same C# project. Work in an indented view while teammates and build tools keep ordinary .cs files.
• Edits are checked before they reach C#. If a conversion would lose meaningful code or comments, ICS refuses it rather than silently changing the source.
• No migration required. Opening a C# file as ICS creates no .ics sidecar beside it; exporting standalone ICS files is optional.
• Your code stays local. Conversion and language analysis run on your machine. ICS does not upload your source code and includes no analytics or usage telemetry of its own.
• Unchanged means unchanged. An untouched ICS preview returns the original C# exactly.

See the difference

The same InvoiceService example is 22 lines of ordinary C# and 12 lines in its ICS view. The project still builds from the .cs file.

C# on disk

namespace Billing;

public class InvoiceService
{
    public decimal Total(IEnumerable<Line> lines)
    {
        decimal total = 0m;
        foreach (var line in lines)
        {
            if (line.Taxable)
            {
                total += line.Amount * 1.2m;
            }
            else
            {
                total += line.Amount;
            }
        }

        return total;
    }
}

ICS in the editor

namespace Billing

public class InvoiceService
    public decimal Total(IEnumerable<Line> lines)
        decimal total = 0m
        foreach (var line in lines)
            if (line.Taxable)
                total += line.Amount * 1.2m
            else
                total += line.Amount

        return total

Work in the ICS editor

The ICS view supports hover, Go to Definition, Find References, completion, semantic highlighting, and reference-count code lenses. Analysis runs locally on the generated C# projection. See the language-service scope and limitations.

Enable Editor Fidelity in the ICS Control Panel → Live Editing (or set ics.enableEditorFidelity to true) to use the following optional features. The option is off by default and takes effect immediately.

ICS: Change Signature… in the editor context menu or Command Palette opens native parameter choices for a resolvable source declaration or call. Reorder or remove existing parameters, or add required/optional parameters with a C# type and explicit, named, inferred or omitted-default call-site values. Roslyn updates related source declarations and callers across the loaded SDK solution, including constructors, indexers, delegates and interface implementations. Existing parameter names and types retain their identities; use Rename to change a parameter name. Changes use the guarded unsaved workspace transaction. Stale source, invalid parameter ordering, conflicting declarations and new compiler errors reject the whole operation. Related external definitions can require an explicit warning confirmation.

Outline, breadcrumbs and Go to Symbol show the current file's declarations. Symbol occurrences distinguish reads and writes, and declarations and executable blocks can be folded. Enter indents recognized single-line block headers. Completion also offers ICS-native if, foreach, class, method, prop, and try snippets. These features are free; structural results can temporarily clear while code is incomplete.

With this option enabled, SDK-style C# projects supply the context for completion, parameter help, diagnostics, definitions and references. Analysis loads the nearest solution, including downstream consumers, or the nearest project's reference graph when no solution exists. It uses evaluated compiler settings, restored references and unsaved buffers. Install a compatible .NET SDK and restore the project first. Analysis never changes saved C# files. Files outside SDK projects retain localized analysis.

Use ics.projectPath and ics.solutionPath to resolve ambiguous discovery, ics.targetFramework to select a multi-targeted context, and ics.configuration and ics.platform to choose build settings. Solution symbol search, source type and implementation navigation use the same workspace. ICS: Check Solution Diagnostics refreshes compiler and configured-analyzer results in Problems, including unopened files. With diagnostics enabled, these results also refresh automatically after edits to live buffers, external source changes, and project or analyzer configuration changes. Background scans are debounced, cancellable and disabled when editor fidelity or diagnostics is turned off. Separate workspace roots retain their own results. Checks continue after the last ICS editor closes, using current C# working copies and saved source. Closed private ICS drafts are excluded.

Discovery folders are scanned together, compiling each resolved SDK graph once. Background watches cover loaded projects, known linked-source directories, ancestor build settings, .editorconfig files and restored NuGet assets. They also cover evaluated imports with custom extensions, analyzer binaries and their managed dependencies, additional analyzer inputs, and empty external Compile globs. Newly created source directories join the selected SDK context. Analyzers load from private immutable copies so their project outputs can be rebuilt while the editor remains open.

The normal Rename command updates resolvable symbols across the loaded solution in one undo transaction. It checks every affected buffer before applying edits and leaves them unsaved. Conflicting names, stale buffers, invalid open ICS views and edits that cannot map safely to ICS are rejected. If a closed standalone ICS companion is reported, open it and repeat the rename.

Quick Fix offers bundled Roslyn C# fixes such as importing a namespace, qualifying a type or implementing missing interface members. A selected fix is recalculated against current buffers and applied as one unsaved undo transaction. Structural fixes may canonicalize the affected ICS document after conversion checks. Applicable Fix All actions cover a document, project or solution using the same guarded edit path. File creation, moves and deletion can join that transaction. Actions that require project/reference/configuration changes or unsupported IDE operations are unavailable with a reason. Other options-dialog actions and third-party code-fix providers are not included.

The native Refactor menu offers applicable C# refactorings for selected ICS, including Extract Method, Extract Local Function, introducing a local and inlining a temporary variable. Whole-line and block selections use native ICS positions. Edits use the same guarded conversion, unsaved workspace edit and single-undo path; stale source or selection snapshots cannot resolve an old offer. Guarded file creation, rename, move and deletion can join the same native edit transaction. Broader project-system operations and other IDE options dialogs remain outside this path.

Planned file actions keep private ICS previews and physical ICS companions separate. A closed preview follows a later rename or deletion invoked from another editor, retaining its saved draft and common baseline. Native Undo/Redo works from the invoking editor or the reopened target, including earlier file actions from that IDE session. Closed previews do not contribute abandoned edits to analysis. Explorer and native file/folder renames also keep private previews attached and move their standalone ICS companions. Native Undo/Redo retains those identities, including after the option is turned off. If a companion destination is occupied, the existing files stay intact and the view becomes a recoverable draft; undoing the source rename reattaches it. Ordinary file deletion retains the independent saved bytes, raw C# working copy and private ICS draft; native Undo restores the pair. Deleting a folder retains recovery copies but follows VS Code's irreversible-folder behavior. Disk changes made by another application still require manual recovery.

VS Code may ask to include ICS refactoring changes with a deletion. Choose OK to retain paired native file history. Skip Changes retains private recovery copies while VS Code performs the original deletion.

With Enable editor fidelity enabled, completion includes symbol types, method signatures, overload counts and available source documentation. The documentation includes each overload's signature. Selecting a suggestion replaces the full partial identifier, including text to the right of the caret. In an SDK project, suggestions can also add a missing import or generate an override body. Accept these suggestions with Tab or Enter. The ICS buffer and its open C# companion change together in one undo step; an offer is rejected if its source or project context changes before acceptance. Parameter help shows method, constructor, indexer and attribute overloads, highlights the current argument, and handles named, optional and params parameters. Named attribute fields and writable properties include their types and documentation. Resolvable delegate calls, target-typed new(...), constructor chaining and inferred generic method signatures use the same parameter-help UI.

Open ICS companions contribute current declarations while common method bodies, calls, indexers and signatures are unfinished. Completion, parameter help, navigation, references and read-only hierarchies use those current declarations and native positions. Recovery never rewrites the draft. Generating C# and applying workspace transformations still require valid source; unprojectable indentation errors can temporarily limit cross-file features.

Enter also recognises parenthesis-free ICS if conditions, bare catch, checked, unchecked, unsafe, await foreach and await using headers.

These queries recover common unfinished typing states such as text., partial member names, Method(, Method(value, and nested or multiline calls. Recovery is temporary and local to the query; it never changes the document or relaxes conversion/save validation. Comments, string contents, unsupported syntax and unrelated parse errors may return no results. This remains a subset of native C# workspace editing: other IDE options dialogs, broader project-system operations and debugger integration are not included.

With fidelity enabled, Go to Definition and Go to Type Definition can open read-only C# declarations from referenced assemblies and generated source. Library navigation includes available documentation and signatures, and decompiles method bodies when an implementation assembly is available. Reference-only libraries fall back to declarations. Call Hierarchy and Type Hierarchy use the same SDK project context and map source entries to their ICS positions. Reopen a hierarchy after changing its source or project context; stale entries cannot expand.

With editor fidelity enabled, live preview working copies use private .ics files in VS Code's extension storage so text and file Undo/Redo survive a workspace rename or move. They are separate from project files and contain no projection metadata. Removing a source retains both working copies in private recovery; saving the retired preview saves its draft without recreating or saving the project source. Deleted views retain their own recovery records across window reloads. Opening a new source at the same path creates an independent live view; the old draft remains available through its private tab and Show Paired C# File. Close and reopen older virtual previews before using these file operations.

Free and Pro

Live in-memory C# ↔ ICS synchronization is free. ICS Pro enables:

• Display ICS only.
• Auto-save paired C# after each successful live update.
• Sync standalone ICS files on save.

ICS Pro is $29 once. No subscription. Includes all 1.x updates, eight activations for one person, and a 30-day refund guarantee.

After purchase, run ICS: Enter License Key; use ICS: Deactivate License to release an activation before moving it.

Full pricing and terms · Activation transfer policy

Prerequisites

Requires VS Code 1.100 or later.

The converter is bundled. Microsoft's .NET Install Tool automatically installs the required user-level .NET 10 runtime on first use, which may require an Internet connection. A system-wide .NET installation is not needed.

The validated desktop target for this release is Windows. Native macOS/Linux, WSL, Remote SSH, Dev Containers and Codespaces workflows remain unvalidated. ICS runs on the workspace host, so a remote host would need its own compatible .NET runtime and, for project analysis, SDK and restored references. Runtime acquisition alone does not establish remote compatibility. The extension is disabled in untrusted workspaces (Restricted Mode).

Live editing, saves, and recovery

By default, live updates change editor buffers only; disk writes occur on save or an explicit output command. Pro's optional auto-save can also write each successful update.

Incomplete code is normal while typing. Until it becomes convertible, the other pane keeps its last verified text and is marked out of date—it is not overwritten with a partial conversion. If both panes have independent edits, ICS: Resolve Preview Conflict lets you review and choose. Local recovery copies can contain source code; the editing and recovery guide explains where they live and how to remove them.

Other ways to work

• ICS-only mode (Pro): set ics.displayIcsOnly to replace C# editors with ICS views while saving back to the ordinary .cs files.
• Keep .ics files on disk: ICS: Sync Current File to C# converts one file on demand; Pro can synchronize on every save.
• Export once: ICS: Export as ICS File writes a standalone .ics copy without creating a live-linked preview.

The full VS Code guide covers save behavior, conflicts, recovery, workspace-wide conversion, and troubleshooting.

C# clipboard fragments

ICS: Paste C# as ICS converts complete C# statements, members or declarations at a statement/declaration margin, with one undo step. ICS: Copy Selection as C# copies one contiguous selection of complete ICS statements or members. Copy Generated C# continues to copy the whole document. Partial expressions and incomplete fragments are outside this first version; a failed explicit conversion leaves both the clipboard and documents unchanged.

With Enable editor fidelity on, ordinary paste can also offer Paste C# as ICS. Text copied within ICS retains normal paste behavior. If automatic conversion is unavailable, VS Code falls back to ordinary text paste. A paste that would change a multiline string's value through the target document's line endings is refused; use a matching line-ending format or edit the paired C#.

File-based apps and merge conflicts

Basic conversion supports .NET 10 file-based programs, preserving the shebang and #: directives as native rows. ICS does not restore dependencies or construct a virtual SDK project from #:package, #:sdk or #:property. Project-aware fidelity for file-based apps is deferred; these files use current-file analysis.

Git merge-conflict markers block fresh conversion. An existing ICS view retains its last verified text and any recovery draft. Resolve the markers in the paired C# file; Resolve Preview Conflict opens that source rather than replacing its markers with the ICS draft. Refresh from C# after resolving; if both sides have independent edits, review both before choosing a version.

AI assistants

Copilot and other AI completions, chat edits and next-edit suggestions in ICS are unvalidated. This release makes no AI compatibility claim. Suggestions may contain ordinary C# syntax; review them in the paired C# editor or use explicit C# clipboard conversion for complete fragments.

Keyboard and screen readers

The Windows smoke check covered keyboard movement, Go to Symbol in Editor (Ctrl+Shift+O), completion (Ctrl+Space) and invoking selected C# copy through the Command Palette. NVDA announced the ICS editor, indentation and the merge warning. This is a focused smoke check; broader assistive-technology compatibility has not been established.

Use VS Code's Editor: Accessibility Support setting (auto, or on when needed). Because indentation expresses ICS block boundaries, enable Line indentation reporting in NVDA's Settings → Document Formatting, using Speech or Both Speech and Tones. It is off by default in NVDA. The paired C# view remains available when audible braces are useful. See the NVDA user guide for indentation reporting options.

Settings at a glance

Free live pairing needs no configuration. To change conversion behavior, open VS Code Settings and search for ICS. The three Pro automation settings are ics.displayIcsOnly, ics.autoSaveCSharpFromPreview, and ics.syncOnSave; each is off by default.

Structural C# braces disappear from the ICS view automatically. The optional ics.removeBraces setting also removes eligible braces from regenerated C#. It is off by default.

The control panel's document actions use the last open text tab while the panel has focus. Apply Preview to C# applies a paired preview; Sync Standalone ICS to C# generates a companion for an independent local .ics file and respects the same conversion options. Sync never writes beside a private preview cache. Existing authored C# requires overwrite confirmation unless protection is disabled. A generated-file marker counts only in a leading comment. An unchanged output from the current session can be synced again without prompting; external changes require fresh confirmation.

ics.removeIfConditionParentheses affects simple single-line if and else if headers. Multiline and comment-bearing headers retain their delimiters. ics.tabWidth is a legacy positive whole-number converter input hint and may have no visible effect on native conversion. Native ICS always uses four spaces per level; normal C# columns and formatting follow .editorconfig's indent_size, falling back to tab_width and then four. ics.matchLineNumbers pads toward canonical C# positions and does not guarantee the original file's line count. General panel settings write to the current workspace (or User settings without one); converter command and arguments always write to User settings. A multi-root workspace keeps its window settings in the .code-workspace file. Folder-specific ics.projectPath and ics.targetFramework follow the original source location, including when its native ICS preview lives in private extension storage.

Optional-brace examples and preservation rules · Complete settings reference

Main commands

To toggle the view, press Ctrl+K (Cmd+K on Mac), release both keys, then press I. Ctrl+Alt+S (Cmd+Option+S) applies a preview. VS Code's standard Format Document command also formats ICS.

All commands and shortcuts

Privacy, terms, and output ownership

Conversion, language services, recovery, and diagnostics run locally. The Microsoft .NET Install Tool may contact Microsoft to install or update the required runtime. ICS contacts Lemon Squeezy for Pro licence activation, validation and deactivation. Validation can happen automatically when Pro access is checked and the cached result has expired or is about to expire. Deactivation happens when you request it, or automatically to release an activation that ICS has just rejected, such as a key for a different product. ICS does not claim ownership of source code, ICS files, or generated C# processed or produced using the extension.

• Software license — Elastic License 2.0.
• Product terms — output rights and Free/Pro tier conditions.
• Activation transfer and deactivation policy — moving or changing an ICS Pro activation.
• Privacy notice — local processing and Pro-license data flow.

Reporting bugs

Run ICS: Report Issue to prepare a scrubbed diagnostic in a local editor. Review it before copying anything to the public support tracker. Do not submit proprietary source, license keys, paths, customer information, or other sensitive data.