A History of C Compilers – Part 1: Performance, Portability and Freedom

Original Article ↗ Hacker News Discussion ↗

Early C compilers on systems like CP/M, DOS, and early Unix are remembered as remarkably small, fast, and expensive tools, with products such as Aztec C, Lattice C, Watcom, and Zortech C++ shaping how developers worked in the 1980s and 1990s. Commenters contrast these commercial compilers—often better optimized but costly and proprietary—with GCC, whose free availability, portability, and later stability helped it win the “Unix compiler wars” and advance the ideals of free software. The thread also touches on how C’s longevity compares with newer languages like Rust, the trade-offs between language complexity and safety, and the lasting impact of historical design decisions on today’s toolchains.

Retro C, CP/M, and Small Compilers

  • Several comments reminisce about CP/M-era tools: Aztec C, Hi-Tech C, BDS C, Whitesmiths, and Turbo Pascal 3.x, emphasizing how small and fast they were compared with modern toolchains.
  • People describe writing or using Z80/CP‑M emulators and compilers, debugging missing BDOS/syscalls, and cross‑compiling from modern machines (e.g., with SDCC).
  • There is interest in niche languages and compilers targeting CP/M and DOS (e.g., T3X, Dice, vbcc), often praised for compactness and decent code generation.
  • Some report rough edges with old toolchains (e.g., include handling, odd errors) and highlight just how manual and brittle builds could be.

Commercial vs Free Unix Compilers and GCC’s Role

  • Multiple posts argue that commercial C compilers (Sun cc, IBM xlc, others) historically produced faster code and had advanced features (e.g., profile‑guided optimization) compared to GCC.
  • Cost and licensing hurdles for vendor compilers are cited as a major driver of GCC adoption, especially after Unix vendors unbundled their toolchains.
  • There is disagreement on GCC reliability in the late 1990s: some recall it as the stable default; others report serious bugs around 2.8/2.95 and point to the egcs fork as a response.
  • GCC’s portability and zero price are consistently credited for its eventual dominance.

C++ and Other Influential Compilers

  • The thread debates which was the “first native C++ compiler”: an early GNU C++ (g++) beta in 1987 versus a commercial Zortech C++ release in 1988.
  • One side notes g++ used the GCC backend and was available earlier on the net; the other stresses that Zortech was the first shrink‑wrapped, widely impactful native C++ compiler on PCs.
  • Datalight C is highlighted for pioneering data‑flow analysis optimizations that aggressively removed dead code, influencing later compilers.
  • Other notable historical compilers mentioned include Metaware HighC, Watcom C/C++, UCSD Pascal, Free University Compiler Kit, and Tiny C.

Microsoft C and Lattice C

  • There is discussion over how much early Microsoft C derived from Lattice C.
  • Ads and historical material are cited indicating that Microsoft C 1.0 and 2.0 were essentially rebranded Lattice C, with Microsoft moving to its own implementation by later versions.
  • Exact version boundaries and timelines remain somewhat unclear in the thread.

Licensing, “Freedom”, and Economics

  • Several comments discuss how “freedom” in the GNU sense interacted with practical concerns: many users initially cared more about cost and availability than philosophy.
  • There is a long subthread contrasting copyleft (GPL/AGPL) and permissive licenses (BSD/MIT), arguing over whether most people value software freedom or primarily financial freedom.
  • Some argue permissive licenses still deliver the core freedoms (study, modify, redistribute), while others see them as enabling “wealth transfer” to companies.
  • Opinions diverge on the long‑term sustainability of GPL projects versus permissively licensed software and on how much corporate capture will shape major projects.

Language Longevity: C, Rust, and Predecessors

  • Participants note that in 1983 predictions of C’s permanence seemed premature, yet C remains near the top of language popularity decades later, with many C‑syntax descendants widely used.
  • One line of argument holds that Rust’s safety guarantees and maturing ecosystem are pushing organizations away from C, especially for security‑sensitive, internet‑facing code.
  • A skeptical line compares Rust to PL/I: powerful but complex, slow to compile, and prone to intricate feature interactions; predicts an eventual, simpler “C‑like with safety” successor.
  • A counterpoint stresses that many of Rust’s complexities are required for static memory‑safety guarantees and that even if a theoretically better design appears, adoption inertia will be strong.
  • There is agreement that safety often comes from forbidding dangerous capabilities, but disagreement on how minimal a “safe C” can be in practice.