I need a code editor that supports remote development via SSH and does not lag on large files.

If SSH remote development + responsiveness on large files are the priorities, I’d shortlist these:

1. Zed — my top pick

• Native Rust editor designed around low latency.
• Its SSH remote-development architecture keeps the UI local while the codebase, language servers, terminal, and tasks run remotely.
• Zed specifically positions itself for large codebases and performance-sensitive workflows.
• Caveat: very large directories (100k+ files) can still be problematic, so open a specific project/subdirectory rather than an entire filesystem.

2. Visual Studio Code + Remote SSH — safest all-rounder

• Extremely mature SSH workflow; VS Code Server runs on the remote machine, so language tooling and extensions operate close to the code.
• Much larger extension ecosystem than Zed.
• For huge individual files, however, I'd favor Zed or a terminal editor if your primary concern is avoiding UI stalls.

3. Neovim — performance champion

• Runs directly on the remote machine over SSH, so there is essentially no remote filesystem/UI synchronization layer.
• Excellent for enormous files and low-bandwidth connections.
• The tradeoff is configuration and a much less conventional GUI workflow.

My recommendation

Try Zed first. It is probably the closest match to “modern GUI editor, SSH remote development, and don't make me wait when working in a big codebase.” Its remote architecture is specifically designed to keep the interactive UI local while pushing computational work to the remote machine.

If you depend heavily on VS Code extensions, choose VS Code Remote SSH instead. If you're routinely opening multi-hundred-MB logs, generated files, or enormous single files, I'd seriously consider Neovim for those files.

zed.dev ·

When dealing with large files over SSH, standard web-based or heavy Electron-backed remote extensions (like vanilla VS Code Remote-SSH) often lag because they try to parse, index, or watch massive amounts of text across the wire.

The best options for handling massive files smoothly over a remote SSH connection depend on whether you prefer a modern graphical interface or a terminal-based setup:

1. Sublime Text (via SSHFS / Local Mount)
   • How it works: Instead of running a heavy remote server plugin, you mount your remote server directory locally using SSHFS or SFTP, and open the folder in Sublime Text.
   • Why it doesn't lag on large files: Sublime Text is written in C++ [Sublime Text] and has legendary, industry-leading performance when opening and rendering huge single files (gigabyte-scale logs or massive data dumps) that crash or freeze VS Code. Because the rendering happens locally on your machine against a cached mount, editing is instantaneous.
2. Neovim / Vim (Running directly via SSH inside tmux)
   • How it works: You SSH directly into your server and run Neovim inside a terminal multiplexer like tmux.
   • Why it doesn't lag on large files: There is no network overhead trying to sync a heavy GUI DOM tree. Neovim loads only the visible portion of the file into memory buffers, making it extraordinarily fast for massive files. Paired with tmux , you can drop your connection and reattach without losing your place.
3. JetBrains IDEs via JetBrains Gateway (Remote Development)
   • How it works: JetBrains runs a headless backend IDE on your remote server and streams the thin client interface to your local machine via JetBrains Gateway.
   • Why it doesn't lag on large files: Unlike VS Code's extension model which can choke on single giant files or massive projects, JetBrains handles heavy indexing server-side. Note: It requires a beefier remote server with plenty of RAM, but it handles large codebases and complex navigation much better than single-process editors.

To help narrow down the ideal choice, do you need:

• A Graphical User Interface (GUI) vs. a terminal interface?
• To edit massive single files (like 500MB+ logs) or just a large codebase/repository?

If your priorities are SSH remote development + staying responsive with large files, I’d shortlist these:

1. Zed — best for raw responsiveness

• Native Rust/GPU-accelerated editor, designed around low latency.
• SSH remote development runs the project, terminal, language servers, and tasks on the remote machine while the UI stays local.
• Particularly attractive if you routinely open large logs/source files.
• Caveat: Zed's extension ecosystem is much smaller than VS Code's, and very large directories (>100k files) are a known limitation.

2. Visual Studio Code — best all-around choice

• Remote - SSH is extremely mature: VS Code runs its server and extensions on the remote machine, so you aren't dragging an entire remote filesystem across SSH.
• Much larger extension ecosystem and better choice if you need Docker, Kubernetes, language-specific tooling, debugging, etc.
• For large files, performance can vary considerably depending on extensions and indexing, so I'd keep the extension count lean.

