Portable c compiler for windows

Portable C and C++ Development Kit for x64 Windows

w64devkit is a Dockerfile that builds from source a small, portable
development suite for creating C and C++ applications on and for x64
Windows. See «Releases» for pre-built, ready-to-use kits.

Included tools:

• Mingw-w64 GCC : compilers, linker, assembler
• GDB : debugger
• GNU Make : standard build tool
• busybox-w32 : standard unix utilities, including sh
• Vim : powerful text editor
• Universal Ctags : source navigation
• NASM : x86 assembler
• Cppcheck : static code analysis

The toolchain includes pthreads, C++11 threads, and OpenMP. All included
runtime components are static. Docker/Podman is not required to use the
development kit. It’s merely a reliable, clean environment for building
the kit itself.

Build

First build the image, then run it to produce a distribution .zip file:

docker build -t w64devkit .
docker run --rm w64devkit >w64devkit.zip

This takes about half an hour on modern systems. You will need an internet
connection during the first few minutes of the build. Note: Do not use
PowerShell because it lacks file redirection.

Usage

The final .zip file contains tools in a typical unix-like configuration.
Unzip the contents anywhere. Inside is w64devkit.exe, which launches a
console window with the environment configured and ready to go. It is the
easiest way to enter the development environment, and requires no system
changes. It also sets two extra environment variables: W64DEVKIT_HOME to
the installation root and W64DEVKIT to the version.

Alternatively, add the bin/ directory to your path. For example, inside
a cmd.exe console or batch script:

set PATH=c:\path\to\w64devkit\bin;%PATH%

Then to start an interactive unix shell:

Main features

• No installation required. Run it anywhere as any user. Simply delete
  when no longer needed.

• Fully offline. No internet access is ever required or attempted.

• A focus on static linking all runtime components. The runtime is
  optimized for size.

• Trivial to build from source, meaning it’s easy to tweak and adjust any
  part of the kit for your own requirements.

• Complements Go for cgo and
  bootstrapping.

Optimized for size

The language runtimes in w64devkit are optimized for size, so it produces
particularly small binaries when programs are also optimized for size
(-Os) during compilation. If your program only uses the printf family
of functions with MSVC-compatible directives (i.e. limited to C89), and
you want even smaller binaries, you can avoid embedding the Mingw-w64’s
improved implementation by setting __USE_MINGW_ANSI_STDIO to 0 before
including any headers.

$ cc -Os -D__USE_MINGW_ANSI_STDIO=0 ...

Fortran support

Only C and C++ are included by default, but w64devkit also has full
support for Fortran. To build a Fortran compiler, add fortran to the
--enable-languages lines in the Dockerfile.

Recommended downloadable, offline documentation

With a few exceptions, such as Vim’s built-in documentation (:help),
w64devkit does not include documentation. However, you need not forgo
offline documentation alongside your offline development tools. This is a
list of recommended, no-cost, downloadable documentation complementing
w64devkit’s capabilities. In rough order of importance:

• cppreference (HTML), friendly documentation for the C and C++
  standard libraries.

• GCC manuals (PDF, HTML), to reference GCC features,
  especially built-ins, intrinsics, and command line switches.

• Win32 Help File (CHM) is old, but official, Windows API
  documentation. Unfortunately much is missing, such as Winsock. (Offline
  Windows documentation has always been very hard to come by.)

• C and C++ Standards (drafts) (PDF), for figuring out how
  corner cases are intended to work.

• Intel Intrinsics Guide (interactive HTML), a great resource
  when working with SIMD intrinsics. (Search for «Download» on the left.)

• GNU Make manual (PDF, HTML)

• GNU Binutils manuals (PDF, HTML), particularly ld and as.

• GDB manual (PDF)

• BusyBox man pages (TXT), though everything here is also
  available via -h option inside w64devkit.

• NASM manual (PDF)

