Features

Everything you need to build for .NET. Nothing to bolt on.

Write, run, debug, test and ship from one fast, native IDE on Windows, macOS and Linux. The tools you'd otherwise collect one extension at a time are already here, and they work together from the first launch.

Download Get started
The editor with inlay hints, Find Results for references to Greet, and the Solution Explorer
EditorRoslyn-powered C# with inlay hints, the minimap, Find All References and the Solution Explorer.
Typing a call in the editor: the completion list below the line with an icon per kind, the selected method's description beside it and the kind filters under it, and parameter info above the line
IntelliSenseCompletion with an icon per kind, kind filters and the selected item's description, and parameter info above the line: the call site's types, the parameter you're typing in bold, in your editor's colors.
The Find and Replace window floating over the editor, with Find Results below
Find in FilesFind and Replace in Files from a floating window: scopes, file types and regular expressions, with every match listed in Find Results in the editor's colors, which filters, groups by folder and file as a tree or a list, and keeps earlier results on their own pages.
The New Project window: recent templates on the left, the search box, language, platform and project type filters, and templates with their descriptions and tags
New ProjectNew Project as the classic IDE's three-page wizard: your recent templates, search and filters over every installed template, then the name, location and solution, then the template's own options for the framework you pick, labeled with its support.
Paused at a breakpoint with a PerfTip, and the Exception Settings window
DebuggingPaused on a line with a PerfTip, and the Exception Settings window, with every debug tool window a tab away.
Debugging a Razor component, paused inside Counter.razor, with the Test Explorer and the Debug Console
BlazorA hosted Blazor app: the server and its WebAssembly page debugged as one session, paused inside a .razor file.
A .http file with run buttons, the HTTP Response window and the Endpoints Explorer
Web APIsSend requests from a .http file, read the response with its status, headers and history, and browse every route in the Endpoints Explorer.
The WCF Test Client with a CoreWCF service's operations, the request form of Greet and its response as a tree
WCFCall a WCF or CoreWCF service from its metadata: a typed form per operation, the SOAP envelope, and the response as a tree, a fault as a chip.
A CPU profiling report: the sample timeline above a flame graph of the program's hot methods
ProfilingRecord a CPU trace, scrub the timeline, and find the hot path in the flame graph, with hot lines marked in the editor.
The model diagram of an Entity Framework Core DbContext, with its entities, keys and relationships, and the migrations list
EF CoreSee your DbContext as a diagram, and add, apply and remove migrations without leaving the IDE.
An Avalonia .axaml file in the editor with the XAML Previewer rendering it beside the code
Avalonia XAMLEdit Avalonia XAML with completion and bindings, and watch the previewer follow every change.
AI Chat beside the editor: a question about the selected method, the files sent with it as chips, and the answer with a code block to copy, insert or apply
AI ChatAsk about your code with the context you choose as chips, and get answers with code blocks in your editor's colors, ready to copy, insert or apply after a preview. Off until you choose a provider.
AI Chat in agent mode: the file it read shown as a step, its explanation, and the edit it proposes as a code block to apply
Agent modeAgent mode reads, searches, builds, edits and runs commands, each step shown in the chat, every change in a preview and every command after you allow it.
Connect to Claude over AI Chat: Node.js and npx found, Claude's ways to sign in, the exact commands it runs, and the box that turns AI assistance on
Connect an agentConnect Claude, Codex, Gemini CLI or GitHub Copilot in one dialog: what it needs, how it signs in and exactly what runs, then a connection test before anything is saved.
The first-run setup's appearance step: Classic, chosen, then Harbor, Graphite, Daylight and Ember as cards, each with a miniature of the IDE in that theme, and the mode
First startThe first start sets it up your way: a theme family and its mode, previewed as you click, then the keyboard scheme, your settings from elsewhere and a tools check.

Make it yours

Classic, and four theme families.

Classic, the default, in Blue, Light, Dark and High Contrast, and Harbor, Graphite, Daylight and Ember, each in Light, Dark and High contrast, following your system or not. A classic layout in each: the menu and search in the title bar, the Solution Explorer on the right, and a status bar colored by state.