3. Neovim — best if terminal-native is acceptable

• Extremely lightweight and excellent for huge files when configured appropriately.
• SSH is effectively a non-issue because you can run Neovim directly on the remote host.
• The tradeoff is setup and IDE-like functionality: you'll be assembling LSP, debugging, file navigation, etc. yourself.

My pick

Try Zed first if your main complaint is editor lag. Its architecture is particularly well matched to your requirements: local responsive UI + remote computation over SSH.

Choose VS Code instead if you need a broad extension ecosystem or sophisticated remote/container tooling. Its Remote-SSH architecture is explicitly designed to avoid the performance problems of editing through SSHFS/network-mounted filesystems.

If you tell me your OS (Windows/macOS/Linux), typical largest file size (e.g. 500 MB logs), and language, I can narrow this to the best 1–2 options.

Neovim (or Vim) running inside an SSH terminal session (often paired with Tmux ) is the best choice for remote development that handles massive files without lagging.

Unlike Electron-based IDEs that stream UI elements or load entire files into local memory buffers, terminal-based editors execute directly on the remote host. They consume minimal network bandwidth, bypass GUI rendering bottlenecks, and effortlessly handle multi-gigabyte files using native chunking and virtual memory mapping.

Top Code Editors for Remote SSH & Large Files

• Neovim / Vim : Executes directly on the remote server via SSH, meaning zero latency from network roundtrips for keystrokes. It handles huge files smoothly because it only loads the visible buffer into memory. You can enhance it with modern configurations like LazyVim or AstroNvim for IDE-like features.
• JetBrains Gateway : Connects your local machine to a JetBrains Remote Development backend over SSH. The heavy lifting (indexing, parsing) happens on the remote server, and the thin client streams a responsive UI. It manages large codebases and files much better than web-technologies, though it requires substantial RAM on the host server.
• VS Code (Remote - SSH) : The most popular choice via the VS Code Remote - SSH Extension , but it can lag on massive files or weak network connections because it runs a Node.js server instance on the remote machine. Use it only if your files are moderately large and you heavily rely on complex GUI extensions.

Comparison of Remote Workflows

To help narrow down the ideal setup, tell me:

• What is the average size of the large files you work with (megabytes or gigabytes)?
• Do you prefer a terminal-based interface or a traditional graphical UI?

If SSH remote development + responsiveness on large files are your two priorities, I’d shortlist these:

1. Zed — my top pick

• Native, performance-focused editor with a local UI and remote code/language servers over SSH.
• Its architecture keeps editing/rendering local while computation happens remotely.
• Particularly attractive if VS Code starts feeling sluggish with large projects or lots of extensions.
• Caveat: Zed currently advises against opening enormous directories containing 100k+ files; open a specific project/subdirectory instead.

2. Neovim — fastest/lightest option

• Excellent for very large files and projects, especially if you're comfortable with Vim-style editing.
• You can simply run Neovim on the remote machine over SSH, avoiding a remote-filesystem layer entirely.
• Less polished than Zed/VS Code for graphical debugging, extensions, and integrated workflows.

3. Visual Studio Code + Remote - SSH — best ecosystem

• Very mature SSH workflow: the VS Code server and extensions run on the remote host while the UI remains local.
• Huge extension ecosystem and excellent debugging/LSP support.
• However, Microsoft's own documentation notes performance limitations in some remote/bulk-file scenarios, so I wouldn't make it my first choice if "doesn't lag on large files" is the primary requirement.

My recommendation

Try Zed first. It gives you the closest combination of a modern GUI editor, native responsiveness, and proper SSH remote development.

If you're dealing with gigabyte-scale logs, generated files, huge JSON, minified JS, or files with millions of lines, I'd lean toward Neovim (or a specialized large-file editor) rather than a full IDE.

If you tell me your OS (Windows/macOS/Linux) and roughly how large the files are (e.g. 100 MB, 500 MB, 2 GB), I can narrow it down to the best 1–2 choices.

When you need robust remote development via SSH combined with smooth performance on large files, standard GUI editors like VS Code can sometimes struggle or lag if you hit massive files (due to memory mapping, syntax tokenization, or extension overhead on the remote server).