• Intel Software Developer Manuals (PDF), for referencing x86
  instructions, when either studying compiler output with objdump, or
  writing assembly with nasm or as.

Library installation

Except for the standard libraries and Win32 import libraries, w64devkit
does not include libraries, but you can install additional libraries such
that the toolchain can find them naturally. There are three options:

1. Install it under the sysroot at w64devkit/$ARCH/. The easiest option,
   but will require re-installation after upgrading w64devkit. If it
   defines .pc files, the pkg-config command will automatically find
   and use them.

2. Append its installation directory to your CPATH and LIBRARY_PATH
   environment variables. Use ; to delimit directories. You would likely
   do this in your .profile.

3. If it exists, append its pkgconfig directory to the PKG_CONFIG_PATH
   environment variable, then use the pkg-config command as usual. Use
   ; to delimit directories

Both (1) and (3) are designed to work correctly even if w64devkit or the
libraries have paths containing spaces.

Cppcheck tips

Use --library=windows for programs calling the Win32 API directly, which
adds additional checks. In general, the following configuration is a good
default for programs developed using w64devkit:

$ cppcheck --quiet -j$(nproc) --library=windows \
           --suppress=uninitvar --enable=portability,performance .

A «strict» check that is more thorough, but more false positives:

$ cppcheck --quiet -j$(nproc) --library=windows \
      --enable=portability,performance,style \
      --suppress=uninitvar --suppress=unusedStructMember \
      --suppress=constVariable --suppress=shadowVariable \
      --suppress=variableScope --suppress=constParameter \
      --suppress=shadowArgument --suppress=knownConditionTrueFalse .

Notes

$HOME can be set through the adjacent w64devkit.ini configuration, and
may even be relative to the w64devkit/ directory. This is useful for
encapsulating the entire development environment, with home directory, on
removable, even read-only, media. Use a .profile in the home directory
to configure the environment further.

I’d love to include Git, but unfortunately Git’s build system doesn’t
quite support cross-compilation. A decent alternative would be
Quilt, but it’s written in Bash and Perl.

Neither Address Sanitizer (ASan) nor Thread Sanitizer (TSan) has been
ported to Mingw-w64 (also), but Undefined Behavior Sanitizer
(UBSan) works perfectly under GDB. With both -fsanitize=undefined and
-fsanitize-trap, GDB will break precisely on undefined
behavior, and it does not require linking with libsanitizer.

The kit includes a unique debugbreak command. It causes
all debugee processes to break in the debugger, like using Windows’ F12
debugger hotkey. This is especially useful for console subsystem programs.

Since the build environment is so stable and predicable, it would be
great for the .zip to be reproducible, i.e. builds by different people
are bit-for-bit identical. There are multiple reasons why this is not
currently the case, the least of which are timestamps in the .zip
file.

Licenses

When distributing binaries built using w64devkit, your .exe will include
parts of this distribution. For the GCC runtime, including OpenMP, you’re
covered by the GCC Runtime Library Exception so you do not need to
do anything. However the Mingw-w64 runtime has the usual software license
headaches and you may need to comply with various BSD-style licenses
depending on the functionality used by your program: MinGW-w64 runtime
licensing and winpthreads license. To make this easy,
w64devkit includes the concatenated set of all licenses in the file
COPYING.MinGW-w64-runtime.txt, which should be distributed with your
binaries.

Embarcadero Dev-C++

A fast, portable, simple, and free C/C++ IDE. Dev C++ has been downloaded over 67,796,885 times since 2000.

Embarcadero Dev-C++ is a new and improved fork (sponsored by Embarcadero) of Bloodshed Dev-C++ and Orwell Dev-C++. It is a full-featured Integrated Development Environment (IDE) and code editor for the C/C++ programming language. It uses Mingw port of GCC (GNU Compiler Collection) as its compiler. Embarcadero Dev-C++ can also be used in combination with Cygwin or any other GCC based compiler. Embarcadero Dev-C++ is built using the latest version of Embarcadero Delphi. Embarcadero Dev-C++ has a low memory footprint because it is a native Windows application and does not use Electron.

