Kastor

Documentation website — Jekyll site in docs/, deployed with GitHub Actions. On a fork, enable Settings → Pages → Build and deployment: GitHub Actions.

Reading the docs: How documentation fits together · Glossary.

Contributors: repository architecture (Gradle modules, layers, and on-disk layout) and CONTRIBUTING (build, tests, CI).

Kastor is a modern, comprehensive Kotlin framework for RDF (Resource Description Framework) and semantic web development. It bridges the gap between traditional object-oriented programming and semantic technologies, making RDF accessible and powerful for Kotlin developers.

💝 Support Kastor: If this project helps you, consider sponsoring to ensure continued maintenance and feature development. Organizations using Kastor in production can contact us for enterprise support and custom adaptations.

See release contracts and verification for tested capabilities, resource ownership, generated snapshots, and experimental limitations.

Why Kastor (in one sentence)

Use Kastor when you want domain-first RDF in Kotlin: pure domain interfaces with a side-channel back to RDF, plus a vocabulary-agnostic DSL that keeps RDF explicit without forcing RDF types into your business code.

Philosophy & Tradeoffs

Philosophy

• Domain-first, RDF second: work with pure Kotlin domain interfaces; access RDF through a side-channel when needed.
• Vocabulary-agnostic core: no hardcoded vocab assumptions; your vocabularies drive the model.
• Explicit semantics over magic: the DSL avoids hidden inference; validation and reasoning are explicit.
• Provider-agnostic: swap Jena, RDF4J, Memory, or SPARQL without changing your app model.

Anti-goals

• Not a triple store or RDF database.
• Not a SPARQL engine (it integrates with providers that are).
• Not an ontology reasoner beyond provider capabilities.

Comparison (neutral)

Concern	Kastor	Jena / RDF4J / rdflib
Domain objects without RDF dependencies	✅	❌
Side-channel RDF access	✅	❌ (typically direct RDF types)
Vocabulary-agnostic DSL	✅	⚠️ (varies)
Provider-agnostic core API	✅	❌ (engine-specific APIs)

🔌 Works with Your Existing RDF Infrastructure

Kastor doesn't replace Jena or RDF4J—it makes them easier to use in Kotlin.

For Existing Jena/RDF4J Projects

✅ Keep your existing infrastructure: Use your current repositories, stores, and configurations
✅ No migration required: Your data and queries work as-is
✅ Gradual adoption: Use Kastor for new code, keep existing code unchanged
✅ Full access: Reach underlying Jena/RDF4J APIs when needed
✅ Same backends: TDB2, NativeStore, memory stores—all supported

What Kastor Adds

RDF-H 0.8: the optional rdf-holon module resolves an explicit holon registry over named graphs, RDF 1.2 reifiers, or declared mixed data. It supports direct, aggregated and visible content, attribution, checked conversion, and scoped SHACL validation. See RDF-H usage.

🎨 Natural language DSL: person has FOAF.name with "Alice" instead of verbose Model API calls
🔒 Type-safe SPARQL: Compile-time validated queries with Kotlin-idiomatic builders
🚀 Kotlin idioms: Extension functions, sealed classes, null safety, coroutines
🔄 Provider-agnostic: Switch between Jena, RDF4J, Memory, or SPARQL endpoints without changing your code

Example: Using Existing Jena Infrastructure

import com.geoknoesis.kastor.rdf.*
import com.geoknoesis.kastor.rdf.jena.*
import com.geoknoesis.kastor.rdf.vocab.FOAF
import org.apache.jena.rdf.model.Model
import org.apache.jena.rdf.model.ModelFactory

// Your existing Jena Model
val jenaModel: Model = ModelFactory.createDefaultModel()

// Wrap it with Kastor for easier Kotlin development.
// Reads are strict: a statement Kastor cannot represent (e.g. xml:lang="en_US") fails the read.
// Use JenaBridge.fromJenaModel(jenaModel, strictRead = false) to skip such statements instead.
val graph = jenaModel.toKastorGraph()

// Now use Kastor's DSL
graph.add {
    val person = iri("http://example.org/alice")
    person has FOAF.name with "Alice"
    person has FOAF.age with 30
}

// Or access Jena directly when needed
val underlyingModel = graph.toJenaModel()
val statement = underlyingModel.listStatements().next()

Example: Using Existing RDF4J Repository

