Alwide — O Sublime Text para o Terminal que Não Sabias que Precisavas

Se usas o terminal com frequência e sentes que o nano é básico mas o vim é demasiado — ou se trabalhas por SSH e gostavas de ter um editor com a fluidez do Sublime Text — o Alwide pode ser o que andavas à procura.

Alwide é um TUI IDE (editor de texto para terminal) escrito em C puro, com syntax highlighting via Tree-sitter e suporte LSP opcional. O autor descreve-o como “Sublime Text no terminal”. Depois de o testar no MacBook (incluindo compilar do fonte nativamente para ARM64), fica aqui o guia completo.

O Que É o Alwide

O Alwide é um editor de texto para terminal que se propõe a ser uma alternativa moderna entre o nano e o vim. Oferece uma experiência visual rica no terminal com suporte total a rato, abas, explorador de ficheiros, numeração de linhas e status bar — coisas que esperamos de um IDE gráfico mas que raramente encontramos num terminal.

Características principais:

• Zero learning curve: Suporte total a rato — click, drag-select, scroll. Funciona como um editor gráfico.
• Sublime-inspired: Inspirado na velocidade e fluidez do Sublime Text.
• Rápido e leve: Escrito em C puro. Arranca em milissegundos.
• Tree-sitter: Syntax highlighting de alta qualidade para 20+ linguagens.
• LSP opcional: Complecoes, hover docs e goto definition se instalares os Language Servers.
• Estado persistente: Abas, cursores, undo/redo preservados entre sessões.
• Código fonte limpo: O README diz que é “perfeito para educação ou curiosidade” — e é mesmo. O código é muito legível.

Linguagens Suportadas

C, C++, Python, Java, C#, Go, Rust, JavaScript, TypeScript, Dart, Lua, Bash, HTML, CSS, JSON, Markdown, VHDL, Assembly, LaTeX, INI, Makefile.

Se faltar alguma, podes adicionar editando o ficheiro de configuração.

Instalação

Linux (x86_64 / ARM64)

A forma mais simples:

curl -fsSL https://raw.githubusercontent.com/arnauda-gh/Alwide/main/install.sh | bash

Isto coloca o binário em ~/.local/bin/al e a configuração em ~/.config/alwide/.

macOS (compilar do fonte)

Não existem binários pré-compilados para macOS. Foi preciso compilar. O processo é simples mas requer algumas dependências:

Dependências: - Xcode Command Line Tools (xcode-select --install) - Homebrew ncurses (brew install ncurses) - Rust/Cargo (via rustup) - tree-sitter-cli (npm install -g tree-sitter-cli)

Passos:

# Clonar com submodulos (shallow para ser rapido)
git clone --recurse-submodules --shallow-submodules --depth 1 \
  https://github.com/arnauda-gh/Alwide.git
cd Alwide

# Compilar release
export PKG_CONFIG_PATH="/opt/homebrew/opt/ncurses/lib/pkgconfig:$PKG_CONFIG_PATH"
make release

# Instalar binario
cp al ~/.local/bin/

