Skip to main content

Featured

the importance of hustle and why it matters

Anyone who has played a team sport, say soccer, knows the difference between speed and hustle . Speed is distance over time.  Hustle is mind over matter .  Speed is how quickly you can run. Hustle is how quickly you get to the ball when ... a) it's sitting in front of your goal and the goalie is gone b) you're tired but you need that burst of energy to stop a run-away forward on the other team c) when you decide you won't let the other guy/gal get to the ball before you. In other words, hustle is what you do to win .  It's the difference between waiting for a pass to get to you and going out to meet the ball . It's Wayne Gretzky skating to where the puck will be . In business, it is following up with a customer, or staying late one night because it is the last push to production.  Hustle is writing that thank-you note to the cleaning staff even though you want to go home or dropping a pizza off to the operations team working late tonight.    You don'

Native compilers for Windows (32 and 64 bit)


It is remarkable to me that so few native compilers are still available on the market today. I am well aware of the benefits of .Net and Java byte-code compilers. However, there are a number of products that are better suited to native code.   Regardless of the reasons, it is troubling to note how few commercial/high quality competitors are left.

There's a certain irony, considering the Intel/AMD chips have won the instruction set wars.  Making software go fast on an Intel chip would seem to be a valuable service.  Of course, you'd have to compete with open source software.

Worse yet, some of these compilers are basically out to pasture, obsolete, no longer maintained, old, crusty, and ultimately a dubious idea to base any professional work on. But they might still be a ton of fun to explore.

Here are a few products that still generate native code. I do not include compilers that run byte codes or tokenized source, because that does not result in a binary. I did include compilers that generate assembly or "C" source that can then be assembled/compiled to binaries.

Inclusion in this list is not an endorsement and neither is exclusion a judgment - I am merely collecting these lists as a service to myself and others.  The main criteria for inclusion is the generation of native code at compile time, not JIT and not interpreted.

By the way, it seems that 64-bit compilers are even rarer than Win32 compilers.

Many of these are no longer actively maintained which is too bad.

Update:
In the past 10 years, there has been a sudden interest in native compilers.  I attribute this to the availability of LLVM as a compiler backend.

Now we have C++, Crystal, Go, Haskell, Nim, Rust, Zig, Odin, and others that generate native code.  

We are learning that writing code for native compilation requires care in memory management and types that we never did get right before.  But, as an industry, we really have learned a few things. So the situation is getting better.  C and C++ are still rather dangerous (in the sense of being tools with sharp edges) yet I still enjoy programming in both of them.
 

Ada Compilers

Ada is certainly not as popular as it once was and the standard did advance once.

APL
no compilers known. See J language below for alternative.

AWK

Oh yeah, there's an Awk Compiler:  http://awka.sourceforge.net/index.html 


Assemblers

NASM -the netwide assembler.


BASIC Compilers

It's rather amazing how many BASIC compilers generate native code. 
C/C++ Compilers
NOTE: if you are doing Windows development using free tools, you probably need to get the Windows-specific headers and libraries. You can get these at:
http://www.mingw.org/

CAML Compiler
COBOL Compilers
I can't recommend COBOL for any application except migration to another language.  At this point in time, it is too risky to use given its poor support for testing, poor data typing, and general disuse.

Crystal Compilers

None yet.

D Compilers
Remarkably, these are still a viable option and free available.
DIBOL
Factor Compiler

Factor has an optimizing compiler! This is a neat functional programming language very similar to Forth but far more powerful.
FORTRAN Compilers
Naturally, Fortran has many native compilers. The oldest language lives on, still producing new standards.




Google GO
Haskell
Haskell is a strongly typed, lazy, functional programming language that has recently become quite popular.

 

Haxe
 
The Haxe optimizing cross-compiler generates C++ output that can be compiled on Windows. It works! It can also generate a bunch of other languages, like JavaScript or Java.  I'm quite surprised.  Also, it's designed with the idea that you can use local facilities (i.e. it's not like Java which is compile-once, run everywhere because there's a huge library). 

J language

Does the J language generate compiled executables? I don't think so from a read of https://jsoftware.com

Jai Compiler

Jonathan Blow (famed game designer/developer) is writing a new compiler + language for game development. It is a native compiler. It is not publicly available as of March 2020.


Jovial Compilers

"Jonathan's Version of Algol" - once heavily used in military applications (apparently).
  • http://seadeo.com/SEA_Compilers.htm

Julia Compiler

Julia as a language feels like a scripting language but contains a full compiler as well.  Emphasis is on numerical computation but seems general purpose to me.  I believe it can now do pre-compilation instead of only doing JIT.


Kotlin

The kotlin native compiler can generate x86_64 binaries for Windows. https://kotlinlang.org/


Lisp Compilers (Common Lisp and Scheme)

It seems many of the lisp compilers either generate byte-code or don't target Windows as a platform.  I will say that most of these compiles are rather expensive for my tastes.  However, given the productivity of Common Lisp, there may be good reason to adopt them.

Lobster

 The lobster compiler generates C++ code which can then be compiled into a binary.

Modula-2/3 Compilers
ML Compiler

NIM Compiler

 Oberon 2 Compilers

OCCAM Compilers
  • none known

OCAML Compilers
  • OCaml for Windows (uses Cygwin to run but generates Win32 exes that don't require cygwin)
Odin Compiler


Pascal Compilers
PL/1 Compilers

As far as I can see, there are no PL/1 compilers left.

Prolog Compilers
Oddly enough, there are a ton of compilers for prolog, which is funny since this was originally an interpreted language.
RUST
The Mozilla Rust language can compile native binaries. https://www.rust-lang.org/en-US/ 

 
Sather
This language out of UC Berkeley never really got much traction despite some good ideas.



Seed7 Compilers

The Seed7 language is both interpreted and compiled. (see http://seed7.sourceforge.net/) The compiler is at http://seed7.sourceforge.net/scrshots/s7c.htm and generates C code (like old C++ compilers used to do...)


SIMULA
What happened to Lund Simula?

SMALLTALK

Smalltalk is an odd beast because it does not produce standalone binaries.  It's all about the "image" file.  So I'm uncertain how you would use it on the Desktop.  On Server side, you can certainly use it.  Now the only question is whether it is a true native code compiler. I don't believe so. Let me know if I should add Squeak, Pharos, or StrongTalk, any other Smalltalk derivative.


SNOBOL/SPITBOL
none known.
Catspaw used to provide a Spitbol-386 compiler.

XBASE
Xbase languages were very hot in the 1980s and 1990s for all-in-one database applications.  The web and web-hosted applications have significantly reduced the need for these languages but I still need a niche.
Harbour Project - https://harbour.github.io/

Zig
The Zig language is targeting the C/C++ world as a drop in replacement - https://ziglang.org





Comments

Popular Posts