Codalus IDE in the Classic family, Light
Classic LightThe default, with tool windows and documents as rounded cards, an outlined tab and a blue accent
Codalus IDE in the Harbor family, Light
Harbor LightClosest to a classic IDE, with a navy title bar
Codalus IDE in the Graphite family, Dark
Graphite DarkCompact, hairlines instead of gutters
Codalus IDE in the Daylight family, Light
Daylight LightFlat, with rounded tabs
Codalus IDE in the Ember family, Dark
Ember DarkWarm, with floating panels

The full list

Everything in the box

Editor

  • Tabs with preview and split views, multiple carets, folding and a minimap
  • Semantic highlighting, and IntelliSense like a classic IDE's: a completion list with an icon per kind, filters (Alt+C classes, Alt+M methods…, Alt+J target type matches), commit characters (Con then . gives Console.), the expected type preselected, and a description beside the selection; parameter info above the line with overloads and the active parameter in bold; Quick Info with fixes for the errors under the pointer. Signatures in your editor's colors, generics as you use them
  • Live diagnostics and an Error List, grouped by project, file, severity or code, with background analysis of open documents, the current project or the solution
  • Rename, code fixes and refactorings, all with previews
  • Snippets, Code Cleanup, format on save and local history
  • Pasted code brings its usings along; editor settings per language, and an EditorConfig settings page
  • CodeLens with references, Git history and test status

Solutions and NuGet

  • .sln and .slnx, SDK-style projects and solution filters
  • Property pages that show where each value comes from
  • Launch profiles, Configuration Manager and Reference Manager
  • Browse, update and consolidate packages; Central Package Management
  • nuget.org's verified owners: a badge after a package whose ID prefix nuget.org reserved for one of its owners, shown only when it can be nobody else's copy (never from a mirror), and search that leaves out what package source mapping wouldn't restore
  • New Project as the classic IDE's three-page wizard: recent templates, search and filters, each template's own options, and the framework with its support
  • The Properties window, Show All Files, Add New Item, templates and External Tools
  • Folder mode for a folder without a solution
  • A solution reopens as you left it: documents, breakpoints, bookmarks, configuration and the Solution Explorer's expansion, kept in a self-ignoring .codalus/state next to it
  • .NET 11 projects with C# 15, every framework from .NET Core 2.0 to .NET 10, and older SDKs in global.json
  • A start window with your recent solutions, pinned and searchable
  • Check Environment: a missing .NET SDK or git offered to install, and the .NET runtime Codalus itself needs: one notification that installs it and starts the helper processes again

Build, run and test

  • Build, Rebuild and Clean on MSBuild, cancellable
  • Colored output: errors, warnings and successes in your theme's colors, standard error in red, and programs' ANSI colors shown as colors
  • A fast up-to-date check, binary logs and build timings
  • Batch Build, build events, and custom tools for ResX and T4, with a resource editor for .resx files
  • Run with Ctrl+F5, and multiple startup projects
  • A Test Explorer for xUnit, NUnit, MSTest and TUnit
  • Code coverage with Coverlet

Debugging

  • Launch (F5) and attach, stepping and threads
  • Conditions, hit counts, logpoints and dependent breakpoints
  • Text, JSON, XML and HTML visualizers, and [DebuggerDisplay]
  • Data tips like a classic IDE's: the header over the hovered expression, each expanded level a tip of its own, members grouped with their icons, List, Dictionary, HashSet, Queue and Stack as their elements, View drop-downs for visualizers, values edited in place and red when they changed, any row pinned, and Ctrl to see through them
  • Pinned data tips that expand like the data tip, PerfTips and Run to Click
  • Locals, Autos, Watch and QuickWatch with the data tip's rows: Name, Value and Type in aligned columns at every depth, expansion kept across steps, values edited in place
  • Dumps, Parallel Stacks and Parallel Watch, and Just-In-Time crash dumps
  • Attach over SSH, in containers and in WSL; console apps in the integrated terminal
  • Blazor WebAssembly in Chrome, Edge or Chromium

Git and hosting

  • Per-file, per-change and per-line staging, from Git Changes or the diff, and blame
  • Diffs and the merge editor in the editor's colors
  • A branch drop-down in Git Changes: search, outgoing and incoming counts, and each branch's own menu (checkout, merge, rebase, update, push, rename, delete, compare)
  • Update a branch from its remote without checking it out
  • A folder's menu in Git Changes, as in the classic IDE: stage, discard, stash, ignore, history, reveal, terminal, copy path
  • A history graph and interactive rebase
  • A 3-way merge editor: check boxes beside each conflict, the merge base in the result, both versions scrolling with it
  • Stash, tags, remotes, worktrees and Git LFS
  • Pull requests, with review comments in the editor
  • GitHub, Azure DevOps and GitLab

Web

  • Razor and Blazor, with C# features inside the markup and components, HTML and directives each in their own color
  • .http files, the HTTP Response window (the status as a chip, the body pretty or raw, the headers, a history of requests) and an Endpoints Explorer
  • HTML, CSS, JavaScript and TypeScript language servers
  • ESLint, Prettier, npm scripts and the Task Runner Explorer
  • Hot Reload through dotnet watch, and while debugging Blazor WebAssembly components, standalone or in a Blazor Web App (its server under dotnet watch with the debugger attached)
  • Scaffolding, OpenAPI and gRPC service references, the dev certificate and user secrets

Data, containers and cloud

  • EF Core migrations, model views and reverse engineering
  • A Database Explorer for SQL Server, PostgreSQL, MySQL and SQLite
  • A query editor with plans and history, a SQL language service and .sqlproj builds
  • Run and debug in containers with docker or podman; Add Docker Support; Compose up, down and debug
  • Aspire AppHosts and their resources
  • Publish profiles, including container images

Make it yours

  • A first-run setup: the theme family and mode, previewed live, the keyboard scheme, your settings from VS Code, a .vssettings file or settings sync, and a check of the .NET SDK and git, before the start window
  • Classic's Blue, Light, Dark and High Contrast, the default, with the classic IDE's rounded cards and editor colors, and four theme families, Harbor, Graphite, Daylight and Ember, each Light, Dark and High contrast, chosen from pictures in Options
  • Fonts and Colors over any theme, for code, the editor and the window
  • Default, VS Code, ReSharper and Emacs keyboard schemes
  • Import from VS Code or a .vssettings file; export to one file
  • Profiles, and settings sync with a folder or a Git repository
  • Customize menus and toolbars; saved window layouts and distraction-free mode

