LinkML-Scala: a Robust, Fast, and Portable Implementation of LinkML

Source: arXiv:2607.22335 · Published 2026-07-24 · By Piotr Sowinski, Kacper Grzymkowski, Andriy Plokhotnyuk

TL;DR

LinkML-Scala addresses the performance, portability, and consistency limitations of the original Python implementation of LinkML, a unified modeling framework that generates data schema across JSON, RDF, CSV, SQL, and more. By reimplementing LinkML in Scala 3, the authors created a cross-platform, fast, and robust system that runs on the JVM, in browsers (via Scala.js), and as native binaries (GraalVM). This new implementation preserves LinkML's full metamodel and provides schema derivation and generators for popular schema languages such as JSON Schema, SHACL, RDFS, and Table Schema. LinkML-Scala is distributed as a CLI tool, in-browser playground, GitHub Action, and libraries for JVM and JavaScript ecosystems. Benchmark evaluations over 11 diverse LinkML schemas show that LinkML-Scala outperforms the Python package by 22.9x–38.5x on average across cold and warm scenarios, enabling usage scenarios previously inaccessible due to performance constraints, such as real-time schema editing and enterprise server deployment. The implementation also improves error handling and behavior consistency across output formats, enhancing developer experience and reliability.

Key findings

• LinkML-Scala outperforms the Python implementation by geometric mean speedups of 36.5x (JSON Schema) and 22.9x (SHACL) in cold-start scenarios.
• In warm (persistent) scenarios, LinkML-Scala achieves average speedups of 38.5x (JSON Schema) and 26.8x (SHACL).
• Speedup varies widely by schema: warm JSON Schema benchmarks ranged from 1.7x to 187x speedup depending on dataset.
• Start-up times for the native Scala CLI are very low (~2.5ms), which benefits short-running scripted workflows.
• LinkML-Scala supports generation of JSON Schema, SHACL, RDFS, Scala, Table Schema, and LinkML formats, with consistent error handling.
• The implementation runs in environments previously not supported by Python LinkML, including browsers (JavaScript transpilation) and native binaries.
• LinkML-Scala includes a comprehensive model catalog ('model zoo') to verify semantic consistency across generators using valid/invalid instance tests.

Threat model

n/a — the paper addresses performance, portability, and semantic consistency of a schema generation tool rather than adversarial threat scenarios. The adversary is not defined since the focus is on enabling improved developer experience and broader deployment contexts.

Methodology — deep read

The authors began by identifying limitations of the original LinkML Python implementation: poor runtime performance, lack of portability outside Python, and inconsistent generator behavior leading to unreliable outputs across formats. Their threat model focuses on use cases that require high responsiveness and cross-platform availability rather than adversarial security scenarios.

They collected a benchmark dataset of 11 diverse, publicly available LinkML schemas from the LinkML Schema Registry and GitHub, covering domains such as cybersecurity, biology, finance, and energy. After minor manual repairs for validity, these schemas allow evaluation across varied real-world modeling use cases. Dataset sizes ranged from ~40KiB to nearly 3 MiB, with class counts from 9 to 4366 and attributes from 110 to 34172.

The LinkML-Scala implementation is coded in Scala 3 to leverage its rich type system, metaprogramming, and cross-compilation capabilities (Scala.js for JavaScript, GraalVM native images). Core components include a runtime with custom codec generators using scala-yaml parser and custom macros to handle LinkML's YAML features that standard serializers cannot. The architecture modularizes metamodel parsing, schema view for validation and utilities, and generators with distinct strategies (direct string generation or AST-based). Generators currently support JSON Schema, SHACL, RDFS, Table Schema, and Scala code.

For training, the system is not ML-based but rigorously tested with a curated model zoo providing valid and invalid instances for each example schema to verify correctness and consistency across output formats and validators (e.g., SHACL and JSON Schema validators). This approach avoids brittle structural assertions and instead enforces expected behaviors.

Evaluation includes two benchmark scenarios: cold start (end-to-end CLI execution to emulate CI and authoring workflows) and warm (generator loops inside the runtime to emulate persistent server applications). They use hyperfine for cold benchmarks and Java Microbenchmark Harness plus Python scripts for warm benchmarks, running on a high-end Linux machine with Intel Core Ultra 9 CPU and 64GB DDR5.

Results are reported as throughput (generations per second) and speedup ratios comparing LinkML-Scala to Python LinkML. Extensive benchmarking on all 11 schemas showed that LinkML-Scala is faster in every scenario with geometric mean speedups around 22x–38x.

Reproducibility is supported by open-sourcing the LinkML-Scala code, benchmark schemas, and tooling on GitHub, with CLI packages available as native binaries and libraries on Maven Central and npm. An in-browser playground exposes the system via JavaScript for easy experimentation. However, some edge-case performance variances and coverage gaps remain as future work.

