any – the engine to build software, distributable in POSIX universe.


any at its core is the set of POSIX shell functions. The functions are designed for launch with anch do or non-container any do commands (see description of both in any-do(1)).

The build of each package is described by file called anybuild, build file, build script or just build. Commands in a build are written in shell and grouped into aimed methods like source fetching, configure, compile or packing.

Single build file may produce installable binary archives in formats for different package managers, for several platforms and with conformance to various development policies.

Tutorial documentation

any-guide(7) - generic introduction, the description of basic working concepts, the description of work with the system in examples. Start with that guide.
any-howto(7) contains brief summary of typical build tasks.
any-build(7) describes in examples how to create a new anybuild.

Local pages in man and html

One may view the man documentation on build commands and functions like that:

        any man <subject>

The any-man(1) command has the same syntax, as the system man(1).

Local docs in HTML format are located at doc/html/index.html.

any, anch

anch is the command, performing its next command inside isolated file environment (host, container), locating in the working directory. anch do is the semantic equivalent for chroot <workdir> ; any do

All commands, starting with any, may be launched with anch:

        any do id package-1.2.3
        # chrooted variant
        anch do id package-1.2.3

        any build id package-1.2.3
        # chrooted variant
        anch build id package-1.2.3

        ... etc.

Reference documentation

For the work with existing packages:

any-do(1) describes the main lauch utility and possibilities of the build through command line.
any-workdir(7) describes the project directory to work with: its installation, inner structure and the purpose of each directory inside.
any-conf(7) describes all options inside configuration files.

For debug and writing of the new builds:

any-map(7) describes all essential methods and interfaces, which perform the actual building.
any-api(7) describes all interfaces, provided by the engine for the use inside build scripts.

For project development:

any-dev(7) describes the conventions about writing new code for the engine.
any-distro(7) describes the creation of new build projects.

Specialized areas:

anymods(7) lists the additional modules with support of version control systems, binary package formats and other outer infrastructure.
rdd(1) low-level description of frontend: how the data is read from config files and how the launch of build process is implemented.


Working directory
Autonomous directory with complete build suite. Working directories are isolated from each other and, in case of chrooted / containerised environment, from host system as well. See any-workdir(7) for more detailed description of working directory.

Configs, configuration files, configuration options
All settings for the build process are stored in the configuration files rdd.conf.d/ and rdd.def at the root of working directory. ports/ directory, fixed version of any and aforesaid configuration files altogether represent exhaustive input data for the build.

Ports directory
Directory with the individual build scripts for packages. It also contains materials, common for the entire package set, such as etalon data for checkers. See any-workdir(7) for more details.

Single unit of software to build. Name of a package or a package list is the second argument in any-do(1) launch string.

Package may be also referenced as binary package, meaning installable archive with files and metainformation, intended for package manager. One source package can produce one or several binary packages. Software name inside package database may differ from the name in source form. In the any series of manuals the term package means source package or build-time entity, unless specified otherwise.

Package list
Plain text file with a list of packages. Each package is on a separate line, comments and empty lines are ignored. Used for the build of package sets in single launch. Lists must be located at their own directory, ports/list/ as given by default any.conf config.

Configuration name, data words
One or several words, identifying the data from configs, involved in a build. It's the first argument in any-do(1) launch string. The examples from the above commands are amd64 or amd64,packslack.

Data reading is designed in a way the first main id like amd64 usually loads the full chain of other identificator words and their according data. The details of data reading are in any-do(1).

Build profile
A string, identifying the build inside working directory. It presents in paths to logs, temporary directories and stuff alike. In simple case the profile is equal to the configuration name, but it is not so in common case. For the configuration amd64,packslack the build profile remains amd64.

The build profile is set up explicitly inside configuration files. See any-conf(7) for more detailed description.

Build map
The main shell method, executed along the work of any. By default it performs the complete build. See any-map(7) for more details.

There can be other maps also, for example, map_autopre, which contains sequence of inner auxiliary methods to prepare the building: output starting information to stdout, create needed temporary files.

Launch methods
It is possible to launch arbitrary methods instead of build map. They are given as the third argument in any-do(1) launch string. Methods may perform arbitrary actions, not only package building. The main limitation to the methods is absence of input parameters, but they can use variables from any-api(7).

Anybuild, build file, build script, build
The file in shell with methods and variables, which build the package. The most often these methods are src_config(3), src_compile(3) and src_install(3). Variables are used in engine procedures, such as dependencies handling. See any-build(7) for further details.

Interface method
Method with determined aim, but possibly different implementations. Different implementations of interface may depend on configuration and on the set of modules, used during the build. That provides function flexibility.

Build interfaces are described in any-map(7).

Set of global shell variables and methods, allowed for use inside anybuilds. Described by any-api(7).

Engine module
Functionality, not turned on by default. It may be utilized with addition of needed identificator-word to the name of configuration. Module files with code usually reside in any/lib/, with own variables in any/include/. A module may have its own configs, declare new methods, global variables, implement interfaces of any-map(7) in its own way and extend the functionality of the engine in almost arbitrary manner.

anymods(7) contains module list, available by default with release of any.