Draco Visualization Knowledge Base

• Draco Knowledge Base is a constraint-based system that formalizes visualization design guidelines as hard and soft constraints using Answer Set Programming.
• It employs Clingo to search for valid specifications and ranks visualizations based on the weighted sum of soft constraint violations.
• Draco offers extensible APIs, visual analytics tools, and data-driven synthesis pipelines to enhance and debug recommendation strategies across various domains.

Draco is a constraint-based knowledge base for visualization design that formalizes design guidelines as logical rules over a chart design space. It represents validity conditions and preferences as hard and soft constraints in Answer Set Programming (ASP), uses Clingo to search valid specifications, and ranks candidates by the weighted sum of violated soft constraints. Across subsequent work, Draco became both a recommendation engine and an extensible research substrate: it has been used to encode theoretical principles and empirical graphical perception results, to inspect and debug recommendation behavior, and to synthesize new design knowledge bases for domains beyond the original manually authored rule space (Yang et al., 2023, Zeng et al., 2023, Kim et al., 27 Jan 2026).

1. Constraint-based representation

Draco models visualization design knowledge through three main parts: a chart description language, a knowledge base of hard and soft constraints, and an API for querying, debugging, extending, and reasoning over the knowledge base. In this formulation, hard constraints eliminate invalid or non-expressive charts, while soft constraints express preferences. A violation of a soft constraint is allowed, but it adds cost; the cost of a visualization is the weighted sum of violated soft constraints. The solver then searches for the lowest-cost solution among valid candidates (Yang et al., 2023).

The ASP encoding is organized into blocks for definitions, constraints, generation, and hard and soft rules. Draco 2 summarizes this structure with domain declarations, validity constraints, and generator rules such as:

domain((mark,type),(point;bar;line;area;text;tick;rect)).

$s_i = sign(p_i - b_i)$0

$s_i = sign(p_i - b_i)$1

These rules make design knowledge concrete, actionable, and testable. The same framework supports both manually specified preferences and weights learned from ranked visualization pairs. Draco 2 states that the default knowledge base starts from CompassQL rules, with weights either manually assigned or learned from data (Yang et al., 2023).

A central distinction in Draco is between validity and preference. A hard constraint can rule out impossible or semantically incoherent designs, while a soft constraint can penalize an inferior but still admissible design. The graphical-perception pipeline paper illustrates the same distinction with a hard rule for invalid log scaling and a soft rule penalizing shape for high-cardinality encodings:

$s_i = sign(p_i - b_i)$2

$s_i = sign(p_i - b_i)$3

In this sense, Draco is not merely a chart-ranking heuristic; it is a formal knowledge representation for visualization design with explicit semantics for expressiveness, effectiveness, and optimization (Zeng et al., 2023).

2. Specification model, search, and the Draco 2 platform

Draco 2 generalizes the original system into a renderer-agnostic platform. Its major architectural change is that it is no longer tightly tied to Vega-Lite. Instead, it uses a generalized nested specification format that can represent multi-layer charts, multi-view charts, shared scales across marks, and more extensible visualization structures. Scales become first-class entities, which is important for reasoning across marks and views. Draco 2 also removes encoding data types as explicit elements because they can be inferred from primitive field type and scale type (Yang et al., 2023).

The underlying logical representation is built from entities and attributes. A specification can therefore be expressed as facts such as:

$s_i = sign(p_i - b_i)$4

This nested representation supports both complete specifications and partial specifications. Partial specifications are fundamental to recommendation: the solver fills in unspecified components while respecting hard constraints and minimizing soft-constraint cost. Draco 2 also supports integrity constraints at query time, for example:

$s_i = sign(p_i - b_i)$5

This rejects candidates with fewer than three encoding entities (Yang et al., 2023).

The platform emphasis is equally important. Draco 2 runs entirely in Python, whereas Draco 1 required both Python and JavaScript. It provides a REST API, a WebAssembly distribution, and direct Python APIs for validating specifications, converting between nested and flat formats, completing partial specifications, and debugging or adapting the knowledge base. It also adds thorough documentation, a comprehensive test suite, and 100% unit test coverage. For debugging, DracoDebug and DracoDebugPlotter expose violated constraints and weights; the debugger can return recommendations, violated soft constraints, and weights in a DataFrame, while the plotter visualizes weights as a bar chart and violation frequencies as a heatmap (Yang et al., 2023).

Empirically, Draco 2 preserves the intended ranking behavior of the earlier system while increasing flexibility. On 100 visualization pairs from Kim and Heer’s graphical perception dataset, Draco 1 and Draco 2 agreed on ranking 86% of the time, and in all divergences Draco 2 preferred the visualization that participants in the study also preferred (Yang et al., 2023).

3. Learning from graphical perception studies

