A terminal-based UI for managing .NET solutions and projects, inspired by lazygit.

lazydotnet provides an interactive, keyboard-driven interface for common .NET development tasks. Navigate your solution structure, build and run projects, manage NuGet packages, and run tests—all without leaving your terminal.

Important: This project does not include LSP (Language Server Protocol) functionality or debugging capabilities. It focuses on solution/project management and execution tasks.

• .NET 10 runtime or later

dotnet tool install --global lazydotnet

To update to the latest version:

dotnet tool update --global lazydotnet

For the NuGet package update features (checking for outdated packages and updating all packages), install dotnet-outdated:

dotnet tool install --global dotnet-outdated-tool

# Open current directory (auto-detects solution)
lazydotnet

# Open specific solution
lazydotnet MySolution.sln

# Open specific project
lazydotnet --project MyProject.csproj

# Open specific directory
lazydotnet /path/to/project

# Open with explicit solution file
lazydotnet -s MySolution.sln

• Hierarchical tree view of your solution structure
• Navigate projects and nodes with vim-style keybindings (j/k) or arrow keys
• Expand/collapse nodes and project groups
• Visual indicators for running projects with [green](R)[/] marker
• Supports .sln, .slnx, .slnf, and .csproj files

• Build individual projects or the entire solution (b / B)
• Run projects with live log streaming (r)
• Stop running project (s)
• Edit project files in the editor (e)

• View all project references for the selected project
• Add new project references from a picker dialog (a)
• Remove existing references with confirmation (d)
• Jump to referenced projects in the explorer (Enter)
• Open referenced projects in your editor (e)

• View all NuGet packages with current and latest versions
• Color-coded version indicators:
  • Green: Patch update available (safe)
  • Yellow: Minor update available (non-breaking)
  • Red: Major update available (potentially breaking)
• Add new packages via search dialog (a)
• Update individual packages to latest version (u)
• Update all outdated packages with strategy selection (U)
  • Patch (Safe): Bug fixes only
  • Minor (Non-breaking): New features
  • Major (Breaking): Upgrade everything
• Remove packages (d)
• Version picker with available versions (Enter)

• Automatic test discovery for all test providers (xUnit, NUnit, MSTest, etc.)
• Dual protocol support: VSTest (legacy) and Microsoft Testing Platform (MTP)
• Hierarchical test tree view (namespaces → classes → methods)
• Run individual tests, test classes, or entire namespaces (r)
• Filter tests by status (f): All, Running, Failed, or Passed
• View test details including error messages, stack traces, and output (Enter)
• Navigate to test source code (e)

• Live log streaming from running projects
• Auto-scroll to latest output (can be paused)
• Navigate log history with j/k or arrow keys
• Run the current project (r)
• Stop the running project (s)
• Clear execution logs (c)
• Resume auto-scroll with Esc

• Switch between different solutions in the same directory
• Solution picker dialog for directories with multiple .sln files
• Support for solution filters (.slnf) and XML-based solutions (.slnx)

• Automatic in-editor detection: (Zed, VS Code, Cursor, etc)
• Open project files, test files
• Line number navigation for test failures

• Panel navigation: Tab / Shift+Tab or number keys 0-3
• Reload current project/solution data (Ctrl+R)
• Keybindings help (?) showing context-sensitive shortcuts
• Build solution (Shift+B)
• Stop all running projects (Shift+S)

Search is available in some panels.

• Search is per-panel: switching panels preserves each panel's search state
• Matches are highlighted

lazydotnet is not a replacement for the Zed c# extension. It can complement it.

Add this task to your .zed/tasks.json:

[
  {
    "label": "lazydotnet",
    "command": "lazydotnet",
    "use_new_terminal": false,
    "allow_concurrent_runs": false,
    "reveal": "always",
    "reveal_target": "center",
    "hide": "always",
    "shell": {
      "program": "sh"
    }
  }
]

Then add a keybinding to your .zed/keymap.json. For example:

[
  {
    "context": "Workspace",
    "bindings": {
      "cmd-shift-d": [
        "task::Spawn",
        {
          "task_name": "lazydotnet",
          "reveal_target": "center"
        }
      ]
    }
  }
]

Now you can launch lazydotnet with Cmd+Shift+D from Zed.

For Vim mode users, you can use a more specific context like "context": "Editor && VimControl && !VimWaiting && !menu" and bind to space . . or any key combination you prefer.

• This project is based on the idea of lazygit.
• Special thanks to easy-dotnet for the inspiration.
• Built with Spectre.Console for beautiful terminal UI.

• easy-dotnet.nvim - A Neovim plugin for .NET development.
• DotRush - A VS Code extension alternative to C# Dev Kit that works in all VS Code forks.

MIT License - See LICENSE for details.

Contributions are welcome! Please feel free to submit a Pull Request.