Best Text Editors for FreeBSD in 2026

Choosing a text editor on FreeBSD is not a trivial decision. You will spend hundreds or thousands of hours inside it -- editing configuration files, writing code, managing servers. The editor you pick shapes how fast you work and how much friction you tolerate daily.

FreeBSD ships with vi in the base system, so you always have a modal editor available without installing anything. But the ports and package collection offers every major editor, and several of them integrate deeply with FreeBSD's toolchain and workflow.

This guide compares the six most practical text editors for FreeBSD, with FreeBSD-specific installation instructions, configuration notes, and honest assessments of trade-offs. No fluff, no filler -- just what you need to pick the right tool and start using it.

Quick Recommendation by User Type

If you want a single answer based on who you are:

Beginners and casual users: Install Micro. It works like a normal desktop editor with familiar keybindings (Ctrl+S to save, Ctrl+Q to quit), mouse support, and syntax highlighting out of the box. If you want something even simpler, nano is already familiar to anyone who has used a terminal.
Power users and developers: Install Neovim. Native LSP support, Tree-sitter syntax highlighting, Lua-based configuration, and a thriving plugin ecosystem make it the most capable terminal editor available today.
Emacs devotees: Install Emacs with Doom Emacs or Spacemacs. If you already live in Emacs, nothing else comes close for Org-mode, Magit, and the unified environment philosophy.
Modern modal editing without configuration: Install Helix. It gives you a Kakoune-inspired modal editor with built-in LSP, Tree-sitter, and multiple cursors -- no plugin manager, no config file required.
Vim veterans who want zero dependencies: Stick with Vim. It runs everywhere, has decades of documentation, and your .vimrc will work on any system you touch.

The rest of this article explains why.

Vim

Vim is the editor most FreeBSD administrators already know. It has been the default "enhanced vi" on Unix systems for over 30 years, and its keybinding language is embedded in tools from less to bash (with set -o vi) to web browsers (via Vimium).

Installation

sh
pkg install vim

This installs Vim 9.x with sensible defaults. If you want a minimal build without GUI dependencies:

sh
pkg install vim-console

Configuration

Vim is configured through ~/.vimrc, a plain-text file using Vimscript. A minimal productive configuration:

vim
set number
set relativenumber
set tabstop=4
set shiftwidth=4
set expandtab
set incsearch
set hlsearch
set wildmenu
set encoding=utf-8
syntax on
filetype plugin indent on

Plugin management is handled by tools like vim-plug, Vundle, or Vim 8+'s native package system. A common setup uses vim-plug:

vim
call plug#begin('~/.vim/plugged')
Plug 'tpope/vim-fugitive'
Plug 'junegunn/fzf.vim'
Plug 'dense-analysis/ale'
call plug#end()

Strengths

Ubiquitous. Vim or vi is available on every Unix system. Your muscle memory transfers everywhere.
Lightweight. Vim starts in milliseconds and uses minimal RAM, even with dozens of plugins.
Vim 9 and Vimscript 9. Vim 9 introduced a compiled Vimscript dialect that is significantly faster than legacy Vimscript, closing the performance gap with Neovim's Lua.
Massive documentation. :help is one of the most comprehensive built-in help systems of any software. Decades of Stack Overflow answers, books, and blog posts cover every conceivable workflow.

Weaknesses

Vimscript is awkward. Even with Vim 9 improvements, Vimscript remains a domain-specific language that few developers enjoy writing. Plugin authors increasingly target Neovim's Lua API instead.
LSP is bolted on. Vim has LSP support through plugins like ALE or coc.nvim, but it is not native. Setup is more complex than Neovim's built-in LSP client.
Async support is limited. Vim added async job support in version 8, but the implementation is less flexible than Neovim's.
Plugin ecosystem is plateauing. Many popular plugin authors have shifted focus to Neovim-specific plugins that leverage Lua and Tree-sitter.

Verdict

Vim remains the right choice if you work across many systems and want one configuration that works everywhere, or if you have an existing .vimrc that does everything you need. For new users choosing a modal editor today, Neovim is the stronger starting point.

Neovim

Neovim is a fork of Vim that started in 2014 with a clear goal: modernize the codebase, add first-class Lua scripting, and build native support for features that Vim handles through plugins. In 2026, Neovim has delivered on those promises and become the dominant terminal editor for developers.

