Aniimo Low FPS in Floating Metropolis: Complete Performance & Stuttering Fix Guide

There is a particular kind of performance problem that drives me crazy in open-world games: everything runs perfectly until you reach the one location that actually matters. That is exactly what can happen in Aniimo, especially after entering the Floating Metropolis. You can spend hours exploring the wider world at a comfortable 80, 90, or even 100+ FPS, only to walk through the city gates and suddenly watch the counter collapse into the 30s.

What makes the problem especially frustrating is that the Floating Metropolis doesn’t necessarily look demanding enough to justify such a dramatic hit. The city is packed with vertical structures, atmospheric effects, NPCs, shops, distant platforms, reflective materials, and constantly streaming assets, but modern GPUs such as the RTX 40 series and RX 7000 series should be capable of handling considerably more. In practice, however, the problem isn’t simply about raw GPU power.

From my experience with plenty of open-world RPGs, this feels much more like an engine and frame-pacing problem than a straightforward graphics-quality issue. A game can report 45 FPS and still feel awful if those frames arrive unevenly. That is why fixing Aniimo low FPS in the Floating Metropolis requires looking at CPU workload, shader compilation, asset streaming, VRAM usage, and frame-time consistency rather than blindly lowering every graphics setting.

The good news is that you don’t necessarily have to turn Aniimo into a blurry mess to make the city playable. A few targeted changes can make a surprisingly large difference.

Aniimo Best Graphics Settings for RTX 3060: Max FPS and Performance Guide

Why Does Aniimo Run Worse in the Floating Metropolis?

The Floating Metropolis is essentially a stress test for the game’s entire rendering pipeline. Unlike a relatively open wilderness area, the city has to keep track of large numbers of objects and characters at the same time, often across several vertical layers.

There are also plenty of small details that aren’t immediately obvious. NPC behavior, pathfinding, dynamic shadows, distant geometry, volumetric fog, reflections, and background asset streaming can all compete for CPU and GPU resources. When several of these systems become busy simultaneously, the game’s main rendering thread can become the limiting factor.

This explains one of the most confusing symptoms: GPU utilization isn’t always at 99% when FPS collapses. If the CPU or rendering thread is struggling to prepare frames, a powerful graphics card can sit there waiting for additional work.

In other words, buying a faster GPU isn’t necessarily the magic solution. The Floating Metropolis needs smarter settings.

1. Start With the Graphics Settings That Actually Matter

My first rule with an unoptimized PC game is simple: don’t immediately drop the entire preset from Ultra to Low. You often sacrifice a huge amount of image quality for relatively little performance gain.

Instead, target the settings that create the biggest workload.

Volumetric Clouds and Fog

This is one of the first options I would reduce.

The Floating Metropolis is surrounded by clouds and atmospheric effects, and volumetric rendering can be extremely expensive. If your GPU is already struggling in the city, Medium or Low volumetric quality is a good starting point.

The visual difference isn’t always as dramatic as you might expect, particularly when the city is already filled with haze and bright lighting effects. Meanwhile, the performance improvement can be substantial.

Crowd Density and NPC Detail

The city wouldn’t feel like a city without NPCs, but all those characters aren’t free from a performance perspective.

Lower Crowd Density to Medium if you’re experiencing severe stuttering. This can reduce the number of active AI routines and associated CPU work.

Personally, I’d much rather lose a few background citizens than watch my frame time constantly spike while running through the marketplace.

Shadow Quality

Dynamic shadows are another common performance trap.

The Floating Metropolis contains multiple levels, platforms, structures, and moving light sources, which can make shadow rendering particularly expensive. Try Medium shadow quality first rather than completely disabling shadows.

The city will still look good, but your GPU and VRAM should have more breathing room.

View Distance and Level of Detail

Ultra view-distance settings are often guilty of wasting performance on objects you barely notice.

