GITNUXSOFTWARE ADVICE
Finance Financial ServicesTop 10 Best Trading System Development Software of 2026
Top 10 ranking of trading system development software for algorithmic trading, comparing QuantConnect, TradeStation, and NinjaTrader by cost and tools.
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
TradingView is the best fit if you want a single workspace for visual strategy development, historical testing, and alert-based execution, whereas AmiBroker is the smarter entry for systematic traders who prefer local, AFL-driven research and script-level control over automation.
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
TradingView
Pine Script combines chart-native coding, Strategy Tester validation, visual annotations, and alert deployment in one interface.
Built for fits when traders need visual strategy development, historical testing, and alert-based execution from one workspace..
cTrader
Editor pickcTrader Algo combines C# and Python cBots with cTrader Cloud execution for remote strategy deployment.
Built for fits when developers need broker-connected forex automation with C# or Python and managed remote execution..
AmiBroker
Editor pickAFL's Custom Backtester lets developers define portfolio metrics, position handling, ranking behavior, and trade-processing rules.
Built for fits when systematic traders need local portfolio research with script-level control and external automation..
Comparison Table
TradingView
enterpriseCharting and analysis platform with Pine Script for indicator and strategy development and backtesting.
Pine Script combines chart-native coding, Strategy Tester validation, visual annotations, and alert deployment in one interface.
TradingView gives developers one workspace for chart studies, executable strategies, alerts, and published Pine Script libraries. Pine Script supports custom indicators, strategy rules, arrays, maps, multi-timeframe requests, and visual annotations. The Strategy Tester reports trades, equity curves, drawdowns, and performance statistics without requiring a separate research environment.
The main tradeoff is execution control because Pine Script runs within TradingView’s managed runtime and its data access, processing limits, and external integration surface are restricted. TradingView fits discretionary traders and small development teams that need to validate signals visually, monitor live alerts, and route selected orders through supported broker integrations.
- +Pine Script connects custom indicators, strategies, alerts, and chart annotations.
- +Strategy Tester provides trade lists, equity curves, drawdowns, and performance metrics.
- +Bar Replay supports historical signal review across synchronized chart intervals.
- +Webhook alerts connect generated signals with external execution services.
- –Pine Script lacks unrestricted server-side execution and a general-purpose trading API.
- –Runtime limits constrain complex calculations, long histories, and high-frequency logic.
- –Broker integrations vary by market, broker, and supported order functionality.
Independent strategy developers
Testing indicator-based entry rules
Faster signal iteration
Technical analysis teams
Sharing reusable market studies
Consistent chart analysis
Show 2 more scenarios
Alert-driven traders
Routing signals to execution tools
Automated signal routing
Server-side alerts send webhook payloads when specified Pine conditions trigger on selected instruments.
Discretionary traders
Reviewing historical market conditions
Repeatable chart review
Bar Replay reconstructs prior chart sessions for manual review of entries, exits, and indicator behavior.
Best for: Fits when traders need visual strategy development, historical testing, and alert-based execution from one workspace.
cTrader
enterpriseSpotware trading platform with cAlgo for building cBots in C# for algorithmic strategy development and execution.
cTrader Algo combines C# and Python cBots with cTrader Cloud execution for remote strategy deployment.
cTrader combines a broker-connected trading terminal with an event-driven backtester and a code-based automation environment. Developers can create cBots and indicators in C# or Python, test strategies with historical bars and ticks, and run selected algorithms in cTrader Cloud. Open API uses authenticated application access for market data, account information, positions, orders, and trade history.
The main tradeoff is its concentration on broker-provided forex and CFD markets rather than broad portfolio research across equities, futures, and alternative datasets. cTrader fits teams that need deployable broker automation, especially when a strategy must move from local testing to cloud execution without maintaining a trading workstation.
- +C# and Python support covers mainstream algorithm development workflows
- +Cloud execution keeps cBots running without a local desktop session
- +Open API exposes market data, accounts, orders, and positions
- +Visual backtesting helps inspect entries, exits, and indicator behavior
- –Market coverage depends on the connected broker's forex and CFD offering
- –No native notebook environment for portfolio-level quantitative research
- –Advanced automation requires familiarity with asynchronous trading APIs
- –Broker-specific execution conditions can complicate cross-account testing
Forex algorithm developers
Deploy automated currency strategies
Remote strategy execution
Broker integration teams
Connect external trading applications
Broker-connected automation
Show 1 more scenario
Strategy validation teams
Test indicator-based trading logic
Earlier strategy validation
Historical backtesting and optimization expose strategy behavior before deployment to a live account.
Best for: Fits when developers need broker-connected forex automation with C# or Python and managed remote execution.
AmiBroker
SMBTechnical analysis and trading system development platform using AFL for backtesting, optimization, and exploration.
AFL's Custom Backtester lets developers define portfolio metrics, position handling, ranking behavior, and trade-processing rules.
AmiBroker's AFL language covers indicators, entry and exit rules, position sizing, ranking, and custom portfolio logic. The Analysis window evaluates multiple symbols and time frames while supporting optimization, walk-forward testing, and portfolio-level statistics. COM and OLE automation can launch analyses, modify parameters, and retrieve results from external applications.
The desktop architecture limits shared research, centralized administration, and browser-based collaboration. Market data and broker connectivity depend on configured plugins or external providers, so deployment requires technical setup. AmiBroker fits systematic traders who want detailed control over portfolio rules and execution assumptions on a local workstation.
- +Custom Backtester supports portfolio-level metrics and position-processing rules.
- +AFL handles indicators, signals, ranking logic, and custom analysis workflows.
- +COM automation connects external applications to analysis and execution workflows.
- +Multi-threaded analysis accelerates parameter testing across symbols and periods.
- –Desktop deployment lacks a native cloud workspace for shared research and centralized administration.
- –Broker connectivity depends on data or broker plugins rather than one universal gateway.
- –AFL syntax and backtester configuration require a substantial learning period.
- –Collaboration lacks shared notebooks, granular roles, and centralized audit logs.
quantitative research teams
portfolio strategy research
Repeatable research workflow
technical equity traders
rotational equity ranking
Ranked portfolio allocations
Show 1 more scenario
automation engineers
external analysis orchestration
Programmatic research control
COM automation lets scripts launch analyses, alter parameters, retrieve results, and coordinate AmiBroker with external applications.
Best for: Fits when systematic traders need local portfolio research with script-level control and external automation.
NinjaTrader
enterpriseFutures and forex trading platform with NinjaScript, a C#-based framework for strategy development and backtesting.
NinjaScript strategy lifecycle with state-driven setup and execution consistency across charts and backtests.
NinjaTrader targets trading system development with a tight workflow around strategy code, charting, and backtesting in one desktop environment. It supports event-driven strategy execution with lifecycle hooks for state transitions, plus built-in order handling features that map to trade simulations.
NinjaTrader also provides extensibility through its scripting layer and an ecosystem of integrations that can connect strategies to external execution and data workflows. The main development differentiator is that strategies, signals, and execution logic run in a consistent engine across chart evaluation and historical testing.
- +Strategy lifecycle states map cleanly to backtest and live execution phases
- +NinjaScript exposes granular order and position events for detailed trade logic
- +Chart and strategy research share the same simulation and event pipeline
- +Extensible scripting supports custom indicators, signals, and execution rules
- –Higher effort is required to replicate execution costs like slippage and fills precisely
- –Deployment and governance depend on disciplined setup of scripts and connections
Best for: Fits when a code-first shop wants one strategy engine for research, backtesting, and brokerage routing under control.
QuantRocket
API-firstPython-based platform for algorithmic trading research, backtesting, and live trading with integrated data services.
Strategy configuration and orchestration layer that turns indicator and execution wiring into deterministic, repeatable runs.
QuantRocket automates the wiring between market data, indicator logic, and backtest execution for algorithmic trading research. It provides a configurable strategy pipeline with broker and execution integration patterns, plus project-level orchestration for repeatable runs.
The tool also supports data integrity controls and deterministic dataset handling so results remain reproducible across iterations. QuantRocket is built for teams that want automation around strategy builds and performance measurement rather than manual notebook workflows.
- +Automates end to end backtest runs from configuration instead of notebooks
- +Strong broker and execution adapter patterns for realistic pipeline testing
- +Reproducible backtest inputs via controlled dataset handling and settings
- +Built in project orchestration for parameter sweeps and repeated experiments
- –More setup effort than pure backtest scripts due to pipeline configuration
- –Execution fidelity depends on available market data granularity
- –Extending custom models can require deeper knowledge of QuantRocket internals
- –Workflow shifts from ad hoc notebooks to a more structured project model
Best for: Fits when teams need automated backtest orchestration with repeatable inputs and broker-style integration.
ProRealTime
SMBCharting platform with ProBuilder and ProBacktest for developing and testing trading strategies via a dedicated language.
Chart-synced strategy language with in-platform execution simulation and live broker workflow under one UI.
ProRealTime is a trading system development environment that centers on its built-in strategy language for chart-based coding and testing. It supports end-to-end workflow for signal generation, historical backtesting, and strategy deployment with broker connectivity for live execution.
The development loop is shaped by its integrated charting, order simulation controls, and data handling that targets point-in-time backtests. ProRealTime also supports automation around strategies through its platform scripting and execution setup rather than requiring external orchestration.
- +Integrated chart editor connects indicators and strategies to one workflow
- +Strategy language supports conditional logic and clear order intent
- +Backtest runs use platform-managed data and consistent execution rules
- +Broker connection workflow keeps live execution steps close to development
- –External integration options and API surface are limited versus code-first ecosystems
- –Advanced execution modeling depth is less granular than specialized backtest tools
- –Complex multi-asset deployment and governance controls require careful manual setup
- –Tick-level workflow depends on available data and engine constraints
Best for: Fits when teams want chart-centric strategy coding with reliable platform backtesting and straightforward broker execution.
Sierra Chart
SMBAdvanced charting and trading platform with ACSIL, a C++ API for custom study and trading system development.
ACSIL trading and order management code runs inside Sierra Chart, linking chart events to automated order handling in one environment.
Sierra Chart is a charting and trading system development environment centered on its own study scripting and data handling, rather than a general-purpose research IDE. Strategy logic is built as ACSIL studies and custom order logic, then validated with built-in historical simulation and playback-oriented testing workflows.
It supports connectivity to market data feeds and broker execution paths, which lets development extend from signal generation to trading automation within the same workspace. Governance is handled through project-level configuration, versioned local settings, and a reproducible configuration footprint suited to on-prem deployments.
- +ACSIL scripting supports custom indicators, strategy logic, and event-driven trading behavior
- +Integrated historical simulation workflows reduce tool handoff during backtesting iterations
- +Local configuration and on-prem deployment fit firms that want control over the runtime
- +Broker and market data connectivity can be wired from the same development environment
- –C++-style ACSIL development adds engineering overhead versus point-and-click strategy builders
- –Backtest realism depends on data quality and simulator configuration choices
- –Debugging across strategy, fills, and connectivity often requires careful log tracing
- –Governance is more configuration-driven than role-based for large teams
Best for: Fits when a trading desk needs custom order logic, tight chart-to-trade integration, and local runtime control.
Wealth-Lab
SMBStrategy development platform using WealthScript for building, backtesting, and optimizing equity trading systems.
Event-driven backtesting with an integrated strategy framework for signal-to-order logic continuity.
Wealth-Lab is a trading system development tool focused on building strategies that run through an integrated research and backtesting workflow. It includes an event-driven backtesting engine, a signal-to-trade strategy framework, and utilities for testing variations such as parameter sweeps.
The development experience centers on reusable strategy components and repeatable simulation runs that support out-of-sample testing workflows. Execution is handled via supported broker connectivity and order routing, so strategy signals can be translated into trades for live or simulated operation.
- +Event-driven backtester supports bar and intra-bar style testing in one workflow
- +Built-in parameter sweep tooling helps manage systematic strategy variation runs
- +Strategy development framework keeps signal generation and trade logic in one codebase
- +Broker integration supports taking generated orders beyond research
- –Automating large multi-strategy studies can require custom scripting and orchestration
- –Advanced execution modeling depth can lag specialized execution research stacks
- –Tick-level fidelity depends on the data feed quality and settings used
- –Live routing and simulation behavior can diverge without careful configuration checks
Best for: Fits when strategy research needs a single code-driven workflow from backtest to order placement.
SmartQuant
enterpriseInstitutional algorithmic trading framework offering OpenQuant for strategy development and QuantRouter for execution.
Deployment-ready strategy packaging that keeps research logic consistent with broker-connected execution wiring.
SmartQuant builds trading strategies through a workflow that combines strategy logic, research tooling, and deployment into a broker-connected execution loop. It offers backtesting with simulation components for fills and costs, plus a strategy configuration layer that supports iterative parameter changes.
The platform emphasizes automation through code-driven strategy templates and reusable components for data ingestion, signal generation, and risk controls. Operational fit centers on teams that need consistent strategy packaging, repeatable runs, and controlled release paths across environments.
- +Automated research-to-deploy pipeline reduces manual rework between runs
- +Configurable simulation settings for costs and fills improve scenario repeatability
- +Reusable strategy modules support consistent signal and risk implementation
- +Clear separation between strategy logic and execution wiring
- –Nontrivial setup is required for end-to-end data feed and broker connectivity
- –Debugging strategy behavior can be slower when backtests diverge from live fills
- –Advanced workflows rely on engineering familiarity with the platform’s conventions
- –Throughput tuning for large parameter sweeps needs careful resource planning
Best for: Fits when research teams require a repeatable research-to-execution workflow with controlled configuration.
Hummingbot
API-firstOpen-source framework for building automated crypto trading strategies including market making and arbitrage.
Multi-venue connector architecture that runs the same strategy logic while adapting exchange-specific order routing and account handling.
Hummingbot is a trading system development tool focused on building and running crypto market making and execution bots. It provides a strategy framework with configurable components for connectors, order management, and exchange interaction.
Development work centers on Python strategy code and on wiring the bot runtime to venues through supported adapters. It is less oriented toward full event-driven backtester workflows and FIX-style enterprise execution integration.
- +Python strategy framework with clear separation between strategy and exchange connectors
- +Built-in exchange connectors reduce custom broker bridge work for common crypto venues
- +Supports multiple bot types for market making and automated execution workflows
- +Extensive configuration surface for order sizing, routing, and risk limits
- –Backtesting is not the primary workflow and lacks enterprise-grade execution simulation depth
- –Strategy correctness depends on manual testing, and governance controls are limited
- –Operational reliability requires careful monitoring because runtime behavior is connector-specific
- –Order book handling and slippage modeling are not standardized across all venues
Best for: Fits when teams need crypto execution bots with Python customization and venue-specific connector integration.
Conclusion
After evaluating 10 finance financial services, TradingView 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 trading system development software
Trading system development software spans chart-native script editors, broker-connected automation frameworks, and local or remote backtest engines for turning signals into routed orders. This guide covers TradingView, NinjaTrader, and QuantConnect among the top options, with additional tools like AmiBroker, Sierra Chart, and Wealth-Lab used to highlight different development and execution workflows.
The comparisons focus on integration depth with brokerage or execution environments, the shape of the strategy development workflow from research to simulated fills, and how each tool exposes automation and configuration for repeatable runs. Each tool card reflects how the coding surface, backtesting engine, and deployment path influence what teams can test and automate.
Trading system development software for coding, backtesting, and executing algorithmic strategies
Trading system development software provides a strategy coding surface that connects signal generation to testing and order handling, often spanning chart testing, portfolio research, and broker routing workflows. Tools like NinjaTrader use NinjaScript strategy lifecycle states to keep the research-to-execution path consistent across backtests and live runs.
For teams that want repeatable pipeline runs, QuantRocket adds a configuration and orchestration layer that drives end-to-end backtest execution through deterministic inputs and broker-style adapter patterns. For visually grounded development and alert-based deployment, TradingView combines Pine Script Strategy Tester validation with chart-native indicators and chart annotations in one workspace.
Integration, automation, and repeatable execution controls
Trading system development software succeeds when the strategy coding surface can connect to a realistic execution path instead of ending at a backtest chart. The most decisive differences show up in how each tool wires orders, broker connectivity, and automated run control.
Strategy-to-execution wiring and broker connectivity
NinjaTrader routes strategies through its NinjaScript lifecycle into brokerage connections, which keeps the same event logic across research and execution phases. QuantConnect pairs algorithm logic with execution adapters for a broker-style workflow, while AmiBroker depends on data or broker plugins rather than one universal gateway.
Automation surface for repeatable backtests and studies
QuantRocket turns indicator and execution wiring into deterministic runs driven by configuration, which reduces manual study setup time. Wealth-Lab includes parameter sweep tooling around an event-driven backtester, while TradingView uses Strategy Tester for validation and trade list style outputs tied to chart context.
Extensibility and language fit for order and portfolio logic
Sierra Chart uses ACSIL to code custom order handling and event-driven trading behavior inside the platform runtime. AmiBroker’s AFL Custom Backtester supports portfolio-level metrics and position-processing rules, while TradingView limits server-side execution and a general-purpose trading API exposure.
Execution realism controls for costs, fills, and slippage modeling
SmartQuant provides configurable simulation settings for costs and fills, which improves scenario repeatability when backtest outcomes need tighter constraints. NinjaTrader requires higher effort to replicate execution costs like slippage and fills precisely, while Sierra Chart ties backtest realism to simulator configuration and data quality choices.
Operational governance for deployments and remote runtime
cTrader Algo combines C# and Python cBots with cTrader Cloud execution, which keeps bots running without a local desktop session. NinjaTrader and Sierra Chart rely more on disciplined script and connection setup, while Hummingbot focuses on multi-venue connector architecture for common crypto routing rather than enterprise-grade execution simulation depth.
Choose the workflow that matches how strategies become routed orders
The fastest decision comes from matching the strategy development workflow to the execution workflow. The category splits into chart-native builders, code-first engines, and orchestration layers that run repeatable pipelines.
If chart-native development and alert deployment dominate, evaluate TradingView first
TradingView combines Pine Script with chart-native coding, Strategy Tester validation, and visual annotations in one workspace. This fit matters when research output must stay visually grounded and when alert-based deployment is the execution path.
If code-first strategy lifecycle and order event detail must stay consistent, compare NinjaTrader and Sierra Chart
NinjaTrader maps NinjaScript strategy lifecycle states to backtest and live execution phases and exposes granular order and position events for detailed trade logic. Sierra Chart brings ACSIL into the runtime so chart events can trigger automated order handling, but it adds C++-style engineering overhead.
If deterministic multi-run automation drives the team process, choose QuantRocket or Wealth-Lab
QuantRocket orchestrates end-to-end backtest runs from configuration and emphasizes deterministic, repeatable inputs using adapter patterns for realistic pipeline testing. Wealth-Lab keeps event-driven testing and parameter sweep runs in one code-driven workflow for systematic variation studies.
If broker-connected forex automation is the priority, validate cTrader Cloud execution
cTrader Algo supports both C# and Python via cBots and uses cTrader Cloud execution for remote strategy deployment without a local session. This choice depends on whether the connected broker offers the needed forex and CFD market coverage.
If portfolio research needs explicit trade-processing rules, test AmiBroker’s AFL Custom Backtester
AmiBroker’s AFL Custom Backtester defines portfolio metrics, position handling, ranking behavior, and trade-processing rules. This approach favors local desktop research with external automation rather than centralized shared administration.
If crypto multi-venue routing is the primary execution target, assess Hummingbot
Hummingbot provides Python strategy framework separation between strategy and exchange connectors and includes built-in exchange connectors for common crypto venues. The workflow fits teams that accept backtesting as secondary and use manual testing plus governance discipline.
Teams that get the most value from each development model
Different tools reflect different assumptions about where strategy code lives, how it runs, and how it reaches brokerage routing. The best fit depends on whether strategy behavior is primarily chart-driven, code-driven, or configuration-orchestrated.
Active chart users who prototype strategies visually and rely on alert-style deployment
TradingView combines Pine Script coding, Strategy Tester validation, and chart annotations in one interface, which keeps development output aligned with the chart workflow.
Algorithm developers who need a single strategy engine across research and brokerage routing
NinjaTrader’s NinjaScript lifecycle and granular order and position events fit shops that want consistent behavior between backtests and live brokerage phases.
Quant teams that standardize research-to-run pipelines across many parameter sets
QuantRocket’s configuration-driven orchestration supports deterministic, repeatable pipeline testing and reduces the need for notebook-style study setup.
Portfolio research builders who require explicit portfolio metrics and trade-processing rules
AmiBroker’s AFL Custom Backtester handles portfolio-level metrics and position-processing rules, which supports research patterns that go beyond indicator backtesting.
Crypto execution operators coordinating multiple venues with Python-coded strategies
Hummingbot’s connector architecture runs the same strategy logic while adapting exchange-specific order routing and account handling.
Common failure modes when selecting and implementing strategy development tools
Many teams start by validating chart performance and only later discover that execution routing, simulator configuration, and governance controls did not match their live constraints. The result is backtests that look credible but break under broker reality.
Selecting a chart-first workflow and assuming it provides a general-purpose trading API for deployment
TradingView’s Pine Script approach is strong for Strategy Tester validation and alert-based workflows, but Pine Script lacks unrestricted server-side execution and a general-purpose trading API for broad automation.
Treating strategy code portability as guaranteed across backtests and live execution without validating fill realism
NinjaTrader can expose granular order and position events, but it requires higher effort to replicate execution costs like slippage and fills precisely, so simulator settings must be validated against trading constraints.
Underestimating governance and setup discipline for long-running deployments
Hummingbot’s governance controls are limited and backtesting is not its primary workflow, so manual testing and careful operational controls are required to prevent strategy correctness drift.
Choosing a pipeline tool while ignoring market data granularity requirements for simulation fidelity
QuantRocket focuses on deterministic pipeline runs, but execution fidelity depends on the available market data granularity, so data sources must support the modeling depth required for your strategy.
How We Selected and Ranked These Tools
We evaluated how each tool connects strategy development to execution by comparing integration depth with broker routing and the automation surface for repeatable runs. We scored features at 40% because the category differences show up in Strategy Tester validation and alert deployment for TradingView, NinjaScript lifecycle event control for NinjaTrader, and configuration-driven orchestration for QuantRocket.
We scored ease at 30% and value at 30% based on how quickly teams can go from configuration or chart code to consistent backtest outputs and deployment workflows. TradingView ranked highest because Pine Script combines chart-native coding, Strategy Tester validation, visual annotations, and alert deployment in one interface, which reduces handoff friction compared with tools that emphasize custom engines or connector-heavy setups.
Frequently Asked Questions About trading system development software
How does QuantConnect compare with NinjaTrader for running the same logic in research and backtests?
Which tool fits a chart-first development loop with execution simulation and broker workflow in the same UI?
What breaks when strategy logic relies on alerts or chart scripting rather than a general-purpose trading API?
How does Sierra Chart handle custom order logic compared with Wealth-Lab’s signal-to-trade framework?
When is AmiBroker the better choice for local portfolio research and external automation control?
How do integrations differ between QuantRocket and Hummingbot for connecting strategy logic to external execution systems?
What security controls should be checked for automation environments that use SSO and RBAC?
How should data migration be handled when moving from a spreadsheet workflow to QuantRocket’s deterministic dataset handling?
Which tool is best suited for walk-forward optimization and parameter sweep workflows with portfolio metrics and ranking?
Tools reviewed
Primary sources checked during evaluation.
Referenced in the comparison table and product reviews above.
- Finance Financial ServicesTop 10 Best System Trading Software of 2026
- Technology Digital MediaTop 10 Best System Development Software of 2026
- Finance Financial ServicesTop 10 Best Technical Analysis Trading Software of 2026
- Technology Digital MediaTop 10 Best Trading Platform Development Services of 2026
- Finance Financial ServicesTop 10 Best Fintech Trading 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
Finance Financial Services alternatives
See side-by-side comparisons of finance financial services tools and pick the right one for your stack.
Compare finance financial services tools→