---
title: "Configurar Sublime Text e Emacs para Zig — Plugins e LSP"
url: "https://ziglang.com.br/instalacao/configurar-sublime-text-e-emacs-para-zig-plugins-e-lsp/"
markdown_url: "https://ziglang.com.br/instalacao/configurar-sublime-text-e-emacs-para-zig-plugins-e-lsp.MD"
description: "Guia para configurar Sublime Text e Emacs para desenvolvimento com Zig. Syntax highlighting, LSP, autocompletar e formatação automática."
date: "2026-02-21"
author: "Zig Brasil"
---

# Configurar Sublime Text e Emacs para Zig — Plugins e LSP

Guia para configurar Sublime Text e Emacs para desenvolvimento com Zig. Syntax highlighting, LSP, autocompletar e formatação automática.


# Configurar Sublime Text e Emacs para Zig

Embora o [VS Code](/instalacao/configurar-vscode-zig/) e o [Neovim](/instalacao/configurar-neovim-zig/) sejam os editores mais populares para Zig, o **Sublime Text** e o **Emacs** também oferecem excelente suporte. Este guia mostra como configurar ambos para ter syntax highlighting, autocompletar via LSP, diagnósticos e formatação automática.

Antes de configurar o editor, certifique-se de que o Zig e o ZLS estão instalados. Consulte o [guia completo de instalação](/instalacao/) para sua plataforma.

---

## Parte 1: Sublime Text

O Sublime Text é um editor leve, rápido e extensível. Com os plugins corretos, oferece uma experiência de desenvolvimento completa para Zig.

### Pré-requisitos

- Sublime Text 4 (build 4143+)
- Zig instalado e no PATH
- ZLS instalado e no PATH

### Passo 1: Instalar o Package Control

Se ainda não tem o Package Control:

1. Abra o Sublime Text
2. Pressione `Ctrl+Shift+P` (ou `Cmd+Shift+P` no macOS)
3. Digite **"Install Package Control"** e pressione Enter

### Passo 2: Instalar o Plugin de Sintaxe do Zig

1. Pressione `Ctrl+Shift+P`
2. Digite **"Package Control: Install Package"**
3. Pesquise por **"Zig Language"** ou **"Zig"**
4. Instale o pacote

Isso adiciona:
- Syntax highlighting para arquivos `.zig` e `.zon`
- Snippets básicos
- Definição de comentários para toggling

### Passo 3: Instalar o LSP

O plugin **LSP** oficial do Sublime Text fornece suporte a Language Servers, incluindo o ZLS:

1. `Ctrl+Shift+P` > **"Package Control: Install Package"**
2. Pesquise por **"LSP"** e instale
3. Pesquise por **"LSP-zig"** e instale (se disponível)

### Passo 4: Configurar o LSP para ZLS

Se não há um pacote LSP-zig disponível, configure manualmente. Vá em **Preferences > Package Settings > LSP > Settings** e adicione:

```json
{
    "clients": {
        "zls": {
            "enabled": true,
            "command": ["zls"],
            "selector": "source.zig",
            "settings": {
                "enable_snippets": true,
                "enable_autofix": true,
                "warn_style": true,
                "highlight_global_var_declarations": true
            }
        }
    },
    "lsp_format_on_save": true
}
```

### Passo 5: Configurações do Sublime para Zig

Vá em **Preferences > Settings** e adicione configurações específicas para Zig:

```json
{
    "tab_size": 4,
    "translate_tabs_to_spaces": true,
    "rulers": [100],
    "trim_trailing_white_space_on_save": true,
    "ensure_newline_at_eof_on_save": true
}
```

Para configurações específicas da sintaxe Zig, vá em **Preferences > Settings - Syntax Specific** (com um arquivo `.zig` aberto):

```json
{
    "tab_size": 4,
    "translate_tabs_to_spaces": true,
    "rulers": [100]
}
```

### Passo 6: Build System para Zig

Crie um build system personalizado para compilar e executar código Zig diretamente do Sublime Text.

Vá em **Tools > Build System > New Build System** e salve como `Zig.sublime-build`:

