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

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.

When dealing with remote SSH development combined with massive files, performance bottlenecks usually come from two places: network latency (sending every keystroke/render chunk over the wire) or heavy UI threads choking on long lines or missing syntax-highlighting limits.

The top options that handle SSH remoting and large-file performance exceptionally well include:

• Zed : An extremely high-performance, GPU-accelerated editor built in Rust. Zed features native Zed Remote Development via SSH . Because the UI runs locally on your machine (utilizing your local GPU and native OS rendering) while only language servers and terminals run on the remote host, it avoids the sluggishness of web-tech-based UIs. It handles large files gracefully due to its high-throughput architecture.
• VS Code (with Remote - SSH) : While standard VS Code can lag if extensions go wild on huge files, Visual Studio Code Remote Development is still a powerhouse if tuned correctly. To prevent lag on large files, you can increase or disable the large file warning threshold ("editor.largeFileOptimizations": false or adjusting "maxTokenizationLineLength" ), which disables heavy syntax highlighting and tokenization for massive logs or data files that choke the renderer.
• Neovim / Vim (running directly over SSH or via client-server) : If you are willing to use a terminal-based editor, running Neovim directly inside an SSH session (optionally paired with tmux ) uses minimal bandwidth. For large files, you can use performance plugins like bigfile.nvim which automatically disable heavy features (like treesitter syntax highlighting, LSP attachments, and matchparen) when opening massive files, ensuring it never lags.
• JetBrains IDEs (via Remote Development / Gateway) : JetBrains offers JetBrains Remote Development via SSH using a thin client locally and a heavy IDE backend on the server. While resource-heavy on the server side, it manages massive codebases well, though it can feel sluggish if your network latency fluctuates.

To help narrow down the best fit for your workflow, tell me:

• What programming languages or file types (e.g., gigabyte-sized JSON/logs, massive C++ codebases) are you working with?
• Do you prefer a GUI-based editor or a terminal-based (Vim/Emacs) environment?

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

1. Zed — my first pick

• Native, performance-focused editor.
• Its SSH remote-development architecture keeps the UI local while source code, language servers, terminals, and tasks run on the remote machine.
• Recent releases specifically include improvements to large-file input performance.
• Caveat: Zed still has some rough edges with extremely large repositories/directories, particularly directories containing 100,000+ files.

2. Visual Studio Code + Remote SSH — safest overall

• Extremely mature SSH support: VS Code runs a server on the remote host, while your editor UI stays local.
• Excellent extension ecosystem and debugging/IntelliSense.
• For genuinely huge files, avoid loading unnecessary extensions and language features; VS Code can become resource-heavy with a large extension stack.

3. Neovim — fastest/leanest option

• Run it directly on the remote server over SSH, so there's essentially no remote filesystem/UI protocol to introduce latency.
• Particularly compelling for enormous files and high-latency connections.
• Tradeoff: significantly more setup and a less conventional GUI experience. Zed itself notes Neovim as the stronger choice for terminal-native SSH workflows.

4. IntelliJ IDEA — best if you're in the JetBrains ecosystem

• Remote Development puts the IDE backend on the remote server, letting you use more powerful remote hardware.
• Excellent for Java/Kotlin and similarly sophisticated IDE workflows, but heavier than Zed or Neovim.

My recommendation

Try Zed first if you want a modern GUI editor and your biggest complaint is lag. Its architecture is particularly well matched to remote development, and recent releases have continued improving large-file performance.

If Zed doesn't handle your particular giant files/repository well, VS Code Remote SSH is the next one I'd try. If the files are truly enormous (hundreds of MB/GB) and you care more about raw responsiveness than IDE features, Neovim over SSH is the strongest choice.

If you tell me your OS, typical file size (e.g. 50 MB vs 2 GB), and whether the remote machine is Linux, I can narrow this down to one.

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

1. Zed — my first choice for speed. Zed is a native Rust editor designed around low latency, and its SSH remote-development architecture keeps the UI, parsing, and syntax highlighting local while running the source tree, language servers, terminal, and tasks remotely. GitHub Zed Caveat: Zed still has known rough edges with very large directories, and recent users have reported slow opening of some large remote files.
2. VS Code + Remote-SSH — safest overall choice. Its Remote-SSH extension runs the development environment on the server while keeping the editor experience local. It has a much larger extension ecosystem and is particularly mature for remote workflows. Visual Studio Code Visual Studio Code If by “large files” you mean huge individual files (100+ MB logs, generated JSON/XML, etc.), I'd lean toward testing VS Code against Zed rather than assuming Zed wins.
3. JetBrains IDEs — best if you need a full IDE. Remote Development puts the IDE backend on the remote machine and uses a local JetBrains Client. JetBrains specifically describes its remote protocol as designed to make typing feel instant. JetBrains I'd choose this for Java/Kotlin, C++, Python, etc. when you need sophisticated refactoring/debugging rather than a lightweight editor.

My recommendation

Try Zed first if your workflow is mostly editing code over SSH and responsiveness is your #1 concern. Choose VS Code Remote-SSH if you need maximum compatibility, extensions, or particularly dependable handling of unusual/huge files.

One important distinction: large repositories and large individual files stress editors differently. If you tell me roughly how large your files are (e.g. 10 MB, 100 MB, 1 GB) and whether you're on Windows, macOS, or Linux, I can narrow this down considerably.

Finding a tool that balances a smooth GUI or comfortable editing experience via SSH and stellar performance on massive files can be tricky. Standard IDEs often lag on large files because they attempt full syntax parsing, tokenization, or linting across the entire buffer at once.

Here are the top options that fit these criteria, depending on your preferred workflow:

• Neovim / Vim : The gold standard for zero lag on massive files over SSH. Running a terminal editor directly on the remote host means zero file-transfer overhead and instantaneous rendering. Modern distributions like LazyVim or NvChad give it a modern IDE-like feel with file trees and autocomplete without sacrificing the core C-accelerated speed.
• GNU Emacs with TRAMP : If you want to edit remote files transparently via SSH without running the editor head-to-tail in a terminal session, Emacs via TRAMP Mode connects seamlessly. Emacs handles large files very gracefully (especially when turning off global font-lock/syntax highlighting for massive buffers), though it has a steep learning curve.
• Sublime Text (via SSHFS / Mounting): Sublime Text is legendary for its blazing-fast performance and ability to open multi-gigabyte files instantly without choking. However, it lacks native remote SSH features. The workaround is mounting your remote directory locally using an efficient tool like SSHFS or Mutagen , then opening the local mount in Sublime.
• Visual Studio Code (with caveats): VS Code's Remote - SSH extension runs a headless server on the remote machine, which solves general remote dev wonderfully. However, it will lag if you open single oversized files (like 100MB+ logs or minified bundles) because its internal editor buffer and language servers struggle with extreme line lengths. If you use VS Code, you have to explicitly disable heavy extensions (like certain linters or language servers) on a per-workspace basis when handling giant files.

To help narrow down the ideal choice, let me know:

• Are you looking for a terminal-based interface (TUI) or a traditional desktop GUI?
• Roughly how large are the "large files" you are working with (megabytes or gigabytes)?

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

🥇 My pick: Zed

Zed is probably the best match if lag is your biggest complaint. It's a native Rust/GPUI editor designed around low latency, and its remote-development architecture keeps the UI local while running the codebase, language servers, terminal, and tasks on the SSH machine.

The main caveat: Zed currently doesn't handle enormous directories particularly well—its docs recommend opening a specific project/subdirectory rather than something like a home directory containing 100,000+ files.

🥈 VS Code if you need the ecosystem

Visual Studio Code + Remote - SSH is the safer choice if you need debugging, Docker/dev containers, specialized language extensions, or a mature workflow. The Remote-SSH extension runs the VS Code server and extensions on the remote machine rather than repeatedly transferring project files over SSH.

For large files specifically, I'd keep VS Code's extensions to a minimum and avoid indexing unnecessary directories.

🥉 Sublime Text for truly enormous individual files

Sublime Text remains exceptionally lightweight and is explicitly known for handling large files without lag. zed.dev The downside is that its SSH/remote-development story isn't as integrated as Zed or VS Code.

Bottom line:

• Want the fastest modern editor: Zed
• Want the most capable remote-development environment: VS Code
• Opening multi-GB logs/data files is the main job: Sublime Text

If you tell me your OS (Windows/macOS/Linux), typical file size (e.g. 500 MB vs 5 GB), and whether the SSH server is Linux, I can narrow this down to the best choice and configuration.

When you need native or near-native remote SSH development combined with high performance on large files, your choices depend heavily on your tolerance for terminal-based workflows versus full graphical user interfaces (GUIs).

Here are the best code editors that fit these requirements, ranked by how they handle remote connection and large-file performance:

