Neo​Vintageous

About NeoVintageous

NeoVintageous is an advanced Vim emulator for Sublime Text.

• :sparkles: For a full list of supported Vim features, please refer to our roadmap.
• :rocket: The changelog outlines the breaking/major/minor updates between releases.
• :page_facing_up: Vim's full documentation is accessible via :help {subject} and online.
• Report missing features/bugs on GitHub.
• Drop-in replacement for Vintageous
• Zero configuration required

• About NeoVintageous
• Installation
• Settings
• Modes
• neovintageousrc
• Key mapping
  • Leader mapleader
  • LocalLeader maplocalleader
  • Map commands
  • Special arguments
  • Mapping Specific File-Types
  • Mapping and modes
  • map-overview
  • Mapping special keys
  • Mapping Ex Commands
  • Mapping Sublime Text Commands
  • Mapping Super-Keys
  • Mapping Case-Sensitivity
  • Mapping for Toggling the Side Bar
  • Mapping for Revealing the Side Bar
  • Mapping Capslock to Escape
• Options
• Customize Search Highlighting Colors
• Plugins
  • Highlighted Yank
  • Customize Highlighted Yank Colors
  • Input Method :rocket: :new: Since v1.32
  • Markology :rocket: :new: Since v1.32
  • Customize Markology Mark Colors
  • Multiple Cursors
  • Sneak
  • Customize sneak mappings
• F.A.Q.
  • Key Presses are Laggy or Slow
  • On macOS (OSX):
  • On Ubuntu (GNOME desktop):
  • On KDE:
  • On X11 Systems (generic method):
• Contributing
  • Enable Pre-Release Upgrades
• Changelog
• Credits
• License

Installation

Package Control Installation

1. Open Sublime Text.
2. Press Ctrl+Shift+P (Windows/Linux) or Cmd+Shift+P (macOS) to open the Command Palette.
3. Type “Package Control: Install Package” and press Enter.
4. In the input field, type “NeoVintageous” and select it from the list of available packages.

Git Repository Installation

1. Open a terminal or command prompt.
2. Navigate to the Sublime Text Packages directory:
   • On Windows: %APPDATA%\Sublime Text\Packages
   • On macOS: ~/Library/Application Support/Sublime Text/Packages
   • On Linux: ~/.config/sublime-text/Packages
3. Clone the plugin repository directly into the Packages directory using Git:

git clone https://github.com/NeoVintageous/NeoVintageous.git

Settings

Command Palette → Preferences: NeoVintageous Settings

Modes

[count] - An optional number that may precede the command to multiply or iterate the command.

neovintageousrc

A file that contains initialization commands is typically referred to as a “vimrc” file. In NeoVintageous, this file is called “neovintageousrc”. Each line in the neovintageousrc file is executed as an Ex command at startup.

To edit the neovintageousrc file, follow these steps:

1. Open the Command Palette: Command Palette → NeoVintageous: Open neovintageousrc file.

2. Make the necessary changes to the file.

3. To apply the changes, reload the neovintageousrc from the Command Palette: Command Palette → NeoVintageous: Reload neovintageousrc file.

Key mapping

<Leader> mapleader

To define a mapping which uses the “g:mapleader” variable, the special string “<Leader>” can be used. It is replaced with the string value of “g:mapleader”. If “g:mapleader” is not set or empty, a backslash is used instead. Example:

noremap <Leader>A  oanother line<Esc>

Works like:

noremap \A  oanother line<Esc>

But after:

let mapleader=,

It works like:

noremap ,A  oanother line<Esc>

Note that the value of “g:mapleader” is used at the moment the mapping is defined. Changing “g:mapleader” after that has no effect for already defined mappings.

<LocalLeader> maplocalleader

<LocalLeader> is just like <Leader>, except that it uses “maplocalleader” instead of “mapleader”. Example:

let maplocalleader=,
noremap: <LocalLeader>A  oanother line<Esc>

Map commands

There are commands to enter new mappings, remove mappings and list mappings.

See map-overview for the various forms of “map” and their relationships with modes.

{lhs} means left-hand-side.

{rhs} means right-hand-side.