The best options depending on your workflow and tolerance for terminal-based tools include:

• Neovim (or Vim) with Remote SSH: This is the gold standard for zero lag on massive files. Because it doesn't run a heavy GUI daemon or complex syntax highlighters (like Tree-sitter) by default on gigantic files, it opens instantly over an SSH session. You can use native SSH or tools like mosh or Neovim plugins/LSPs. If a file is exceptionally large, you can disable heavy plugins or use a large-file configuration to keep things lightning-fast.
• JetBrains IDEs (PhpStorm, PyCharm, IntelliJ IDEA, etc.): JetBrains has a dedicated JetBrains Remote Development architecture via SSH. It runs the heavy backend IDE engine on the remote server and streams the UI to your local client. They handle large files and massive codebases significantly better than Electron-based apps because of aggressive indexing and optimized memory management, though they do demand healthy RAM on the remote server.
• Visual Studio Code (with Remote - SSH): While VS Code's VS Code Remote - SSH is the most feature-rich for remote workflows, it can lag or bog down if you open multi-megabyte/gigabyte single files because its tokenization and extensions try to parse the buffer. However, VS Code does automatically disable certain features (like linting or complex maps) when it detects a very large file. It’s a great middle ground as long as your "large files" aren't multi-gigabyte logs.
• Sublime Text (via SSH/SFTP or Remote Mounting): Sublime Text is legendary for opening huge files instantly because of its optimized custom rendering engine. However, it doesn't have a native client-server remote daemon like VS Code; you typically use it alongside remote filesystem mounting (like SSHFS) rather than a direct native SSH host plugin.

To help narrow this down, could you tell me:

• How large are the files you are dealing with (Megabytes? Gigabytes?)
• Do you prefer a terminal/keyboard-driven environment (like Neovim) or a full graphical IDE?

If SSH remote development + large-file performance are the priorities, I’d shortlist these:

1. code.visualstudio.com — best overall

• Its Remote-SSH extension runs the VS Code Server and extensions on the remote machine, rather than treating the remote filesystem like a slow network drive.
• Excellent ecosystem and debugging/IntelliSense support.
• My first choice if you're routinely opening multi-MB logs, generated code, JSON/XML, or large source files.
• Avoid SSHFS for the actual workspace; VS Code specifically notes that SSHFS is significantly slower for this kind of work.

2. zed.dev — fastest-feeling alternative

• Zed keeps the UI and text rendering local while the project, terminal, language servers, and tasks run remotely over SSH.
• Very snappy for ordinary editing.
• Caveat: Zed currently acknowledges problems with extremely large directories, and there are recent reports of large files/repositories being slower than VS Code in some SSH scenarios.
• I'd try it, but wouldn't pick it over VS Code if huge files are your main requirement.

3. jetbrains.com / other JetBrains IDEs — best for heavy IDE features

• Remote Development puts the IDE backend on the remote machine, including indexing, analysis, building, testing, and debugging.
• Great for Java/Kotlin, Python, Go, etc., where deep IDE analysis matters.
• Heavier than VS Code/Zed, so I wouldn't choose it solely for raw editor responsiveness.

My recommendation

Start with VS Code + Remote-SSH. It's the safest combination for your requirements: mature SSH architecture, remote execution, excellent handling of remote projects, and a huge extension ecosystem.

If your definition of "does not lag" is specifically opening/editing enormous files (say 100 MB+ logs, JSON, XML, SQL dumps, etc.), tell me roughly how large the files are and what OS you're using locally/remotely. I can narrow this down considerably—including editors like Neovim, Sublime Text, Helix, and Emacs that may perform better for truly gigantic files.

For remote development via SSH combined with blistering performance on large files, standard Electron-based editors (like VS Code or Cursor) often lag or consume excessive memory when parsing massive single files over a remote connection.

The top-performing options that solve both requirements depend on whether you prefer a modern graphical interface or a terminal-native environment:

• Neovim (Running directly on the remote server via SSH / Tmux):
  • Why it fits: Because Neovim runs directly on the host machine where the file lives, there is zero network serialization lag while editing. It handles massive files exceptionally well, especially when configured to disable heavy line-wrapping or unnecessary syntax highlighting plugins for extreme file sizes.
  • The Remote Setup: Log in via terminal, use tmux to persist sessions, and run nvim . You get native speed with full access to the file system.
