Category Archives: Embedded and mobile phone platforms

Cygwin vs MinGW/MSYS vs the VM top end?

I am surprised that whilst I’ve been distracted by VM (Virtual Machine) based development, the directly compiled options had improved quite a lot. Or did I just not take enough notice of yet another good option? What do I mean?

Well when sat atop of Vista, comparing between a Cygwin shell and an MSYS shell, GCC output says it all

Thread model: win32
gcc version 3.4.5 (mingw-vista special r3)

Thread model: posix
gcc version 3.4.4 (cygming special, gdc 0.12, using dmd 0.125)

Yes (OK my Cygwin might have been on my machine a while, but) the MinGW gcc really is for targeting native windows code.

I don’t know that I would wish to take advantage of the WinAPI, but when creating something that needs to be independent of say Cygwin (cygwin1.dll and its POSIX/*nix layer), and quick, this seems to be a good offering. Somebody else says it more clearly than I, and I quote

Cygwin applications by principle are not considered a “Native Win32 application” because it relies on the Cygwin® POSIX Emulation DLL or cygwin1.dll for Posix functions and does not use win32 functions directly. MinGW on the other hand, provides functions supplied by the Win32 API. While porting applications under MinGW, functions not native to Win32 such as fork(), mmap() or ioctl() will need to be reimplemented into Win32 equivalents for the application to function properly.

I’m preparing myself for some still rather unknown embedded stuff that may lend itself to a greater grasp of C / OpenGL, though if that were not the case, JOGL (Java openGL binding) is an equally valid option.

My recent C / OpenGL code runs fast and native on Windows, and for a *nix person, using GCC is just peachy.

Oh, if you like Clojure, have a look at this option called Penumbra, idiomatic opengl bindings for clojure. Their example says it all, a big step beyond both C and Java. I love the idea that to visualize data, I could combine both Incanter and OpenGL to create an incredible interface! And one could use Clojure concurrency in a way that makes threads look like the new assembly code!