Special arguments

FileType <type> can be used to limit a mapping to specific file types. It must appear right after the command, before any other arguments. This feature is specific to Sublime Text.

Mapping Specific File-Types

File type specific mappings are supported by the FileType keyword that accepts a comma-delimited list of file-types.

Example: Map gd to the lsp_symbol_definition command for *.go and *.html files.

nnoremap FileType go,html gd :LspSymbolDefinition<CR>

Mapping and modes

There are seven sets of mappings

• For Normal mode: When typing commands.
• For Visual mode: When typing commands while the Visual area is highlighted.
• For Select mode: like Visual mode but typing text replaces the selection.
• For Operator-pending mode: When an operator is pending (after “d”, “y”, “c”, etc.).
• For Insert mode. These are also used in Replace mode.

Special case: While typing a count for a command in Normal mode, mapping zero is disabled. This makes it possible to map zero without making it impossible to type a count with a zero.

map-overview

Overview of which map command works in which mode. More details below.

Same information in a table:

Mapping special keys

In Vim, certain keys hold special significance. You can find a useful list of these special keys, along with their notations and codes, in the Vim documentation's key-notation and key-codes section.

Examples

Mapping Ex Commands

Example: Map CTRL-l to the :nohlsearch command to stop the highlighting for the 'hlsearch' option.

noremap <C-l> :nohlsearch<CR>

For a full list of supported ex commands, please refer to our roadmap.

Mapping Sublime Text Commands

Sublime Text commands are mappable. The command must be PascalCase and the parameters must be space separated.

Note: Sublime Text commands are PascalCased for the purpose of distinguishing them from Ex commands, which always start with a lowercase letter. This choice is due to an implementation detail.

Example: Map ,f to the show_overlay command with arguments {"overlay": "goto", "text": "@"}

nnoremap ,f :ShowOverlay overlay=goto text=@<CR>

Where do these commands come from?

When you run a command in Sublime Text, you can inspect the console log to discover the command and arguments needed to map it.

1. Console Logging: View console logging by navigating to Menu → View → Show Console.

2. Command and Input Logging: Enable command and input logging by running the following commands in the console:

sublime.log_commands(True)
   sublime.log_input(True)

For example, let's say you want to map “Goto Symbol” command above. Run the command, e.g., “Menu → Goto → Goto Symbol” command and Sublime Text will print the following in the console:

command: show_overlay {"overlay": "goto", "text": "@"}

Mapping Super-Keys

Super keys, also known as the Windows key or Command key (⌘) on Mac, are denoted as <D-...>.

For example, to map the <D-i> combination to the goto_symbol_in_project command, add the following configuration to your neovintageousrc file:

nnoremap <D-i> :GotoSymbolInProject<CR>

With this mapping in place, pressing the Super key (Windows key or Command key on Mac) together with the 'i' key will trigger the goto_symbol_in_project command in NeoVintageous.

Please note that this example demonstrates mapping the <D-i> combination for illustrative purposes. You can map other Super-key combinations or any desired key combinations to different commands based on your needs and preferences.

Mapping Case-Sensitivity

All keys are case-sensitive in Sublime Text. This means that <D-i> and <D-I> are treated as two distinct key events, allowing you to map actions to both.

Example: Map “Goto Symbol in Project” and “Goto Symbol in File” using case-sensitive mappings

To map the Super-key (Windows key or Command key on Mac) together with the 'i' key to the “Goto Symbol in Project” command, add the following configuration to your neovintageousrc file:

noremap <D-i> :GotoSymbolInProject<CR>

To map the Super-key together with the 'Shift' and 'i' keys (<D-I>) to the “Goto Symbol in File” command, add the following configuration to your neovintageousrc file:

noremap <D-I> :ShowOverlay overlay=goto text=@<CR>

With these mappings in place, you can now use both <D-i> and <D-I> combinations to trigger different commands in NeoVintageous.

Feel free to modify and customize these mappings based on your preferences and workflow. The case-sensitivity of the keys allows you to create distinct mappings for different actions, providing you with greater flexibility in your keybindings.

Mapping for Toggling the Side Bar

