Projects tagged ‘development’ and ‘make’

Make is a tool which controls the generation of executables and other non-source files of a program from the program's source files.

Apache Ant is a Java-based build tool. In theory, it is kind of like Make, but without Make's wrinkles.

GNU Automake is a part of the GNU build system, along with GNU Autoconf and GNU Libtool. GNU Automake is a tool to create portable makefiles to manage the building and distribution of source code projects.

Rake is a Ruby make-like utility using standard Ruby syntax for the build specification file.

CMake is a cross-platform, open-source build system. It is used to control the software compilation process using simple platform and compiler independent configuration files. CMake generates native makefiles and workspaces that can be used in the compiler environment of your cour choice, such as GNU Make, Visual Studio, and Xcode.

NAnt is a Ant like build tool for .NET

Cabal is a system for building and packaging Haskell libraries and programs. It defines a common interface for package authors and distributors to easily build their applications in a portable way. Cabal is part of a larger infrastructure for distributing, organizing, and cataloging Haskell libraries and programs.

MPC takes platform specific input along with the build tool-generic files and generates build tool-specific project files by using a framework-based approach that supports the following: * Inheritance from common base projects * Default ... [More] values for many aspects of a project * Simple syntax for ease of use and maintenance * Extensibility for adding custom features or support for new build tools * Use a scripting language (OO Perl) for rapid development, portability, and ease of automation MPC is more than a makefile generator. It currently supports the following tools: Generic Make, GNU Make (ACE, TAO, and CIAO only), NMake, Visual C++ 6, 7.1, 8 & 9, Embedded C++, WindRiver Workbench 2.6, & Borland Make Presently MPC supports C++, C#, Java, and Visual Basic. [Less]

Bakefile is cross-platform, cross-compiler native makefiles generator. It takes compiler-independent description of build tasks as input and generates native makefile (autoconf's Makefile.in, Visual C++ project, bcc makefile etc.). Bakefile's task ... [More] is to generate native makefiles, so that people can keep using their favorite tools. There are other cross-platform make solutions, but they either aren't native and require the user to use unfamiliar tools (Boost.Build) or they are too limited (qmake). [Less]

Buildr is a build system for Java applications. We wanted something that’s simple and intuitive to use, so we only need to tell it what to do, and it takes care of the rest. But also something we can easily extend for those one-off tasks, with a ... [More] language that’s a joy to use. And of course, we wanted it to be fast, reliable and have outstanding dependency management. [Less]

The Pre Make Kit project is a toolkit providing a collection of tools aimed to ease a lot of stages in project development. It provides a scanner that generates template source components such as configuration file or makefile. It also provides a ... [More] dependency checker that sets up templates files depending on the system components (such as auto* tools or similar projects). For portability purpose, a BSD like install program is also part of the kit. [Less]

Dolt provides a drop-in replacement for libtool that significantly decreases compile times on the platforms it supports. Rather than the libtool approach of running a large script for every compile that repeatedly figures out how to build libraries ... [More] on the platform, dolt figures out those details at configure time and writes out a minimal doltcompile script containing only the commands needed to build a library on the current platform. If you use automake, autoconf, and libtool, then using dolt just requires two steps: 1. add DOLT after the call to LT_INIT, AC_PATH_LIBTOOL, or AM_PATH_LIBTOOL in your configure.ac or configure.in script, and 2. append dolt.m4 to your project's acinclude.m4. For any platform Dolt does not support, it will transparently fall back to libtool. [Less]

ASDF dependency grovel helps you maintain a Common Lisp system that is both easy to develop and speedy to recompile - think of it as a "make depend" for Lisp. It allows you to keep your system definition in a serial (or condensed) shape, and ... [More] figures out the dependencies between the system's components itself. This helps you or your users to incrementally compile the system when files change, without going insane from maintaining tens of compile/load-time dependencies for every file in the system. [Less]

Yabs is a build system that takes the form of a Python library. Build systems that use Yabs are specified as a Python programme that makes calls to Yabs functions to register rules for object files, executables and other build targets. A primary ... [More] aim of Yabs is to provide high-level functionality so that these programmes are shorter and easier to write than makefiles or similar. Rules are expressed as Python functions which take a target filename and, if the rule can generate this target, return a Python tuple containing the command(s) that should be run (or a python function to be called) to create the target and a list of the target's prerequisites required by these commands. This design means that the full power of the Python language is available to the user when writing rules. [Less]

Sake is a system-wide version of the Rake application, allowing you to copy and run tasks from one general file into your specific project.

Cookbooks is a set of recipes for the cook program. Main goal is flexibility with minimal maintenance. One may consider it a replacement for automake.