Which Cloud Providers Offer S390x Virtual Instances?

Whenever I need s390x images I treat Docker Hub like a little scavenger hunt — it’s oddly satisfying when you find exactly the manifest you need. I’ll usually start at hub.docker.com, search for the image name (for example 'ubuntu', 'alpine', or whatever project you care about) and open the Tags view. Click a tag and look for the 'Supported architectures' section: if the repository publishes a manifest list, Docker Hub will show whether 's390x' (aka IBM Z) is included. That visual check saves a lot of time before attempting a pull. If I want to be 100% sure from the command line I run a few quick checks: docker pull --platform=linux/s390x IMAGE:TAG to try pulling the s390x variant (Docker will error if it doesn’t exist), or docker manifest inspect IMAGE:TAG | jq '.' to inspect the manifest list and see which platforms are present. For more advanced work I use docker buildx imagetools inspect IMAGE:TAG or skopeo inspect docker://IMAGE:TAG — those return the manifest and platform info reliably. If an image doesn’t include s390x you’ll either need to find a different image, look for a vendor that publishes s390x builds, or build one yourself with buildx and qemu emulation. A few practical tips from my experiments: official images like 'ubuntu', 'debian', 'alpine' and many OpenJDK variants frequently include s390x builds, but not every tag/version will. Some community or vendor images explicitly add a '-s390x' suffix in their tag names, though relying on manifest lists is safer. If you’re running on non‑Z hardware and testing, remember to enable qemu (multiarch/qemu-user-static) or use a CI with actual s390x runners. Happy hunting — once you get the hang of manifest inspection it becomes second nature and saves many wasted pulls.

I’ve spent a lot of time exploring the Gutenberg Museum’s offerings. Yes, they do have virtual tours available online, and they’re absolutely worth checking out. The museum’s digital presence is quite impressive, allowing you to wander through exhibits showcasing the evolution of printing, from Gutenberg’s original press to modern typography. The virtual tour feels immersive, with detailed explanations and high-quality images that make you feel like you’re there. One of the highlights is the replica of Gutenberg’s workshop, where you can almost hear the clatter of the press. They also have interactive elements, like zooming in on rare manuscripts or watching demonstrations of historical printing techniques. For anyone who can’t visit in person, this is a fantastic way to experience the museum’s treasures. I’ve revisited it a few times just to soak in all the details, and it never gets old.

Oh, yes — you can run containers on s390x machines, but there are some practical things to keep in mind before you dive in. I've run Linux on big iron and toyed with containers there enough to know the main checklist: the machine needs a Linux distro built for s390x (think SLES, RHEL, Ubuntu on IBM Z or LinuxONE), and the container runtime must be available for that architecture. Many modern distros provide Docker or Podman packages for s390x directly through their repositories. I usually reach for Podman these days on enterprise Linux because it’s packaged well for s390x and works rootless, but plain Docker Engine is also possible — just install the distro-specific package rather than expecting Docker Desktop binaries. A technical caveat that trips people up is image architecture. Containers are not magically architecture-agnostic: if you pull an image built for amd64 it won’t run natively on s390x. The good news is many official images are multi-arch (manifest lists) and include an s390x variant; you can do things like docker pull --platform linux/s390x image:tag or let Docker/Podman pick the right one automatically. If an s390x build doesn't exist, you can either build an s390x image yourself or use emulation with qemu-user-static and buildx. Emulation works (I’ve used qemu via buildx to cross-build and test), but expect a performance hit compared to native s390x images. Other practical tips: ensure the kernel supports required container features (cgroups and overlayfs usually), check docker info to confirm the architecture, and if you plan to build multi-arch images, set up buildx and register qemu with binfmt_misc (multiarch/qemu-user-static is handy). Also, don’t assume Docker Desktop workflows will apply — you’ll be working with CLI tooling on a server. Running containers on IBM Z is surprisingly smooth once images are available; it’s a powerful way to get modern workloads on mainframes and LinuxONE hardware, and it can feel oddly satisfying spinning up a tiny container on such a massive machine.