To toggle the side bar using your preferred mapping (in this example, <leader>d), first, add the following configuration to your neovintageousrc file:

let mapleader=,
nnoremap <leader>d :Neovintageous action=toggle_side_bar<CR>

Next, open the Command Palette and navigate to Preferences: Key Bindings. Add the following JSON key binding to be triggered when the side bar has focus:

{
    "keys": [",", "d"],
    "command": "neovintageous",
    "args": {
        "action": "toggle_side_bar"
    },
    "context": [
        { "key": "control", "operand": "sidebar_tree" }
    ]
}

Please note that the provided example uses <leader>d as the mapping, but you can customize it to your preferred mapping by modifying the <leader> part and updating the key binding to match your leader and preferred key. For instance, if your preferred mapping is <leader>t, you can modify the mapping as follows:

1. Update the mapping in your neovintageousrc file:

let mapleader=,
nnoremap <leader>t :Neovintageous action=toggle_side_bar<CR>

1. Open the Command Palette and navigate to Preferences: Key Bindings. Add the following JSON key binding to be triggered when the side bar has focus, using your preferred key combination:

{
    "keys": [",", "t"],
    "command": "neovintageous",
    "args": {
        "action": "toggle_side_bar"
    },
    "context": [
        { "key": "control", "operand": "sidebar_tree" }
    ]
}

By making these modifications, you can now use your preferred mapping (e.g., <leader>t) to easily toggle the side bar while using NeoVintageous in Sublime Text. This flexibility allows you to choose a keyboard combination that suits your workflow and personal preferences.

Mapping for Revealing the Side Bar

To reveal the side bar using your preferred mapping (in this example, <leader><leader>), first, add the following configuration to your neovintageousrc file:

let mapleader=,
nnoremap <leader><leader> :Neovintageous action=reveal_side_bar<CR>

Next, open the Command Palette and navigate to Preferences: Key Bindings. Add the following JSON key binding to be triggered when the side bar has focus:

{
    "keys": [",", ","],
    "command": "focus_group",
    "args": {
        "group": 0
    },
    "context": [
        { "key": "control", "operand": "sidebar_tree" }
    ]
}

With this setup, you can now use the specified key bindings to easily toggle and reveal the side bar while using NeoVintageous in Sublime Text.

Please note that the provided example uses <leader><leader> as the mapping, but you can customize it to your preferred mapping by modifying the <leader> part and updating the key binding to match your leader and preferred key. See Mapping for Toggling the Side Bar for a more detailed example.

Mapping Capslock to Escape

NeoVintageous cannot directly remap the CapsLock key; however, you can achieve this remapping at the operating system level. For instance, on Ubuntu, you can map the CapsLock key to Escape using a tool called gsettings. Follow these steps to make the remapping:

1. Open a terminal.

2. Run the following command to map CapsLock to Escape using gsettings:

gsettings set org.gnome.desktop.input-sources xkb-options "['caps:escape']"

After executing this command, the CapsLock key will act as the Escape key in your system. This means that when using NeoVintageous or any other application, pressing CapsLock will have the same effect as pressing the Escape key.

Please note that the specific method to remap keys might vary depending on your operating system or desktop environment. Be sure to check the documentation or forums related to your OS for any variations or additional steps.

Options

The list below includes all options, presented with their full names and corresponding abbreviations, where applicable. You can use either form interchangeably. Certain options act as proxies to Sublime Text settings, meaning they utilize the underlying Sublime Text setting. Modifying the option will consequently alter the corresponding Sublime Text setting.

Customize Search Highlighting Colors

You can customize the colors for search highlighting in Sublime Text.

To tailor these colors, follow these steps:

1. Open the Command Palette by using the shortcut Ctrl+Shift+P (or Cmd+Shift+P on macOS).

2. Type and select: UI: Customize Color Scheme.

3. Within the color scheme file, define distinct styles for various search highlighting scopes:

• neovintageous_search_inc: This scope is used for highlighting the current search incrementally as you type.
• neovintageous_search_cur: This scope is used for highlighting the current search term.
• neovintageous_search_occ: This scope is used for highlighting all occurrences of the search term.

Here's an example of defining styles for these scopes:

{
    "rules": [
        {
            "scope": "neovintageous_search_inc",
            "background": "#a1efe4",
            "foreground": "#272822"
        },
        {
            "scope": "neovintageous_search_cur",
            "background": "#a1efe4",
            "foreground": "#272822"
        },
        {
            "scope": "neovintageous_search_occ",
            "background": "#e6db74",
            "foreground": "#272822"
        }
    ]
}

Feel free to adjust the color values ("#a1efe4", "#e6db74", etc.) according to your preferences.

Personalizing search highlighting colors improves the visual distinction of results in your code, enhancing your overall coding experience.

Plugins

Experience the power of Vim with NeoVintageous, which seamlessly integrates several impressive Vim plugins right out of the box. While we continuously strive for feature parity, please note that some functional differences might exist, and they may not always be fully documented.

If you come across any missing features or observe variations in functionality, we warmly encourage you to create issues to request enhancements. For a comprehensive inventory of supported Vim features and a detailed development roadmap, kindly consult our roadmap.

Additional plugins, install via Package Control:

• NeoVintageous Files: Single key side bar and overlay file commands. :rocket: :new:
• NeoVintageous Highlight Line: Auto-disable highlight line when entering Insert mode and Visual modes. :rocket: :new:
• NeoVintageous Line Numbers: Auto-disable relative line numbers when entering Insert mode. :rocket: :new:
• NeoVintageous Toggle: Toggle NeoVintageous on and off from the command palette.

Enhanced support, install via Package Control:

• SublimeLinter: Required for jump-to lint-error commands (i.e., [l and ]l).
• Origami: Required for some window commands (e.g., CTRL-w s, CTRL-w v, CTRL-w ]).

Additional keyboard layouts, manual installation:

• NeoVintageous Dvorak: Dvorak key mappings. :rocket: :new:
• NeoVintageous Colemak: Colemak key mappings. :rocket: :new:

Blog

• blog.gerardroche.com: Releases, guides, and tips.

Highlighted Yank

Highlighted Yank is a plugin designed to highlight the yanked region in Sublime Text.

When new text is yanked, the old highlighting is automatically deleted. This ensures that the highlighting remains relevant to the most recent yanked text. Similarly, when former lines are edited, the highlighting is cleared to prevent shifting the position of the highlighting.

You can customize the highlighted yank duration and style using the following settings:

• vintageous_highlighted_yank_duration: This setting allows you to configure the duration for which the yanked region will be highlighted. You can set the duration according to your preferences.

• vintageous_highlighted_yank_style: This setting allows you to customize the style of the highlighted yank region. You can modify the background and foreground colors to suit your color scheme.

Customize Highlighted Yank Colors

To tailor the colors of highlighted yanks to your preference, you can create a color scheme override using the following steps:

1. Open the Command Palette by using the shortcut Ctrl+Shift+P (or Cmd+Shift+P on macOS).

2. Open the Command Palette: UI: Customize Color Scheme.

3. Add the following styles using the “highlightedyank” scope, and adjust the background and foreground colors as desired:

{
    "rules": [
        {
            "scope": "highlightedyank",
            "background": "#e6db74",
            "foreground": "#272822"
        }
    ]
}

By customizing the colors of highlighted yanks, you can make yanked regions more visually distinctive and ensure they align with your preferred color scheme, enhancing your editing experience in the Sublime Text editor.

Input Method :rocket: :new: Since v1.32

Automatically switch the input method when entering and exiting Insert Mode.

Any third-party program can be used to switch input methods. Below are some examples.

Below, you'll find instructions for installing and using input method switchers on various operating systems.

The {im} argument in the configurations below represents a command-line option that will be passed to the input switcher command, indicating the desired input method for switching. If you're using an alternative program for input method switching, you should incorporate a similar option into the configuration. For instance, if the alternate program's syntax for switching input methods is my-program -s im, then the vintageous_auto_switch_input_method_set_cmd should be set to /path/to/my-program -s {im}. This ensures compatibility with different input method switching tools.

Linux:

1. Install an Input Method Switcher:

Choose from popular options like:

• ibus: A powerful input method framework.

