Neovim как среда мышления

За последние годы мир редакторов как будто замер. Массовый выбор сделан: удобные интерфейсы, готовые экосистемы, предсказуемый пользовательский опыт, десятки расширений, которые ставятся в пару кликов. На этом фоне Neovim выглядит почти анахронизмом — терминальный редактор, уходящий корнями в эпоху, когда вычислительные ресурсы экономили почти так же жадно, как сегодня экономят внимание. Слишком странный, слишком требовательный, слишком похожий на вещь, которую современная индустрия давно должна была оставить в музее.

Но с Neovim случилось иначе. Он не исчез, не остался маргинальной игрушкой для нескольких упрямых энтузиастов и даже не законсервировался как памятник славному прошлому. Наоборот: в какой-то момент стало ясно, что этот почти архаичный с виду инструмент удивительно точно попал в нерв современной разработки. Пока большие редакторы и IDE соревновались в том, кто лучше скроет сложность за дружелюбным интерфейсом, Neovim предложил другую сделку: не прятать сложность, а дать пользователю самому решить, какой она будет и где именно окажется.

Вот сцена, которая повторяется в десятках команд по всему миру. Один разработчик открывает VS Code, ставит пару расширений и сразу приступает к задаче. Другой открывает терминал, запускает nvim, и со стороны его экран выглядит так, будто человек работает в программе из девяностых. Но проходит полгода, и именно второй всё реже тянется к мыши, всё точнее формулирует правки, всё быстрее ориентируется в чужом коде. Он не стал хакером из кино. Он просто научился думать о тексте иначе.

В этом, вероятно, и заключается причина живучести Neovim. Его любят не потому, что он «быстрее печатает код» или потому, что в нём есть какая-то особая романтика терминала. Его любят за более редкую вещь: за чувство контроля. За ощущение, что редактор — не чужой комбайн с навязанной логикой, а инструмент, который можно собрать под собственный ритм мышления. Для одних это выглядит как ненужная форма инженерного мазохизма. Для других — как один из самых честных и мощных способов работать с текстом, кодом, структурой и вниманием.

Парадокс Neovim в том, что он одновременно очень старый и очень современный. Его фундамент вырос из идей, которые появились задолго до нынешнего бума «настраиваемых сред», «компонуемых инструментов» и «персональной инфраструктуры разработчика». Но именно сейчас эти идеи снова звучат актуально. Neovim оказался не попыткой законсервировать прошлое, а способом заново прочитать его в эпоху, когда разработчики всё сильнее устают от монолитных инструментов и всё чаще хотят не просто редактор, а среду, которая действительно принадлежит им.

Именно поэтому говорить о Neovim как просто о текстовом редакторе уже недостаточно. Это не только программа для редактирования файлов и не только наследник Vim с более современной архитектурой. Это ещё и культурный феномен, и инженерная философия, и в каком-то смысле проверка того, насколько далеко человек готов зайти ради ощущения, что его инструменты подчиняются ему, а не наоборот.

Этот текст — не инструкция по установке плагинов и не попытка в очередной раз доказать, что Neovim «лучше» других редакторов. Гораздо интереснее другое: как вообще появился Neovim, почему он оказался так важен, что именно умеет сегодня, за что его любят, почему он иногда бесит — и как получилось, что редактор из терминальной традиции стал для тысяч разработчиков не просто рабочим инструментом, а формой мышления.

Чтобы понять, почему Neovim вообще оказался в этой точке, нужно вернуться к идеям, из которых он вырос — и которые оказались удивительно долговечными.

От ed до Neovim: как рождались идеи, пережившие эпохи

Чтобы понять, почему Neovim вообще стал заметным явлением, мало сказать, что это «ответвление Vim». Формально этого достаточно, по сути — почти ничего не объясняет. За словом «форк» легко теряется главное: Neovim появился не как случайная ветка старого проекта и не как каприз группы энтузиастов, которым захотелось ещё один редактор. Он вырос из гораздо более глубокой линии — из одной из самых сильных идей в истории программных инструментов вообще.

Эта линия начинается задолго до самого Neovim и даже задолго до Vim. В 1969 году Кен Томпсон написал ed — строчный текстовый редактор для только что родившейся операционной системы UNIX. Экран у терминалов тогда нередко представлял собой рулон бумаги, и ed работал именно так: пользователь вводил команду, получал результат, вводил следующую. Ни курсора, ни визуального представления файла — только адреса строк и операции над ними. Звучит как пытка, но именно здесь зародилась мысль, что текстом можно управлять командами, а не только набирать его символ за символом.

В 1976 году Билл Джой, будучи аспирантом в Беркли, создал vi — визуальную надстройку над ex (потомком ed). Впервые редактор показал пользователю весь файл целиком и позволил перемещаться по нему в реальном времени. Но главное наследие vi — не в визуальности как таковой. Главное — модальность. Джой разделил ввод текста и управление им на разные режимы, и это решение, казавшееся многим страным, оказалось фундаментально мощным.

