# Run Redis on Windows (No Docker, No WSL)

> Redis OSS ships no native Windows binaries. Run Redis natively on Windows without Docker or WSL using custom binaries from Layerbase Desktop or SpinDB.

Published: 2026-07-10
Canonical: https://layerbase.com/blog/redis-on-windows-without-docker

Short version: Redis OSS ships no native Windows binaries, and the usual answers are Memurai, Docker Desktop, or WSL2, all of which mean running Linux to get a key-value store. We compiled Redis from source for Windows and ship it through Layerbase Desktop and the Layerbase CLI, so `lbase create myredis -e redis --start` gives you a real Windows process on `redis://127.0.0.1:6379`. RDB persistence works; AOF persistence and Cluster mode do not.

Redis OSS does not ship native Windows binaries. That's not a bug or an oversight. The Redis maintainers have historically targeted Linux and macOS for the open-source server, and the official docs now point Windows users to Memurai, Redis' Windows compatibility partner, or to WSL.

If you search for "Redis on Windows," the common answers are: use Memurai, install Docker Desktop and run Redis in a Linux container, or enable WSL2 and run Redis inside a Linux subsystem. Those paths work. Docker and WSL still mean you're running Linux to use a key-value store. Docker Desktop adds a VM, a daemon, and several gigabytes of overhead. WSL2 is lighter but still requires managing a Linux distribution inside your Windows machine.