• xkb-switch: A lightweight utility for XKB-based layouts.

• fcitx: A flexible and feature-rich input method platform.

• gdbus: A command-line tool for switching input methods.

  Put the following into im-get e.g., ~/bin/im-get.

  You may need to make the script executable e.g., chmod 744 ~/bin/im-get.

  #!/bin/sh
    gdbus call \
        --session \
        --dest org.gnome.Shell \
        --object-path /org/gnome/Shell \
        --method org.gnome.Shell.Eval \
        "imports.ui.status.keyboard.getInputSourceManager().currentSource.index" | \
        awk -F'[^0-9]*' '{print $2}'
  

  Put the following into im-set e.g., ~/bin/im-set.

  You may need to make the script executable e.g., chmod 744 ~/bin/im-set.

  #!/bin/sh
    gdbus call \
        --session \
        --dest org.gnome.Shell \
        --object-path /org/gnome/Shell \
        --method org.gnome.Shell.Eval \
        "imports.ui.status.keyboard.getInputSourceManager().inputSources[$1].activate()"
  

• qdbus: A D-Bus tool for communication with input methods.

1. Determine your Default Input Method:

Switch your input method to English and execute the following commands in your terminal:

• ibus: Run ibus engine. Example output: xkb:us::eng
• xkb-switch: Run xkb-switch. Example output: us
• fcitx: Run fcitx-remote. Example output: 1
• gdbus: Run /path/to/im-get. Example output: 0
• qdbus: Run /usr/bin/qdbus org.kde.keyboard /Layouts getLayout. Example output: 0

1. Configure the Input Method Auto Switcher:

   1. Open the Command Palette by using the shortcut Ctrl+Shift+P.
   2. Add the following JSON configuration:

   ibus

   {
         "vintageous_auto_switch_input_method": true,
         "vintageous_auto_switch_input_method_default": "xkb:us::eng",
         "vintageous_auto_switch_input_method_get_cmd": "/usr/bin/ibus engine",
         "vintageous_auto_switch_input_method_set_cmd": "/usr/bin/ibus engine {im}"
     }
   

   xkb-switch

   {
         "vintageous_auto_switch_input_method": true,
         "vintageous_auto_switch_input_method_default": "us",
         "vintageous_auto_switch_input_method_get_cmd": "/usr/local/bin/xkb-switch",
         "vintageous_auto_switch_input_method_set_cmd": "/usr/local/bin/xkb-switch -s {im}"
     }
   

   fcitx

   {
         "vintageous_auto_switch_input_method": true,
         "vintageous_auto_switch_input_method_default": "1",
         "vintageous_auto_switch_input_method_get_cmd": "/usr/bin/fcitx-remote",
         "vintageous_auto_switch_input_method_set_cmd": "/usr/bin/fcitx-remote -t {im}"
     }
   

   gdbus

   {
         "vintageous_auto_switch_input_method": true,
         "vintageous_auto_switch_input_method_default": "0",
         "vintageous_auto_switch_input_method_get_cmd": "/path/to/im-get",
         "vintageous_auto_switch_input_method_set_cmd": "/path/to/im-set {im}"
     }
   

   qdbus (KDE)

   {
         "vintageous_auto_switch_input_method": true,
         "vintageous_auto_switch_input_method_default": "0",
         "vintageous_auto_switch_input_method_get_cmd": "/usr/bin/qdbus org.kde.keyboard /Layouts getLayout",
         "vintageous_auto_switch_input_method_set_cmd": "/usr/bin/qdbus org.kde.keyboard /Layouts setLayout {im}"
     }
   

Mac:

1. Install an Input Method Switcher:

Choose from popular options like:

• im-select: A versatile input switching tool.

1. Determine Your Default Input Method:

Switch your input method to English and execute the following commands in your terminal:

• im-select: Run im-select. Example output: com.apple.keylayout.US

