Docker Engine v29.0.0 was officially released on November 6, 2025. Just 5 days later, Docker CLI v29.0.0 was available for RISC-V64. By November 12 (6 days after the official release), Docker Engine v29.0.0-riscv64 was ready for production use. Welcome to the era where RISC-V64 is no longer an afterthought—it’s a first-class citizen in the container ecosystem.

Photo by BoliviaInteligente on Unsplash

The Speed That Matters

When Docker officially released v29.0.0 on November 6, the clock started ticking. Would RISC-V64 users have to wait weeks or months for support? Would they be left behind as the x86 and ARM ecosystems celebrated their shiny new containerd-based architecture?

The answer came faster than anyone expected:

• November 11, 2025: Docker CLI v29.0.0-riscv64 released (5 days)
• November 12, 2025: Docker Engine v29.0.0-riscv64 released (6 days)

Less than a week. From official release to production-ready RISC-V64 binaries. That’s not just fast—that’s a statement about where RISC-V64 stands in the modern computing landscape.

Why Docker v29 is a Game-Changer

Docker Engine v29.0.0 isn’t just another incremental update. It represents a fundamental architectural shift:

Containerd Image Store Becomes Default

For the first time, containerd becomes the default image store for new Docker installations. This is massive:

• Simplified Architecture: Both container execution and storage now use containerd, eliminating legacy complexity
• Ecosystem Alignment: Better integration with Kubernetes and other containerd-based platforms
• Performance Benefits: Enhanced content management, multi-snapshotter support, and faster pull/push workflows
• Future-Proof: Docker Desktop has been using containerd as default for a year—v29 brings this maturity to Docker Engine

What This Means for RISC-V64

The fact that Docker v29 with its containerd-first architecture is available on RISC-V64 immediately sends a clear message: RISC-V64 is production-ready. This isn’t a hobbyist platform anymore. When architectural changes this significant land on RISC-V64 within days of the official release, it demonstrates:

1. Automated excellence: The build pipeline doesn’t sleep
2. Native compilation: Real RISC-V64 hardware (BananaPi F3) producing real binaries
3. Community momentum: RISC-V64 is no longer playing catch-up

The Secret Sauce: Automation That Works

How does a Docker v29 release on x86/ARM translate to RISC-V64 availability in 5-6 days? The answer lies in a carefully orchestrated build system:

Daily Release Tracking

Every day at 06:00 UTC, automated workflows check for new official Docker releases. When v29.0.0 was tagged on GitHub, the system knew within hours.

Native RISC-V64 Compilation

Unlike cross-compilation hacks or emulation workarounds, these binaries are compiled on actual RISC-V64 hardware:

• BananaPi F3 running Armbian Trixie
• Self-hosted GitHub Actions runner
• Native Go compilation (1.25.3)
• Full integration testing

Multi-Format Packaging

Within hours of successful compilation, the system generates:

• Debian packages (.deb) for APT repositories
• RPM packages (.rpm) for Fedora/RHEL/Rocky/AlmaLinux
• Gentoo ebuilds for Portage overlay users
• Raw binaries for manual installation

Signed Repository Updates

The APT and RPM repositories are automatically updated with GPG-signed packages, ready for immediate installation:

# Install Docker v29 on Debian/Ubuntu RISC-V64
sudo apt-get update
sudo apt-get install docker.io docker-cli

# Install Docker v29 on Fedora/RHEL RISC-V64
sudo dnf install moby-engine docker-cli

No waiting. No manual downloads. Just apt install or dnf install like any other mainstream architecture.

The Numbers Tell the Story

Let’s put this timeline in perspective:

Docker Engine Release History (RISC-V64 Availability):

This consistency isn’t luck—it’s infrastructure. It’s automation. It’s what happens when RISC-V64 is treated as a priority, not an afterthought.

What’s Different About v29 on RISC-V64?

Nothing. That’s the Point.

Docker Engine v29.0.0 on RISC-V64 includes:

• Containerd v2.1.5 as the new default image store
• Experimental nftables support for modern networking
• API v1.44 minimum (Docker v25+ compatibility)
• Full feature parity with x86_64 and arm64 releases

The only difference? The riscv64 architecture tag. Everything else—features, security updates, performance improvements—lands simultaneously.

What About Breaking Changes?

Docker v29 introduced several breaking changes:

1. Containerd image store is now default (for new installations)
2. Legacy graph drivers deprecated (still available via config)
3. Minimum API version raised to 1.44 (Docker v25+)

All of these apply equally to RISC-V64. No special cases. No “RISC-V limitations.” Just architectural parity.

Real-World Impact: Who Benefits?

Edge Computing on RISC-V

With Docker v29’s containerd-first architecture on RISC-V64, edge computing deployments can leverage:

• Faster image pulls on bandwidth-constrained devices
• Better content management for offline/intermittent connectivity
• Kubernetes compatibility through shared containerd runtime

Development Teams

Developers targeting RISC-V64 now have:

• Same-day access to latest Docker features
• No compatibility worries with x86/ARM workflows
• Production-ready tooling backed by automated testing