Позже появился Vim, и именно он превратил эти идеи в нечто большее, чем удачный текстовый редактор. В 1991 году Брам Моленар выпустил первую версию — Vi IMproved — изначально для компьютера Amiga. Vim стал системой мышления о редактировании. Не случайно у него сложилась почти культурная аура: для одних это был выдающийся инструмент, для других — странный культ, для третьих — личная профессиональная дисциплина. Но в любом случае Vim оказался намного влиятельнее, чем можно было бы ожидать от программы, работающей в терминале. Его сила была не в экзотике и не в аскетизме как таковом. Она была в том, что он предложил очень плотную модель взаимодействия с текстом: редактирование не как медленное перемещение курсора и набор символов, а как язык действий, движений и преобразований.

В этом смысле Vim перестал быть просто редактором. Он стал одной из тех программ, которые меняют не только поведение пользователя, но и его представление о самой задаче. Человек, всерьёз освоивший Vim, обычно уже не воспринимает текст как последовательность символов, по которой надо аккуратно водить курсором. Он начинает видеть структуру, области, объекты, повторяющиеся паттерны и операции, которые можно комбинировать. Именно поэтому влияние Vim всегда было больше его доли на рынке. Даже там, где люди не пользовались им ежедневно, они сталкивались с его философией — через модальное редактирование, через привязки клавиш, через попытки привнести его механику в другие редакторы. Сегодня режим Vim встроен в VS Code, JetBrains, Obsidian, браузеры — практически повсюду.

Но у всякой долгой истории есть своя цена. Сила Vim росла десятилетиями, и вместе с ней росла сложность того, что находилось под капотом. Брам Моленар сопровождал проект более тридцати лет, лично контролируя почти каждое изменение. Это обеспечивало целостность, но делало эволюцию медленной. Проекты такого масштаба редко бывают лёгкими для перемен: чем больше слоёв накапливается, тем труднее двигаться, тем тяжелее менять фундаментальные вещи, тем болезненнее любая попытка сделать архитектуру более современной. И дело тут не в том, что Vim «устарел» в каком-то уничижительном смысле. Скорее наоборот: он слишком долго и слишком успешно нёс на себе огромный пласт традиции, обратной совместимости, привычек сообщества и исторических решений. Всё это делало его великим проектом, но одновременно усложняло движение в сторону более современной расширяемости, более прозрачного API и более удобной интеграции с внешними инструментами.

Именно в этой точке становится понятен смысл появления Neovim. В 2014 году бразильский разработчик Тиаго де Аррудо опубликовал манифест и запустил краудфандинговую кампанию на Bountysource. Идея была не в том, чтобы «убить Vim», а в том, чтобы освободить его сильные принципы от технического груза, который мешал им развиваться. Проект предлагал конкретные вещи: рефакторинг кодовой базы, современный API, встроенную поддержку асинхронных задач, возможность писать плагины на любом языке через протокол удалённого вызова. Кампания собрала больше тридцати тысяч долларов, и вокруг проекта быстро образовалось активное сообщество.

Здесь важно не скатиться в примитивную драматургию, где есть «старый плохой Vim» и «новый правильный Neovim». Такая схема слишком груба и, честно говоря, просто неверна. Без Vim не было бы ни самой идеи, ни той культуры, ни той инженерной глубины, из которой вырос Neovim. Но и сводить Neovim к роли косметического обновления тоже нельзя. Он стал попыткой дать тем же фундаментальным принципам другую операционную форму — более открытую к современным интеграциям, более удобную для программируемости, более приспособленную к миру, где редактор уже не живёт в изоляции, а постоянно взаимодействует с языковыми серверами, Git, средствами форматирования, анализаторами, поисковыми утилитами и целыми цепочками внешних инструментов.

Vim можно представить как собор, который достраивали поколениями: впечатляющий, сложный, живой, но не всегда легко поддающийся перепланировке. Neovim в этом контексте — не попытка разрушить собор, а способ сохранить его архитектурный замысел, переложив коммуникации и часть внутренней инфраструктуры под новый век. Речь идёт не о смене веры, а о реконструкции несущих конструкций.

В этом как раз и заключается историческая важность Neovim. Он не придумал заново модальность, не изобрёл текстовые объекты и не отменил традицию Vim. Его роль была другой: сделать так, чтобы всё это не осталось музейной ценностью, а снова стало технологически живым. Не как памятник прошлой инженерной эпохе, а как рабочая основа для новой.

Но сама по себе история происхождения ещё не объясняет, почему всё это так цепляет пользователей. Ответвление, архитектура, сообщество, кодовая база — всё это важно, но вторично по отношению к главному. В центре здесь не репозиторий и не язык конфигурации. В центре — довольно радикальная идея о том, что редактирование текста вообще можно устроить иначе.

Эта идея — модальное редактирование как язык действий — и есть то, что делает Vim и Neovim принципиально отличными от большинства других редакторов.

Редактирование как язык: главная идея Vim и Neovim

Почти все разговоры о Vim и Neovim рано или поздно упираются в одни и те же внешние признаки: терминал, тёмные темы, клавиатурные сочетания, странные команды, модальные режимы, мемы про то, как сложно выйти из редактора. Всё это давно стало частью культурного образа. Но если убрать антураж, останется куда более важная вещь: Neovim предлагает не просто другой набор команд, а другую модель редактирования.

