Universal Dependencies Parser & Visualizer
Explore and compare grammatical analyses of English and German sentences.
Start parsing →
Enter a sentence, choose a parser, and click Parse. Or select an example to run it immediately.
Inspect the tree, then open Annotations or CoNLL-U for the underlying data.
Select Include morphology (FEATS) before parsing if you need morphological features.
Explore the analysis
Hover over words and POS tags to reveal syntactic heads.
Open Help below the tree for UD definitions, or click a word to search for its exact form in Grew.
Compare parsers
Use Compare to inspect two trees stacked vertically and a table of differences.
Disagreement can reflect ambiguity, annotation conventions, or parser errors.
Save and reuse
Download each tree as SVG or PNG using its toolbar.
Use Annotate & Export for batch annotation, CoNLL-U files, and tree exports.
Choose a treebank
The Treebank Guide describes the training corpora and their conventions.
Parser names identify both UDPipe and the training treebank.
A dependency tree is an automatic analysis that can contain errors and may not be the only possible interpretation.
"""
CONFORMANCE_DOC_MD = """
**Parser and model identification**: Parser names in this application show
UDPipe and the model ID used in the raw CoNLL-U output, including the training
treebank and UD release (for example, `UDPipe · english-ewt-ud-2.17-251125`).
**Training size** is the number of syntactic words in the training split, not
the size of the whole corpus. Smaller training sets provide fewer examples
and can increase errors on uncommon constructions; size alone does not
predict correctness on your sentence.
**Quality and conformance** concern how consistently annotations follow the
universal and language-specific UD guidelines. Automated validation checks
format and many constraints, but cannot verify every linguistic decision.
Manual review and conversion history are useful evidence, not a compliance
score. These sources do not establish a comparable conformance ranking.
In **Compare**, inspect disagreements against the sentence and the
[UD syntax guidelines](https://universaldependencies.org/u/overview/syntax.html)
([German](https://universaldependencies.org/de/),
[English](https://universaldependencies.org/en/)).
The table describes annotation methods, rather than assigning quality labels.
Sizes refer to **UD 2.17**, the training release of the app's configured models.
Treebank names link to their documentation; training counts link to the
release-specific statistics.
| Treebank | Training words | Annotation quality / conformance evidence | Why included |
| :--- | ---: | :--- | :--- |
""" + "\n".join(
f"| [{row['Language']}-{row['Treebank']}]({row['SourceURL']}) "
f"| [{row['TrainingWords']}]({row['StatsURL']}) "
f"| {row['Conformance']} | {row['BestFor']} |"
for row in TREEBANK_CATALOG
) + """
[UD validation: what is checked](https://universaldependencies.org/contributing/validation.html)
· [UDPipe model training and evaluation](https://ufal.mff.cuni.cz/udpipe/2/models)
"""
def run_single_or_compare(
lang: str,
sentence: str,
primary_model_name: str,
compare_mode: bool,
secondary_model_name: str,
include_morphology: bool = False,
cache: Optional[BoundedParseCache] = None
):
"""
Executes parsing for one sentence.
If compare_mode is active, queries both models and diffs POS tags + dependencies.
"""
sentence = sentence.strip()
if not sentence:
return (
"Please enter a sentence to parse.
",
pd.DataFrame(),
"",
"",
gr.update(visible=False),
pd.DataFrame(),
)
# Restrict strictly to one sentence (first line / sentence split)
if "\n" in sentence:
sentence = sentence.split("\n")[0].strip()
models_dict = AVAILABLE_MODELS.get(lang, AVAILABLE_MODELS["English"])
model_id_a = models_dict.get(primary_model_name, list(models_dict.values())[0])
strip_morphology = not include_morphology
res_a = client.parse_sentence(sentence, model_id_a, strip_morphology=strip_morphology, cache=cache)
error_a = res_a.get("error")
if not error_a and not extract_tree_signature(res_a.get("conllu", "")):
error_a = "The primary model returned no usable parse tokens."
if error_a:
err_msg = f"Input changed—parse again to update the analysis.
',
)
def on_settings_input():
return 'Settings changed—parse again to update the analysis.
'
def on_example_input(new_ex_idx, current_lang, current_primary, current_secondary, morph, cache):
if new_ex_idx is None:
return tuple(gr.update() for _ in range(14))
ex = CURATED_EXAMPLES[int(new_ex_idx)]
ex_lang = ex["language"]
if ex_lang != current_lang:
models = list(AVAILABLE_MODELS[ex_lang])
primary_name = models[0]
secondary_name = models[min(1, len(models)-1)]
model_updates = (
gr.update(choices=models, value=primary_name),
gr.update(choices=models, value=secondary_name),
)
else:
primary_name = current_primary
secondary_name = current_secondary
model_updates = (gr.update(), gr.update())
vis_html, table_df, raw_conllu, status_html, diff_group, diff_df = run_single_or_compare(
lang=ex_lang,
sentence=ex["text"],
primary_model_name=primary_name,
compare_mode=compare,
secondary_model_name=secondary_name,
include_morphology=morph,
cache=cache,
)
return (
ex_lang,
*model_updates,
_describe_example(ex),
ex["text"],
int(new_ex_idx),
gr.update(value=int(new_ex_idx) if ex_lang == "German" else None),
gr.update(value=int(new_ex_idx) if ex_lang == "English" else None),
vis_html,
table_df,
raw_conllu,
status_html,
diff_group,
diff_df,
)
language.input(
on_language_input,
[language],
[primary, secondary],
api_name=False,
)
sentence.input(
on_sentence_change,
None,
[selected_example, german_examples, english_examples, phenomenon, status],
api_name=False,
)
# An instance, not the class: Gradio deep-copies it per session, and a
# callable default would register a public load endpoint.
# An instance, not the class: Gradio deep-copies State per session, and a
# callable default would publish a load endpoint in the API.
session_cache = gr.State(BoundedParseCache())
for example_dropdown in (german_examples, english_examples):
example_dropdown.input(
on_example_input,
[example_dropdown, language, primary, secondary, include_morphology, session_cache],
[language, primary, secondary, phenomenon, sentence, selected_example,
german_examples, english_examples, visualization, table, raw, status, differences, diff_table],
api_name=False,
)
for control in (language, primary, secondary, include_morphology):
control.input(on_settings_input, None, [status], api_name=False)
inputs = [language, sentence, primary, gr.State(compare), secondary, include_morphology, session_cache]
outputs = [visualization, table, raw, status, differences, diff_table]
result_identity = gr.State(None)
def run_with_identity(*args):
return (*run_single_or_compare(*args), tuple(args[:6]))
def check_result_freshness(lang, text, model, mode, second, morph, identity, message):
if identity != (lang, text, model, mode, second, morph):
return 'Input changed—parse again to update the analysis.
'
return message
for event in (submit.click, sentence.submit):
event(run_with_identity, inputs, outputs + [result_identity], api_name=False).then(
check_result_freshness, inputs[:6] + [result_identity, status], [status], api_name=False
)
share_btn.click(
fn=None,
inputs=[],
outputs=[],
js="""() => {
if (window.updateShareUrl) window.updateShareUrl();
const url = window.location.href;
navigator.clipboard.writeText(url).then(() => {
const btn = document.activeElement;
if (btn) {
const oldText = btn.textContent;
btn.textContent = '✓ Copied!';
setTimeout(() => { btn.textContent = oldText; }, 2000);
}
}).catch(() => {
prompt('Copy shareable link:', url);
});
return [];
}""",
api_name=False,
)
return {
"sentence": sentence,
"language": language,
"primary": primary,
"secondary": secondary,
"include_morphology": include_morphology,
"session_cache": session_cache,
"visualization": visualization,
"table": table,
"raw": raw,
"status": status,
"differences": differences,
"diff_table": diff_table,
}
EXPORT_FORMATS = ["CoNLL-U", "SVG", "PNG"]
API_MD = """
Each button below is also an API endpoint. From Python:
```python
from gradio_client import Client
client = Client("simon-clmtd/universal-dependencies-visualizer")
conllu, files = client.predict(
"Bestimmt hat sie die Lösung bestimmt.", "german-hdt-ud-2.17-251125",
False, ["CoNLL-U", "SVG", "PNG"], api_name="/annotate")
files = client.predict(conllu, ["SVG", "PNG"], api_name="/render")
client.predict(api_name="/models")
```
- `/annotate(text, model, include_morphology, formats)`: parses each non-empty line
(at most 50) and returns the CoNLL-U text and the requested files.
- `/render(conllu, formats)`: draws your own or corrected CoNLL-U as SVG and PNG,
exactly like the tree download buttons.
- `/models()`: lists the model IDs.
Images take a few seconds per request because a browser draws each tree.
"""
def _write_exports(conllu: str, formats: List[str], stem: str = "ud-analysis") -> List[str]:
"""Writes the requested CoNLL-U/SVG/PNG files to a fresh temporary directory."""
folder = tempfile.mkdtemp(prefix="ud-export-")
paths = []
if "CoNLL-U" in formats:
path = os.path.join(folder, stem + ".conllu")
with open(path, "w", encoding="utf-8") as handle:
handle.write(conllu)
paths.append(path)
image_formats = [name for name in ("SVG", "PNG") if name in formats]
if image_formats:
try:
images = export_tree_images(conllu)
except TreeExportError as error:
raise gr.Error(str(error))
for name in image_formats:
path = os.path.join(folder, f"{stem}.{name.lower()}")
with open(path, "wb") as handle:
handle.write(images[name.lower()])
paths.append(path)
return paths
def annotate_and_export(text: str, model: str, include_morphology: bool, formats: List[str]):
"""Parses each line of text with one UDPipe model and exports the analysis."""
try:
result = annotate_text(text, model, include_morphology=include_morphology, client=client)
except (ValueError, RuntimeError) as error:
raise gr.Error(str(error))
return result["conllu"], _write_exports(result["conllu"], formats or [])
def render_conllu(conllu: str, formats: List[str]):
"""Draws supplied CoNLL-U as SVG/PNG (and returns it as a file if requested)."""
if not conllu or not conllu.strip():
raise gr.Error("Paste CoNLL-U to render.")
return _write_exports(conllu if conllu.endswith("\n") else conllu + "\n", formats or [])
def list_models() -> List[str]:
"""Returns the selectable UDPipe model IDs."""
return model_ids()
def build_exporter():
"""Batch annotation and file export; its events are the public API."""
gr.Markdown(
"Annotate one sentence per line, or paste CoNLL-U (for example a corrected "
"analysis) and render it. Download the CoNLL-U, SVG, and PNG files below."
)
with gr.Row():
with gr.Column():
text = gr.Textbox(label="Sentences (one per line)", lines=6,
value="Bestimmt hat sie die Lösung bestimmt.")
with gr.Row():
model = gr.Dropdown(label="UDPipe model", choices=model_ids(),
value="german-hdt-ud-2.17-251125", scale=2)
include_morphology = gr.Checkbox(label="Include morphology (FEATS)", value=False, scale=1)
formats = gr.CheckboxGroup(EXPORT_FORMATS, value=EXPORT_FORMATS, label="Files")
annotate = gr.Button("Annotate", variant="primary")
with gr.Column():
conllu = gr.Code(label="CoNLL-U (editable)", language="markdown", interactive=True, lines=12)
render_formats = gr.CheckboxGroup(EXPORT_FORMATS, value=["SVG", "PNG"], label="Files")
render = gr.Button("Render CoNLL-U")
files = gr.File(label="Downloads", file_count="multiple", interactive=False)
with gr.Accordion("Use as an API", open=False):
gr.Markdown(API_MD)
annotate.click(annotate_and_export, [text, model, include_morphology, formats], [conllu, files],
api_name="annotate", concurrency_limit=2)
render.click(render_conllu, [conllu, render_formats], [files],
api_name="render", concurrency_limit=2)
gr.api(list_models, api_name="models")
_blocks_init_params = inspect.signature(gr.Blocks.__init__).parameters
_blocks_kwargs = {"title": "Universal Dependencies Visualizer"}
_launch_kwargs = {}
if "css" in _blocks_init_params:
_blocks_kwargs.update(theme=gr.themes.Base(primary_hue="slate", neutral_hue="slate"), css=CUSTOM_CSS, head=CUSTOM_HEAD)
else:
_launch_kwargs.update(theme=gr.themes.Base(primary_hue="slate", neutral_hue="slate"), css=CUSTOM_CSS, head=CUSTOM_HEAD)
with gr.Blocks(**_blocks_kwargs) as demo:
if ENABLE_SCREENCAST and ScreenRecorder is not None:
with gr.Accordion("Record screencast (experimental)", open=False, elem_id="screencast-panel"):
gr.Markdown(
"Record your exploration with microphone narration. Choose this browser "
"tab or a window in the screen-sharing dialog, then explore Parse or Compare. "
"Stop recording, then click Download WebM. The video is saved directly "
"from your browser."
)
screen_recorder = ScreenRecorder(
label="Screencast", audio_enabled=True, webcam_overlay=False,
recording_format="webm", max_duration=600,
)
download_recording = gr.Button("Download WebM", size="sm")
# 0.0.1 does not bridge completion events to Gradio or upload FileData.
# Save its browser-local preview instead of relying on that broken path.
download_recording.click(
fn=None, inputs=[], outputs=[], api_name=False, js="""() => {
const video = Array.from(document.querySelectorAll('#screencast-panel .recording-preview video'))
.find(video => video.src.startsWith('blob:'));
if (!video) {
alert('Stop a recording before downloading it.');
return [];
}
const link = document.createElement('a');
link.href = video.src;
link.download = 'ud-exploration.webm';
document.body.appendChild(link);
link.click();
link.remove();
return [];
}"""
)
with gr.Tabs(selected="tab_overview", elem_id="app-tabs") as tabs:
with gr.Tab("About", id="tab_overview"):
gr.HTML(OVERVIEW_MD)
with gr.Tab("Parse", id="tab_parser"):
parse_ctrls = build_parser()
with gr.Tab("Compare", id="tab_compare"):
compare_ctrls = build_parser(compare=True)
with gr.Tab("Annotate & Export", id="tab_export"):
build_exporter()
with gr.Tab("Treebank Guide", id="tab_guide"):
with gr.Accordion("Training size, quality and conformance", open=False):
# Remove duplicate heading since accordion provides the label
doc_lines = CONFORMANCE_DOC_MD.strip().splitlines()
if doc_lines and doc_lines[0].startswith("### "):
conformance_content = "\n".join(doc_lines[1:]).strip()
else:
conformance_content = CONFORMANCE_DOC_MD
gr.Markdown(conformance_content)
with gr.Accordion("Explore corpora with Grew", open=False):
gr.Markdown(
"Go beyond a single parse: search annotated corpus sentences, "
"look for recurring patterns, and find counterexamples to your expectations. "
"Use Grew's built-in dependency-relation search examples to get started. "
"Inspect several matches and explain what their trees have in common.\n\n"
"| Treebank on Grew | Try exploring |\n"
"| --- | --- |\n"
+ "\n".join(
f"| [{row['Language']}-{row['Treebank']}]({row['GrewURL']}) "
f"| {row['ExplorePrompt']} |"
for row in TREEBANK_CATALOG
)
)
with gr.Accordion("Full treebank catalog", open=False):
catalog_rows = [
[
row["Language"],
row["Treebank"],
row["Words"],
row["TrainingWords"],
row["Sentences"],
row["Genres"],
row["BestFor"],
]
for row in TREEBANK_CATALOG
]
catalog_df = gr.DataFrame(
value=catalog_rows,
headers=["Language", "Treebank", "Total words (UD 2.17)", "Training words", "Sentences", "Text sources", "Role in this app"],
interactive=False,
)
gr.HTML(
f'