Installation

sh
pkg install neovim

For the latest stable release:

sh
pkg install neovim

Neovim's configuration lives at ~/.config/nvim/init.lua (or init.vim for legacy Vimscript configs).

Configuration

Neovim is configured in Lua. A minimal starting configuration:

lua
vim.opt.number = true
vim.opt.relativenumber = true
vim.opt.tabstop = 4
vim.opt.shiftwidth = 4
vim.opt.expandtab = true
vim.opt.termguicolors = true
vim.opt.signcolumn = "yes"

-- Bootstrap lazy.nvim plugin manager
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
  vim.fn.system({ "git", "clone", "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git", lazypath })
end
vim.opt.rtp:prepend(lazypath)

require("lazy").setup({
  "neovim/nvim-lspconfig",
  "nvim-treesitter/nvim-treesitter",
  "nvim-telescope/telescope.nvim",
  "lewis6991/gitsigns.nvim",
})

Key Features

Native LSP client. Neovim includes a built-in Language Server Protocol client. Configure it once, and you get code completion, diagnostics, go-to-definition, and rename refactoring for any language with an LSP server. No third-party plugin required for the core functionality.
Tree-sitter integration. Neovim uses Tree-sitter for incremental syntax parsing. This gives you accurate syntax highlighting, code folding, and text objects based on the actual parse tree -- not regex patterns.
Lua configuration and plugin API. Lua is a real programming language with proper data structures, error handling, and performance. Plugin authors write Lua, and the result is faster, more maintainable extensions.
lazy.nvim plugin manager. The standard plugin manager for Neovim in 2026. It handles lazy-loading, dependency resolution, and lock files. Plugins load in milliseconds.
Telescope. A fuzzy finder framework that replaces fzf, ctrlp, and half a dozen other Vim plugins with a single, extensible interface for finding files, grep results, LSP symbols, git commits, and more.

Strengths

Best-in-class developer experience in the terminal. With LSP, Tree-sitter, Telescope, and a good colorscheme, Neovim rivals VS Code for code intelligence while staying in the terminal.
Fast startup. A well-configured Neovim with lazy-loaded plugins starts in under 50ms.
Active ecosystem. Neovim has the most active plugin development community of any terminal editor. New plugins appear weekly, and existing ones are actively maintained.
Drop-in Vim compatibility. All Vim keybindings work. Most Vimscript plugins work. Migration from Vim is incremental.

Weaknesses

Configuration can be a rabbit hole. The flexibility of Lua means there is no single "right" way to configure Neovim. New users can spend hours on configuration before writing a single line of code. Starter configurations like kickstart.nvim or LazyVim help, but they add their own layer of abstraction.
Breaking changes between versions. Neovim's API evolves faster than Vim's, and plugins occasionally break after updates.
Not installed by default. Unlike vi, Neovim must be installed from packages or ports.

Verdict

Neovim is the best terminal text editor for developers on FreeBSD in 2026. If you write code, edit configuration files regularly, and want an editor that grows with your skill, start here. Use kickstart.nvim as a starting template rather than building a configuration from scratch.

Emacs

GNU Emacs is not just a text editor -- it is a Lisp environment that happens to edit text exceptionally well. It has been in active development since 1984, and its community has built tools inside Emacs that rival or surpass standalone applications: email clients, terminal emulators, file managers, git interfaces, and an entire personal information management system.

Installation

sh
pkg install emacs

For a terminal-only build without X11 dependencies:

sh
pkg install emacs-nox

Emacs configuration lives at ~/.emacs.d/init.el or ~/.config/emacs/init.el.

Doom Emacs and Spacemacs

Writing an Emacs configuration from scratch is a significant undertaking. Two distribution frameworks solve this:

Doom Emacs is the recommended starting point in 2026. It provides a fast, opinionated configuration with Vim keybindings (via evil-mode), sensible defaults, and a module system. Installation:

sh
git clone --depth 1 https://github.com/doomemacs/doomemacs ~/.config/emacs
~/.config/emacs/bin/doom install

Spacemacs takes a similar approach with a heavier focus on discoverability through a mnemonic keybinding system triggered by the space bar.

Key Features