I keep circling back to 'Elder Scrolls Online'. The sheer volume of zones, each with its own distinct biomes and layers of verticality, is unmatched for me. You can get lost for days in the dense, alien jungles of Blackwood or scale the frozen peaks of Western Skyrim, and it all feels contiguous, not just a series of disconnected maps. Where it really wins on exploration, though, is the environmental storytelling. It’s not just pretty vistas; every ruin, every abandoned campfire, every strange rock formation hints at a deeper history. You’re rewarded for poking into corners with books, hidden quests, and even entire public dungeons off the beaten path. Other MMOs might have flashier movement or mounts, but ESO’s world feels lived-in and worth understanding, not just sprinting through.

Honestly, if you're digging into s390x support today, the landscape is surprisingly tidy compared to other niche architectures. In plain terms: the big mainstream distributions offer official support, because IBM Z and LinuxONE are widely used in enterprise settings. The names you should know: Debian (official s390x port with regular images and repos), Fedora (s390x is an official Fedora architecture with regular composes), openSUSE/Leap and Tumbleweed (plus SUSE Linux Enterprise which is the commercial offering) and Red Hat Enterprise Linux (RHEL) all provide official builds for s390x. Canonical also ships Ubuntu images for IBM Z (s390x) for supported releases. Gentoo has maintained s390x support too, though its workflow is source-based rather than binary-focused. These are the ones you can reasonably point to as officially supported by their projects or vendors. Beyond that, some distributions provide community or experimental s390x images — Alpine and certain RHEL rebuilds or downstreams may have builds contributed by their communities, and projects like Rocky or AlmaLinux occasionally have community efforts, but their s390x coverage is more hit-or-miss and varies by release. If you need production stability, stick with Debian, Fedora, SUSE/SLES, Ubuntu, RHEL, or Gentoo depending on your preferred model (binary vs source). For getting started, look for images labeled 's390x' on each distro's download or cloud image pages, and check release notes for kernel and z/VM compatibility. I'm always tickled by how resilient these platforms are on mainframe iron — it's a different vibe from desktop Linux, but super solid if you need uptime.

The Hargrove Ballet Company’s virtual offerings are a game-changer for dancers like me who can’t always make it to their physical studio. I stumbled upon their online classes during the pandemic, and they’ve kept them running ever since—smart move! Their platform streams live sessions with their top instructors, plus there’s a library of prerecorded routines for all levels. What’s cool is how interactive the live classes feel; you can even get real-time feedback if you turn your camera on. They cover everything from classical techniques to contemporary fusion, so it never gets stale. I’ve improved my pirouettes so much just by rewatching their barre drills. One thing I wish they’d add? More specialized workshops, like character dancing or period-style choreography. But hey, their current lineup is solid, especially for beginners easing into ballet. The subscription’s a bit pricey, but split it with a friend like I do—totally worth it. Their ‘Dancer’s Corner’ forum is also low-key awesome for sharing tips.

When I dive into s390x support, I tend to look at two things: how mature a feature is in upstream mainline, and what enterprise distributions have backported. Historically, s390x has been part of the kernel for a long time (the s390/s390x tree matured through the 2.6 and 3.x eras), but the real message is that modern LTS kernels are where you'll find the best, most polished support for contemporary mainframe features. If you want concrete guidance: pick a modern long-term-stable kernel — think 5.10, 5.15, or 6.1 — or newer 6.x kernels if you need bleeding-edge fixes. Those LTS lines collect important fixes for KVM on s390x, DASD/CCW improvements, zfcp (Fibre Channel) robustness, zcrypt and CPACF crypto support, and paravirtual I/O enhancements. Enterprise distros (RHEL, SLES, Ubuntu LTS) often backport features into their kernel trees, so a distribution-provided LTS kernel can be the safest route for production while still giving you modern hardware support. Practically, if I’m deploying to a z15/z16 or running heavy KVM workloads, I’ll test on the latest upstream stable or a 6.x kernel to catch recently merged performance and crypto improvements, then switch to the distribution LTS that includes those backports for production. Also check kernel config options (look for s390, CCW, DASD, zcrypt-related flags) and read the s390-specific changelogs in the kernel git to verify feature flags you rely on.