A major line of work treats Draco as an intermediate knowledge base for importing a large body of graphical perception results. The key idea is that a study’s result can often be rewritten as a preference relation between two designs, which then becomes a ranked-pair learning problem over Draco’s soft constraints. The pipeline paper uses Zeng and Battle’s 2023 survey dataset, which records data types, data characteristics, transformations, encodings, marks, scales, and ranked results for visualization pairs under tasks. Experimental results and theoretical principles are both converted into ranked pairs so that Draco-Learn can infer consistent weights (Zeng et al., 2023).

This approach is substantial but not universal. Even after translation, the paper reports that only 30 papers from the 59-paper survey corpus could be modeled in Draco. The missing support includes 3D, graph, animated, and interactive visualizations; some granular design decisions such as sorting of bars or distractors; detailed study metadata such as participant demographics; and more nuanced task distinctions than Draco supports (Zeng et al., 2023).

Within the subset that can be represented, the resulting analysis is highly structured. Out of 147 Draco soft constraints, the 30 papers cover 98. Hierarchical clustering over coverage vectors yields roughly 7 groups, and the clusters are distinguished mostly by what they omit. Log-scale constraints are under-covered, some task types are under-studied, and only about 30% of papers cover both value and summary tasks. A second clustering over sign-based weight shifts identifies three major clusters spanning 20 of the 30 papers. The paper gives examples of clusters that prefer bar charts and linear or continuous scales, categorical color hue encodings, and zero baselines, while other groups prefer non-zero baselines (Zeng et al., 2023).

The same work explicitly studies agreement and conflict among studies. In a controlled case study, single positive evidence shifts weights toward the positive design, completely contradictory evidence cancels out, partial conflicts decompose into overlap plus difference, and aligned overlaps are additive but with diminishing returns. To compare changes across runs, the paper normalizes weight shifts as

$$n_i = (e_i - b_i) / e_{max}; \qquad \text{where} \qquad e_{max} = \max (|e_1|, |e_2|,.., |e_n|).$$

It also defines sign-based shift vectors

$s_i = sign(p_i - b_i)$

for clustering plus-one models against a baseline (Zeng et al., 2023).

A further empirical result is that weight shifts correspond strongly to recommendation shifts. Over 461 combinations of attributes on three datasets, the paper compares baseline and plus-one recommendation rankings using Spearman correlation and reports a strong linear relationship between weight-shift magnitude and recommendation-rank shift, with $r = 0.7818$ and $p < 0.001$. This makes soft-constraint weights an interpretable intermediate representation of how accumulated empirical evidence changes downstream recommendations (Zeng et al., 2023).

4. Explainability, inspection, and visual analytics

As Draco’s rule base grows, its internal structure becomes difficult to inspect directly from ASP source code. The visual-analytics paper identifies three reasons: scale, textual encoding only, and hidden interrelationships among constraints. To address this, it introduces a system for visualizing and analyzing Draco’s constraints rather than proposing a new recommender (Schmidt et al., 2023).

The system has four components: a recommendation query editor, a recommendation viewer, a constraints viewer, and a constraints inspector. Users can begin from a recommendation and trace its violated rules, or begin from a rule and trace which recommendations violate it. This bidirectional explanation loop exposes the relation between recommendation cost and underlying soft-constraint violations (Schmidt et al., 2023).

The extraction architecture has two pipelines. One parses the knowledge base into an Abstract Syntax Tree after adapting ASP-Core 2 into an EBNF grammar suitable for web-based parsing. From the AST it extracts recurring syntax elements called features. The other pipeline extracts constraint identifiers, hard or soft type, weights, and the hierarchical structure of constraint identifiers using Draco’s existing regex-based extraction process. These outputs are merged into a file-based indexed database linking constraints, features, weights, hierarchy relations, and shared syntax (Schmidt et al., 2023).

The resulting visualization combines three structures. Constraints are arranged radially on an outer ring; shared features are encoded as a hypergraph in the center; and hierarchical categories are shown with arcs surrounding the constraints. Soft constraints are color-coded by weight on a blue-to-red diverging scale with range $0\text{--}50$, while hard constraints receive a uniform color. The hypergraph avoids clique explosion by introducing feature nodes between related constraints, and the surrounding arcs use an inside-out strategy so that root categories appear on inner arcs and deeper levels expand outward (Schmidt et al., 2023).

This inspection machinery is not merely descriptive. Hovering over a recommendation highlights the constraints it violates, selecting multiple recommendations overlays their violation patterns, and hovering over a constraint reveals which recommendations violate it. The paper reports a qualitative and quantitative evaluation with six participants, twelve tasks, and ICE-T scores of 5.9 for Insight, 6.1 for Time, 5.7 for Essence, and 4.7 for Confidence. The prototype was judged effective for understanding Draco’s knowledge base and recommendation process, although participants also reported difficulties with some filter interactions and complex recommendation-to-constraint relations (Schmidt et al., 2023).

