Free tools Windows power users keep installed
One-click scans. No signup required.
Use MySQLTuner as a diagnostic, not an automatic optimizer. Run its read-only Perl script after the server has handled at least 24 hours of representative traffic, investigate the measured symptom behind each suggestion, change one related setting at a time, and keep a change only when production measurements improve without exhausting memory, increasing latency, or weakening reliability.
Need a server to try this on? Antihost offers Linux VPS plans with NVMe storage, full root access and a 14-day free trial.
MySQLTuner does not edit configuration files or restart MySQL. Its output is a set of observations and hypotheses. The difficult—and valuable—part is connecting each hypothesis to your MySQL or MariaDB version, hardware, workload, queries, storage engine, and operating limits.
As an Amazon Associate I earn from qualifying purchases.
What MySQLTuner does—and what it cannot do
MySQLTuner inspects status variables, configuration, logs, schema characteristics, operating-system conditions, replication state, and other indicators, then prints warnings and suggested actions. The project FAQ describes it plainly: “MySQLTuner is a read only script.” It does not write my.cnf, execute an index change, or restart a service.
That safety boundary does not make every recommendation safe to apply. A larger per-connection buffer can multiply memory use under concurrency; a change that reduces disk work can increase CPU; maintenance on a busy table can block traffic; and a setting valid on one release may be removed, renamed, dynamic only in another release, or unavailable on a managed service. Treat every line as a question to investigate.
#1 Best Overall
The Oracle MySQL Reference Manual summarizes the broader issue: “Database performance depends on several factors at the database level, such as tables, queries, and configuration settings.” A server variable cannot repair a missing index, an inefficient join, lock contention, slow storage, or an application that opens and abandons connections.
How long should MySQLTuner run before you trust it?
Wait for at least 24 hours of uptime with a normal workload. The project README warns that running the script on a freshly restarted server is “completely useless” for accurate ratio-based results. Twenty-four hours is a minimum, not a guarantee: a weekly batch, month-end close, seasonal traffic, or an infrequent failover may require a longer observation window that includes the relevant activity.
Record the uptime and workload period in the report. A ratio based on a counter accumulated for five minutes can look radically different after a full day. A server that was idle overnight may also produce a misleadingly favorable average. Re-run after a configuration change only after the new setting has again seen representative traffic.
Prepare a baseline before running the script
Capture enough context to decide whether a warning represents a bottleneck. Save the timestamp and uptime with every baseline so later comparisons use the same frame of reference.
| Baseline item | What to record | Why it matters |
|---|---|---|
| Server identity | MySQL, MariaDB, or Percona distribution; exact version and edition | Variable names, valid ranges, defaults, and dynamic behavior differ by release. |
| Host capacity | Total RAM, CPU topology, storage type, filesystem, and container limits | Global and per-session memory must fit the real limit, not just the physical host. |
| Workload | Traffic pattern, peak periods, read/write mix, batch jobs, and connection-pool behavior | A recommendation based on a quiet period may not fit peak concurrency or write pressure. |
| Health signals | Application response-time percentiles, throughput, errors, lock waits, disk latency, and CPU/memory use | These are the outcomes against which a tuning change should be judged. |
| Logs and topology | Error log, slow-query log, replication role and lag, failover state | Operational faults and replica constraints can outweigh a ratio warning. |
| Current configuration | Effective variables, configuration-file locations, included files, and pending changes | You need the old value and its source to create a reliable rollback. |
For a remote server, MySQLTuner may not be able to discover host memory. Supply it with the script’s --forcemem option using the host’s actual available memory, not an arbitrary estimate. In exhaustive mode, the account needs the read privileges required by the checks. The Debian manpage identifies SELECT, PROCESS, SHOW DATABASES, and REPLICATION CLIENT as relevant privileges; grant the minimum required scope and use a dedicated credential rather than an application account.
Run MySQLTuner without changing anything
- Obtain the current project version from its official distribution and verify the file before execution. Keep the script version with the report because checks evolve.
- Run the default invocation first. This gives you an unmodified reference report. If the database is remote, use the documented connection options and provide
--forcememwhen host memory cannot be detected. - Save stdout and stderr with the date, hostname, server version, and uptime. Do not paste a password into shell history; use the credential mechanism supported by your client and deployment.
- Read the report completely. Separate observations, warnings, informational checks, and suggested actions. The project usage guidance recommends reviewing recommendations before applying changes.
- Repeat at a comparable time if the first run coincided with a maintenance event, outage, restart, failover, or unusually low traffic.
The script’s output is evidence about the period it inspected, not a promise of a target configuration. Keep the original report immutable so you can compare later runs.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Clear out junk files and repair common Windows errors3Fix the driver behind crashes, sound loss and screen glitchesClassify each recommendation before touching a variable
Create a change record for every proposed action. Include the exact finding, the metric and time window behind it, the current value and source, the proposed value or non-variable action, the expected benefit, the risks, the test, and the rollback. Then classify it into one of the following groups.
Memory and buffer recommendations
“Add RAM before increasing buffers” is a capacity warning. First calculate a worst-case memory envelope: fixed global allocations plus buffer-pool or cache allocations, plus per-thread buffers multiplied by the maximum simultaneous sessions, plus connection overhead, temporary tables, replication threads, and the operating system or container reserve. Compare that envelope with the limit visible to the database process. A high cache-miss ratio does not justify a larger cache if the host is already swapping.
Distinguish allocated memory from actively used memory and average connections from peak concurrent sessions. A connection pool can make a seemingly modest per-session increase dangerous at the traffic peak. Watch resident memory, swap activity, out-of-memory events, and allocation failures after any change.
InnoDB buffer pool, redo, and log findings
Verify the working-set size, read/write mix, checkpoint pressure, storage latency, and crash-recovery requirements. A larger buffer pool may reduce reads but leave too little memory for connections or the operating system. Larger redo capacity can reduce checkpoint pressure for write-heavy traffic, yet it changes recovery characteristics and must fit the exact server version’s limits and dynamic behavior. Checkpoint age, dirty-page behavior, flush latency, and replication lag rather than relying on one percentage.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Temporary tables, sorts, and joins
Find the queries that create internal temporary tables or perform large sorts and joins. Inspect their row counts, selected columns, predicates, join order, and execution plans. Raising per-session limits can move work from disk to RAM, but concurrent sessions can multiply the allocation. An index, a smaller result set, a corrected data type, or a rewritten query is often safer than increasing a global limit.
Connections and thread cache
Separate connection churn from insufficient capacity. Compare connection-attempt rates, aborted connections, active sessions, pool size, authentication latency, and application timeout behavior. A larger thread cache may help when the application repeatedly creates short-lived connections, but it will not fix a pool that leaks connections or a host that cannot support the configured maximum. Set limits from observed peak concurrency and a deliberate reserve, not from a single high-water mark.
Tables, indexes, and OPTIMIZE suggestions
Confirm the engine, fragmentation evidence, table size, locking behavior, and maintenance window before running an operation. An OPTIMIZE action can require substantial temporary space and I/O, and its locking behavior varies by engine and version. Confirm that the proposed index supports a real query predicate or ordering requirement; do not add indexes solely because a tool lists a table. Extra indexes consume storage and make writes and maintenance more expensive.
Slow queries and schema warnings
Use the slow-query log and query metrics to rank work by total time and user-visible latency, not by an isolated execution. Inspect EXPLAIN and, where supported and safe, EXPLAIN ANALYZE on representative data. Check cardinality, row estimates, access type, sort and temporary-table operations, and whether a schema or data-type mismatch prevents index use. Configuration tuning cannot compensate for an inefficient query plan.
Recommended Free Tools
Replication and high-availability findings
Check replica SQL and I/O thread state, lag during peak writes, relay-log and binary-log capacity, failover procedures, and the consistency requirements of the application. A setting that improves a primary’s throughput can increase replica lag or alter durability. Test on a replica or staging topology before changing write-related or logging variables.
Security and version findings
Handle security and lifecycle warnings as a separate workstream, not as performance tweaks. Prioritize a supported database release, least-privilege accounts, protected credentials, encrypted connections where required, and appropriate exposure controls. A performance change should never weaken authentication, transport security, auditing, or backup integrity.
Questions to ask about every recommendation
- What symptom triggered it? Identify the counter, rate, ratio, log message, or operating-system observation.
- Is the measurement mature? A cumulative counter or ratio needs enough uptime and a representative denominator.
- Does the exact version support the setting? Check the version-specific MySQL, MariaDB, or Percona manual for range, scope, default, and dynamic behavior.
- What is the concurrency cost? Calculate the worst-case per-session allocation and the configured connection ceiling.
- What trade-off is expected? Consider CPU versus I/O, latency under writes, lock duration, crash recovery, durability, and replication.
- Is the action actually SQL or schema work? A missing index, bad plan, or fragmented table cannot be repaired by copying a variable into a configuration file.
- Can it be observed and reversed? Define a measurable success condition and a tested rollback before production deployment.
Validate the hypothesis with MySQL’s optimization tools
Start with the query and workload that exhibit the problem. Use slow-query evidence, application traces, response-time percentiles, and execution plans to identify where time is spent. Correlate that with buffer-pool behavior, disk latency, CPU saturation, lock waits, temporary-table creation, and memory pressure.
For a query change, compare plans and timings on production-like data. For a memory change, test peak concurrency and monitor resident memory and swap. For an I/O or redo change, observe write latency, checkpoint activity, recovery time in a safe test, and replica behavior. A high “hit rate” is not proof that increasing a cache will help; establish that cache misses are causing measurable waits and that the host has headroom.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallRank #4
Use the exact-version manual for valid commands and settings. MySQL, MariaDB, and Percona Server are related but not interchangeable, and managed services may restrict variables or require a parameter-group rollout instead of a local file edit.
Apply changes in a controlled way
- Reproduce in staging. Use production-like schema, data distribution, concurrency, and query mix. Include the peak case that exposed the warning.
- Make one coherent change set. Group settings that address the same measured bottleneck, but avoid changing unrelated variables in the same deployment.
- Record the old state. Save the effective value, configuration-file location or parameter group, deployment time, and expected scope (global, session, dynamic, or restart-required).
- Plan the rollback. Know whether reverting requires a dynamic statement, a configuration deployment, a restart, or a failover. Verify that the previous value is valid in the current version.
- Deploy during an observable window. Confirm backups, alerts, replication health, and an operator who can stop or reverse the change.
- Do not paste the entire recommendation block. Informational findings, index work, capacity warnings, and environment checks require different actions. MySQLTuner itself cautions that improving one area can harm another.
For a restart-required setting, account for connection draining, failover behavior, startup validation, and recovery time. For a dynamic setting, test whether existing sessions inherit the new value or retain their session setting.
Measure the result and decide whether to keep it
Define the target before deployment. Compare a matched pre-change and post-change window rather than relying on an immediate impression. Track:
- Application response-time percentiles and throughput.
- Error rates, timeouts, aborted connections, and deadlocks.
- Lock waits, transaction latency, and queue depth.
- Temporary-table creation and disk-based temporary work.
- Buffer-pool reads and writes, eviction behavior, and relevant hit or miss trends.
- CPU utilization, resident memory, swap, disk latency, and I/O queue depth.
- Replication lag, log pressure, and recovery or failover signals.
Keep the change only when the target workload improves without an unacceptable regression in reliability or resource use. If the target does not improve, revert it and investigate the query, schema, storage, or workload assumption that was wrong. Re-run MySQLTuner after representative uptime has accumulated again, then compare its findings with continuous monitoring rather than treating the new report as an authority.
Common failure modes and recovery paths
The server begins swapping after a buffer change
Reduce or revert the new allocation, protect the operating-system reserve, and inspect peak concurrent sessions and per-thread buffers. If memory pressure caused errors or killed the process, restore service first, then recalculate the worst-case envelope before any retest.
Temporary-table warnings remain after increasing limits
Find the statements still spilling to disk, inspect their plans and result sizes, and address indexes, predicates, joins, or sorting requirements. A larger limit may simply have moved the failure point while increasing the cost of every concurrent session.
Best Value
Connection recommendations do not improve latency
Measure connection creation and authentication time, pool reuse, aborted connections, and application timeouts. Correct pool sizing or leaked sessions before raising server limits.
Write latency or replica lag increases
Check redo and flush behavior, storage latency, lock waits, and replica apply capacity. Roll back the change if the workload’s durability or lag objective is violated, then test a smaller or differently scoped change with the replication topology included.
An OPTIMIZE or index operation disrupts traffic
Stop or reschedule the maintenance if safe, restore normal traffic, and review the engine-specific online DDL and locking behavior. Plan future maintenance with measured table size, temporary-space requirements, and a tested window.
A recommendation conflicts with a managed-service control
Use the provider’s supported parameter mechanism and verify which variables are exposed, static, or overridden. If the required setting is unavailable, address the underlying query, schema, instance size, or storage tier instead of attempting an unsupported file edit.
When to consult deeper references
Use the official, version-specific manual for variable semantics and optimization behavior. For a broader companion, O’Reilly describes High Performance MySQL, 4th Edition as covering server configuration, hardware, query performance, InnoDB, replication, high availability, and scaling. Efficient MySQL Performance emphasizes response time, indexes, EXPLAIN, query metrics, transactions, row locking, and server metrics—useful when MySQLTuner points toward query or schema work. The official MySQL books catalog also lists titles on MySQL 8 query-performance tuning and concurrency. Treat edition availability and access terms as changeable, and verify them before purchase.
Quick Recap
A repeatable operating checklist
- Confirm the exact database distribution, version, deployment type, and host or container limits.
- Capture configuration, logs, workload shape, topology, and health metrics.
- Ensure at least 24 hours of representative uptime, or a longer window that includes periodic work.
- Run MySQLTuner in read-only mode and archive the complete report.
- Classify each finding and identify the measured symptom behind it.
- Check version-specific semantics, memory impact, trade-offs, and whether the action is query, schema, capacity, or security work.
- Test one related change with production-like concurrency and a rollback.
- Measure latency, throughput, errors, resource use, locking, I/O, and replication before deciding.
- Revert changes that fail the target and document the result.
- Re-run after representative uptime and keep continuous monitoring as the primary feedback loop.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →
