How Smart Loop Analysis, Caching, and Reanalyze Work

Smart Loop is one of the most advanced systems in Atmos, and a lot of its real behavior is easy to miss if you only think of it as a simple “better loop” toggle.

Behind the scenes, Atmos analyzes the track, builds a beat graph, caches the result, and then uses a staged jump system during playback to create less repetitive loop behavior.

This guide explains how that process works and what reanalyze actually does.

Smart Loop starts with track analysis

Before Atmos can make Smart Loop decisions, it needs information about the structure of the file.

That means the app analyzes the audio to find:

• beat times
• beat strengths
• feature vectors for different parts of the song
• candidate jumps between structurally similar beats

So Smart Loop is not guessing blindly while playback is happening. It is working from a prepared analysis model.

The analysis is local

Atmos performs Smart Loop analysis locally on the user’s machine.

There is no remote service call for this system. The app reads the local media file, extracts a mono analysis stream, detects beats, computes features, and builds the jump graph on-device.

That is important because it keeps the feature responsive and self-contained.

Smart Loop uses a beat graph, not just one loop point

Another important hidden detail is that Smart Loop does not simply compute one magic splice position and call it done.

Instead, it builds a graph of beat points and similarity candidates.

That gives the playback system multiple possible structural jumps instead of one fixed loop destination.

This is a big part of why the system can feel more organic over time.

Hidden behavior: candidate jumps are filtered aggressively

Atmos does not keep every weak similarity match.

The graph-building step applies thresholds and filtering such as:

• minimum raw similarity
• mutual top-match checks
• cluster deduplication
• limits on the number of target candidates

That matters because without those filters, Smart Loop would have too many low-quality jump options and would feel much messier.

Analysis progress is surfaced in stages

While analysis is running, Atmos updates progress through a few coarse phases rather than pretending it is doing nothing until the end.

The progress steps reflect the broad stages of the pipeline, including:

• loading and preparing samples
• beat detection
• feature extraction
• graph building

This gives users a better sense of what the app is doing when Smart Loop first analyzes a file.

Smart Loop caches the analysis result

Once the analysis is complete, Atmos stores the resulting beat graph in a cache file.

That means the app does not need to recompute the whole structure every time the same file is used again.

This is one of the main reasons Smart Loop can feel fast after the first analysis pass.

Hidden behavior: the cache key depends on file path and modification date

Atmos does not cache analysis by filename alone.

Its Smart Loop cache key includes:

• the file path
• the file modification time
• a cache-version prefix

This is a smart design choice because it means the app can invalidate an old cached result automatically if the underlying file changes.

Why modification-aware caching matters

If a user edits or replaces a media file in place, the app should not necessarily trust an older analysis result forever.

By including the modification date in the cache key, Atmos treats a changed file as analytically different even if the path still looks the same.

That makes the cache much safer than a path-only lookup would be.

Hidden behavior: cached analysis is skipped only when allowed

Atmos only reuses cached Smart Loop data when the analysis request is not forcing a refresh.

That means cached results are the default fast path, but the app still has a clean way to bypass them when the user explicitly wants a fresh analysis.

This is exactly where reanalyze becomes important.

What reanalyze actually does

When you trigger reanalyze, Atmos does not just restart the same status animation.

It:

• resets the active Smart Loop state
• marks the system as not ready
• resets progress values
• forces a fresh analysis pass
• bypasses the existing cache

That means reanalyze is a real invalidation and rebuild path, not just a cosmetic retry button.

Hidden behavior: turning Smart Loop off also resets runtime jump state

Separate from full reanalysis, Atmos also resets Smart Loop’s runtime jump state when Smart Loop is turned off.

That clears things like:

• recent jump targets
• pending jump decisions
• jump timing memory

So toggling Smart Loop off is already a smaller cleanup step even if it does not rebuild the underlying analysis graph.

Playback uses a two-phase jump system

One of the most interesting hidden details in Smart Loop is that Atmos does not make the whole jump decision at the exact last instant.

Instead, it works in two phases:

1. look ahead and choose a strong upcoming jumpable beat
2. execute the already-chosen jump when playback reaches the decision point

This staged behavior helps the system feel smoother and more intentional during real playback.

Hidden behavior: lookahead is limited to a future window

Atmos only considers beats in a forward-looking time window rather than scanning the whole track equally at every moment.

That lets it evaluate plausible near-future jump opportunities without turning each playback tick into an expensive global search.

The result is a more practical live system.

Smart Loop is not purely deterministic

Smart Loop is also not rigidly deterministic in the simple sense of “when beat X appears, always jump to beat Y.”

Atmos uses:

• jump probability
• weighted target selection
• recent-target avoidance
• small bonuses for certain structural targets

That means the same track can feel alive over time instead of repeating the exact same alternate route every cycle.

Jump probability controls how often the system takes a jump

The jump probability value is one of the most user-visible Smart Loop tuning knobs.

At a high level, it controls how willing Atmos is to convert a good jump opportunity into a real jump during playback.

Higher values create a more active Smart Loop feel.

Lower values make the system more conservative.

Minimum similarity controls how strict candidate selection is

The minimum similarity slider changes how strict Smart Loop is about accepting candidate matches.

If the threshold is raised, Atmos will prefer more strongly matched jump targets.

If it is lowered, the system becomes more permissive and may find more opportunities, but with looser structural matching.

That is why this control can change the feel of the system quite a bit.

Hidden behavior: recent targets are avoided on purpose

Atmos keeps a short memory of recently used jump targets.

That means Smart Loop tries not to keep throwing playback back into the exact same few sections over and over if other strong targets exist.

This is one of the more important anti-repetition details in the whole feature.

Smart Loop also enforces a minimum time between jumps

The app does not allow Smart Loop to fire continuously in rapid succession.

It keeps a minimum play interval between jump commits so playback has time to breathe before another structural jump is considered.

Without that spacing, the feature could feel chaotic rather than musical.

Cache cleanup is built into the system too

Atmos also manages Smart Loop cache growth.

It does not just keep every old analysis artifact forever. The cache layer evicts stale entries after the cache grows beyond a limit.

That helps the system stay practical over time, especially for users who analyze many files.

Why this system feels stronger than a basic loop enhancer

The full Smart Loop system is doing several things at once:

• analyzing local audio structure
• building beat-to-beat similarity candidates
• caching analysis intelligently
• bypassing cache when the user asks for a rebuild
• scheduling jumps in two phases
• adding controlled randomness and anti-repetition logic

That is why the feature feels more sophisticated than a simple seamless-loop checkbox.

What users should take away

The practical rules are:

• the first Smart Loop pass analyzes the track locally
• Atmos caches the beat graph so future use is faster
• cache reuse depends on file path, file modification time, and cache version
• reanalyze forces a fresh analysis instead of trusting the old cache
• jump probability and minimum similarity meaningfully change runtime behavior
• Smart Loop avoids repeating the same jump targets too often

Once you understand those rules, the feature becomes much easier to tune and trust.

Smart Loop is not just a prettier loop button. It is a real local analysis-and-decision system built into Atmos.