I’m often torn between geeky delight and pragmatic analysis when comparing s390x to x86_64, and honestly the differences read like two different design philosophies trying to solve the same problems. On paper, s390x (the IBM Z 64-bit architecture) is built for massive, predictable throughput, top-tier reliability, and hardware-assisted services: think built-in crypto, compression, and I/O plumbing that shine in transaction-heavy environments. That pays off in real-world workloads like large-scale OLTP, mainframe-hosted JVM applications, and legacy enterprise stacks where consistent latency, hardware offloads (zIIP-like processors), and crazy dense virtualization are the priorities. Benchmarks you hear about often favor s390x for throughput-per-chassis and for workloads that leverage those special features and the mainframe’s I/O subsystem; it’s also built to keep the lights on with near-zero interruptions, which changes how you measure “performance” compared to raw speed. By contrast, x86_64 CPUs from Intel and AMD are the everyman champions: higher clock speeds, aggressive single-thread boosts, and a monstrous software ecosystem tuned for them. For single-threaded tasks, developer tooling, desktop-like responsiveness, and the vast majority of open-source binaries, x86_64 usually feels faster and is far easier to optimize for. The compilers, libraries, and prebuilt packages are more mature and more frequently tuned for these chips, which translates to better out-of-the-box performance for many workloads. If you’re running microservices, cloud-native stacks, or latency-insensitive batch jobs, x86_64 gives you flexibility, cheaper entry costs, and a huge talent pool. Power efficiency per core and raw FLOPS at consumer prices also often lean in x86_64’s favor, especially at smaller scales. When I’m actually tuning systems, I think about practical trade-offs: if I need predictable 24/7 transaction processing with hardware crypto and great virtualization density, I’ll favor s390x; if I need rapid scaling, a broad toolchain, and cheap instances, x86_64 wins. Porting code to s390x means paying attention to endianness, recompiling with architecture flags, and sometimes rethinking assumptions about atomic operations or third-party binaries. On the flip side, s390x’s specialty engines and massive memory bandwidth can make it surprisingly efficient per transaction, even if its per-thread peak may not match the highest-clocked x86 cores. Honestly, the best choice often comes down to workload characteristics, ecosystem needs, and cost model — not a simple “better-or-worse” verdict — so I tend to prototype both where possible and measure real transactions rather than relying on synthetic numbers. I’ve had projects where a JVM app moved to s390x and suddenly cryptographic-heavy endpoints got cheaper and faster thanks to on-chip crypto, and I’ve also seen microservice farms on x86_64 scale out at way lower upfront cost. If you’re curious, try running your critical path on each architecture in a constrained test and look at latency distributions, throughput under contention, and operational overhead — that’s where the truth lives.

I still get a little giddy thinking about weird museums, and that includes 'Ripley's Believe It or Not!'. From what I've seen, yes — many Ripley's locations and related attractions have offered virtual experiences, but it's a bit messy because it varies by city and by year. Some spots rolled out 360-degree tours and curated online galleries during the pandemic, others offer scheduled virtual field trips or live-streamed guided tours for schools and groups, and a few have short virtual walkthroughs on YouTube or embedded on their local site pages. If you want to try one right now, my practical route is to check the specific Ripley's location you care about (for example, 'Ripley's Aquarium' and the various 'Odditoriums' each list offerings by site). Look for keywords like "virtual tour," "360 tour," "virtual field trip," or "online exhibits" on their pages. If it’s not obvious, emailing or calling the location often gets a quick, clear reply — some will even arrange private Zoom tours if you ask. It’s a nice way to explore the odd and curious without leaving home, and I’ve taught a small group where the kids loved the zoomed-in artifacts and live Q&A.

I've been using QEMU for s390x work for years, and honestly, for most development tasks it's impressively dependable. For bringing up kernels, testing initramfs changes, and iterating on system services, QEMU will save you endless time: fast cycles with snapshots, easy serial logs, and straightforward debugging with gdb. The system emulation supports the common channel-attached (CCW) devices and block/network backends well enough to boot mainstream distributions, run systemd, and validate functionality without needing iron in the room. That said, reliability depends on what you mean by "reliable." If you need functional correctness—does the kernel boot, do filesystems mount, do userspace services run—QEMU is solid. If you need hardware-accurate behavior, cycle-exact timing, or access to specialized on-chip accelerators (cryptographic units, proprietary telemetry, or mainframe-specific features), QEMU's TCG emulation will fall short. KVM on real IBM Z hardware is the path for performance parity and hardware feature exposure, but of course that requires access to real machines. My usual workflow is to iterate fast in QEMU, use lightweight reproducible images, write tests that run in that environment, then smoke-test on actual hardware before merging big changes. For everyday development it's a huge productivity boost, but I always treat the emulator as the first step, not the final authority.