• JetBrains IDEs (PyCharm, IntelliJ, GoLand, etc. via Gateway / Remote Development):
  • Why it fits: JetBrains uses a thin client on your local machine and runs the heavy IDE backend directly on the remote server via SSH. Their text rendering engine handles large files and heavy indexing much more gracefully than VS Code's editor components, without choking on large payloads.
  • How to use it: Download the official JetBrains Gateway to spin up secure, lag-free remote connections.
• Sublime Text (Combined with SSHFS):
  • Why it fits: Sublime Text is written in C++ and is legendary for opening huge log files or multi-megabyte source files instantly without lagging.
  • The Remote Setup: Mount your remote server's directory locally using an efficient utility like sshfs , then open the local mount in Sublime. Local processing avoids remote GUI lag entirely.

To help narrow down the best fit, let me know:

• Do you prefer a terminal-based workflow (like Neovim/Vim) or a full graphical IDE?
• Roughly how large are the files/projects you are working with (e.g., MBs vs. GBs)?

If you love the smooth, lag-free performance of native apps when dealing with massive files but need robust remote SSH capabilities, the top choices balance high-speed rendering with remote host integration.

• Zed Editor : A high-performance, open-source code editor written in Rust. It renders via the GPU using a custom framework (GPUI) rather than running on Electron. It handles massive files and high-refresh-rate scrolling seamlessly without lagging, and it features native, stable SSH remote development workflows that run the UI locally while executing language servers and terminals on your remote host. You can check out the Zed Remote Development Docs to get started.
• Visual Studio Code : The industry standard for remote development via the Remote - SSH extension . While VS Code is Electron-based and can occasionally stutter or lag when opening exceptionally large log or data files compared to native editors, it remains the most feature-complete environment with unmatched extension support. If you choose VS Code, you can mitigate large-file lag by installing extensions tailored for big files or adjusting memory limits, but out-of-the-box raw performance on multi-megabyte files won't match a native tool like Zed.
• Neovim / Emacs : The ultimate lightweight choice for remote work over a direct SSH/mosh session. Combined with plugins or run natively inside the terminal, they consume virtually zero overhead and never lag on large files. However, they lack a traditional out-of-the-box graphical IDE experience unless heavily customized.

If you want to narrow this down, let me know:

• Are you looking for a pure GUI editor or comfortable with a terminal-based workflow?
• Roughly how large are the files you work with (megabytes, lines of code)?

If your priorities are SSH remote development + staying responsive with very large files, I’d shortlist these:

1. Visual Studio Code — best overall

• Its Remote-SSH architecture runs the VS Code server, extensions, language servers, terminals, etc. on the remote machine, while the UI stays local.
• This avoids the performance problems you can get from SSHFS/network-mounted filesystems; Microsoft specifically recommends Remote-SSH over SSHFS for performance.
• My pick if you routinely work with multi-GB repos, generated files, logs, or huge monorepos.

2. Zed — best if responsiveness is your #1 priority

• Zed keeps its UI, parsing, and syntax highlighting local while putting the source code, language servers, terminal, and tasks on the remote server.
• Its recent releases have specifically improved input performance in large files.
• Caveat: Zed still has reported issues with very large files and large repositories, so I wouldn't choose it over VS Code if "huge files must never lag" is non-negotiable.

3. Neovim — fastest/lightest, but more DIY

• Excellent for enormous files and low-resource environments.
• However, running Neovim through SSH means editing operations themselves happen remotely, so network latency can become noticeable.
• Best if you're comfortable living in a terminal and configuring your own tooling.

My recommendation

Start with VS Code + Remote-SSH. It's the safest choice for your requirements because the architecture is explicitly designed to avoid network-filesystem latency, and it has the broadest ecosystem.

If you're willing to trade some ecosystem maturity for a very snappy native-feeling UI, try Zed alongside it.

One important distinction: don't mount the remote filesystem with SSHFS and then edit it locally if large-file performance matters. That puts filesystem operations across the network and can become a major bottleneck.