Wyjaśnienie nowego menedżera pamięci

On iOS your shared code runs as Kotlin/Native, which manages its own memory. Knowing how it works keeps your app stable.

The original model froze objects so threads could share them. That freezing rule caused confusing crashes and a lot of workarounds.

Modern Kotlin/Native ships a new memory manager that drops the freezing rule entirely. Shared objects just work across threads now.

You no longer hit InvalidMutabilityException when touching state from another thread. Mutable objects can cross threads freely.

The new model behaves much like the JVM you know from Android. The same shared Kotlin runs with familiar semantics on both.

A real garbage collector reclaims unused objects automatically. You write normal Kotlin and let the runtime clean up after you.

Recent Kotlin versions enable the new manager by default, so a fresh KMP project already uses it. No special flag needed.

Because state is no longer frozen, coroutines can carry mutable data across dispatchers on iOS exactly like they do on Android.

You can read and write a normal object from several threads without freezing it first. The runtime handles the bookkeeping for you.

The manager removes freezing, but it does not remove race conditions. Two threads writing the same field still need coordination.

The new manager means your shared logic ports to iOS with almost no special handling. You focus on features, not memory rules.

A quick check on the memory manager.

You saw how the new memory manager ends freezing, adds garbage collection, and makes shared Kotlin feel JVM-like on iOS. 🎉