apercue.ca@v0

One typed graph.
13 W3C standards.
Zero servers.

One typed CUE value, projected to 13 W3C specifications (8 full, 5 partial), plus Dublin Core and schema.org, as compile-time projections of the same typed dependency graph. No triplestore. For large graphs the closure is precomputed by tools/toposort.py and CUE verifies and projects it.

13W3C specs implemented
4domain examples
0servers
The argument

What it replaces for constrained domains

Traditional semantic web
  • 1Model data in RDF triples
  • 2Load into a triplestore
  • 3Write SPARQL queries per view
  • 4Validate shapes with a SHACL engine
  • 5Serialize to JSON-LD
5 runtime components. 5 failure points.
apercue.ca
  • 1Define typed resources in CUE
  • 2cue export -e <projection>
0 servers. 13 W3C projections.
# Every spec is one export expression
$ cue export -e compliance.shacl_report --out json # SHACL
$ cue export -e ontology --out json # RDFS/OWL
$ cue export -e cpm.time_report --out json # OWL-Time
$ cue export -e provenance.prov_report --out json # PROV-O
$ cue export -e catalog --out json # DCAT 3
$ cue export -e activity_stream --out json # Activity Streams
Mechanism

How it works

1

Define a typed graph

Resources are structs with @type, depends_on, and metadata. #Graph computes topology, depth, and critical path at eval time.

2

Declare constraints

#Charter declares what must exist. #ComplianceCheck validates structural rules. Both emit sh:ValidationReport automatically.

3

Export 13 W3C projections

JSON-LD, SHACL, SKOS, OWL-Time, PROV-O, ODRL, Activity Streams, W3C Org, DCAT and more, plus Dublin Core and schema.org terms. Each is a cue export -e expression. No transformation layer.

Proof of generality

Domain-agnostic by design

The same #Graph, #Charter, and W3C projection patterns work across any domain. Not just infrastructure.

Education

Course Prerequisites

University CS curriculum as a dependency graph. Charter gates enforce degree requirements. CPM finds the optimal schedule.

12 courses 3 gates 4 layers
Cooking

Recipe Ingredients

Beef bourguignon as a prep dependency graph. Critical path finds the minimum cooking timeline.

17 steps 5 types 6 layers
Project Management

Release Tracker

Software release pipeline with schema:actionStatus lifecycle. Gap analysis surfaces what's blocking each milestone.

10 tasks 4 gates 5 layers
Supply Chain

Laptop Assembly

Multi-tier supply chain from raw materials to product. DCAT catalog, SHACL quality gates, CPM lead times.

14 parts 5 tiers 4 types
Standards

W3C spec coverage

Each spec is a CUE comprehension that projects the same underlying graph. No adapters. No converters. The data is the standard.

Spec CUE Pattern Depth Status
Core projections
JSON-LD 1.1 vocab/context.cue Full Implemented
SHACL validation.cue, charter.cue Full Implemented
SKOS views/skos.cue, lifecycle.cue Full Implemented
EARL lifecycle.cue (test plan only: every outcome is earl:untested) Partial Projection
OWL-Time analysis.cue Full Implemented
Dublin Core (DCMI, not W3C) vocab/context.cue Vocabulary Implemented
Extended projections
PROV-O provenance.cue Full Implemented
schema.org (not W3C) schema_alignment.cue Vocabulary Implemented
ODRL 2.2 policy.cue Partial Implemented
Activity Streams 2.0 activity.cue Partial Implemented
Verifiable Credentials 2.0 credentials.cue (unsigned credential shape, no proof) Structural Projection
W3C Org views/org.cue Partial Implemented
VoID void.cue Full Implemented
RDFS/OWL ontology.cue Partial Implemented
Web Annotation annotation.cue Partial Implemented
DQV quality.cue Full Implemented
DCAT 3 catalog.cue Full Implemented
Downstream (in quicue.ca)
Hydra Core quicue.ca operator Partial Downstream
What's new here

Why this approach didn't exist before

Comprehensions replace SPARQL

Every query that would traditionally require a SPARQL endpoint is precomputed as a CUE comprehension at eval time. No query language. No query engine. The answers are structural.

Unification replaces SHACL engines

Shape validation isn't a separate runtime step. CUE's type system is the SHACL engine. If a graph evaluates, its shapes are valid. Constraint violations are evaluation errors, not runtime exceptions.

One file per standard

Adding PROV-O support meant writing provenance.cue. Adding ODRL meant writing policy.cue. Each W3C projection is a single file that projects the same graph. No framework changes needed.

Self-referential build tracking

The project's own build charter is tracked using #Charter and #GapAnalysis; the same patterns it defines. The charter page shows live gate progress.

Domain-agnostic, not infrastructure-specific

The typed dependency graph pattern works for course prerequisites, cooking recipes, supply chains, housing retrofits, real estate transactions, and infrastructure. The W3C projections don't know or care what domain they're projecting. That generality is the point.

Engagement

W3C Community Groups

Two W3C Community Groups have a public artifact from this project: KG-Construct and Dataspaces. The other two are drafted.

KG-Construct

Knowledge Graph Construction

Use cases contributed to the KG-Construct CG.

PR #21 merged 2026-02-27
Dataspaces

Data Governance

Compile-time governance as a lightweight dataspace primitive.

Issue #17 open
Context Graphs

Multi-Context Identity

Struct-as-set types for resources participating in multiple contexts simultaneously.

Drafted, sent to chair and list 2026-03, not in public archive
UORA

Asset Attestation

Typed dependency graphs for physical asset lifecycle tracking.

Use case drafted
Get started

Try it locally

$ git clone https://github.com/quicue/apercue && cd apercue

# Run an example
$ cue eval ./examples/course-prereqs/ -e summary
{
  graph_valid: true
  charter_complete: true
  total_resources: 12
}

# Export any W3C projection
$ cue export ./examples/course-prereqs/ -e gaps.shacl_report --out json
$ cue export ./examples/course-prereqs/ -e provenance.prov_report --out json