GITNUXSOFTWARE ADVICE
Food NutritionTop 10 Best Recipe Conversion Software of 2026
Ranked top 10 recipe conversion software tools, with technical criteria and tradeoffs for converting recipes, including Edamam and Spoonacular.
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
Mealie is the best overall pick for teams that want repeatable, local recipe conversion with serving scaling and clean manual corrections, while meez is the cheapest entry for getting incoming formats into standardized kitchen outputs, and CalcMenu fits food teams needing controlled scaling with consistent units and allergen-safe nutrition across menu variants.
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
Mealie
Self-hosted recipe import and editing workflow that preserves converted records inside a local recipe library.
Built for fits when a team needs repeatable local recipe conversions with serving scaling and manual correction..
CalcMenu
Editor pickAllergen flag propagation tracks declared ingredients through scaling and unit conversion without forcing duplicate recipe maintenance.
Built for fits when food teams need controlled recipe scaling with consistent allergens and units across multiple menu variants..
MenuCalc
Editor pickBaker’s percentage output ties ingredient amounts to a flour-based reference for repeatable formula conversions.
Built for fits when baker’s percentage and UOM conversions must stay consistent across production runs..
Comparison Table
Mealie
open sourceSelf-hosted recipe manager with automatic scaling and serving-size adjustment.
Self-hosted recipe import and editing workflow that preserves converted records inside a local recipe library.
Mealie’s conversion workflow is centered on importing recipes into its internal recipe records, then normalizing ingredients and directions into an editable format. Converted recipes can be saved as repeatable entries with versioned updates through the normal edit flow. Serving size changes drive quantity recalculation across ingredient lines so the recipe stays usable after conversion. Support for data extraction depends on the source format in each import, which means some pages convert cleanly while others require manual cleanup.
A practical tradeoff is that Mealie’s conversion quality is tied to how consistently a given recipe source follows common markup patterns. Mealie fits situations where a team wants a local recipe store and recurring scaling, not an all-in API-first conversion pipeline that maps to external nutrition and compliance datasets. A common usage situation is importing a batch of family recipes, editing ingredient lines once, and then using serving scaling for week-to-week meal planning.
- +Self-hosted imports keep converted recipe data under direct admin control
- +Servings scaling recalculates ingredient quantities after conversion
- +Imported recipes remain editable for consistent internal formatting
- +Recipe library management supports repeated reuse of converted content
- –Conversion accuracy varies by source markup and often needs manual ingredient fixes
- –Automation and external API workflows are less central than in conversion-first vendors
Home cooks and small households
Import personal blog recipes for scaling
Fewer manual recalculations
Kitchen managers
Standardize team recipes from mixed sources
More consistent prep output
Show 1 more scenario
Small catering teams
Scale converted recipes for different headcounts
Faster headcount adjustments
Serving updates drive ingredient quantity changes across converted recipe records for each customer batch.
Best for: Fits when a team needs repeatable local recipe conversions with serving scaling and manual correction.
CalcMenu
enterpriseProfessional recipe management platform with multi-level scaling, unit conversion, and nutritional analysis for foodservice operations.
Allergen flag propagation tracks declared ingredients through scaling and unit conversion without forcing duplicate recipe maintenance.
CalcMenu is built around repeatable recipe transformations, including yield adjustments and conversion-ready ingredient lists. Unit-of-measure normalization helps keep conversions consistent when sources mix grams, cups, and count-based measures. Allergen flag propagation supports downstream outputs that must retain declared allergen intent during scaling.
A key tradeoff is that complex nutrition and label requirements depend on how ingredient mappings and rounding rules are modeled in the workflow. CalcMenu fits best when a team needs predictable conversion outputs for multiple menu variations and wants fewer manual edits after recipe updates.
- +Unit conversions stay consistent across scaled outputs with clear normalization
- +Allergen flags carry through scaling and ingredient list transformations
- +Subrecipe reuse reduces duplicated work across related menu items
- +Versioned recipe outputs help control downstream changes
- –Advanced nutrition and rounding behavior needs careful setup to match requirements
- –Multi-location variance workflows can require more manual reconciliation than expected
- –Deep POS or ERP automation depends on external integration paths
- –Complex ingredient mapping increases configuration time
Menu ops teams
Scale recipes for seasonal menu changes
Fewer manual corrections
Recipe developers
Standardize unit formats for production
Lower conversion errors
Show 2 more scenarios
Kitchen production managers
Maintain yield across batch runs
More predictable batch outputs
Yield factor calculation supports batch yield reconciliation when servings and batch size shift.
Nutrition and compliance teams
Keep ingredient lists aligned after edits
Controlled documentation updates
Recipe versioning helps ensure nutrition and label inputs reflect the intended revision.
Best for: Fits when food teams need controlled recipe scaling with consistent allergens and units across multiple menu variants.
MenuCalc
SMBRecipe analysis tool for nutritional labeling and scaling.
Baker’s percentage output ties ingredient amounts to a flour-based reference for repeatable formula conversions.
MenuCalc is designed around a repeatable conversion flow that takes an input recipe, applies a yield or servings change, and returns adjusted ingredient amounts. It handles ingredient density lookup and unit-of-measure normalization to reduce errors when ingredients move between volume, weight, and count-based measures. It also provides baker’s percentage conversion for recipes that use a flour-based reference point instead of simple servings. The UI supports rapid iteration so teams can compare outputs for different target yields without rebuilding the calculation each time.
A key tradeoff is that MenuCalc’s conversion engine is best at deterministic scaling, so edge cases like ingredient substitutions and policy-driven HACCP rounding often require extra input discipline. The strongest usage situation is when a production team needs consistent yield factor calculation for the same recipes across shifts or locations. Another fit signal is the emphasis on unit normalization and percent-based outputs, which matches kitchens that document recipes in multiple measurement styles.
- +Unit-of-measure normalization reduces conversion mistakes across weight and volume.
- +Baker’s percentage conversion supports formula-style recipe documentation.
- +Scaling workflow supports quick recalculation for target servings and yields.
- +Density-aware handling improves conversions for ingredient-heavy recipes.
- –Does not replace substitution planning for inventory or menu changes.
- –HACCP-compliant rounding needs consistent input and careful settings use.
Bakery operations teams
Scale formulas by target batch size
Consistent batch preparation
Recipe data coordinators
Convert UOM across recipe documentation
Fewer unit reconciliation errors
Show 1 more scenario
Menu planning staff
Estimate servings for promotions
Repeatable yield planning
Scales quantities from a base recipe to projected servings with density-aware conversions.
Best for: Fits when baker’s percentage and UOM conversions must stay consistent across production runs.
Paprika Recipe Manager
consumerRecipe manager with ingredient scaling, unit conversion, and serving-size adjustment across desktop and mobile platforms.
Interactive recipe import that prioritizes editability of parsed ingredients and instructions before downstream scaling.
Paprika Recipe Manager focuses on converting recipes from web sources into editable, structured recipes with a workflow built around meal prep and ingredient reuse. It imports recipe pages, lets users correct parsing errors, and stores recipes in a local library designed for scaling and serving-size adjustments.
Conversion output stays controllable through manual ingredient and instruction edits, plus ingredient normalization inside the editor. Compared with API-driven conversion tools, Paprika relies on an interactive import and refinement loop rather than automated, API-first ingredient mapping.
- +Web recipe import turns messy HTML into editable ingredient and step lists
- +Recipe library keeps converted content organized for later scaling and reuse
- +Built-in editor supports quick correction of misread quantities and units
- +Local workflow works offline after import for ongoing recipe iteration
- –Automation depends on manual review after parsing, not fully hands-off conversion
- –API support for ingredient mapping and programmatic conversion is limited
- –Complex nutrition and compliance outputs require manual cleanup in many imports
- –Cross-system syncing for POS and inventory depletion is not part of the core workflow
Best for: Fits when personal or household meal prep workflows need accurate conversion with manual refinement.
ReciPal
SMBRecipe costing and nutrition labeling software with batch scaling and unit conversion for food businesses.
Conversion pipeline that keeps ingredient mappings and yield-aligned scaling consistent from input to exported format.
ReciPal converts recipe formats into standardized outputs, mapping ingredients and quantities so results stay consistent across systems. Recipe scaling behavior and unit normalization are handled as part of the conversion workflow, so yield changes follow the same rules from input to output.
The workflow focuses on repeatable conversions for kitchen and food data files rather than ad hoc spreadsheet edits. ReciPal’s core strength is handling conversion steps in a controlled pipeline that can be reused across recipe versions and serving sizes.
- +Unit-of-measure normalization reduces manual quantity correction after conversion
- +Repeatable recipe conversion pipeline helps maintain consistency across versions
- +Ingredient quantity mapping preserves yield changes during scaling
- +Structured output formats fit downstream feeding into other recipe systems
- –Conversion rule setup can require careful input mapping work
- –Multi-location yield variance handling is limited for complex location matrices
- –Recipe versioning workflows need tighter coordination for ongoing edits
- –Automation and API integration depth is less evident for fully programmatic pipelines
Best for: Fits when teams need consistent recipe conversions for standardized outputs across edits and scaling scenarios.
Tandoor Recipes
open sourceSelf-hosted recipe manager with ingredient scaling and unit conversion capabilities.
Structured recipe imports that preserve ingredient fields and instruction steps for immediate cleanup and later reuse.
Tandoor Recipes focuses on recipe conversion and recipe-library workflows, with Tandoor’s import pipeline as the center of the job. It can ingest recipes from multiple sources into a normalized internal format so cooks and admins can edit, scale, and reuse ingredients and instructions across the library.
For conversion work, it emphasizes practical authoring controls like structured ingredients, step ordering, and repeatable templates for consistent edits. The conversion result is stored in a way that supports ongoing versioning and serving-size adjustments inside the same workspace.
- +Recipe import results land in an editable, structured format
- +Ingredient and step ordering stays consistent after conversion
- +Scaling updates propagate through servings and ingredient quantities
- +Self-hostable setup fits teams that need controlled data handling
- –API surface for automated conversion pipelines is limited versus enterprise tools
- –File-to-library conversion quality depends on source structure
Best for: Fits when a team needs repeatable recipe conversion and ongoing library curation without deep enterprise integration demands.
meez
vertical specialistDigital recipe platform with built-in cost calculation and scaling.
Conversion configuration can be reused across multiple recipes to keep ingredient normalization consistent.
meez focuses on converting recipes into formats usable across kitchen and digital channels, with attention to unit handling and repeatable conversions. It supports recipe conversion workflows that translate ingredient lists into standardized quantities and serving counts without forcing users to rebuild recipes from scratch. The product’s main utility is turning an incoming recipe representation into a consistent output that can be reused for production planning and menu materials.
- +Produces consistent ingredient quantities across repeated conversion runs
- +Supports conversion from common recipe input formats into standardized outputs
- +Keeps conversion configuration separate from the original source recipe
- +Handles multi-step conversion workflows without manual rework
- –Conversion results depend heavily on input quality and naming conventions
- –Limited visibility into intermediate calculation states during troubleshooting
- –Advanced mapping work needs careful configuration to avoid quantity drift
- –Not designed as a full end-to-end POS and inventory sync system
Best for: Fits when teams need dependable recipe conversions from incoming formats into standardized kitchen and menu outputs.
MenuSano
vertical specialistMenu analysis software calculates nutrition and allergen information from recipes and ingredients.
Allergen flag propagation and ingredient-line attribute retention during recipe transformation runs.
MenuSano converts menu recipes between common menu, ingredient, and portion formats using a recipe mapping and transformation workflow built around unit-of-measure normalization. It focuses on repeatable conversions for multi-site menus by keeping conversion rules tied to ingredient lines and serving outputs.
The tool generates conversion-ready outputs meant for downstream menu publishing and batch prep documentation. MenuSano also supports ingredient statement ordering and allergen-related propagation so converted recipes keep those line-level attributes.
- +Unit-of-measure normalization keeps converted ingredients consistent across recipes
- +Allergen flag propagation preserves allergen attributes during conversions
- +Ingredient statement ordering remains stable after recipe transformations
- +Subrecipe linking supports shared components across multiple menu items
- –Conversion accuracy depends on clean ingredient naming and mapped units
- –Automation depth is limited without disciplined configuration governance
- –Batch yield reconciliation needs careful handling for multi-location variance
- –API-based ingredient mapping coverage is narrower than feature parity targets
Best for: Fits when menu operations need consistent recipe conversion with allergen and ingredient-line rules across locations.
Galley
enterpriseFoodservice software manages recipes, ingredients, production, nutrition, and operational data.
Allergen flag propagation is tied to ingredient mapping, so converted recipes retain allergen context without rebuilding rules.
Galley converts existing recipe formats into standardized outputs through a guided import, mapping, and validation workflow. It focuses on conversion rules for ingredient quantities, unit-of-measure normalization, and yield-driven serving or batch recalculation.
It also supports downstream compatibility by generating consistent nutrition facts panels and propagating allergen flags across converted ingredients. The result is a repeatable conversion process that reduces manual rework when recipe data must move between systems.
- +Ingredient unit-of-measure normalization reduces manual quantity corrections
- +Yield-based recalculation keeps serving counts consistent after conversion
- +Allergen flag propagation travels with mapped ingredient lines
- +Nutrition facts panel generation stays aligned to the converted recipe structure
- –Conversion quality depends on clean source naming and ingredient line consistency
- –Complex multi-location yield variance needs careful rule configuration per site
Best for: Fits when recipe libraries need repeatable conversion into standardized nutrition and allergen outputs across multiple systems.
Computrition
enterpriseHealthcare foodservice software manages recipes, menus, nutrition data, production, and patient diets.
Batch recalculation that maintains consistent serving targets across recipe versions using database-backed ingredient and unit rules.
Computrition focuses on recipe conversion workflows built around branded and retailer-ready nutrition and unit handling. It supports yield and serving normalization so the same recipe can be recalculated for different batch sizes and output targets.
Its core strength is translating recipe inputs into consistent nutrition facts outputs with repeatable ingredient and measure rules. For teams with standardized food lists, it reduces manual recalculation across locations and recipe versions.
- +Yield and serving normalization supports repeatable batch conversions
- +Branded and database-led ingredient mapping reduces ingredient re-entry
- +Consistent unit-of-measure normalization improves cross-recipe comparability
- +Recipe versioning keeps outputs tied to prior calculation states
- –Recipe conversion outcomes depend on quality and coverage of the configured food database
- –Automation and API options are less extensive than general-purpose conversion stacks
- –Subrecipe linking coverage can feel restrictive for complex assembly hierarchies
- –Multi-location yield variance requires careful configuration discipline
Best for: Fits when standardized ingredient databases and repeatable yield conversions matter more than custom API-driven pipelines.
Conclusion
After evaluating 10 food nutrition, Mealie 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.
How to Choose the Right recipe conversion software
Recipe conversion software turns messy or inconsistent recipe inputs into standardized ingredient lines, instruction steps, and scaled serving targets that can be reused across a recipe library or exported to downstream menu and nutrition workflows. This guide covers Mealie, CalcMenu, and MenuCalc alongside Paprika Recipe Manager, ReciPal, Tandoor Recipes, meez, MenuSano, Galley, and Computrition.
The tool set varies from self-hosted conversion workflows in Mealie to allergen-aware scaling in CalcMenu and baker’s percentage formula conversion in MenuCalc. The selection criteria below focus on integration depth, automation surface, and admin controls that affect conversion throughput and governance.
Recipe conversion software that normalizes ingredients, allergens, and servings for consistent outputs
Recipe conversion software ingests recipe content, maps ingredients to normalized unit-of-measure targets, recalculates serving counts, and outputs converted recipes that stay editable for later correction. Mealie emphasizes a self-hosted import and editing workflow that preserves converted records inside a local recipe library and recalculates ingredient quantities when serving scaling changes.
CalcMenu emphasizes allergen flag propagation that carries declared ingredients through scaling and unit conversion so converted recipe variants keep allergen context without duplicating recipe maintenance. Across the set, conversion outcomes depend on input cleanliness and mapping coverage, and some tools push more automation and API-driven workflows while others focus on interactive parsing and editability before further scaling.
Recipe conversion capabilities that determine output consistency
Conversion quality is decided by how reliably a tool normalizes ingredient lines and scales quantities into stable servings that downstream systems can reuse. The best results come from combining unit-of-measure normalization with serving scaling rules that keep quantities consistent after edits.
Self-hosted conversion workflow with a local recipe library
Mealie converts and preserves converted records inside a local recipe library so teams keep edit history and corrected outputs under direct admin control. This workflow supports serving scaling that recalculates ingredient quantities after conversion while staying centered on the converted recipe record.
Allergen flag propagation through scaling and unit conversion
CalcMenu carries allergen flags through scaling and unit conversion so scaled menu variants keep declared ingredient context without duplicating allergen rules. MenuSano and Galley also tie allergen flag propagation to ingredient mapping so converted recipes retain allergen attributes during transformation runs.
Baker’s percentage formula conversion for repeatable production
MenuCalc outputs baker’s percentage amounts tied to a flour-based reference so recurring formula conversions stay consistent across production runs. This approach supports baker’s percentage and unit conversion in one conversion target while keeping outputs structured for recipe-style documentation.
Interactive import that outputs editable ingredients and steps
Paprika Recipe Manager prioritizes editability by turning messy HTML into editable ingredient lists and instruction steps before downstream scaling. This makes it easier to clean parsed ingredients and steps, but it relies on manual review after parsing more than fully hands-off conversion.
Conversion pipelines that keep mappings and yield-aligned scaling consistent
ReciPal uses a conversion pipeline that keeps ingredient mappings and yield-aligned scaling consistent from input through exported format. Tandoor Recipes also preserves structured ingredient fields and instruction steps for immediate cleanup and later reuse, which supports iterative correction.
How to choose recipe conversion software by conversion workflow and governance needs
Selection should start with where corrected conversion results must live and how teams want to reuse them after scaling. Tools built around local library conversion behave differently than tools built around conversion pipelines that emphasize allergen-aware scaling and transformation runs.
Pick the workflow center: local library edits versus transformation-first pipelines
Choose Mealie if converted recipes must be preserved inside a self-hosted local recipe library so teams can edit corrected records and rescale servings without leaving the conversion workspace. Choose ReciPal or Tandoor Recipes if the conversion pipeline must keep ingredient fields and step ordering consistent so cleanup happens early but conversion logic remains repeatable.
Require allergen correctness across scaled variants
Choose CalcMenu if declared allergens must propagate through scaling and unit conversion so menu variants keep allergen context without duplicating recipe maintenance rules. Choose MenuSano or Galley if ingredient-line attribute retention and allergen preservation during transformation runs must work across locations with disciplined configuration.
Convert formulas in baker’s percentage rather than only absolute quantities
Choose MenuCalc when baker’s percentage outputs are the required conversion artifact so ingredient amounts tie to a flour-based reference for repeatable formula conversion. Choose MenuCalc alongside careful HACCP-aligned rounding settings when output tolerance requirements demand consistent conversion parameters.
Validate rounding, nutrition fidelity, and multi-location variance handling
Choose CalcMenu if allergen-aware scaling is central, but budget time for careful setup when advanced nutrition and rounding behavior must match internal requirements. Choose ReciPal if conversion rule setup can be invested up front, but note that multi-location yield variance handling remains limited for complex location matrices.
Account for troubleshooting visibility when conversions fail
Choose meez if conversion configuration needs to be reused across multiple recipes so ingredient normalization stays consistent across repeated runs. Choose Galley or CalcMenu when visibility into intermediate correction states is less critical because ingredient mapping and allergen propagation are tightly coupled to the transformation process.
Who should buy recipe conversion software
Recipe conversion software fits teams that must convert inconsistent recipe inputs into standardized ingredient lines, instruction steps, and serving targets that stay reusable after edits. The strongest fit appears when conversions feed scaling across menu variants, nutrition outputs, or allergen reporting needs.
Small and distributed teams that want self-hosted conversion records
Mealie fits teams that need repeatable local recipe conversions with serving scaling and manual correction while keeping converted recipe data under direct admin control.
Food service teams managing allergen requirements across scaled menu variants
CalcMenu supports allergen flag propagation through scaling and unit conversion so scaled recipe variants keep declared allergen context without duplicate maintenance.
Bakeries and production groups that document recipes as percentages
MenuCalc fits production workflows that require baker’s percentage conversion so formulas remain consistent across runs using a flour-based reference and unit conversion.
Household meal prep users who need clean editability of parsed content
Paprika Recipe Manager fits meal prep workflows where interactive parsing into editable ingredient and step lists reduces the friction of cleaning messy HTML before scaling.
Standardization teams building repeatable conversion outputs across versions
ReciPal fits teams that need a conversion pipeline that keeps ingredient mappings and yield-aligned scaling consistent from input to exported format.
Common conversion pitfalls when evaluating recipe conversion software
Conversion errors usually originate in mismatched mappings, inconsistent source formatting, or unvalidated rounding and nutrition expectations. Several tools require disciplined configuration because conversion logic depends on clean ingredient naming and mapped units.
Assuming conversion accuracy will stay high across messy source markup without manual correction
Mealie and Paprika Recipe Manager produce editable outputs after import, but conversion accuracy varies by source markup so manual ingredient fixes are often required after parsing.
Treating allergen labels as independent fields instead of tied to ingredient mapping
CalcMenu, MenuSano, and Galley handle allergen attributes through scaling and ingredient mapping, so allergen outcomes depend on clean ingredient naming and mapped units.
Underestimating rounding and nutrition configuration work for compliance-like output requirements
CalcMenu needs careful setup when advanced nutrition and rounding behavior must match internal requirements, and MenuCalc requires consistent inputs and settings when HACCP-aligned rounding is expected.
Expecting multi-location yield variance to work automatically for complex site matrices
CalcMenu and ReciPal can require more manual reconciliation when multi-location variance is complex, and ReciPal’s multi-location yield variance handling is limited for complex location matrices.
Using conversion configuration without enough input naming discipline
meez produces consistent ingredient quantities across repeated runs, but conversion results depend heavily on input quality and naming conventions, which can break normalization when ingredient names drift.
How We Selected and Ranked These Tools
We evaluated recipe conversion software on conversion output consistency, conversion workflow fit, and how quickly correct results can be reproduced after edits. Features accounted for 40% because allergen flag propagation, serving scaling recalculation, unit-of-measure normalization, and pipeline repeatability determine whether converted records stay stable.
Ease and value each accounted for 30% because self-hosted import and local library editing in Mealie reduces friction for iterative correction, while other tools trade off that workflow center for focused conversion behaviors like allergen propagation or baker’s percentage outputs. Mealie ranked highest because the self-hosted import and editing workflow preserves converted records inside a local recipe library and keeps servings scaling recalculations anchored to the same edited conversion records.
Frequently Asked Questions About recipe conversion software
How does recipe conversion software handle unit-of-measure normalization when scaling servings?
Which tool is best for converting recipes from web sources when the parsing must be edited manually?
What breaks if a recipe conversion workflow does not propagate allergen flags through ingredient mapping?
When does baker’s percentage conversion matter more than standard serving scaling?
How do conversion tools support recipe versioning and reuse across related dishes?
Which approach is better for data migration into a local recipe library: self-hosted import or API-first conversion?
How do recipe conversion tools recalculate yield-driven servings or batch sizes consistently?
What integration and API capabilities should be evaluated if recipes must be pushed into downstream POS or menu publishing workflows?
Where do admin controls and team governance matter in practice for converted recipe libraries?
Tools reviewed
Primary sources checked during evaluation.
Referenced in the comparison table and product reviews above.
- Food NutritionTop 10 Best Recipe Book Software of 2026
- Technology Digital MediaTop 10 Best Conversion Software of 2026
- Food NutritionTop 10 Best Recipe Card Maker Software of 2026
- Food NutritionTop 10 Best Food Consulting Services of 2026
- Technology Digital MediaTop 10 Best Book Conversion Services of 2026
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
Food Nutrition alternatives
See side-by-side comparisons of food nutrition tools and pick the right one for your stack.
Compare food nutrition tools→