```json
{
    "shell_cmd": "zig build run",
    "working_dir": "${project_path:${folder}}",
    "selector": "source.zig",
    "file_regex": "^(.+):(\\d+):(\\d+): (.+)$",
    "variants": [
        {
            "name": "Build",
            "shell_cmd": "zig build"
        },
        {
            "name": "Run Current File",
            "shell_cmd": "zig run ${file}"
        },
        {
            "name": "Test",
            "shell_cmd": "zig build test"
        },
        {
            "name": "Test Current File",
            "shell_cmd": "zig test ${file}"
        },
        {
            "name": "Format",
            "shell_cmd": "zig fmt ${file}"
        }
    ]
}
```

Uso:
- `Ctrl+B` — Build and run (padrão)
- `Ctrl+Shift+B` — Selecionar variante (Build, Run, Test, etc.)

### Atalhos Úteis no Sublime com LSP

| Atalho | Ação |
|---|---|
| `F12` | Ir para a definição |
| `Shift+F12` | Encontrar referências |
| `Ctrl+Shift+P` > "LSP: Hover" | Ver documentação |
| `F2` | Renomear símbolo |
| `Ctrl+.` | Ações de código (code actions) |
| `Ctrl+B` | Build |

### Plugins Complementares para Sublime

- **SublimeLinter** — Framework de linting
- **GitGutter** — Indicadores de mudanças Git na margem
- **SideBarEnhancements** — Funcionalidades extras na barra lateral
- **A File Icon** — Ícones para tipos de arquivo, incluindo `.zig`
- **BracketHighlighter** — Destaque de colchetes e chaves

---

## Parte 2: Emacs

O Emacs é um editor altamente extensível com suporte robusto a LSP. Vamos configurar o Emacs para desenvolvimento com Zig usando `zig-mode`, `lsp-mode` (ou `eglot`) e ferramentas complementares.

### Pré-requisitos

- Emacs 29+ (recomendado para eglot integrado)
- Zig instalado e no PATH
- ZLS instalado e no PATH

### Opção A: Configuração com eglot (Integrado no Emacs 29+)

O `eglot` é o cliente LSP integrado no Emacs 29+. É a opção mais simples e leve.

#### Instalar zig-mode

Adicione ao seu `~/.emacs.d/init.el` ou `~/.emacs`:

```elisp
;; Configurar repositórios de pacotes
(require 'package)
(add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/") t)
(package-initialize)

;; Instalar use-package se necessário
(unless (package-installed-p 'use-package)
  (package-refresh-contents)
  (package-install 'use-package))

(require 'use-package)
(setq use-package-always-ensure t)

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

;; Configurar eglot para ZLS
(with-eval-after-load 'eglot
  (add-to-list 'eglot-server-programs
               '(zig-mode . ("zls"))))
```

#### Configurar eglot

Adicione configurações adicionais para o eglot:

```elisp
;; Configurações do eglot
(use-package eglot
  :config
  (setq eglot-autoshutdown t)
  (setq eglot-events-buffer-size 0)

  ;; Configurações do ZLS via eglot
  (setq-default eglot-workspace-configuration
                '(:zls (:enableSnippets t
                        :enableAutofix t
                        :warnStyle t))))
```

### Opção B: Configuração com lsp-mode

O `lsp-mode` é um cliente LSP mais completo, com mais funcionalidades que o `eglot`, mas também mais pesado.

```elisp
;; LSP Mode
(use-package lsp-mode
  :commands lsp
  :hook (zig-mode . lsp)
  :config
  (setq lsp-zig-zls-executable "zls")
  (setq lsp-enable-snippet t)
  (setq lsp-zig-enable-autofix t))

;; LSP UI - Interface visual para diagnósticos
(use-package lsp-ui
  :commands lsp-ui-mode
  :hook (lsp-mode . lsp-ui-mode)
  :config
  (setq lsp-ui-doc-enable t)
  (setq lsp-ui-doc-show-with-cursor t)
  (setq lsp-ui-sideline-enable t)
  (setq lsp-ui-sideline-show-diagnostics t))

;; Zig mode
(use-package zig-mode
  :mode "\\.zig\\'"
  :config
  (setq zig-format-on-save t))
```

### Autocompletar com Company

```elisp
;; Company mode para autocompletar
(use-package company
  :hook (after-init . global-company-mode)
  :config
  (setq company-minimum-prefix-length 1)
  (setq company-idle-delay 0.1)
  (setq company-selection-wrap-around t))
```

### Flycheck para Diagnósticos

```elisp
;; Flycheck para diagnósticos em tempo real
(use-package flycheck
  :hook (prog-mode . flycheck-mode))
```