Org-mode. A plain-text system for notes, project planning, task management, literate programming, and document export. Nothing else in the editor world comes close. If you manage complex projects, write documentation, or keep a personal knowledge base, Org-mode alone justifies learning Emacs.
Magit. The best git interface available in any editor, period. It presents git operations as an interactive buffer where you stage hunks, write commits, rebase, and resolve conflicts without leaving Emacs. Many developers who otherwise use Neovim switch to Emacs solely for Magit.
LSP via eglot or lsp-mode. Emacs 29+ includes eglot as a built-in LSP client. It provides code completion, diagnostics, and refactoring for all major languages.
Elisp extensibility. Emacs Lisp is a full programming language. Every aspect of Emacs is configurable, and the entire editor state is inspectable and modifiable at runtime.
TRAMP. Edit files on remote servers over SSH as if they were local. No need to install Emacs on the remote machine -- TRAMP transparently handles file operations over the network.

Strengths

Unmatched breadth. Emacs can replace your editor, terminal, email client, RSS reader, file manager, and task manager. For users who commit to the ecosystem, context-switching drops to near zero.
Org-mode is irreplaceable. No other tool provides Org-mode's combination of outlining, task management, time tracking, literate programming, and export to HTML/LaTeX/PDF.
Magit is the best git interface. Interactive rebasing, hunk staging, and conflict resolution are faster in Magit than in any other tool.
Mature and stable. Emacs rarely introduces breaking changes. Configurations from five years ago still work.

Weaknesses

Steep learning curve. Emacs has its own terminology, its own keybindings, and its own way of thinking about text editing. The investment is real, even with Doom Emacs smoothing the path.
Startup time. Vanilla Emacs starts slowly compared to Vim or Neovim. Doom Emacs mitigates this significantly, but it is still not instant. Many users run Emacs as a daemon (emacs --daemon) and connect with emacsclient.
Resource usage. Emacs uses more RAM than any other terminal editor on this list. A typical Doom Emacs session uses 200-400 MB.
Elisp is showing its age. Emacs Lisp is dynamically scoped by default (though lexical scoping is now standard in new code) and lacks modern concurrency primitives. Long-running operations can freeze the UI.

Verdict

Emacs is the right choice if you want a unified environment that handles everything from code editing to project management to email. The investment is high but the payoff is proportional. If you only need a text editor, Neovim is more efficient. If you want a personal computing environment, Emacs is unmatched.

Helix

Helix is a post-modern terminal text editor written in Rust. It ships with built-in support for Tree-sitter syntax highlighting, LSP, and multiple cursors. Its design philosophy is "batteries included" -- you should not need plugins or extensive configuration to have a productive editing experience.

Installation

sh
pkg install helix

Configuration lives at ~/.config/helix/config.toml. The default configuration is usable without modification.

Key Features

Kakoune-inspired modal editing. Helix reverses Vim's verb-object order to object-verb. Instead of d3w (delete three words), you select three words first with 3w, see the selection highlighted, then press d to delete. This "selection-first" approach gives you visual feedback before committing to an action.
Built-in LSP. Helix detects installed language servers automatically. If you have clangd, pyright, rust-analyzer, or any other LSP server in your $PATH, Helix uses it. No configuration required.
Built-in Tree-sitter. Syntax highlighting, code folding, and text objects use Tree-sitter grammars that ship with the editor. No plugin installation needed.
Multiple cursors. Select multiple occurrences of a pattern and edit them simultaneously. This is a core editing primitive, not an afterthought.
Built-in file picker and grep. Fuzzy file finding and project-wide search are built in.

Configuration

A minimal config.toml:

toml
theme = "gruvbox"

[editor]
line-number = "relative"
mouse = true
bufferline = "multiple"
color-modes = true

[editor.cursor-shape]
insert = "bar"
normal = "block"
select = "underline"

[editor.lsp]
display-messages = true
display-inlay-hints = true

Strengths

Zero configuration productivity. Install Helix, install a language server, and start editing. No plugin manager, no package manager, no hours of configuration.
Fast. Written in Rust, Helix starts instantly and handles large files without lag.
Selection-first editing is intuitive once learned. Seeing what you are about to act on before acting reduces errors.
Excellent built-in features. LSP, Tree-sitter, fuzzy finder, and multiple cursors work out of the box with no plugins.

