---
title: "Plugins IDE e Suporte a Editores para Zig"
url: "https://ziglang.com.br/ecossistema/plugins-ide-e-suporte-a-editores-para-zig/"
markdown_url: "https://ziglang.com.br/ecossistema/plugins-ide-e-suporte-a-editores-para-zig.MD"
description: "Guia completo dos plugins e extensões para desenvolvimento Zig: VS Code, Neovim, Emacs, Sublime Text, IntelliJ, Helix e mais editores."
date: "2026-02-21"
author: "Zig Brasil"
---

# Plugins IDE e Suporte a Editores para Zig

Guia completo dos plugins e extensões para desenvolvimento Zig: VS Code, Neovim, Emacs, Sublime Text, IntelliJ, Helix e mais editores.


# Plugins IDE e Suporte a Editores para Zig

Um bom ambiente de desenvolvimento é fundamental para a produtividade. O ecossistema Zig oferece suporte a praticamente todos os editores populares, principalmente através do [ZLS (Zig Language Server)](/ecossistema/zls-language-server/) que implementa o protocolo LSP. Este guia cobre a configuração detalhada para cada editor, plugins adicionais e dicas de produtividade.

## VS Code — O Editor Mais Popular

O Visual Studio Code é o editor mais utilizado pela comunidade Zig, com suporte excelente.

### Extensão Oficial: Zig Language

```
Nome: Zig Language
ID: ziglang.vscode-zig
Marketplace: Visual Studio Code Marketplace
```

**Instalação**: Abra o VS Code, pressione `Ctrl+Shift+X`, busque "Zig Language" e instale.

### Funcionalidades

- Syntax highlighting avançado
- Integração com ZLS (autocompletar, diagnósticos, hover)
- Formatação automática com `zig fmt`
- Snippets para padrões comuns
- Integração com o sistema de build
- Debug com CodeLLDB ou C/C++ extension

### Configurações Recomendadas

```json
// settings.json
{
    "zig.path": "zig",
    "zig.zls.path": "zls",
    "zig.zls.enableAutofix": true,
    "zig.formattingProvider": "zls",
    "zig.zls.enableSnippets": true,
    "zig.zls.enableInlayHints": true,
    "editor.formatOnSave": true,
    "[zig]": {
        "editor.defaultFormatter": "ziglang.vscode-zig",
        "editor.tabSize": 4,
        "editor.insertSpaces": true
    }
}
```

### Debug no VS Code

Instale a extensão CodeLLDB e configure:

```json
// .vscode/launch.json
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Debug Zig",
            "type": "lldb",
            "request": "launch",
            "program": "${workspaceFolder}/zig-out/bin/app",
            "args": [],
            "cwd": "${workspaceFolder}",
            "preLaunchTask": "build"
        }
    ]
}
```

```json
// .vscode/tasks.json
{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "build",
            "type": "shell",
            "command": "zig build",
            "group": { "kind": "build", "isDefault": true }
        },
        {
            "label": "test",
            "type": "shell",
            "command": "zig build test",
            "group": { "kind": "test", "isDefault": true }
        }
    ]
}
```

## Neovim — Para Entusiastas de Terminal

O Neovim oferece a melhor experiência Zig em terminal, com plugins altamente configuráveis.

### Configuração com nvim-lspconfig

```lua
-- init.lua ou lua/plugins/zig.lua

-- Plugin de LSP
require('lspconfig').zls.setup{
    cmd = { "zls" },
    filetypes = { "zig", "zon" },
    root_dir = require('lspconfig.util').root_pattern("build.zig", "build.zig.zon", ".git"),
    settings = {
        zls = {
            enable_snippets = true,
            enable_ast_check_diagnostics = true,
            enable_autofix = true,
            enable_import_detection = true,
            enable_inlay_hints = true,
            inlay_hints_show_builtin = true,
            operator_completions = true,
            include_at_in_builtins = false,
        }
    },
    on_attach = function(client, bufnr)
        -- Keymaps
        local opts = { noremap=true, silent=true, buffer=bufnr }
        vim.keymap.set('n', 'gd', vim.lsp.buf.definition, opts)
        vim.keymap.set('n', 'gr', vim.lsp.buf.references, opts)
        vim.keymap.set('n', 'K', vim.lsp.buf.hover, opts)
        vim.keymap.set('n', '<leader>rn', vim.lsp.buf.rename, opts)
        vim.keymap.set('n', '<leader>ca', vim.lsp.buf.code_action, opts)
        vim.keymap.set('n', '[d', vim.diagnostic.goto_prev, opts)
        vim.keymap.set('n', ']d', vim.diagnostic.goto_next, opts)
    end,
}

-- Treesitter para syntax highlighting
require('nvim-treesitter.configs').setup{
    ensure_installed = { "zig" },
    highlight = { enable = true },
    indent = { enable = true },
}
```

### Plugins Recomendados para Neovim

