PIC24 still ships a weird almost-C compiler. Among its many exciting features, the language doesn’t support variadics and there is a special case in the compiler for printf.

tcc https://bellard.org/tcc/

I’m using it for tests with tcc -run -

Back in the 1980s I was using Matt Dillon’s DICE (Dillon’s Integrated C Environment) on my Amigas. That’s how I learned to program in C back then. I can’t remember its license. It was payware, but came with full source, presumably non-redistributable. “Everything” was closed-source payware or shareware. I believe in the beginning we pirated the SAS/C compiler, but the I switched to DICE.

Edit: Oh, a link:

• https://en.wikipedia.org/wiki/Matthew_Dillon
• https://apollo.backplane.com/FreeSrc/ ← source for DICE
• https://en.wikipedia.org/wiki/Lattice_C ← apparently SAS/C was originally named Lattice C

When I was in school I used Metrowerks CodeWarrior a bit. I guess NXP owns it now but I don’t know if they kept the toolchain or switched to something more standard.

The one I learned on:

https://en.wikipedia.org/wiki/THINK_C

The intel c compiler is still relevant to industry. It has tricks in it to take more advantage of their chips and occasionally has bugs that make it slower on AMD.

It uses the intel math library as well by default, I think, which is faster than most other libm’s.

Zeta-C ran C on Lisp Machines.

It used fat pointers internally:

All pointers were represented as pairs of an array and an index; NULL was
simply a pair of NIL and 0.  If you cast a pointer to an integer, you got a
cons of the array part and the index part.

Norcroft?

https://en.wikipedia.org/wiki/Norcroft_C_compiler

Led to Acorn C.

https://en.wikipedia.org/wiki/Acorn_C/C%2B%2B

Also to Inmos C for the Transputer. Later versions of RISC OS were partly built in it, and it was the official SDK, AIUI.

Inmos’ work led to HeliOS, a now-FOSS Unix-like OS for massively-multicore processors, related to TRIPOS (the original BCPL OS and ancestor of AmigaOS).

https://github.com/axelmuhr/Helios-NG

Its language suppert isn’t that weird, but the LCC compiler has two interesting properties:

1. It was written as an exercise in literate programming, and I’m talking the full-fledged weave/tangle Knuth style, not just “more/inverse comments”. It was basically a byproduct of a book. (While we’re at it, I can also recommend the data structures book by the same author, written in a similar style).
2. It become somewhat popular for programming 32 bit Windows applications. A version called lcc-win32 filled a niche for Windows 95/98 programming, where you didn’t want to buy the somewhat expensive Microsoft/Borland products, but also didn’t want to incure the overhead (both time and space) of GNU toolchains. (Pelles C is another derivative compiler).

More than 10 years ago I worked for a company that develops its own smalltalk VM on which they’ve built all of their products. The core of that VM is written in smalltalk and compiled to C89 using a selfwritten compiler (again, smalltalk). The C code is then compiled to machine code with some ancient borland C compiler. Modern compilers wouldn’t work since ancient allows for things like implicit return types. I looked into massaging clang cflags into compiling that stuff, but I honestly can’t remember if it worked. Turns out C isn’t so portable after all.

C in 4 functions only compiles a subset of C, but it is impressively minimalistic (and worth a quick read). SectorC also exists.

The Plan 9 C compiler, nowadays, is again relevant as the historical starting point for the Go compiler.

There’s also CERN’s cint that allows you to use C as a scripting language (for rapid prototyping, or if you’re too lazy to compile the source): https://root.cern/root/html534/cint/cint.html

• The other gcc: https://www.ghs.com/products/compiler.html
• The frontend everyone uses but nobody talks about: https://www.edg.com/c / https://en.wikipedia.org/wiki/Edison_Design_Group

Both actively in use today.

I have also witnessed a C++ compiler implemented as a compiler to C, with the requirement that line numbers had to be preserved, so all the C that a particular C++ line became had to be on the same line. Depending on what year it is, this ranges from the obvious way to do it to somewhat horrifying.

There is TenDRA, interesting for a number of reasons

Enjoy VisualDSP++, where sizeof(char), sizeof(int) and sizeof(short) were all 1, and the sizeof a pointer was either 1 or 2 depending on what it pointed at, had extensions for vectorized operations, indexed initializers, and many other goodies. I dimly recall that at one point it had some extensions specifically for ring buffers but I can’t find it now (or maybe I’m misremembering, ti was a long time ago). This one’s an older edition, it’s just the first one that came up on Google.

