github.com/redis/go-redis

The go-redis library provides a clean, idiomatic Go interface for Redis that feels natural from day one. The API closely mirrors Redis commands, so if you know Redis, you'll be productive immediately. Commands like `client.Set(ctx, key, value, 0)` and `client.Get(ctx, key)` are straightforward, and the context support throughout makes timeout handling clean. Pipelining and transactions work as expected with minimal boilerplate.

Error handling is generally good - connection errors are clear, and nil returns for missing keys follow Go conventions. The library handles connection pooling automatically, which removes a common headache. Documentation is decent with working examples for most operations, though some advanced features like Lua scripting could use more depth.

The main gotcha is version confusion: the package path changed from v6 to v8+, and this "incompatible" v6 tag can trip up new users. You'll want to use `github.com/go-redis/redis/v8` or later for new projects. Community support is strong - GitHub issues get responses, and Stack Overflow has good coverage of common patterns. When things go wrong, error messages point you in the right direction without excessive digging.

This v6 version (marked incompatible) represents an outdated state of go-redis that shouldn't be used in new projects. The package has since moved to proper semantic versioning with v8 and v9, which include significant API improvements and bug fixes. The 'incompatible' tag indicates Go module compatibility issues that create friction in dependency management.

The core Redis operations work fine when you get them running, but the error handling patterns are inconsistent and context support is limited compared to modern versions. Pipeline operations exist but lack the fluent interface refinements added later. The documentation for this specific version is hard to find since the main repository has moved on, making troubleshooting difficult.

If you're stuck maintaining legacy code on v6, migration to v9 is straightforward but requires addressing renamed methods and context parameter additions throughout your codebase. There's no compelling reason to start new projects with this version.

This v6 version represents an outdated era of go-redis with significant developer experience issues. The biggest problem is the version itself - the '+incompatible' suffix indicates it predates Go modules, and the 2020 release date means you're missing years of improvements. The API uses interface{} returns everywhere, forcing constant type assertions and eliminating compile-time safety.

Day-to-day usage involves wrestling with type conversions. Simple operations like GET return (string, error) which seems fine, but complex commands return interface{} that you must manually cast. Error messages are basic and don't provide actionable context about connection issues or command failures. The lack of generics support (pre-Go 1.18) means you're constantly writing boilerplate.

Migrating to v8 or v9 is straightforward and absolutely worth it. The newer versions have proper module support, better type safety, improved error messages with context, and enhanced pipelining. Unless you're maintaining legacy code frozen in time, there's no reason to use this version.