В большинстве обычных редакторов работа с текстом устроена предсказуемо. Есть курсор, есть ввод, есть выделение, есть набор команд, привязанных к меню или горячим клавишам. Пользователь в этой модели в основном перемещается по тексту, выбирает участок и применяет к нему действие. Это хорошо знакомый паттерн, и он кажется естественным просто потому, что мы к нему привыкли. Но привычность ещё не означает, что это единственно возможная или даже лучшая форма взаимодействия.

Модель Vim исходит из другого предположения: ввод текста и управление текстом — это не одно и то же. Набирать символы и оперировать уже существующей структурой — разные задачи, и смешивать их в одном режиме не обязательно. Отсюда и возникает модальность, которая для новичка обычно выглядит как источник бессмысленного трения. Человек открывает редактор и внезапно обнаруживает, что привычная интуиция больше не работает. Нажатия ведут себя «не так», текст не вставляется тогда, когда ожидаешь, команды надо осваивать отдельно. В первые часы или дни это действительно может казаться неочевидной, даже искусственной сложностью.

Но проблема здесь не в том, что модальность плоха, а в том, что она требует перестройки базовой привычки. Большинство визуальных редакторов приучили нас к идее, что одно и то же пространство отвечает и за набор текста, и за навигацию, и за команды. Neovim разводит эти задачи. И как только это разделение перестаёт казаться враждебным, в нём начинает проступать очень мощная внутренняя логика. Редактор больше не выглядит как поле, в котором ты то печатаешь, то случайно даёшь команды. Он становится системой, где разные режимы соответствуют разным намерениям.

