This is by LLM but was verified by me, so I put it here. Added my comments.
IDEs (Integrated Development Environments) have a broader scope than LSPs (Language Server Protocols). LSPs primarily focus on providing language-specific features like code completion, diagnostics, and go-to-definition. IDEs build upon this foundation and offer much more. Here's a breakdown of functionalities commonly found in IDEs but not typically handled by LSPs:
- Project Management: IDEs often have built-in tools for managing projects, including creating new projects from templates, managing dependencies, building and running projects, and version control integration (Git, SVN, etc.). LSPs don't handle project-level concepts.
some additions: framework all provide their own template, like
npx create xxx , or cargo new name npm init , make up for lsp.- Debugging: While some debugging capabilities might leverage the LSP's capabilities for things like evaluating expressions, the core debugging experience (breakpoints, stepping, variable inspection, etc.) is typically implemented by the IDE, not the LSP. DAP (Debug Adapter Protocol) is a separate protocol often used alongside LSP for debugging.
I hardly use debugging though.
- Refactoring across multiple files/languages: While an LSP can provide refactoring suggestions within a single file, IDEs can orchestrate more complex refactorings that span multiple files or even multiple languages within a project.
Now we have LLM (doge
- GUI Builders/Designers: IDEs frequently include visual tools for designing user interfaces, which are outside the scope of LSPs.
- Integrated Terminal/Console: IDEs often provide an integrated terminal or console for running command-line tools directly within the IDE.
who need this?
- Plugin Ecosystem/Extensibility: IDEs have rich plugin ecosystems that allow developers to extend the functionality of the IDE in many ways, whereas LSPs don't typically have a plugin model themselves.
For vscode, plugins are same level as lsp. So people can only directly change lsp, not add plugins to it.
- Deployment and Testing tools: IDEs might include features for deploying code to various environments or for running automated tests, which are typically beyond the scope of LSPs.
this is… well, r-a has click-and-debug tools.
- Code profiling and performance analysis: While some analysis might leverage information from the LSP, the overall profiling and performance analysis tools are usually implemented by the IDE.
just use framegraph
- Customization of the UI/UX: IDEs generally offer extensive customization options for the user interface, allowing developers to tailor the look and feel to their preferences. LSPs don't deal with the user interface.
who need this :)
- Integration with other development tools: IDEs are often integrated with other tools in the development workflow, such as database clients, build systems, and issue trackers. LSPs generally focus on the code editor interaction.
use editor’s plugin :)
In summary, LSPs excel at providing language-specific intelligence, while IDEs provide a more complete development environment with features that extend beyond individual language support. Think of the LSP as being the engine for code understanding, while the IDE is the car built around it.