1. Configure the Input Method Auto Switcher:

   1. Open the Command Palette by using the shortcut Cmd+Shift+P.
   2. Add the following JSON configuration:

   im-select

   Given the input method key of com.apple.keylayout.US and im-select located at /usr/local/bin. The configuration is:

   {
         "vintageous_auto_switch_input_method": true,
         "vintageous_auto_switch_input_method_default": "com.apple.keylayout.US",
         "vintageous_auto_switch_input_method_get_cmd": "/usr/local/bin/im-select",
         "vintageous_auto_switch_input_method_set_cmd": "/usr/local/bin/im-select {im}"
     }
   

Windows:

1. Install an Input Method Switcher:

Choose from popular options like:

• im-select: A versatile input switching tool.

1. Determine Your Default Input Method:

Switch your input method to English and execute the following commands in your terminal:

• im-select: Run im-select. Example output: 1033

1. Configure the Input Method Auto Switcher:

   1. Open the Command Palette by using the shortcut Ctrl+Shift+P.
   2. Add the following JSON configuration:

   im-select

   Given the input method key of 1033 (en_US) and im-select.exe located at D:/bin. The configuration is:

   {
         "vintageous_auto_switch_input_method": true,
         "vintageous_auto_switch_input_method_default": "1033",
         "vintageous_auto_switch_input_method_get_cmd": "D:\\bin\\im-select.exe",
         "vintageous_auto_switch_input_method_set_cmd": "D:\\bin\\im-select.exe {im}"
     }
   

Markology :rocket: :new: Since v1.32

Markology displays marks associated with the current line in the gutter. You can disable this feature by modifying the setting vintageous_show_marks_in_gutter.

To do so, follow these steps:

1. Open the Command Palette: Preferences: NeoVintageous Settings.
2. Add the following JSON configuration:

{
    "vintageous_show_marks_in_gutter": false
}

By adjusting this setting, you can control whether marks are displayed in the gutter for the current line.

Customize Markology Mark Colors

If you wish to personalize the color of the marks displayed by Markology, you can follow these steps to create a color scheme override:

1. Open the Command Palette by using the shortcut Ctrl+Shift+P (or Cmd+Shift+P on macOS).

2. Type and select: UI: Customize Color Scheme.

3. Add the following JSON configuration, adjusting the color as desired:

{
    "rules": [
        {
            "scope": "neovintageous.mark",
            "foreground": "yellow"
        }
    ]
}

By customizing the color of the marks, you can ensure they are visually distinct and align with your preferred color scheme, providing you with a more tailored and visually appealing editing experience in Sublime Text.

Multiple Cursors

NeoVintageous provides multiple cursor support in normal mode and visual mode. This feature allows you to work with multiple cursors simultaneously, making repetitive editing tasks more efficient.

Normal and Visual Mode Commands

You can now use visual commands such as c, I, x, and y, which work without any issues.

You could also go to Normal mode by pressing v and use normal commands there.

At any time, you can press <Esc> to exit back to regular Vim.

To change the behaviour of <Esc>, you can set the vintageous_multi_cursor_exit_from_visual_mode setting. When set to false, pressing a quit key (e.g., <Esc> or J) in multiple cursor visual mode exits to normal mode but keeps the cursors. When set to true, pressing a quit key (e.g., <Esc> or J) in multiple cursor visual mode exits all multiple cursors.

With the multiple cursor feature, you can speed up your editing workflow by applying commands to multiple locations simultaneously, increasing productivity and convenience.

Sneak

By default, Sneak is disabled to prevent conflicts with certain Vim commands such as s, S, z, and Z. To enable Sneak, follow these steps:

1. Open the Command Palette by selecting Preferences: NeoVintageous Settings.
2. Add the following JSON configuration:

{
    "vintageous_enable_sneak": true
}

Customize sneak mappings

You can customize the default sneak mappings by setting environment variables.

The necessity to configure these mappings through environment variables, rather than conventional settings, arises from an implementation detail: plugins are loaded during startup, and access to settings is not available at this stage. Resolving this issue will require making significant design adjustments. In the meantime, employing environment variables provides a viable solution.

The environment variables:

NEOVINTAGEOUS_SNEAK_MAP_S=s
NEOVINTAGEOUS_SNEAK_MAP_BIG_S=S
NEOVINTAGEOUS_SNEAK_MAP_Z=z
NEOVINTAGEOUS_SNEAK_MAP_BIG_Z=Z