Set Object Detail or LoD to High instead of Ultra. You still retain a convincing world at normal gameplay distances, while the engine doesn’t have to maintain unnecessarily detailed geometry far outside your immediate surroundings.

The idea isn’t to make Aniimo look worse. It’s to remove expensive settings that provide relatively little visual benefit.

2. Don’t Ignore Frame Pacing

This is probably the most overlooked part of troubleshooting Aniimo stuttering.

Imagine your game is running at 45 FPS. On paper, that sounds reasonably playable. But if one frame takes 15 milliseconds, the next takes 40 milliseconds, and another takes 20 milliseconds, movement can feel noticeably jerky.

That is frame-time inconsistency, and it can make a stable-looking FPS counter completely misleading.

If Aniimo’s internal limiter isn’t producing consistent frame delivery on your system, an external limiter such as RivaTuner Statistics Server (RTSS) can be worth trying.

Install RTSS, add the Aniimo executable, and set a frame-rate limit that your PC can actually maintain in the Floating Metropolis. If the game fluctuates between 40 and 55 FPS, for example, chasing 60 FPS isn’t necessarily useful. A consistent 45 FPS can feel considerably smoother than an unstable 55 FPS.

That’s something I’ve learned from playing plenty of demanding PC games: consistency usually feels better than a higher number that constantly moves around.

Disable the game’s own frame limiter if necessary and allow RTSS to handle the cap. You can also experiment with V-Sync depending on your monitor and VRR setup, but don’t assume that simply enabling every synchronization option will improve things.

3. Deal With DirectX 12 Shader Stuttering

Shader compilation is another potential reason Aniimo can hitch when you enter areas containing new materials and effects.

The Floating Metropolis has an enormous variety of surfaces: metallic structures, glass, neon lighting, reflective materials, atmospheric effects, and countless decorative objects. When a game compiles shaders during gameplay instead of preparing everything ahead of time, you can get sudden freezes or short but very noticeable stutters.

First, make sure your NVIDIA or AMD graphics driver is up to date. Driver updates frequently include game-specific optimizations and shader-related fixes.

If you’re using NVIDIA hardware, check the Shader Cache settings in the NVIDIA Control Panel. A larger cache can help prevent previously compiled shaders from being discarded too aggressively.

However, there’s an important catch: increasing the cache isn’t a magical fix for every stutter. If an Aniimo update changes its shaders or the cache becomes corrupted, rebuilding it can actually be more useful than simply making it larger.

If stuttering suddenly becomes worse after a major game update, clearing the DirectX Shader Cache through Windows and allowing the game to rebuild it is a reasonable troubleshooting step.

Don’t panic if the first launch afterward feels worse. Shader rebuilding can temporarily increase compilation activity.

4. Watch Your VRAM and System Memory

One of the more annoying performance patterns in large open-world games is gradual degradation.

You launch the game and everything feels great. An hour later, the Floating Metropolis starts hitching. Another hour passes, and suddenly traversal feels terrible even though you haven’t changed any graphics settings.

That can happen when assets aren’t being released from memory efficiently.

Persistent hubs are particularly good at exposing these problems because you repeatedly move between different areas while the game keeps loading new characters, textures, geometry, effects, and environmental assets.

Keep an eye on VRAM and system RAM usage while playing. If memory consumption keeps climbing during a long session, restarting the game can sometimes restore performance immediately.

It’s not an elegant solution, obviously. Nobody wants to restart an RPG every couple of hours. But until a developer-side memory-management fix arrives, a clean restart can be much more effective than endlessly changing graphics settings.

5. Make Sure Windows Has Enough Virtual Memory

Windows virtual memory isn’t going to transform a badly optimized game into a perfectly smooth one, but it can help prevent serious problems when physical RAM becomes exhausted.

If you have plenty of system memory, Windows normally does a good job managing the pagefile automatically. Still, make sure you haven’t accidentally disabled virtual memory or restricted it to an unsuitable drive.