# Instalar configuracao e assets
cp -r assets/* ~/.config/alwide/

Nix

nix develop
make release
./al
# Ou instalar:
nix profile install .

Primeiros Passos

Corre al no terminal. Vais ver:

• Um editor vazio com números de linha (gutter) à esquerda
• Uma status bar na parte inferior com o nome do ficheiro, linguagem, tamanho, e posição do cursor
• Abas no topo (quando abres mais que um ficheiro)

Para abrir um ficheiro:

al ficheiro.py

Interface

O Alwide tem vários componentes de interface:

• Editor window (EDW): A área principal onde editas o texto.
• File Explorer (FEW): Sidebar com a árvore de diretórios (Ctrl+E para alternar).
• Open Files (OFW): Lista de ficheiros abertos (Ctrl+L).
• Status/Diagnostics (SBW): Painel de diagnósticos (Ctrl+B).
• Popups: Search (Ctrl+F), Language selector, Quit dialog.

Atalhos de Teclado

Gerais

Navegação e Seleção

Edicao

Janelas e Popups

Suporte a Rato

O rato funciona nativamente. Podes fazer tudo sem tirares as mãos do rato:

Configuracao

A configuracao do Alwide vive em ~/.config/alwide/.

config

Ficheiro JSON simples que define o caminho padrão:

{
  "default_path": "~/.config/alwide"
}

languages-features.json

É o ficheiro mais importante. Define como cada linguagem é detetada, editada e servida por LSP. Estrutura para cada linguagem:

{
  "label": "Python",
  "id": "python",
  "detect": {
    "extensions": [".py"],
    "shebang": ["python"]
  },
  "comments": { "line": "#", "block": ["\"\"\"", "\"\"\""] },
  "tabulation": { "size": 4, "space": true },
  "pairs": [["(", ")"], ["{", "}"], ["\"", "\""]],
  "lsp": { "exe": "pylsp", "arguments": ["-v"] }
}

Podes mudar o servidor LSP, o tamanho da tabulação, ou adicionar novas linguagens.

theme

Ficheiro de tema com cores RGB para cada token. Cada linha define a cor normal e a cor brilhante (usada em seleções) mais atributos opcionais:

@function (1000, 360, 341) (1000, 360, 341) ""
@keyword (882, 349, 1000) (882, 349, 1000) ""
@string (349, 964, 552) (349, 964, 552) ""
@comment (600, 600, 600) (1000, 1000, 1000) "i"
@type (992, 411, 752) (992, 411, 752) ""
@variable (341, 780, 1000) (341, 780, 1000) ""
@todo (1000, 698, 0) (1000, 698, 0) "i"

Os valores são RGB em escala 0-1000. O terceiro campo pode ter atributos como "i" (italic) ou "b" (bold).

queries/

Ficheiros .scm (Tree-sitter query) para cada linguagem. São os padrões que o Tree-sitter usa para fazer syntax highlighting. Exemplo de highlights-python.scm poderia conter regras como:

(function_definition name: (identifier) @function)
(call function: (identifier) @function)

LSP (Language Server Protocol)

O LSP no Alwide é opcional. Sem LSP, o editor funciona na mesma com syntax highlighting Tree-sitter, search, undo/redo, etc.

Com LSP ativado, tens: - Auto-completion: Sugestões contextuais (Ctrl+Space) - Hover docs: Documentação ao passar o rato (Ctrl+Hover) - Go to definition: Navegar para a definição de símbolos (Ctrl+Click) - Diagnósticos: Erros e warnings no painel lateral - Code actions: Ações de código (quando disponíveis) - Auto-format: Ao guardar ou com Ctrl+R

Servidores LSP por Linguagem

Arquitetura (para curiosos)

O código fonte está bem organizado e é bastante legível para um projeto em C:

src/
  main.c                  — Entry point
  core/
    editor_init.c         — Inicializacao do editor
    editor_state.c        — Estado global
    editor_render.c       — Renderizacao ncurses
    editor_input.c        — Processamento de input (teclado + rato)
    editor_lsp.c          — Integracao LSP
    editor_destroy.c      — Cleanup
    editor_context.c      — Contexto do editor
  terminal/
    term_handler.c        — Manipulacao do terminal (ncurses)
    key_management.c      — Mapeamento de teclas
    click_handler.c       — Gestos de rato
    kitty_protocol.c      — Suporte a Kitty keyboard protocol
    windows/              — Janelas (EDW, FEW, OFW, POW, TPW)
    windows/popups/       — Popups (search, quit, notification, etc.)
  advanced/
    lsp/                  — Cliente LSP completo
    tree-sitter/          — Tree manager, query, highlighter
    intelligence/         — Auto-pairs, search, comments, indentation
  config/
    config.c              — Leitor de config JSON
    language_feature.c    — Parser de languages-features.json
  data-management/        — File structure, UTF-8/16, state
  io-management/          — IO, explorer, viewport history
  utils/                  — Tools, logger, clipboard
lib/
  cjson/                  — cJSON (submodulo)
  tree-sitter/            — Tree-sitter C library (submodulo)
  tree-sitter-*/          — Gramaticas individuais (Rust/Cargo)

Dependências externas: ncursesw, tree-sitter (C), cJSON.

Experiencia no MacBook

O Alwide não tem binários para macOS. Foi a primeira vez que alguém (que se saiba) o compilou nativamente para ARM64 Mac. O processo correu sem problemas:

1. git clone com submodulos demorou cerca de 30s
2. As gramaticas Rust compilaram automaticamente via cargo build --release
3. O binario final tem ~22MB (Mach-O 64-bit arm64)
4. Corre nativamente no Terminal.app com suporte a rato

Pormenor interessante: todas as 20 gramáticas Tree-sitter são compiladas como bibliotecas Rust .rlib e linkadas estaticamente. Isto explica porque o binário é maior que os 3MB anunciados para a versão Linux (que usa gramáticas C).

Ao executar, o editor abre instantaneamente. A interface é limpa e responsiva. O suporte a rato funciona sem configuração adicional no Terminal.app.

Considerações Finais

O Alwide é um projeto promissor. Está claramente inspirado no Sublime Text e consegue trazer a mesma fluidez para o terminal. O facto de ser escrito em C puro (com gramáticas Rust) torna-o acessível a quem quer contribuir ou perceber como funciona internamente.

Não substitui o VS Code para trabalho pesado, mas para edições rápidas por SSH, configuração de servidores, ou quando queres um editor com qualidade sem abrir um IDE gráfico, é uma ferramenta a ter em conta.

Pontos fortes: rapidez, suporte a rato, LSP opcional, código limpo, instalação simples. A melhorar: pouca documentação ainda, temas limitados, atalhos fixos (sem customização por agora), falta suporte a splits e terminal integrado.

Projeto: github.com/arnauda-gh/Alwide Licenca: MIT