Sun Microsystems: Stanford Roots to AI-Era Lessons
Conversation prep for meeting with Forest Baskett (NEA General Partner, formerly SVP Engineering at SGI). Alan Ma, Stanford EE.
timeline: Sun microsystems (1982-2010)
| Year | Event |
|---|---|
| 1982 | Sun founded by Andy Bechtolsheim, Vinod Khosla, Scott McNealy, Bill Joy |
| 1982 | Name = Stanford University Network — from Bechtolsheim’s workstation project |
| 1984 | IPO; revenue hits $39M |
| 1987 | SPARC architecture announced — first open RISC ISA |
| 1989 | SPARCstation 1 — the iconic “pizza box” workstation |
| 1991 | Solaris (SunOS rebased on SVR4) |
| 1995 | Java released — “Write Once, Run Anywhere” |
| 1995 | UltraSPARC I — first 64-bit SPARC |
| 1996 | ”The Network is the Computer” trademark |
| 1999 | Peak market cap ~$200B; stock hits $64/share |
| 2000 | Dot-com crash begins Sun’s long decline |
| 2004 | Open-sources Solaris (OpenSolaris) |
| 2005 | UltraSPARC T1 (Niagara) — 8 cores, 32 threads, throughput computing |
| 2006 | ZFS released — “the last word in filesystems” |
| 2007 | UltraSPARC T2 — 8 cores, 64 threads |
| 2007 | Rock processor cancelled after years of development |
| 2008 | Revenue collapse; stock falls below $4 |
| 2009 | IBM walks away from $7B acquisition |
| 2010 | Oracle acquires Sun for $7.4B; Java + hardware portfolio absorbed |
1. The stanford founding story
Andy Bechtolsheim (Andreas von Bechtolsheim) was a Stanford EE graduate student in the late 1970s. He built the SUN workstation — Stanford University Network — as a project to give the Stanford campus a powerful networked computing platform. Key details:
- Bechtolsheim used the Motorola 68000 processor and designed a custom board with built-in Ethernet (the Ethernet standard itself came from Xerox PARC / Stanford / DEC collaboration, Bob Metcalfe’s work)
- The workstation was designed to be networked from day one — not a standalone personal computer, but a node on a network. This was radical in 1982.
- Vinod Khosla (Stanford MBA, co-founded Daisy Systems) saw the commercial potential and recruited Scott McNealy (Stanford MBA) to be the operations guy.
- Bill Joy joined from UC Berkeley, where he’d built BSD Unix and the vi editor. Joy became Sun’s chief technologist and later co-designed SPARC and envisioned Java.
Stanford connection for your conversation: Bechtolsheim’s thesis work literally became the company. The university’s networking philosophy — that computers should talk to each other — was Sun’s founding DNA. This is a direct parallel to how Stanford continues to produce foundational computing ideas (the Transformer paper came from Google Brain but with Stanford connections, Fei-Fei Li’s ImageNet, etc.).
2. SPARC architecture: why it mattered
the RISC philosophy
SPARC (Scalable Processor Architecture) was announced in 1987 and was rooted in the RISC (Reduced Instruction Set Computer) movement from Berkeley and Stanford:
- Berkeley RISC (David Patterson) and Stanford MIPS (John Hennessy) showed that simpler instruction sets with load/store architecture, fixed-length instructions, and register windows could dramatically outperform complex CISC designs per watt and per transistor.
- SPARC drew heavily from the Berkeley RISC-II design. It used register windows — a distinctive feature where each function call gets a fresh set of registers, reducing memory traffic for procedure calls.
what made SPARC unique
-
Open architecture: Sun published the SPARC ISA spec and let others build SPARC chips. Fujitsu, Texas Instruments, Cypress Semiconductor, and others all made SPARC processors. This was unprecedented — every other CPU vendor kept their ISA proprietary. (Foreshadowed RISC-V by 30 years.)
-
Register windows: SPARC had 128-520 physical registers organized in overlapping windows. Each procedure call “rotated” to a new window, so function calls didn’t need to save/restore registers to memory. This was great for deeply nested server workloads.
-
Scalability focus: The “S” in SPARC stood for Scalable. Sun designed it to scale from low-end workstations to high-end multiprocessor servers — a vision that guided 20 years of design.
key SPARC implementations
- SuperSPARC (1992): First superscalar SPARC
- UltraSPARC I (1995): 64-bit, included VIS (Visual Instruction Set) — early SIMD for multimedia
- UltraSPARC III (2001): Scaled to high-end servers, competed with Itanium
- UltraSPARC T1 “Niagara” (2005): The throughput computing breakthrough (see Section 3)
- UltraSPARC T2 “Niagara 2” (2007): 8 cores, 8 threads/core = 64 hardware threads
- SPARC T3 (2010, under Oracle): 16 cores, 128 threads
3. Sun’s hardware innovations — the niagara story
the throughput computing thesis
The Niagara line is the most architecturally interesting thing Sun ever did, and the most relevant to modern AI hardware.
The insight: For server workloads (web serving, database queries, application servers), single-thread performance doesn’t matter much. What matters is throughput — how many concurrent requests you can serve per watt and per dollar.
The design philosophy:
- Instead of one fast, complex, power-hungry core (the Intel/AMD approach), build many simple, slow, power-efficient cores
- Use chip multithreading (CMT) — each core runs multiple hardware threads (like HyperThreading but more aggressive: 4 threads/core on T1, 8 threads/core on T2)
- When one thread stalls on a cache miss (waiting for memory), another thread immediately takes over the pipeline
- This hides memory latency through thread-level parallelism rather than through out-of-order execution and speculation
UltraSPARC T1 (Niagara, 2005):
- 8 in-order cores, 4 threads each = 32 hardware threads
- Single-issue, in-order pipeline (deliberately simple)
- Shared L2 cache
- 72W TDP — radically lower power than contemporary Xeons
- Could handle web/app server loads at 1/4 the power of Intel alternatives
UltraSPARC T2 (Niagara 2, 2007):
- 8 cores, 8 threads each = 64 hardware threads
- Added per-core floating point unit
- Integrated 10GbE and crypto accelerators on-die
- Open-sourced the entire design (OpenSPARC)
the rock processor (Cancelled)
Rock was Sun’s attempt at the opposite end — a high-single-thread-performance chip with exotic features like hardware transactional memory and hardware scout threads. It was in development from ~2003 and cancelled in 2008 after billions in R&D. The failure of Rock contributed to Sun’s financial crisis.
Lesson: Sun tried to do both Niagara (throughput) and Rock (latency) simultaneously. The company couldn’t fund both. Rock’s failure left a hole in their product line for enterprise database workloads.
4. Forest baskett’s connection
Forest Baskett is a General Partner at New Enterprise Associates (NEA), one of the largest VC firms. His background:
- PhD in Computer Science from Stanford — so he shares the Stanford connection with Sun’s founders
- SVP of Engineering at Silicon Graphics (SGI) in the 1990s — SGI was Sun’s direct competitor in high-performance workstations and servers. SGI made the famous Onyx, Octane, and Origin systems using MIPS processors
- At SGI, Baskett oversaw the engineering of systems that competed head-to-head with SPARC workstations in visualization, scientific computing, and server markets
- After SGI, joined NEA where he focuses on deep technology investments — semiconductors, systems, enterprise infrastructure
- At NEA, he has been involved in investments in companies like Arista Networks (founded by ex-Sun/Stanford people), Cloudflare, and various semiconductor startups
The SGI-Sun rivalry: In the late 1980s and 1990s, SGI (MIPS-based) and Sun (SPARC-based) were the two dominant RISC workstation vendors. They fought for the same customers — engineers, scientists, financial firms. SGI won in graphics/visualization (Hollywood, defense), Sun won in general-purpose servers and the dotcom era. Both were eventually crushed by commodity x86 + Linux.
Conversation angle: Baskett saw the workstation war from the SGI side. He watched MIPS and SPARC both lose to x86. He’d have deep views on what it takes for a non-x86 architecture to win (relevant to ARM’s current rise, RISC-V, and custom AI silicon).
5. “The network is the computer”
Sun’s famous slogan, coined by John Gage (Sun’s Chief Researcher) in 1984, trademarked in 1996.
What it meant then:
- Computing should be distributed across networked machines, not concentrated in mainframes
- The network itself becomes the computing platform
- Sun sold this vision with NFS (Network File System, invented at Sun in 1984), Java (network-portable code), Jini (network service discovery), and grid computing
How it maps to today’s AI infrastructure:
- Modern AI training clusters are literally “the network is the computer” — thousands of GPUs connected by InfiniBand/NVLink fabrics where the interconnect bandwidth is the binding constraint
- NVIDIA’s DGX SuperPOD, Google’s TPU pods, and all hyperscaler training clusters are networked computers in Sun’s exact vision
- The “memory wall” that Sun tried to solve with Niagara’s thread-level parallelism is the same memory bandwidth wall that drives HBM adoption and tiled architectures in modern AI chips
- Sun’s NFS became the standard for shared storage; today’s AI clusters use parallel filesystems (Lustre, GPFS) that descend from the same philosophy
6. software legacy: java, solaris, ZFS
java (1995)
- Designed by James Gosling at Sun
- “Write Once, Run Anywhere” — bytecode compiled to a virtual machine
- Became the dominant enterprise programming language for 15+ years
- Today: Android (Kotlin/JVM), big data (Hadoop, Spark, Kafka all JVM-based), enterprise backends
- Oracle’s stewardship has been controversial (Google lawsuit over Android’s use of Java APIs)
solaris / SunOS
- SunOS (BSD-based, then SVR4-based as Solaris) was the premier Unix for servers
- Innovations: DTrace (dynamic tracing — revolutionary for systems debugging), Zones (lightweight containers, predating Docker by a decade), ZFS
- Solaris’s DTrace directly influenced Linux’s BPF/eBPF tracing infrastructure
ZFS (Zettabyte file system, 2005)
- Designed by Jeff Bonwick and Matt Ahrens at Sun
- 128-bit filesystem — theoretically stores more data than atoms in the universe
- Copy-on-write, checksumming, built-in RAID (RAIDZ), snapshots, deduplication
- Survived Sun’s death: lives on as OpenZFS, used heavily in FreeBSD, TrueNAS, and Linux storage
- Considered one of the greatest filesystems ever designed
7. Why Sun failed
root causes
-
Commodity x86 ate their market: Sun sold proprietary SPARC hardware at premium prices. When Linux on x86 became “good enough” for server workloads, Sun’s value proposition collapsed. Google, Facebook, and the hyperscalers all chose commodity x86 over Sun/IBM/HP proprietary systems.
-
Dot-com dependency: Sun was the dominant server vendor during the dot-com boom. When the bubble burst (2000-2002), Sun’s revenue fell from $18.3B to $11.4B. They never recovered.
-
Identity crisis: Sun tried to be a hardware company, a software company (Java), an open-source company (OpenSolaris, OpenSPARC), and a services company simultaneously. They never committed to one identity.
-
Failed to monetize software: Java was enormously influential but Sun never figured out how to make money from it. Contrast with Red Hat (Linux support) or Oracle (database licensing). Sun gave everything away.
-
Rock processor failure: Billions spent on a processor that never shipped. This drained R&D resources that could have gone into Niagara improvements or x86-based Sun servers.
-
Late to x86: Sun eventually offered x86 Opteron-based servers (the Galaxy line / Sun Fire x64), but it was too late — Dell, HP, and commodity whitebox vendors owned that market.
-
Jonathan Schwartz’s leadership: CEO from 2006-2010, he pushed open-source strategy aggressively (open-sourced Solaris, SPARC, Java) but couldn’t convert openness into revenue. Revenue fell from $13.9B (2006) to $11.4B (2009).
the acquisition
- IBM offered ~$7B in early 2009, but negotiations collapsed (reportedly over antitrust and cultural concerns)
- Oracle bought Sun for $7.4B in January 2010
- Oracle wanted Java (enterprise middleware lock-in) and Solaris/SPARC (for running Oracle Database on integrated stacks — what became Oracle Exadata)
- Larry Ellison: “Sun had a different strategy from Oracle. Our strategy is to make a profit.”
8. lessons for today: sun’s ideas were ahead of their time
niagara = the GPU philosophy, 15 years early
This is the most important connection for your conversation:
| Niagara (2005) | Modern GPU / AI Accelerator (2024) |
|---|---|
| Many simple, in-order cores | Thousands of simple CUDA/tensor cores |
| Thread-level parallelism hides latency | Warp-level parallelism hides latency |
| 4-8 threads per core | 32+ threads per warp |
| Optimized for throughput, not latency | Optimized for throughput, not latency |
| Low power per core | Low power per core |
| Shared memory hierarchy | Shared memory (L2, HBM) |
| In-order pipeline (no speculation) | In-order pipelines in streaming multiprocessors |
Sun’s Niagara was throughput computing for server workloads. NVIDIA’s GPUs are throughput computing for parallel compute workloads. The philosophy is identical: trade single-thread performance for massive parallelism and power efficiency.
The difference: Sun targeted web/app servers where the parallelism was “lots of independent requests.” GPUs target data-parallel workloads where the parallelism is “same operation on lots of data” (SIMD/SIMT). Sun’s market was too small and too easily served by commodity x86. NVIDIA’s market turned out to be the largest compute market in history.
open architecture then and now
Sun open-sourced SPARC in 2006 (OpenSPARC). Today’s parallel: RISC-V is the open ISA succeeding where OpenSPARC didn’t, partly because the ecosystem is broader and the timing is better (cloud + edge + AI create massive demand for custom silicon).
“The network is the computer” fully realized
Sun’s vision literally describes a modern AI training cluster — a supercomputer where the network fabric (InfiniBand, NVLink, UALink) is as important as the compute. The constraint in training LLMs is not FLOPs, it’s interconnect bandwidth for all-reduce operations. Sun was right; they were just 25 years too early.
conversation hooks for Forest Baskett
hook 1: “Niagara was the GPU playbook”
“Sun’s Niagara chips in 2005 made the exact same bet that GPU computing makes today — trade single-thread performance for massive throughput via simple cores and hardware multithreading. The philosophy was right but the market (web servers) didn’t need it enough to overcome x86 commoditization. NVIDIA applied the same philosophy to a market (parallel compute, then AI) where there was no x86 alternative. As someone who was at SGI competing with Sun, did you see Niagara as visionary at the time, or as a niche product?”
This lets Baskett share his insider perspective on the SPARC vs. MIPS vs. X86 wars and naturally transitions to discussing why some architectures win and others don’t — directly relevant to the current AI chip landscape.
hook 2: “The SGI-Sun convergence”
“SGI and Sun were rivals in the workstation era, but they were both ultimately trying to solve the same problem — how to build parallel computing systems that scale. SGI had the graphics pipeline expertise (Geometry Engine, InfiniteReality) and Sun had the network-centric philosophy. Today, those two ideas have merged in NVIDIA’s DGX — massively parallel graphics-derived compute connected by high-speed fabrics. Was there a moment at SGI when you saw these paths converging?”
This flatters Baskett’s SGI experience and connects to his deep tech investing thesis at NEA.
hook 3: “What would you have done differently at sun?”
“Sun had three assets that are incredibly valuable today: throughput-oriented chip design (Niagara), the ‘network is the computer’ vision, and systems software expertise (Solaris, DTrace, ZFS). If you were advising Sun in 2005, what would you have told them to focus on to survive? And does that inform how you evaluate deep tech startups at NEA today — companies that might have the right technology but the wrong market timing?”
This is personal and strategic — it invites Baskett to share VC-level thinking about technology timing, which is directly useful for a Stanford EE student thinking about what to build.
quick facts to drop naturally
- Andy Bechtolsheim later became one of Google’s first investors — he wrote a $100K check to “Google Inc.” before the company was even incorporated (1998)
- Bill Joy wrote the “Why the Future Doesn’t Need Us” essay (Wired, 2000) about existential risk from technology — prescient given today’s AI safety debates
- Sun’s stock went from $64 (2000) to under $3 (2009) — a 95%+ decline. Oracle bought the whole company for less than Sun’s annual revenue at peak
- ZFS is still considered the gold standard for data integrity — it’s running in most NAS devices and data centers today
- Java runs on ~3 billion devices (as of Oracle’s count) — more than any other platform
- The SPARC T2 was fully open-sourced in 2008 under GPL — one of the most complex open-source hardware designs ever released
interesting reads
- John Hennessy & David Patterson, “A New Golden Age for Computer Architecture” (2019) — the Turing Award lecture that frames the current AI hardware moment
- Forest Baskett — venture partner at NEA, former Sun VP, Stanford faculty
- Andy Bechtolsheim — Sun co-founder, early Google investor, now at Arista Networks
- “The Network Is the Computer” — Sun’s prescient thesis, now literally true with cloud computing
- OpenSPARC T2 (GPL) — the open-source chip design that preceded RISC-V by a decade