Это важный момент, потому что дальше открывается главная красота всей модели: редактирование начинает напоминать язык. Не в метафорическом, а почти в буквальном смысле. Вместо набора разрозненных горячих клавиш возникает грамматика действий. Есть оператор — удалить (d), изменить (c), скопировать (y). Есть движение — до слова (w), до конца строки ($), к следующему абзацу (}). Есть объект — содержимое скобок (i)), текст в кавычках (i"), абзац (ap), аргумент функции (ia). Есть повтор — точка (.), которая воспроизводит последнее действие. Есть композиция: daw — удалить слово, ci" — заменить содержимое кавычек, yap — скопировать абзац. Пользователь не столько «вызывает команду», сколько формулирует операцию над текстом.

Представьте: вы читаете чужой код и видите, что строковый аргумент "production" нужно заменить на "staging". В обычном редакторе вы берёте мышь, аккуратно выделяете текст внутри кавычек, набираете новое значение. В Neovim вы ставите курсор куда угодно внутри кавычек и набираете ci"staging — «изменить внутри кавычек, вставить staging». Три секунды, без мыши, без выделения, без прицеливания. А если такая замена нужна в двадцати местах? Вы выполняете действие один раз, потом находите следующее место и нажимаете . — точка повторяет операцию. Двадцать правок за двадцать нажатий.

Это и есть тот переломный момент, после которого Neovim перестаёт быть странным терминальным редактором и начинает выглядеть как одна из самых интересных идей в интерфейсах работы с текстом. В обычном редакторе вы часто мыслите координатами: подвести курсор, выделить мышью, попасть в нужный фрагмент, не промахнуться, применить действие. В Neovim вы постепенно начинаете мыслить структурами: изменить содержимое скобок, удалить абзац, выделить блок, повторить предыдущее преобразование, перейти к следующему логическому объекту. Внимание смещается с геометрии экрана на логику текста.

Именно поэтому текстовые объекты в этой традиции — не маленькая возможность для продвинутых, а одна из лучших идей во всей конструкции. Они позволяют работать не с «семью символами вправо» и не с «примерно этим куском, который я сейчас мышью выделю», а с осмысленными единицами. Кавычки, скобки, предложения, абзацы, блоки, функции, аргументы — всё это превращается в нечто, над чем можно выполнять действия почти как над грамматическими объектами. Пользователь перестаёт быть человеком, который водит курсор по экрану. Он становится человеком, который оперирует структурой текста.

Это сдвигает и саму когнитивную нагрузку. Многие думают о Neovim в категориях скорости: будто главный вопрос в том, можно ли в нём работать быстрее. Но более точное слово здесь — не скорость, а плотность намерения. Когда действие формулируется на уровне структуры, а не набора механических движений, уменьшается часть мелкого трения. Редактор начинает лучше соответствовать тому, как человек думает о правке: не «мне нужно подвести курсор вон туда и выделить вот это», а «мне нужно изменить содержимое этого блока» или «повторить такое же преобразование на следующем объекте».

Разумеется, у этой модели есть цена. Она требует обучения. Она не дарит мгновенного комфорта. Она ломает привычки, которые приобретены в других редакторах и кажутся единственно правильными. Но именно это и делает её интересной: здесь удобство не выдано авансом. Оно накапливается по мере того, как пользователь начинает мыслить не кнопками, а операциями. Поэтому опыт Neovim так трудно объяснять тем, кто смотрит на него со стороны. Внешне они видят редактор, который требует слишком многого. Внутренне пользователь начинает видеть систему, которая, наоборот, лучше согласована с его намерениями.

Можно сказать и жёстче: обычный редактор в большинстве случаев предлагает набор команд. Neovim предлагает синтаксис. И как только эта разница становится ощутимой, всё остальное — конфиги, плагины, темы, строки состояния, терминальные анимации — отходит на второй план. За этим стоит очень сильная и довольно редкая идея: текст можно не просто набирать и править, а обрабатывать как организованную структуру, используя для этого компактный, выразительный язык действий.

Но одной красивой идеи было бы недостаточно. Чтобы модальное мышление снова заработало в современной разработке, ему нужна была новая архитектурная опора. И именно здесь начинается история Neovim как современной платформы.

Почему Neovim оказался современнее, чем выглядит

Со стороны Neovim легко принять за вещь, чья главная ценность — верность традиции. Терминал, модальность, минималистичный интерфейс, наследие Vim — всё это действительно отсылает к очень длинной истории. Но одна из самых любопытных особенностей Neovim в том и состоит, что его современность неочевидна внешне. Он выглядит как ретро-инструмент, но при этом даётдовольно точный ответ на некоторые очень актуальные запросы современной разработки.

Проблема многих разговоров о редакторах в том, что их слишком часто описывают только на уровне интерфейса. Удобный или неудобный, красивый или аскетичный, понятный или сложный. Но с Neovim это не прокатывает. Его сила не в том, что он визуально современнее или дружелюбнее в массовом смысле слова, а в том, что он получил более современную программную основу. Иначе говоря, он оказался важен не как ностальгическая оболочка вокруг старых привычек, а как удачное соединение старой модели редактирования с новой инженерной архитектурой.

Вместе с переходом на Lua — о котором мы поговорим отдельно — у Neovim усилилась важнейшая черта: открытость к внешним интеграциям. Современный редактор давно уже не может существовать как изолированный текстовый мир. Он постоянно взаимодействует с целой инфраструктурой: языковые серверы анализируют код, анализаторы проверяют стиль и ошибки, средства форматирования приводят файлы в соответствие с соглашениями, Git подсказывает изменения, поисковые утилиты шерстят репозиторий, терминал запускает тесты, сборку и скрипты. В такой экосистеме редактор должен быть не просто местом, где открыт файл. Он должен быть координационным узлом, через который проходит и где связывается множество внешних процессов.

Переломным стал 2016 год, когда Microsoft опубликовала спецификацию Language Server Protocol. До этого каждый редактор и каждая IDE выстраивали поддержку языков самостоятельно: свои парсеры, свои подсказки, свои переходы к определениям. LSP изменил правила: один языковой сервер обслуживает любой редактор, который понимает протокол. Для Neovim это оказалось подарком. Редактор с хорошим API и открытой архитектурой мог теперь получить «умный» слой — диагностику, автодополнение, переименования, переходы по ссылкам — без необходимости строить всё это с нуля. Встроенный LSP-клиент, появившийся в Neovim 0.5 (2021), убрал одну из последних причин, по которым можно было говорить: «Для настоящей работы всё равно нужна IDE».

Именно поэтому для Neovim так важны API, плагины и вся его программируемая поверхность. Они меняют не только количество возможностей, но и сам тип редактора. Из текстового инструмента он превращается в ядро среды. Это тонкое, но принципиальное изменение. Старый образ редактора предполагал, что есть программа для текста, а всё остальное живёт где-то рядом. В случае Neovim текст остаётся в центре, но вокруг него выстраивается целая рабочая система: навигация по проекту, поиск, подсказки, диагностика, Git, запуск тестов, чтение логов, терминальные команды, локальные заметки, автоматизации. Не обязательно потому, что Neovim хочет стать ещё одной гигантской IDE, а потому, что он умеет быть хорошей поверхностью для сборки своей среды из компонентов.

Здесь же становится особенно важной асинхронность. На первый взгляд это может звучать как деталь, интересная в основном тем, кто любит архитектурные разговоры. Но на деле это один из тех элементов, которые пользователь чувствует почти телесно, даже если никогда не называет их по имени. Современный редактор не должен застывать от каждого сложного действия. Подсказки не должны вызывать задержки в работе. Фоновый анализ кода, проверки Git, поиск по большим репозиториям, обновления дерева символов — всё это должно происходить так, чтобы не разрушать ритм. И в этом смысле Neovim оказался не просто «современным, потому что поддерживает новые штуки», а современным, потому что его внутренняя модель лучше соответствует идее живого, готового к взаимодействиям редактора.

Это особенно хорошо видно на примере LSP и всего, что выросло вокруг него. Когда-то разговор о Vim-подобных редакторах часто строился вокруг компромисса: да, они хороши для быстрых правок и терминальной работы, но настоящая «умная среда» всё равно где-то в мире больших IDE. Neovim заметно раздвинул эту границу. Переходы к определениям, поиск ссылок, переименования, действия с кодом, диагностика, форматирование, автодополнение — всё это перестало быть недостижимой мечтой для аскетов и стало нормальной частью экосистемы. И что особенно важно, этот слой «языкового интеллекта» не уничтожил идентичность редактора. Neovim не просто скопировал чужую модель. Он встроил многие её сильные стороны в свою, более модульную систему.

В этом и заключается его парадоксальная современность. Он не выигрывает у других редакторов тем, что полностью скрывает сложность. Скорее наоборот: он принимает как факт, что сложность никуда не денется, и предлагает более честно распределить её. Вместо одного большого монолита с заранее заданной логикой пользователь получает платформу, на которой можно выстроить то, что ему требуется. Для кого-то это будет минусом, потому что готовое решение всегда психологически комфортнее. Но для другого типа разработчика именно здесь и начинается настоящая ценность: среда перестаёт быть чёрным ящиком и становится материалом, с которым можно работать.

Neovim оказался современнее, чем выглядит. Не потому, что научился быть похожим на все остальные редакторы, а потому, что очень точно совпал с важным сдвигом в инженерной культуре. Сегодня многим уже недостаточно просто удобного инструмента. Им нужен инструмент, который можно присвоить, настроить, встроить в свою систему. Neovim отвечает именно на этот запрос. Он предлагает не отполированную универсальность, а программируемую глубину. Не мгновенную дружелюбность, а высокий потенциал совпадения с личным ритмом работы.

Но один архитектурный сдвиг заслуживает отдельного разговора. Именно Lua стал тем языком, который превратил настройку Neovim из эзотерической практики в нормальную инженерную работу.

Lua: язык, который изменил всё

Если выбирать момент, после которого экосистема Neovim стала расти по-настоящему быстро, это переход на Lua. Не потому, что Lua сам по себе — какой-то волшебный язык, а потому, что он решил проблему, которая десятилетиями держала мир Vim в полузакрытом состоянии.

Vimscript — собственный язык конфигурации Vim — был мощным, но специфичным. Он складывался органически, слой за слоем, по мере того как Vim обрастал возможностями. Для человека, который жил внутри Vim годами, Vimscript был терпим и даже привычен. Но для любого разработчика «извне» он выглядел как язык с причудливым синтаксисом, неочевидной семантикой и документацией, требующей отдельного посвящения. Написать рабочий конфиг — сложно, но можно. Написать сложный плагин — уже тяжело. Отлаживать — мучительно. Конфигурация Vim оставалась чем-то вроде средневековой рукописи: мощная, но доступная лишь посвящённым.

Neovim не отказался от Vimscript полностью. Он по-прежнему понимает его и не ломает совместимость. Но с версии 0.5 (2021 год) главным языком настройки и расширения стал Lua. Выбор был неслучайным. Lua — компактный, быстрый, встраиваемый язык, давно зарекомендовавший себя в игровой индустрии, встроенных системах и других проектах, где важна лёгкость интеграции. В контексте Neovim он дал несколько вещей одновременно.

Во-первых, скорость. Neovim использует LuaJIT — компилятор, который транслирует Lua в машинный код. Конфигурация, которая на Vimscript работала «достаточно быстро», на Lua начинает работать заметно быстрее. Для маленьких конфигов это неважно, но когда в настройке сотни строк логики, десятки автокоманд и сложная инициализация плагинов, разница ощутима. Редактор запускается быстрее, реагирует мгновеннo, меньше «спотыкается» при загрузке.

Во-вторых — и это, пожалуй, важнее — доступность. Lua читается как нормальный язык программирования. Его синтаксис прозрачен для любого, кто работал с Python, JavaScript, Ruby или хотя бы с псевдокодом. Таблицы, функции, строки, циклы, условия — всё выглядит знакомо. Конфигурация Neovim на Lua — это не заклинания, а обычный код:

-- Базовые настройки
vim.opt.number = true         -- номера строк
vim.opt.relativenumber = true -- относительная нумерация
vim.opt.expandtab = true      -- пробелы вместо табуляции
vim.opt.shiftwidth = 4        -- ширина отступа
vim.opt.termguicolors = true  -- полная палитра цветов

-- Привязка клавиш: пробел как лидер
vim.g.mapleader = " "

-- Быстрое сохранение
vim.keymap.set("n", "<leader>w", "<cmd>write<cr>",
  { desc = "Сохранить файл" })

-- Перемещение между окнами без Ctrl-W
vim.keymap.set("n", "<C-h>", "<C-w>h")
vim.keymap.set("n", "<C-l>", "<C-w>l")

Этот код не требует знания Vimscript. Любой разработчик, взглянув на него, поймёт, что происходит. Именно это снизило порог входа для тысяч людей, которые раньше смотрели на конфигурацию Vim как на чёрную магию.

В-третьих, Lua открыл путь к настоящей программируемости. Через пространство имён vim.api пользователь получает доступ ко всему внутреннему состоянию редактора: буферы, окна, курсоры, пространство команд, автокоманды, группы подсветки. Можно написать функцию, которая при сохранении файла автоматически убирает лишние пробелы в конце строк. Можно создать команду, которая открывает терминал с определённым контекстом. Можно реагировать на события — открытие файла, смену буфера, начало редактирования — и выполнять произвольную логику.

-- Автокоманда: убрать лишние пробелы при сохранении
vim.api.nvim_create_autocmd("BufWritePre", {
  pattern = "*",
  callback = function()
    local pos = vim.api.nvim_win_get_cursor(0)
    vim.cmd([[%s/\s\+$//e]])
    vim.api.nvim_win_set_cursor(0, pos)
  end,
})

Это уже не «конфигурация» в традиционном смысле — это программирование редактора. Разница принципиальная. Вместо того чтобы подбирать нужный плагин на каждую мелочь, пользователь может написать десять строк Lua и решить задачу точно под себя. Не универсально, не красиво для публикации на GitHub — но именно так, как нужно ему в его повседневной работе.

Четвёртый эффект Lua — расцвет экосистемы плагинов. До перехода на Lua большинство плагинов Vim были написаны на Vimscript, часть — на Python или Ruby через внешние интерфейсы. Lua-плагины оказались быстрее, проще в разработке и ближе к ядру редактора. За несколько лет возникла целая волна современных дополнений: Telescope (нечёткий поиск), nvim-treesitter (структурный разбор синтаксиса), nvim-lspconfig (настройка языковых серверов), lazy.nvim (менеджер плагинов с отложенной загрузкой), gitsigns.nvim (интеграция с Git). Все они написаны на Lua и используют API Neovim напрямую. Это создало плотную, быструю и хорошо связанную экосистему, которой у Vim в таком виде никогда не было.

Наконец, Lua изменил саму культуру настройки. Если раньше конфигурация Vim часто была длинным, плохо структурированным файлом .vimrc, то конфигурация Neovim на Lua — это обычный проект. Файл init.lua может импортировать модули из отдельных файлов. Настройки плагинов живут в своих модулях. Привязки клавиш отделены от параметров. Автокоманды сгруппированы по назначению. Это не просто эстетика — это возможность управлять конфигурацией как кодом: версионировать в Git, рефакторить, делить на части, понимать через полгода, что здесь происходит и зачем.

~/.config/nvim/
├── init.lua              -- точка входа
├── lua/
│   ├── config/
│   │   ├── options.lua   -- базовые настройки
│   │   ├── keymaps.lua   -- привязки клавиш
│   │   └── autocmds.lua  -- автокоманды
│   └── plugins/
│       ├── telescope.lua -- поиск
│       ├── treesitter.lua -- синтаксис
│       ├── lsp.lua       -- языковые серверы
│       └── git.lua       -- Git-интеграция

Такая структура понятна любому разработчику. Она не требует особого «Vim-мышления» для навигации. Она позволяет новичку начать с простого init.lua на двадцать строк и постепенно наращивать сложность, не теряя контроля.

Переход на Lua не был безболезненным. Часть старых плагинов осталась на Vimscript, и они по-прежнему работают. Мост между двумя языками иногда создаёт путаницу: одни вещи удобнее делать через vim.cmd (вызов Vimscript-команд из Lua), другие — через чистый Lua API. Документация долго догоняла реальность. Но в целом результат трудно переоценить. Lua сделал для Neovim то, что JavaScript сделал для браузера: превратил среду исполнения из закрытого мира в открытую платформу, где тысячи людей могут строить свои решения.

Но никакая архитектура сама по себе не заставляет людей любить инструмент. Привязанность рождается не в API, а в ритме повседневной работы.

Почему люди влюбляются в Neovim

Если смотреть на Neovim только со стороны, любовь к нему легко принять за разновидность профессиональной эксцентрики. Редактор с высоким порогом входа, модальностью, конфигами, странной терминальной эстетикой и бесконечными разговорами о том, как именно должен выглядеть «правильный» рабочий процесс, не очень похож на очевидный объект массовой симпатии. Тем не менее у Neovim есть одна редкая черта: те, кому он по-настоящему подходит, обычно привязываются к нему не поверхностно, а очень глубоко. И дело здесь не в фетише клавиатуры, не в романтике консоли и не в желании чувствовать себя техничнее других. Причины этой привязанности гораздо интереснее.

Первая из них — ощущение непрерывности. В хорошо настроенном Neovim действия перетекают друг в друга, не прерываясь на мелкие вынужденные паузы: потянуться к мыши, найти нужную кнопку, переключить контекст, вернуться в код и вспомнить, на чём остановился. Каждое такое микропрерывание по отдельности почти незаметно. Но за несколько часов сосредоточенной работы они накапливаются — и именно их отсутствие создаёт то ощущение цельного рабочего ритма, за которое люди ценят Neovim.

Это особенно заметно в длинной, сосредоточенной работе. Когда человек пишет код, читает чужую систему, разбирает ошибки, переписывает участок логики или просто пытается удержать в голове несколько уровней абстракции сразу, любое лишнее трение начинает ощущаться почти физически. В такой ситуации Neovim оказывается силён не как магический ускоритель, а как инструмент, который лучше удерживает целостность действия. Он меньше похож на среду, в которой пользователь постоянно договаривается с интерфейсом, и больше — на пространство, в котором интерфейс уже встроен в мышление.

Вторая причина — ощущение, что среда по-настоящему твоя. Большинство современных редакторов и IDE работают по принципу гостеприимства: среда готова, обжита, продумана, а пользователь приходит в неё как гость — может передвинуть мебель, но не перестроить дом. Это хорошая модель, и в массе случаев она действительно удобна. Но некоторым людям важно другое: не просто пользоваться чужим пространством, а жить в своём.

Neovim предлагает противоположный опыт. Он не обещает готовой гармонии. Он, скорее, говорит: вот мощная, немного суровая, местами неровная система; если вложиться в неё, она позволит собрать среду под ваш способ работы. И именно эта возможность обжить инструмент оказывается для многих почти решающей. Редактор перестаёт быть чужой программой, которую ты терпишь ради её возможностей, и становится собранной под себя инфраструктурой. Среда не просто обслуживает задачу — она начинает совпадать с твоими привычками, приоритетами, способом двигаться по тексту, переключаться между режимами работы, организовывать внимание.

Вот характерная сцена. Разработчик полгода работал в VS Code, потом попробовал Neovim и через несколько недель мучений вернулся обратно: «Слишком сложно, не моё». Прошло ещё полгода — и он снова в Neovim. Что изменилось? Он не стал терпеливее. Он заметил, что в VS Code постоянно делает одни и те же монотонные вещи: тянется к мыши, чтобы переключить вкладку; выделяет текст, чтобы заменить один аргумент; открывает боковую панель, чтобы найти файл. Каждое действие по отдельности — пустяк. Но за день их набирается сотни, и каждое чуть-чуть разрывает поток. Neovim не обещал ему скорости — он обещал непрерывность. И на этот раз обещание оказалось настоящим.

Отсюда возникает третья причина — когнитивная компактность. Для многих людей главный комфорт Neovim не в том, что он «умеет всё», а в том, что множество действий начинают жить в одной логике. Навигация по файлам, переходы по символам, поиск по проекту, правки, диагностика, быстрые операции с Git, запуск тестов, заметки, работа с терминалом — всё это перестаёт быть набором разрозненных островов, между которыми нужно постоянно перестраивать способ взаимодействия. Да, технически в любой экосистеме можно собрать похожий набор возможностей. Но именно в Neovim они часто ощущаются как части одного ритма, а не как серия соседствующих функций.

Эта когнитивная компактность особенно ценна для тех, кто много работает не только с написанием, но и с чтением, исследованием, анализом. В индустрии любят говорить о «производительности», будто разработка состоит в основном из активного написания кода. В реальности огромная часть работы — это чтение чужих файлов, понимание структуры проекта, поиск причин ошибки, сравнение изменений, точечные переписывания, мелкие массовые трансформации, постоянное удержание контекста. Neovim хорошо попадает именно в эту ткань повседневного труда.

Есть и четвёртая, менее рациональная причина, о которой обычно говорят с некоторым смущением: удовольствие от инструментальности как таковой. Люди вообще любят хорошо сделанные инструменты не только за пользу, но и за качество контакта. Это касается музыкальных инструментов, фотоаппаратов, кухонных ножей, механических клавиатур, велосипедов, языков программирования и редакторов текста. В какой-то момент важным становится не только то, что инструмент позволяет сделать, но и то, как именно он это позволяет. Neovim для многих попадает именно в эту зону. Он даёт не только функциональную выгоду, но и почти телесное чувство, что работаешь с вещью, которую можно оттачивать, понимать, углублять, делать «своей».

Конечно, в этом месте легко скатиться в романтизацию и начать приписывать редактору мистические свойства. Этого как раз стоит избегать. Neovim не делает человека автоматически умнее, дисциплинированнее или продуктивнее. Он не превращает работу в эстетическое совершенство и не отменяет рутину. Но он действительно может изменить то, как человек переживает собственный рабочий процесс. И если этот новый ритм совпадает с внутренней организацией внимания, привязанность возникает очень быстро. Внешне это выглядит как любовь к странному терминальному редактору. Внутренне — как узнавание инструмента, который вдруг оказался удивительно близок твоему способу думать и работать.

Вся эта привязанность была бы пустой, если бы за ней не стояла реальная повседневная мощь. Поэтому следующий вопрос простой: что Neovim действительно умеет в работе — не в теории, а в живых сценариях.

Что Neovim умеет на практике: сцены вместо списка возможностей

Одна из главных проблем почти любого текста про редакторы в том, что в какой-то момент он начинает напоминать каталог характеристик. С Neovim особенно легко попасть в эту ловушку, потому что экосистема у него большая, список возможностей длинный, а соблазн перечислить «что уже можно сделать» очень велик. Но по-настоящему сила редактора видна не в списке, а в сценах. Не в том, что он умеет теоретически, а в том, как он ведёт себя внутри реальной работы.

Написание нового кода

Долгое время вокруг Vim-подобных редакторов существовал устойчивый стереотип: да, это отличные инструменты для быстрых правок и терминальной работы, но когда начинается «настоящая разработка» с переходами по определениям, диагностикой, рефакторингом и автодополнением — без большой IDE не обойтись. Сегодня этот образ плохо описывает реальность. Современный Neovim умеет быть полноценной средой для повседневного программирования: языковые серверы дают переходы к определениям и ссылкам, переименования, действия с кодом, подсказки по типам и диагностике. Дополнение, сниппеты и средства форматирования делают опыт достаточно плотным, чтобы редактор не ощущался голой терминальной коробкой.

Важно, впрочем, не то, что Neovim «догнал IDE» по галочкам, а то, что он делает это по-своему. Он не пытается обязательно стать монолитной средой, где весь мир уже организован за пользователя. Скорее он даёт возможность собрать именно тот интеллектуальный слой, который нужен конкретному стеку и конкретному ритму работы.

Чтение чужого кода

Разработка состоит из чтения не меньше, а часто и больше, чем из письма. Но именно чтение почему-то реже становится критерием выбора редактора. Здесь Neovim проявляет одну из своих самых сильных сторон. Быстрые переходы между файлами, поиск по проекту, ссылки, список переходов, символы, локальные списки результатов — всё это делает его особенно сильным там, где нужно не столько писать, сколько понимать.

Вот типичная ситуация: вы подключаетесь к новому проекту на Go с несколькими сотнями файлов. В IDE вы бы открыли дерево проекта и начали щёлкать по папкам. В Neovim вы нажимаете <leader>ff (нечёткий поиск файлов), набираете часть имени — и через секунду в нужном месте. Оттуда gd — перейти к определению. gr — найти все места, где эта функция используется. <C-o> — вернуться назад. За пять минут вы обошли полпроекта, не открыв ни одного бокового дерева и не тронув мышь.

Массовые однотипные правки

Именно здесь Neovim особенно нагляден в своём отличии от графических редакторов. Когда нужно повторить одну и ту же трансформацию много раз — аккуратно пройти по похожим структурам, переименовать, поправить форму, вычистить повторяющийся мусор, — его язык действий, повтора и макросов даёт серьёзное преимущество.

Реальный пример: в конфигурационном файле на YAML нужно заменить двести строк вида enabled: true на enabled: false, но только внутри блоков, помеченных определённым тегом. В обычном редакторе это либо поиск с заменой (рискованно — заменит везде), либо ручная работа. В Neovim вы находите первое место, делаете правку (ciwfalse<Esc>), потом записываете макрос: перейти к следующему совпадению, повторить правку. Дальше — 200@q, и двести замен выполняются за секунду. Настоящая сила Neovim часто проявляется не в «больших функциях», а именно в этой мелкой механике повторяемости.

Большие и шумные проекты

Когда репозиторий становится достаточно объёмным, чтобы визуальная навигация по вкладкам перестала работать, Neovim раскрывает свои сильные стороны иначе. В таких средах выигрывает не тот редактор, который показывает больше панелей, а тот, который позволяет быстро и без перегруза искать, перемещаться, собирать результаты и держать под рукой список релевантных мест. Нечёткий поиск, поиск по содержимому через ripgrep, список ошибок, символы, буферы, фрагменты изменений Git — всё это образует не просто набор удобств, а систему работы с масштабом.

Текст, а не только код

Одна из самых недооценённых сторон Neovim — его пригодность для работы с текстом вообще. Документация, Markdown, заметки, черновики статей, конфигурации, YAML, JSON, структурированные списки, таблицы, файлы журналов — всё это тоже материал, который постоянно требует движения по структуре, повторяющихся операций, перестроек, локальных трансформаций. Есть распространённая привычка считать Neovim редактором «для программистов», как будто вне кода его сила заканчивается. На самом деле он хорошо раскрывается там, где текст нужно не просто набрать, а активно формировать, перестраивать, чистить, организовывать. Этот лонгрид, к примеру, написан в Neovim — в Markdown, с использованием текстовых объектов для абзацев, сниппетов для ссылок и нечёткого поиска для навигации между разделами.

Жизнь внутри терминала

Тут Neovim остаётся особенно органичным: он не просто существует рядом с другими консольными инструментами, а естественно встраивается в их ритм. Поиск через ripgrep, работа с Git, запуск тестов, просмотр журналов, связь с tmux, быстрые локальные скрипты, сборка и перезапуск — всё это превращает редактор в нечто большее, чем «место, где открыт файл». Он становится центром, из которого удобно не только редактировать, но и управлять соседними действиями. Для части пользователей именно это ощущение оказывается главным: Neovim не заменяет всё на свете, но организует множество рабочих операций так, что между ними меньше шума и меньше разрыва.

При этом важно не строить из Neovim мифическую универсальную машину. Его практическая сила — не в том, что он «лучше всего во всём», а в том, что он особенно хорошо чувствует текстоцентричные, поисковые, навигационные и трансформационные сценарии. И чем больше рабочий день состоит не из красивых демо-моментов, а из длинного, неровного, местами скучного взаимодействия с кодом и текстом, тем заметнее становится его сила.

Но одного факта, что редактор «многое умеет», недостаточно. По-настоящему Neovim раскрывается там, где пользователь перестаёт накапливать возможности и начинает выстраивать собственную логику работы.

На сегодня это всё. Продолжение будет завтра.