Weaknesses

No plugin system (yet). Helix does not support plugins as of early 2026. What ships with the editor is what you get. A plugin system is in development, but it is not yet available in stable releases.
Smaller community. Fewer tutorials, blog posts, and Stack Overflow answers compared to Vim or Emacs.
Different keybindings. If you have years of Vim muscle memory, Helix's object-verb order requires retraining. The transition period is uncomfortable.
Limited customization. Without plugins, you cannot add features that the editor does not already provide.

Verdict

Helix is the best choice for users who want a modern, fast, capable modal editor without spending time on configuration. If you are coming from VS Code and want a terminal editor that "just works," Helix is the shortest path to productivity. If you need extensive customization or a specific plugin, Neovim is the better choice.

Micro

Micro is a modern terminal text editor that aims to be easy to use and intuitive. It uses familiar keybindings (Ctrl+S, Ctrl+C, Ctrl+V, Ctrl+Z) that anyone who has used a graphical text editor will recognize immediately.

Installation

sh
pkg install micro

Configuration lives at ~/.config/micro/settings.json.

Key Features

Familiar keybindings. No modal editing. Ctrl+S saves. Ctrl+Q quits. Ctrl+Z undoes. Ctrl+F finds. If you know how to use Notepad or gedit, you know how to use Micro.
Mouse support. Click to place the cursor. Click and drag to select text. Scroll with the scroll wheel. This works in any terminal that supports mouse events.
Syntax highlighting. Over 130 languages supported out of the box.
Plugin system. Micro supports plugins written in Lua. Install them with micro -plugin install . The plugin repository includes file tree viewers, linters, and formatters.
Split panes and tabs. Open multiple files in splits or tabs within a single Micro instance.
True color support. Micro uses 24-bit color if your terminal supports it.

Configuration

json
{
    "colorscheme": "gruvbox",
    "tabsize": 4,
    "tabstospaces": true,
    "autoindent": true,
    "savecursor": true,
    "scrollbar": true,
    "rmtrailingws": true
}

Strengths

Zero learning curve. Anyone can use Micro immediately. This is its primary value.
Good default behavior. Syntax highlighting, line numbers, and sane editing behavior work without configuration.
Lightweight. Single binary, small footprint, fast startup.
Better than nano in every way. Micro is what nano should have become -- a simple editor with modern features.

Weaknesses

No LSP support. Micro does not have a built-in LSP client. You can get basic linting through plugins, but there is no code completion, go-to-definition, or refactoring support.
Limited plugin ecosystem. The Lua plugin system works, but the number of available plugins is small compared to Vim or Neovim.
Not modal. If you want the efficiency of modal editing, Micro is not the right tool.
Ceiling is low. Micro is designed to be simple. As your needs grow, you will likely outgrow it.

Verdict

Micro is the best text editor for FreeBSD users who do not want to learn Vim keybindings and do not need IDE-level features. It is the right default editor for servers where multiple people may need to edit files, and it is an excellent replacement for nano. Set it as your default with export EDITOR=micro in your shell profile.

nano

nano is the simplest terminal text editor in common use. It displays keybinding hints at the bottom of the screen, so you never need to memorize commands. It is the default editor on many Linux distributions, which means many administrators already know how to use it.

Installation

nano is not in the FreeBSD base system but is a quick install:

sh
pkg install nano

Configuration lives at ~/.nanorc.

Configuration

A practical .nanorc:

shell
set autoindent
set tabsize 4
set tabstospaces
set linenumbers
set mouse
set softwrap
include "/usr/local/share/nano/*.nanorc"

The include line enables syntax highlighting for common file types.

Strengths

Absolute minimum learning curve. The keybinding hints at the bottom of the screen mean you never need external documentation.
Available everywhere. nano is packaged for every Unix-like operating system. It is the first editor many beginners learn.
Predictable. nano does one thing and does it adequately. It will never surprise you.

Weaknesses

Extremely limited. No splits, no tabs, no plugins, no LSP, no syntax-aware features.
Keybindings are non-standard. Ctrl+O to save (not Ctrl+S), Ctrl+X to exit, Ctrl+W to search. These are unique to nano and do not transfer to any other tool.
No mouse support by default. nano supports mouse input, but it must be explicitly enabled.
Syntax highlighting is basic. nano uses regex-based highlighting that is less accurate than Tree-sitter.
Slow on large files. nano can struggle with files over a few megabytes.

