GITNUXSOFTWARE ADVICE
Art DesignTop 10 Best Professional Book Cover Design Software of 2026
Top 10 Professional Book Cover Design Software ranked for authors and designers, with technical comparisons of Canva, Adobe Express, and Affinity Publisher.
How we ranked these tools
Core product claims cross-referenced against official documentation, changelogs, and independent technical reviews.
Analyzed video reviews and hundreds of written evaluations to capture real-world user experiences with each tool.
AI persona simulations modeled how different user types would experience each tool across common use cases and workflows.
Final rankings reviewed and approved by our editorial team with authority to override AI-generated scores based on domain expertise.
Score: Features 40% · Ease 30% · Value 30%
Gitnux may earn a commission through links on this page — this does not influence rankings. Editorial policy
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
Canva
Brand Kit enforces reusable typography, colors, and logo placement across designs.
Built for fits when teams need cover throughput and brand consistency without code..
Adobe Express
Editor pickBrand asset libraries for recurring fonts, logos, and palette reuse in cover variants.
Built for fits when teams need repeatable cover templates with governed brand assets..
Affinity Publisher
Editor pickMaster pages plus text styles for consistent front and spine typography across a cover series.
Built for fits when individual designers or small teams need repeatable cover templates without external automation dependencies..
Related reading
Comparison Table
This comparison table evaluates professional book cover design tools by integration depth, including how each platform connects to storage, asset pipelines, and brand systems through configuration and API surface. It also compares the underlying data model and automation options, such as schema support, provisioning workflows, and extensibility, plus admin controls like RBAC and audit log visibility. The result shows practical tradeoffs in governance, workflow throughput, and custom automation for teams that need repeatable cover production.
Canva
design collaborationProvides a cover-design workflow with brand kits, reusable design assets, export to print-ready formats, and team collaboration controls.
Brand Kit enforces reusable typography, colors, and logo placement across designs.
Canva for book covers supports canvas sizing, bleed-aware exports, layered editing, and typography pairing inside a single design environment. Brand Kit configuration centralizes reusable tokens like logo placement, color palettes, and font families, which reduces inconsistencies across multiple cover variations. Collaboration features include version history, comments, and link-based sharing for draft reviews during iterative cover design cycles. For automation and extensibility, Canva’s app ecosystem and integrations help move text, images, and layout templates into repeatable production flows.
A key tradeoff is that Canva’s most reliable repeatability depends on discipline around template structure and brand tokens rather than on a strict, developer-defined data schema for book metadata like author, series, and trim size. Canva also limits deep admin governance compared with enterprise asset pipelines that require granular provisioning, custom data model enforcement, and complete API-level control for every output attribute. Canva fits best when teams need fast throughput for cover drafts and variant runs while keeping approvals and brand consistency inside one workflow.
- +Brand Kit centralizes fonts, colors, and logos for consistent covers.
- +Layered editor and typography tools cover complex cover compositions.
- +Collaboration supports comment workflows and version history for review cycles.
- +App integrations help import assets and apply reusable templates.
- –Metadata-driven cover generation is limited without external automation.
- –Governance depth is weaker than enterprise DAM provisioning and policy control.
- –Output configuration control can require manual checks for print specs.
Indie authors and small publishers
Generate cover variants per title
Faster cover iteration cycles
Design teams in marketing
Coordinate reviews across stakeholders
Reduced review churn
Show 2 more scenarios
Book production operations
Batch output for multiple formats
Consistent export deliverables
Maintains consistent layout styling while exporting finished cover files for campaigns.
Content ops with automation
Import assets into template layouts
Lower manual layout work
Relies on integrations and apps to pull in images and apply template structure.
Best for: Fits when teams need cover throughput and brand consistency without code.
More related reading
Adobe Express
template-based designSupports cover template creation and editing with export options and account controls under Adobe for teams.
Brand asset libraries for recurring fonts, logos, and palette reuse in cover variants.
Adobe Express fits teams that need consistent cover outputs across multiple editions, because template-driven composition enforces recurring structure for typography and imagery. Asset libraries support reusable brand elements, so cover variants can pull approved fonts, logos, and color palettes without rework. The data model centers on editable design surfaces, linked media assets, and reusable components that map well to repeatable cover pipelines.
A tradeoff appears when advanced print preflight and deep page-box control are required beyond Express templates. Teams also hit limits when high-throughput cover production needs fine-grained, schema-level metadata governance across thousands of assets. Adobe Express works well when a workflow includes template provisioning, library approvals, and export batches for ongoing releases.
- +Template-driven cover layouts reduce variance across editions
- +Reusable brand libraries cut repeated typography and logo placement
- +Creative Cloud asset identity simplifies cross-tool asset reuse
- +Design export supports print-oriented workflows from one editor
- –Limited control over deep print box settings beyond templates
- –Fine-grained asset metadata governance is constrained
- –Automation surface is weaker than dedicated DAM and CI systems
Publishing production teams
Seasonal series cover variants
Faster edition turnarounds
Marketing teams
Campaign cover refreshes
Fewer design review cycles
Show 2 more scenarios
Design operations leads
Template and asset provisioning
Lower template drift
Standardize reusable components so new covers follow the same composition rules.
Freelance designers
Brand-consistent client covers
More predictable delivery
Reuse shared brand libraries to create client-specific covers with fewer manual steps.
Best for: Fits when teams need repeatable cover templates with governed brand assets.
Affinity Publisher
print layout automationProvides print-focused book and cover layout with automation via macros and document style management.
Master pages plus text styles for consistent front and spine typography across a cover series.
Affinity Publisher is a desktop document editor that maps covers to a page and object data model using layers, guides, and master-page constructs. Typography control is driven by text styles and paragraph styles, which makes series covers consistent when layouts evolve. Export pipelines support print-ready formats with deterministic page setup and crop, bleed, and resolution settings.
Tradeoffs show up in integration and governance. There is no native multi-user admin layer for RBAC, no tenant provisioning model, and no audit-log trail for edits across a team. A strong usage situation is a production workflow where one designer maintains cover templates, exports print-ready PDFs, and hands off files to prepress or print operators.
- +Text styles and paragraph styles keep cover typography consistent across series
- +Master pages and layers support reusable cover templates and controlled variations
- +Deterministic export settings help maintain bleed and crop requirements
- –External integration surface is limited for automated cover pipelines
- –Team governance lacks RBAC, provisioning controls, and audit log features
- –Automation depends more on internal repeatability than a public API
Independent cover designers
Batch-create consistent series cover variants
Faster variant production
Publishing prepress operators
Validate print-ready PDF exports
Fewer prepress corrections
Show 2 more scenarios
Small print production teams
Prepare covers with layered assets
Repeatable revision workflow
Layer and object organization simplifies controlled revisions before final output.
Brand designers
Maintain typography rules across covers
Consistent visual identity
Paragraph styles and formatting constraints keep brand typography consistent across editions.
Best for: Fits when individual designers or small teams need repeatable cover templates without external automation dependencies.
QuarkXPress
pro desktop layoutSupports professional page layout for cover publishing with styles, reusable elements, and automation tooling.
Scripting and templates for repeatable cover layouts using consistent master structures.
QuarkXPress is a professional desktop page layout tool used for print-ready and export-ready book cover production. It supports precise typography, CMYK and spot-color workflows, and export formats geared to production pipelines.
Automation is driven through scripting and template-driven layout structures that reduce repetitive cover assembly. Integration depth centers on file-based interchange with downstream prepress steps rather than a built-in cloud data model.
- +Production-grade color workflow with CMYK and spot-color control
- +Scripting supports repeatable cover assembly across template variants
- +High-fidelity typography controls for print-ready typographic layouts
- +Panel-based layout tools support precise bounding and alignment
- –Limited built-in integration depth for cover data exchange beyond files
- –API surface is not oriented around external schema-driven automation
- –Automation is stronger for layout reuse than for workflow orchestration
- –Governance controls for teams rely more on local process than RBAC
Best for: Fits when a design team needs controlled, print-focused cover layouts with repeatable templates.
Figma
design systemsEnables collaborative cover design with component libraries and automation through plugins and APIs.
Component sets and variants with libraries propagate cover-wide updates across multiple Figma files.
Figma performs collaborative book cover composition by combining vector tools, layout components, and style-driven typography in a single canvas. Integration depth comes from plugins, webhooks, and export pipelines that convert design artifacts into production-ready assets for covers, spines, and templates.
The data model centers on files, pages, frames, and reusable components with variant sets that support controlled updates across cover systems. Automation and extensibility rely on the Figma plugin API plus REST endpoints for programmatic reads, writes, and asset generation at high throughput.
- +Plugin API supports automated export workflows for cover assets
- +Component variants propagate typographic and layout changes across cover templates
- +Webhooks enable event-driven pipelines from file changes to downstream builds
- +REST endpoints provide programmatic access to files, nodes, and exports
- +Shared styles standardize cover typography across multi-page designs
- +RBAC in organizations enables role-gated access to files and libraries
- +Audit logs support review of administrative and workspace activity
- –Automation depends on plugin and REST patterns with manual permission setup
- –Complex component hierarchies can slow bulk edits and exports
- –Structured governance is stronger at org level than per-file fine-grain rules
- –Asset production still requires external tooling for print-ready preflight checks
Best for: Fits when publishing teams need governed design automation and API-driven cover asset production.
Sketch
vector designSupports vector cover design with symbol libraries and automation via third-party plugins and scripting.
Symbols and shared styles provide a strict design schema for scalable cover variants.
Sketch fits teams that need repeatable professional book cover design with controlled production settings and consistent typography. The workflow centers on a detailed design data model with layers, symbols, styles, and export formats that map cleanly to production outputs.
Integration depth depends on Sketch’s plugin system for automation and extensibility, plus interoperability via imported assets and export pipelines for layout delivery. API and automation coverage is primarily achieved through plugins that define custom tooling and batch actions around the document schema.
- +Layer and symbol model supports consistent cover variants and style reuse
- +Plugin extensibility enables automation around document structure and exports
- +Export pipeline maintains predictable output settings for print and digital formats
- +Style system reduces manual drift across typography and color choices
- –Automation relies heavily on plugin code instead of a dedicated external API
- –Governance controls like audit logs and RBAC are limited for enterprise administration
- –Batch operations can be constrained by plugin sandboxing boundaries
- –Cross-tool integration needs format conversions and manual workflow wiring
Best for: Fits when design teams standardize cover generation via templates and plugin-driven batch export.
CorelDRAW
vector productionProvides vector cover artwork creation with batch export workflows and scripting for repeatable production.
CorelDRAW scripting plus batch tools for repeatable, script-driven cover exports.
CorelDRAW is a vector-first design application that supports production-ready workflows for print covers using CMYK and spot-friendly export paths. It provides a data model centered on vector shapes, typography, and document styles, which helps keep cover typography and layout consistent across revisions.
Automation is practical through scripting and batch processing, but the integration surface is narrower than document-centric DAM ecosystems. Admin and governance controls are limited compared with enterprise design workflow systems that include RBAC, audit logs, and provisioning.
- +Vector editing with CMYK and spot-color export paths for print-grade covers
- +Reusable styles and master-like document structures support typographic consistency
- +Scripting enables repeatable cover layout generation and batch production runs
- –Automation APIs are less extensive than server-side design automation platforms
- –RBAC, provisioning, and audit logs are not geared for design governance
- –Integrations depend more on file-based handoff than schema-driven workflows
Best for: Fits when a studio needs local vector cover production with repeatable automation.
Gravit Designer
vector designSupports vector cover creation with libraries and export tooling for print-oriented outputs.
Layered vector editing with precise text handling for print-ready cover compositions.
Gravit Designer is a vector design application used for book cover production with typography and layout tools built into the editor. Its integration story is limited for admin and governance, since most work happens inside the desktop and web design workspace rather than through external workflow orchestration.
Automation is mainly indirect through file-based interchange and scripting options inside its ecosystem rather than a documented, task-scoped API surface for cover assembly. The data model centers on vector objects, text frames, and layers that export predictably to print formats used in publishing pipelines.
- +Vector-first workflow with layers and text objects for print-grade cover typography
- +Exports cover assets in common print formats for downstream imposition and prepress
- +Works across desktop and web editing sessions with project-level organization
- –Limited documented automation for cover variants and batch generation
- –Thin admin and governance controls such as RBAC and audit logging
- –API surface for schema-driven provisioning is not a primary integration path
Best for: Fits when solo or small workflows need vector covers with reliable exports.
Vectr
lightweight vectorProvides lightweight vector cover design with shared project collaboration features.
Layered vector editing for typography and graphic composition in repeatable book cover layouts
Vectr generates and edits professional book cover layouts with vector-first design tooling and export-ready outputs. Vectr’s data model centers on layered elements, typography, and page-level composition, which supports consistent cover variations.
Integration depth is limited to what the product exposes for importing assets and sharing documents, rather than a comprehensive automation surface. Automation and API capabilities are not presented as an explicit schema-driven interface for cover pipelines and governance workflows.
- +Vector-first layout with layers, shapes, and typography for consistent cover variants
- +Asset import and template-like workflows for reusing design components
- +Export outputs suitable for print-oriented cover production workflows
- –Document model is not exposed as a programmable schema
- –Automation and API surface for cover pipelines is not clearly documented
- –Admin governance controls like RBAC and audit logs are not clearly specified
Best for: Fits when designers need repeatable vector cover layouts without a programmatic pipeline.
Wix Studio
template publishingSupports cover artwork workflows through editable templates and asset management for publishing exports.
Component-driven design editing for reusable cover elements across variants.
Wix Studio fits teams that need a design system style workflow for book covers and other marketing assets inside Wix’s ecosystem. It focuses on visual layout and component-driven editing, with collaboration controls that live in Wix account management.
Integration depth is strongest within Wix properties, while external automation relies on Wix’s available developer interfaces and published data connectors. The practical governance model centers on role-based access in site workspaces, but audit and administration depth is less explicit than in enterprise DMS-style tools.
- +Component-driven layouts speed repeatable cover variants without rebuilding each design
- +Collaboration and publishing controls align with Wix site workspace workflows
- +Wix-centric integrations reduce handoff friction for assets used across Wix sites
- +Extensibility through Wix developer tooling supports automation around published content
- –External data model control is limited compared to schema-first design toolchains
- –Automation coverage depends on available Wix APIs and connector scope
- –Governance signals like audit log granularity are less transparent for reviewers
- –Cross-tool throughput can bottleneck when assets require manual export steps
Best for: Fits when teams want cover production inside Wix workflows with controlled publishing and collaboration.
How to Choose the Right Professional Book Cover Design Software
This buyer’s guide covers professional book cover design software across Canva, Adobe Express, Affinity Publisher, QuarkXPress, Figma, Sketch, CorelDRAW, Gravit Designer, Vectr, and Wix Studio.
The focus stays on integration depth, data model structure, automation and API surface, and admin and governance controls so cover pipelines can be controlled across editions and teams.
Book-cover design platforms built for repeatable production, not one-off artwork
Professional book cover design software combines typography, layout, and export control with reusable structure for recurring cover series. These tools reduce manual rework by keeping fonts, logo placement, and print output settings consistent across iterations and teams.
Tools like Canva and Adobe Express deliver brand kits and template-driven assembly for recurring cover variants, while Figma adds an API-driven path for programmatic export and event-driven pipelines.
Integration, data model, automation surface, and governance controls that affect cover pipelines
Cover production needs more than design editing because brand assets, variant rules, and output settings must stay consistent across teams and releases. The evaluation criteria below target integration breadth, data model structure, and automation control so cover generation can scale without manual drift.
Admin governance matters when multiple designers and publishers share templates, libraries, and export workflows, especially in tools that expose RBAC, audit logs, or clear provisioning controls.
Brand libraries or brand kits that enforce reusable typography and logo placement
Canva’s Brand Kit centralizes fonts, colors, and logo placement so cover variants inherit the same visual rules. Adobe Express uses brand asset libraries for recurring fonts, logos, and palette reuse, which reduces variance across editions.
Schema-like reuse through components, variants, and master structures
Figma’s component sets and variant libraries propagate typographic and layout changes across cover templates across multiple files. Affinity Publisher’s master pages plus text styles and QuarkXPress scripting and template structures keep front and spine typography repeatable across a cover series.
Programmatic automation via API, webhooks, and plugin-driven event flows
Figma provides a REST endpoint model plus webhooks that enable event-driven pipelines from file changes into downstream builds. Canva supports app integrations for importing assets and templating variants, but its metadata-driven cover generation is limited without external automation.
Deterministic print output configuration and export readiness control
Affinity Publisher emphasizes deterministic export settings to maintain bleed and crop requirements for print. QuarkXPress provides production-oriented export paths with CMYK and spot-color workflows for controlled prepress output.
Admin and governance controls with RBAC and audit logging
Figma includes RBAC at the organization level and audit logs for administrative and workspace activity, which supports controlled review cycles. Canva’s governance depth is weaker for policy control and lacks enterprise-style provisioning strength, and Sketch’s governance signals like audit logs and RBAC are limited for enterprise administration.
Extensibility that fits operational throughput and bulk variant generation
CorelDRAW scripting plus batch tools support repeatable, script-driven cover exports for studios running many revisions. Sketch relies more on plugin-based automation around its document schema, so automation throughput depends on plugin behavior and batch limits.
Pick the tool whose data model and automation surface match the way covers are produced
A good fit depends on whether cover work is templated and repeated at volume, or done as controlled production layout with deterministic export settings. The decision framework below matches integration depth, automation and API availability, and governance controls to the actual cover workflow.
The goal is to align brand enforcement, variant propagation, and admin controls so cover updates do not require manual rework across editions.
Map cover variants to reusable structure before comparing editors
If cover series rules must stay consistent across editions, start with Figma’s component variants or Affinity Publisher’s master pages plus text styles. Canva also helps by enforcing reusable typography, colors, and logo placement through Brand Kit across repeated designs.
Select integration depth based on whether automation must be programmable
If cover assets must be produced by an automated pipeline, prioritize Figma’s REST endpoints and webhooks plus plugin API for programmatic reads, writes, and exports. If automation stays within templates and internal repeatability, QuarkXPress scripting and template-driven layout structures can reduce repetitive assembly without external orchestration.
Validate print output control for your production requirements
For strict bleed and crop control, Affinity Publisher’s deterministic export settings are designed to maintain those print requirements. For production-grade color workflows with CMYK and spot-color control, QuarkXPress supports production pipelines more directly than editors focused on file exchange.
Check governance controls for shared templates and libraries
For multi-user publishing environments that require role-based access and traceability, use Figma’s organization-level RBAC and audit logs. For team collaboration without deep enterprise governance, Canva’s comment workflows and version history can cover review cycles but provide weaker policy and provisioning controls.
Stress test batch throughput for the exact variant volume and timing
For studios generating many revisions, CorelDRAW scripting plus batch tools support repeatable, script-driven cover exports. For template-driven batch work where automation relies on extensions, Sketch can work if plugin code covers the needed batch actions within its document model.
Which teams benefit from each cover design approach
Different cover workflows demand different levels of templating, automation control, and governance. The segments below map directly to the published best-for fit for each tool.
The right selection reduces manual correction by matching the tool’s reuse mechanism and automation surface to how covers are iterated and approved.
Publishing teams that need API-driven, event-based cover asset generation
Figma fits because it exposes a plugin API with REST endpoints for programmatic access and webhooks for event-driven pipelines from file changes to downstream builds. The component set and variant libraries also propagate typographic and layout changes across cover templates at scale.
Teams that run recurring cover programs with strict brand rules and repeatable templates
Adobe Express fits because brand asset libraries support recurring fonts, logos, and palette reuse while templates reduce variance across editions. Canva also fits when teams need cover throughput and consistent output using Brand Kit plus reusable design assets.
Designers and small teams that need print-focused deterministic layout exports without external automation dependencies
Affinity Publisher fits because master pages and text styles keep front and spine typography consistent and deterministic export settings help maintain bleed and crop requirements. QuarkXPress fits when production-grade CMYK and spot-color workflows plus scripting and templates matter more than external integration.
Studios that prioritize local vector production with repeatable exports
CorelDRAW fits because vector editing supports CMYK and spot-friendly export paths and scripting plus batch tools support repeatable production runs. Gravit Designer and Vectr fit when vector covers and layered typography are needed for reliable exports, but they provide weaker programmable automation and governance signals.
Teams producing covers inside Wix-based publishing workflows
Wix Studio fits teams that want component-driven layout editing inside Wix properties with collaboration and publishing controls in Wix account and site workspace workflows. External automation remains limited to what Wix developer interfaces and connectors support.
Mistakes that break cover consistency, governance, or automation throughput
Cover tools fail in predictable ways when the evaluation ignores governance depth, output configuration control, or the automation surface needed for variant generation. The pitfalls below are mapped to recurring limitations across the reviewed tools.
Corrective actions target concrete capabilities like RBAC, audit logs, deterministic exports, and schema-like reuse mechanisms.
Choosing a design editor without a governed way to reuse fonts, logos, and palette rules
Avoid tools that only share assets through manual copy when cover programs require enforced consistency. Prefer Canva’s Brand Kit or Adobe Express brand asset libraries so typography and logo placement propagate through variants.
Assuming templates alone replace API automation for bulk variant pipelines
Avoid expecting metadata-driven cover generation without an external automation path. Figma supports programmatic pipelines with REST endpoints and webhooks, while Canva’s metadata-driven generation stays limited without outside automation.
Underestimating print output configuration risk during production onboarding
Avoid skipping a print-spec check for export settings because manual verification can be required in tools with weaker output configuration control. Affinity Publisher emphasizes deterministic export settings for bleed and crop, while QuarkXPress supports production-grade CMYK and spot-color workflows.
Selecting a collaborative tool without checking RBAC, audit logs, and provisioning strength
Avoid relying on collaboration features when governance needs include role-gated access and administrative traceability. Figma includes organization-level RBAC and audit logs, while Canva’s governance depth and Sketch’s enterprise governance controls are weaker for provisioning and audit needs.
Overcomplicating component hierarchies and variants before bulk exporting
Avoid deep component structures that slow bulk edits and exports. Figma can generate assets through variants, but complex component hierarchies can slow bulk operations, so keep the variant model structured for throughput.
How We Selected and Ranked These Tools
We evaluated each tool on feature coverage for cover layout and reuse, ease of use for operating the cover workflow, and value for fitting recurring production needs. We also prioritized automation and integration behavior because cover programs usually require repeatable variant generation and controlled output. Overall scoring treated features as the biggest driver, and ease of use and value each contributed the same secondary influence on the final result.
Canva separated itself from lower-ranked options by pairing Brand Kit with reusable typography, colors, and logo placement and by delivering high ease of use for repeatable cover production. That combination raised its feature fit for brand-consistent throughput and helped it land near the top overall because it keeps repeatable design structure inside the editor.
Frequently Asked Questions About Professional Book Cover Design Software
Which tool best supports API-driven cover asset production at high throughput?
How do Canva and Adobe Express handle brand consistency across multiple cover editions?
What is the main tradeoff between Figma and Affinity Publisher for repeatable cover templates?
Which desktop workflow fits when print production requires CMYK and spot-color control?
Which tool is better suited for automation via scripting rather than broad external integrations?
How do admin controls and governance differ between CorelDRAW and collaboration-first tools?
What are common data migration issues when moving cover templates between tools?
Which tool supports the strongest component and symbol-based schema for scalable cover variants?
What integration limitations appear for Gravit Designer and Vectr in automated cover pipelines?
Which tool is best for building cover design workflows inside Wix ecosystems?
Conclusion
After evaluating 10 art design, Canva stands out as our overall top pick — it scored highest across our combined criteria of features, ease of use, and value, which is why it sits at #1 in the rankings above.
Use the comparison table and detailed reviews above to validate the fit against your own requirements before committing to a tool.
Tools reviewed
Primary sources checked during evaluation.
Referenced in the comparison table and product reviews above.
Keep exploring
Comparing two specific tools?
Software Alternatives
See head-to-head software comparisons with feature breakdowns, pricing, and our recommendation for each use case.
Explore software alternatives→In this category
Art Design alternatives
See side-by-side comparisons of art design tools and pick the right one for your stack.
Compare art design tools→FOR SOFTWARE VENDORS
Not on this list? Let’s fix that.
Our best-of pages are how many teams discover and compare tools in this space. If you think your product belongs in this lineup, we’d like to hear from you—we’ll walk you through fit and what an editorial entry looks like.
Apply for a ListingWHAT THIS INCLUDES
Where buyers compare
Readers come to these pages to shortlist software—your product shows up in that moment, not in a random sidebar.
Editorial write-up
We describe your product in our own words and check the facts before anything goes live.
On-page brand presence
You appear in the roundup the same way as other tools we cover: name, positioning, and a clear next step for readers who want to learn more.
Kept up to date
We refresh lists on a regular rhythm so the category page stays useful as products and pricing change.