LinuxLinks.com
Newbies What Next ? News Forums Calendar
Home | Register | News | Forums | Guide | Free Software | Portal Pages | MyLinks | Add Link | Modify Link | New | Hot | Link Us

Search/Browse

 Category Gateway
More Options
Category:  

Related Sites

LinuxLinks Login

Login:

Password:



Click here
to start your own
Link collection!

LinuxLinks News
 · ASUS’ Big Development
 · OpenBSD devs respond to Torvalds’ monkey jibe
 · Linux 2.6.26 enhances desktop Linux
 · Debug probes expand PowerPC support
 · Torvalds attacks IT industry ’security circus’
 · Mono man accuses Mac Gtk+ fans of jeopardizing Linux desktop
 · 42 of the Best Free Linux Video Software
 · Linux based virtualisation – the way to save money and go green
 · Closed Source vs. Open Source in Desktop Linux
 · Linux not essential to Eee PC success: ASUS
(more...)

 

Latest Links
Autoresponse
LondON Ontario Linux Users Group
(more...)

 

Google Search
 



Top : Software : Programming : Development : Tools : Make Tools

Highlights
ASUS’ Big Development
While the media is downplaying ASUS' ROM boot chip, it may be the most interesting development in a while.

(Read more)
RSSOwl
RSSOwl is a free RSS (0.91, 0.92, 1.0, 2.0) newsreader written in Java programming language using SWT as fast graphic library. Features of RSSOwl include reading RSS or RDF newsfeeds in a comfortable tab folder, save newsfeeds in categories, export them to PDF / HTML or OPML, and view news in an internal browser. Read more