Academic Research

Universities and research institutions exploring RISC-V can:

• Containerize research workloads with confidence
• Use modern Docker Compose stacks for reproducibility
• Deploy cutting-edge features without waiting months

The Repository: Your Gateway to RISC-V64 Docker

GitHub Repository: https://github.com/gounthar/docker-for-riscv64

Installation is Trivial

Debian/Ubuntu/Armbian:

# Add GPG key and repository
wget -qO- https://github.com/gounthar/docker-for-riscv64/releases/download/gpg-key/docker-riscv64.gpg | \
  sudo tee /usr/share/keyrings/docker-riscv64.gpg > /dev/null

echo "deb [arch=riscv64 signed-by=/usr/share/keyrings/docker-riscv64.gpg] https://gounthar.github.io/docker-for-riscv64 trixie main" | \
  sudo tee /etc/apt/sources.list.d/docker-riscv64.list

# Install Docker v29
sudo apt-get update
sudo apt-get install docker.io docker-cli

# Verify
docker --version

Fedora/RHEL/Rocky/AlmaLinux:

# Add repository
sudo curl -L https://gounthar.github.io/docker-for-riscv64/rpm/docker-riscv64.repo \
  -o /etc/yum.repos.d/docker-riscv64.repo

# Install Docker v29
sudo dnf install -y moby-engine docker-cli

# Verify
docker --version

Gentoo Linux:

# Add overlay
eselect repository add docker-riscv64 git https://github.com/gounthar/docker-for-riscv64.git

# Sync and install
emerge --sync docker-riscv64
emerge -av app-containers/docker

Full Component Stack Available

Beyond Docker Engine and CLI v29, the repository provides:

• Docker Compose v2.40+ - Multi-container orchestration
• Docker Buildx v0.19+ - Multi-platform build support
• Tini v0.19.0 - Proper signal handling in containers
• Containerd v2.1.5 - Latest container runtime
• Runc v1.3.0 - OCI-compliant runtime

All packages are GPG-signed, automatically updated, and tested on real RISC-V64 hardware.

The Build System Behind the Scenes

Weekly Automated Builds

Every Sunday at 02:00 UTC, the system builds Docker Engine from the latest upstream. By Monday morning, if there’s a new version, it’s already available.

Daily Release Tracking

At 06:00 UTC daily, workflows scan for new official releases:

• Docker Engine (Moby)
• Docker CLI
• Docker Compose
• Tini
• Buildx

When detected, automated builds trigger immediately.

Multi-Format Package Generation

Once binaries compile successfully:

1. Debian packaging creates .deb files
2. RPM packaging creates .rpm files
3. Gentoo ebuilds generate Portage packages
4. Repository updates push to APT/RPM repos
5. GitHub releases publish with full changelogs

All within hours. All without human intervention.

Native Hardware Compilation

The BananaPi F3 self-hosted runner:

• 192.168.1.185 - Dedicated RISC-V64 hardware
• Armbian Trixie - Debian-based OS
• GitHub Actions Runner - Go-based runner for RISC-V64
• ~35-40 minutes - Full Docker Engine build time

This isn’t emulation. This isn’t cross-compilation. This is native RISC-V64 code running on RISC-V64 silicon.

The Bigger Picture: RISC-V64 Maturity

Open Source Excellence

What you’re witnessing isn’t just about Docker. It’s about what happens when:

• Open ISA (RISC-V) meets open container standards (OCI)
• Community automation delivers enterprise-grade reliability
• Alternative architectures achieve feature parity with mainstream platforms

Production Readiness

Six-day turnarounds demonstrate maturity. When you can reliably deliver complex software stacks to alternative architectures this quickly, it signals:

• Stable toolchains - Go 1.25.3 works flawlessly on RISC-V64
• Mature infrastructure - GitHub Actions runners, native compilation, multi-format packaging
• Community readiness - Documentation, testing, real-world validation

The Future is Open

As RISC-V64 hardware becomes more accessible:

• Lower costs - Open ISA means competitive pricing
• Better performance - Custom silicon optimized for workloads
• Complete freedom - No licensing restrictions or vendor lock-in

And with Docker v29 available day-one, developers can start building now.

Conclusion: Speed Matters, Architecture Matters More

Six days from official release to production-ready RISC-V64 binaries. Automated testing. Signed repositories. Full feature parity.

This is what modern open source looks like. This is what happens when the community decides an architecture matters. This is Docker v29 on RISC-V64.

The question isn’t “When will RISC-V64 be ready for containers?”

The answer is: It already is.

Get Started

• Repository: https://github.com/gounthar/docker-for-riscv64
• Documentation: Full installation guides for Debian, RPM, and Gentoo
• Releases: https://github.com/gounthar/docker-for-riscv64/releases
• APT Repository: https://gounthar.github.io/docker-for-riscv64
• RPM Repository: https://gounthar.github.io/docker-for-riscv64/rpm

Star the repository. Try Docker v29. Share your experience. The RISC-V64 container revolution is here.