{
  "schema_version": 2,
  "id": "operate/oss_and_stack/reference/arm",
  "title": "ARM support",
  "url": "https://redis.io/docs/latest/operate/oss_and_stack/reference/arm/",
  "summary": "Exploring Redis on the ARM CPU Architecture",
  "tags": [
    "docs",
    "operate",
    "stack",
    "oss"
  ],
  "last_updated": "2026-09-21T15:59:03+01:00",
  "page_type": "content",
  "content_hash": "23de5bf6db0baed5fd6de7602594fbbf6f6be446ace5c21d8ed72a68ebd5afa6",
  "sections": [
    {
      "id": "overview",
      "title": "Overview",
      "role": "overview",
      "text": "Redis versions 4.0 and above support the ARM processor in general, and\nthe Raspberry Pi specifically, as a main platform. Every new release of Redis is tested on the Pi\nenvironment, and we update this documentation page with information about supported devices and other useful information. While Redis does run on Android, in the future we look forward to extend our testing efforts to Android\nto also make it an officially supported platform.\n\nWe believe that Redis is ideal for IoT and embedded devices for several\nreasons:\n\n* Redis has a very small memory footprint and CPU requirements. It can run in small devices like the Raspberry Pi Zero without impacting the overall performance, using a small amount of memory while delivering good performance for many use cases.\n* The data structures of Redis are often an ideal way to model IoT/embedded use cases. Some examples include accumulating time series data, receiving or queuing commands to execute or respond to send back to the remote servers, and so forth.\n* Modeling data inside Redis can be very useful in order to make in-device decisions for appliances that must respond very quickly or when the remote servers are offline.\n* Redis can be used as a communication system between the processes running in the device.\n* The append-only file storage of Redis is well suited for SSD cards.\n* The stream data structure included in Redis versions 5.0 and higher was specifically designed for time series applications and has a very low memory overhead."
    },
    {
      "id": "redis-proccpualignment-requirements",
      "title": "Redis /proc/cpu/alignment requirements",
      "role": "content",
      "text": "Linux on ARM allows to trap unaligned accesses and fix them inside the kernel\nin order to continue the execution of the offending program instead of\ngenerating a `SIGBUS`. Redis 4.0 and greater are fixed in order to avoid any kind\nof unaligned access, so there is no need to have a specific value for this\nkernel configuration. Even when kernel alignment fixing set as disabled Redis should\nrun as expected."
    },
    {
      "id": "building-redis-in-the-pi",
      "title": "Building Redis in the Pi",
      "role": "content",
      "text": "* Download Redis version 4.0 or higher.\n* Use `make` as usual to create the executable.\n\nThere is nothing special in the process. The only difference is that by\ndefault, Redis uses the `libc` allocator instead of defaulting to `jemalloc`\nas it does in other Linux based environments. This is because we believe\nthat for the small use cases inside embedded devices, memory fragmentation\nis unlikely to be a problem. Moreover `jemalloc` on ARM may not be as tested\nas the `libc` allocator."
    },
    {
      "id": "performance",
      "title": "Performance",
      "role": "performance",
      "text": "Performance testing of Redis was performed on the Raspberry Pi 3 and Pi 1 model B. The difference between the two Pis in terms of delivered performance is quite big. The benchmarks were performed via the\nloopback interface, since most use cases will probably use Redis from within\nthe device and not via the network. The following numbers were obtained using\nRedis 4.0.\n\nRaspberry Pi 3:\n\n* Test 1 : 5 millions writes with 1 million keys (even distribution among keys).  No persistence, no pipelining. 28,000 ops/sec.\n* Test 2: Like test 1 but with pipelining using groups of 8 operations: 80,000 ops/sec.\n* Test 3: Like test 1 but with AOF enabled, fsync 1 sec: 23,000 ops/sec\n* Test 4: Like test 3, but with an AOF rewrite in progress: 21,000 ops/sec\n\nRaspberry Pi 1 model B:\n\n* Test 1 : 5 millions writes with 1 million keys (even distribution among keys).  No persistence, no pipelining.  2,200 ops/sec.\n* Test 2: Like test 1 but with pipelining using groups of 8 operations: 8,500 ops/sec.\n* Test 3: Like test 1 but with AOF enabled, fsync 1 sec: 1,820 ops/sec\n* Test 4: Like test 3, but with an AOF rewrite in progress: 1,000 ops/sec\n\nThe benchmarks above are referring to simple [`SET`](https://redis.io/docs/latest/commands/set)/[`GET`](https://redis.io/docs/latest/commands/get) operations. The performance is similar for all the Redis fast operations (not running in linear time). However sorted sets may show slightly slower numbers."
    }
  ],
  "examples": []
}