home edit page issue tracker
This page pertains to UD version 2.

Universal Dependencies tools

This page collects links to and minimal instructions for tools related to Universal Dependencies.

If you would like to have your tool added to this page, please submit a pull request for the corresponding Github page. You may also want to announce your tool in the UD mailing list.

Listing

UD-maintained tools

The Universal Dependencies project maintains a number of core tools for working with UD data. These tools are available from https://github.com/universaldependencies/tools; see that repository directly for the list of scripts and their documentation (either in the README.md file or directly in the source code).

Among others, there are scripts for

Third-party tools

Annotation Tools

brat rapid annotation tool

brat is a browser-based tool for text annotation. The brat visualization component is used in the UD documentation system and the tool comes with a custom configuration allowing it to be used for UD annotation .

WebAnno

WebAnno is a general purpose web-based annotation tool for a wide range of linguistic annotations including various layers of morphological, syntactical, and semantic annotations. Additionaly, custom annotation layers can be defined, allowing WebAnno to be used also for non-linguistic annotation tasks. WebAnno targets annotation teams in which all annotators work independently from each other. The tool includes facilities for curating/merging the annotations from multiple annotators, calculating inter-annotator agreement, and project management. Additional features include a correction and automation mode as well as decent support for right-to-left languages.

Since version 3.0.0, WebAnno supports importing and exporting data in the CoNLL-U format. If the data contains sub-token annotations, then the text is obtained from the subtokens and the surface text is added as annotations. To control which column dependencies end up in, the flavor feature of the built-in dependency layer needs to be used. If the feature is set to enchanced, then it goes to the enhanced dependencies column, otherwise to the basic dependencies column. It is currently up to the annotator to ensure that the dependency trees are well-formed and representable in CoNLL-U, otherwise export to CoNLL-U may fail.

WebAnno 3.0.0 does not support the CoNLL-U 2.0 format at this time.

DgAnnotator

DgAnnotator (Dependency Graph Annotator) is a visual tool for annotating text with syntactic information, in particular creating a dependency tree. The tool reads and produces annotated documents in both XML, CoNLL-X and CoNLL-U tab separated format. Additional features: shows the differences, highlighted in red, between two different dependency trees on the same corpus; generates PNG snapshots of trees; performs PoS tagging and parsing connecting to a network service; panning and zooming.

UD Annotatrix

UD Annotatrix is a browser-based offline + online annotation tool for dependency trees aimed at the UD community. It supports a number of features, including validation and two-level tokenisation.

Tred

Tred (Tree Editor) is a graph visualization and manipulation program written in Perl. It was the main tool used to annotate the Prague treebanks. It supports macros (in Perl) to automate frequently repeated operations. There are extensions for various annotation layers such as MWEs or coreference. Since January 2018, there is also an extension for CoNLL-U files (including multi-word tokens and enhanced dependencies).

ArboratorGrew

** ArboratorGrew ** is a comprehensive, open-source, web-based tool designed for dependency treebank annotation. It supports a user-friendly drag-and-drop interface, along with social login features. Its project management capabilities allow for multiple users to collaborate simultaneously and compare trees for efficient and collaborative annotation efforts. The tool is equipped with a teacher mode and class-sourcing capabilities, making it suitable for both research and educational settings. It incorporates search and replace functions based on the Grew formalism, and an integrated neural bi-affine parser for quick bootstrapping. Additionally, it supports various annotation schemes, including UD, SUD, and custom-made schemes. https://arboratorgrew.elizia.net

LightTag

LightTag is a general purpose text annotation tool which supports span annotations, classification as well as phrase-based and dependency-based relations. LightTag allows a drag-and-drop interface allowing annotators to easily drag individual tokens or sub-trees to construct their parse.

LightTag’s Universal Dependency Tool allows the user to paste an existing CoNLL-U file, visualize and correct the annotations. LightTag’s full featured text annotation tool supports managing teams of annotators, is fully hosted and available free for academic use.