• Visual Studio Code (with Remote - SSH Extension ): This is the industry standard for GUI-based remote development. It runs a lightweight server on the remote host, meaning all file operations, Git commands, and language servers (LSPs) execute on the remote machine while streaming the UI locally. Large file handling: VS Code handles large files reasonably well because it automatically disables heavy features (like tokenization or complex linting) on files exceeding specific size limits. However, extremely massive files (>10 MB) can still cause Electron-based stuttering if extensions aren't carefully managed.
• Neovim (via Remote-NVIM or native terminal SSH): Running Neovim directly over an SSH terminal or via a decoupled client-server setup provides the lowest possible memory footprint and unmatched speed. Large file handling: Unlike many GUI editors that attempt to parse the entire DOM or heavy syntax trees at once, Neovim handles large files gracefully—especially if you configure it to disable heavy plugins (like aggressive Git-blame or heavy Tree-sitter parsers) for giant buffers.
• Zed (with Native SSH Support ): A high-performance, GPU-accelerated editor written in Rust. Zed has built-in remote SSH capabilities that feel remarkably instantaneous compared to Electron-based IDEs. Large file handling: Because Zed is engineered from the ground up for extreme UI responsiveness and low latency, it outperforms VS Code on raw rendering speed, though you should still disable heavy language servers if you open multi-megabyte single-source files.
• Emacs (with TRAMP Mode ): A classic choice for power users. TRAMP allows you to transparently edit remote files over SSH without needing a pre-installed daemon on the other end. Large file handling: Emacs deals with massive log files or huge single-file codebases better than most modern editors if opened in fundamental-mode , avoiding the memory bloat that plagues modern web-technology editors.

To help narrow down the ideal choice, could you share:

• Are you looking for a graphical interface (GUI) or a terminal/TUI environment?
• Roughly how large are the files you work with (e.g., hundreds of kilobytes, or multi-gigabyte logs/data files)?

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

1. Zed — my top pick

   • Native Rust editor designed around low latency.
   • Remote development runs the codebase, language servers, terminal, and tasks on the SSH server while the UI stays local.
   • Particularly attractive if you regularly work with huge files or large codebases.
   • Caveat: Zed currently doesn't handle very large directories (>100,000 files) especially well, so open a specific project/subdirectory rather than an enormous monorepo root.

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

   • Extremely mature SSH workflow; VS Code Server and extensions can run on the remote machine.
   • Best choice if you depend on specialized extensions, debuggers, language tooling, or team-standard VS Code configurations.
   • The downside is that VS Code's Electron/extension architecture can become noticeably heavier with large projects and lots of extensions.

3. Neovim — fastest/minimalist option

   • Run it directly on the SSH server, so there is essentially no remote-file synchronization layer.
   • Excellent for enormous files and low-bandwidth SSH connections.
   • Tradeoff: substantially more setup/configuration if you want IDE-like LSP, debugging, project navigation, etc.

My recommendation

Try Zed first. It is unusually well matched to your two requirements: its UI is local and lightweight, while the expensive language-server/project work happens remotely. Zed specifically positions its remote workflow around staying responsive with remote/large codebases.

If you tell me your OS (Windows/macOS/Linux), typical file sizes (e.g. 100 MB vs 2 GB), and whether you need VS Code extensions, I can narrow it down to the best 1–2 choices.

If you are working with large files (several megabytes to gigabytes of logs, minified assets, or massive datasets) over SSH, mainstream Electron-based editors like VS Code or Cursor will often lag, freeze, or choke because they attempt to parse or syntax-highlight the entire buffer into memory.

The best options that genuinely excel at remote SSH workflows and handle large files smoothly are categorized below by style:

• Neovim (with LazyVim or LunarVim) : The absolute gold standard for remote performance. Running Neovim directly inside an SSH terminal (combined with a multiplexer like tmux ) means zero file transfer overhead—the rendering happens entirely on the host and only text characters are sent to your screen. Neovim handles massive files instantly without breaking a sweat, and you can configure plugins over SSH to mimic full IDE functionality.
• Lapce : A modern, extremely fast code editor written in Rust. It features native performance, handles large monorepos and big files exceptionally well compared to web-tech-based editors, and supports remote development workflows.
• Helix : A post-modern modal text editor (similar to Neovim) also written in Rust. It runs directly in the terminal via SSH, features built-in multi-cursor support, and uses tree-sitter for lightning-fast incremental syntax highlighting that doesn't lag on large files.
• GNU Emacs (with TRAMP) : If you prefer traditional keybindings and a GUI or powerful terminal interface, Emacs connects natively to remote files via its built-in TRAMP mode (/ssh:user@host:/path/to/file ) without needing complex background agent installations on the server. It is legendary for handling deep text manipulation and large files if tuned properly.
• Sublime Text (via SFTP/SSH mount) : While Sublime doesn't have a native "remote daemon" protocol like VS Code, it is unmatched in raw UI responsiveness and large-file handling. Paired with a robust local-to-remote mounting tool or package, it stays completely lag-free.

To help narrow down the ideal choice, let me know:

• Do you prefer a terminal-based UI (TUI) like Vim/Helix or a traditional graphical interface (GUI)?
• How large are the files you are dealing with (e.g., 10 MB, 500 MB, or multi-gigabyte logs)?