Links:

  • antiauto
    A simple ant build.xml template to use on automake based projects. It can handle all steps from generating the configure script to creating a distribution tarball by providing simple automake-like ant targets.
  • Autobuild
    a package that process output from building software, primarily focused on packages using Autoconf and Automake, and then generate a HTML summary file, containing links to each build log. The output include project name, version, build host types (cross compile aware), compiler host name, date of build, and indication of success or failure. The output is indexed in many ways to simplify browsing
  • Autodepend
    keeps track of all file access during a build process and then generates gnu-make dependancies. Autodep-gmake is a ehanced gnu make wich use the autodepend shared object natively
  • autoproject
    interviews the user, then creates a source package for a new program which follows the GNU programming standards. The new package uses autoconf to configure itself, and automake to create the Makefile. `make distcheck' succeed
  • autotools-idl
    autotools-idl is a patch for automake and some autoconf macros which add support for IDL and C++ ORBs. They try to provide full support for compiling IDL files to C++ stubs and skeletons.
  • Bakefile
    a cross-platform, cross-compiler native makefiles generator. It takes compiler-independent description of build tasks as input and generates native makefile
  • bras
    a make replacement written in Tcl
  • build
    simplifies C and C++ development on Linux systems. build will scan your source code files for the required elements (lib's and includes) to create a Makefile script then it will automatically generate it
  • Build Audit
    a tool permitting to audit a software build procedure to extract and archive a lot of useful information on the build
  • Build Interceptor
    Build Interceptor is a collection of scripts for recording the .i files generated during a build of C or C++ programs with the gcc tool-chain. No modification to the original build process is necessary.
  • BuildBot
    a system to automate the compile/test cycle required by most software projects to validate code changes. By automatically rebuilding and testing the tree each time something has changed, build problems are pinpointed quickly, before other developers are inconvenienced by the failure
  • Builditis
    Builditis is a build system for C/C++ projects that reads build information from the source files of the project. It flags files for rebuilding based on a checksum. Program builds are organized by directories. It only supports executable builds for now.
  • Buildtool
    a set of utilities which will make your programs more portable and easier to build on any kind of Unix-like system. All the utilities are integrated with each other, which means that they all work together. It is completly free, licensed under the terms of the BSD license
  • ccbuild
    ccbuild is like a dynamic Makefile. ccbuild finds all programs in the current directory (containing "int main") and builds them. For this, it reads the C++ sources and looks at all local and global includes. All C++ files surrounding local includes are considered objects for the main program.
  • cm
    cm is a build management tool similar in spirit to make. It features a clear, powerful language, separate macro and variable namespaces, user-defined procedures, support for multiple build modes and multi-pass builds over complex directory hierarchies, while providing useful abstractions to support compilation on multiple operating systems.
  • CMake
    a cross-platform, open-source make system. CMake 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 choice
  • Confix
    a build and maintenance tool for source code packages. It is built on top of the standard open source tool Automake. It relieves the package maintainer from the burden of having to write complex build instructions by hand
  • CONS
    a replacement for MAKE. It is not compatible with make, but it has a number of powerful capabilities not found in other software construction systems, including make
  • Cook
    a tool for constructing files. It is given a set of files to create, and recipes of how to create them
  • cppmake
    Cppmake is a front-end to make that builds C++ programs with less effort than writing makefiles manually. Building a C++ program with cppmake is similar to compiling a Java program. The idea is that you specify a classpath and cppmake will automatically find all the classes needed by your program. Once found, all of the classes are compiled and linked into an executable or library.
  • Daybodep
    Daybodep scans C files for header inclusions so that they can be written to the Makefile indirectly.
  • distmake
    distmake is a distributed, parallel, GNU make compatible make program. distmake reads a Makefile, and distributes builds targets over a set of build servers on the network.
  • farm
    a utility to accelerate compiles or other jobs that can be processed by GNU make. It spreads the work of a job among multiple systems
  • fastdep
    a fast dependency generator for C/C++ files
  • gamem4
    gamem4 is a package of autoconf/automake m4 files for game development.
  • Gconfigure
    a shell-script that allows for a more easy building of programs for sources
  • Generic Makefiles
    a collection of makefiles using GNU tools (GNU Make and GCC). They provide automatic dependencies and easy configuration for simple (flat directory) C or C++ projects
  • genmake
    A small and pretty fast utility that generates Makefile for C/C++ projects. It's written in bash.
  • hmake
    an intelligent compilation management tool for Haskell programs. It automatically extracts dependencies between source modules, and issues the appropriate compiler commands to rebuild only those that have changed, given just the name of the program or module that you want to build
  • iMake
    (commercial) a platform independent make processor written entirely in Java for creating scalable enterprise solutions
  • Intergif
    a platform-independant perl script which parses the output of GNU make to produce useful information on the terminal, such as progress toward completion and current action
  • istrice
    aim of this project is to allow a client to assign the compilation of a source file to a remote server throughout the mediation of a Master Server
  • Jam
    a make(1) replacement that makes building simple things simple and building complicated things manageable
  • jmake
    an automated alternative to creating makefiles for software development under Unix. Using a few basic assumptions, jmake can build libraries and executables for multiple concurrent platforms with minimal effor
  • kdesvn-build
    kdesvn-build is a script to automate the process of downloading, building, and installing KDE from its Subversion source repository. It supports many advanced features such as partial checkout/build of a module, the unsermake build system, incremental make, module checkouts using Subversion snapshots from the kdesvn-build.kde.org site, and repeatable builds.
  • KJam Build Tool
    KJam is a build tool like make. It uses a syntax similar to Jam, with more powerful features than the original Jam. It has built-in very fast dependency scanning, per-target viewpathing, and C-like control flow. It is optimized for multi-processor machines. It can accelerate building by launching build actions on a distributed peer to peer network of build servers. It is designed to support large projects with thousands of targets, or projects requiring building on many target architectures.
  • LogiLogi.org Make
    yet another make replacement, but one that allows you to create your makefile in C++. A header and footer are added to it, and it's then compiled using your C++ compiler.
  • Magic Makefile
    Magic Makefile is an alternative to autoconf/automake, cmake, scons, etc. that uses only GNU make and bash and other shell tools. It makes it much simpler to do many C/C++ programming tasks without having to resort to an IDE.
  • Make
    a tool which controls the generation of executables and other non-source files of a program from the program's source files
  • make utilities
    a set of portable public domain programs designed to support C/C++ projects. It provides tools for build operations outside of the normal compile/link pipeline. It is designed to be unobtrusively included directly in your own project
  • make+
    a set of scripts which enhance GNU make. The scripts replace the functionality of autoconf, automake, rpm, dpkg and more, allowing you to build, install, make RPMs, make Debian packages and more, all from a single maintainable 'Makefile+' script
  • Makemake.pl
    generates C/C++ Makefiles out of short Perl-based templates. However, users are not required to know Perl to use Makemake.pl
  • MakeModules
    consists of a collection of "Makefile" snippets each of which defines features for a single task or some related tasks. For instance one snippet defines features for generating programs from C sources, another snippet defines features to generate man pages, while yet another snippet defines features for installing files in various ways. In no way the tasks are limited to programming
  • MakeNG
    a system of makefiles which, in conjuncture with the patch to GNU Make, provide a concise, extensible, logically organized and easily modified system of makefiles
  • makepp
    a drop-in replacement for GNU make which has a number of features that allow for more reliable builds and simpler build files. It supports almost all of the syntax that GNU make supports, and can be used with makefiles produced by utilities such as automake
  • maketool
    a simple GTK based GUI front end for GNU make
  • Melas
    Melas is an uncomplicated build and packaging tool. It is used to compile software and create installable package files. Melas can be used to reliably reproduce builds and perform dependency tracking. Cross-compilation is supported through integration with Sbox2.
  • mfg
    a fairly simple (template-based) makefile generator. It tries to guess all necessary steps to create a specified target file from a given set of source files
  • mkDoxy
    parses a makefile and produces HTML documentation of available targets and macros. Only comments starting with ## are considered, so it is easy to control what documentation is generated
  • mkproject
    mkproject ("make project") is a script that makes project skeletons. It automatizes the task of starting a new project with the information provided from the command line. The package created by default is a "hello world" project of the selected skeleton that uses the autotools to be managed.
  • mmake
    generates a Makefile for Java programs. It supports packages, JavaDoc, Cleanup, preprocessor support for version handling, Jar files, Installation, and many more functions
  • My Own Building System
    My Own Building System is a GPL'd build system, lightweight and easy to use, with a limited application framework. It gets information from the end-user wanting to build your project and modifies the building process according to such information.
  • Nmdepend
    Nmdepend is a lightweight "link-time" dependency analyzer for C++. It uses object files and libraries instead of source-code as input. It can help to manage "cross-directory" dependencies. Dependencies can be visualized in combination with Graphviz.
  • OMake
    a build system similar to GNU make but with many additional features, including support for large projects spanning multiple directories, support for commands that produce several targets at once, fast, accurate, and automated dependency analysis using MD5 digests, portability, and built-in functions that provide the most common features of programs like grep, sed, and awk
  • Parabuild
    Parabuild is a quality automated build management server. It helps software teams and organizations of all sizes reduce risks of project failures and increase productivity.
  • pkg-config
    a system for managing library compile/link flags that works with automake and autoconf. It replaces the ubiquitous *-config scripts you may have seen with a single tool
  • pkgconfig
    pkg-config is a system for managing library compile/link flags that works with automake and autoconf. It replaces the ubiquitous *-config scripts you may have seen with a single tool.
  • pkgmake
    pkgmake automates some steps when making software releases. It creates a copy of the development tree, optionally cleans it up a bit (i.e. removes CVS/* and .svn/*), tars it, places the tarball in the SOURCES/ directory, creates the corresponding .spec file from a provided template (and the data specified in the configuration/on the command line), and runs rpmbuild and/or debbuild.
  • Pretty make
    a very small python script that will colorize and organise your make output
  • Prime Mover
    Prime Mover is a small and flexible build tool intended to be used instead of make. It is intended to be deployed with the projects that use it, and does not requires installation to use. It is modular and can be extended using the Lua scripting language.
  • Project Builder
    Project-Builder is a tool that helps you build packages of your application (managed with a tar file or a configuration management system such as CVS or Subversion). It is able to generate a build package skeleton for your project. With simple configuration files, it can generate for up to 20 different tuples of distributions (name, version, architecture), including Fedora, Mandriva, OpenSuSE, Debian, Ubuntu, Gentoo, and Slackware.
  • prototype
    a collection of generic Makefiles which are installed globally and Makefile templates that can be copied into project directories using a simplescript
  • PTXdist
    PTXdist is a collection of Makefiles under the GNU GPL which are used at Pengutronix for generating userlands. The configuration is done via a KConfig based frontend.
  • PVM Gmake
    a GNU make which uses PVM to build in parallel on several remote machines
  • QA Tools
    QA Tools allow you (the software product maintaner) to automatically generate regular releases and/or snapshots of your product. Your product can be distributed as a source code archive (typically .tar.gz) or as a binary distribution archive (.deb, .rpm, .exe).
  • QuickBuild
    (commercial) QuickBuild is a cross-platform build automation and management server which helps continuous integration or nightly builds. Besides the ability to automate your builds, QuickBuild puts extra emphasis on build management so that your QA/release builds can be generated and managed in a simple and efficient way. Configuration, monitoring, and access to build artifacts are all done through an intuitive web interface. Your development and testing team will have a central area to access the build information.
  • relman
    relman is a tool that takes your source code, runs the build, and distributes the packages. A configuration file allows you to define application-wide defaults in addition to information particular to individual projects such as the source directory, package name, and the like. Once set up, you just have to call relman with the name given to the project plus the version to release. It calls pkgmake to build .tar.gz, .deb, and .rpm files, and then distributes them using FTP and/or SCP all in one run.
  • RPSL
    Rapid Prototyping Shared Library is a set of bash scripts and utility files that coordinate the GNU autotools and pkg-config for C/C++ build automation. The scripts and procedures define a system for building and linking that supports an individual or small group. A single command (rpslSyncBuild) scans for source, writes a Makefile.am and Configure.ac, and produces a conventional autotools tree ready for the usual "configure, make, make install" build steps.
  • Schily Source Package System
    The Schily Source Package System (SPS) is a source-based packaging system that is developed for SchilliX (a OpenSolaris-based Unix distribution) but is highly portable and works on many operating systems. It "boots" from a single 10kb shell script and creates all needed binaries from scratch. In contrast to other similar systems, it is modular and reusable. It is based on the Schily Makefilesystem and smake.
  • SCons
    an Open Source software construction tool--that is, a build tool; an improved substitute for the classic Make utility
  • SCons Erlang
    Scons Erlang is an add on for SCons, a make/autotools replacement, to compile Erlang projects.
  • sdist
    builds a Makefile.PL for perl scripts, together with the necessary files to make a distribution
  • Sire
    a build utility like make. However, it is free format with what is a (hopefully) a simple and straight forward syntax
  • SMake
    SMake is a powerful mechanism to generate standard Makefiles out of skeleton Makefiles which only provide the essential parts.
  • SMK
    automatically determines, which pieces of a program need to be recompiled and issues commands to recompile them, in other words, it's a build tool (or make tool), superseding make
  • Sol Manager
    Sol Manager is a tool to manage your source files and configuration settings. SolMgr organizes project information in compiler- and platform-independent descriptions and allows conversion to native build scripts, such as makefiles or MS Visual Studio solutions. GUI is provided to visually control project configurations, and to perform everyday project management tasks such as files addition/removal, dependency management etc.
  • tmake
    tmake is an easy-to-use tool to create and maintain makefiles and IDE project files for software projects.
  • tmk
    combines the functionality of a traditional make utility with the power of the Tcl scripting language
  • XMake
    specifically designed to allow you to easily construct multiple complex dependencies without getting screwed by default rulesets. XMake contains a number of features specifically designed to trivialize the construction of compilation rules
  • xmake
    similar to other make's out there, but is specifically designed to allow you to easily construct multiple complex dependencies without getting screwed by default rulesets
  • Yabu
    Yabu is a replacement for the make build tool with some extended features. Yabu's file format is similar, though not compatible with make.
  • yruba
    Yruba provides a rule system similar to make or ant for the shell (bash). It provides a clear separation between a list of dependencies that must be up-to-date before the current task can be performed, an explicit test that checks whether the target is really out-of-date, and a command that finally makes the target.



Other Sites

Migrate to Linux
Thinking of switching to Linux? Check out our Linux Equivalents to Windows Software section, highlighting popular Linux equivalents to Windows software.

This feature also includes over 150 individual software portal pages including Blender, Scribus, OpenOffice.org, Evolution, Eclipse, K3b, and MythTV, providing a wealth of essential information.

 

Distribution Guides
Distro Guide

Debian
Fedora
Gentoo
Mandriva
OpenSuSE
RedHat
Slackware
Ubuntu
Xandros

Absolute
Linux Mint
64 Studio

LiveCDs
Berry Linux
GoblinX
KNOPPIX
Kubuntu
NimbleX
PCLinuxOS
Sabayon
SimplyMEPIS
Xubuntu

Entire List

 

SourceFiles.org
Sourcefiles.org
Backup
CD Writing
Databases
Editors
Emulators
Financial
Games
Graphics
Home ...
Internet
Multimedia
Networking
Office
Prod Tools
Scientific
Shells
Spreadsheets
Toys
Utilities
WMs

 

Services
Web Calendar
Linux Licenses

Advertise at LinuxLinks.com

 

My LinuxLinks
MyLinks
  • Bookmarked links
  • Emailed Newsletter
  • Your own profile

  • Latest Portal Pages
    Mixxx
    energyXT2
    GRASS
    uDig
    QGIS
    gretl
    SPSS

     

    About | FAQ | Privacy | Awards | Contact
    Portal Version 0.7. Intel Blade.
    Comments to the webmaster are welcome.
    Copyright 2002-2007 LinuxLinks.com All rights reserved.