Download the latest release: https://github.com/Embarcadero/Dev-Cpp/releases

Main Features include:

• TDM-GCC 9.2.0 32/64bit
• Support GCC-based compilers
• Integrated debugging (using GDB)
• GPROF profiling
• Project Manager
• Customizable syntax highlighting editor
• Class Browser
• Code Completion
• Code Insight
• Function listing
• AStyle code formatting support
• GPROF Profiling support
• Quickly create Windows, console, static libraries and DLLs
• Support of templates for creating your own project types
• Makefile creation
• Edit and compile Resource files
• Tool Manager
• Devpak IDE extensions
• Print support
• Find and replace facilities
• CVS support

Supported Operating System:

• Windows 7
• Windows 8.1
• Windows 10

Dev C++ Release Notes

Version 6.3 — 30 January 2021

• Added: Parallel compilation enabled by default for release builds through MAKE Jobs.
• Added: 3 Buttons for setting up custom shell command line tabs.
• Updated: Code completion and menues for dark themes.
• Updated: CTRL-TAB editor tab selection wrapping.
• Fixed: Make clean file deletion issue.
• Fixed: Status bar not showing all text.
• Fixed: Debug/CPU Window hex column issue.
• Fixed: Closing tabs in editor side by side view.

Version 6.2 — 13 November 2020

• Added: 5 new UI styles. Windows 10 Black Pearl, Glossy, Calypso, Flat UI Light, Material Patterns Blue
• Added: Default encoding for new documents option.
• Added: New setting to enable and disable font ligature support.
• Updated: Welcome screen hotkey backgrounds.
• Updated: Allow multiple instances of Dev-C++ to run simaltaniously.
• Fixed: Error on AStyle Formatting Config Form
• Fixed: Double clicking text now selects the current line.
• Fixed: Auto Indent to {} and : now works correctly.
• Fixed: CTRL-Y will not delete the current line if there is nothing left to redo.
• Fixed: Buggy behaviour when highlighting matching braces.

Version 6.1 — 2 November 2020

• Updated: C++ keyword highlighting. Added some C++20 keywords.
• Updated: Font ligature support.
• Updated: SVGIconImageList dependency
• Updated: SynEdit dependency.
• Updated: Text file loading and saving dialogs with Encodings.
• Added: Visual Studio Dark theme.
• Fixed: Automatic Tab widths.
• Fixed: Launching help from directory with spaces.
• Fixed: Welcome screen issue when canceling closing.
• Fixed: Shortcuts Form dark styling.
• Fixed: Crash in Issue #26.

Screenshot:

Bundled Compiler

tdm-gcc: GCC compiler, Windows-friendly. https://jmeubank.github.io/tdm-gcc/

Third Party Libraries

«Artistic Style is a source code indenter, formatter, and beautifier for the C, C++, C++/CLI, Objective‑C, C# and Java programming languages.» http://astyle.sourceforge.net/

«SynEdit is a syntax highlighting edit control, not based on the Windows common controls. SynEdit is compatible with both Delphi and C++ Builder.» https://github.com/TurboPack/SynEdit

«FastMM is a fast replacement memory manager for Embarcadero Delphi applications that scales well across multiple threads and CPU cores.» https://github.com/pleriche/FastMM5

«VCL Styles Utils is a Delphi library which extend the RAD Studio VCL Styles.» https://github.com/RRUZ/vcl-styles-utils

«DDetours is a library allowing you to hook Delphi and Windows API functions.» https://github.com/MahdiSafsafi/DDetours

«Components to simplify use of SVG images (resize, fixedcolor, grayscale…). » https://github.com/EtheaDev/SVGIconImageList

«Abbrevia is a compression toolkit for Delphi and C++Builder.» https://github.com/TurboPack/Abbrevia