import com.geoknoesis.kastor.rdf.*
import com.geoknoesis.kastor.rdf.vocab.FOAF
import org.eclipse.rdf4j.repository.Repository

// Your existing RDF4J repository
val rdf4jRepo: Repository = // ... your existing setup

// Wrap the initialized repository. Closing the adapter also shuts down rdf4jRepo.
// Graph reads are strict; pass Rdf4jRepository(rdf4jRepo, inference = false, lenientRead = true)
// to skip statements Kastor cannot represent instead of failing.
val repo = com.geoknoesis.kastor.rdf.rdf4j.Rdf4jRepository(rdf4jRepo)

// Now write cleaner Kotlin code
repo.add {
    val person = iri("http://example.org/alice")
    person has FOAF.name with "Alice"
}

// Same API works with Jena, Memory, or SPARQL endpoints
val jenaRepo = Rdf.repository {
    providerId = "jena"
    variantId = "tdb2"
    location = "/data/tdb2"
}
// Same code, different backend!

Bottom line: Kastor is a compatibility layer that makes RDF programming easier in Kotlin. You keep your existing infrastructure and get a better developer experience.

Gradle dependency profiles (Jena / RDF4J)

Use the kastor-bom when you want every published module pinned to one version. When trimming the classpath:

• Store only: implementation("com.geoknoesis.kastor:rdf-core") plus rdf-jena or rdf-rdf4j (Maven artifact IDs).
• Reasoning SPI (RdfReasoning, ReasonerRegistry): add rdf-reasoning and the adapter-specific rdf-jena-reasoning and/or rdf-rdf4j-reasoning artifacts (they are no longer pulled in transitively by the store adapters).

See Repository architecture — Dependency profiles for the full table.

🌟 What Makes Kastor Special?

Kastor provides a dual-layer architecture that serves both RDF experts and application developers:

🎯 For RDF Experts

• Native RDF Operations: Full control over triples, graphs, and SPARQL queries
• Multiple Backends: Jena, RDF4J, Memory, and SPARQL endpoint support
• Advanced Features: Reasoning, SHACL validation, transactions, and RDF graph testing (rdf-testkit, rdf-cli; see Testing RDF graphs)
• RDF 1.2 triple terms: statement metadata via rdf:reifies and triple terms (Jena and RDF4J providers)

🚀 For Application Developers

• Natural Language DSL: Write RDF like natural language (person `is` FOAF.Person)
• Type-Safe Domain Objects: Pure Kotlin interfaces with compile-time validation
• Code Generation: Generate domain models from ontologies (SHACL + JSON-LD)
• Zero RDF Dependencies: Domain objects have no RDF library dependencies

🏗️ Enterprise Ready

• Transactions: Local memory, Jena, and RDF4J rollback; HTTP endpoints expose individual operations
• Performance Optimized: Streaming, parallel processing, and memory management
• Production Backends: Jena TDB2 and RDF4J Native Store support
• Validation & Reasoning: Built-in SHACL validation and OWL/RDFS reasoning

Why "Kastor"?

The name Kastor is a tribute to Castor, the pioneering Java XML data binding framework developed by Exolab. Castor was one of the first frameworks to bridge the gap between object-oriented programming and structured data formats, making it easier for developers to work with XML data in Java applications.

Just as Castor revolutionized XML data binding in Java, Kastor aims to bring the same level of developer experience to RDF and semantic web technologies in Kotlin. The "K" in Kastor represents:

• Kotlin - Our chosen language for modern, expressive, and type-safe development
• Knowledge - The semantic web's focus on knowledge representation and reasoning

Kastor honors Castor's legacy while embracing the future of semantic technologies and the Kotlin ecosystem.

🚀 Core Capabilities

✅ Standards & Versions Supported

Core Standards

• RDF 1.2 (data model: triple terms, rdf:reifies, rdf:dirLangString)
• RDF 1.1 (still parses; legacy reification still works)
• SPARQL 1.1
• SPARQL 1.2 (<<( s p o )>> syntax, LANGDIR / STRLANGDIR, TRIPLE family)

Validation & Semantics

• SHACL 1.2: Core, SHACL-SPARQL (constraints, constraint components, functions) and Node Expressions in the native engine; the SPARQL parts run on rdf-jena or rdf-rdf4j (see SHACL validation)
• RDFS reasoning
• OWL reasoning (EL / RL / DL via providers)