```lua
-- Lazy.nvim config
return {
    -- LSP
    { 'neovim/nvim-lspconfig' },

    -- Autocompletar
    { 'hrsh7th/nvim-cmp' },
    { 'hrsh7th/cmp-nvim-lsp' },
    { 'L3MON4D3/LuaSnip' },

    -- Treesitter
    { 'nvim-treesitter/nvim-treesitter', build = ':TSUpdate' },

    -- Telescope para busca
    { 'nvim-telescope/telescope.nvim' },

    -- Diagnósticos organizados
    { 'folke/trouble.nvim' },

    -- Zig-specific
    { 'ziglang/zig.vim' },
}
```

## Emacs

### Configuração com eglot (Emacs 29+)

```elisp
;; Zig mode
(use-package zig-mode
  :ensure t
  :hook (zig-mode . eglot-ensure)
  :config
  (setq zig-format-on-save t))

;; Eglot (built-in no Emacs 29)
(add-to-list 'eglot-server-programs '(zig-mode . ("zls")))

;; Company para autocompletar
(use-package company
  :ensure t
  :hook (zig-mode . company-mode))
```

### Configuração com lsp-mode

```elisp
(use-package lsp-mode
  :ensure t
  :commands lsp
  :hook (zig-mode . lsp-deferred)
  :config
  (setq lsp-zig-zls-executable "zls"))

(use-package zig-mode
  :ensure t
  :config
  (setq zig-format-on-save t))
```

## Helix

O Helix tem suporte nativo a Zig sem configuração adicional:

```toml
# ~/.config/helix/languages.toml
[[language]]
name = "zig"
scope = "source.zig"
file-types = ["zig", "zon"]
language-server = { command = "zls" }
auto-format = true
formatter = { command = "zig", args = ["fmt", "--stdin"] }
```

O Helix já inclui syntax highlighting via tree-sitter e configuração LSP padrão para ZLS.

## Sublime Text

### Instalação

1. Instale o Package Control
2. Instale "LSP" e "LSP-zig" via Package Control
3. O ZLS será usado automaticamente se estiver no PATH

### Configuração

```json
// LSP.sublime-settings
{
    "clients": {
        "zig": {
            "enabled": true,
            "command": ["zls"],
            "selector": "source.zig"
        }
    }
}
```

## IntelliJ IDEA / CLion

### ZigBrains Plugin

```
Plugin: ZigBrains
Marketplace: JetBrains Marketplace
```

Funcionalidades:
- Syntax highlighting
- Integração com ZLS
- Navegação de código
- Refatoração
- Debug integrado

## Kakoune

```
# ~/.config/kak/kakrc
hook global WinSetOption filetype=zig %{
    lsp-enable-window
}

# kak-lsp.toml
[language.zig]
filetypes = ["zig"]
roots = ["build.zig", "build.zig.zon"]
command = "zls"
```

## Comparação de Editores

| Editor | LSP | Treesitter | Debug | Facilidade | Comunidade Zig |
|---|---|---|---|---|---|
| VS Code | Excelente | Via ext | CodeLLDB | Fácil | Grande |
| Neovim | Excelente | Nativo | DAP | Médio | Grande |
| Emacs | Bom | Via pacote | GDB/DAP | Médio | Média |
| Helix | Excelente | Nativo | Parcial | Fácil | Crescente |
| Sublime | Bom | Parcial | Limitado | Fácil | Pequena |
| IntelliJ | Bom | Parcial | Integrado | Fácil | Pequena |

## Funcionalidades LSP Disponíveis

Todos os editores com ZLS têm acesso a:

- **Autocompletar**: Funções, campos, módulos, imports
- **Diagnósticos**: Erros e avisos em tempo real
- **Go to Definition**: Navegar para declarações
- **Find References**: Encontrar todos os usos
- **Hover Info**: Documentação e tipos ao passar o cursor
- **Rename**: Renomear símbolos em todo o projeto
- **Code Actions**: Correções automáticas
- **Inlay Hints**: Tipos inferidos inline
- **Formatação**: Formatação automática com zig fmt

## Boas Práticas

1. **Mantenha ZLS atualizado**: Sincronize com a versão do compilador usando [zigup](/ecossistema/zigup-version-manager/)
2. **Ative formatação ao salvar**: Garante estilo consistente
3. **Use inlay hints**: Ajudam a entender tipos inferidos
4. **Configure debug**: Invista tempo configurando breakpoints e inspeção de variáveis
5. **Atalhos de teclado**: Aprenda os atalhos do LSP no seu editor

## Próximos Passos

Configure o [ZLS](/ecossistema/zls-language-server/) para funcionalidades avançadas, explore as [ferramentas de debug](/ecossistema/zig-debug-tools/) para depuração integrada, e consulte nossos [tutoriais](/tutoriais/) para começar a programar com seu editor configurado. Para oportunidades profissionais, visite a seção de [carreira](/carreira/).
