If your PC sounds like a jet on takeoff during a firefight and then whines with an annoying, ever-changing hum at idle, the problem is almost never the fans themselves — it is the coarse fan logic baked into your motherboard firmware. FanControl fixes that. It is a free Windows utility that reads every temperature sensor in your system and lets you draw precise, per-fan speed curves that respond to whatever heat source you choose: CPU package, GPU hotspot, NVMe drive, or a blend of all three. This tutorial walks through a complete FanControl setup in 12 practical steps, from the first launch and sensor calibration to switchable silent and gaming profiles you can flip with a single click.
The tool is developed by a single author known as Rem0o and has been in active development since May 2020. As of the V269 build released on June 3, 2026, the release repository has picked up more than 20,000 GitHub stars and ships a new version roughly every two to three weeks. It is genuinely free, requires no account, and — despite what a decade of “fan control software” scare stories will tell you — it is safe to run on a modern system once you understand the driver model. By the end of this guide you will have a fully tuned machine that is quiet at the desktop and aggressive under load, plus the troubleshooting knowledge to keep it that way.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Is FanControl and Why Software Fan Curves Beat BIOS
FanControl is a highly customizable fan controller for Windows 10 and Windows 11. Instead of the two or three fixed points your motherboard exposes in BIOS, it gives you an unlimited-node graph editor, the ability to control each fan header independently, and — crucially — the freedom to drive any fan from any sensor. You can spin your case exhaust off the GPU hotspot instead of the CPU, ramp the front intake off your NVMe temperature during a big file copy, or blend several sensors into one smoothed control signal. None of that is possible with a typical UEFI Q-Fan or Smart Fan page.
Under the hood, FanControl reads sensors through the open-source LibreHardwareMonitor library, the same engine that powers many popular monitoring apps. That means it sees the same rich sensor tree you would get from a dedicated hardware monitor, and it updates several times per second. The app itself is deliberately lightweight, keeps resource usage low, and stores each configuration as a portable JSON file you can back up or copy between machines. For CPU-side tuning it pairs naturally with a dedicated overclocking tool — see our Ryzen Master undervolt guide — while GPU enthusiasts often run it alongside MSI Afterburner for clock and voltage control.
Compared with the tools it effectively replaced, FanControl wins on flexibility. The venerable SpeedFan still runs but stalled years ago and struggles with modern chipsets; Argus Monitor is polished but paid and comparatively rigid; and your BIOS simply cannot cross-reference sensors or switch profiles on the fly. The table below summarizes where each option lands in 2026.
| Feature | FanControl (V269) | SpeedFan | Argus Monitor | Motherboard BIOS |
|---|---|---|---|---|
| Price | Free (donationware) | Free | Paid (annual license) | Included |
| Windows 10/11 support | Full | Partial / legacy | Full | N/A (firmware) |
| Sensor engine | LibreHardwareMonitor | Built-in (dated) | Proprietary | Super I/O only |
| Cross-sensor curves | Yes (mix/sync/trigger) | Limited | Limited | No |
| GPU fan control | NVIDIA & AMD | No | Yes | No |
| Switchable profiles | Yes (JSON configs) | No | Partial | No |
| Kernel driver | PawnIO (signed) | Legacy driver | Signed driver | N/A |
| Last major update | June 2026 | Stalled | Active | Vendor-dependent |
The takeaway: if you are on Windows 10 or 11 and want granular, sensor-aware fan curves without paying, FanControl is the default recommendation in 2026. The only real learning curve is understanding its curve types and the driver situation, both of which we cover next.
Is FanControl Safe? Inside the PawnIO Driver Switch
This is the single most-searched question about the app, so let us settle it clearly. FanControl is safe to use, but there is real history behind the concern. To read low-level hardware sensors and write to fan registers, any fan utility needs a kernel-mode driver that operates in ring 0 — the most privileged layer of the operating system. For years, FanControl and dozens of other monitoring tools relied on a legacy driver called WinRing0 (installed as FanControl.sys). That driver worked, but it was old, and its broad access made it a favorite building block for malware.
In late 2025, Microsoft Defender began flagging the WinRing0 driver as Trojan:Win32/Vigorf.A. On builds V237 and earlier, that flag would quarantine the driver and silently break sensor detection — your fans would show up but refuse to move. The author’s response was decisive: starting with version V238, FanControl ships a build of LibreHardwareMonitor that uses PawnIO instead of WinRing0. As the developer explained, this “fixes the anti-virus problems encountered with WinRing0, as it is no longer shipped with FanControl.”
PawnIO is a new, cryptographically signed kernel driver designed specifically to satisfy the open-source community’s need to safely execute hardware access in ring 0. Rather than exposing raw memory access, it runs sandboxed bytecode modules, which dramatically shrinks the attack surface. FanControl bundles a recent PawnIO release (version 2.2.0 as of the V265 build), and the switch has been thoroughly documented by the community — the write-up “Replacing WinRing0 in Fan Control with PawnIO” is the clearest technical explanation available.
There is one important caveat for competitive gamers: some anti-cheat systems, notably FACEIT, will block the PawnIO driver because they refuse to load unrecognized ring-0 modules. If you play on FACEIT and see the driver blocked, that is expected behavior, not a FanControl bug. The practical workaround is to run FanControl before launching the anti-cheat, or to accept that fan control is unavailable while that specific client is active. For everyone else, the golden rule is simple: always download from the official source and keep the app updated to at least V238. Older copies floating around download-aggregator sites are exactly what triggers the malware warnings.
Prerequisites: Hardware, Windows, and .NET Versions
FanControl controls fans that are already wired to a controllable header. Before you start, confirm your hardware can actually be driven by software and that your system meets the runtime requirements. Missing one of these is the number-one cause of a “no fans detected” experience.
Hardware you need
Your fans must be connected to motherboard fan headers (or a supported fan hub/controller such as certain Corsair Commander units), not directly to the PSU. Both 4-pin PWM and 3-pin DC headers work, though PWM headers give finer control. GPU fans require a supported card — FanControl uses NVIDIA’s NVAPI and AMD’s ADLX interface, so both vendors are covered, but a handful of laptop and OEM GPUs lock their fan tables in firmware and cannot be overridden. If your fans plug into a proprietary RGB/fan combo hub, control depends on whether a plugin exists for it.
Software and runtime
FanControl is distributed in two flavors: a .NET 8.0 build and a .NET Framework 4.8 build. Windows 10 and 11 already include .NET Framework 4.8, so that build runs with zero extra installs; the .NET 8.0 build needs the .NET 8 Desktop Runtime, which you can grab from Microsoft’s official .NET download page. You also need local administrator rights, because the kernel driver cannot load otherwise. The table below lists everything with the versions verified for this guide.
| Requirement | Minimum / recommended | Notes |
|---|---|---|
| Operating system | Windows 10 or Windows 11 (64-bit) | Windows 7/8 not supported |
| FanControl build | V269 (June 3, 2026) or newer | Anything V238+ uses the safe PawnIO driver |
| Runtime (.NET build) | .NET 8.0 Desktop Runtime | Only for the .NET version of the app |
| Runtime (Framework build) | .NET Framework 4.8 | Pre-installed on Windows 10/11 |
| Privileges | Administrator | Required to load the ring-0 driver |
| Fan wiring | Motherboard/hub PWM or DC headers | PSU-connected fans cannot be controlled |
| BIOS setting | Manual/full-speed fan mode | Disable Q-Fan/Smart Fan to avoid conflicts |
One prerequisite that trips people up: your motherboard’s own fan logic. If BIOS keeps a “Smart Fan” or “Q-Fan” curve active, it will fight FanControl for the same header. Set those headers to full speed (100%) or manual in BIOS so the operating system has clean authority. We will revisit this in the pitfalls section.
Step 1 — Download the Portable Build and Extract It
Go to the official FanControl release repository on GitHub or the project site at getfancontrol.com and download the latest release. You will see two options: a portable ZIP and an installer. For a first-time setup, the portable ZIP is the better choice — it keeps every file in one folder, is trivial to back up, and never touches the registry. Choose the .NET Framework 4.8 archive if you want zero dependencies, or the .NET 8.0 archive if you already have the runtime.
Extract the ZIP to a permanent location such as C:\Tools\FanControl. Do not run it from inside the Downloads folder or from within the ZIP viewer — the app writes its configuration and log files next to the executable, and a temporary path will lose your settings. After extraction, the folder looks like this:
C:\Tools\FanControl\
├── FanControl.exe # main application
├── FanControl.dll
├── Configurations\ # your saved profiles (JSON) live here
│ └── userConfig.json
├── Logs\ # rolling diagnostic logs
├── Plugins\ # drop third-party .dll plugins here
├── Themes\ # optional color themes
└── LibreHardwareMonitorLib.dll # the sensor engineRight-click FanControl.exe, open Properties, and on the General tab click Unblock if Windows added a “downloaded from the internet” mark. This prevents SmartScreen from nagging on every launch. You are now ready to run it.
Step 2 — Launch FanControl and Complete the Guided Setup
Launch FanControl.exe. Windows will prompt for administrator elevation — accept it, because the driver load depends on it. On first run, FanControl walks you through a guided setup that installs the PawnIO driver and scans your hardware. This scan populates the sensor tree and detects every controllable fan header on your motherboard, plus GPU and any supported hubs.
When the scan finishes you will see two main columns: Controls (each fan you can drive, shown as a percentage) and Speeds (the measured RPM of each fan). A representative first-launch summary looks like the output below.
[FanControl] PawnIO driver loaded OK
[FanControl] Detected motherboard: B650 (Super I/O: IT8689E)
Controls found:
- CPU_FAN (PWM) current: 45%
- CPU_OPT (PWM) current: 45%
- SYS_FAN1 (PWM) current: 60%
- SYS_FAN2 (DC) current: 100%
- GPU Fan (NVAPI) current: 0% (idle, zero-RPM)
Speeds found:
- CPU_FAN 1180 RPM
- SYS_FAN1 820 RPM
- GPU Fan 0 RPM (fans stopped)
Temperatures: CPU 41 C | GPU 38 C | NVMe 44 C | Motherboard 34 CIf a fan you know exists does not appear, stop and check the pitfalls: most often it is a BIOS “Smart Fan” override or a fan wired to a hub FanControl cannot see. Do not proceed to calibration until the fans you intend to control are visible in the Controls column.
Step 3 — Calibrate Fans to Detect Start and Stop RPM
Every fan has a minimum duty cycle below which it either stalls or refuses to spin up from a dead stop. Calibration finds those thresholds so your curves never accidentally park a fan in a dead zone. Open the app menu (the three dots, top-right), choose Settings, and run the fan calibration routine. FanControl steps each fan from 100% down to 0% and back, recording the exact points where it stops and restarts.
The V267 build (May 2026) added a manual calibration feature with “avoid regions”, which lets you exclude noisy or resonant speed bands from your usable range — useful when a specific RPM makes your case panel buzz. A typical calibration result reads like this:
Calibration results (CPU_FAN, Noctua NF-A12x25 PWM):
Start threshold : 18% (fan begins spinning)
Stop threshold : 12% (fan stalls below this)
Min stable RPM : 340 RPM
Max RPM : 1980 RPM
Recommendation: keep curve minimum >= 20% to guarantee spin-up.Write these numbers down or leave calibration data saved. When you build curves in the next steps, keep the lowest node at or slightly above the start threshold so the fan reliably kicks in. This is the difference between a fan that silently stops (great for acoustics) and one that fails to restart when temperatures climb (bad for hardware).
Step 4 — Read Your Sensors: CPU, GPU, and Storage Temps
Before drawing curves, understand which temperatures matter. FanControl exposes the full LibreHardwareMonitor tree, which can list dozens of sensors. For fan control you typically care about four: CPU package (or Tctl/Tdie on AMD), GPU core/hotspot, the hottest NVMe drive, and motherboard/VRM. Click any sensor to see its live value, and pin the ones you plan to use so they stay visible.
A key concept is that CPU temperatures are spiky — they can jump 20 °C in a single second as the processor boosts, then fall just as fast. If you bind a case fan directly to raw CPU temperature, it will surge and drop constantly, producing exactly the “hum that never settles” you are trying to eliminate. GPU and drive temperatures are far smoother. We will solve the CPU spikiness with response-time smoothing and trigger curves later, but for now simply identify your sources. A sensible mapping for a typical gaming tower is:
| Fan / control | Best temperature source | Why |
|---|---|---|
| CPU cooler fan | CPU package (Tctl/Tdie) | Directly tracks the load it cools |
| AIO pump | Flat 100% (or coolant temp) | Pumps should not modulate for cooling |
| Rear/top exhaust | Mix of CPU + GPU | Removes heat from both hot components |
| Front intake | GPU hotspot or NVMe | Feeds cool air to the graphics card |
| Bottom intake | NVMe / motherboard | Targets storage and VRM heat |
This mapping is a starting point, not gospel. The whole point of FanControl is that you can experiment: if your GPU dumps heat into the top of the case, drive the top exhaust from the GPU instead. Note your chosen sources now — you will reference them in Step 6.
Step 5 — Build Your First Graph Fan Curve
The Graph curve is the workhorse of FanControl. It plots temperature on the X axis and fan duty on the Y axis, and you place as many nodes as you like. Press the + button at the bottom of the app and choose Add “Graph” fan curve. Give it a clear name such as “CPU Silent” and pick your temperature source — for this example, CPU package.
Click Edit to open the graph, then left-click to add nodes and drag them into place. The single most important design rule, echoed by nearly every guide including Digital Trends’ walkthrough, is to build a stepped, flat-then-steep curve rather than a straight diagonal line. A flat low section keeps fans quiet and stable through normal temperature fluctuation; a steep upper section slams them to full speed only when you are genuinely under load. Here is a proven quiet-daily curve for a CPU air cooler:
Curve: "CPU Silent" (source: CPU package)
Temp (C) Fan (%)
--------- -------
0 20 <- floor above the 18% start threshold
50 20 <- stays flat and silent through idle/browsing
60 35
70 55
80 85
85 100 <- full send before thermal throttling
Response time: 4 s up / 8 s down (smooths CPU spikes)
Hysteresis : 3 C (prevents micro-oscillation)Notice the flat 20% shelf from 0 °C to 50 °C. That single design choice eliminates the majority of annoying fan noise, because your CPU spends most of its life below 50 °C and the fan simply never reacts to the small spikes. Only when a real workload pushes past 60 °C does the curve start climbing. Set the response time and hysteresis fields shown above — they live in the curve’s advanced settings and are what separate a professional-feeling setup from a twitchy one.
Step 6 — Bind Curves to Fans and Pick the Right Temp Source
A curve on its own does nothing; you must bind it to a physical control. Find the fan you want to drive in the Controls column, click its Curve selector, and choose the curve you just built. The fan’s percentage will immediately snap to whatever the curve dictates for the current temperature. Repeat for each fan, assigning the appropriate curve and confirming the temperature source is correct.
Two bindings deserve special care. First, if you own an all-in-one liquid cooler, locate the pump header (often labeled AIO_PUMP or CPU_OPT) and set it to a flat 100% control or a fixed high value — never a temperature curve. Pumps are not meant to modulate for cooling, and slowing one down to chase quiet can cause coolant cavitation and long-term wear. Second, for the GPU fan, verify that FanControl actually has authority; some cards allow control only when their own vendor software is closed. If you use a graphics utility for overclocking, our comparison of the NVIDIA App versus GeForce Experience explains which background services can clash with third-party fan control.
Once every fan is bound, watch the Speeds column for 30 seconds. RPM values should be stable and match the duty you expect. If a fan reads 0 RPM while its control shows 25%, you are below its start threshold from Step 3 — raise the curve floor.
Step 7 — Combine Sensors With a Mix Curve
Real systems have more than one heat source, and this is where FanControl leaves BIOS behind entirely. A Mix curve takes several input curves and combines them with a function — typically Max, but also Average, Min, Sum, or a custom function. The classic use case: drive your exhaust fans off whichever is hotter right now, the CPU or the GPU.
First build two graph curves — one keyed to CPU temperature, one keyed to GPU hotspot. Then press +, choose Add “Mix” fan curve, set the function to Max, and add both curves as inputs. The mix outputs the higher of the two demands at every instant, so your case exhaust ramps up whether you are compiling code (CPU-bound) or gaming (GPU-bound) without you touching anything.
Mix curve: "Exhaust Smart"
function = Max
inputs:
- "CPU Exhaust" (source: CPU package)
- "GPU Exhaust" (source: GPU hotspot)
Runtime behavior:
CPU 72C -> CPU curve demands 55%
GPU 44C -> GPU curve demands 25%
Max(55, 25) = 55% -> exhaust runs at 55%
(later, mid-game)
CPU 55C -> 30%
GPU 71C -> 60%
Max(30, 60) = 60% -> exhaust follows the GPU nowMix curves can even take other mix curves as inputs, letting you build sophisticated logic like “run the front intake at the average of GPU and NVMe, but never below what the CPU demands.” Start simple with a single Max mix for your exhaust; it is the highest-value curve most people build.
Step 8 — Stop Fan Ramping With a Trigger Curve (Hysteresis)
Sometimes you do not want a proportional response at all — you want a fan that is off (or quiet) until a threshold, then jumps to a set speed, and importantly stays there until the temperature drops well below the trigger point. That is a Trigger curve, and its two-threshold design is the cleanest way to eliminate the on-off-on-off oscillation that plagues naive setups.
Add a Trigger curve, set an idle speed, a load speed, and two temperatures: the upper temperature that turns the fan up and a lower temperature that turns it back down. The gap between them is your hysteresis band. Because the fan will not drop back down until the temperature falls past the lower threshold, it cannot flutter around a single point.
Trigger curve: "GPU Zero-RPM"
idle speed : 0% (fans fully stopped, silent desktop)
load speed : 45%
upper temp : 55 C (fans spin up when GPU passes 55C)
lower temp : 48 C (fans stop again only below 48C)
Result: a clean 7 C dead band. The fan will not
stutter on and off while the GPU hovers near 55 C.This is ideal for GPU zero-RPM behavior and for hard drives that only need airflow during sustained writes. If you have ever been annoyed by a fan that clicks on and off every few seconds at a fixed workload, a trigger curve with a healthy dead band is the fix.
Step 9 — Use Sync and Flat Curves for Pumps and AIOs
FanControl offers five curve types in total, and the last two are the simplest but still essential. A Flat curve is a single fixed percentage — perfect for AIO pumps (set 100%), for a fan you simply want at a constant quiet 30%, or as a temporary override while testing. A Sync curve mirrors another control exactly, so multiple fans move in lockstep without duplicating curve logic; build one master curve, then sync your three intakes to it and adjust them all from one place.
Here is the complete curve-type cheat sheet so you always reach for the right tool:
| Curve type | What it does | Best used for |
|---|---|---|
| Graph | Temperature-to-speed nodes on a graph | Primary CPU, GPU, and case fan control |
| Mix | Combines curves with Max/Avg/Min/Sum | Exhaust driven by hottest of several sensors |
| Trigger | Two-threshold on/off with hysteresis | Zero-RPM GPU, sporadic drive cooling |
| Sync | Mirrors another control | Ganging multiple identical fans together |
| Flat | One fixed percentage | AIO pumps, constant-speed fans, testing |
With graph, mix, trigger, sync, and flat curves in your toolkit, there is no fan behavior you cannot express. The remaining steps are about making your configuration permanent, switchable, and extensible.
Step 10 — Save Configs and Auto-Start With the FanControl Service
None of your work survives a reboot until you save it and arrange for FanControl to start with Windows. Open the app menu and choose Save configuration; the settings write to a JSON file in the Configurations folder. Give it a descriptive name so you can recognize it later. This file is your entire setup — back it up, and you can restore a machine in seconds.
For auto-start, the 2026 releases added a genuinely useful feature. The FanControl Service, introduced in V268 (May 2026), lets the app run as a proper Windows service with a “start service on boot” option and a lightweight tray client. This is more robust than the old “start with Windows” scheduled-task method because the service loads before you log in, so your fans are under control from the moment the machine powers on — not just after you reach the desktop. Enable it under Settings.
# Verify the FanControl service is installed and running (PowerShell, admin)
Get-Service -Name "*FanControl*" | Format-Table -Auto
# Expected output:
# Status Name DisplayName
# ------ ---- -----------
# Running FanControlService Fan Control Service
# Confirm the .NET 8 runtime is present (if you use the .NET build)
dotnet --list-runtimes | Select-String "Microsoft.WindowsDesktop.App 8"If you prefer the classic approach, the Settings menu still offers a plain “Start with Windows” toggle that registers a scheduled task with the highest privileges. Either way, reboot once and confirm your fans behave correctly before you log in — that is the real test that persistence is working.
Step 11 — Create Switchable Silent and Gaming Profiles
This is the complete working project that ties everything together: two full configurations you can swap in one click. A Silent profile keeps everything as quiet as possible for browsing, office work, and video; a Gaming profile prioritizes low temperatures and accepts more noise. Because each FanControl configuration is just a JSON file, switching profiles is instantaneous and lossless.
Build the Silent profile using the flat-shelf curves from Step 5, then use Save configuration as to store it as silent.json. Now raise every curve’s floor and steepen the ramps, and save that as gaming.json. The two profiles might look like this:
| CPU temp (°C) | Silent profile fan % | Gaming profile fan % |
|---|---|---|
| 40 | 20 | 35 |
| 50 | 20 | 45 |
| 60 | 30 | 60 |
| 70 | 50 | 80 |
| 80 | 80 | 95 |
| 85 | 100 | 100 |
You can switch profiles inside the app, but the power-user move is a desktop shortcut that launches a specific config. FanControl accepts a config path on the command line, so you can create two shortcuts — or wire them to a stream-deck button or a scheduled task — and flip your whole cooling behavior without opening the UI.
# Two shortcuts that load different fan profiles
# Silent (target field of a Windows shortcut):
"C:\Tools\FanControl\FanControl.exe" -c "silent.json"
# Gaming:
"C:\Tools\FanControl\FanControl.exe" -c "gaming.json"
# Optional: auto-load the gaming profile at logon via a scheduled task
schtasks /Create /TN "FanControl-Gaming" /RL HIGHEST /SC ONLOGON /TR ^
"\"C:\Tools\FanControl\FanControl.exe\" -c \"gaming.json\""With this project done, you have a machine that whispers on the desktop and breathes hard in-game, switchable on demand. That is the payoff that no BIOS fan page can match.
Step 12 — Extend FanControl With Plugins
FanControl’s core reads standard motherboard and GPU sensors, but hardware that speaks a proprietary protocol — certain Corsair, NZXT, or Aquacomputer devices, or exotic sensors like coolant-flow meters — needs a plugin. Plugins are community-built .NET libraries that add new sensors or control outputs. Installing one is as simple as dropping a DLL into the Plugins folder and restarting the app.
C:\Tools\FanControl\Plugins\
├── FanControl.CorsairLink.dll # Corsair Commander / Hydro devices
├── FanControl.LiquidCtl.dll # NZXT, Aquacomputer, EK via liquidctl
└── FanControl.NvidiaGpu.dll # extended NVIDIA sensor exposure
# After adding a DLL: fully close FanControl (right-click tray -> Exit),
# then relaunch as admin. New sensors appear in the tree automatically.Only install plugins from sources you trust, because they run with the same privileges as the app itself. The most popular ones are maintained on GitHub and widely used, but a random DLL from a forum post is a security risk. When a plugin exposes a new sensor — say, water temperature from an AIO — you can immediately use it as a temperature source for any curve, closing the loop on truly custom cooling. If you are cleaning up a system that previously ran conflicting vendor tools, our guide to using Display Driver Uninstaller pairs well here for wiping leftover GPU services that fight for control.
Common Pitfalls to Avoid
Most FanControl frustration comes from a short list of avoidable mistakes. Read these before you spend an hour debugging.
- Running without administrator rights. The ring-0 driver cannot load as a standard user, so sensors and controls appear empty or frozen. Always run elevated, and set the service or scheduled task to “highest privileges.”
- Leaving BIOS Smart Fan / Q-Fan active. Firmware and FanControl will tug-of-war over the same header, producing erratic speeds. Set the relevant headers to full-speed or manual in BIOS so Windows owns them.
- Drawing a straight diagonal curve. A linear line makes fans track every tiny temperature wobble, creating the constant hum you are trying to kill. Use a flat low shelf and a steep top, plus response-time smoothing.
- Setting a curve floor below the start threshold. If your minimum is under the calibrated spin-up point, the fan can stall and never restart under load — a genuine hardware risk. Keep the floor at or above the Step 3 start value.
- Modulating an AIO pump. Putting a temperature curve on a pump header to “save noise” invites cavitation and premature failure. Pumps belong on a flat 100% control.
- Not backing up your config. The JSON in the Configurations folder is your entire setup. A drive wipe or accidental delete erases hours of tuning. Copy it somewhere safe.
- Using an outdated build on FACEIT or Vanguard. Pre-V238 copies use WinRing0, which trips Defender and some anti-cheats. Keep the app current, and expect PawnIO to be blocked by strict anti-cheat clients.
Troubleshooting FanControl: 8 Common Fixes
When something misbehaves, work through this table from top to bottom. Each row pairs the symptom with the most likely cause and the fastest fix.
| Symptom | Likely cause | Fix |
|---|---|---|
| No fans in the Controls column | Not running as admin, or fans on a hub/PSU | Relaunch elevated; confirm headers in BIOS |
| Defender flags FanControl.sys as a Trojan | Old WinRing0 build (V237 or earlier) | Update to V238+ which ships the PawnIO driver |
| Fan shows a % but reads 0 RPM | Duty below the fan’s start threshold | Recalibrate; raise the curve floor above spin-up |
| GPU fan will not respond | Vendor software holding control, or locked card | Close vendor GPU app; check card supports override |
| Settings reset after every reboot | Config not saved or app not auto-starting | Save config; enable the FanControl Service |
| Fan speed jumps up and down constantly | Linear curve with no smoothing | Add hysteresis and response time; use a trigger curve |
| Driver blocked / anti-cheat error | FACEIT or similar rejecting PawnIO | Start FanControl before the anti-cheat, or accept the limit |
| A sensor you need is missing | Proprietary hardware needs a plugin | Install the matching plugin DLL and restart |
If none of these resolve the issue, the Logs folder next to the executable captures a detailed startup and sensor trace. The community-maintained issues tracker on GitHub is well populated and searchable; nearly every hardware-specific quirk has already been discussed there.
Advanced Tips for Power Users
Once your basics are solid, these techniques squeeze out the last bit of polish. First, tune response times per curve: a longer “down” time than “up” time means fans ramp quickly under a sudden load but coast down gently, which sounds far more natural than symmetric timing. Second, use custom offset sensors — you can create a synthetic sensor that is “GPU hotspot minus 10 °C” to normalize a card that reports unusually high hotspot deltas.
Third, take advantage of the tray icons: FanControl can pin live temperature or RPM readouts to the system tray, giving you at-a-glance monitoring without opening the window. Fourth, exploit the V267 manual calibration “avoid regions” feature to blacklist any RPM band that causes case resonance — the curve will simply skip over the buzzing zone. Fifth, remember that configs are portable: build a great profile on one machine and copy the JSON to an identical build to replicate it instantly, adjusting only for different fan models. Finally, if you run a mini-ITX or handheld-style build where thermals are tight, treat the exhaust mix curve as your priority tuning target; small cases live or die on getting hot air out. For broader context on how airflow-constrained systems behave, our breakdown of gaming laptops versus desktops shows why chassis volume changes the entire thermal equation.
Frequently Asked Questions
Is FanControl really free?
Yes. FanControl is free to download and use with no feature paywall and no account. It is donationware — the author accepts optional contributions — but nothing is locked behind payment. Note that it is free, not fully open source: the README states plainly that “sources for this software are closed,” even though the release repository, plugin SDK, and issue tracker are public on GitHub.
Is FanControl a virus or safe to install?
It is safe when downloaded from the official GitHub repository or project site and kept updated. Historic malware warnings stem from the old WinRing0 kernel driver, which Microsoft Defender flagged as Trojan:Win32/Vigorf.A on builds V237 and earlier. Since V238 the app uses the signed, sandboxed PawnIO driver instead, resolving those flags. Avoid third-party download mirrors, which often bundle outdated or tampered copies.
Does FanControl work with NVIDIA and AMD GPUs?
Both are supported. FanControl controls NVIDIA fans through NVAPI and AMD fans through the ADLX interface. A minority of laptop and OEM graphics cards lock their fan tables in firmware and cannot be overridden by any software, but most standard desktop cards work. Close any vendor GPU utility that might be holding exclusive control if the fan does not respond.
What is the difference between a Mix and a Sync curve?
A Mix curve combines several input curves with a function such as Max or Average to produce one output — use it to drive a fan from the hottest of multiple components. A Sync curve simply mirrors another control one-to-one, so several fans move together from a single master curve. Mix is for blending logic; Sync is for ganging identical fans.
Does FanControl run on Linux?
No. FanControl is a Windows-only application targeting Windows 10 and 11. Linux users have separate native tools for fan curves (such as the kernel’s own fancontrol utility from lm-sensors, which is unrelated to this app despite the shared name). The two should not be confused.
Why did my fans stop working after a Windows update?
A Windows or Defender definition update can occasionally quarantine an older driver or reset a service permission. Confirm you are on a current FanControl build (V238 or later for PawnIO), re-run the app as administrator, and verify the FanControl Service is still enabled. If the driver was removed, the guided setup will reinstall it on the next launch.
Can I control my AIO pump speed with FanControl?
You can, but you generally should not modulate it for cooling. Set the pump header to a flat 100% (or a fixed high percentage) rather than a temperature curve. Pumps deliver best cooling and longest life at a steady speed; slowing one to reduce noise risks cavitation and wear for negligible acoustic gain.
How is FanControl different from MSI Afterburner?
They solve different problems and are often used together. MSI Afterburner focuses on GPU clocks, voltage, and the graphics card’s own fan; FanControl orchestrates every fan in the system — CPU, case, and GPU — from any sensor with far richer curve types. Many builders run Afterburner for GPU overclocking and FanControl for whole-system airflow.
The Bottom Line: Quiet at Idle, Cool Under Load
FanControl turns a noisy, thermally sloppy PC into a machine that responds intelligently to what you are actually doing. The 12 steps in this guide — download, guided setup, calibration, sensor mapping, graph curves, binding, mix curves, trigger hysteresis, sync/flat curves, saving and auto-start, switchable profiles, and plugins — give you a complete, production-ready cooling configuration. The 2026 releases, with the PawnIO driver and the new FanControl Service, have also closed the two long-standing complaints about the app: the malware false-positives and the flaky auto-start.
Start with the silent flat-shelf curve, add a Max mix for your exhaust, and layer in a trigger curve for GPU zero-RPM. That combination alone will transform how your system sounds and cools. From there, the tool scales as far as your patience for tuning goes — and because every setting lives in a portable JSON file, you never have to build it twice.
