GITNUXSOFTWARE ADVICE
Art DesignTop 8 Best Origami Design Software of 2026
Top 10 Origami Design Software ranked for folding workflows and modeling support, with software comparisons for creators using Blender or Tinkercad.
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.
Blender
Python scripting controls scene state and can run headless batches for crease and fold validation.
Built for fits when studios need script-driven origami generation with automated fold simulation testing..
Fusion 360
Editor pickParametric timeline and component model enable regeneration and rule enforcement via Autodesk scripting APIs.
Built for fits when engineering teams need API-driven parametric workflow automation for origami-like parts..
Tinkercad
Editor pickIn-browser 3D modeling that generates exportable models for folding and physical testing.
Built for fits when small teams need visual fold-ready prototypes without code-based automation..
Related reading
Comparison Table
The comparison table maps Origami Design Software tools across integration depth, including data model compatibility and how each platform exposes files, parameters, and geometry to external systems. It also contrasts automation and API surface, focusing on schema and configuration options, provisioning workflows, and the extent of extensibility for repeatable generation. Admin and governance controls are compared via RBAC coverage, audit log availability, and how sandboxing limits execution risk for team workflows.
Blender
API-first 3DA 3D creation suite with a programmable Python API that supports scripted mesh generation and foldable geometry workflows.
Python scripting controls scene state and can run headless batches for crease and fold validation.
Blender supports origami modeling through polygon mesh editing, subdivision and deformation modifiers, and rig-style workflows that can represent flaps and hinge behavior. Fold validation can be tested with rigid body dynamics, soft body simulation, and constraint systems, which helps catch collisions and binding points during design iteration. Extensibility is practical for production pipelines because Blender automation is exposed through a Python API that can read and write scene state, generate geometry, and run headless batch jobs for repeatable outputs.
A tradeoff appears in governance and schema management because Blender’s automation surface is script-first rather than schema-first, so enforcing a strict design data model requires custom conventions. Blender fits when a studio needs high integration depth with versioned Python tooling and a repeatable geometry generation pipeline, not when a centralized admin console and RBAC are required. For teams that maintain their own data schema and testing harness, Blender can deliver high throughput for batch crease pattern generation and simulation-driven verification.
- +Python API enables repeatable origami geometry generation and batch rendering.
- +Modifiers and constraints support fold logic and collision checks during design iteration.
- +Scene and object hierarchy enables structured configuration of complex fold assemblies.
- –No built-in RBAC or org-level governance for multi-user design control.
- –Data model enforcement relies on conventions and custom validators, not native schemas.
Architecture studios and parametric fabrication teams
Generate crease patterns and export fold-ready meshes for CNC-ready fabrication drawings.
Repeatable fabrication-ready mesh outputs for each design variant without manual rework.
3D animation and visualization teams
Produce fold animations that match physical motion for product packaging and interactive demos.
Consistent fold motion across variants with fewer iteration cycles caused by manual keyframing.
Show 2 more scenarios
Simulation engineers in small pipelines
Validate that designed folds avoid self-intersection and hinge binding under motion constraints.
Faster elimination of crease layouts that fail due to collisions or binding during folding.
Blender’s physics and constraint systems support collision detection and motion constraints during iterative testing. A Python harness can automate simulation runs and capture failure cases for comparison.
Tooling teams building internal authoring workflows
Integrate Blender into an internal origami authoring service that generates designs from structured inputs.
Higher integration breadth through standardized automation calls and repeatable scene builds.
Blender can be orchestrated through Python to load templates, construct scenes, and apply transformations from external configuration files. Teams can implement their own schema, validation, and audit logging around the script runner to control governance.
Best for: Fits when studios need script-driven origami generation with automated fold simulation testing.
Fusion 360
CAD APIA CAD and CAM system that supports API automation for generating origami-related sketches, surfaces, and assemblies.
Parametric timeline and component model enable regeneration and rule enforcement via Autodesk scripting APIs.
Fusion 360 fits teams that need an end-to-end origami-to-CAD-to-fabrication path with repeatable design intent. The core data model is built around component hierarchies, parametric parameters, and a timeline that can be interrogated or regenerated through automation. Documented surfaces for automation include scripting hooks and an add-in style extension approach, which supports configuration-driven tasks like generating fold patterns from parameters.
A tradeoff appears in governance for large multi-team environments, because RBAC granularity and audit log depth are tied to the Autodesk account layer rather than being fully exposed at the design object level. Fusion 360 is a strong match when a small engineering team needs higher configuration throughput than manual CAD edits, like creating families of crease patterns and exporting consistent manufacturing deliverables.
- +Parametric timeline keeps fold geometry tied to editable design intent
- +API and add-in automation enable parameterized model and rule checks
- +Component hierarchy supports structured handoff between design and manufacturing
- +Simulation and manufacturing workflows reduce geometry-to-process rework
- –Admin governance and audit detail depend on account-level controls
- –Deep orchestration across many projects can require custom automation glue
- –Data model constraints can make cross-design schema mapping nontrivial
Industrial design studio teams
Maintaining a consistent series of fold layouts across a product line
Reduced manual rework and faster approval cycles for geometry variants.
Manufacturing engineering teams
Translating crease patterns into fabrication-ready outputs with repeatable operations
Lower risk of mismatched designs and fabrication instructions.
Show 2 more scenarios
Robotics and prototyping groups
Rapid iteration of mechanisms that require precise fold clearances and constraints
Fewer failed builds caused by invalid fold geometry.
Fusion 360 modeling supports iterative constraint-driven edits that maintain a traceable timeline of changes. Simulation and automation checks can validate geometry behavior and catch invalid configurations early in the workflow.
Enterprise CAD operations teams
Provisioning controlled design workflows with policy enforcement
More consistent outputs across teams through automated policy gates.
Fusion 360 extensibility via API and automation supports configuration-driven checks such as required parameters, approved template components, and export format validation. Governance controls rely on account-level RBAC patterns, so policy enforcement typically combines admin settings with automation guards inside the design workflow.
Best for: Fits when engineering teams need API-driven parametric workflow automation for origami-like parts.
Tinkercad
browser CADA browser-based modeling tool that supports constructive workflows for designing origami-style physical parts and exportable meshes.
In-browser 3D modeling that generates exportable models for folding and physical testing.
Tinkercad centers on a visual data model where users assemble primitives and edit features through an interactive workspace, then export models for downstream use. Integration depth is mostly file-based through exports rather than a documented API surface for model provisioning, programmatic edits, or geometry queries. Automation options are constrained to user-driven creation and sharing flows, with minimal extensibility for batch generation or rule-based fold logic.
A key tradeoff appears in governance and admin controls, since the workspace does not offer enterprise-style RBAC granularity, audit log export, or configuration management for large teams. Tinkercad fits instructors and small maker groups that need rapid folding prototypes and visual iteration without code-heavy automation or formal orchestration.
- +Browser editor enables fast shape iteration without local CAD setup
- +Primitive-based modeling supports quick geometric experimentation
- +Export workflows support physical mockups and basic downstream processing
- –Limited documented API reduces automation and batch geometry generation
- –Model structure favors visual editing over an explicit origami data schema
- –Minimal enterprise governance features like detailed RBAC and audit log export
Education teams and classroom instructors
Assign fold-ready model exercises with in-browser editing and exportable deliverables
More consistent class outcomes due to a shared visual workflow and easy exports.
Independent makers and small design studios
Prototype origami-inspired structures by iterating primitives and testing physical folds
Shorter iteration loops because model changes occur in real time.
Show 2 more scenarios
Teams building lightweight digital-to-physical product demos
Generate simple foldable parts for demos without integrating a full PLM or automation layer
Faster demo preparation because the pipeline stays file-driven.
Teams can rely on exports for handoff into downstream tools that handle slicing, templates, or assembly instructions. Limited API availability keeps integration overhead low but reduces programmatic control.
IT and operations teams supporting shared creative workspaces
Centralize access and track changes across multiple contributors
Reduced admin overhead for small groups, with limited governance depth for regulated workflows.
Administration relies more on account-level sharing patterns than on granular RBAC, schema enforcement, or external audit log export. Change tracking and policy enforcement are therefore constrained for compliance-heavy environments.
Best for: Fits when small teams need visual fold-ready prototypes without code-based automation.
Adobe Illustrator
vector patternA vector graphics editor with scripting support for generating crease patterns and cut lines as layered vector assets.
ExtendScript and JavaScript document scripting for repeatable vector edits and export sequences.
Adobe Illustrator supports precise vector illustration workflows with a document model built around artboards, layers, and editable vector objects. Integration depth is strongest through export and interoperability with Adobe ecosystems, including PDF, SVG, and layered formats designed for downstream placement.
Automation and extensibility are primarily driven by Adobe scripting with JavaScript and ExtendScript, plus template reuse through document styles and controlled asset libraries. Governance controls are limited compared with enterprise software categories because Illustrator centers on file-based work rather than centralized schema, provisioning, RBAC, or audit logging.
- +Artboard and layer structure maps cleanly to SVG and PDF outputs
- +JavaScript scripting and ExtendScript enable repeatable document transformations
- +Vector editing stays lossless through native formats and PDF workflows
- +Extensive import filters support common brand asset formats
- –No enterprise-grade RBAC or centralized provisioning for teams
- –Minimal API surface for external systems beyond file and script workflows
- –Audit logs and change tracking require external process design
- –Automation throughput depends on scripting discipline per repository
Best for: Fits when design teams need scriptable vector production and predictable export pipelines.
OpenSCAD
code modelingA code-driven modeling tool that uses a declarative data model to script origami-inspired folds and tessellations.
Deterministic headless rendering from parametric scripts to produce many variant crease patterns.
OpenSCAD renders parametric origami and fold-pattern geometry using a script-first workflow with a declarative modeling language. The data model is code-as-source where parameters, transformations, and derived face layouts are computed at render time.
Integration depth is limited because OpenSCAD does not present a service-grade project schema with first-party import export pipelines for origami-specific assets. Automation and extensibility rely on scripting the OpenSCAD toolchain, so API surface is thin compared with platforms that expose workflow orchestration endpoints.
- +Scripted parameters generate repeatable fold geometry from the same source
- +Deterministic geometry output supports regression checks in version control
- +Extensible via OpenSCAD language functions and external include files
- +Headless rendering supports batch generation for many pattern variants
- –No documented origami-specific data schema for face, crease, and patterns
- –Automation lacks a first-party REST API for workflow provisioning and control
- –RBAC, audit logs, and governance controls are not part of the core workflow
- –Interoperability depends on manual import and export through generic formats
Best for: Fits when solo or small teams need code-driven origami generation with batch rendering.
SketchUp
modeling scriptsA modeling platform with Ruby scripting support for generating paper-like surfaces and foldable assemblies.
SketchUp SDK supports extension development for geometry tools and custom export pipelines.
SketchUp supports origami-style modeling through native geometry tools, subdivision-style workflows, and accurate mesh edits for creases and faces. For integration depth, it relies heavily on file exchange formats and the Trimble ecosystem rather than a formal public API for origami-specific operations.
Extensibility is mainly achieved through the SketchUp SDK and community-developed extensions that add tools, validators, and export pipelines. For automation and governance, the model is document-based, while admin controls and audit logs depend on how SketchUp content is managed in connected services.
- +SketchUp SDK enables custom modeling tools and scripted geometry operations
- +Strong extension ecosystem for export automation and format conversion
- +Document-based data model supports repeatable component workflows
- +Trimble ecosystem options support collaboration and asset management
- –Limited public API surface for direct origami-specific automation
- –Governance controls rely on connected services rather than core RBAC
- –Automation granularity is constrained by document-centric architecture
- –Audit logging coverage varies with external collaboration setup
Best for: Fits when teams need repeatable paper-folding geometry workflows with extension-driven automation.
Vectary
web 3d designA browser-based 3D design and simulation workspace that supports parametric scene edits and exportable assets suitable for folding-pattern prototyping workflows.
Graph-based model linking fold constraints to editable 3D elements
Vectary positions origami design around a structured 3D-to-fold workflow that keeps geometry, constraints, and materials attached to a single model. Integration depth is strongest when design assets need to flow into pipelines via its import and export paths and scripted handling of model data.
The data model centers on a design graph that links fold logic to editable scene elements, which makes schema-driven automation feasible. Extensibility and governance depend on the availability and coverage of Vectary’s documented API and automation hooks across projects and assets.
- +Model graph keeps geometry, crease logic, and scene assets linked
- +Export pipelines support downstream rendering and fabrication review
- +APIs and automation hooks support integration into design tooling
- –Automation coverage can be uneven across project, asset, and fold operations
- –Schema and data mapping work can require custom handling per workflow
- –Admin governance controls may lag behind enterprise needs like RBAC granularity
Best for: Fits when teams need repeatable origami folding models with integration into existing design pipelines.
Houdini
procedural modelingNode-based procedural modeling software used for parametric origami-like fold logic via expressions, custom tools, and automated geometry generation.
Attribute-centric geometry data model with programmable node networks for repeatable parametric builds.
Houdini is a node-based origami and procedural design environment centered on a parametric geometry pipeline. Its integration depth comes from tightly coupled Python scripting, HScript interfaces, and extensible node networks that carry parameters through transforms, constraints, and remeshing steps.
The data model is built around geometry streams and node parameters, which supports schema-like consistency via consistent node inputs, attributes, and naming conventions. Automation and API surface are strongest for repeatable builds using scripted graph edits, batch processing, and custom tools that register into existing workflows.
- +Procedural node graph passes parameters across modeling, constraints, and remeshing steps
- +Python scripting supports automated graph edits and batch geometry generation
- +Custom node tooling enables extensibility inside established Houdini workflows
- +Attribute-based geometry data model supports structured downstream operations
- +Batch and headless execution supports high throughput renderless preprocessing
- –Graph complexity can hinder governance and change control across teams
- –RBAC and audit logging are not a first-class part of the authoring workflow
- –Automation often relies on internal conventions for nodes, parameters, and attribute names
- –Versioning large node graphs can increase merge conflicts in collaboration
Best for: Fits when teams need procedural origami automation with scripting control over geometry attributes.
How to Choose the Right Origami Design Software
This buyer’s guide covers eight origami design tools: Blender, Fusion 360, Tinkercad, Adobe Illustrator, OpenSCAD, SketchUp, Vectary, and Houdini. The guide focuses on integration depth, data model design, automation and API surface, and admin and governance controls across these tools.
Each section maps tool mechanics to evaluation checkpoints like schema enforcement, extensibility hooks, RBAC and audit log capabilities, and repeatable generation via scripting or node graphs. The guide also calls out common failure points seen when teams rely on file-only workflows or lack centralized governance.
Evaluation criteria for integration, data modeling, automation, and governance
Origami design work breaks down when the tool cannot express fold logic in a structured model that external systems can validate or extend. Integration depth matters when pipelines need deterministic exports, linked scene graphs, or parameterized regeneration across versions.
Automation and API surface also determine whether batch crease generation, fold validation, or rule enforcement can run without manual steps. Admin and governance controls control access, traceability, and change auditing when multiple designers or projects share the same content.
Scripted generation with repeatable geometry outputs
Blender provides a Python API that can generate crease patterns and run headless batches for fold validation. OpenSCAD provides deterministic headless rendering from parametric scripts so regression checks can run through version control.
Data model structure that ties fold logic to editable parameters
Fusion 360 uses a parametric timeline and a component hierarchy so regenerated fold-like parts stay tied to editable design intent. Houdini carries parameters through node networks into geometry streams so attributes and constraints remain consistent across preprocessing steps.
Graph or scene model linking geometry to fold constraints
Vectary uses a graph-based model that links fold constraints to editable 3D elements so automation can target a connected model state. Blender uses scene and object hierarchy plus modifiers and constraints so complex fold assemblies stay organized during iteration.
API and automation hooks beyond file-based workflows
Fusion 360 centers extensibility on an API for scripting and add-ins that can enforce workflow checks. Blender relies on Python scripting hooks and headless batch runs for automation, while OpenSCAD relies on scripting the toolchain for batch generation.
Admin governance with RBAC and audit log coverage
Houdini lacks first-class RBAC and audit logging inside the authoring workflow, which makes team governance depend on conventions outside the core tool. Blender also lacks built-in RBAC or org-level governance, while Adobe Illustrator centers on file-based work with limited enterprise governance and audit mechanisms.
Interoperability paths that support downstream placement and validation
Adobe Illustrator maps artboard and layer structures cleanly to export formats like SVG and PDF, and ExtendScript plus JavaScript scripting enables repeatable export sequences. Tinkercad supports exportable models for physical mockups, but it has limited documented API and minimal enterprise governance features.
Decision framework for selecting an origami design tool that fits pipelines and teams
Start with the tool’s automation surface and its ability to regenerate fold geometry from a structured model state. Then verify whether the data model and exports match how downstream systems need to validate or consume the design.
Finally, confirm governance gaps early by checking whether RBAC and audit logging exist as first-class capabilities or whether governance depends on external process and conventions. Blender and OpenSCAD support repeatable batch validation, but governance controls and schema enforcement differ from CAD-centric tools like Fusion 360.
Map the required automation to a concrete scripting or API mechanism
If batch crease and fold validation needs to run headlessly, Blender can execute Python scripting in batch workflows and run fold validation loops. If parameterized regeneration and rule checks must integrate into engineering workflows, Fusion 360 offers an API and add-ins that can enforce checks tied to the parametric timeline.
Choose a data model that can carry fold intent across edits
For parameter-first regeneration where edits must preserve design intent, use Fusion 360’s parametric timeline and component model. For attribute-centric procedural builds, use Houdini’s geometry streams and node parameters so constraints and remeshing steps stay in a consistent attribute pipeline.
Match the tool’s schema and graph linking to integration goals
When automation must target a connected model state, choose Vectary because it links fold constraints to editable 3D elements through a design graph. When fold assemblies must be organized into structured scene hierarchies, choose Blender because scenes and object hierarchies support repeatable complex assemblies.
Check governance and traceability requirements before committing
If multi-user design control needs RBAC and audit log coverage inside the authoring tool, Fusion 360’s account-level controls are the primary governance path rather than project-internal schemas. If RBAC and audit logs must be first-class and native, Blender and Houdini both lack built-in RBAC and audit logging, so governance will rely on external systems and conventions.
Align export formats and scripting to downstream asset review
If the workflow centers on vector crease and cut lines for predictable placement, Adobe Illustrator provides layer and artboard structure and ExtendScript plus JavaScript scripting for repeatable export sequences. If the workflow centers on quick physical prototypes and simple export for folding tests, Tinkercad offers in-browser modeling that exports fold-ready models but has limited documented API and schema-level integration.
Which teams benefit from each origami design approach
Different origami workflows demand different mechanisms for automation, data structure, and governance. Tool fit depends on whether fold logic is scripted, procedural, CAD-timeline parametric, or graph-linked to editable constraints.
Blender and Houdini fit teams that treat fold design like a build pipeline. Fusion 360 fits engineering teams that need API-driven parametric regeneration linked to manufacturing and simulation handoffs.
Studios that run script-driven crease and fold validation
Blender fits when repeatable geometry generation and headless validation loops matter, because Python scripting can run batch crease and fold checks. OpenSCAD also fits when deterministic headless rendering supports regression checks from parametric scripts.
Engineering teams that require parametric regeneration and API add-ins
Fusion 360 fits when foldable parts must stay tied to editable design intent through a parametric timeline and component hierarchy. Its API and add-in automation supports parameterized model generation and workflow rule enforcement.
Design teams that need vector-first crease and cut production
Adobe Illustrator fits when teams generate crease patterns and cut lines as layered vector assets for predictable exports. ExtendScript and JavaScript document scripting supports repeatable vector transformations and export sequences.
Teams that need procedural pipelines with attribute-driven geometry builds
Houdini fits when the workflow centers on node-based procedural modeling, parameter propagation, and geometry attribute pipelines. Its Python scripting supports automated graph edits and batch geometry generation even when governance depends on external control.
Teams building origami models inside existing design pipelines
Vectary fits when origami folding models must integrate through its import and export paths and when automation needs to target fold constraints linked to editable scene elements. Its model graph can make schema-driven automation feasible, though governance depth can lag enterprise RBAC granularity.
Pitfalls that cause failed integrations or ungoverned origami workflows
A common failure is choosing a tool that can only work through file editing when the workflow needs automation, regeneration, and traceability. Another common failure is assuming schema enforcement exists natively when the tool relies on conventions and external validation.
Governance gaps also surface when teams expect first-class RBAC and audit logs inside the authoring tool, even when the tool is primarily document-based or procedural without native org-level controls.
Assuming built-in RBAC and audit logs exist for team governance
Blender lacks built-in RBAC or org-level governance, and Houdini also lacks first-class RBAC and audit logging inside the authoring workflow. Fusion 360 depends on account-level controls for governance detail, so governance design must be planned around the tool’s actual control points.
Selecting a vector-only or file-first tool for parameterized fold regeneration
Adobe Illustrator can script vector exports, but it centers on artboards, layers, and file-based work rather than centralized origami schema or enterprise provisioning. Tinkercad supports quick modeling and exports, but limited documented API and minimal governance features reduce automation depth.
Overestimating schema enforcement and cross-design mapping between projects
Blender enforces data structure mainly via scene and object hierarchy conventions plus custom validators rather than native schemas. Fusion 360’s data model constraints can make cross-design schema mapping nontrivial, so integration pipelines should plan explicit mapping logic between designs and components.
Using code-driven tools without a governance and merge strategy for artifacts
OpenSCAD provides deterministic headless rendering, but it lacks an origami-specific data schema and lacks first-party REST API for workflow provisioning and control. Houdini node graphs can increase merge conflicts, so versioning and change control rules must be defined for large procedural graphs.
How We Selected and Ranked These Tools
We evaluated Blender, Fusion 360, Tinkercad, Adobe Illustrator, OpenSCAD, SketchUp, Vectary, and Houdini using a consistent scoring model across features, ease of use, and value. We rated each tool as an editorial synthesis of how it supports origami-like fold workflows through its named automation surfaces, such as Blender’s Python API and Fusion 360’s API and add-in automation, and how well teams can structure designs via its stated data model.
We used a weighted average that gives features the most weight, followed by ease of use and value, with features carrying the heaviest influence on the final ranking. Blender separated from lower-ranked tools because Python scripting can generate crease and fold geometry and can run headless batch validation, which directly lifts both features coverage and automation throughput.
Frequently Asked Questions About Origami Design Software
Which tools provide an API or scripting interface for automating crease-pattern generation?
How do Blender and Houdini differ when mapping fold constraints into repeatable workflows?
Which tool is better for origami-like parametric control using a declarative data model?
What is the main tradeoff between using a code-first tool like OpenSCAD versus a visual editor like Tinkercad?
Which tools integrate best into existing design pipelines via import or export pathways?
Do any tools support enterprise-style RBAC, provisioning, and audit logging for admin governance?
How does Extensibility work in practice across Blender, SketchUp, and Illustrator?
When teams need to run automated validation over many crease variants, which setup fits best?
What common workflow problem appears when importing origami-like assets across tools?
Conclusion
After evaluating 8 art design, Blender 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.