
GITNUXSOFTWARE ADVICE
Science ResearchTop 10 Best Quantum Mechanics Simulation Software of 2026
Ranked list of quantum mechanics simulation software for researchers, with technical comparisons of CP2K, GPAW, Octopus, Pulser, Qulacs, and QuEST.
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
Pulser is the best fit overall if you’re simulating neutral-atom pulse sequences in Python with repeatable dynamics scheduling, whereas Qulacs is the stronger alternative when you already have qubit circuits or observables and want fast statevector simulation with noise.
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
Pulser
Pulse schedules tied to an atom register compile into time evolution with device-aware controls.
Built for fits when pulse-level Rydberg-array dynamics need repeatable simulation from Python schedules..
Qulacs
Editor pickDensity matrix simulator execution for the same gate circuits used in statevector runs.
Built for fits when qubit circuits or qubit observables already exist and fast simulation with noise is required..
QuEST
Editor pickA single engine that routes both pure-state and mixed-state simulations through the same circuit and measurement interfaces.
Built for fits when scripted experiments need consistent measurement statistics and mixed-state noise modeling..
Comparison Table
Pulser
vertical specialistPulse-level framework for composing and simulating neutral-atom quantum device programs.
Pulse schedules tied to an atom register compile into time evolution with device-aware controls.
Pulser’s workflow starts from a pulse schedule defined on an atom register, then compiles that schedule into simulation-ready dynamics for the configured device geometry. The simulator covers driven dynamics with configurable detuning and Rabi controls, and it can report measurable quantities derived from operator expectations. The primary integration path is the Python API exposed by its documentation build, which makes programmatic schedule generation and batch runs practical for research scripts.
A key tradeoff is that Pulser’s neutral-atom focus narrows scope to Rydberg-array experiment models rather than general Hamiltonians across electronic structure codes. Pulser fits best when pulse-level control logic, including spatial placement and timing, is the dominant uncertainty in the study, such as benchmarking circuit depth assumptions against measured excitation patterns.
- +Python API compiles pulse schedules into simulation-ready dynamics
- +Atom-register driven control model matches Rydberg-array experiment design
- +Expectation values support operator-based observables for analysis
- +Detuning and drive controls enable realistic time-dependent studies
- –Neutral-atom Rydberg model does not generalize to arbitrary Hamiltonians
- –Fidelity modeling depends on explicitly configured noise and calibration assumptions
- –Large register simulations can hit throughput limits without careful sizing
Quantum optics researchers
Test excitation profiles for atom arrays
Tighter comparison to experiments
Quantum algorithm engineers
Validate variational control ansätze
Faster parameter sweeps
Show 1 more scenario
Experiment design teams
Plan measurement observables
Clear measurement predictions
Computes expectation values from specified operator definitions on the simulated state.
Best for: Fits when pulse-level Rydberg-array dynamics need repeatable simulation from Python schedules.
Qulacs
performance computingFast quantum circuit simulator optimized for large-scale statevector simulations.
Density matrix simulator execution for the same gate circuits used in statevector runs.
Qulacs builds circuits from gate-level operations and executes them on in-memory simulators, with Python bindings that support tight edit-run cycles. Its density matrix support enables decoherence modeling beyond pure-state evolution, and its Pauli observable measurement tooling supports expectation value workflows without requiring external post-processing. Automation comes from programmatic circuit construction, since circuits and measurement operators are objects that can be generated in loops.
A key tradeoff is that Qulacs does not function as an end-to-end quantum chemistry package, so mapping fermionic Hamiltonians, basis handling, and integral generation usually happen outside the simulator. Qulacs fits best when the upstream step already produces qubit operators or circuits, such as after fermionic-to-qubit encoding and when the main requirement is repeatable simulation with controlled noise.
- +Fast statevector execution with direct circuit object manipulation
- +Density matrix simulation supports common noise workflows
- +Python API enables quick iteration over circuit structure
- +Observable expectation routines integrate with Pauli measurement
- –Not a complete quantum chemistry stack for integrals and basis work
- –Noise modeling requires explicit operator setup for the target channel
- –Large circuits can hit memory limits in state-based simulation
- –Limited turnkey workflows for end-to-end parameter sweeps
Quantum algorithm researchers
Benchmarking variational circuit measurements
Iteration-ready measurement datasets
Methods engineers
Noise-aware regression testing
Deterministic noise impact checks
Show 2 more scenarios
Quantum software developers
Prototyping circuit tooling
Reduced manual validation effort
Generates circuits programmatically in Python and validates results against known operator targets.
Computational physics teams
Small system operator studies
Quick operator-to-signal mapping
Evaluates Pauli-string observables for model Hamiltonians without external simulators.
Best for: Fits when qubit circuits or qubit observables already exist and fast simulation with noise is required.
QuEST
performance computingHigh-performance open source simulator for quantum circuits and quantum registers on CPUs and GPUs.
A single engine that routes both pure-state and mixed-state simulations through the same circuit and measurement interfaces.
QuEST targets workflows where repeatable runs matter, such as estimating observable expectation values under varying gates, timings, and noise assumptions. The simulator supports multiple internal state representations so users can trade memory for fidelity when moving from ideal circuits to mixed-state behavior. The Python layer is used for orchestration while the simulation engine stays in the native core for throughput on batch jobs.
A clear tradeoff is that QuEST is less suited to interactive circuit editing and notebook-first GUI exploration than to scripted simulation pipelines. It fits best when a lab or research group needs to run the same circuit family across many parameter points, then compare measurement statistics across runs.
- +Statevector and density-matrix execution paths from one simulator core
- +Python scripting drives batch runs without rewriting simulation logic
- +Observable estimation workflow is consistent across ideal and noisy models
- +Noise modeling integrates into measurement and statistics gathering
- –Less convenient for GUI-based circuit authoring than notebook tools
- –High-performance runs require careful control of simulator parameters
- –Large job orchestration still depends on external workflow tooling
Quantum algorithm researchers
Compare expectation values across circuit parameters
Stable, comparable expectation estimates
Quantum controls teams
Test decoherence and gate errors
Noise-sensitive gate performance
Show 1 more scenario
Computational physics groups
Prototype measurement strategies
Actionable measurement design
Generates shot-based measurement outcomes and compares different measurement setups for the same circuit.
Best for: Fits when scripted experiments need consistent measurement statistics and mixed-state noise modeling.
QuTiP
researchOpen source software for simulating the dynamics of open quantum systems.
Superoperator construction with Lindblad-form collapse operators enables direct decoherence and noise-channel modeling in one workflow.
QuTiP focuses on quantum dynamics and open-system modeling in Python, with Hamiltonian construction and time evolution built around density-matrix formalism. It provides state and operator primitives for observable expectation values, partial traces, and superoperators for noise and decoherence modeling.
The project includes utilities for measurement handling and fast linear algebra paths for common simulation tasks. Automation comes through a consistent API surface that integrates with NumPy and SciPy workflows for batch runs and parameter sweeps.
- +Native density-matrix and superoperator support for open-system dynamics
- +Consistent operator and state API for Hamiltonian construction and time evolution
- +Includes partial trace and expectation value helpers for measurement observables
- +Python-first integration with NumPy and SciPy enables scripting and batch runs
- –Performance can drop for large Hilbert spaces without careful sparse choices
- –Circuit-level workflows like variational ansatz training are not a primary focus
- –High-dimensional parameter sweeps need custom parallelization patterns
- –Complex multi-component models require careful basis bookkeeping
Best for: Fits when Python-based research teams need open-system quantum dynamics with automation-friendly APIs.
Quantum Toolbox in Julia
researchJulia-based framework for simulating open quantum systems and quantum optics models.
Model Hamiltonians and operator algebra are expressed in Julia, so custom terms and observables plug into the same simulation pipeline.
Quantum Toolbox in Julia performs quantum-mechanics simulations by combining Julia-native numerical routines with a set of focused packages for Hamiltonian building, basis handling, and time evolution. It supports workflows centered on second-quantized model construction and expectation-value computation, with examples that map common spin and fermionic operators into matrices or sparse operators.
The Julia integration enables custom code to define problem-specific Hamiltonians and measurement operators while reusing the library’s evolution and linear-algebra utilities. It is also used for reproducible notebooks where simulation inputs and outputs stay in a single Julia environment.
- +Julia-first design keeps Hamiltonian and solver code in one language
- +Operator-centric workflow supports custom observables and model extensions
- +Sparse-friendly numerics help with mid-size Hilbert spaces
- +Notebook-driven examples make it easier to reproduce simulation pipelines
- –API surface is not a unified high-level interface for every common method
- –Advanced workflows often require writing glue code around models and solvers
- –Large-scale tensor network contraction workflows are not the primary focus
- –Some specialist analysis steps depend on user-managed data structures
Best for: Fits when researchers need Julia-integrated Hamiltonian modeling and solver control for operator-level studies.
Cirq
developer platformOpen source Python framework for writing and simulating quantum circuits on noisy intermediate-scale devices.
Moment-based circuit scheduling with rewrite-ready circuit structure for deterministic circuit-level transformations.
Cirq is a quantum circuit simulation system where the primary artifact is a circuit built from operations arranged into moments. That moment structure supports deterministic scheduling constraints and enables transformation passes that operate on gate placement rather than only final results.
Simulation in Cirq supports both exact-style state evolution and sampling-based measurement, which lets the same circuit definition target ideal outcomes and finite shot behavior. Expectation-style computations are supported through explicit observables built from measurement operations.
The library includes validation utilities that check circuit consistency and common gate constraints. It also provides extensibility via custom gates, custom operations, and custom simulators, so domain-specific models can be expressed without abandoning the circuit programming model.
- +Python-native circuit representation with parameterized gates for controlled experiments
- +Statevector and sampling paths let researchers choose fidelity versus shot noise behavior
- +Circuit transformation passes support rewrite-based workflow automation
- +Clear separation between circuit construction and simulator backend selection
- –Dense Hamiltonian workflows require external model-to-circuit translation work
- –Scaling limits appear quickly for large qubit counts due to simulator memory growth
- –Fewer built-in domain libraries than specialized materials or chemistry simulation stacks
- –Complex measurement grouping logic often needs custom circuit construction
Best for: Fits when researchers prototype circuit-first experiments and need statevector-style simulation plus sampling within one Python workflow.
TeNPy
researchPython library for tensor network simulations of strongly correlated quantum systems.
Operator-to-contraction integration that turns model Hamiltonian definitions into reusable expectation-value workflows.
TeNPy is a quantum mechanics simulation toolkit built around tensor network contraction workflows and physics-first abstractions for model Hamiltonians. It provides code paths for variational tensor network states and time evolution methods that target one-dimensional quantum systems with local interactions.
Its documentation emphasizes reproducible experiments with configurable solvers, model parameterization, and contraction backends for controlled truncation behavior. For projects that need Hamiltonian construction and observables from operator definitions into contraction-ready objects, TeNPy keeps that pipeline in the same Python environment.
- +Strong tensor network contraction workflow for 1D Hamiltonians
- +Variational solvers use consistent interfaces across model classes
- +Observable evaluation reuses operator and state objects
- +Extensible model definitions support custom terms and symmetries
- –Best performance depends on carefully managed truncation parameters
- –Workflow complexity rises with advanced boundary conditions and symmetries
Best for: Fits when researchers need Python-native tensor network simulations for 1D quantum models with custom Hamiltonian terms.
Dynamiqs
researchPython library for high-performance simulation of open quantum systems with JAX.
Trajectory and master-equation style dynamics share the same model-building and observables workflow, reducing rewrite costs.
Dynamiqs is a quantum mechanics simulation software solution focused on dynamics in open and driven systems. It provides scripted simulation workflows centered on master-equation and trajectory-style time evolution, plus tight control over time grids and parameter sweeps. The core capability emphasized in typical usage is computing time-resolved observables and state properties under specified Hamiltonian and dissipator definitions.
- +Time-resolved observables from explicit dynamical definitions and event loops
- +Parameter sweeps for Hamiltonian and dissipator variations using consistent interfaces
- +Support for open-system dynamics through master-equation style modeling
- +Efficient batching across independent runs to raise simulation throughput
- –Less suited to ab initio workflows like plane-wave basis sets and pseudopotentials
- –Requires careful operator construction to avoid dimension and basis mismatches
- –Advanced measurement post-processing can need custom observable bookkeeping
- –Does not cover tensor-network contraction workloads as a first-class workflow
Best for: Fits when groups need scripted open-quantum-system time evolution with sweepable parameters.
VASP
enterpriseVienna Ab initio Simulation Package for atomic-scale materials modeling using pseudopotentials and plane-wave DFT.
Projector-augmented wave potentials with plane-wave expansion enables accurate solid-state ground-state calculations at scale.
VASP performs ab initio electronic structure simulations using density functional theory for periodic solids and surfaces. It provides a plane-wave basis with projector-augmented wave and robust workflows for optimizing ionic structures, relaxing lattices, and computing electronic properties.
Core capabilities include electronic self-consistency, Brillouin-zone sampling, and response workflows such as band structure and density-of-states outputs. VASP’s practical focus on atomistic modeling makes it a mainstay for materials research rather than quantum-circuit or tensor-network backends.
- +High-throughput batch runs for k-point and cutoff convergence studies
- +Strong support for periodic boundary conditions across solids and surfaces
- +Well-established pseudopotential and plane-wave workflows for reproducible setups
- +Extensive output coverage for electronic structure and derived observables
- –Tuning convergence parameters can require significant iteration
- –Not designed for circuit-level gate simulation or shot-based measurement workflows
Best for: Fits when researchers need production-grade periodic DFT simulations with repeatable parameter convergence workflows.
Schrödinger
enterpriseCommercial molecular simulation platform combining quantum mechanics, molecular dynamics, and computational chemistry for drug discovery and materials design.
Unified job workflow that keeps QM inputs and property outputs consistent across repeated parameter studies.
Schrödinger centers quantum mechanics simulations on an integrated workflow that connects structure preparation, Hamiltonian setup, and property prediction. It provides engines for electronic structure and molecular modeling workflows, including ab initio and density functional workflows used for energy and spectroscopy targets.
Automation features cover job templating, parameter reuse, and batch execution across datasets. Data handling focuses on consistent inputs and outputs across model preparation and simulation runs, which helps reduce manual formatting work between stages.
- +Integrated workflow connects structure setup to quantum calculations and property outputs
- +Job templates and batch execution reduce repeat setup across parameter sweeps
- +Large curated chemical input handling supports standard molecular preparation workflows
- +Extensive output artifacts for energies, geometries, and spectroscopic style properties
- –Limited transparency for custom Hamiltonian construction compared with research-first toolchains
- –Automation depends on Schrödinger-specific job packaging rather than a general API-first model
- –Exporting results into fully custom simulation loops can require manual bridging steps
- –Tensor-network and circuit-style simulation workflows are not the focus
Best for: Fits when teams need an end-to-end QM workflow for molecules with repeatable runs and standardized outputs.
Conclusion
After evaluating 10 science research, Pulser 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 quantum mechanics simulation software
Quantum mechanics simulation software spans pulse-level control for Rydberg-array experiments, circuit-first statevector and density matrix simulation, and model Hamiltonian workflows built for tensor networks, open-system dynamics, or production DFT.
This guide covers Pulser, Qulacs, QuEST, QuTiP, Quantum Toolbox in Julia, Cirq, TeNPy, Dynamiqs, VASP, and Schrödinger, with category comparisons grounded in how each tool constructs time evolution, represents operators, and runs parameter sweeps.
The most consequential differences show up in integration depth through Python APIs, the degree of automation around simulation runs, and the practical boundaries around Hamiltonian generality.
Quantum mechanics simulation software for controlled dynamics, circuits, and model Hamiltonians
Quantum mechanics simulation software computes time evolution, energy structure, and observable expectation values by executing a defined model of the Hamiltonian and measurement process. Tools in this category either simulate quantum states directly from circuit or operator descriptions or run open-system dynamics from explicit dynamical definitions.
Pulser focuses on compiling Python-defined pulse schedules into simulation-ready time evolution using an atom register control model, which makes Rydberg-array dynamics repeatable from experiment-like inputs. Qulacs emphasizes fast circuit execution with explicit density matrix simulation that uses the same gate circuits used for statevector runs, which supports noise workflows that start from a circuit object rather than a full quantum chemistry stack.
Quantum dynamics integration, execution models, and automation controls
Quantum mechanics simulation software has to translate a Hamiltonian and measurement specification into time evolution that can be executed repeatedly under parameter sweeps. The most reliable tools expose that translation as an inspectable interface so runs stay reproducible when noise, boundary conditions, or truncation parameters change.
Pulse-schedule to device-aware time evolution
Pulser compiles Python-defined pulse schedules into simulation-ready dynamics tied to an atom register control model, which matches Rydberg-array experiment design.
Circuit-first execution with density matrix noise workflows
Qulacs runs statevector-style circuits quickly and can switch to density matrix simulation for the same circuit objects, which keeps shotless noise experiments tied to the circuit.
One simulator interface for pure-state and mixed-state paths
QuEST routes statevector and density-matrix execution through the same core and measurement interfaces, which supports consistent measurement statistics and mixed-state noise modeling in scripted runs.
Open-system dynamics with superoperators and Lindblad collapse operators
QuTiP builds superoperators with Lindblad-form collapse operators in a single workflow, which supports direct decoherence modeling with Python-level control.
Tensor network contraction workflows for 1D model Hamiltonians
TeNPy integrates operator-to-contraction steps that turn model Hamiltonian definitions into reusable expectation-value workflows for 1D tensor network simulations.
Trajectory and master-equation dynamics from a shared model pipeline
Dynamiqs uses one model-building and observables workflow for trajectory-style dynamics and master-equation style evolution, which reduces rewrite cost when changing dissipators and Hamiltonians.
Production-grade periodic DFT workflows and repeatable convergence batches
VASP provides high-throughput batch execution for k-point and cutoff convergence studies with plane-wave and periodic boundary condition support for solids and surfaces.
Pick the execution philosophy that matches the way the Hamiltonian is defined
The key decision is whether the workflow starts from experiment-like control inputs, circuit objects, operator algebra, or production-grade ab initio inputs. A mismatch forces manual translation across model representations and often breaks reproducibility across parameter sweeps.
Choose pulse-level control simulation when the primary input is time-structured driving
Pick Pulser when the simulation input is a Python pulse schedule that must compile into device-aware time evolution driven by an atom register control model.
Choose circuit-first simulation when gate circuits already exist as the canonical artifact
Pick Qulacs when statevector-style circuits and density matrix simulation need to share the same circuit object and fast execution path, especially for noise experiments.
Choose mixed-state consistency when scripts must keep measurement logic identical
Pick QuEST when batch scripts need statevector and density-matrix execution from one simulator core without rewriting measurement or expectation-value code paths.
Choose superoperator construction when Lindblad open-system dynamics is the center of the workflow
Pick QuTiP when collapse operators and superoperator time evolution must be constructed explicitly in Python and then reused consistently across Hamiltonian changes.
Choose tensor contraction tooling when the system is 1D and model terms change often
Pick TeNPy when Hamiltonians are built as operators that need to flow into tensor network contraction and expectation-value workflows under different truncation parameters.
Choose trajectory and master-equation dynamics when dissipators are frequently swept
Pick Dynamiqs when the workflow must generate observables from explicit dynamical definitions while sweeping Hamiltonian and dissipator parameters under the same model-building interface.
Teams that get measurable value from each workflow shape
Quantum mechanics simulation software is most productive when it matches the team’s canonical representation of the physical model. These segments map to who benefits from pulse scheduling, circuit objects, density matrix execution paths, tensor contractions, open-system dynamics, or production DFT repeatability.
Rydberg-array groups generating time-structured control schedules in Python
Pulser fits teams that define driving as Python pulse schedules and need repeatable compilation into simulation-ready time evolution tied to an atom register control model.
Quantum circuit researchers who already store experiments as gate circuits
Qulacs fits researchers who manipulate circuit objects directly and need fast density matrix simulation for the same circuits to support noise workflows.
Open-systems researchers who model decoherence through explicit collapse operators
QuTiP fits teams that construct Lindblad-form collapse operators and want consistent density-matrix and superoperator time evolution in one Python workflow.
Condensed-matter model builders running 1D tensor network studies
TeNPy fits researchers who build operator-level Hamiltonians and want those definitions to feed into reusable tensor network contraction and expectation-value pipelines.
Materials simulation teams running periodic solid-state convergence batches
VASP fits teams that need production-grade plane-wave basis and periodic boundary condition workflows with repeatable k-point and cutoff convergence runs.
Common failure modes when the simulation boundary is wrong
Many teams pick quantum mechanics simulation software for the physics they want but ignore the representation boundary they inherit. That boundary determines how much manual translation is needed from Hamiltonian definitions to executable time evolution and what breaks first in parameter sweeps.
Using pulse-level tools for arbitrary Hamiltonians outside the atom-register control model
Pulser is built around atom register driven control and compiles pulse schedules into device-aware dynamics, so it is not the right fit when the model must cover arbitrary Hamiltonians without that control structure.
Rebuilding noise logic by constructing density matrix operators without preserving the circuit artifact
Qulacs keeps density matrix simulation tied to circuit objects, so noise experiments stay consistent when noise channels are defined for operators aligned with those circuits.
Switching between pure-state and mixed-state runs while measurement code changes
QuEST routes pure-state and mixed-state simulation through one core with shared circuit and measurement interfaces, which reduces measurement drift when scripts run batch comparisons.
Trying to scale large Hilbert spaces without controlling sparse choices
QuTiP can slow down for large Hilbert spaces unless sparse data handling is managed carefully, so operator construction choices can dominate throughput.
Assuming tensor network workflows will stay stable under aggressive truncation changes
TeNPy performance depends on truncation parameter management, so changing bond-dimension or related limits can increase workflow complexity and affect expectation-value reliability.
How We Selected and Ranked These Tools
We evaluated Pulser, Qulacs, QuEST, QuTiP, Quantum Toolbox in Julia, Cirq, TeNPy, Dynamiqs, VASP, and Schrödinger on execution coverage, representational fit, and how directly each tool turns a physical definition into runnable time evolution. Features carried 40% of the score, ease and workflow overhead carried 30% of the score, and value for the intended simulation workflow carried 30% of the score.
Pulser ranked highest because its Python pulse-schedule compilation into device-aware time evolution tied to an atom register control model provides a tight control-to-dynamics integration path. That integration reduces manual translation compared with circuit-first or operator-first workflows when Rydberg-array dynamics is the primary target.
Frequently Asked Questions About quantum mechanics simulation software
How do Pulser and Cirq differ in how simulations map to the control inputs researchers write?
Which tools support open-system noise modeling via density matrices rather than only ideal statevector dynamics?
When does QuEST’s single-engine routing of pure-state and mixed-state workflows matter for experiment sweeps?
What breaks if a workflow needs tensor network contraction support for 1D lattice models rather than circuit or Hamiltonian-integration primitives?
How do QuTiP and Dynamiqs handle time dependence and time-resolved observables in open or driven dynamics?
Which toolchain is better aligned with automation when batch runs need consistent experiment definitions and result extraction?
How do data models and APIs differ between Qulacs circuit objects and Pulser’s pulse scheduling objects?
When teams need Hamiltonian construction that plugs into a unified operator workflow, how do Quantum Toolbox in Julia and Schrödinger compare?
What security and administrative controls should be expected when deploying these tools inside managed research environments?
Tools reviewed
Primary sources checked during evaluation.
Referenced in the comparison table and product reviews above.
- Science ResearchTop 10 Best Quantum Simulation Software of 2026
- Science ResearchTop 10 Best Mechanics Simulation Software of 2026
- Chemicals Industrial MaterialsTop 10 Best Quantum Chemical Software of 2026
- Science ResearchTop 10 Best Quantum Computer Development Services of 2026
- Science ResearchTop 10 Best Quantum Error Correction 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
Science Research alternatives
See side-by-side comparisons of science research tools and pick the right one for your stack.
Compare science research tools→