If possible, the pagefile should be located on a fast SSD rather than an old mechanical hard drive.

I generally prefer letting Windows manage the pagefile unless there is a specific reason to configure it manually. If you’re troubleshooting unusual memory exhaustion, however, a larger pagefile can provide additional safety when the game suddenly consumes more RAM than expected.

The important thing is not to confuse virtual memory with real RAM. A pagefile is an emergency resource, not a replacement for physical memory.

6. Turn Off Unnecessary Overlays

Overlays aren’t usually the biggest cause of FPS problems, but when troubleshooting a game with unstable performance, I like eliminating as many variables as possible.

Try disabling overlays from applications such as Discord, Steam, or your GPU software temporarily.

You don’t necessarily have to leave them disabled forever. This is simply a diagnostic step. If Aniimo suddenly becomes smoother, you have identified another layer worth investigating.

The same principle applies to background recording software and hardware-monitoring utilities. When a game is already pushing CPU, GPU, and memory resources hard, removing unnecessary hooks can make troubleshooting much easier.

7. Use DLSS, FSR, or XeSS Instead of Destroying Image Quality

If the Floating Metropolis is primarily GPU-limited on your machine, upscaling is probably the cleanest way to gain performance.

For NVIDIA RTX users, I would start with DLSS Quality. If you’re using a compatible RTX 40-series GPU, Frame Generation can provide another substantial boost to perceived smoothness.

AMD users can experiment with FSR, while Intel GPU owners can consider XeSS where supported.

The important word here is Quality. Don’t immediately jump to Performance mode.

A good-quality upscaler can preserve much of the original image while reducing the resolution the GPU actually renders internally. In a visually busy city full of fog, lighting, and distant objects, the difference between native rendering and a good Quality preset can be surprisingly difficult to notice during normal gameplay.

Frame Generation is a little different. It can increase displayed FPS significantly, but it doesn’t remove the underlying CPU bottleneck. If your base frame rate is extremely low, it shouldn’t be treated as a substitute for fixing the actual performance problem.

What I Would Change First

If I were troubleshooting Aniimo on my own PC, I wouldn’t change twenty settings at once. That makes it impossible to know what actually helped.

I’d use this order:

1. Set volumetric effects to Medium.
2. Reduce crowd density to Medium.
3. Set shadows to Medium and LoD to High.
4. Enable DLSS/FSR/XeSS Quality if GPU-limited.
5. Update the GPU driver.
6. Test frame pacing with a sensible RTSS cap.
7. Clear the shader cache if stuttering appeared after an update.
8. Disable unnecessary overlays.
9. Restart Aniimo after long sessions if memory usage becomes excessive.

This approach keeps the game looking good while targeting the systems most likely to cause performance problems.

The Floating Metropolis Needs an Engine Fix, Not Just Lower Settings

There is a limit to what players can accomplish through the graphics menu.

If Aniimo is genuinely suffering from CPU-bound draw calls, inefficient asset streaming, shader compilation during traversal, or memory-management problems, no combination of Low and Medium settings can completely solve the underlying issue.

That’s why I wouldn’t judge the game’s overall optimization solely by how it performs in an empty field. The Floating Metropolis is the real stress test. It’s where the engine has to demonstrate that it can manage NPCs, vertical geometry, lighting, effects, streaming, and player movement simultaneously.

For now, though, targeted optimization can make the experience considerably more manageable. The biggest mistake is assuming that every FPS drop is caused by the GPU. In a modern open-world RPG, the real culprit can be sitting somewhere between the CPU’s main thread, shader compilation, memory allocation, and frame scheduling.

If your Aniimo FPS suddenly collapses from 90 to 30 inside the Floating Metropolis, don’t immediately start shopping for a new graphics card. Tune the expensive settings, stabilize your frame rate, check memory behavior, and give the shader cache a clean start first. You may be surprised by how much performance is hiding behind a handful of sensible changes.