AI assistance, your way

  • Off until you turn it on, with no telemetry; nothing is sent until you choose a provider
  • OpenAI-compatible servers, Ollama on your machine, Anthropic, or a provider plugin; your key in the OS credential store
  • AI Chat with the context you choose as chips: the selection, files, errors, build output and the solution's projects, shown with each question
  • Answers in rendered Markdown, with code blocks in your editor's colors: copy them, insert them at the cursor, or apply them over the selection or the file after a preview
  • Inline suggestions and next edit suggestions, each with its own switch
  • Commit messages, pull request descriptions, Ask AI on an exception or a failing test, Fix with AI, tests for the selection, and profile summaries
  • Agent mode, one switch: it reads, searches, builds, edits and runs commands, each step shown in the chat, every change in a preview and every command after you allow it
  • MCP: your MCP servers' tools in agent mode, and codalus mcp for agents outside the IDE
  • External agents in AI Chat over the Agent Client Protocol (Claude, Codex, Gemini CLI, GitHub Copilot, pi, OpenCode, goose, your own CLIs): Codalus serves their file, terminal and permission requests with its own checks, and gives each one the IDE's tools
  • Connect to Claude, Codex, Gemini CLI or GitHub Copilot from AI Chat in one dialog: it finds or installs Node.js with your own package manager, signs the agent in (Claude subscription through Claude Code's own login, or an API key kept in the OS credential store), tests the connection in an empty folder, and only then saves it; Disconnect undoes it
  • Files .gitignore or a .codalusignore excludes, and secrets, are never sent; a request log of what was

.NET MAUI

  • Android devices and emulators on Windows, Linux and macOS; iOS simulators, iPhones and Mac Catalyst on macOS; Windows Machine (the Windows target) on Windows
  • A device picker on the toolbar and a Devices window: start emulators, boot simulators, choose where the app runs
  • Build, deploy and run with the platform SDK's own run target
  • Debug on Android devices and emulators, iOS simulators and Mac Catalyst with our own Mono debugger: breakpoints, stepping, locals, watch and exceptions
  • MAUI XAML: completion, compiled binding paths from x:DataType, live errors, hover and Go to Definition
  • The MAUI workloads, the Android SDK and a JDK installed when you agree, and listed in Check Environment
  • The Windows target runs and debugs as a desktop app (netcoredbg, Hot Reload with dotnet watch), packaged or unpackaged

WPF, Windows Forms and WinUI 3

  • WPF and Windows Forms projects open, edit and build on Windows, Linux and macOS
  • Run, debug, test and Hot Reload them on Windows; elsewhere the IDE says they're Windows only
  • WPF XAML: completion of controls, dependency and attached properties, markup extensions, styles, triggers and resources through App.xaml and merged dictionaries
  • Binding paths from d:DataContext, checked as warnings; the markup compiler's errors in their XAML files
  • Go to Definition, hover, x:Name rename into the code-behind, and formatting
  • On Windows, the XAML Previewer draws WPF XAML on your app's own WPF as you type: design-time data from d:DesignInstance, the design size, zoom and scale, and a click selects the element's tag
  • On Windows, the Live Visual Tree and Live Property Explorer for running WPF apps: logical and visual trees, dependency property values with their sources, values set live, highlight, pick and Go to XAML
  • On Windows, the Windows Forms designer on your app's own Windows Forms: select, move, resize, nudge, copy and paste controls, the Toolbox with an icon for every control and your own controls, the Properties window and its Events view
  • The Properties window as the classic IDE's: categories that collapse, Font, Location, Size and Padding opened into their parts (each written as one assignment), color, alignment, multi-line text, shortcut key and date drop-downs, the font editor, the String Collection Editor and Select Resource, choices for AcceptButton and Cursor, Reset, and a component list
  • Drag, click or double-click from the Toolbox (or press Enter on an item) to add controls, into the selected container as in the classic IDE
  • Build while a form is open: the designer runs on a copy of your build output, as the classic IDE does, and loads the form on the new build after it
  • Snap lines, the Format menu (align, make same size, spacing, center, bring to front and send to back, Lock Controls), tab order mode, Dock and Anchor pickers and adorners
  • Smart tags with the designers' tasks, menus and tool strips edited in place with Type Here, the component tray, and collection editors for items, columns, tab pages and table styles
  • The designer's context menu as in the classic IDE: the designers' own commands (Add Tab, Edit Items...), Bring to Front and Send to Back, Align to Grid, Lock Controls, Select the parent, Cut, Copy, Paste, Delete and Properties, grayed when they don't apply; Edit's commands and Select All in the designer
  • Localizable forms designed per language into each culture's .resx, images imported into the form's or the project's resources, extender properties such as ToolTip on toolTip1, and data binding to a BindingSource's members
  • The designer writes InitializeComponent as Visual Studio does, as the smallest edit of the designer file: undo, local history and source control see only what changed; code it can't read opens as code with the reason
  • New WPF and Windows Forms projects; windows, pages, user controls, resource dictionaries and forms in Add New Item, nested with their code-behind
  • WinUI 3 apps open and edit everywhere, and build, run, debug and Hot Reload on Windows; packaged (MSIX) apps are registered, started by Windows and attached to, with Developer Mode explained when it's off
  • WinUI XAML: x:Bind paths checked against the page's class as errors, x:Load and x:DefaultBindMode, ThemeResource and resources through App.xaml's merged dictionaries, WinUI's compiler errors in their files

.NET Framework

  • net48, net472 and the other .NET Framework projects open, restore and build on Windows, Linux and macOS, with no targeting pack: the reference assemblies come from NuGet
  • Old-style (non-SDK-style) projects too: packages.config restored, a Dependencies node of their references, hint paths and packages, built with the .NET SDK's MSBuild
  • C# 7.3 in the editor, as the compiler uses it, and binding redirects generated for executables
  • Convert to SDK-Style: an old-style project rewritten as an SDK-style one, packages.config as package references and AssemblyInfo.cs as properties, after a preview of every change
  • Run and debug .NET Framework apps on Windows with our own .NET Framework debugger, on the debugging API that comes with the .NET Framework: breakpoints with conditions, stepping with Just My Code, call stack, threads, locals and watch with C# expressions and method calls, exceptions, and Attach to Process; elsewhere the IDE says it's Windows only
  • xUnit, NUnit and MSTest tests on .NET Framework in the Test Explorer on Windows, old-style test projects included: discover, run and debug
  • Projects that need Visual Studio's own targets (ASP.NET web applications) open with IntelliSense and say why they don't build
  • New .NET Framework console apps and class libraries, and the installed .NET Framework in Check Environment

Visual Basic

  • Completion, Quick Info, signature help and live errors, from the same language service as C#
  • C# and VB projects in one solution: Go to Definition, Find All References and rename across both
  • End If, Next and End Sub added as you press Enter, keyword casing fixed, XML literals' end tags closed
  • Quick fixes and refactorings, formatting, the outline, folding and snippets
  • New Project in Visual Basic, VB item templates, and Option Strict, Explicit, Infer and Compare on the project's properties
  • VB tests in the Test Explorer, and debugging with breakpoints, stepping and locals

F#

  • FsAutoComplete, Ionide's language server, installed for you: completion with unopened namespaces, Quick Info, live errors and FSharpLint
  • Navigation, rename, quick fixes, inlay hints and signature CodeLens
  • Fantomas formatting with your .editorconfig
  • Solution Explorer in compile order: Move Up, Move Down, Add Above and Add Below; signature files under their implementation
  • F# Interactive in the terminal: send a selection, a line, a file or a project's references; reset
  • Scripts with #load and #r "nuget:", type providers, F# analyzers
  • Expecto, xUnit and NUnit tests in the Test Explorer; debugging F#
  • F# item templates and project properties

WCF

  • Add Service Reference with your dotnet-svcutil: from a service's metadata, a WSDL file or a CoreWCF service you run
  • Namespace, collection types, synchronous operations, type reuse and access; Update and Remove
  • References kept as Visual Studio keeps them: Connected Services and ConnectedService.json
  • CoreWCF services from CoreWCF's templates in New Project
  • A WCF Test Client: operations with their signatures, a typed form per operation or raw XML, responses as a tree and faults as chips; BasicHttpBinding and WSHttpBinding
  • system.serviceModel completion, hover and checks in app.config and web.config

And more

  • Remote development over SSH, in WSL and in containers; Dev Containers; reconnecting after a network drop; the Test Explorer and workspace plugins on the remote machine; tests in WSL, Docker or over SSH
  • Profiling: counters, CPU traces and flame graphs, memory snapshots and diffs, allocations, .NET Async, threads, exceptions, file I/O and BenchmarkDotNet
  • Avalonia XAML editing, a live previewer and the Live Visual Tree
  • An integrated terminal and C# Interactive
  • About forty languages highlighted; JSON and YAML schemas
  • Any LSP language server through a plugin
  • A stable plugin API (1.0): themes and file icon themes in VS Code's formats, debug adapters, declarative views and custom editors, file system, sign-in and source control providers
  • Plugin development: a dotnet new template, in-memory plugin tests, debugging a plugin in a development instance, and a generated API reference
  • A Plugin Gallery on NuGet: search, install with the plugin's permissions and signature shown first, automatic updates, and Bisect Plugins to find the one behind a problem
  • Components: everything downloaded on demand, with versions, sizes and licences, and offline layouts for machines without internet access
  • Running tasks in the status bar: loading projects, restores and builds, with a progress bar and cancel

Not there yet: Dev Containers' features and Compose-based Dev Containers, Hot Reload while debugging server-side code, and translations of the interface.

See the roadmap

All of it, in one download.

Download for your platform