CoNLL-U format is a plain-text, ten-column TSV representation where each line corresponds to a token, and blank lines mark sentence boundaries. The ten fields encode a token's ID, FORM, LEMMA, UPOS, XPOS, FEATS, HEAD, DEPREL, DEPS, and MISC, with underscores used for unspecified values. Comment lines beginning with a hash (#) carry metadata such as sent_id and text.
Glossary
CoNLL-U Format

What is CoNLL-U Format?
The CoNLL-U format is the standard tab-separated values (TSV) file format defined by the Universal Dependencies project for representing annotated linguistic data, including tokenization, lemmatization, part-of-speech tags, morphological features, and typed dependency relations.
The format serves as the primary interchange standard for Universal Dependencies (UD) treebanks, enabling interoperability between parsers like the Deep Biaffine Parser and Stanza. Its strict columnar structure allows direct evaluation of Labeled Attachment Score (LAS) and facilitates the representation of both basic and enhanced dependencies through the DEPS column, which captures additional semantic relations beyond surface syntax.
Key Features of the CoNLL-U Format
The CoNLL-U format is the tab-separated values (TSV) standard for representing annotated linguistic data in the Universal Dependencies project. It encodes tokenization, morphology, syntax, and semantics in a structured, machine-readable format.
10-Column Tabular Structure
Every token occupies a single line with 10 tab-separated fields. Empty lines mark sentence boundaries, and lines starting with # store metadata comments. The rigid column structure ensures consistent parsing across all UD treebanks.
- ID: Token index (integer) or range for multiword tokens (e.g.,
1-2) - FORM: The surface form as it appears in the text
- LEMMA: Base or dictionary form of the word
- UPOS: Universal part-of-speech tag (e.g.,
NOUN,VERB) - XPOS: Language-specific POS tag (optional,
_if absent) - FEATS: Morphological features as
Key=Valuepairs separated by| - HEAD: ID of the syntactic head (
0for root) - DEPREL: Universal dependency relation label (e.g.,
nsubj,obj) - DEPS: Enhanced dependency graph as
HEAD:RELpairs - MISC: Any other annotation as
Key=Valuepairs
Multiword Token Representation
The format handles syntactic words that span multiple orthographic tokens (e.g., Spanish 'dámelo' = 'da' + 'me' + 'lo'). A multiword token line uses a range ID (e.g., 1-3) followed by individual token lines with dashed IDs (1-1, 1-2, 1-3). This preserves both the original text segmentation and the syntactic analysis.
- Range ID line contains the full surface form
- Sub-token lines carry the morphological and syntactic annotations
- Enables accurate alignment between raw text and linguistic analysis
Morphological Feature Encoding
The FEATS column uses a structured Key=Value notation to encode inflectional and derivational morphology. Multiple features are separated by the pipe character (|), and the underscore (_) indicates no morphological annotation is available.
- Example:
Gender=Fem|Number=Sing|Case=Acc - Universal features defined by UD include Animacy, Aspect, Case, Definite, Degree, and 20+ others
- Enables cross-linguistic queries for specific grammatical phenomena
- Language-specific extensions can be added as needed
Enhanced Dependency Graphs
The DEPS column extends basic syntax with additional arcs capturing implicit predicates, shared arguments, and control relationships. Each entry is a HEAD:REL pair, with multiple pairs separated by |. This bridges surface syntax and deeper semantic interpretation.
- Example:
3:obl:agent|5:nsubj:xsubj - Captures null elements and elided material
- Supports downstream tasks like semantic role labeling and AMR parsing
- The
_placeholder indicates no enhanced annotation is present
Sentence-Level Metadata Comments
Lines beginning with # store structured metadata as key-value pairs. Standard comment keys include sent_id for unique sentence identifiers and text for the raw sentence string. Transliterations, translations, and corpus-specific annotations are also stored here.
# sent_id = weblog-blogspot.com_norvig_20060911092800_ENG_20060911_092800-0001# text = What if Google Morphed Into GoogleOS?# translit = ...for scripts requiring romanization- Comments precede the token lines they describe
Empty Nodes for Ellipsis
The format supports empty syntactic nodes to represent elided or gapped material in coordinated structures. Empty nodes use an ID with a decimal (e.g., 5.1) and carry the _ placeholder in the FORM and LEMMA columns while retaining full morphological and dependency annotations.
- Example: 'Mary bought a book and John a newspaper' — an empty node represents the elided verb 'bought' in the second clause
- Enables complete syntactic representation of elliptical constructions
- Critical for languages with frequent argument dropping
Frequently Asked Questions
Clear answers to common questions about the CoNLL-U format, the standard tab-separated representation for Universal Dependencies annotation.
The CoNLL-U format is the standard tab-separated values (TSV) file format used by the Universal Dependencies (UD) project to represent annotated linguistic data. It encodes tokenization, lemmatization, part-of-speech tags, morphological features, and dependency syntax in a structured, human-readable plain-text file. Each sentence is represented as a block of lines separated by blank lines, where each token occupies a single line with 10 tab-separated fields. Comment lines begin with a hash (#). The format is designed to be both machine-parseable and manually editable, serving as the primary interchange format for multilingual treebanks and parser training pipelines.
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Related Terms
The CoNLL-U format is the standard interchange format for the Universal Dependencies project. Understanding its structure requires familiarity with the linguistic annotations it encodes and the tools that process it.
Dependency Parsing
The syntactic analysis task whose output is stored in CoNLL-U files. A dependency parser analyzes the grammatical structure of a sentence to determine head-dependent relationships between words.
- Constructs a directed graph where nodes are tokens and edges are typed dependencies
- The HEAD field in CoNLL-U (column 7) stores the index of the syntactic governor
- The DEPREL field (column 8) stores the specific grammatical relation
Part-of-Speech Tagging
The foundational NLP task that populates the UPOS and XPOS fields (columns 4 and 5) in CoNLL-U. Taggers assign grammatical categories to each token.
- UPOS: Universal part-of-speech tag from the UD inventory
- XPOS: Language-specific part-of-speech tag (may be empty with an underscore)
- Serves as a critical input feature for downstream dependency parsing and entity recognition
Morphological Features
The FEATS field (column 6) in CoNLL-U encodes inflectional properties of a token using a key-value pair notation. This structured representation captures grammatical categories like tense, number, case, and gender.
- Format:
Feature=Valuepairs separated by pipes (e.g.,Number=Sing|Case=Nom) - Enables precise linguistic analysis across morphologically rich languages
- An underscore (
_) indicates the feature is not applicable or unspecified
Enhanced Dependencies
An extended representation in Universal Dependencies that augments the basic syntactic tree in the DEPS field (column 9). Enhanced dependencies add extra arcs to capture implicit predicates, shared arguments, and control relationships.
- Represents semantic roles beyond surface syntax
- Critical for tasks like semantic role labeling and coreference resolution
- Stored as a list of head-relation pairs separated by pipes in CoNLL-U
Tokenization and Multiword Tokens
CoNLL-U handles complex tokenization through its multiword token lines (lines 1-2) and empty node lines (lines 3-4). This structure represents cases where syntactic words do not align with orthographic words.
- Multiword tokens: A single orthographic token spanning multiple syntactic words (e.g., French 'du' = 'de' + 'le')
- Empty nodes: Syntactic words with no surface realization (e.g., elided verbs in gapping constructions)
- The ID field uses dash notation (e.g.,
1-2) for multiword spans and decimal notation (e.g.,2.1) for empty nodes

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us