gedit vs. Sublime Text: Which Linux Editor Suits You?

Customizing gedit for Coding: Best Plugins and Settingsgedit is GNOME’s lightweight text editor — simple by default but very customizable. With the right plugins, themes, and settings, gedit can become a productive, distraction-free coding environment for many programming tasks. This article walks through practical steps to configure gedit for coding, recommended plugins, useful settings, tips for language support, and workflows to make everyday development faster.

Why customize gedit for coding?

gedit is fast, integrates with GNOME, and starts instantly. Out of the box it’s minimal, which keeps distraction low, but that minimalism also means some features programmers expect (like powerful project navigation, advanced autocompletion, or refactoring tools) are not present by default. Customization fills these gaps while keeping the editor lightweight.

Installing gedit and the plugin package

Most Linux distributions include gedit in their package repositories.

On Debian/Ubuntu:

sudo apt update sudo apt install gedit gedit-plugins

On Fedora:
```
sudo dnf install gedit gedit-plugins 
```
On Arch:
```
sudo pacman -S gedit gedit-plugins 
```

Installing the gedit-plugins package gives you several useful built-in plugins. For extras, see section “Third‑party plugins.”

Core settings to enable

Open Preferences → Editor and adjust the following to make coding comfortable:

Tab width and indent behavior: Set Tab width (commonly 4) and enable “Insert spaces instead of tabs” for consistent formatting across editors.
Enable automatic indentation to keep block structure when pressing Enter.
Display line numbers — essential for debugging and navigating code.
Highlight current line to keep the caret visible.
Bracket matching — enables quick visual pairing of parentheses/braces.
Enable text wrapping off for code (turn on for prose files).
Font and font size: choose a monospaced font (e.g., Fira Code, JetBrains Mono, DejaVu Sans Mono). Increase size for readability.

Preferences → View:

Show right margin at 80 or 100 characters to guide line length.
Display line endings and show whitespace when working with strict formatting requirements.

Essential built-in plugins

After installing gedit-plugins, enable these via Preferences → Plugins:

Snippets — create and insert reusable code snippets, with tab stops.
External Tools — run shell commands or scripts on the current file (useful for build/test/lint commands).
File Browser — a sidebar for quick project navigation.
Terminal (if available) — run commands without leaving the editor.
Code Comment — easily toggle comments for selected lines.
Multi Edit — basic multi-cursor functionality to edit several places at once.
Auto Save — useful when running external build commands that read files.
Git Plugin (if present) — basic repository actions from the editor.

Enable only what you need to keep the UI uncluttered.

Third‑party plugins and extensions

If the built-in set isn’t enough, consider third‑party plugins:

gedit-plugins-extra (varies by distro) — sometimes contains additional community plugins.
gmate / gedit-plugins from GitHub — adds features inspired by other code editors (confirm compatibility with your gedit version).
Language-specific coloring or linting plugins maintained by language communities.

To install a third‑party plugin manually:

Download the plugin files (.py, .plugin, and any resources).
Place them in ~/.local/share/gedit/plugins/ (create the folder if missing).
Restart gedit and enable via Preferences → Plugins.

Always check plugin compatibility and review code if installing from untrusted sources.

Syntax highlighting and language support

gedit uses GtkSourceView for syntax highlighting. Most common languages are supported out of the box. For additional languages:

Install additional language definitions or package updates from your distribution (packages may be named gtk-sourceview-lang or similar).
Custom language definitions: add a .lang file to ~/.local/share/gtksourceview-4/language-specs/ (version number may be 3 or 4 depending on distro/gedit). Restart gedit to pick them up.

Set file type manually via View → Highlight Mode if detection fails.

Autocompletion and code intelligence

gedit’s completion is basic (word-based) but can be improved:

Enable Preferences → Editor → Enable code completion and choose options for case sensitivity.
Use the Snippets plugin for pattern-based expansions (e.g., for common function templates).
Use External Tools to run language-specific completion generators or call language servers with lightweight wrappers (see “Language Server Protocol” below).

For full language intelligence (go-to-definition, semantic completion), integrate an LSP client. There are community efforts to connect gedit to LSP servers; these may require installing additional Python packages and an LSP bridge script (search for “gedit lsp plugin”). These solutions vary in maturity.

