What is an ANI File?

📋 On This Page

What is ANI? Quick Facts How It Animates Timing and Sequence Inside an ANI File ANI vs CUR Where ANI Came From How to Open Use It as Your Pointer Good to Know FAQ

📖 What is an ANI File?

An ANI file is a Windows animated cursor. It holds a short reel of pointer pictures and the timing that plays them, so your cursor can spin, pulse or shimmer instead of sitting still.

The classic example is the busy pointer, the little ring that turns while Windows is working. That motion is an ANI file doing its job, flipping through a handful of frames fast enough to read as one moving shape.

Each frame inside is a normal cursor, so an ANI is best thought of as a flipbook of cursors wrapped in one file, with a clock attached. The sections below unpack how that reel and its clock are put together.

⚡ Quick Facts

Full Name	Windows Animated Cursor
Extension	.ani
Developer	Microsoft
Category	Animated cursor, system file
Container	RIFF, form type ACON
Holds	Cursor frames plus timing
Each Frame	A Windows cursor with a hotspot
Timing Unit	Jiffies, one sixtieth of a second
MIME Type	application/x-navi-animation
Related Formats	CUR, ICO

🎞️ How It Animates

An animated cursor works like a flipbook. Windows shows one frame, waits a beat, shows the next and loops back to the start, which reads as smooth motion once it runs at speed. Here is a five frame reel of a turning ring:

Because every frame is a self contained cursor, an ANI can carry rich, full colour pointers with soft edges, not just simple line art. The only thing the format adds on top of a plain cursor is the reel and its timing.

⏱️ Timing and Sequence

Two pieces of data turn a stack of frames into an animation, the speed and the order. Both are optional extras stored beside the frames.

Speed is measured in jiffies, where one jiffy is a sixtieth of a second. A default rate lives in the header, and a rate table can override it frame by frame, so a pointer can hold on one pose and rush through others.

💡 A neat trick: A sequence table lets frames play in any order and repeat, so a file can store three pictures yet play them 1, 2, 3, 2, 1 for a five step there and back loop. Fewer frames on disk, smoother motion on screen.

🔬 Inside an ANI File

An ANI is a RIFF file, the same tagged chunk container that holds WAV audio and AVI video. Its chunks break down like this:

RIFF ACON Wrapper

The outer tag that labels the file as animated content and wraps everything else inside.

Animation Header

A short chunk that records the frame count, the number of steps in the loop and the default speed.

Rate and Sequence Chunks

Optional tables that set how long each frame shows and what order they play, so frames can repeat.

The Frame List

The pictures themselves, each a complete Windows cursor with its own hotspot, stacked in play order.

🎯 Hotspots ride along: Since each frame is a real cursor, the click point travels inside the animation. Windows keeps tracking that single pixel no matter which frame is on screen at the moment.

⚖️ ANI vs CUR

ANI and CUR are a matched pair, one moving and one still. They even share their frames, since an ANI is essentially a reel of the same images a CUR file holds one of:

Feature	ANI	CUR
Motion	Animated, many frames	Still, a single frame
Container	RIFF ACON	DIB bitmap
Timing	Jiffies per frame	None needed
Each frame	A cursor with a hotspot	The one image, with a hotspot
Typical role	Busy and working pointers	Everyday pointers

✅ Good to know: Both formats plug into the same mouse settings, so you can mix a static arrow with an animated busy ring in one pointer scheme without a second thought.

🕰️ Where ANI Files Came From

Animated cursors arrived with the Windows 95 and NT wave, when the desktop gained room for small flourishes like a spinning wait ring in place of a frozen hourglass. Reusing the RIFF container meant the format slotted into tools Windows already understood.

Decades on, the busy and working pointers you see every day are still ANI files, and custom cursor packs keep the format alive for anyone who wants a livelier desktop.

📂 How to Open an ANI File

Double clicking an ANI does not play it, since Windows hands the file to the pointer system rather than a media player. To study the frames, load it into a tool that reads the format:

✅ See the Frames (Recommended)

Open the .ani in the Univik ICO Converter.
Step through the frames that make up the animation.
Check each frame with its size and colour depth.
Export a frame to ICO or PNG when you want a still.

🧰 Other Routes

Cursor editors: RealWorld Cursor Editor and IcoFX play and edit the animation.
Image viewers: XnView can preview the frames as pictures.
Windows preview: the pointer preview in Mouse settings animates it live.
To use it: assign it as a pointer, shown next.

🖱️ Use It as Your Pointer

An animated cursor slots into Windows the same way a still one does, through the Pointers tab in Mouse settings. The twist is which role you give it.

⚠️ Pick the right role: Assign a .ani to a pointer that suits motion, usually Busy or Working, so the animation reads as a status rather than a distraction. Browse to the file on the Pointers tab, then use Save As to keep it as a scheme. The step by step version, shared with static cursors, lives on our CUR file guide.

⚠️ ANI Good to Know

🚫 The Catches

Windows only: other systems use their own pointer formats.
Not a GIF: a web animation will not work as a desktop pointer.
Bigger files: many frames weigh more than one still cursor.
Can distract: constant motion tires the eye if overused.

✅ What ANI Does Well

Live feedback: a moving pointer signals a busy state.
Frame reuse: a sequence replays frames to save space.
Full colour: each frame supports a smooth alpha edge.
Native fit: Windows plays it with no extra software.

❓ Frequently Asked Questions

An ANI file is a Windows animated cursor. It is a RIFF container that stores a run of cursor frames along with the timing that plays them, which is how you get moving pointers like the spinning busy ring. Each frame is itself a small cursor image.

To look at the frames inside, open the .ani in a tool that reads animated cursors, such as the Univik ICO Converter, which lists each frame and lets you save it out. To use the file, you assign it as a mouse pointer in Windows rather than opening it like a picture.

A CUR is a single still cursor, one frame that never moves. An ANI is the moving version, a sequence of cursor frames plus timing wrapped in a RIFF container. Put simply, ANI is the animated cousin of the static CUR.

You assign it on the same Pointers tab a static cursor uses, usually to the Busy or Working role since those are the pointers that animate. Pick the role, browse to the .ani, then save a scheme so it sticks. The full walkthrough sits on our CUR file guide.

Yes. Every frame inside an ANI is a full cursor image, so it carries the hotspot that marks the click point. The animation plays the frames in place while Windows keeps tracking that one pixel.

A jiffy is the timing unit an ANI uses, and one jiffy equals a sixtieth of a second. The header sets a default speed in jiffies, and an optional rate table can give each frame its own duration for faster or slower moments.

Not directly. Windows animates the pointer with the ANI format, not GIF, so a moving cursor has to be built or converted into a .ani first. A GIF works fine on a web page, but the desktop pointer needs an animated cursor file.

The built in animated pointers, such as the working ring, live in C:\Windows\Cursors alongside the static ones. Custom cursors go in the same folder, and a theme can bundle its own set of .ani files and swap them in together.