TrUDucer

TrUDucer is a tree rewriting system based on tree transducers. It transforms dependency trees in a top-down fashion, making sure that each resulting structure will still be a valid tree. Rules are written in a domain-specific language; for cases where the DSL is not powerfui enough, rules can be augmented by writing special-case predicates in groovy. It contains an interactive transformation viewer to debug rule applications and a search tool to find trees where a specific rule could be applicable. As of 2018, TrUDucer is under active development at Hamburg University.

An example rule file converting (large parts of) the Hamburg Dependency Treebank to UD is provided with TrUDucer. The Univerity of Zurich provides a rule file to convert the TIGER treebank to UD using TrUDucer.

ConlluEditor

ConlluEditor is a tool which facilitates the editing of syntactic relations and morphological features of files in CoNLL-U format. It uses a Java-based server and a HTML/CSS/Javascript based front-end. The editor loads the CoNLL-U file and saves every change to disk (and performs a git commit if the file is under git version control). It serves also as a graphical front-end to dependecy parsers (like the UDPipe-Server).

The editor provides the following functionalities:

Palmyra

Palmyra Palmyra is a configurable platform independent graphical dependency tree visualization and editing software. Palmyra has been designed with morphologically rich languages in mind, and thus has a number of features to support the complexities of these languages. These include supporting easy change of morphological tokenization through edits, additions, deletions and splits/merges of words. It can also be used to annotate a multitude of linguistic features. Palmyra uses an intuitive drag-and-drop metaphor for editing tree structures. Palmyra can be configured to be used with any dependency representation. A UD configuration file is provided in its github repo.

BoAT

BoAT (Boğaziçi University Annotation Tool) is a collaborative grammatical annotation tool. It supports annotating CoNLL-U files. Some of its features are autocompletion, UD validation, visualization of dependency graphs and advanced search. It’s capable of serving multiple treebanks and annotators.

ConlluVisualiser

ConlluVisualiser is a tree visualizer and editor inspired by TrEd but developed directly for CoNLL-U.

Editor modes

Emacs

conllu-mode is an Emacs mode for editing CoNLL-U files (syntax highlighting, column alignment, shortcuts for navigation, etc).

Atom

This package provides syntax highlighting for CoNLL-U files in Atom.

Sublime Text

Syntax highlighting for CoNLL-U files on Sublime Text.

Vim

Basic syntax highlighting and automatic syntax checking (through ALE or syntastic) for CONLL-U files.

Processing tools

CL-CoNLLU

A Common Lisp library for various CoNLL-U-related operations. We have already functions for reading, writing, making queries, construct visualizations of sentences, compare trees etc.

hs-conllu

A Haskel library for various CoNLL-U-related operations. So far, the basic functions for reading and writing. The plan is to port all other functions from the CL-CONLLU

DepEdit

DepEdit is a simple, open source, configurable tool for manipulating dependency trees, written in Python (2/3). It can be run standalone from the commandline or imported as a module, and it is available on PyPI (pip install depedit). Main features:

DKPro Core CoNLL-U reader/writer

DKPro Core is collection of software components for natural language processing (NLP) based on the Apache UIMA framework. DKPro Core can be used to build workflows that automatically process text using a wide range of NLP tools from third parties that are all interoperable (Stanford CoreNLP, Apache OpenNLP, ClearNLP, mate-tools, etc etc.). It also supports a range of different data formats and can be used to convert between the different supported formats.

Starting with version 1.9.0, DKPro Core supports reading and writing the CoNLL-U format.

The latest CoNLL-U 2.0 format is not yet supported.

pyconll

pyconll is a minimal, entirely python, library for parsing and writing CoNLL-U files. pyconll allows users to easily parse out info from CoNLL-U corpora, or to perform and write corpus transformations. pyconll aims to provide a low-level interface over the CoNLL-U annotation scheme that is easy to understand and works with the current standard. Further, since it is written in python, there is no need to learn a new DSL or tool.

conllu