Language Server Protocol (LSP)

For features like auto-complete, diagnostics, and go-to-definition, LSP is the modern standard. gedit does not ship with a polished LSP client, but you can:

Use a community LSP plugin for gedit (if available for your version).
Run a small external script that starts an LSP server and communicates via stdin/stdout, using gedit’s External Tools to surface results.
Alternatively, run language-specific linters/formatters via External Tools to approximate LSP benefits.

Expect some manual setup and occasional rough edges compared to editors with native LSP integration.

Formatting, linting, and running tests

Use External Tools to integrate formatting and linting:

Example External Tool to run Black (Python formatter) on the current file:

Command:
```
black --quiet "%f" 
```
Set input/output to “Nothing” and choose a shortcut.

Example to run a test command and show output in a new terminal:

Command:


bash -lc "pytest -q %f && echo 'Tests passed' || echo 'Some tests failed'; read -n1 -r -p 'Press any key to close...'"

For linters (flake8, eslint, golangci-lint), create tools that run them and capture results. Use regex search on the output to jump to offending lines, or copy results to a quickfix-like window.

Keyboard shortcuts and productivity tweaks

Customize shortcuts in Preferences → Shortcuts:

Map Build/Run script to F5 or Ctrl+F5.
Map Toggle Comment to Ctrl+/ if not already set.
Create External Tools with shortcuts for common tasks: format, lint, run tests, build.

Use the File Browser plugin combined with project root bookmarks for quick switching between project files.

Themes and UI tweaks

Use dark themes (e.g., Adwaita-dark) for evening work to reduce eye strain.
gedit supports Gtk and CSS-based styling; change theme via GNOME settings or install icon/font themes as needed.
For syntax themes, add or edit style schemes in ~/.local/share/gtksourceview-4/styles/ or system equivalent.

If you prefer a compact interface for focused coding, disable toolbars you don’t use via View menu.

Using gedit for quick refactoring and multi-file edits

Multi Edit plugin helps with same-text edits across a file.
For multi-file refactors, rely on external tools: ripgrep/ag for finding occurrences, sed/perl for batch replaces, or use a small script that updates matches. Integrate these into External Tools with confirmation prompts.

Example: quick project-wide rename (interactive):

rg -n --hidden --glob '!node_modules' "OldName" | sed -n 's/:.*//p' | xargs -I{} -r ${EDITOR:-gedit} "{}"

(Use with care — prefer version control to revert mistakes.)

Backups, autosave, and session recovery

Enable Autosave or configure an External Tool to save before running commands. Use Git for real versioned backups. gedit also supports file history through your system (e.g., Timeshift/backups) but don’t rely on it as a primary backup.

Example workflow: Python project

Open project folder with File Browser.
Enable Snippets, External Tools, and Terminal plugins.
Configure shortcuts:
- F5 → Run current file with python3 “%f”
- Ctrl+Shift+F → Run pytest for current project
- Ctrl+Alt+L → Run black “%f”
Use Snippets for common constructs (if/for/def).
Run linter with External Tools (flake8) before committing.

Troubleshooting and tips

If a plugin doesn’t appear after installing to ~/.local/share/gedit/plugins/, restart gedit and check ownership/permissions.
Version mismatches between gtksourceview and plugin language spec folders are common; confirm your distro’s gtksourceview version (3 vs 4) and place files in the correct path.
For performance: disable heavy plugins or split very large files into smaller modules.
If you need robust refactoring, consider using a dedicated IDE for that language and using gedit for quick edits.

When gedit is the right choice

Choose gedit when you want:

A fast, low-memory editor integrated with GNOME.
Simple editing with occasional coding tasks.
Easy inspection and quick tweaks to files without launching a full IDE.

If you require deep language intelligence, complex refactoring, or integrated debugging, consider pairing gedit with external tools or using a dedicated IDE for those tasks.

Conclusion

gedit scales well from a lightweight general-purpose editor to a capable coding tool with a handful of plugins and custom settings. Focus on enabling only the plugins you need, integrate external tools for building/formatting, and consider community LSP plugins if you need richer language features. With these tweaks, gedit can be a comfortable, efficient environment for many programming workflows.