Serialization Formats

• Turtle 1.2, TriG 1.2, N-Triples 1.2, N-Quads 1.2
• JSON-LD, RDF/XML

Other

• Triple terms / rdf:reifies (RDF 1.2 native; provider-dependent)

The bundled in-memory provider is RDF 1.1 only. RDF 1.2 features (triple terms, directional language strings, the new format syntaxes) require rdf-jena or rdf-rdf4j on the classpath. See docs/kastor/concepts/rdf-1.2.md and the migration guide for upgrading from 0.1.x.

Conformance: Kastor includes a W3C RDF 1.2 syntax harness in :rdf:conformance (Turtle 1.2, TriG 1.2, N-Triples 1.2, N-Quads 1.2) for Jena and RDF4J. Use ./gradlew conformanceSmokeTest for a fast bundled check; run python scripts/fetch-conformance-data.py (pinned W3C corpora) and then ./gradlew :rdf:conformance:test for the full upstream corpus. Details: docs/kastor/concepts/rdf-1.2-conformance.md.

📊 RDF Core Framework

• 🔄 Repository Management: Seamlessly switch between Memory, Jena, RDF4J, and SPARQL backends
• 📈 Graph Operations: Advanced triple storage, retrieval, manipulation, and graph algorithms
• 🔍 SPARQL Integration: Full SPARQL 1.1 support with type-safe query builders
• 💾 Serialization: Complete RDF format support (Turtle, RDF/XML, JSON-LD, N-Triples, N-Quads)
• 🔒 ACID Transactions: Local provider rollback with provider-specific guarantees
• 🧮 Graph testing: Module rdf-testkit — RDF-isomorphic assertions and golden Turtle checks; rdf-cli — parse, to-turtle, and diff from the command line (guide)
• 🎨 Natural Language DSL: Intuitive syntax (person `is` FOAF.Person, person has FOAF.name with "Alice")

🧠 Advanced Semantic Features

• 🔬 Reasoning Engine: RDFS, OWL-EL, OWL-RL, and OWL-DL inference capabilities
• ✅ SHACL Validation: Comprehensive data validation with detailed constraint checking
• ⭐ RDF 1.2 Triple Terms: reifies(...) DSL for statement metadata (replaces the RDF-star model of 0.1.x)
• 🔗 QName helpers: qname("foaf:name") resolves declared and built-in prefixes to IRIs
• 📚 Built-in Vocabularies: Pre-configured prefixes for RDF, RDFS, OWL, SHACL, and XSD

🏷️ Kastor Gen - Code Generation

• 🎯 Domain Interfaces: Generate pure Kotlin interfaces from ontologies
• 🔄 Automatic Materialization: Seamless conversion between RDF and domain objects
• 🛡️ Type Safety: Compile-time validation of property types and constraints
• 🔌 RDF Side-Channel: Access underlying RDF power when needed
• ⚙️ Gradle Integration: Zero-configuration build system integration
• 📋 Ontology Sources: Generate from SHACL shapes, JSON-LD contexts, and RDFS/OWL ontologies

Key Benefits:

• ✅ Generated, not hand-written — interfaces and wrappers are regenerated from the shapes on every build
• ✅ Stays in sync — regeneration removes obsolete files listed in each ontology's manifest
• ✅ Compile-time safety — property types derived from SHACL constraints

🏢 Integration Features

• 🌐 Multiple repositories: create and combine Memory, Jena (TDB2), RDF4J (Native Store) and HTTP SPARQL repositories via Rdf.repository { }
• 🔧 Pluggable Architecture: provider SPI for custom backends
• 📱 Scoped streaming: withSelectRows, withConstructTriples and Rdf.openTripleStream release backend resources deterministically (release contract)

Quick Start

Required runtime dependency: Rdf.memory() and Rdf.persistent() need a SPARQL-capable provider on the classpath. Add either com.geoknoesis.kastor:rdf-jena or com.geoknoesis.kastor:rdf-rdf4j to your dependencies. Without one, both factories throw RdfProviderException. The bundled :rdf:core-only memory provider is graph-only and must be opted into explicitly via Rdf.repository { providerId = "memory" }.

Basic RDF Operations