conllu is a python library that parses a CoNLL-U string into a nested python dictionary.

It’s easily installable with “pip install conllu”, has good documentation and a big test suite that ensures working code, and is very customizable, which means it also works for custom formats that are similar to CoNLL-U. It works with both Python 2 and Python 3.

Treex

Treex is a modular natural language processing framework. It reads and writes data in many formats (including CoNLL-U) and provides API for dependency tree manipulation. Many treebanks have been harmonized in HamleDT and then converted to UD using Treex.

UDPipe

UDPipe is a trainable pipeline for tokenization, tagging, lemmatization and parsing of CoNLL-U files. UDPipe is language-agnostic and can be trained given only annotated data in CoNLL-U format. (Nevertheless, to train the tokenizer, either the SpaceAfter feature must be present, or at least some plain text must be available; also morphological analyzer and lemmatizer can be improved if morphological dictionary is provided.) Trained models are provided for nearly all UD treebanks. UDPipe is available as a binary, as a library for C++, Python, Perl, Java, C#, and as a web service.

UDAPI

UDon2

UDon2 is a library providing the possibility to manipulate Universal Dependencies trees. UDon2 is written in C++ with Python bindings via Boost.Python and is geared towards downstream NLP applications that require plenty of manipulations with individual dependency trees, including transforming UD trees to trees without labels on edges (as defined by Croce et. al. (2011)) to be used in ML algorithms. The package can perform these manipulations, as well as reading and writing to CoNLL-U files, efficiently (see benchmarks. UDon2 lacks command-line interface and thus is not recommended by the authors for working with treebanks.

ACoLi CoNLL Libraries

The ACoLi CoNLL Libraries provide advanced tools for processing, creating and manipulating CoNLL/TSV formats, including CoNLL-U and CoNLL-U Plus. In particular, this includes merging, transforming and querying CoNLL and other TSV (CSV) data:

None of these operations are limited to CoNLL-U, but CoNLL-U and CoNLL-U Plus are supported as input and output formats.

Visualization tools

Deptreeviz

Deptreeviz is a SVG visualization and editing component. It can be used as a swing component or to create SVGs from the command line. It supports drag-and-drop modifications of trees, including dependency label and selecting the correct lexical items. For the editing facilities, a matching backend needs to be programmed. Deptreeviz is used to convert the Hamburg Dependency Treebank to UD.

CoNLL-U viewer

A simple browser-based (JavaScript, i.e. client side) viewer of your CoNLL-U files. Open your file, see the tree, go to the next tree. Click on a node to see all its attributes. Save the tree as an SVG graphics if needed. There is no way of jumping directly to a tree, neither by tree number, nor by searching attribute values.

CoNLL-U viewer at rug.nl

TüNDRA

TüNDRA (Tübingen aNnotated Data Retrieval Application) is a web application for searching in treebanks using a lightweight query language inspired by the widely used TIGERSearch application. It offers corpus linguists an interface for using corpora with complex annotation and syntactic links. Most of the treebanks available in TüNDRA are free and publicly available. To access all the treebanks a user has to have an account at a European institution of higher education (i.e. be a student or an employee). Any user may upload a CoNLL-U or a TCF file to browse/search it with the tool. A visualization is interactive (scaling, zooming, panning) and can be saved in multiple formats (e.g. to be later used for a publication). TüNDRA is a part of CLARIN-D project and is funded by the German Federal Ministry for Education and Research (BMBF).

UDeasy

Udeasy is an application written in Python 3 whose main goal is to allow the user to easily query a treebank and extract patterns from a treebank in CoNLL-U format. To do this, users are prompted in a series of dialogs to enter relevant information about syntactic nodes, their properties, relationship, and positions. The functions to extract the occurrences from a treebank rely on the udapi Python package. The graphic interface is built using the GUI toolkit wxPython. Due to its ease of use it is a useful tool for the community of linguists who want to use a data-driven approach and for the students who approach dependency treebanks without almost any experience with queries.