Verdict

nano is fine for quick edits to configuration files on a server. For anything more, use Micro (if you want simplicity) or Neovim (if you want power). There is no scenario in 2026 where nano is the best tool for a task -- but it is an acceptable tool for many tasks, and its familiarity has value.

Honorable Mentions

vi (in base system)

FreeBSD ships with vi (nvi) in the base system at /usr/bin/vi. It is always available, even on a minimal installation with no packages installed. This makes it essential knowledge for FreeBSD administration. If a system is so broken that you cannot install packages, vi is your only option for editing configuration files. Learn the basics: i to insert, Esc to return to normal mode, :wq to save and quit, :q! to quit without saving.

ee (Easy Editor)

ee is also in the FreeBSD base system. It is a simple, menu-driven editor that predates nano. Press Esc to access the menu bar. It is functional for quick edits but has no syntax highlighting, no modern features, and no community momentum. Use it when vi keybindings feel foreign and you cannot install anything.

joe (Joe's Own Editor)

sh
pkg install joe

joe emulates WordStar keybindings and has a loyal following among users who learned to type on DOS-era word processors. It supports syntax highlighting, multiple buffers, and macros. It is niche but well-maintained.

Kakoune

sh
pkg install kakoune

Kakoune is the editor that inspired Helix's selection-first editing model. It uses a client-server architecture and has a more developed plugin ecosystem than Helix (through shell scripting). If you want selection-first editing with extensibility today, Kakoune is worth evaluating. Its FreeBSD package is actively maintained.

Comparison Table

|---|---|---|---|---|---|---|

| Built-in LSP | No | Yes | Yes (Emacs 29+) | Yes | No | No |

| Tree-sitter | No | Yes | Yes (Emacs 29+) | Yes | No | No |

| Plugin system | Vimscript/Vim9 | Lua | Elisp | Not yet | Lua | No |

| Mouse support | Limited | Limited | Yes | Yes | Yes | Optional |

| Memory usage | ~10 MB | ~30 MB | ~200 MB | ~20 MB | ~10 MB | ~3 MB |

| Startup time | ~20 ms | ~40 ms | ~500 ms | ~10 ms | ~10 ms | ~5 ms |

| In base system | No | No | No | No | No | No |

| Modal editing | Yes | Yes | Optional (evil) | Yes | No | No |

Memory and startup times are approximate with default or moderate configurations. Emacs with Doom Emacs as a daemon effectively has zero startup time for subsequent connections.

FreeBSD-Specific Notes

vi in the Base System

FreeBSD includes nvi (/usr/bin/vi) in the base system. This is not Vim -- it is the original BSD vi implementation. It lacks syntax highlighting, multiple undo, and most features you expect from Vim. However, it is always available, even on a system where pkg has not been bootstrapped. Every FreeBSD administrator should know enough vi to edit /etc/rc.conf in an emergency.

Setting Your Default Editor

FreeBSD respects the EDITOR and VISUAL environment variables. Add one of these to your ~/.profile or ~/.zshrc:

sh
export EDITOR=nvim
export VISUAL=nvim

This affects crontab -e, visudo, git commit, and any other tool that opens an editor.

Installing from Ports vs. Packages

All editors in this guide are available as binary packages via pkg install. If you need custom compile options -- for example, building Vim with specific language bindings or Emacs with native compilation -- use the ports tree:

sh
cd /usr/ports/editors/neovim && make install clean

For most users, packages are the right choice. They are pre-built, faster to install, and updated regularly.

Language Servers on FreeBSD

LSP support in Neovim, Helix, and Emacs requires installing language servers separately. Common ones available in FreeBSD packages:

sh
pkg install rust-analyzer       # Rust
pkg install py311-python-lsp-server  # Python
pkg install ccls                # C/C++ (alternative to clangd)
pkg install lua-language-server # Lua

Many language servers can also be installed through their language's package manager (npm, pip, cargo) if a FreeBSD package is not available.

If you are setting up a full development environment on FreeBSD, see our guide on building a FreeBSD development environment for the complete setup including compilers, version control, and debugging tools.

Decision Guide

Follow this path to choose your editor:

Do you need to edit files on a minimal FreeBSD system with no packages?

Use vi. It is in the base system.

Do you want an editor that works like a normal desktop application?

Install Micro. If Micro is not available, install nano.

Do you want modal editing?

Continue below.

Do you want the editor to work out of the box with no configuration?

Install Helix.

Do you want maximum customization and the largest plugin ecosystem?

Install Neovim. Start with kickstart.nvim or LazyVim.

Do you want a unified environment for code, notes, email, and project management?

Install Emacs with Doom Emacs.

Do you need your configuration to work on every Unix system you touch?

Install Vim. Your .vimrc will work on any machine with Vim installed.

If you are setting up a new FreeBSD server from scratch, our FreeBSD VPS setup guide covers the initial system configuration, including how to set your default editor and shell.

Frequently Asked Questions

What text editor comes with FreeBSD by default?

FreeBSD includes two text editors in the base system: vi (nvi, the traditional BSD vi implementation) and ee (Easy Editor). Neither requires installing any packages. vi is at /usr/bin/vi and ee is at /usr/bin/ee. Both are always available, even on a minimal installation. For anything beyond basic editing, you will want to install a more capable editor from packages.

Is Vim installed by default on FreeBSD?

No. FreeBSD ships with nvi (/usr/bin/vi), not Vim. nvi is the original BSD vi implementation from the 1990s. It lacks syntax highlighting, multiple undo levels, split windows, and plugins. To get Vim, run pkg install vim. To get Neovim, run pkg install neovim. Both are available as binary packages.

Should I use Vim or Neovim on FreeBSD?

For new users in 2026, Neovim is the better starting point. It has native LSP support, Tree-sitter integration, and a Lua-based configuration system that is more approachable than Vimscript. If you already have a working Vim setup that does everything you need, there is no urgent reason to switch -- but if you are starting fresh, Neovim gives you more for less effort.

Can I use VS Code on FreeBSD?

VS Code does not have an official FreeBSD release. There are community efforts to build it from source, but the result is unsupported and may lack features like remote development and certain extensions. If you want a VS Code-like experience on FreeBSD, Neovim with the right plugins (LSP, Telescope, Tree-sitter) provides comparable code intelligence in the terminal. Alternatively, you can run VS Code on a desktop OS and use its Remote-SSH extension to connect to your FreeBSD server.

What is the best text editor for editing FreeBSD configuration files?

For quick, one-off edits to files like /etc/rc.conf, /etc/pf.conf, or /usr/local/etc/nginx/nginx.conf, any editor works. Micro is the easiest if you are not comfortable with modal editing. For regular system administration where you edit configuration files frequently, learning Neovim or Vim pays off quickly -- the ability to jump to specific lines (:42), search and replace across patterns (:%s/old/new/g), and repeat operations with . saves real time on every edit.

How do I make Neovim my default editor on FreeBSD?

Add the following lines to your ~/.profile, ~/.bashrc, or ~/.zshrc:

sh
export EDITOR=nvim
export VISUAL=nvim
alias vi=nvim
alias vim=nvim

This ensures that tools like crontab -e, git commit, visudo, and vipw open Neovim. The aliases are optional but convenient if your muscle memory types vi or vim.

Is Emacs too heavy for a FreeBSD server?

Emacs uses more resources than other editors on this list, but "too heavy" depends on your server. On a VPS with 1 GB of RAM, an Emacs daemon using 200-400 MB is a significant fraction of available memory. On a server with 4 GB or more, it is negligible. If resource usage is a concern, use Neovim or Helix. If you need Org-mode or Magit and your server has the RAM, Emacs runs fine on FreeBSD -- its resource usage is modest by desktop application standards.

Conclusion

The FreeBSD ecosystem supports every major text editor. The base system gives you vi for emergencies, and pkg install puts Neovim, Vim, Emacs, Helix, Micro, or nano one command away.

For most developers working on FreeBSD in 2026, Neovim is the right default choice. It combines the efficiency of modal editing with modern features like native LSP and Tree-sitter that previously required a full IDE. Helix is a strong alternative if you prefer zero-configuration productivity. Emacs remains unmatched for users who want an integrated environment. And Micro is the best option for anyone who wants simplicity without learning modal editing.

Pick one, learn it well, and get back to work.