Technical innovations

• Use of Scala 3's type system and metaprogramming to generate optimized, reflection-free codecs enabling efficient YAML parsing of complex LinkML schemas.
• Cross-platform portability achieved via Scala.js (JavaScript compilation) and GraalVM (native binaries), enabling usage in browsers, JVM, and native environments.
• Modular architecture separating runtime support, schema semantics, and generators to achieve consistent behavior and ease extension.
• Model catalog-based testing strategy using valid/invalid instances to verify semantic consistency across diverse schema generators without brittle structural output assertions.

Datasets

• bridge2ai — 1 file, 39.5 KiB — public via LinkML Schema Registry
• cdm — 37 files, 2237.9 KiB — public via LinkML Schema Registry
• chem-dcat — 5 files, 117.4 KiB — public via LinkML Schema Registry
• crdch — 1 file, 1064.8 KiB — public via LinkML Schema Registry
• d3fend — 1 file, 2591.3 KiB — public via LinkML Schema Registry
• fluxnova — 17 files, 244.3 KiB — public via LinkML Schema Registry
• include — 1 file, 56.3 KiB — public via LinkML Schema Registry
• iso27001 — 1 file, 251.7 KiB — public via LinkML Schema Registry
• nmdc — 14 files, 558.8 KiB — public via LinkML Schema Registry
• sssom — 1 file, 59.4 KiB — public via LinkML Schema Registry
• tc57cim — 1 file, 2952.3 KiB — public via LinkML Schema Registry

Baselines vs proposed

• LinkML Python (version 1.11.1) cold start JSON Schema throughput = 1x baseline; LinkML-Scala (0.9.3) achieves 7.1x–127x speedups depending on schema (mean ~36.5x)
• LinkML Python cold start SHACL throughput = 1x; LinkML-Scala achieves 3.4x–126x speedups (mean ~22.9x)
• LinkML Python warm JSON Schema throughput = 1x; LinkML-Scala achieves 1.7x–187x speedups (mean ~38.5x)
• LinkML Python warm SHACL throughput = 1x; LinkML-Scala achieves 1.9x–235x speedups (mean ~26.8x)

Figures from the paper

Figures are reproduced from the source paper for academic discussion. Original copyright: the paper authors. See arXiv:2607.22335.

Fig 1: LinkML-Scala in-browser playground: https://linkml.neverblink.eu/playground/

Limitations

• Speedup varies significantly across schemas, with some smaller or text-heavy schemas showing modest gains (as low as 1.7x in warm JSON Schema benchmarks).
• Cold start benchmarks reflect some overhead from native binary startup times (~2.5 ms), which can be a significant portion of total time on very small schemas.
• LinkML-Scala currently does not support some LinkML target formats such as SQL DDL, Avro, Parquet, or Protobuf, planned for future work.
• Uneven feature coverage between LinkML-Scala and Python implementation may cause discrepancies in schema generation, requiring further harmonization.
• No adversarial robustness or security threat analyses are presented; focus is on performance and portability improvements only.
• Differences in benchmarking methodology (JMH for Scala, plain scripts for Python) might affect exact throughput comparisons.

Open questions / follow-ons

• How to further optimize LinkML-Scala to reduce performance variance across text-heavy or small schemas?
• What is the interoperability state between LinkML-Scala and Python implementations for a seamless developer experience across ecosystems?
• How can support for additional schema/serialization formats like SQL DDL, Avro, Parquet, and Protobuf be integrated while maintaining performance?
• What are the best practices for community-driven improvements to the LinkML specification in light of multiple implementations?

Why it matters for bot defense

While this paper does not address bot defense or CAPTCHA directly, the improvements and innovations in LinkML-Scala offer a case study in building performant, portable, and reliable schema modeling tools that can support complex data validations and transformations across diverse environments. For CAPTCHA and bot defense engineers, such a schema framework could underpin robust data validation pipelines across client platforms and backend systems, enabling consistent validation logic and format conversions. Moreover, the ability to run in browsers or on edge devices with minimal latency aligns with the growing need for client-side validation or dynamic schema-driven challenges. The model catalog and semantic consistency testing approach could inspire validation tooling to ensure consistency across different CAPTCHA formats or bot detection heuristics. However, direct application would require extension of LinkML models to capture the semantics specific to bot behavior and CAPTCHA challenge-response formats.

Cite

@article{arxiv2607_22335,
  title={ LinkML-Scala: a Robust, Fast, and Portable Implementation of LinkML },
  author={ Piotr Sowinski and Kacper Grzymkowski and Andriy Plokhotnyuk },
  journal={arXiv preprint arXiv:2607.22335},
  year={ 2026 },
  url={https://arxiv.org/abs/2607.22335}
}

Read the full paper

• arXiv:2607.22335 (abstract)
• arXiv:2607.22335 (PDF)