Two CUE modules. One generic graph engine with 13 W3C specs (apercue). One infrastructure platform with 35 providers and a static API (quicue). This page covers both: architecture, build plan, live demos, and how they fit together.
apercue is a CUE module that turns typed dependency graphs
into W3C-standard linked data. You define resources and their dependencies.
CUE computes everything else: topology, critical paths, compliance checks, gap analysis.
Every W3C artifact is a different cue export -e expression on the same graph.
Model data in RDF triples. Load into a triplestore. Write SPARQL queries per view. Run a SHACL processor to validate shapes. Serialize to JSON-LD. Five runtime components. Five failure points. Five things to deploy and monitor.
Define typed resources in CUE. Run cue export -e <projection>.
One binary. Zero servers. 13 W3C projections.
CUE's constraint lattice does both the querying (replaces SPARQL) and the validation
(replaces SHACL) in a single evaluation pass.
Core types. #Resource is the base node type. #TypeRegistry
manages the type system. context.cue defines the JSON-LD @context
with 19 W3C namespace prefixes.
The engine. Graph analysis (topology, depth, critical path, cycle detection) and W3C projections (SHACL, PROV-O, DCAT, ODRL, etc.). Each file is one projection of the same graph.
Constraint-first planning. #Charter declares what "done" looks like
with phase gates. #GapAnalysis evaluates a graph against a charter
and emits a SHACL sh:ValidationReport.
Vocabulary projections. #TypeVocabulary emits SKOS ConceptSchemes.
#OrgChart emits W3C Org structures. Both project from the
type registry, not the graph directly.
Four complete, working examples: university course prerequisites (12 courses), beef bourguignon recipe (17 steps), software release tracker (10 tasks), laptop supply chain (14 parts). Each uses the same patterns.
The project models itself. 41 deliverables across 8 phases.
Uses #GraphLite with precomputed topology (because 41 nodes
would timeout the recursive graph engine).
Evidence package for W3C Community Group engagement. Generates conformance
evidence for all 13 specs. 64 validation tests pass.
Export with cue export ./w3c/ -e evidence.<field>.
Static site deployed to apercue.ca via Cloudflare Pages. HTML + D3 visualizations.
Data files in site/data/ are pre-exported from CUE.
You're reading this page right now.
Build scripts and validators. toposort.py precomputes topology
for large graphs. build-site.sh exports all site data.
validate-w3c.py checks JSON-LD output against specs.
The project tracks its own build using #Charter and #GapAnalysis.
Every phase has a gate. Every gate lists its required deliverables.
All 8 gates are satisfied. This timeline shows what was built, in order.
Core type system. Every resource gets a name, @type (struct-as-set), and optional depends_on. JSON-LD @context wires up W3C namespace prefixes. Viz contract defines the D3 data shape.
The graph engine: #Graph computes topology, depth, ancestors, roots, leaves.
Analysis patterns add critical path (CPM), cycle detection, connected components.
Validation patterns produce sh:ValidationReport. Charter module adds gap analysis.
Each W3C spec gets a single CUE file that projects the graph into that standard's format.
SHACL for validation reports. SKOS for type taxonomies. OWL-Time for scheduling.
EARL for test assertions. Same graph, different -e expression.
Four examples prove domain-agnosticism. Course prerequisites (education), beef bourguignon (cooking), project tracker (PM), laptop assembly (manufacturing). All four use the same patterns. All four produce valid SHACL reports.
Documentation, GitHub repo, Cloudflare Pages deployment. The novelty doc explains what's new in three tones (academic, practitioner, executive). Knowledge base tracks architectural decisions (18 ADRs).
SafeID constraints ensure all identifiers are ASCII-safe. CI workflow validates on every push. Specs-registry tracks W3C coverage as a single source of truth. Regen-check catches stale exports.
apercue becomes a shared library. quicue.ca imports it for infrastructure-specific patterns. Canonical URL context, live charter visualization, homelab mirror, CI auto-deploy.
Site data locality (pre-exported JSON instead of runtime CUE eval in browser). Homelab site deployment. CPM overlay on charter graph. Projections dashboard showing SHACL + OWL-Time + CPM together.
CUE is a constraint-based configuration language. If you know JSON and a typed language, you can read CUE. These six patterns appear everywhere in apercue.
Instead of arrays, apercue uses structs with true values for set membership.
O(1) lookup, clean merging via unification, no duplicates possible.
CUE's for loops build structs or lists at eval time. These replace SPARQL queries.
They're deterministic and fully resolved before any output.
CUE's "undefined" value. field != _|_ means "this field exists."
Used for existence checks, optional field detection, and error handling.
If two constraints conflict, the result is _|_.
Fields starting with _ are private to the package. They don't appear in
cue export output. Use them for intermediate computations.
Public fields are the API surface.
CUE merges two values by intersecting their constraints. This is how you apply a pattern to data. If the data doesn't satisfy the pattern, evaluation fails.
Types (schemas) in CUE are called definitions. #Graph, #Charter,
#Resource are definitions. They constrain what fields are allowed and what
values they can hold. They're never exported directly.
Each spec is a CUE projection. The -e flag selects which one.
"Full" means the spec's core terms are emitted and the output parses in rdflib with the expected types; it is not a conformance claim. "Partial" means core terms are covered.
| Spec | Depth | Export expression (from w3c/) |
|---|---|---|
| JSON-LD 1.1 | Full | evidence.context |
| SHACL | Full | evidence.shacl |
| SKOS | Full | evidence.skos_taxonomy |
| EARL | Full | evidence.earl_report |
| OWL-Time | Full | evidence.time_report |
| PROV-O | Full | evidence.prov_report |
| VoID | Full | evidence.void_description |
| DCAT 3 | Full | evidence.dcat_catalog |
| DQV | Full | evidence.quality_report |
| ODRL 2.2 | Partial | evidence.odrl_policy |
| Activity Streams | Partial | evidence.activity_stream |
| Web Annotation | Partial | evidence.annotation_collection |
| W3C Org | Partial | evidence.org_report |
| RDFS/OWL | Partial | evidence.owl_ontology |
| Dublin Core | Vocab | (in @context) |
| schema.org | Vocab | evidence.schema_graph |
| VC 2.0 | Structural | evidence.verifiable_credential |
quicue.ca imports apercue's generic graph engine and adds infrastructure-specific types, 35 provider templates, and a static API. Same patterns, different domain. The relationship: apercue is the library, quicue.ca is the application.
#Resource with identity, network, hosting, dependencies)
and graph algorithms (#InfraGraph, #ImpactQuery, #BlastRadius,
#SinglePointsOfFailure, #DeploymentPlan).
{host} and {container_id} placeholders filled at compile time.
"What breaks if X goes down?" Computes transitive dependents of any resource. Returns the blast radius as a subgraph.
Failure propagation analysis. Given a failed node, which layers are affected? How many resources are unreachable?
Finds resources where failure cascades to multiple dependents. The nodes you need redundancy on.
Layer-by-layer startup ordering. Which resources can start in parallel at each depth level? Computed from the topology.
Provider matching by @type overlap. Selects the right command templates
for each resource based on its types. No if-then cascades.
If layer N fails during deployment, what's the undo sequence? Reverse of the deployment plan, scoped to affected layers.
Each provider has metadata, an action registry (what commands it supports per resource type),
and a working example. Provider selection happens by @type set intersection,
not configuration switches.
These are running on Cloudflare Pages. The API serves 654 pre-computed responses. No backend. No database. CUE exported everything at build time.
Interactive dependency graph with deployment planner, resource browser, impact queries, and Hydra API explorer. Click any node to see its blast radius and upstream dependencies.
demo.quicue.caEvery API response is a static JSON file generated by CUE at build time. Swagger UI, OpenAPI spec, Hydra JSON-LD. Zero runtime cost. The API is a directory of files.
api.quicue.caW3C Hydra vocabulary on top of the static API. Clients discover available operations by following links. The API describes itself in standards-compliant linked data.
api.quicue.ca/api/v1/hydraLanding page, W3C playground, recipe graph demo, ecosystem explorer, projection coverage matrix, and this plan page. All static HTML + D3.
apercue.caapercue is the library. Everything else imports it and adds domain-specific types. The generic graph engine and W3C projections are shared across all downstream modules.
Graph engine, W3C projections, charter planning.
78 pattern definitions. 13 W3C specs. Domain-agnostic.
import "apercue.ca/patterns@v0"
107 pattern definitions. 35 providers. 40+ resource types.
Static API with 654 endpoints. Hydra JSON-LD.
import "quicue.ca/patterns@v0"
Knowledge graph framework with reasoning and federation patterns on top of apercue.
CMHC housing retrofit graphs. Imports apercue for charter-based tracking of retrofit programs.
Multi-site federation, bootstrap sequencing, and Change Advisory Board reporting. All import quicue.ca.