Skip to content


Switch branches/tags


Failed to load latest commit information.
Latest commit message
Commit time

Wolfram Language Server

Develop with: Wolfram Language License: MIT CI


Table of Contents

Wolfram Language Server (WLServer) is an implementation of the Microsoft's Language Server Protocol (LSP) for Wolfram Language. This server is implemented in Wolfram Language itself.

Our current goal is to provide the experience as good as the Mathematica FrontEnd with addition power from the editor.

We have provided the client-side code for VS Code here, which is based on some slight modifications of Microsoft's LSP example. If you are using other editors supporting LSP, some adaptation to the client would certainly work too.


  1. Wolfram Mathematica (11.2 or higher1) or Wolfram Engine (12.0 or higher).

  2. Use git to clone this repository.

    git clone
  3. Install the dependent paclets with the correct versions (currently 1.0 or later) from the Wolfram kernel / Mathematica. (This will cost some time for the first time) :

  4. Install the client. Currently, we provide the VS Code extension on Visual Studio Marketplace: Wolfram Language Server For other editors, please refer to the wiki.

  5. You may also want to install GitLink packet in order to check for updates.

Run the Server

Clients can start the server by running the init.wls file from Wolfram Mathematica executables

wolfram -script /path/to/lsp-wl/init.wls [args]
# or
wolframscript -f /path/to/lsp-wl/init.wls [args]

The posible arguments for the server are

  • --help, -h to print help information.
  • --socket=port to assign the port to which the server will connect. (Default: 6536)
  • --tcp-server=port to assign the port at which the server will start. (Default: 6536)
  • --pipe=pipename to specify the pipe name for the server to connect to.
  • --log=level, -l level to specify the logging level of the server. (Levels: error, warn, info, debug. Default: info)
  • --test, -t to run the unit test for the server.

If you want to run the server from Mathematica you can use the following code.

initfile = "/path/to/lsp-wl/init.wls";
args = {};
Block[{$ScriptCommandLine = Prepend[args, initfile], Quit = Function[{}, Throw[Null]]},
    Catch[<< (initfile)]

To use the debugger adapter (current in a very early stage), you need to include debuggerPort in the initializationOptions. And attach the frontend to that port. For VS Code, it is automatically done by the extension.

Language Server Features


You may typeset your package in the same way that Mathematica FrontEnd handles it: a cell begins with two lines of comments, where the first line specifies the style of the cell and the second line names it. So you may get the outline structure of the file.

(* ::Title:: *)
(*Title of the file*)

(* ::Section:: *)
(*Section 1*)



Provide documentations for functions and variables from the System` context, such as String and $Path, the MessageName and the special numerical literals with ^^ or *^.



The completion is shown by the client automatically. Functions and system variables from the System` context that matches the input would be displayed. To enter an unicode character, you may use the leader key \ followed by the alias just like esc in Wolfram FrondEnd. E.g., <esc>a in the FrontEnd is input as \a in the editor and the server will show you the available completions.


Completion Resolve: Further information (such as documentation) would be provided for the items in the list.



Syntax error would be underlined. This feature is powered by CodeParser and CodeInspector paclets, thank you @bostick.


Definition / References / Document Highlight

It is now able to look up the definition and references of a local variable in a scope such as Module or pattern rules.


Code Action

Code action is now able to,

  • Open the documentation of system symbols in Mathematica (Not available for Wolfram Engine).

  • Evaluate the selected code if debugger is running. See Evaluate.

Document Color / Color Presentation

Both Named Colors and Color Models with constant parameters are able to show and modify.
(Experimental, may have performance issues.)



The project is under development, so more features are on the way. Notice that, syntax highlight will not be provided as long as it is excluded from the LSP, but I believe there are already plenty of good Mathematica highlighters available for your editor.

Here is a full list of LSP features.

Debug Adapter Features


Code evaluation can be run from the code action of the selection or code lens below each section title. The results are usually shown in the debug console on the editor side.


Expressions can also be directly input from the debug console.



After evaluation, the symbol values can be retrieved from the editor. This includes the own values of variables and the down/up/sub values of functions defined.


The behavior of the variables mimics the workspace in MATLAB, so all the symbols defined in the debug console as well as evaluated from the file will be recorded. This also includes contexts other than Global` . The editor can also watch on a specific expression after each evaluation if applicable.


Here is a full list of DAP features.


Design Principles

  1. The files are located according to its context name. The init.wls is the entry script that parses the commandline arguments, loads packages and starts the server. This is intended to be different from a paclet, since it is not intended to be normally used inside Mathematica / Wolfram Kernel.

  2. We implemented a stateless (by passing the state around :)) server in WolframLanguageServer`Server` that will parse and handle messages.

  3. DataType` is a simple type system extracted as an independent package in the Matypetica library that supports pattern test on every field of a data structure. The operations on the data objects are designed to be immutable.

  4. WolframLanguageServer`Test`* stores the unit tests for some of the functions which are integrated into GitHub Action.

Todo list

It will be nice if you want to make a contribution to the following topic.

  • Our server-client communication only supports Socket with TCP protocol. We tried to use ZMQ_Stream protocol and SocketListen[] to enable concurrency, but it fails to send responses back to the client.

  • It will be helpful to implement a stdio channel, so that the Mathematica earlier than 11.2 will also be supported, but it is really hard to expose the stdin channel. Hope this will be dicussed in future release of Wolfram kernel.

  • More editor clients are needed. You can feel free to open a repository and create a pull request to add the clients in once your client is released.

  • Thanks to CodeParser and CodeInspector paclets, we are able to parse the code and extract useful information. Please consider to contribute to them as well.

    If you have ideas about how to use these fantastic language tools to help the language server with more features, please send us issues or pull requests.

If you want to help us with this project, feel free to fork and create a pull request. Do not forget to add unit tests if possible.

Donations 💵

If you really like this project, please donate to us! $5 (or equivalently ¥35). A cup of coffee would certainly brighten our day! Your donation would be the motivation for us to move forward, thanks in advance 😄.


[1] SocketListen[] is used for server-client communication, which is introduced since 11.2. ^