import com.geoknoesis.kastor.rdf.*
import com.geoknoesis.kastor.rdf.vocab.FOAF
import com.geoknoesis.kastor.rdf.vocab.RDF

// Create a repository (needs rdf-jena or rdf-rdf4j on the classpath)
val repo = Rdf.memory()

repo.add {
    prefixes {
        put("ex", "http://example.org/")
    }

    val alice = qname("ex:alice")               // QName → <http://example.org/alice>
    val bob = iri("http://example.org/bob")

    alice - RDF.type - FOAF.Person              // minus-operator form
    bob `is` FOAF.Person                        // natural-language alias for rdf:type
    alice - FOAF.name - "Alice"                 // strings become xsd:string literals
    alice has FOAF.age with 30                  // has/with form; Int becomes xsd:integer
    alice[FOAF.knows] = bob                     // bracket form
}

// Query with a SPARQL string
val results = repo.select(SparqlSelectQuery("""
    PREFIX foaf: <http://xmlns.com/foaf/0.1/>
    SELECT ?name WHERE { ?person a foaf:Person ; foaf:name ?name }
"""))
results.forEach { row -> println(row.get("name")) }

Domain Object Mapping

Requires kastor-gen-runtime and the KSP processor (kastor-gen-processor) to generate the implementation.

import com.geoknoesis.kastor.gen.annotations.Rdf   // the annotation (not the Rdf factory object)
import com.geoknoesis.kastor.gen.runtime.materialize
import com.geoknoesis.kastor.gen.runtime.materializeIn
import com.geoknoesis.kastor.rdf.iri

// Define domain interface
@Rdf(iri = "http://xmlns.com/foaf/0.1/Person")
interface Person {
    @Rdf(iri = "http://xmlns.com/foaf/0.1/name")
    val name: String

    @Rdf(iri = "http://xmlns.com/foaf/0.1/age")
    val age: Int
}

// Materialize from RDF (idiomatic — reified domain type)
val person: Person = repo.materialize(iri("http://example.org/person"))
// Equivalently: repo.defaultGraph.materialize(iri("http://example.org/person"))
// or: iri("http://example.org/person").materializeIn(repo.defaultGraph)

// Use domain object
println("Name: ${person.name}, Age: ${person.age}")

Prefixes and QNames

String objects are always literals, and IRIs are explicit. Use qname(...) to expand a prefixed name with declared or built-in prefixes, and iri(...) for full IRIs:

import com.geoknoesis.kastor.rdf.*
import com.geoknoesis.kastor.rdf.vocab.RDF

repo.add {
    // Built-in prefixes need no declaration: rdf, rdfs, owl, sh, xsd, obo,
    // skos, prov, dcat, dcterms, void, geo, time
    prefixes {
        put("foaf", "http://xmlns.com/foaf/0.1/")     // declare (or override) prefixes
    }
    prefix("ex", "http://example.org/")               // single-prefix form

    val person = qname("ex:person")

    person - RDF.type - qname("foaf:Person")          // → <http://xmlns.com/foaf/0.1/Person>
    person - qname("rdfs:label") - "Person"           // predicate from a built-in prefix
    person - qname("foaf:homepage") - iri("http://example.org/profile")
}

Explicit literals

import com.geoknoesis.kastor.rdf.*                  // Direction, add, iri, lit, string
import com.geoknoesis.kastor.rdf.vocab.FOAF
import com.geoknoesis.kastor.rdf.vocab.XSD

repo.add {
    val person = iri("http://example.org/person")

    person - FOAF.name - string("foaf:Person")                // "foaf:Person"^^xsd:string (never an IRI)
    person - FOAF.name - lang("Alice", "en")                  // "Alice"@en
    person - FOAF.name - lang("مرحبا", "ar", Direction.RTL)   // RDF 1.2 directional string
    person - FOAF.age - lit("30", XSD.integer)                // "30"^^xsd:integer
}

The Kotlin samples in this README are compiled by the build; see examples/hello-world/src/main/kotlin/ReadmeSnippets.kt.

Installation

Not yet on Maven Central. Kastor artifacts have not been published yet. Build from source and install into your local Maven repository with ./gradlew publishToMavenLocal, then add mavenLocal() to your repositories. You can also include the Kastor checkout as a composite build (includeBuild("../kastor")). The version (0.3.0-SNAPSHOT) is defined once in gradle.properties. Requires JDK 21+ and Kotlin 2.4.