5. Automatic synthesis of visualization design knowledge bases

A later development replaces manual feature authoring with data-driven synthesis while preserving Draco’s logical representation. The synthesis paper is explicitly framed as a generalization of Draco and Draco 2: the logical, interpretable representation remains, but candidate design features are extracted from corpora of preferred versus less-preferred visualizations, selected algorithmically, and rendered back into Draco-style logical rules (Kim et al., 27 Jan 2026).

The synthesis pipeline begins by converting specifications into Draco-style entity(...) and attribute(...) facts. It then traverses each chart specification depth-first to enumerate key-value chains. If a terminal value is numeric, the method clusters values using 1D k-means, tests cluster counts from 2 to 10, chooses the best clustering by silhouette score, and adjusts thresholds to human-friendly boundaries. It next combines structurally compatible features, introduces negated features, and un-grounds them by stripping membership information and then parent information to create more general design rules (Kim et al., 27 Jan 2026).

Feature selection is formalized through difference vectors and wrapper-style evaluation. For a feature $x$, the paper defines

$d_x = p_x - n_x$

where $p_x$ and $n_x$ are the feature’s frequency vectors over positive and negative designs. Candidate features are first scored by pre-selection metrics for meaningfulness, generalizability, and usefulness, including relevance, LDA score, specificity, appearance count, difference count, dominance, determinance gap, and determinance ratio. Forward selection then adds features only if they improve cross-validation accuracy under a logistic regression or linear SVC model, and backward selection removes features whose omission improves the same objective. The final selected features are rendered back into Draco’s logical representation with weights derived from classifier coefficients (Kim et al., 27 Jan 2026).

On the benchmark corpus, this synthesis process improves on Draco 2 while remaining interpretable. The corpus contains 1,384 chart pairs from 30 graphical perception studies, split into a Baseline subset of 1,229 pairs and a Zeng+ subset of 155 pairs, with 15% holdout and five cross-validation splits. The paper reports that the synthesized knowledge base improves the accuracy of predicting effective designs by 1–15% in varied training and test sets. Concrete holdout examples include 89.85 versus Draco 2’s 87.43 on the full corpus, and 78.39 versus Draco 2’s 72.58 on Zeng+ in one reported configuration (Kim et al., 27 Jan 2026).

The same framework extends beyond standard statistical graphics. In a genomics case study, the authors start from 10 representative genomics visualizations, generate variants, have a genomics visualization expert label the resulting pairs, and obtain 296 pairs. With manually encoded helper rules for ideograms, Circos plots, pile-up charts, x/y collocations, and multi-view constraints, the synthesized genomics knowledge base reaches 94.64% to 98.40% cross-validation accuracy and 82.95% to 97.72% holdout accuracy. The discovered features include static versus interactive views, linear arrangement of charts, coordinated x axes, color channels, bar and rect marks, and genomics-specific structural features. Two genomic experts judged 75–80% of the features helpful or very helpful (Kim et al., 27 Jan 2026).

6. Significance, misconceptions, and current limitations

A recurrent misconception is that Draco is a fixed rule set. The published work describes something more dynamic: a formal, extensible platform whose default knowledge base can be modified by adding or removing constraints, changing soft-constraint weights, extending the specification schema, plugging in custom renderers, or programmatically reasoning over charts through Python, REST, and WebAssembly interfaces. Draco 2 is therefore a platform rather than only a recommender (Yang et al., 2023).

A second misconception is that incorporating more graphical perception studies necessarily improves recommendation quality in a monotone way. The evidence is more qualified. Complementary studies can reinforce recommendations, contradictory studies can neutralize each other, and redundant studies may have no effect at all. Some papers have zero influence because Draco lacks the relevant constraints; others have zero influence because their knowledge is already encoded in the baseline. This makes the framework useful not only for recommendation, but also for exposing gaps, redundancies, and conflicts in the perception literature (Zeng et al., 2023).

Current limitations are explicit. Not all graphical perception findings can be represented in Draco; support is missing for 3D, graph, animated, and interactive visualizations, as well as some granular design decisions and detailed study metadata. Coverage across the literature is uneven, with under-covered log-scale constraints and task types. The synthesis work addresses a different limitation—manual feature authoring—but it still depends on the quality and diversity of the input corpus. Taken together, these results suggest an evolving research trajectory: Draco functions simultaneously as a knowledge base, a recommendation substrate, an explainability target, and a mechanism for synthesizing new formal design knowledge from empirical evidence (Yang et al., 2023, Zeng et al., 2023, Kim et al., 27 Jan 2026).