The entire world of DSPs and MCUs is fascinating in this regard. I bet a good chunk of the undefined behaviour cases left in the C standard are due to some of these and it’s still not enough, their compilers still go around the standard in all sorts of ways (sometimes for legitimate reasons, sometimes because why not).

A couple unusual ones I didn’t see in this thread yet: GNU Mes and the DuskOS Compiler

Oh, I’ve been waiting for this thread for years!

Small C by Ron Cain (http://www.svipx.com/pcc/PCCminipages/zc9b6ec9e.html) later known as Pawn and adapted by Thiadmer Riemersma aka Compuphase (https://www.compuphase.com/pawn/pawn.htm) and later adapted again by the sa-mp/open.mp community to fix bugs and provide new features (https://github.com/openmultiplayer/compiler)

This was my first language and the reason I got into software! Why you may ask? Well some time in 2005, someone known only as “Kyeman” (who has since disappeared) built a mod with a team of others (who’s names I sadly forget) for GTA San Andreas that provided multiplayer functionality. Players can host a server which uses Pawn as its scripting language. This lead to a huge community growing around the game (and it’s still played today! massive in Russia, Indonesia, Philippines, Brazil, etc and our server index is telling us: 40736 players on 913 servers with an average of 44.6 players per server.)

This language has a special place in my heart, this game was my childhood and many thousands of hours were spent writing my server script and running my little community. Some of us are still friends today (and we’ll be meeting up at FOSDEM as we have done for the last few years)

It’s a fascinating language, diverged quite a bit from C over the years but I could write a whole series (which I need to make time to do) about it. There are some really interesting ideas, some of which I think are really clever and haven’t really made their way into modern languages. So, if you’re curious, AMA!

Hyper C for the Apple II is mirrored on Github!

This is a weird one for multiple reasons that will become obvious as soon as you start reading https://github.com/shinh/elvm

I learned on Borland’s Turbo C in the 90s. It was a commercial IDE and compiler. But I was too young to know that it wasn’t the only option, so I have nothing else to compare it to, and I remember very little about it.

https://en.wikipedia.org/wiki/Turbo_C

MetaWare’s High C has made the rounds a couple times via this article.

See https://lobste.rs/s/wmfa4g/lost_language_extensions_metaware_s_high

JeanHeyd Meneide mentions “Kate’s maliciously conforming TenDRA compiler, which allows you to do things like screw around with the actual, physical representation of elements”.

Tendra started out in 1992 as a project by the UK’s Defence Research Agency, and at present it has a website with a bunch of docs, papers, and technical reports, as well as a version control repository. In the earliest technical report, from 1993, I was delighted to see dr. Peeling’s e-mail address at the time was peeling%hermes.mod.uk@relay.mod.uk.

(Me, I don’t know any C except C is Charlotte, die drinkt chocolaad’ / D is een Dame die drentelt op straat.)

I used the HP-UX C/C++ compiler, aCC, years ago but I don’t remember anything particularly weird about it. It came with RogueWave’s STL implementation which was quite nice.

Also used the Green Hills C compiler back in my embedded systems days. https://www.ghs.com/products/compiler.html … we had our own in-house peephole optimizer for this one.

Someone mentioned Watcom. Here are some even more obscure C compilers originating in Waterloo, Ontario.

• ⟨https://csg.uwaterloo.ca/sdtp/watc.html⟩ Waterloo C for IBM mainframes running MVS or VM/CMS.
• ⟨https://www.thinkage.ca/gcos/product-ansic.htm⟩ Thinkage ANSI C compiler for the GCOS operating system running on a 36 bit Honeywell 6000.
• ⟨https://www.phaedsys.org/principals/bytecraft/bytecraftccop8.html⟩ Byte Craft COP8 C compiler. The National Semiconductor COP8 is an 8 bit microcontroller from 1988.
• ⟨https://www.phaedsys.com/principals/bytecraft/bytecraftc6808.html⟩ Byte Craft 6808 and RS08 C compiler. The 6808 is a variant of the Motorola 8 bit 6800 cpu from 1974. The RS08 is a “reduced resource” variant. The 6800 had an extravagant 5 CPU registers (A, B were 8 bit, IX, SP, PC were 16 bit, plus an 8 bit status register with 6 usable status bits). The RS08 dispenses with the stack register (thus, no stack), and provides: A (8 bits), PC and SPC (14 bits), and 2 status bits, with 3 additional 8 bit registers mapped into RAM. 14 bit addresses give you a 16KByte address space. An 8 bit memory mapped Page Select register allows you to use 6 bit addresses into the currently selected page. Interesting that a C compiler is even possible for this ISA.

My first actual language, Not Quite C - https://bricxcc.sourceforge.net/nqc/

I recall on RISCOS the compiler would – I feel like this can’t possibly be correct – go look for a file called stdio in a subdirectory called h, when you wrote #include <stdio.h>, because file extensions weren’t a thing and so they got turned into subdirectories. Could that be right?? It was more than 30 years ago.

Or could it have been that you had to write #include <h.stdio>, instead, and because . was the path separator on RISCOS it ended up doing the above? Ugh. (Certainly . is the path separator on RISCOS.)

We can’t forget QuakeC! The C variant used in Quake!

VisualDSP++ (toolchain/IDE for Blackfin/SHARC DSP chips) has some custom extensions and behaviors that will look weird. IIRC signed integer overflow is not UB, it’s actually configurable (wrapping or saturating).

The Reason digital audio workstation has an extension platform: https://developer.reasonstudios.com/

To develop new extensions you write C++ and then use a proprietary, outdated llvm fork to build it into special secret llvm bit code for upload and testing. And the tools are of course only available for a couple of platforms.

XSCompiler. It was a DOS-era compiler for a C-like language created on top of C, which has used a different extension (.xss instead of .c). But it should handle at least some C sources. I think it was made mainly for demos and games, as it featured a lot of bundled libraries handling graphics and sound. It bundled its own DOS extender (Xtender).

One interesting feature is that the standard toolchain had support for generation of encrypted binaries (but I have no idea what encryption was used).

The original website has been excluded from the Wayback Machine, so it’s lost.

Later it was converted to ECDK, and later it was forked to OpenECDK.

Also, nobody has mentioned djgpp yet. It is a fork of gcc, so a little bit boring here, but it has a lot of DOS specific stuff exclusive to DJGPP, like a DOS extender go32. It was used commercially for some games, e.g. Quake.

OpenWatcom is the descendant of the original Watcom C/C++ compilers and is the standard C compiler for FreeDOS (IIRC).

HiSoft C: a K&R based compiler from 1984 for Z-80 based micros. Not very commercially relevant but it was my first encounter with a C compiler.

I have a copy of James E. Hendrix’s A Small C Compiler: Usage, Theory, and Design book sitting on the shelf behind me. I found it in the bargain bin at the local CompUSA store one day as a young teen. I never actually did use the compiler itself, but poring over that book on a bunch of summer evenings sitting by local lakes while my dad and brother fished was one of two book from which I learned C. (I was lousy at fishing; I pretty quickly gave up on it, but I still enjoyed the company and the fresh air and quiet for reading).

The other was, C for Yourself which came bundled with the Microsoft QuickC 2.5 compiler, which is the compiler that I actually did learn C on. I spent a lot of time experimenting with writing code with that compiler before eventually moving on to Borland C++ 4.0.

I also remember seeing lots of ads for Mix Power C, back in the hay day of Dr. Dobbs Journal. Never tried it though, but the price was appealing.

And of course, there was the Watcom compiler, which I remember being notable for being able to build 32 bit protected-mode binaries with a DOS extender. Famously, that’s what the first Quake was built with.

Some time ago I was looking for a compiler suite / code editor that would be useful on a 8086-class machine and I’ve stumbled upon this little gem - https://www.aztecmuseum.ca/

We forgot open64

Like any commercial RTOS dev environment - sometimes they shipped with a heavily patched/augmented gcc, sometimes it was their own compiler 🤷‍♂️

A few more:

BDS C I may have a copy of that on floppy somewhere. https://en.wikipedia.org/wiki/BDS_C

Alycon C Used by Digital Research for the Atari ST, also for CDOS 68k (aka FlexOS 68k). It was a quite poor implementation. Source can be found in certain DR data dumps, e.g. on Gabi’s CP/M site.

Sozobon C For the 68k, K&R

Pure C For the 68k (Atari ST), essentially a version of Borland’s Turbo C, but for 68k.

AHCC An ANSIfied version of Sozobon : https://github.com/swetland/ahcc

VBCC (The direct site is not currently responding for me) https://web.archive.org/web/20250102013526/https://www.compilers.de/vbcc.html

[Comment removed by author]

There was the Mix Power-C compiler for DOS. http://www.mixsoftware.com/ There were a whole suite of libraries for it.

Wikipedia has got you covered: Category:C (programming language)