Google doesn’t get the same AI-infrastructure headlines as Nvidia or OpenAI, but it quietly runs two pieces of foundational tech that power a huge share of the industry: custom TPU chips for AI training and inference, and the Go programming language that underpins much of the cloud-native world’s backend infrastructure. Neither gets much coverage on its own; together they say a lot about how Google builds for scale.
At a Glance
| Technology | Category | Current state |
|---|---|---|
| Ironwood (TPU v7) | AI accelerator chip | GA; Google’s 7th-gen TPU, built for inference |
| Trillium (TPU v6e) | AI accelerator chip | GA; prior generation, still widely used |
| Go (Golang) | Programming language | Go 1.27 (Aug 2026), patch 1.27.3 (Oct 2026) |
Short Verdict
TPUs are now a credible third option alongside Nvidia GPUs and AWS’s Trainium for serious AI workloads — Anthropic’s decision to scale Google TPU usage toward a million chips is hard to argue with. Go, meanwhile, has become unglamorous infrastructure plumbing in the best sense: not exciting, but running Kubernetes, Docker, and a huge share of cloud-native backend systems, with steady, incremental language improvements rather than hype-driven changes.
TPU Chips: Google’s AI Silicon
Google’s current-generation TPUs span two chips. Trillium (TPU v6e), generally available, delivers 918 TFLOPs of bf16 compute and 32GB of HBM per chip at 1,638GB/s bandwidth, scaling to 256-chip pods; Google claims it’s 67% more energy-efficient and offers 4.7x higher peak compute per chip than the previous generation. Ironwood (TPU v7), which Google calls its “first TPU built for the age of inference,” is the newer chip: 192GB of HBM per chip at 7.37TB/s bandwidth, scaling to pods of up to 9,216 chips delivering a claimed 42.5 exaflops. Google has described Ironwood as roughly 2x more power-efficient than Trillium in its original launch materials, though a separate Google Cloud page frames the generational jump as “4x better performance per chip” — both are Google’s own figures from different pages, worth noting as evolving marketing language rather than a hard contradiction.
TPUs are rented through Google Cloud as “slices” — a dedicated portion of a pod that behaves as one unified machine, orchestrated through Google Kubernetes Engine. The software stack leans heavily on JAX (a NumPy-style array computation library with composable transforms) and the XLA/OpenXLA compiler, though PyTorch and TensorFlow are also supported.
The clearest validation of TPUs at frontier scale comes from Anthropic, which announced in late 2025 that it’s expanding its use of Google Cloud TPUs to up to 1 million chips, adding well over a gigawatt of capacity coming online through 2026. Anthropic uses TPUs alongside Nvidia GPUs and AWS Trainium as part of a deliberate multi-chip strategy, rather than relying on any single vendor. Other named Google Cloud TPU customers include Citadel Securities (claiming 2–4x faster workloads at 30% lower cost) and Lightricks (claiming 40% more daily training steps after migrating to JAX/TPU). Reports that Apple trained some of its on-device Apple Intelligence models on TPUs rather than Nvidia GPUs are well-corroborated by tech press but are best described as “reportedly,” since this piece did not independently verify that detail against Apple’s own primary technical documentation.
Go: Quiet Infrastructure for the Cloud-Native World
Go was designed at Google starting in 2007 by Robert Griesemer, Rob Pike, and Ken Thompson, out of frustration with the build times and complexity of existing languages at Google’s scale, and open-sourced in 2009. Today go.dev describes it simply as “an open-source programming language supported by Google” — language evolution now runs through a public change-proposal process, though Google retains some structural control over the project’s infrastructure (code review runs on Google’s own Gerrit instance, and certain compliance rules require Google employee involvement in some changes).
The current stable release is Go 1.27 (released August 2026, with security patch 1.27.3 in October 2026), which added generic methods, new strict JSON handling packages, post-quantum cryptographic signature support, and cheaper small-object allocation. The prior release, Go 1.26, enabled a new garbage collector by default (claimed 10–40% reduction in GC overhead) and added faster cgo calls. Go’s defining feature remains its concurrency model: goroutines are lightweight functions the runtime multiplexes onto OS threads, cheap enough to create hundreds of thousands of at once, communicating through channels modeled on Hoare’s CSP rather than shared-memory locking.
Go’s real impact shows up in what’s built with it: Kubernetes, Docker, and Terraform — three of the most widely used pieces of cloud infrastructure software in existence — are all written in Go, which is part of why it’s become the default language for cloud-native tooling, CLIs, and backend network services, generally favored over Python for performance and over Java/C++ for its simpler build model and faster compile times.
Pros
- TPUs: proven at frontier scale via Anthropic’s million-chip commitment, with a mature JAX/XLA software stack and strong perf-per-watt claims from Google.
- TPUs: Cloud TPU slices let teams rent a fraction of a pod rather than committing to an entire cluster.
- Go: exceptionally fast compile times and a concurrency model that scales to hundreds of thousands of lightweight goroutines without heavyweight thread management.
- Go: steady, backward-compatible releases on a predictable six-month cycle, rather than disruptive breaking changes.
Cons
- TPUs: tied exclusively to Google Cloud, unlike Nvidia GPUs which run on every major cloud.
- TPUs: Google’s own marketing language around generational performance gains (Ironwood’s “2x” vs “4x” framing in different materials) isn’t always perfectly consistent.
- Go: lacks Rust’s compile-time memory-safety guarantees, relying on garbage collection instead.
- Go: its standard library and idioms deliberately avoid some abstractions (generics arrived late, no traditional class hierarchy), which some developers coming from Java or C++ find limiting.
Who It’s a Good Fit For
Teams already on Google Cloud training large models at scale are a natural fit for TPUs, especially with JAX-based workflows. For Go: teams building cloud infrastructure tooling, CLIs, network services, or anything where fast compilation, simple deployment (a single static binary), and high-concurrency networking matter more than maximal runtime performance or compile-time memory safety.
Who Should Look Elsewhere
Teams not already on Google Cloud, or needing cross-cloud portability, will find Nvidia GPUs or AWS’s Trainium more practical than TPUs. For Go: teams needing compile-time memory-safety guarantees without a garbage collector should look at Rust; teams needing dynamic prototyping speed over performance may still prefer Python.
Bottom Line
TPUs and Go don’t get bundled together often, but both reflect the same Google trait: building deeply vertically integrated infrastructure, then letting the results speak through adoption rather than marketing noise. TPUs have earned a real seat at the AI-chip table via Anthropic’s scale commitment; Go has quietly become the default language underneath most of the cloud-native stack most engineers use every day.
FAQ
Can I use TPUs outside Google Cloud?
No. TPUs are proprietary Google silicon, available only through Google Cloud’s Cloud TPU service.
Is Go still controlled by Google?
Go is open-source and changes go through a public proposal process, but Google retains meaningful structural control — the canonical repository, code review tooling, and certain compliance requirements still run through Google.
What major software is written in Go?
Kubernetes, Docker, and Terraform are among the best-known infrastructure projects written in Go, which is a large part of why it’s the default language for cloud-native tooling.
Sources
- Cloud TPU overview (cloud.google.com)
- Ironwood TPU announcement (blog.google)
- Anthropic’s TPU expansion announcement (anthropic.com)
- Go release history (go.dev)
- Go FAQ (go.dev)
- Go contribution and governance process (go.dev)
Discover more from Software Online Review
Subscribe to get the latest posts sent to your email.