Example: For Linux users, consider adding the following lines to your ~/.profile or ~/.bashrc file:

export NEOVINTAGEOUS_SNEAK_MAP_S=s
export NEOVINTAGEOUS_SNEAK_MAP_BIG_S=S
export NEOVINTAGEOUS_SNEAK_MAP_Z=z
export NEOVINTAGEOUS_SNEAK_MAP_BIG_Z=Z

Please keep in mind that to activate these changes, you will be required to restart Sublime Text and, in some cases, reboot your system.

Example: For Windows users:

You can set environment variables for each user separately through the System Properties dialog box. The steps to do that:

1. Type Windows Key + R to open the “Run” dialog box.
2. Enter “sysdm.cpl” and press the “OK” button. The “System Properties” dialog box will open.
3. Select the “Advanced” tab and press the “Environment Variables…” button. The “Environment Variables” dialog box will open.
4. Select an existing variable in the “User variables” list and press the “Edit…” button to edit it. Or press the “New…” button to add a new variable.
5. After you finished editing variables, press the “OK” button to save the changes.

Please keep in mind that to activate these changes, you will be required to restart Sublime Text and, in some cases, reboot your system.

F.A.Q.

Key Presses are Laggy or Slow

If you are experiencing laggy or slow key presses, it could be due to the system configuration. Here are some steps you can take to improve the responsiveness of key presses:

On macOS (OSX):

1. Enable Key Repeat: If holding down a key like “j” does not repeat the command (a feature of macOS), you can enable key repeat by running this command once at the terminal:

defaults write com.sublimetext.3 ApplePressAndHoldEnabled -bool false

On Ubuntu (GNOME desktop):

1. Configure Keyboard Repeat Interval and Delay: You can adjust the keyboard repeat interval and delay using gsettings. Open a terminal and run the following commands:

gsettings set org.gnome.desktop.peripherals.keyboard repeat-interval 15
   gsettings set org.gnome.desktop.peripherals.keyboard delay 180

On KDE:

1. Adjust Keyboard Delay and Rate: For KDE users, you can change the keyboard delay and rate by running the following command:

systemsettings5 kcm_keyboard

This will bring up a window where you can change the 'Delay' and 'Rate' settings as required.

On X11 Systems (generic method):

1. Directly Set Keyboard Repeat Rate: For X11 type systems, you can directly set the keyboard repeat rate using xset. Open a terminal and run the following command:

xset r rate <milliseconds_before_repeating> <repetitions_per_second>

For example, to set a 300 milliseconds delay before repeating and a repetition rate of 30 repetitions per second, use:

xset r rate 300 30

By adjusting these settings, you can enhance the responsiveness of key presses and improve your typing experience in Sublime Text or any other applications on your system.

Contributing

See CONTRIBUTING.md.

Enable Pre-Release Upgrades

Pre-release versions of packages allow you to access the latest features, improvements, and bug fixes before they are officially released. If you're eager to test out new functionalities in NeoVintageous, you can enable pre-release installation with a simple configuration.

1. Open the Command Palette by using the shortcut Ctrl+Shift+P (or Cmd+Shift+P on macOS). Type and select Preferences: Package Control Settings to open the settings file for Package Control.

2. In the user settings file, add the “install_prereleases” setting and specify “NeoVintageous” in the list of packages to enable pre-release installation:

{
       "install_prereleases": ["NeoVintageous"]
   }

Save the settings file.

1. After saving the settings, you can now install the pre-release version of NeoVintageous. Open the Command Palette again and type Package Control: Upgrade Package to install the pre-release version.

2. Enjoy the Latest Features:

With pre-release installation enabled, you'll receive updates to NeoVintageous before they are officially released. Enjoy exploring and testing the latest features and improvements.

Note:

Pre-release versions might contain experimental features or changes that are still being refined. If you encounter any issues or have feedback, feel free to share it with us on the NeoVintageous GitHub repository.

Changelog

See CHANGELOG.md.

Credits

NeoVintageous is a fork of the discontinued Vintageous plugin.

License

Released under the GPL-3.0-or-later License.