Docker v29 Lands on RISC-V64 in Under a Week: The Future is Here
Summary
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:
Automated excellence: The build pipeline doesn’t sleep
Native compilation: Real RISC-V64 hardware (BananaPi F3) producing real binaries
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-cliNo 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):
| Component | Official Release | RISC-V64 Release | Days Delta |
|---|---|---|---|
Docker CLI v29.0.0 | Nov 6, 2025 | Nov 11, 2025 | 5 days |
Docker Engine v29.0.0 | Nov 6, 2025 | Nov 12, 2025 | 6 days |
Docker Buildx (recent) | October 2025 | 5 days later | 5 days |
Docker Compose (recent) | October 2025 | Same week | <7 days |
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:
Containerd image store is now default (for new installations)
Legacy graph drivers deprecated (still available via config)
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
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 --versionFedora/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 --versionGentoo 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/dockerFull 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:
Debian packaging creates
.debfilesRPM packaging creates
.rpmfilesGentoo ebuilds generate Portage packages
Repository updates push to APT/RPM repos
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.