Gradle (Kotlin DSL)

dependencies {
    // Align all Kastor modules
    implementation(platform("com.geoknoesis.kastor:kastor-bom:0.3.0-SNAPSHOT"))

    // Kastor RDF Core (transitive: rdf-sparql-contract for query markers)
    implementation("com.geoknoesis.kastor:rdf-core")

    // Backends (at least one for SPARQL)
    implementation("com.geoknoesis.kastor:rdf-jena")
    implementation("com.geoknoesis.kastor:rdf-rdf4j")

    // Kastor Gen
    implementation("com.geoknoesis.kastor:kastor-gen-runtime")
    ksp("com.geoknoesis.kastor:kastor-gen-processor:0.3.0-SNAPSHOT")

    // Optional: Kotlin SPARQL query DSL / sparql package / flows
    implementation("com.geoknoesis.kastor:rdf-sparql-lang")
    // Optional: SHACL shapes DSL (shacl {}, Rdf.shacl); pulls rdf-sparql-lang transitively
    implementation("com.geoknoesis.kastor:rdf-shacl-dsl")
    // Optional: SHACL validation, reasoning
    implementation("com.geoknoesis.kastor:rdf-shacl-validation")
    implementation("com.geoknoesis.kastor:rdf-reasoning")
}

Maven

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.geoknoesis.kastor</groupId>
            <artifactId>kastor-bom</artifactId>
            <version>0.3.0-SNAPSHOT</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>com.geoknoesis.kastor</groupId>
        <artifactId>rdf-core</artifactId>
    </dependency>
    <!-- Kotlin SPARQL query DSL (optional) -->
    <dependency>
        <groupId>com.geoknoesis.kastor</groupId>
        <artifactId>rdf-sparql-lang</artifactId>
    </dependency>
    <!-- Kotlin SHACL shapes DSL (optional; transitive rdf-sparql-lang) -->
    <dependency>
        <groupId>com.geoknoesis.kastor</groupId>
        <artifactId>rdf-shacl-dsl</artifactId>
    </dependency>
    <dependency>
        <groupId>com.geoknoesis.kastor</groupId>
        <artifactId>kastor-gen-runtime</artifactId>
    </dependency>
</dependencies>

Documentation

• Kastor RDF Documentation - Core RDF functionality
• Kastor Gen Documentation - Domain object mapping
• Getting Started Guide - Quick start tutorial
• API Reference - Detailed API documentation

🎯 Example Application Areas

Kastor is designed for (though not yet proven in) domains such as:

📊 Data Governance & Catalogs

• Government Data Portals: DCAT-compliant data catalogs with automatic validation
• Enterprise Data Lakes: Semantic metadata management for large-scale data integration
• Data Quality Assurance: SHACL-based validation ensuring data consistency and compliance
• Data Lineage Tracking: PROV-O provenance with RDF 1.2 reifiers for statement-level metadata

🏢 Knowledge Management

• Enterprise Knowledge Graphs: Comprehensive knowledge representation with reasoning
• Semantic Search: Intelligent search across heterogeneous data sources
• Content Management: Linked data publishing with automatic relationship discovery
• Decision Support Systems: OWL reasoning for complex business rule evaluation

🔬 Scientific & Research Applications

• Research Data Repositories: FAIR data principles implementation with semantic metadata
• Scientific Workflows: Ontology-driven data processing and analysis pipelines
• Collaborative Research: Federated queries across distributed research datasets
• Publication Management: Automatic extraction and linking of research entities

🌐 Web & API Development

• Semantic APIs: RESTful services with automatic RDF serialization
• Linked Data Publishing: Standards-compliant web resource representation
• Microservices Integration: Semantic service discovery and orchestration
• Real-time Data Streaming: Reactive processing of semantic data streams

🏭 Industry-Specific Solutions

• Healthcare: FHIR-compliant medical data integration with semantic reasoning
• Finance: Regulatory compliance and risk assessment using semantic rules
• Manufacturing: IoT data integration with semantic device descriptions
• E-commerce: Product catalog management with automated classification

🏗️ Architecture Overview

Kastor's architecture is designed around separation of concerns and pluggable components:

┌─────────────────────────────────────────────────────────────┐
│                    Kastor Framework                         │
├─────────────────────────────────────────────────────────────┤
│  🎨 Natural Language DSL  │  🛡️ Type Safety  │  ⚡ Performance │
├─────────────────────────────────────────────────────────────┤
│                    Application Layer                        │
│  📊 Domain Objects  │  🔄 Materialization  │  🎯 Code Gen    │
├─────────────────────────────────────────────────────────────┤
│                      Core API Layer                         │
│  📈 Graph Ops  │  🔍 SPARQL  │  🧠 Reasoning  │  ✅ Validation │
├─────────────────────────────────────────────────────────────┤
│                   Provider Layer (Pluggable)                │
│  💾 Memory  │  🏢 Jena  │  🔧 RDF4J  │  🌐 SPARQL  │  🔌 Custom │
└─────────────────────────────────────────────────────────────┘

🔄 Dual-Layer Design

Layer 1: RDF Core - For semantic web experts

• Direct access to RDF triples, graphs, and SPARQL
• Full control over serialization and reasoning
• Advanced features like graph isomorphism and transactions

Layer 2: Kastor Gen - For application developers

• Pure Kotlin domain interfaces with no RDF dependencies
• Automatic conversion between RDF and domain objects
• Code generation from ontologies and schemas

🎯 Key Design Principles

• Type Safety: Compile-time validation prevents runtime errors
• Performance: Optimized for both memory usage and query speed
• Extensibility: Pluggable providers for custom backends and features
• Standards Track: RDF 1.2 data model, SPARQL 1.1/1.2 via providers, and native SHACL 1.2 validation (see conformance)
• Developer Experience: Natural language DSL and comprehensive tooling

Development

Building from Source

git clone https://github.com/geoknoesis/kastor.git
cd kastor
./gradlew assemble
./gradlew publishToMavenLocal   # optional: consume 0.3.0-SNAPSHOT from mavenLocal()

Running Tests

./gradlew check -x :rdf:conformance:test
./gradlew conformanceSmokeTest

Requires JDK 21+ and Python 3: check also runs the repository quality gates (verifyQualityGates: complexity ratchet, documentation versions, build pins, README imports). See CONTRIBUTING for the full W3C conformance suites, memory settings, and the release process.

About

Kastor is developed by GeoKnoesis LLC, a company specializing in semantic web technologies and knowledge engineering.

Main Developer

• Stephane Fellah - Principal Developer
• Contact: [email protected]

💝 Support & Sponsorship

Kastor is open-source and free to use, but maintaining and evolving it requires ongoing effort.

If Kastor is valuable to you or your organization, your financial support helps ensure:

• ✅ Continued maintenance - Bug fixes, security updates, and compatibility with new Kotlin/Jena/RDF4J versions
• ✅ Feature development - New capabilities and improvements based on community needs
• ✅ Custom adaptations - Priority consideration for features that align with your specific requirements
• ✅ Long-term sustainability - Keeping the project active and well-maintained for the community

Ways to support:

• 💰 GitHub Sponsors - Monthly or one-time sponsorship
• ☕ Ko-fi - One-time donations
• 🏢 Enterprise Support - For organizations needing priority support, custom features, or commercial licensing: [email protected]
• 🌟 Star the repository - Help others discover Kastor on GitHub

For organizations: If you're using Kastor in production or need specific features, consider enterprise sponsorship. This helps prioritize your needs and ensures the project continues to evolve in ways that benefit your use case.

Other Ways to Contribute

• 🐛 Report issues or suggest improvements
• 💬 Join discussions in our GitHub Discussions
• 📖 Improve documentation through pull requests
• 🔧 Contribute code — See CONTRIBUTING.md; pull requests are welcome.

Community

• Contributing — build, test, and pull request guidelines
• Support — where to ask questions, file bugs, and security reports
• Code of Conduct — expected behavior in community spaces
• Security policy — how to report vulnerabilities responsibly

Changelog

See CHANGELOG.md for the full list of changes between releases.

License

Kastor is licensed under the Apache License 2.0.

Acknowledgments

• Built with Kotlin
• Compatible with Apache Jena
• Compatible with RDF4J
• Supports SHACL validation
• Follows the RDF 1.2 data model (see CHANGELOG.md for migration notes from earlier snapshots)
• Inspired by Castor XML data binding framework

---

Ready to get started? Check out our Getting Started Guide or explore the examples!