Features • Installation • Troubleshooting

This language server and an extension for VSCode-based editors provide comprehensive support for TON Blockchain languages and technologies including Tolk, FunC, Fift assembly, TL-B, BoC and Blueprint.

Tolk support includes:

• Semantic syntax highlighting
• Code completion with auto import, postfix completion, snippets, imports completion
• Go to definition, type definition
• Find all references, workspace symbol search, symbol renaming
• Automatic import updates when renaming and moving files
• Types and documentation on hover
• Inlay hints for types, parameter names, and more
• On-the-fly inspections with quick fixes
• Signature help inside calls
• Build and test projects based on Blueprint
• Flexible toolchain management

FunC support includes:

• Basic syntax highlighting

Fift assembly support includes:

• Basic and semantic syntax highlighting
• Go-to definition
• Inlay hints with instruction gas consumption
• Hover documentation for instructions

TL-B support includes:

• Basic and semantic syntax highlighting
• Go-to definition
• Completion for fields, parameters, and types
• Go-to references for types
• Hover documentation for declarations

BoC support includes:

• Automatic BoC disassembly with syntax highlighting
• Automatic updates on BoC changes

The easiest way to get started with TON development is to use VS Code or editors based on it:

1. Install the TON extension in VS Code or in VS Code-based editors
2. That's it!

The extension automatically detects your toolchain installation. If you need to work with custom-builds or configurations, check out the toolchain management guide.

1. Get the latest .vsix file from releases from VS Code marketplace or from Open VSX Registry
2. In VS Code:
   • Open the Command Palette (Ctrl+Shift+P or Cmd+Shift+P)
   • Type "Install from VSIX"
   • Select the downloaded .vsix file
   • Reload VS Code

1. Get the latest archive from releases:
   • ton-language-server-*.tar.gz for Linux/macOS
   • ton-language-server-*.zip for Windows
2. Extract it to a convenient location
3. Configure your editor to use the language server (see editor-specific instructions below)

If you want to build the language server yourself:

git clone https://github.com/ton-blockchain/ton-language-server
cd ton-language-server
yarn install
yarn build

To obtain the .vsix package with the VS Code extension, additionally run:

yarn package

Then run either of those to install the extension from the .vsix package:

# VSCode, replace VERSION with the actual version from package.json
code --install-extension vscode-ton-VERSION.vsix

# VSCodium, replace VERSION with the actual version from package.json
codium --install-extension vscode-ton-VERSION.vsix

1. Install LSP package:

   • Open Command Palette (Ctrl+Shift+P or Cmd+Shift+P)
   • Select "Package Control: Install Package"
   • Search for and select "LSP"

2. Add the following configuration to your LSP settings (Preferences > Package Settings > LSP > Settings):

   {
       "clients": {
           "ton": {
               "enabled": true,
               "command": ["node", "path/to/language-server/dist/server.js", "--stdio"],
               "selector": "source.tolk, source.fift, source.tlb",
           },
       },
       "inhibit_snippet_completions": true,
       "semantic_highlighting": true,
   }

3. Create a new file or open an existing file with the .tolk, .fift, or .tlb extension to verify the setup

Prerequisites:

• nvim-lspconfig
• Neovim 0.5.0 or newer

Setup steps:

1. Add ton.lua to your lua/lspconfig/server_configurations directory with the following content:

   local util = require 'lspconfig.util'
   
   return {
     default_config = {
       cmd = { 'node', '/absolute/path/to/language-server/dist/server.js', '--stdio' },
       filetypes = { 'tolk', 'fift', 'tlb' },
       root_dir = util.root_pattern('package.json', '.git'),
     },
     docs = {
       description = [[
         TON Language Server
         https://github.com/ton-blockchain/ton-language-server
       ]],
       default_config = {
         root_dir = [[root_pattern("package.json", ".git")]],
       },
     },
   }

2. Add the following to your init.lua:

   require'lspconfig'.ton.setup {}

Prerequisites:

• Vim 8 or newer
• Async LSP Client for Vim: vim-lsp

Recommended, but not required:

• Auto-configurations for many language servers: vim-lsp-settings

Setup steps:

1. Install the vim-lsp plugin if it isn't already installed. For that, use vim-plug or the built-in package manager of Vim 8+, see :help packages.

• If it wasn't installed before, you should set up basic keybindings with the language client. Add the following to your ~/.vimrc (or ~/_vimrc if you're on Windows):

  function! s:on_lsp_buffer_enabled() abort
      setlocal omnifunc=lsp#complete
      setlocal signcolumn=yes
      if exists('+tagfunc') | setlocal tagfunc=lsp#tagfunc | endif
      nmap <buffer> gd <plug>(lsp-definition)
      nmap <buffer> gs <plug>(lsp-document-symbol-search)
      nmap <buffer> gS <plug>(lsp-workspace-symbol-search)
      nmap <buffer> gr <plug>(lsp-references)
      nmap <buffer> gi <plug>(lsp-implementation)
      nmap <buffer> gt <plug>(lsp-type-definition)
      nmap <buffer> <leader>rn <plug>(lsp-rename)
      nmap <buffer> [g <plug>(lsp-previous-diagnostic)
      nmap <buffer> ]g <plug>(lsp-next-diagnostic)
      nmap <buffer> K <plug>(lsp-hover)
      nnoremap <buffer> <expr><c-f> lsp#scroll(+4)
      nnoremap <buffer> <expr><c-d> lsp#scroll(-4)
  
      let g:lsp_format_sync_timeout = 1000
      autocmd! BufWritePre *.rs,*.go call execute('LspDocumentFormatSync')
  
      " Refer to the doc to add more commands:
      " https://github.com/prabirshrestha/vim-lsp#supported-commands
  endfunction
  
  augroup lsp_install
      au!
      " call s:on_lsp_buffer_enabled only for languages that have the server registered.
      autocmd User lsp_buffer_enabled call s:on_lsp_buffer_enabled()
  augroup END

2. Add the following to your ~/.vimrc (or ~/_vimrc if you're on Windows):

   if executable('node')
     au User lsp_setup call lsp#register_server({
           \ 'name': 'tolk',
           \ 'cmd': {server_info->['node', '/absolute/path/to/language-server/dist/server.js', '--stdio']},
           \ 'allowlist': ['tolk'],
           \ })
   endif

1. Add the following configuration to your ~/.config/helix/languages.toml:

   [[language]]
   name = "tolk"
   language-servers = ["ton-language-server"]
   
   [language-server.ton-language-server]
   
   command = "node"
   args = ["/absolute/path/to/language-server/dist/server.js", "--stdio"]

2. Replace path/to/language-server with the actual path where you cloned the repository

3. Restart Helix for changes to take effect

See TROUBLESHOOTING.md.

MIT