mimalloc

v3: v2: v1:    v3: mimalloc   mimalloc (pronounced "me-malloc") is a general purpose allocator with excellent performance characteristics. Initially developed by Daan Leijen for the runtime systems of the Koka and Lean languages. Latest release : v3.6.1 (2026-10-30) recommended. Latest v2 release: v2.5.2 (2026-09-12) stable, legacy. Latest v1 release: v1.15.2 (2026-09-12) legacy. mimalloc is a drop-in replacement for malloc and can be used in other programs without code changes, for example, on dynamically linked ELF-based systems (Linux, BSD, etc.) you can use it as: > LD_PRELOAD=/usr/lib/libmimalloc.so myprogram It also includes a way to dynamically override the default allocator in Windows. Notable aspects of the design include: small and consistent: the library is about 12k LOC using simple and consistent data structures. This makes it very suitable to integrate and adapt in other projects. For runtime systems it provides hooks for a monotonic heartbeat and deferred freeing (for bounded worst-case times with reference counting). Partly due to its simplicity, mimalloc has been ported to many systems (Windows, macOS, Linux, WASM, various BSD's, Haiku, MUSL, etc) and has excellent support for dynamic overriding. At the same time, it is an industrial strength allocator that runs (very) large scale distributed services on thousands of machines with excellent worst case latencies. free list sharding: instead of one big free list (per size class) we have many smaller lists per "mimalloc page" which reduces fragmentation and increases locality -- things that are allocated close in time get allocated close in memory. (A mimalloc page contains blocks of one size class and is usually 64KiB on a 64-bit system). free list multi-sharding: the big idea! Not only do we shard the free list per mimalloc page, but for each page we have multiple free lists. In particular, there is one list for thread-local free operations, and another one for concurrent free operations. Free-ing from another thread can now be a single CAS without needing sophisticated coordination between threads. Since there will be thousands of separate free lists, contention is naturally distributed over the heap, and the chance of contending on a single location will be low -- this is quite similar to randomized algorithms like skip lists where adding a random oracle removes the need for a more complex algorithm. eager page purging: when a "page" becomes empty (with increased chance due to free list sharding) the memory is marked to the OS as unused (reset or decommitted) reducing (real) memory pressure and fragmentation, especially in long running programs. secure: mimalloc can be built in secure mode, adding guard pages, randomized allocation, encrypted free lists, etc. to protect against various heap vulnerabilities. The performance penalty is usually around 10% on average over our benchmarks. first-class heaps: efficiently create and use multiple heaps to allocate across different regions. A heap can be destroyed at once instead of deallocating each object separately. New: v3 has true first-class heaps where one can allocate in a heap from any thread. bounded: it does not suffer from blowup [1], has bounded worst-case allocation times (wcat) (upto OS primitives), bounded space overhead (~0.2% meta-data, with low internal fragmentation), and has no internal points of contention using only atomic operations. fast: In our benchmarks (see below), mimalloc outperforms other leading allocators (jemalloc, tcmalloc, Hoard, etc), and often uses less memory. A nice property is that it does consistently well over a wide range of benchmarks. There is also good huge OS page support for larger server programs. The documentation gives a full overview of the API. You can read more on the design of mimalloc in the technical report which also has detailed benchmark results. Enjoy! Versions There are three maintained versions of mimalloc. These are mostly equal except for how the OS memory is handled. New development is mostly on v3, while v1 and v2 are maintained with security and bug fixes. v3: recommended: simplifies the lock-free design of previous versions and improves sharing of memory between threads. On certain large workloads this version may use (much) less memory. Also supports true first-class heaps (that can allocate from any thread) and has more efficient heap-walking (for the CPython GC for example). (release tags: v3.x, development branch dev3). v2: stable legacy mimalloc version. Uses thread-local segments to reduce fragmentation. (release tags: v2.x, development branch dev2 and main) v1: legacy version: initial design of mimalloc (release tags: v1.x, development branch dev). Send PR's against this version if possible (and otherwise dev3). Releases 2026-10-30, v3.6.1: (v3) Many small fixes for CPython integration (thank you @DinoV), Emscripten fixes (#1455, thank you @kleisauke) and reduced memory usage on WASI and Emscripten, C23 free_sized(_aligned) overrides (#1470), improved fork support (#1456), fix armv5tej compilation (#1464), fix MSVC overrides for strdup family (#1460), faster STL allocator trait (#1468), always use a 2-level pagemap for security and simplicity. Experimental support for CHERI platforms. Improved Rust bindings (thank you @OscarTHZhang and @Techcable). Add -DMI_SECURE=MINIMAL as improved security with minimal (~1%) performance impact which puts guard pages around all mimalloc meta-data (but does not encode free lists). Move all static variables into a mi_process_t struct (that is guarded). 2026-10-23, v3.6.0: (v3) add initial profiling hooks and default profiler, "always on" detailed statistics per size-bin, and always-on profiling. Initial rust bindings. Better support for large OS page sizes, support a quiescent state based reclamation interfacec (for CPython), better cache line aware allocation, fix heap visitor where some pages might be skipped, improve fork support, avoid over-alloca