We took a different approach. We compiled Redis from source targeting Windows, tested it, and packaged it as a native binary. You can run it through [Layerbase Desktop](https://layerbase.com/desktop/download) (a GUI) or the [Layerbase CLI](https://layerbase.com/docs/cli) (formerly SpinDB). No containers, no Linux subsystem, no VM. Just Redis, running as a Windows process.

## Contents

- [Why Redis Doesn't Support Windows](#why-redis-doesnt-support-windows)
- [The Usual Workarounds](#the-usual-workarounds)
- [Native Redis on Windows with Layerbase](#native-redis-on-windows-with-layerbase)
  - [Option 1: Layerbase Desktop (GUI)](#option-1-layerbase-desktop-gui)
  - [Option 2: Layerbase CLI](#option-2-layerbase-cli)
- [What About Layerbase Cloud?](#what-about-layerbase-cloud)
- [Connecting to Your Redis Instance](#connecting-to-your-redis-instance)
- [What Works and What Doesn't](#what-works-and-what-doesnt)
- [Wrapping Up](#wrapping-up)

## Why Redis Doesn't Support Windows

Redis uses OS-level features that are deeply tied to Linux: `fork()` for background persistence, `epoll` for I/O multiplexing, and Unix domain sockets for local connections. Windows handles all of these differently. Microsoft maintained a Windows port of Redis years ago (Microsoft Open Technologies), but that project was archived and hasn't been updated since Redis 3.x. The current Redis codebase (8.x) has moved far beyond what that port covered.

The Redis team's position is straightforward: Redis OSS is optimized for Linux and macOS, and Redis itself does not ship native Windows OSS builds. If you're deploying Redis in production, it's almost certainly running on Linux anyway. But for local development on a Windows machine, the lack of a native Redis OSS build means extra friction.

## The Usual Workarounds

### Docker Desktop

The most common suggestion. Install Docker Desktop, pull the `redis:7-alpine` image, and run:

```bash
docker run -d --name redis -p 6379:6379 redis:7-alpine
```

This works, but it means:

- Docker Desktop requires a background VM (Hyper-V or WSL2 backend)
- Memory overhead from the Docker daemon and container runtime
- Port mapping between the container and your host
- Paid subscription required for companies above a certain size
- Redis is running inside a Linux container, not natively on Windows

### WSL2

Enable Windows Subsystem for Linux, install Ubuntu (or another distro), and install Redis through `apt`:

```bash
wsl --install
# Inside WSL:
sudo apt update && sudo apt install redis-server
sudo service redis-server start
```

This gives you a real Linux environment, so Redis runs the way the maintainers intended. But you're managing a Linux distribution inside Windows, switching between file systems, and dealing with networking between WSL and Windows.

Both approaches add layers between you and Redis. If all you want is a local Redis server for development, those layers are overhead.

## Native Redis on Windows with Layerbase

We built custom Windows binaries for Redis. The binary runs as a native Windows process. Your data lives on your Windows file system. Connection happens through `localhost` on the standard Redis port. No containers, no Linux layer.

### Option 1: Layerbase Desktop (GUI)

[Layerbase Desktop](https://layerbase.com/desktop/download) is a desktop app for managing local databases. Download the Windows installer, open the app, and create a new Redis instance with a few clicks.

1. Download Layerbase Desktop from [layerbase.com/desktop/download](https://layerbase.com/desktop/download)
2. Open the app and click **Create Database**
3. Select **Redis** as the engine
4. Give it a name and click **Create**

The app handles downloading the binary, setting up the data directory, and starting the server. You get start/stop controls, connection details, and a visual overview of all your database instances.

### Option 2: Layerbase CLI

If you prefer the terminal, the [Layerbase CLI](https://layerbase.com/docs/cli) is the command-line tool that shares the same engine as Layerbase Desktop. Install it with npm and create a Redis instance in one command. ([What is the Layerbase CLI?](https://layerbase.com/docs/cli))

```bash
npm i -g layerbase
```

Create and start a Redis instance:

```bash
lbase create myredis -e redis --start
```

The CLI downloads the Windows Redis binary (cached after the first run), creates a data directory, and starts the server. Check the connection URL:

```bash
lbase url myredis
```

```text
redis://127.0.0.1:6379
```

Manage the instance:

```bash
lbase stop myredis   # Stop the server
lbase start myredis  # Start it again
lbase list           # See all instances
```

## What About Layerbase Cloud?

This post focuses on local Redis on Windows, but if you want the same database as a managed endpoint, [hosted Redis on Layerbase Cloud](/db/redis) runs on the free tier: $0, no card, and it scales to zero when idle.

Prefer the BSD-licensed fork? [Valkey](https://cloud.layerbase.com/create?engine=valkey) speaks the Redis protocol, works with the same client libraries, and is hosted on the same free tier.

## Connecting to Your Redis Instance

Once Redis is running, connect from your application the same way you would on any platform. The connection URL is `redis://127.0.0.1:6379` (the CLI assigns a different port if 6379 is already in use).

With the `redis` npm package:

```typescript
import { createClient } from 'redis'

const client = createClient({ url: 'redis://127.0.0.1:6379' })
client.on('error', (err) => console.error('Redis client error:', err))
await client.connect()

await client.set('greeting', 'Hello from Windows')
const value = await client.get('greeting')
console.log(value) // "Hello from Windows"

await client.close()
```

With `ioredis`:

```typescript
import { Redis } from 'ioredis'

const redis = new Redis(6379, '127.0.0.1')

await redis.set('key', 'value')
const result = await redis.get('key')
console.log(result)

redis.disconnect()
```

Every Redis client library works. The server speaks the same protocol regardless of the platform it's running on.

## What Works and What Doesn't

Our Windows Redis binary supports the core feature set that matters for local development:

- All data structures (strings, lists, sets, sorted sets, hashes, streams)
- Pub/Sub
- Transactions (MULTI/EXEC)
- Lua scripting
- RDB persistence
- Standard TCP connections on localhost

Our Windows binary does not support AOF (append-only file) persistence. Some third-party Windows ports (like tporadowski/redis, based on Redis 5.0.14) do support AOF by replacing Unix `fork()` with a Windows-compatible background rewrite mechanism, but our binary focuses on the features above. RDB persistence is fully supported and more than sufficient for local development.

Redis Cluster mode is not supported in our Windows binary due to Windows networking constraints (the cluster bus port, firewall/NAT issues). This is a platform limitation, not a file I/O issue. For production clusters, you'll be running on Linux anyway.

## FAQ

### Can you run Redis on Windows without Docker or WSL?

Yes, with a binary compiled for Windows. Redis OSS does not publish one, so the mainstream advice is Memurai, a Linux container, or a Linux subsystem. We build the binary ourselves and both Layerbase Desktop and the Layerbase CLI download and run it for you.

### Why does Redis not support Windows officially?

Because the codebase leans on Linux primitives: `fork()` for background persistence, `epoll` for I/O multiplexing, and Unix domain sockets for local connections. Microsoft maintained a port years ago, but it was archived at Redis 3.x and the current 8.x codebase has moved far past it. Production Redis runs on Linux, so that is where the maintainers spend their effort.

### Does the Windows build support AOF persistence?

No. RDB snapshots work and are more than enough for local development, but append-only file persistence is not in our Windows binary. Some third-party ports built on Redis 5.0.14 replace `fork()` with a Windows-compatible background rewrite to get AOF; ours does not.

### Does Redis Cluster work on Windows?

No, and this one is a platform constraint rather than a build choice: the cluster bus port runs into Windows networking, firewall, and NAT behavior. If you are running a production cluster you are on Linux anyway.

### Which client libraries work?

All of them. The server speaks the same protocol regardless of the platform underneath it, so `redis`, `ioredis`, and everything else connect to `redis://127.0.0.1:6379` unchanged. The CLI picks a different port if 6379 is already taken.

### Should I use Valkey instead?

If licensing matters to your project, it is worth a look. Valkey is the BSD-licensed fork, speaks the same protocol, and works with the same client libraries. We ship a Windows binary for it too.

## Wrapping Up

Redis not supporting Windows is a reasonable decision by the maintainers. Linux is where Redis runs in production, and that's where they focus their effort. But developers use Windows, and needing Docker or WSL just to run a local cache server during development is unnecessary friction.

We built these Windows binaries because we think running a database locally should be a one-step process on any platform. [Layerbase Desktop](https://layerbase.com/desktop/download) gives you a GUI if you want one, and the [Layerbase CLI](https://layerbase.com/docs/cli) gives you the command line if you don't. Either way, Redis runs natively on your Windows machine in seconds. If you want a hosted Redis-compatible endpoint instead, use [Valkey on Layerbase Cloud](https://cloud.layerbase.com/create?engine=valkey).

Redis is one of 20+ engines available through the Layerbase CLI and Layerbase Desktop. Check out the full list at [layerbase.com/docs/cli](https://layerbase.com/docs/cli), or the [Redis on Layerbase](/db/redis) page for the Redis-specific details.