### Configurações Gerais para Zig no Emacs

```elisp
;; Configurações gerais para arquivos Zig
(add-hook 'zig-mode-hook
          (lambda ()
            (setq indent-tabs-mode nil)
            (setq tab-width 4)
            (setq zig-format-on-save t)
            (display-line-numbers-mode 1)
            (column-number-mode 1)))

;; Compilação com Zig
(defun zig-build ()
  "Executar zig build no diretório do projeto."
  (interactive)
  (compile "zig build"))

(defun zig-build-run ()
  "Executar zig build run no diretório do projeto."
  (interactive)
  (compile "zig build run"))

(defun zig-test ()
  "Executar zig build test no diretório do projeto."
  (interactive)
  (compile "zig build test"))

(defun zig-run-current ()
  "Executar o arquivo Zig atual."
  (interactive)
  (compile (format "zig run %s" (buffer-file-name))))

;; Keybindings para Zig
(with-eval-after-load 'zig-mode
  (define-key zig-mode-map (kbd "C-c C-b") 'zig-build)
  (define-key zig-mode-map (kbd "C-c C-r") 'zig-build-run)
  (define-key zig-mode-map (kbd "C-c C-t") 'zig-test)
  (define-key zig-mode-map (kbd "C-c C-x") 'zig-run-current))
```

### Atalhos do Emacs para Zig

| Atalho | Ação |
|---|---|
| `M-.` | Ir para a definição (xref) |
| `M-,` | Voltar da definição |
| `M-?` | Encontrar referências |
| `C-c C-b` | Zig build |
| `C-c C-r` | Zig build run |
| `C-c C-t` | Zig build test |
| `C-c C-x` | Executar arquivo atual |
| `C-c C-d` | Documentação (hover) |

### Doom Emacs

Se você usa Doom Emacs, a configuração é mais simples. Edite `~/.doom.d/init.el`:

```elisp
;; Em init.el, descomente ou adicione:
(doom! :lang
       (zig +lsp))
```

Depois execute:

```bash
doom sync
```

### Spacemacs

Para Spacemacs, adicione a layer do Zig ao `.spacemacs`:

```elisp
;; Em dotspacemacs-configuration-layers:
(zig :variables
     zig-format-on-save t)
```

---

## Parte 3: Outros Editores

### Kate (KDE)

O Kate, editor padrão do KDE, suporta LSP nativamente:

1. Abra **Settings > Configure Kate > LSP Client**
2. Adicione a configuração do ZLS:

```json
{
    "servers": {
        "zig": {
            "command": ["zls"],
            "root": "",
            "highlightingModeRegex": "^Zig$"
        }
    }
}
```

### Helix

O Helix Editor tem suporte nativo a LSP e Tree-sitter. Com o ZLS no PATH, o suporte a Zig funciona automaticamente:

```bash
# Instalar o Helix
sudo pacman -S helix  # Arch Linux
brew install helix    # macOS

# Verificar suporte a Zig
hx --health zig
```

### Zed

O Zed Editor tem suporte nativo ao Zig com Tree-sitter e LSP integrados. Basta instalar o ZLS e o Zed detecta automaticamente.

---

## Problemas Comuns

### ZLS não conecta ao editor

Verifique se o ZLS está acessível:

```bash
which zls
zls --version
```

### Formatação não funciona

Certifique-se de que `zig fmt` funciona na linha de comando:

```bash
zig fmt main.zig
```

### Performance lenta no Emacs

Se o Emacs ficar lento com o LSP, ajuste:

```elisp
(setq gc-cons-threshold 100000000)
(setq read-process-output-max (* 1024 1024))
```

Para mais soluções, visite nossa página de [erros comuns](/erros/).

---

## Próximos Passos

Com seu editor configurado:

1. **Crie seu primeiro projeto** — [Primeiro projeto Zig](/instalacao/zig-primeiro-projeto/)
2. **Aprenda a linguagem** — [Introdução ao Zig](/tutoriais/introducao-ao-zig/)
3. **Configure CI/CD** — [GitHub Actions com Zig](/instalacao/zig-ci-github-actions/)
4. **Gerencie versões** — [Gerenciar versões do Zig](/instalacao/zig-gerenciar-versoes/)
5. **Veja exemplos** — [Receitas](/receitas/)