«Monokai Theme» https://github.com/rbardini/devcpp-monokai

«Monokai Fresh Theme» https://github.com/sspathare97/devcpp-monokai_fresh

Original Dev-C++ Developers

Find out more about the original developers of Bloodshed Dev-C++:

https://www.bloodshed.net/devcpp.html

Built In Delphi

Find out more information about Embarcadero Delphi:

https://www.embarcadero.com/products/delphi

Portable C and C++ Development Kit for x64 Windows

w64devkit is a Dockerfile that builds from source a small, portable development suite for writing C and C++ applications on and for x64 Windows. Docker is not needed to use the tools themselves. It’s merely used as reliable, clean environment for compilation and linking. Included tools:

• Mingw-w64 GCC : compilers, linker, assembler
• GDB : debugger
• GNU Make : standard build tool
• busybox-w32 : standard unix utilities, including sh
• Vim : powerful text editor
• Universal Ctags : source navigation
• NASM : x86 assembler

The compilers support pthreads, C++11 threads, and OpenMP. All included libraries are static.

Build

First build the image, then run it to produce a distribution .zip file:

docker build -t w64devkit .
docker run --rm w64devkit >w64devkit.zip

This takes about half an hour on modern systems. You will need an internet connection during the first couple minutes of the build.

Usage

The final .zip file contains tools in a typical unix-like configuration. Unzip the contents anywhere and add its bin/ directory to your path. For example, while inside a console or batch script:

set PATH=c:\path\to\w64devkit\bin;%PATH%

Then to access a small unix environment:

busybox sh -l

This will expose the rest of busybox’s commands without further action. However, the unix environment will not be available to other tools such as make without «installing» BusyBox into the bin/ directory:

busybox --install

The distribution contains activate.bat that launches a console window with the path pre-configured and ready to go. It’s an easy way to enter the development environment.

Notes

Due to an old GCC bug, we must build a cross-compiler to cross-compile GCC itself because, due to host contamination, GCC can only be correctly and safely cross-compiled by a matching version.

Since the development kit is intended to be flexible, light, and portable — i.e. run from anywhere, in place, and no installation is necessary — the binaries are all optimized for size, not speed.

I’d love to include Git, but unfortunately Git’s build system is a disaster and doesn’t support cross-compilation. It’s also got weird dependencies like Perl. Git may be a fantastic and wonderful tool, but it’s also kind of a mess.

It would be nice to have a better shell like Bash. BusyBox’s ash is limited, and the Windows port is even more limited and quite quirky. Unfortunately Bash’s build system is a total mess and does not support cross-compilation.

Emacs does not support cross-compilation, particularly due to its fragile dumper. There has been a «portable dumper» in the works for years that, once stable, may eventually resolve this issue. Even then, the parts of the build system that target Windows needlessly assumes a very specific environment (msys), and much of Emacs’ source very brittle. Besides all that, Emacs is huge and including it would triple the size of the distribution. So Emacs will not be included.

What about sanitizer support? That would be fantastic, but unfortunately libsanitizer has not yet been ported from MSVC to Mingw-w64 (also).

Since the build environment is so stable and predicable, it would be great for the .zip to be reproducible, i.e. builds by different people are bit-for-bit identical. There are multiple reasons why this is not currently the case, the least of which are timestamps in the .zip file.

License Crap

When distributing binaries built using w64devkit, your .exe will include parts of this distribution. For the GCC runtime, including OpenMP, you’re covered by the GCC Runtime Library Exception so you do not need to worry about those. However the Mingw-w64 runtime has the usual software license crap and you might need to comply with various BSD-style licenses depending on the functionality used by your program: MinGW-w64 runtime licensing and winpthreads license. To make this easy, w64devkit includes the complete set of licenses in the file COPYING.MinGW-w64-runtime.txt, which should be distributed with your binaries.