---
title: Chapter 17. Using USES Macros
prev: books/porters-handbook/keeping-up
next: books/porters-handbook/versions
description: USES macros make it easy to declare requirements and settings for a FreeBSD Port
tags: ["uses", "macros", "introduction", "guide"]
showBookMenu: true
weight: 17
params:
  path: "/books/porters-handbook/uses/"
---

[[uses]]
= Using `USES` Macros
:doctype: book
:toc: macro
:toclevels: 1
:icons: font
:sectnums:
:sectnumlevels: 6
:sectnumoffset: 17
:partnums:
:source-highlighter: rouge
:experimental:
:images-path: books/porters-handbook/

ifdef::env-beastie[]
ifdef::backend-html5[]
:imagesdir: ../../../../images/{images-path}
endif::[]
ifndef::book[]
include::shared/authors.adoc[]
include::shared/mirrors.adoc[]
include::shared/releases.adoc[]
include::shared/attributes/attributes-{{% lang %}}.adoc[]
include::shared/{{% lang %}}/teams.adoc[]
include::shared/{{% lang %}}/mailing-lists.adoc[]
include::shared/{{% lang %}}/urls.adoc[]
toc::[]
endif::[]
ifdef::backend-pdf,backend-epub3[]
include::../../../../../shared/asciidoctor.adoc[]
endif::[]
endif::[]

ifndef::env-beastie[]
toc::[]
include::../../../../../shared/asciidoctor.adoc[]
endif::[]

[[uses-intro]]
== An Introduction to `USES`

`USES` macros make it easy to declare requirements and settings for a port.
They can add dependencies, change building behavior, add metadata to packages, and so on, all by selecting simple, preset values.

Each section in this chapter describes a possible value for `USES`, along with its possible arguments.
Arguments are appended to the value after a colon (`:`).
Multiple arguments are separated by commas (`,`).

[[uses-intro-ex1]]
.Using Multiple Values
[example]
====
[.programlisting]
....
USES=	bison perl
....
====

[[uses-intro-ex2]]
.Adding an Argument
[example]
====
[.programlisting]
....
USES=	tar:xz
....
====

[[uses-intro-ex3]]
.Adding Multiple Arguments
[example]
====
[.programlisting]
....
USES=	drupal:7,theme
....
====

[[uses-intro-ex4]]
.Mixing it All Together
[example]
====
[.programlisting]
....
USES=	pgsql:9.3+ cpe python:2.7,build
....
====

[[uses-7z]]
== `7z`

Possible arguments: (none), `p7zip`, `partial`

Extract using man:7z[1] instead of man:bsdtar[1] and sets `EXTRACT_SUFX=.7z`.
The `p7zip` option forces a dependency on the `7z` from package:archivers/p7zip[] if the one from the base system is not able to extract the files.
`EXTRACT_SUFX` is not changed if the `partial` option is used, this can be used if the main distribution file does not have a [.filename]#.7z# extension.

[[uses-ada]]
== `ada`

Possible arguments: (none), `6`, `12`, `(run)`

Depends on an Ada-capable compiler, and sets `CC` accordingly.
Defaults to use `gcc6-aux` from ports.

[[uses-angr]]
== `angr`

Possible arguments: `binaries`, `nose`

Provide support for ports that need the https://github.com/angr/angr[angrinary analysis platform].

If the `binaries` argument is present, the port requires the special `angr`
binaries for testing.

If the `nose` argument is present, the port uses `nosetests` for the test
target. This argument implies `USES=python:test`.

The framework provides the following variables to be set by the port:

`ANGR_VERSION`::
The version of the `angr` project programs.

`ANGR_BINARIES_TAGNAME`::
The tagname of the `angr` binaries.

`ANGR_NOSETESTS`::
The path to the `nosetests` program.

[[uses-ansible]]
== `ansible`

Possible arguments: `env`, `module`, `plugin`

Provide support for ports depending on package:sysutils/ansible[].

If the `env` argument is present, the port does not depend on
package:sysutils/ansible[] but needs some Ansible variables set.

If the `module` argument is present then the port is an Ansible module.

If the `plugin` argument is present then the port is an Ansible plugin.

The framework exposes the following variables to the port:

`ANSIBLE_CMD`::
Path to the ansible program.

`ANSIBLE_DOC_CMD`::
Path to the ansible-doc program.

`ANSIBLE_RUN_DEPENDS`::
RUN_DEPENDS with the Ansible port.

`ANSIBLE_DATADIR`::
Path to the root of the directory structure where all Ansible's modules and plugins are stored.

`ANSIBLE_ETCDIR`::
Path to the Ansible etc directory.

`ANSIBLE_PLUGINS_PREFIX`::
Path to the "plugins" directory within `${ANSIBLE_DATADIR}`.
`ANSIBLE_MODULESDIR`::
Path to the directory for local Ansible modules.

`ANSIBLE_PLUGINSDIR`::
Path to the directory for local Ansible plugins.

`ANSIBLE_PLUGIN_TYPE`::
Ansible plugin type (e.g., "connection", "inventory", or "vars").

[[uses-apache]]
== `apache`

Possible arguments: (none), `2.4`, `build`, `run`, `server`

Provide support for ports depending on the Apache web server.

The version argument can be used to require a specific Apache httpd version.
It is possible to set a specific version (`USES=apache:2.4`) a minimum version
(`USES=apache:2.4+`) or a maximum version (`USES=apache:-2.4`).

If the `build` argument is provided a build dependency is added to the port.

If the `run` argument is provided a run dependency is added to the port.

If the `server` argument is provided then it indicates the port is a server
port.

The framework provides the following variables to be set by the port:

`AP_FAST_BUILD`::
Automatic module build

`AP_GENPLIST`::
Automatic `PLIST` generation plus add the module disabled into [.filename]#httpd.conf# (only if no `pkg-plist` exist)

`MODULENAME`::
Name of the Apache module. Default: `${PORTNAME}`

`SHORTMODNAME`::
Short name of the Apache module. Default: `${MODULENAME:S/mod_//}`

`SRC_FILE`::
Source file of the APACHE module. Default: `${MODULENAME}.c`

The following variables can be accessed by the port:

`APACHE_VERSION`::
The major-minor release version of the chosen Apache server, e.g. 2.4

`APACHEETCDIR`::
Location of the Apache configuration directory. Default: [.filename]#${LOCALBASE}/etc/apache24#

`APACHEINCLUDEDIR`::
Location of the Apache include files Default: [.filename]#${LOCALBASE}/include/apache24#

`APACHEMODDIR`::
Location of the Apache modules Default: [.filename]#${LOCALBASE}/libxexec/apache24#

`APACHE_DEFAULT`::Default Apache version


[[uses-autoreconf]]
== `autoreconf`

Possible arguments: (none), `build`

Runs `autoreconf`.
It encapsulates the `aclocal`, `autoconf`, `autoheader`, `automake`, `autopoint`, and `libtoolize` commands.
Each command applies to [.filename]#${AUTORECONF_WRKSRC}/configure.ac# or its old name, [.filename]#${AUTORECONF_WRKSRC}/configure.in#.
If [.filename]#configure.ac# defines subdirectories with their own [.filename]#configure.ac# using `AC_CONFIG_SUBDIRS`, `autoreconf` will recursively update those as well.
The `:build` argument only adds build time dependencies on those tools but does not run `autoreconf`.
A port can set `AUTORECONF_WRKSRC` if `WRKSRC` does not contain the path to [.filename]#configure.ac#.

[[uses-azurepy]]
== `azurepy`

Possible arguments: (none)

Provide support for `py-azure*` ports.
Removes `azure` namespaces and cleans up common files.

[[uses-blaslapack]]
== `blaslapack`

Possible arguments: (none), `atlas`, `netlib` (default), `gotoblas`, `openblas`

Adds dependencies on Blas / Lapack libraries.

[[uses-bdb]]
== `bdb`

Possible arguments: (none), `5` (default), `18`

Add dependency on the Berkeley DB library.
Default to package:databases/db5[].
It can also depend on package:databases/db18[] when using the `:18` argument.
It is possible to declare a range of acceptable values, `:5+` finds the highest
installed version, and falls back to 5 if nothing else is installed.
`INVALID_BDB_VER` can be used to specify versions which do not work with this port.
The framework exposes the following variables to the port:

`BDB_LIB_NAME`::
The name of the Berkeley DB library.
For example, when using package:databases/db5[], it contains `db-5.3`.

`BDB_LIB_CXX_NAME`::
The name of the Berkeley DBC++ library.
For example, when using package:databases/db5[], it contains `db_cxx-5.3`.

`BDB_INCLUDE_DIR`::
The location of the Berkeley DB include directory.
For example, when using package:databases/db5[], it will contain `${LOCALBASE}/include/db5`.

`BDB_LIB_DIR`::
The location of the Berkeley DB library directory.
For example, when using package:databases/db5[], it contains `${LOCALBASE}/lib`.

`BDB_VER`::
The detected Berkeley DB version.
For example, if using `USES=bdb:5+` and Berkeley DB 18 is installed, it contains `18`.

[IMPORTANT]
====
package:databases/db48[] is deprecated and unsupported.
It must not be used by any port.
====

[[uses-bison]]
== `bison`

Possible arguments: (none), `build`, `run`, `both`

Uses package:devel/bison[] By default, with no arguments or with the `build` argument, it implies `bison` is a build-time dependency, `run` implies a run-time dependency, and `both` implies both run-time and build-time dependencies.

[[uses-budgie]]
== `budgie`

Possible arguments: (none)

Provide support for the Budgie desktop environment.
Use `USE_BUDGIE` to select the components needed for the port.
See crossref:special[using-budgie,Using Budgie] for more information.

[[uses-cabal]]
== `cabal`

[IMPORTANT]
====
Ports should not be created for Haskell libraries, see crossref:special[haskell-libs,Haskell Libraries] for more information.
====

Possible arguments: (none), `hpack`, `nodefault`

Sets default values and targets used to build Haskell software using Cabal.
A build dependency on the Haskell compiler port (package:lang/ghc[]) is added.
If there is some other version of GHC already listed in the `BUILD_DEPENDS` variable (for example, package:lang/ghc810[]), it would be used instead.
If the `hpack` argument is given, a build dependency on package:devel/hs-hpack[] is added and `hpack` is invoked at configuration step to
generate .cabal file.
If the `nodefault` argument is given, the framework will not try to pull the main distribution file from the Hackage.
This argument is implicitly added if `USE_GITHUB` or `USE_GITLAB` is present.

The framework provides the following variables:

`CABAL_REVISION`::
Haskell packages hosted on Hackage may have revisions.
Set this knob to an integer number to pull in revised package description.

`USE_CABAL`::
If the software uses Haskell dependencies, list them in this variable.
Each item should be present on Hackage and be listed in form `packagename-_0.1.2_`.
Dependencies can have revisions too, which are specified after the `_` symbol.
Automatic generation of the dependency list is supported, see crossref:special[using-cabal,Building Haskell Applications with `cabal`].

`CABAL_FLAGS`::
List of flags to be passed to `cabal-install` during the configuring and building stage.
The flags are passed verbatim.
This variable is usually used to enable or disable flags that are declared in the .cabal file.
Pass `foo` to enable the `foo` flag and `-foo` to disable it.

`CABAL_EXECUTABLES`::
List of executable files installed by the port.
Default value: `${PORTNAME}`.
Consult the .cabal file of the project being ported to get a list of possible
values for this variable. Each value corresponds to an `executable` stanza in the .cabal file.
Items from this list are automatically added to pkg-plist.

`SKIP_CABAL_PLIST`::
If defined, do not add items from `${CABAL_EXECUTABLES}` to pkg-plist.

`opt_USE_CABAL`::
Adds items to `${USE_CABAL}` depending on `opt` option.

`opt_CABAL_EXECUTABLES`::
Adds items to `${CABAL_EXECUTABLES}` depending on `opt` option.

`opt_CABAL_FLAGS`::
If `opt` is enabled, append the value to `${CABAL_FLAGS}`.
Otherwise, append `-value` to disable the flag.
Note that this behavior is slightly different from the plain `CABAL_FLAGS` as it does not accept values starting with `-`.

`CABAL_WRAPPER_SCRIPTS`::
A subset of `${CABAL_EXECUTABLES}` containing Haskell programs to be wrapped into a shell script
that sets `*_datadir` environment variables before running the program.
This also causes the actual Haskell binary to be installed under `libexec/cabal/` directory.
This knob is needed for Haskell programs that install their data files under `share/` directory.

`FOO_DATADIR_VARS`::
List of extra Haskell packages, whose data files should be accessible by the executable named `FOO`.
The executable should be a part of `${CABAL_WRAPPER_SCRIPTS}`.
Haskell packages listed there should not have a version suffix.

`CABAL_PROJECT`::
Some Haskell projects may already have a `cabal.project` file, which is also generated by the ports framework.
If that is the case, use this variable to specify what to do with the original `cabal.project`.
Setting this variable to `remove` will cause the original file to be removed.
Setting this variable to `append` will:
. Move the original file to `cabal.project.${PORTNAME}` during the `extract` stage.
. Concatenate the original `cabal.project.${PORTNAME}` and the generated `cabal.project` into a single file after the `patch` stage.
Using `append` makes it possible to perform patching on the original file before it gets merged.

[[uses-cargo]]
== `cargo`

Possible arguments: (none)

Uses Cargo for configuring, building, and testing.
It can be used to port Rust applications that use the Cargo build system.
For more information see crossref:special[using-cargo,Building Rust Applications with `cargo`].

[[uses-charsetfix]]
== `charsetfix`

Possible arguments: (none)

Prevents the port from installing [.filename]#charset.alias#.
This must be installed only by package:converters/libiconv[].
`CHARSETFIX_MAKEFILEIN` can be set to a path relative to `WRKSRC` if [.filename]#charset.alias# is not installed by [.filename]#${WRKSRC}/Makefile.in#.

[[uses-cl]]
== `cl`

Possible arguments: (none)

Provides support for Common Lisp ports.

The framework provides the following variables that can be set by ports:

`ASDF_MODULES`::
List of `ASDF` modules to build when `FASL_TARGET` is set (defaults to `PORTNAME`)

`FASL_TARGET`::
Build fasl variant of port (one of `ccl`, `clisp`, or `sbcl`)

`USE_ASDF`::
Depend on package:devel/cl-asdf[]

`USE_ASDF_FASL`::
Depend on `devel/cl-asdf-<FASL_TARGET>`

`USE_CCL`::
Depend on package:lang/ccl[]; implied when `FASL_TARGET=ccl`

`USE_CLISP`::
Depend on package:lang/clisp[]; implied when `FASL_TARGET=clisp`

`USE_SBCL`::
Depend on package:lang/sbcl[]; implied when `FASL_TARGET=SBCL`


The framework provides the following variables that can be read by ports:

`ASDF_PATHNAME`::
Path to CL source

`ASDF_REGISTRY`::
Path to CL registry containing asd files

`CCL`::
Path to the Clozure Common Lisp compiler

`CLISP`::
Path to the GNU Common Lisp compiler

`CL_LIBDIR_REL`::
CL library directory relative to `LOCALBASE` or `PREFIX`

`FASL_DIR_REL`::
Relative path to compiled fasl files; depends on `FASL_TARGET`

`FASL_PATHNAME`::
Path to CL fasl

`LISP_EXTRA_ARG`::
Extra arguments used when building fasl

`SBCL`::
Path to the Steel Bank Common Lisp compiler

[[uses-cmake]]
== `cmake`

Possible arguments: (none), `insource`, `noninja`, `run`, `testing`

Use CMake for configuring the port and generating a build system.

By default an out-of-source build is performed, leaving the sources in `WRKSRC` free from build artifacts.
With the `insource` argument, an in-source build will be performed instead.
This argument should be an exception, used only when a regular out-of-source build does not work.

By default Ninja (package:devel/ninja[]) is used for the build.
In some cases this does not work correctly.
With the `noninja` argument, the build will use regular `make` for builds.
This argument should only be used if a Ninja-based build does not work.

With the `run` argument, a run dependency is registered in addition to a build dependency.

With the `testing` argument, a test-target is added that uses CTest.
When running tests the port will be re-configured for testing and re-built.

For more information see crossref:special[using-cmake,Using `cmake`].

[[uses-compiler]]
== `compiler`

Possible arguments: (none), `env` (default, implicit), `{cpp}17-lang`, `{cpp}14-lang`, `{cpp}11-lang`, `gcc-{cpp}11-lib`, `{cpp}11-lib`, `{cpp}0x`, `c11`, `nestedfct`, `features`

Determines which compiler to use based on any given wishes.
Use `{cpp}17-lang` if the port needs a {cpp}17-capable compiler, `{cpp}14-lang` if the port needs a {cpp}14-capable compiler, `{cpp}11-lang` if the port needs a {cpp}11-capable compiler, `gcc-{cpp}11-lib` if the port needs the `g++` compiler with a {cpp}11 library, or `{cpp}11-lib` if the port needs a {cpp}11-ready standard library.
If the port needs a compiler understanding {cpp}0X, C11 or nested functions, the corresponding parameters should be used.

Use `features` to request a list of features supported by the default compiler.
After including [.filename]#bsd.port.pre.mk# the port can inspect the results using these variables:

* `COMPILER_TYPE`: the default compiler on the system, either gcc or clang
* `ALT_COMPILER_TYPE`: the alternative compiler on the system, either gcc or clang. Only set if two compilers are present in the base system.
* `COMPILER_VERSION`: the first two digits of the version of the default compiler.
* `ALT_COMPILER_VERSION`: the first two digits of the version of the alternative compiler, if present.
* `CHOSEN_COMPILER_TYPE`: the chosen compiler, either gcc or clang
* `COMPILER_FEATURES`: the features supported by the default compiler. It currently lists the {cpp} library.

[[uses-cpe]]
== `cpe`

Possible arguments: (none)

Include Common Platform Enumeration (CPE) information in package manifest as a CPE 2.3 formatted string.
See the https://scap.nist.gov/specifications/cpe/[CPE specification] for details.
To add CPE information to a port, follow these steps:

[.procedure]
. Search for the official CPE entry for the software product either by using the NVD's https://web.nvd.nist.gov/view/cpe/search[CPE search engine] or in the https://nvd.nist.gov/feeds/xml/cpe/dictionary/official-cpe-dictionary_v2.3.xml.gz[official CPE dictionary] (warning, very large XML file). _Do not ever make up CPE data._
. Add `cpe` to `USES` and compare the result of `make -V CPE_STR` to the CPE dictionary entry. Continue one step at a time until `make -V CPE_STR` is correct.
. If the product name (second field, defaults to `PORTNAME`) is incorrect, define `CPE_PRODUCT`.
. If the vendor name (first field, defaults to `CPE_PRODUCT`) is incorrect, define `CPE_VENDOR`.
. If the version field (third field, defaults to `PORTVERSION`) is incorrect, define `CPE_VERSION`.
. If the update field (fourth field, defaults to empty) is incorrect, define `CPE_UPDATE`.
. If it is still not correct, check [.filename]#Mk/Uses/cpe.mk# for additional details, or contact the {ports-secteam}.
. Derive as much as possible of the CPE name from existing variables such as `PORTNAME` and `PORTVERSION`. Use variable modifiers to extract the relevant portions from these variables rather than hardcoding the name.
. _Always_ run `make -V CPE_STR` and check the output before committing anything that changes `PORTNAME` or `PORTVERSION` or any other variable which is used to derive `CPE_STR`.

[[uses-cran]]
== `cran`

Possible arguments: (none), `auto-plist`, `compiles`

Uses the Comprehensive R Archive Network.
Specify `auto-plist` to automatically generate [.filename]#pkg-plist#.
Specify `compiles` if the port has code that need to be compiled.

[[uses-desktop-file-utils]]
== `desktop-file-utils`

Possible arguments: (none)

Uses update-desktop-database from package:devel/desktop-file-utils[].
An extra post-install step will be run without interfering with any post-install steps already in the port [.filename]#Makefile#.
A line with crossref:plist[plist-keywords-desktop-file-utils,`@desktop-file-utils`] will be added to the plist.
Only use this macro if the port provides a `.desktop` file which contains a
`MimeType` entry.

[[uses-desthack]]
== `desthack`

Possible arguments: (none)

Changes the behavior of GNU configure to properly support `DESTDIR` in case the original software does not.

[[uses-display]]
== `display`

Possible arguments: (none), _ARGS_

Set up a virtual display environment.
If the environment variable `DISPLAY` is not set, then Xvfb is added as a build dependency, and `CONFIGURE_ENV` is extended with the port number of the currently running instance of Xvfb.
The _ARGS_ parameter defaults to `install` and controls the phase around which to start and stop the virtual display.

[[uses-dos2unix]]
== `dos2unix`

Possible arguments: (none)

The port has files with line endings in DOS format which need to be converted.
Several variables can be set to control which files will be converted.
The default is to convert _all_ files, including binaries.
See crossref:slow-porting[slow-patch-automatic-replacements,Simple Automatic Replacements] for examples.

* `DOS2UNIX_REGEX`: match file names based on a regular expression.
* `DOS2UNIX_FILES`: match literal file names.
* `DOS2UNIX_GLOB`: match file names based on a glob pattern.
* `DOS2UNIX_WRKSRC`: the directory from which to start the conversions. Defaults to `${WRKSRC}`.

[[uses-drupal]]
== `drupal`

Possible arguments: `7`, `module`, `theme`

Automate installation of a port that is a Drupal theme or module.
Use with the version of Drupal that the port is expecting.
For example, `USES=drupal:7,module` says that this port creates a Drupal 7 module.
A Drupal 7 theme can be specified with `USES=drupal:7,theme`.

[[uses-ebur128]]
== `ebur128`

Possible arguments: (none), `build`, `lib`, `run`, `test`

Adds a dependency on package:audio/ebur128[].
It allows to transparently depend on the `rust` or `legacy` variants by using
`DEFAULT_VERSIONS` in [.filename]#make.conf#.
For instance, to use the legacy version, use `DEFAULT_VERSIONS+=ebur128=legacy`

When no arguments are used, the behavior is the same as if the `lib` argument
was provided.
The rest of the arguments provide the corresponding category of dependency.

[[uses-eigen]]
== `eigen`

Possible arguments: 2, 3, build (default), run

Add dependency on package:math/eigen[].

[[uses-elextronfix]]
== `electronfix`

Possible arguments: `37`, `38`, `39`

Provide support for easy porting of Electron applications that are distributed in binary form.
Adds a build and run time dependency on package:devel/electron37[],
package:devel/electron38[], or package:devel/electron39[] depending on the argument used.

The framework provides the following variables that can be set by ports:

`ELECTRONFIX_SYMLINK_FILES`::
List of files to be symlinked from Electron distribution.

`ELECTRONFIX_MAIN_EXECUTABLE`::
File name of the main executable to be replaced with the original Electron binary.


[[uses-elfctl]]
== `elfctl`

Possible arguments: (none), `build` (default), `stage`

Set ELF binary feature control notes by setting `ELF_FEATURES`.

When either no argument or the `build` argument is supplied, binaries under `BUILD_WRKSRC` are operated on, and files listed in `ELF_FEATURES` are relative to `BUILD_WRKSRC`.
When the `stage` argument is supplied, binaries under `STAGEDIR` are operated on and files listed in `ELF_FEATURES` are relative to `STAGEDIR`.

[[uses-elfct-ex1]]
.Uses=elfctl
[example]
====
[.programlisting]
....
ELF_FEATURES=	featurelist:path/to/file1 \
		featurelist:path/to/file2
....

====

The format of `featurelist` is described in man:elfctl[1].

[[uses-elixir]]
== `elixir`

Possible arguments: (none)

Provide support for ports using package:lang/elixir[].
Adds a build and run time dependency on package:lang/elixir[].

Variables provided by the framework:

`ELIXIR_APP_NAME`::
Elixir app name as installed in Elixir's lib directory
`ELIXIR_LIB_ROOT`::
Elixir default library path
`ELIXIR_APP_ROOT`::
Root directory for this Elixir app
`ELIXIR_HIDDEN`::
Applications to be hidden from the code path; usually ${PORTNAME}
`ELIXIR_LOCALE`::
An UTF-8 locale to be used by Elixir during builds (any UTF-8 locale is good)
`MIX_CMD`::
The `mix` command
`MIX_COMPILE`::
The `mix` command used to compile an Elixir app
`MIX_REWRITE`::
Automatically replace Mix dependencies with code paths
`MIX_BUILD_DEPS`::
List of `BUILD_DEPENDS` in category/portname format (commonly referenced to as "deps" in Erlang and Elixir)
`MIX_RUN_DEPS`::
List of `RUN_DEPENDS` in category/portname format
`MIX_DOC_DIRS`::
Extra doc directories to be installed in `DOCSDIR`
`MIX_DOC_FILES`::
Extra doc files to be installed in `DOCSDIR` (usually README.md)
`MIX_ENV`::
Environment for the Mix build (same format as `MAKE_ENV`)
`MIX_ENV_NAME`::
Name of the Mix build environment, usually "prod"
`MIX_BUILD_NAME`::
Name of the build output in _build/, usually `${MIX_ENV_NAME}`
`MIX_TARGET`::
Name of the Mix target, usually "compile"
`MIX_EXTRA_APPS`::
List of sub-applications to be built, if any
`MIX_EXTRA_DIRS`::
List of extra directories to be installed in `ELIXIR_APP_ROOT`
`MIX_EXTRA_FILES`::
List of extra files to be installed in `ELIXIR_APP_ROOT`

[[uses-emacs]]
== `emacs`

Possible arguments: (none) (default), `build`, `run`, `noflavors`

Provides support for ports requiring Emacs.
The `build` argument creates a build dependency on Emacs.
The `run` argument creates a run dependency on Emacs.
If both the `build` and `run` arguments are absent, create build and run
dependencies on Emacs.
The `noflavors` argument prevents flavors, and is implied if there is no run dependency on Emacs.

The default Emacs flavor for ports with `USES=emacs` can be defined in [.filename]#make.conf#.
For example, for the `nox` flavor, use `DEFAULT_VERSIONS+= emacs=nox`.
The valid flavors are: `full`, `canna`, `nox`, `wayland`, `devel_full`, `devel_nox`.

Variables, which can be set by ports:

`EMACS_FLAVORS_EXCLUDE`::
Do NOT build these Emacs flavors.
If `EMACS_FLAVORS_EXCLUDE` is not defined and:

* there is a run dependency on Emacs
* the noflavors argument is not specified

+
then all valid Emacs flavors are assumed.

`EMACS_NO_DEPENDS`::
Do NOT add build or run dependencies on Emacs.
This will prevent flavors, and no byte code files will be generated as part of
the package.

Variables, which can be read by ports:

`EMACS_CMD`::
Emacs command with full path (e.g. [.filename]#/usr/local/bin/emacs-30.1#)

`EMACS_FLAVOR`::
Used for dependencies (e.g. `BUILD_DEPENDS= dash.el${EMACS_PKGNAMESUFFIX}>0:devel/dash@${EMACS_FLAVOR}`)

`EMACS_LIBDIR`::
Emacs Library directory without `${PREFIX}` (e.g. [.filename]#share/emacs#)

`EMACS_LIBDIR_WITH_VER`::
Library directory without `${PREFIX}` including version (e.g.  [.filename]#share/emacs/30.1#)

`EMACS_MAJOR_VER`::
Emacs major version (e.g. 30)

`EMACS_PKGNAMESUFFIX`::
`PKGNAMESUFFIX` to distinguish Emacs flavors

`EMACS_SITE_LISPDIR`::
Emacs site-lisp directory without `${PREFIX}` (e.g.  [.filename]#share/emacs/site-lisp#)

`EMACS_VER`::
Emacs version (e.g. 30.1)

`EMACS_VERSION_SITE_LISPDIR`::
Include version (e.g. [.filename]#share/emacs/30.1/site-lisp#)

[[uses-erlang]]
== `erlang`

Possible arguments: (none), `enc`, `rebar`, `rebar3`

Adds a build and run time dependency on package:lang/erlang[].
Depending on the argument, it adds additional build dependencies. `enc` adds a
dependency on package:devel/erlang-native-compiler[], `rebar` adds a dependency on
package:devel/rebar[] and `rebar3` adds a dependency on package:devel/rebar3[].

In addition, the following variables are available to the port:

* `ERL_APP_NAME`: Erlang app name as installed in Erlang's lib dir (minus version)
* `ERL_APP_ROOT`: Root directory for this Erlang app
* `REBAR_CMD`: Path to the "rebar" command
* `REBAR3_CMD`: Path to the "rebar3" command
* `REBAR_PROFILE`: Rebar profile
* `REBAR_TARGETS`: Rebar target list (usually compile, maybe escriptize)
* `ERL_BUILD_NAME`: Build name for rebar3
* `ERL_BUILD_DEPS`: List of BUILD_DEPENDS in category/portname format
* `ERL_RUN_DEPS`: List of RUN_DEPENDS in category/portname format
* `ERL_DOCS`: List of documentation files and directories

[[uses-fakeroot]]
== `fakeroot`

Possible arguments: (none)

Changes some default behavior of build systems to allow installing as a user.
See https://wiki.debian.org/FakeRoot[] for more information on `fakeroot`.

[[uses-firebird]]
== `firebird`

Possible arguments: (none), `25`

Add a dependency to the client library of the Firebird database.

[[uses-fonts]]
== `fonts`

Possible arguments: (none), `fc`, `fontsdir` (default), `none`

Adds a runtime dependency on tools needed to register fonts.
Depending on the argument, add a `crossref:plist[plist-keywords-fc,@fc] ${FONTSDIR}` line,
`crossref:plist[plist-keywords-fontsdir,@fontsdir] ${FONTSDIR}` line, or no line if the argument is `none`, to the plist.
`FONTSDIR` defaults to [.filename]#${PREFIX}/share/fonts/${FONTNAME}# and `FONTNAME` to `${PORTNAME}`.
Add `FONTSDIR` to `PLIST_SUB` and `SUB_LIST`

[[uses-fortran]]
== `fortran`

Possible arguments: `gcc` (default)

Uses the GNU Fortran compiler.

[[uses-fpc]]
== `fpc`

Possible arguments: (none), `run`

Provide support for Free Pascal based ports. It will install Free Pascal
compiler and units.

Adds a build dependency on package:lang/fpc[].

If the `run` argument is given a run dependency is also added.

[[uses-fuse]]
== `fuse`

Possible arguments: `2` (default), `3`

The port will depend on the FUSE library and handle the dependency on the kernel module depending on the version of FreeBSD.

[[uses-gem]]
== `gem`

Possible arguments: (none), `noautoplist`

Handle building with RubyGems.
If `noautoplist` is used, the packing list is not generated automatically.

This implies `USES=ruby`.

[[uses-gettext]]
== `gettext`

Possible arguments: (none)

Deprecated.
Will include both crossref:uses[uses-gettext-runtime,`gettext-runtime`] and
crossref:uses[uses-gettext-tools,`gettext-tools`].

[[uses-gettext-runtime]]
== `gettext-runtime`

Possible arguments: (none), `lib` (default), `build`, `run`

Uses package:devel/gettext-runtime[].
By default, with no arguments or with the `lib` argument, implies a library dependency on [.filename]#libintl.so#.
`build` and `run` implies, respectively a build-time and a run-time dependency on [.filename]#gettext#.

[[uses-gettext-tools]]
== `gettext-tools`

Possible arguments: (none), `build` (default), `run`

Uses package:devel/gettext-tools[].
By default, with no argument, or with the `build` argument, a build time dependency on [.filename]#msgfmt# is registered.
With the `run` argument, a run-time dependency is registered.

[[uses-ghostscript]]
== `ghostscript`

Possible arguments: _X_, `build`, `run`, `nox11`

A specific version _X_ can be used. Possible versions are `7`, `8`, `9`, and `agpl` (default).
`nox11` indicates that the `-nox11` version of the port is required.
`build` and `run` add build- and run-time dependencies on Ghostscript.
The default is both build- and run-time dependencies.

[[uses-gl]]
== `gl`

Possible arguments: (none)

Provides an easy way to depend on GL components.
The components should be listed in `USE_GL`.
The available components are:

`egl`::
add a library dependency on [.filename]#libEGL.so# from package:graphics/libglvnd[]

`gbm`::
Add a library dependency on [.filename]#libgbm.so# from package:graphics/mesa-libs[]

`gl`::
Add a library dependency on [.filename]#libGL.so# from package:graphics/libglvnd[]

`glesv2`::
Add a library dependency on [.filename]#libGLESv2.so# from package:graphics/libglvnd[]

`glew`::
Add a library dependency on [.filename]#libGLEW.so# from package:graphics/glew[]

`glu`::
Add a library dependency on [.filename]#libGLU.so# from package:graphics/libGLU[]

`glut`::
Add a library dependency on [.filename]#libglut.so# from package:graphics/freeglut[]

`opengl`::
Add a library dependency on [.filename]#libOpenGL.so# from package:graphics/libglvnd[]

[[uses-gmake]]
== `gmake`

Possible arguments: (none)

Uses package:devel/gmake[] as a build-time dependency and sets up the environment to use `gmake` as the default `make` for the build.

[[uses-gnome]]
== `gnome`

Possible arguments: (none)

Provides an easy way to depend on GNOME components.
The components should be listed in `USE_GNOME`.
The available components are:

* `atk`
* `atkmm`
* `cairo`
* `cairomm`
* `dconf`
* `esound`
* `evolutiondataserver3`
* `gconf2`
* `gconfmm26`
* `gdkpixbuf`
* `gdkpixbuf2`
* `glib12`
* `glib20`
* `glibmm`
* `gnomecontrolcenter3`
* `gnomedesktop3`
* `gnomedesktop4`
* `gnomedocutils`
* `gnomemenus3`
* `gnomemimedata`
* `gnomeprefix`
* `gnomesharp20`
* `gnomevfs2`
* `gsound`
* `gtk-update-icon-cache`
* `gtk12`
* `gtk20`
* `gtk30`
* `gtkhtml3`
* `gtkhtml4`
* `gtkmm20`
* `gtkmm24`
* `gtkmm30`
* `gtksharp20`
* `gtksourceview`
* `gtksourceview2`
* `gtksourceview3`
* `gtksourceviewmm3`
* `gvfs`
* `intlhack`
* `intltool`
* `introspection`
* `libartlgpl2`
* `libbonobo`
* `libbonoboui`
* `libgda5`
* `libgda5-ui`
* `libgdamm5`
* `libglade2`
* `libgnome`
* `libgnomecanvas`
* `libgnomekbd`
* `libgnomeprint`
* `libgnomeprintui`
* `libgnomeui`
* `libgsf`
* `libgtkhtml`
* `libgtksourceviewmm`
* `libidl`
* `librsvg2`
* `libsigc++12`
* `libsigc++20`
* `libwnck`
* `libwnck3`
* `libxml++26`
* `libxml2`
* `libxslt`
* `metacity`
* `nautilus3`
* `orbit2`
* `pango`
* `pangomm`
* `pangox-compat`
* `py3gobject3`
* `pygnome2`
* `pygobject`
* `pygobject3`
* `pygtk2`
* `pygtksourceview`
* `referencehack`
* `vte`
* `vte3`

The default dependency is build- and run-time, it can be changed with `:build` or `:run`.
For example:

[.programlisting]
....
USES=		gnome
USE_GNOME=	gnomemenus3:build intlhack
....

See crossref:special[using-gnome,Using GNOME] for more information.

[[uses-go]]
== `go`

[IMPORTANT]
====
Ports should not be created for Go libs, see crossref:special[go-libs,Go Libraries] for more information.
====

Possible arguments: (none), `N.NN`, `N.NN+`, `N.NN-devel`, `modules`, `no_targets`, `run`

Sets default values and targets used to build Go software.
A build dependency on the Go compiler port is added, port maintainers can set version required.
If the `X.Y+` format is used then Go `X.Y` will be used unless the default go
version is higher than `X.Y` in which case the default version will be used.
By default the build is performed in GOPATH mode.
If Go software uses modules, the modules-aware mode can be switched on with `modules` argument.
`no_targets` will setup build environment like `GO_ENV`, `GO_BUILDFLAGS` but skip creating extract and build targets.
`run` will also add a run dependency on the Go compiler port.

The build process is controlled by several variables:

`GO_MODULE`::
The name of the application module as specified by the `module` directive in `go.mod`.
In most cases, this is the only required variable for ports that use Go modules.

`GO_PKGNAME`::
The name of the Go package when building in GOPATH mode.
This is the directory that will be created in `${GOPATH}/src`.
If not set explicitly and `GH_SUBDIR` or `GL_SUBDIR` is present, `GO_PKGNAME` will be inferred from it.
It is not needed when building in modules-aware mode.

`GO_TARGET`::
The packages to build.
The default value is `${GO_PKGNAME}`.
`GO_TARGET` can also be a tuple in the form `package:path` where path can be either a simple filename or a full path starting with `${PREFIX}`.

`GO_TESTTARGET`::
The packages to test.
The default value is `./...` (the current package and all subpackages).

`CGO_CFLAGS`::
Additional `CFLAGS` values to be passed to the C compiler by `go`.

`CGO_LDFLAGS`::
Additional `LDFLAGS` values to be passed to the C compiler by `go`.

`GO_BUILDFLAGS`::
Additional build arguments to be passed to `go build`.

`GO_TESTFLAGS`::
Additional build arguments to be passed to `go test`.

See crossref:special[using-go,Building Go Applications] for usage examples.

[[uses-gperf]]
== `gperf`

Possible arguments: (none)

Add a buildtime dependency on package:devel/gperf[] if `gperf` is not present in the base system.

[[uses-grantlee]]
== `grantlee`

Possible arguments: `5`, `selfbuild`

Handle dependency on Grantlee.
Specify `5` to depend on the Qt5 based version, package:devel/grantlee5[].
`selfbuild` is used internally by package:devel/grantlee5[] to get their versions numbers.

[[uses-groff]]
== `groff`

Possible arguments: `build`, `run`, `both`

Registers a dependency on package:textproc/groff[] if not present in the base system.

[[uses-gssapi]]
== `gssapi`

Possible arguments: (none), `base` (default), `heimdal`, `mit`, `mit-devel`, `flags`, `bootstrap`

Handle dependencies needed by consumers of the GSS-API.
Only libraries that provide the Kerberos mechanism are available.
By default, or set to `base`, the GSS-API library from the base system is used.
Can also be set to `heimdal` to use package:security/heimdal[], `mit` to use
package:security/krb5[], or `mit-devel` to use package:security/krb5-devel[].

When the local Kerberos installation is not in `LOCALBASE`, set `HEIMDAL_HOME` (for `heimdal`) or `KRB5_HOME` (for `krb5`) to the location of the Kerberos installation.

These variables are exported for the ports to use:

* `GSSAPIBASEDIR`
* `GSSAPICPPFLAGS`
* `GSSAPIINCDIR`
* `GSSAPILDFLAGS`
* `GSSAPILIBDIR`
* `GSSAPILIBS`
* `GSSAPI_CONFIGURE_ARGS`

The `flags` option can be given alongside `base`, `heimdal`, `mit`, or `mit-devel` to automatically add `GSSAPICPPFLAGS`, `GSSAPILDFLAGS`, and `GSSAPILIBS` to `CFLAGS`, `LDFLAGS`, and `LDADD`, respectively.
For example, use `base,flags`.

The `bootstrap` option is a special prefix only for use by package:security/krb5[] and package:security/heimdal[].
For example, use `bootstrap,mit`.

[[uses-gssapi-ex1]]
.Typical Use
[example]
====
[.programlisting]
....
OPTIONS_SINGLE=	GSSAPI
OPTIONS_SINGLE_GSSAPI=	GSSAPI_BASE GSSAPI_HEIMDAL GSSAPI_MIT GSSAPI_NONE

GSSAPI_BASE_USES=	gssapi
GSSAPI_BASE_CONFIGURE_ON=	--with-gssapi=${GSSAPIBASEDIR} ${GSSAPI_CONFIGURE_ARGS}
GSSAPI_HEIMDAL_USES=	gssapi:heimdal
GSSAPI_HEIMDAL_CONFIGURE_ON=	--with-gssapi=${GSSAPIBASEDIR} ${GSSAPI_CONFIGURE_ARGS}
GSSAPI_MIT_USES=	gssapi:mit
GSSAPI_MIT_CONFIGURE_ON=	--with-gssapi=${GSSAPIBASEDIR} ${GSSAPI_CONFIGURE_ARGS}
GSSAPI_NONE_CONFIGURE_ON=	--without-gssapi
....

====

[[uses-gstreamer]]
== `gstreamer`

Possible arguments: (none)

Provides an easy way to depend on GStreamer components.
The components should be listed in `USE_GSTREAMER`.
The available components are:

* `a52dec`
* `aalib`
* `amrnb`
* `amrwbdec`
* `aom`
* `assrender`
* `bad`
* `bs2b`
* `cairo`
* `cdio`
* `cdparanoia`
* `chromaprint`
* `curl`
* `dash`
* `dtls`
* `dts`
* `dv`
* `dvd`
* `dvdread`
* `editing-services`
* `faac`
* `faad`
* `flac`
* `flite`
* `gdkpixbuf`
* `gl`
* `gme`
* `gnonlin`
* `good`
* `gsm`
* `gtk4`
* `gtk`
* `hal`
* `hls`
* `jack`
* `jpeg`
* `kate`
* `kms`
* `ladspa`
* `lame`
* `libav`
* `libcaca`
* `libde265`
* `libmms`
* `libvisual`
* `lv2`
* `mm`
* `modplug`
* `mpeg2dec`
* `mpeg2enc`
* `mpg123`
* `mplex`
* `musepack`
* `neon`
* `ogg`
* `opencv`
* `openexr`
* `openh264`
* `openjpeg`
* `openmpt`
* `opus`
* `pango`
* `png`
* `pulse`
* `qt`
* `resindvd`
* `rsvg`
* `rtmp`
* `shout2`
* `sidplay`
* `smoothstreaming`
* `sndfile`
* `sndio`
* `soundtouch`
* `soup`
* `spandsp`
* `speex`
* `srtp`
* `taglib`
* `theora`
* `ttml`
* `twolame`
* `ugly`
* `v4l2`
* `vorbis`
* `vpx`
* `vulkan`
* `wavpack`
* `webp`
* `webrtcdsp`
* `x264`
* `x265`
* `x`
* `ximagesrc`
* `zbar`

[[uses-guile]]
== `guile`

Possible arguments: (none), `_X.Y_`, `flavors`, `build`, `run`, `alias`, `conflicts`

Adds a dependency on Guile.
By default this is a library dependency on the appropriate `libguile*.so`, unless overridden by the `build` and/or `run` option.
The `alias` option configures `BINARY_ALIAS` appropriately (see crossref:makefiles[binary-alias,Use `BINARY_ALIAS`]).

The default version is set by the usual `DEFAULT_VERSIONS` mechanism;
if the default version is not one of the listed versions, then the latest available listed version is used.

Applications using Guile are normally built for only a single Guile version.
However, extension or library modules should use the `flavors` option to build with multiple flavors.

For more information see crossref:special[using-guile,Using Guile].

[[uses-horde]]
== `horde`

Possible arguments: (none)

Add buildtime and runtime dependencies on package:devel/pear-channel-horde[].
Other Horde dependencies can be added with `USE_HORDE_BUILD` and `USE_HORDE_RUN`.
See crossref:special[php-horde,Horde Modules] for more information.

[[uses-iconv]]
== `iconv`

Possible arguments: (none), `lib`, `build`, `patch`, `translit`, `wchar_t`

Uses `iconv` functions, either from the port package:converters/libiconv[] as a build-time and run-time dependency, or from the base system.
By default, with no arguments or with the `lib` argument, implies `iconv` with build-time and run-time dependencies.
`build` implies a build-time dependency, and `patch` implies a patch-time dependency.
If the port uses the `WCHAR_T` or `//TRANSLIT` iconv extensions, add the relevant arguments so that the correct iconv is used.
For more information see crossref:special[using-iconv,Using `iconv`].

[[uses-imake]]
== `imake`

Possible arguments: (none), `env`, `notall`, `noman`

Add package:devel/imake[] as a build-time dependency and run `xmkmf -a` during the `configure` stage.
If the `env` argument is given, the `configure` target is not set.
If the `-a` flag is a problem for the port, add the `notall` argument.
If `xmkmf` does not generate a `install.man` target, add the `noman` argument.

[[uses-inotify]]
== `inotify`

Possible arguments: (none)

Add `inotify` support for ports.

[[uses-java]]
== `java`

Possible arguments: (none), `ant`, `build`, `extract`, `run`

Defaults to `USES=java:build,run` if no arguments are provided and `NO_BUILD`
is undefined. If `NO_BUILD` is defined, `USES=java:run` is used.
If the `ant` argument is given, the port uses Apache Ant.
If the `build` argument is given, a JDK port is added to the build dependencies.
If the `extract` argument is given, a JDK port is added to the extract dependencies.
If the `run` argument is given, a JDK port is added to the run dependencies.

The framework provides the following variables to be set by the port:

`JAVA_VERSION`::
List of space-separated suitable java versions for the port. An optional `\+`
allows specifying a range of versions. (allowed values `8[+]`, `11[\+]`,
`17[+]`, `18[\+]`, `19[+]`, `21[+]`, `22[\+]`, `23[+]`, `24[\+]`, `25[+]`)

`JAVA_OS`::
List of space-separated suitable JDK port operating systems for the port.
(allowed values: `native`, `linux`)

`JAVA_VENDOR`::
List of space-separated suitable JDK port vendors for the port. (allowed
values: `openjdk`, `oracle`)

The framework exposes the following variables to be read by the port:

`JAVA_PORT`::
The name of the JDK port. (e.g. 'java/openjdk8')

`JAVA_PORT_VERSION`::
The version of the JDK port. (e.g. '8')

`JAVA_PORT_OS`::
The operating system used by the JDK port. (e.g. 'linux')

`JAVA_PORT_VENDOR`::
The vendor of the JDK port. (e.g. 'openjdk')

`JAVA_PORT_OS_DESCRIPTION`::
Description of the operating system used by the JDK port. (e.g. 'Linux')

`JAVA_PORT_VENDOR_DESCRIPTION`::
Description of the vendor of the JDK port.  (e.g. 'OpenJDK BSD Porting Team')

`JAVA_HOME`::
Path to the installation directory of the JDK. (e.g. [.filename]#/usr/local/openjdk8#)

`JAVAC`::
Path to the Java compiler to use. (e.g. [.filename]#/usr/local/openjdk8/bin/javac# or
[.filename]#/usr/local/bin/javac#)

`JAR`::
Path to the JAR tool to use. (e.g. [.filename]#/usr/local/openjdk8/bin/jar# or
[.filename]#/usr/local/bin/fastjar#)

`APPLETVIEWER`::
Path to the appletviewer utility. (e.g.
[.filename]#/usr/local/linux-jdk1.8.0/bin/appletviewer#)

`JAVA`::
Path to the `java` executable. Use this for executing Java programs. (e.g. [.filename]#/usr/local/openjdk8/bin/java#)

`JAVADOC`::
Path to the `javadoc` utility program.

`JAVAH`::
Path to the `javah` program.

`JAVAP`::
Path to the `javap` program.

`JAVA_KEYTOOL`::
Path to the `keytool` utility program.

`JAVA_N2A`::
Path to the `native2ascii` tool.

`JAVA_POLICYTOOL`::
Path to the `policytool` program.

`JAVA_SERIALVER`::
Path to the `serialver` utility program.

`RMIC`::
Path to the RMI stub/skeleton generator, `rmic`.

`RMIREGISTRY`::
Path to the RMI registry program, `rmiregistry`.

`RMID`::
Path to the RMI daemon program.

`JAVA_CLASSES`::
Path to the archive that contains the JDK class files. On most JDKs, this is
[.filename]#${JAVA_HOME}/jre/lib/rt.jar#.

`JAVASHAREDIR`::
The base directory for all shared Java resources.

`JAVAJARDIR`::
The directory where a port should install JAR files.

`JAVALIBDIR`::
The directory where JAR files installed by other ports are located.

[[uses-jpeg]]
== `jpeg`

Possible arguments: `lib` (default, implicit), `build`, `run`

Help handling dependencies on `jpeg`.

If the `lib` argument is provided or no arguments are provided then a lib
dependency is added to the port.

If the `build` argument is provided then a build dependency is added to the
port.

If the `run` argument is provided then a run dependency is added to the
port.

If the `both` argument is provided then a build dependency and a run dependency
are added to the port.

The framework provides the following variable that can be set by ports:

`JPEG_PORT`::
Specifies the JPEG implementation to use. Possible values are:

* package:graphics/jpeg-turbo[] (default)
* package:graphics/mozjpeg[]

[[uses-kde]]
== `kde`

Possible arguments: `5`

Add dependency on KDE components.
See crossref:special[using-kde,Using KDE] for more information.

[[uses-kmod]]
== `kmod`

Possible arguments: (none), `debug`

Fills in the boilerplate for kernel module ports, currently:

* Add `kld` to `CATEGORIES`.
* Set `SSP_UNSAFE`.
* Set `IGNORE` if the kernel sources are not found in `SRC_BASE`.
* Define `KMODDIR` to [.filename]#/boot/modules# by default, add it to `PLIST_SUB` and `MAKE_ENV`, and create it upon installation. If `KMODDIR` is set to [.filename]#/boot/kernel#, it will be rewritten to [.filename]#/boot/modules#. This prevents breaking packages when upgrading the kernel due to [.filename]#/boot/kernel# being renamed to [.filename]#/boot/kernel.old# in the process.
* Handle cross-referencing kernel modules upon installation and deinstallation, using crossref:plist[plist-keywords-kld,`@kld`].
* If the `debug` argument is given, the port can install a debug version of the module into [.filename]#KERN_DEBUGDIR#/[.filename]#KMODDIR#. By default, `KERN_DEBUGDIR` is copied from `DEBUGDIR` and set to [.filename]#/usr/lib/debug#. The framework will take care of creating and removing any required directories.

[[uses-kodi]]
== `kodi`

Possible arguments: (none), `noautoplist`

Provide support for package:multimedia/kodi[] add-ons.
If the `noautoplist` argument is provided it does not generate the `plist`
automatically.

[[uses-lazarus]]
== `lazarus`

Possible arguments: (none), `gtk2` (default), `qt5`, `qt6`, `flavors`

Provide support for package:editors/lazarus[] based ports.

If no arguments are provided or if `gtk2` is provided the lazarus-app is built with
a `gtk2` interface the package:editors/lazarus[] port will be built with the `gtk2`
interface.

If the `qt5` argument is provided, the lazarus-app is built with a `qt5`
interface.

If the `qt6` argument is provided, the lazarus-app is built with a `qt6`
interface.

If the `flavors` argument is provided the lazarus-app is built with flavors
feature.

If the port does not require compiling lazarus project files automatically, the
following variable can be defined:

`NO_LAZBUILD`=  `yes`

The following variables are available for ports:

`LAZARUS_PROJECT_FILES`::
List of lpi files. It must not be empty.  Default: empty

`LAZARUS_DIR`::
Path to lazarus installation directory
Default: [.filename]#${LOCALBASE}/share/lazarus-${LAZARUS_VER}#

`LAZBUILD_ARGS`::
lazbuild extra args. It could be `-d` in most of cases.
See man:lazbuild[1] for more information.
Default: empty

`LAZARUS_NO_FLAVORS`::
Do not build these lazarus flavors.
If `LAZARUS_NO_FLAVORS` is not defined then all valid lazarus flavors are assumed.

`WANT_LAZARUS_DEVEL`::
If set to `yes` then use package:lazarus/devel[] as build dependency.

[[uses-ldap]]
== `ldap`

Possible arguments: (none), <version>, client, server

Registers a dependency on package:net/openldap[].
It uses the specific `<version>` (without the dot notation) if set.
Otherwise it tries to find the currently installed version.
If necessary it falls back to the default version found in `bsd.default-versions.mk`.
`client` specifies a runtime dependency on the client library. This is also the
default.
`server` specifies a runtime dependency on the server.

The following variables can be accessed by the port:

`IGNORE_WITH_OPENLDAP`::
This variable can be defined if the ports does not support one or more versions of OpenLDAP.
`WITH_OPENLDAP_VER`::
User defined variable to set OpenLDAP version.
`OPENLDAP_VER`::
Detected OpenLDAP version.

[[uses-lha]]
== `lha`

Possible arguments: (none)

Set `EXTRACT_SUFX` to `.lzh`

[[uses-libarchive]]
== `libarchive`

Possible arguments: (none)

Registers a dependency on package:archivers/libarchive[].
Any ports depending on libarchive must include `USES=libarchive`.

[[uses-libedit]]
== `libedit`

Possible arguments: (none)

Registers a dependency on package:devel/libedit[].
Any ports depending on libedit must include `USES=libedit`.

[[uses-libtool]]
== `libtool`

Possible arguments: (none), `keepla`, `build`

Patches `libtool` scripts. This must be added to all ports that use `libtool`.
The `keepla` argument can be used to keep [.filename]#.la# files.
Some ports do not ship with their own copy of libtool and need a build time dependency on package:devel/libtool[], use the `:build` argument to add such dependency.

[[uses-linux]]
== `linux`

Possible arguments: `c6`, `c7`

Ports Linux compatibility framework.
Specify `c6` to depend on CentOS 6 packages.
Specify `c7` to depend on CentOS 7 packages. The available packages are:

* `allegro`
* `alsa-plugins-oss`
* `alsa-plugins-pulseaudio`
* `alsalib`
* `atk`
* `avahi-libs`
* `base`
* `cairo`
* `cups-libs`
* `curl`
* `cyrus-sasl2`
* `dbusglib`
* `dbuslibs`
* `devtools`
* `dri`
* `expat`
* `flac`
* `fontconfig`
* `gdkpixbuf2`
* `gnutls`
* `graphite2`
* `gtk2`
* `harfbuzz`
* `jasper`
* `jbigkit`
* `jpeg`
* `libasyncns`
* `libaudiofile`
* `libelf`
* `libgcrypt`
* `libgfortran`
* `libgpg-error`
* `libmng`
* `libogg`
* `libpciaccess`
* `libsndfile`
* `libsoup`
* `libssh2`
* `libtasn1`
* `libthai`
* `libtheora`
* `libv4l`
* `libvorbis`
* `libxml2`
* `mikmod`
* `naslibs`
* `ncurses-base`
* `nspr`
* `nss`
* `openal`
* `openal-soft`
* `openldap`
* `openmotif`
* `openssl`
* `pango`
* `pixman`
* `png`
* `pulseaudio-libs`
* `qt`
* `qt-x11`
* `qtwebkit`
* `scimlibs`
* `sdl12`
* `sdlimage`
* `sdlmixer`
* `sqlite3`
* `tcl85`
* `tcp_wrappers-libs`
* `tiff`
* `tk85`
* `ucl`
* `xorglibs`

[[uses-llvm]]
== `llvm`

Possible arguments: (none), `_XY_`, min=`_XY_`, max=`_XY_`, build, run, lib

Adds a dependency on LLVM.
By default this is a build dependency unless overridden by the `run` or `lib`
options.
The default version is the one set in `LLVM_DEFAULT`. A specific version can be
specified as well. The minimum and maximum versions can be specified with the
`min` and `max` parameters respectively.
The ports framework export the following variables to the port:

`LLVM_VERSION`::
Version chosen from the arguments to llvm.mk
`LLVM_PORT`::
Chosen llvm port
`LLVM_CONFIG`::
llvm-config of the chosen port
`LLVM_LIBLLVM`::
libLLVM.so of the chosen port
`LLVM_PREFIX`::
Installation prefix of the chosen port

[[uses-localbase]]
== `localbase`

Possible arguments: (none), `ldflags`

Ensures that libraries from dependencies in `LOCALBASE` are used instead of the ones from the base system.
Specify `ldflags` to add `-L${LOCALBASE}/lib` to `LDFLAGS` instead of `LIBS`.
Ports that depend on libraries that are also present in the base system should use this.
It is also used internally by a few other `USES`.

[[uses-lua]]
== `lua`

Possible arguments: (none), `_XY_`, `_XY_+`, `-_XY_`, `_XY_-_ZA_`, `module`, `flavors`, `build`, `run`, `env`

Adds a dependency on Lua.
By default this is a library dependency, unless overridden by the `build` and/or `run` option.
The `env` option prevents the addition of any dependency, while still defining all the usual variables.

The default version is set by the usual `DEFAULT_VERSIONS` mechanism, unless a version or range of versions is specified as an argument, for example, `51` or `51-54`.

Applications using Lua are normally built for only a single Lua version.
However, library modules intended to be loaded by Lua code should use the `module` option to build with multiple flavors.

For more information see crossref:special[using-lua,Using Lua].

[[uses-luajit]]
== `luajit`

Possible arguments: (none), `_X_`

Adds a dependency on luajit runtime.
A specific version _X_ can be used. Possible versions are `luajit`, `luajit-devel`, `luajit-openresty`

After including [.filename]#bsd.port.options.mk# or [.filename]#bsd.port.pre.mk# the port can inspect these variables:

`LUAJIT_VER`::
The selected luajit version
`LUAJIT_INCDIR`::
The path to luajit's header files
`LUAJIT_LUAVER`::
Which luajit spec version is selected (2.0 for luajit, else 2.1)

For more information see crossref:special[using-lua,Using Lua].

[[uses-lxqt]]
== `lxqt`

Possible arguments: (none)

Handle dependencies for the LXQt Desktop Environment.
Use `USE_LXQT` to select the components needed for the port.
See crossref:special[using-lxqt,Using LXQt] for more information.

[[uses-magick]]
== `magick`

Possible arguments: (none), `_X_`, `build`, `nox11`, `run`, `test`

Add a library dependency on `ImageMagick`.
A specific version _X_ can be used. Possible versions are `6` and `7` (default).
`nox11` indicates that the `-nox11` version of the port is required.
`build`, `run` and `test` add build-, run-time and test dependencies on ImageMagick.

[[uses-makeinfo]]
== `makeinfo`

Possible arguments: (none)

Add a build-time dependency on `makeinfo` if it is not present in the base system.

[[uses-makeself]]
== `makeself`

Possible arguments: (none)

Indicates that the distribution files are makeself archives and sets the appropriate dependencies.

[[uses-mate]]
== `mate`

Possible arguments: (none)

Provides an easy way to depend on MATE components.
The components should be listed in `USE_MATE`.
The available components are:

* `autogen`
* `caja`
* `common`
* `controlcenter`
* `desktop`
* `dialogs`
* `docutils`
* `icontheme`
* `intlhack`
* `intltool`
* `libmatekbd`
* `libmateweather`
* `marco`
* `menus`
* `notificationdaemon`
* `panel`
* `pluma`
* `polkit`
* `session`
* `settingsdaemon`

The default dependency is build- and run-time, it can be changed with `:build` or `:run`.
For example:

[.programlisting]
....
USES=		mate
USE_MATE=	menus:build intlhack
....

[[uses-meson]]
== `meson`

Possible arguments: (none), `muon`

Provide support for Meson based projects.
For more information see crossref:special[using-meson,Using `meson`].

If `muon` is specified then a build dependency on package:devel/muon[] is added.

[[uses-metaport]]
== `metaport`

Possible arguments: (none)

Sets the following variables to make it easier to create a metaport: `MASTER_SITES`, `DISTFILES`, `EXTRACT_ONLY`, `NO_BUILD`, `NO_INSTALL`, `NO_MTREE`, `NO_ARCH`.

[[uses-minizip]]
== `minizip`

Possible arguments: (none), `ng`

Adds a library dependency on package:archivers/minizip[] or package:archivers/minizip-ng[] respectively.

[[uses-mlt]]
== `mlt`

Possible arguments: `7`, `nodepend`

Provide support for ports depending on package:multimedia/mlt7[].

If the `nodepend` argument is provided no library dependency is generated. This
argument only makes sense for multimedia/mlt7* ports.

[[uses-mysql]]
== `mysql`

Possible arguments: (none), `_version_`, `client` (default), `server`, `embedded`

Provide support for MySQL
If no version is given, try to find the current installed version.
Fall back to the default version, MySQL-5.6.
The possible versions are `55`, `55m`, `55p`, `56`, `56p`, `56w`, `57`, `57p`, `80`, `100m`, `101m`, and `102m`.
The `m` and `p` suffixes are for the MariaDB and Percona variants of MySQL.
`server` and `embedded` add a build- and run-time dependency on the MySQL server.
When using `server` or `embedded`, add `client` to also add a dependency on [.filename]#libmysqlclient.so#.
A port can set `IGNORE_WITH_MYSQL` if some versions are not supported.

The framework sets `MYSQL_VER` to the detected MySQL version.

[[uses-mono]]
== `mono`

Possible arguments: (none), `nuget`

Adds a dependency on the Mono (currently only C#) framework by setting the appropriate dependencies.

Specify `nuget` when the port uses nuget packages.
`NUGET_DEPENDS` needs to be set with the names and versions of the nuget packages in the format `_name_=_version_`.
An optional package origin can be added using `_name_=_version_:_origin_`.

The helper target, `buildnuget`, will output the content of the `NUGET_DEPENDS` based on the provided [.filename]#packages.config#.

[[uses-motif]]
== `motif`

Possible arguments: (none)

Uses package:x11-toolkits/open-motif[] as a library dependency.
End users can set `WANT_LESSTIF` in [.filename]#make.conf# to use
package:x11-toolkits/lesstif[] as dependency instead of package:x11-toolkits/open-motif[].
Similarly setting `WANT_OPEN_MOTIF_DEVEL` in [.filename]#make.conf# will add a
dependency on package:x11-toolkits/open-motif-devel[]

[[uses-mpi]]
== `mpi`

Possible arguments: `mpich` (default), `openmpi`

Provide support for ports depending on `MPI`.

If the `mpich` argument is provided a dependency on package:net/mpich[] is added
to the port.

If the `openmpi` argument is provided a dependency on package:net/openmpi[] is
added to the port.

The ports framework provides the following variables that can be read by the port:

`MPI_LIBS`::
Libraries needed to link programs using `MPI`.

`MPI_CFLAGS`::
Compiler flags necessary to build programs using `MPI`.

`MPICC`::
Location of the `mpicc` executable. Default: [.filename]#${MPI_HOME}/bin/mpicc#.

`MPICXX`::
Location of the `mpicxx` executable. Default: [.filename]#${MPI_HOME}/bin/mpicxx#.

`MPIF90`::
Location of the `mpif90` executable. Default: [.filename]#${MPI_HOME}/bin/mpif90#.

`MPIFC`::
Same as above.

`MPI_HOME`::
Installation directory of `MPI`. Defaults to `${LOCALBASE}` for `MPICH`.

`MPIEXEC`::
Location of the `mpiexec` executable. Default: [.filename]#${MPI_HOME}/bin/mpiexec#.

`MPIRUN`::
Location of the `mpirun` executable. Default: [.filename]#${MPI_HOME}/bin/mpirun#.


[[uses-ncurses]]
== `ncurses`

Possible arguments: (none), `base`, `port`

Uses ncurses, and causes some useful variables to be set.

[[uses-nextcloud]]
== `nextcloud`

Possible arguments: (none)

Adds support for Nextcloud applications by adding a run time dependency on package:www/nextcloud[].

[[uses-ninja]]
== `ninja`

Possible arguments: (none), `build`, `make` (default), `run`

If `build` or `run` arguments are specify, it respectively adds a build or run
time dependency on package:devel/ninja[].
If `make` or no arguments are provided, use ninja to build the port instead of make.
`make` implies `build`.
If the variable `NINJA_DEFAULT` is set to `samurai`, then the dependencies are set
on package:devel/samurai[] instead.

[[uses-nodejs]]
== `nodejs`

Possible arguments: (none), `build`, `run`, `current`, `lts`, `10`, `14`, `16`,
 `17`.

Uses nodejs. Adds a dependency on package:www/node*[]. If a supported version is
specified then `run` and/or `build` must be specified too.

[[uses-objc]]
== `objc`

Possible arguments: (none)

Add objective C dependencies (compiler, runtime library) if the base system does not support it.

[[uses-ocaml]]
== `ocaml`

Possible arguments: (none), `build`,`camlp4`,`dune`,`findlib`,`findplist`,`ldconfig`,`run`,`tk`,`tkbuild`,`tkrun`,`wash`

Provide support for OCaml.

If no arguments are provided, it defaults to `build`, `run`.

If the `build` argument is provided then package:lang/ocamlc[] is added to
`BUILD_DEPENDS`, `EXTRACT` and `PATCH_DEPENDS`.

If the `camlp4` argument is provided then package:devel/ocamlp4[] is used to build.

If the `dune` argument is provided then package:devel/ocaml-dune[] is used as build system.

If the `findlib` argument is provided then `ocamlfind` will be used to install packages. Package directories will be automatically deleted.

If the `findplist` argument is provided then contents of the `findlib` target directories will be added automatically.

If the `ldconfig` argument is provided then OCaml's [.filename]#ld.conf# file
will be automatically processed. When `dune` is used Dune may install stublibs
in site-lib package directory(ies) or in a single directory below `DUNE_LIBDIR` site-lib directory.
Set if the port installs shared libraries into ocaml

If the `run` argument is provided add ocamlc to `RUN_DEPENDS`.

If the `tk` argument is provided then a build and run dependency on
package:x11-toolkits/ocaml-labltk[] is added to the port. Implies `tkbuild` and
`tkrun`.

If the `tkbuild` argument is provided then package:x11-toolkits/ocaml-labltk[]
is added to `BUILD_DEPENDS`, `EXTRACT` and `PATCH_DEPENDS`.

If the `tkrun` argument is provided then package:x11-toolkits/ocaml-labltk[] is
added to `RUN_DEPENDS`.

If the `wash` argument is provided Ocaml's shared directories will be purged on
uninstall. Useful when installing to non-standard `PREFIX`.

The following variables can be set by the port:

`OCAML_PKGDIRS`::
Directories under site-lib to be processed if the `findlib` argument is specified. Default: `${PORTNAME}`

`OCAML_LDLIBS`::
Directories under `PREFIX` to be automatically added/removed from [.filename]#ld.conf#.
Default: `${OCAML_SITELIBDIR}/${PORTNAME}`

`OCAML_PACKAGES`::
List of packages to build and install. Default to `${PORTNAME}`


[[uses-octave]]
== `octave`

Possible arguments: (none), env

Uses package:math/octave[].
`env` loads only one `OCTAVE_VERSION` environmental variable.

[[uses-openal]]
== `openal`

Possible arguments: `al`, `soft` (default), `si`, `alut`

Uses OpenAL.
The backend can be specified, with the software implementation as the default.
The user can specify a preferred backend with `WANT_OPENAL`.
Valid values for this knob are `soft` (default) and `si`.

[[uses-pathfix]]
== `pathfix`

Possible arguments: (none)

Look for [.filename]#Makefile.in# and [.filename]#configure# in `PATHFIX_WRKSRC` (defaults to `WRKSRC`) and fix common paths to make sure they respect the FreeBSD hierarchy.
For example, it fixes the installation directory of `pkgconfig`'s [.filename]#.pc# files to [.filename]#${PREFIX}/libdata/pkgconfig#.
If the port uses `USES=autoreconf`, [.filename]#Makefile.am# will be added to `PATHFIX_MAKEFILEIN` automatically.

If the port crossref:uses[uses-cmake,`USES=cmake`] it will look for [.filename]#CMakeLists.txt# in `PATHFIX_WRKSRC`.
If needed, that default filename can be changed with `PATHFIX_CMAKELISTSTXT`.

[[uses-pear]]
== `pear`

Possible arguments: `env`

Adds a dependency on package:devel/pear[].
It will setup default behavior for software using the PHP Extension and Application Repository.
Using the `env` arguments only sets up the PEAR environment variables.
See crossref:special[php-pear,PEAR Modules] for more information.

[[uses-perl5]]
== `perl5`

Possible arguments: (none)

Depends on Perl. The configuration is done using `USE_PERL5`.

`USE_PERL5` can contain the phases in which to use Perl, can be `extract`, `patch`, `build`, `run`, or `test`.

`USE_PERL5` can also contain `configure`, `modbuild`, or `modbuildtiny` when [.filename]#Makefile.PL#, [.filename]#Build.PL#,
or Module::Build::Tiny's flavor of [.filename]#Build.PL# is required.

`USE_PERL5` defaults to `build run`.
When using `configure`, `modbuild`, or `modbuildtiny`, `build` and `run` are implied.

See crossref:special[using-perl,Using Perl] for more information.

[[uses-pgsql]]
== `pgsql`

Possible arguments: (none), `_X.Y_`, `_X.Y_+`, `_X.Y_-`, `_X.Y_-_Z.A_`

Provide support for PostgreSQL.
Port maintainer can set version required.
Minimum and maximum versions or a range can be specified; for example, `9.0-`, `8.4+`, `8.4-9.2.`

By default, the added dependency will be the client, but if the port requires additional components,
this can be done using `WANT_PGSQL=_component[:target]_`;
for example, `WANT_PGSQL=server:configure pltcl plperl`.
The available components are:

* `client`
* `contrib`
* `docs`
* `pgtcl`
* `plperl`
* `plpython`
* `pltcl`
* `server`

[[uses-php]]
== `php`

Possible arguments: (none), `phpize`, `ext`, `zend`, `build`, `cli`, `cgi`, `mod`, `web`, `embed`, `pecl`, `flavors`, `noflavors`

Provide support for PHP.
Add a runtime dependency on the default PHP version, package:lang/php81[].

`phpize`::
Use to build a PHP extension.
Enables flavors.

`ext`::
Use to build, install and register a PHP extension.
Enables flavors.

`zend`::
Use to build, install and register a Zend extension.
Enables flavors.

`build`::
Set PHP also as a build-time dependency.

`cli`::
Needs the CLI version of PHP.

`cgi`::
Needs the CGI version of PHP.

`mod`::
Needs the Apache module for PHP.

`web`::
Needs the Apache module or the CGI version of PHP.

`embed`::
Needs the embedded library version of PHP.

`pecl`::
Provide defaults for fetching PHP extensions from the PECL repository.
Enables flavors.

`flavors`::
Enable automatic crossref:flavors[flavors-auto-php,PHP flavors] generation.
Flavors will be generated for all PHP versions, except the ones present in
crossref:uses[uses-php-ignore,`IGNORE_WITH_PHP`].

`noflavors`::
Disable automatic PHP flavors generation.
_Must only_ be used with extensions provided by PHP itself.

Variables are used to specify which PHP modules are required, as well as which version of PHP are supported.

`USE_PHP`::
The list of required PHP extensions at run-time.
Add `:build` to the extension name to add a build-time dependency.
Example: `pcre xml:build gettext`

[[uses-php-ignore]]
`IGNORE_WITH_PHP`::
The port does not work with PHP of the given version.
For possible values look at the content of `_ALL_PHP_VERSIONS` in [.filename]#Mk/Uses/php.mk#.

When building a PHP or Zend extension with `:ext` or `:zend`, these variables can be set:

`PHP_MODNAME`::
The name of the PHP or Zend extension.
Default value is `${PORTNAME}`.

`PHP_HEADER_DIRS`::
A list of subdirectories from which to install header files.
The framework will always install the header files that are present in the same directory as the extension.

`PHP_MOD_PRIO`::
The priority at which to load the extension.
It is a number between `00` and `99`.
+
For extensions that do not depend on any extension, the priority is automatically set to `20`, for extensions that depend on another extension, the priority is automatically set to `30`.
Some extensions may need to be loaded before every other extension, for example package:www/php56-opcache[].
Some may need to be loaded after an extension with a priority of `30`.
In that case, add `PHP_MOD_PRIO=_XX_` in the port's Makefile. For example:
+
[.programlisting]
....
USES=		php:ext
USE_PHP=	wddx
PHP_MOD_PRIO=	40
....

These variables are available to use in `PKGNAMEPREFIX` or `PKGNAMESUFFIX`:

`PHP_PKGNAMEPREFIX`::
Contains `php_XY_-` where _XY_ is the current flavor's PHP version.
Use with PHP extensions and modules.

`PHP_PKGNAMESUFFIX`::
Contains `-php_XY_` where _XY_ is the current flavor's PHP version.
Use with PHP applications.

`PECL_PKGNAMEPREFIX`::
Contains `php_XY_-pecl-` where _XY_ is the current flavor's PHP version.
Use with PECL modules.

[IMPORTANT]
====
With flavors, all PHP extensions, PECL extensions, PEAR modules _must have_ a different package name,
so they must all use one of these three variables in their `PKGNAMEPREFIX` or `PKGNAMESUFFIX`.
====

[[uses-pkgconfig]]
== `pkgconfig`

Possible arguments: (none), `build` (default), `run`, `both`

Uses package:devel/pkgconf[].
With no arguments or with the `build` argument, it implies `pkg-config` as a build-time dependency.
`run` implies a run-time dependency and `both` implies both run-time and build-time dependencies.

[[uses-pure]]
== `pure`

Possible arguments: (none), `ffi`

Uses package:lang/pure[].
Largely used for building related pure ports.
With the `ffi` argument, it implies package:devel/pure-ffi[] as a run-time dependency.

[[uses-pyqt]]
== `pyqt`

Possible arguments: (none), `4`, `5`

Uses PyQt. If the port is part of PyQT itself, set `PYQT_DIST`.
Use `USE_PYQT` to select the components the port needs.
The available components are:

* `core`
* `dbus`
* `dbussupport`
* `demo`
* `designer`
* `designerplugin`
* `doc`
* `gui`
* `multimedia`
* `network`
* `opengl`
* `qscintilla2`
* `sip`
* `sql`
* `svg`
* `test`
* `webkit`
* `xml`
* `xmlpatterns`

These components are only available with PyQT4:

* `assistant`
* `declarative`
* `help`
* `phonon`
* `script`
* `scripttools`

These components are only available with PyQT5:

* `multimediawidgets`
* `printsupport`
* `qml`
* `serialport`
* `webkitwidgets`
* `widgets`

The default dependency for each component is build- and run-time, to select only build or run, add `_build` or `_run` to the component name. For example:

[.programlisting]
....
USES=		pyqt
USE_PYQT=	core doc_build designer_run
....

[[uses-pytest]]
== `pytest`

Possible arguments: (none), 4

Introduces a new dependency on package:devel/pytest[]. It defines a `do-test`
target which will run the tests properly.
Use the argument to depend on a specific package:devel/pytest[] version.
For ports using package:devel/pytest[] consider using this instead of a specific
`do-test` target.
The framework exposes the following variables to the port:

`PYTEST_ARGS`::
Additional arguments to pytest (defaults to empty).

`PYTEST_IGNORED_TESTS`::
lists of `pytest -k` patterns of tests to ignore (defaults to empty). For tests
which are not expected to pass, such as ones requiring a database access.

`PYTEST_BROKEN_TESTS`::
lists of `pytest -k` patterns of tests to ignore (defaults to empty). For broken
tests which require fixing.

In addition the following variables may be set by the user:

`PYTEST_ENABLE_IGNORED_TESTS`::
Enable tests which are otherwise ignored by `PYTEST_IGNORED_TESTS`.

`PYTEST_ENABLE_BROKEN_TESTS`::
Enable tests which are otherwise ignored by `PYTEST_BROKEN_TESTS`.

`PYTEST_ENABLE_ALL_TESTS`::
Enable tests which are otherwise ignored by `PYTEST_IGNORED_TESTS` and
`PYTEST_BROKEN_TESTS`.


[[uses-python]]
== `python`

Possible arguments: (none), `_X.Y_`, `_X.Y+_`, `_-X.Y_`, `_X.Y-Z.A_`, `patch`, `build`, `run`, `test`

Uses Python. A supported version or version range can be specified.
If Python is only needed at build time, run time or for the tests, it can be set as a build, run or test dependency with `build`, `run`, or `test`.
If Python is also needed during the patch phase, use `patch`.
See crossref:special[using-python, Using Python] for more information.

`USES=python:env` can be used when the variables exported by the framework are needed but a dependency on Python is not.
It can happen when using with crossref:uses[uses-shebangfix,`USES=shebangfix`], and the goal is only to fix the shebangs but not add a dependency on Python.

[[uses-qmail]]
== `qmail`

Possible arguments: (none), `build`, `run`, `both`, `vars`

Uses package:mail/qmail[]. With the `build` argument, it implies `qmail` as a build-time dependency.
`run` implies a run-time dependency.
Using no argument or the `both` argument implies both run-time and build-time dependencies.
`vars` will only set QMAIL variables for the port to use.

[[uses-qmake]]
== `qmake`

Possible arguments: (none), `norecursive`, `outsource`, `no_env`, `no_configure`

Uses QMake for configuring. For more information see crossref:special[using-qmake,Using `qmake`].

[[uses-qt]]
== `qt`

Possible arguments: `5`, `6`, `no_env`

Add dependency on Qt components.
`no_env` is passed directly to `USES= qmake`.
See crossref:special[using-qt,Using Qt] for more information.

[[uses-qt-dist]]
== `qt-dist`

Possible arguments: (none) or `5` and (none) or `6` and (none) or one of `3d`, `5compat`, `base`, `charts`, `connectivity`, `datavis3d`, `declarative`, `doc` `languageserver`, `gamepad`, `graphicaleffects`, `imageformats`, `locat    ion`, `lottie`, `multimedia`, `networkauth`, `positioning`, `quick3d`, `quickcontrols2`, `quickcontrols`, `quicktimeline`, `remoteobjects`, `script`, `scxml    `, `sensors`, `serialbus`, `serialport`, `shadertools`, `speech`, `svg`, `tools`, `translations`, `virtualkeyboard`, `wayland`, `webchannel`, `webengine`, `webglplugin`, `websockets`, `webview`, `x11extras`, `xmlpatterns`.

Provides support for building Qt 5 and Qt 6 components.
It takes care of setting up the appropriate configuration environment for the port to build.

[[qt5-dist-example]]
.Building Qt 5 Components
[example]
====
The port is Qt 5's `networkauth` component, which is part of the `networkauth` distribution file.

[.programlisting]
....
PORTNAME=	networkauth
DISTVERSION=	${QT5_VERSION}

USES=		qt-dist:5
....

====


[[qt6-dist-example]]
.Building Qt 6 Components
[example]
====
The port is Qt 6's `websockets` component, which is part of the `websockets` distribution file.

[.programlisting]
....
PORTNAME=       websockets
PORTVERSION=    ${QT6_VERSION}

USES=           qt-dist:6
....

====

If `PORTNAME` does not match the component name, it can be passed as an argument to `qt-dist`.

[[qt5-dist-example-explicit]]
.Building Qt 5 Components with Different Names
[example]
====
The port is Qt 5's `gui` component, which is part of the `base` distribution file.

[.programlisting]
....
PORTNAME=	gui
DISTVERSION=	${QT5_VERSION}

USES=		qt-dist:5,base
....

====

[[uses-readline]]
== `readline`

Possible arguments: (none), `port`

Uses readline as a library dependency, and sets `CPPFLAGS` and `LDFLAGS` as necessary.
If the `port` argument is used or if readline is not present in the base system, add a dependency on package:devel/readline[]


[[uses-ruby]]
== `ruby`

Possible arguments: (none), `build`, `extconf`, `run`, `setup`

Provide support for Ruby related ports.
`(none)` without arguments adds runtime dependency on package:lang/ruby[].
`build` adds a dependency on package:lang/ruby[] at build time.
`extconf` states that the port uses extconf.rb to configure.
`run` adds a dependency on package:lang/ruby[] at run time. This is also the default.
`setup` states that the port uses setup.rb to configure and build.

The user may have the following variables defined:

`RUBY_VER`::
Alternative short version of ruby in the form of `x.y'.

`RUBY_DEFAULT_VER`::
Set to (e.g.) `2.7` to use `ruby27` as the default version.

`RUBY_ARCH`::
Set the architecture name (e.g. i386-freebsd7).

The following variables are exported to be used by the port:

`RUBY`::
Set to full path of ruby.
If set, the values of the following variables are automatically obtained from
the ruby executable: `RUBY_ARCH`, `RUBY_ARCHLIBDIR`, `RUBY_LIBDIR`,
`RUBY_SITEARCHLIBDIR`, `RUBY_SITELIBDIR`, `RUBY_VER` and `RUBY_VERSION`

`RUBY_VER`::
Set to the alternative short version of ruby in the form of `x.y'.

`RUBY_EXTCONF`::
Set to the alternative name of extconf.rb (default: extconf.rb).

`RUBY_EXTCONF_SUBDIRS`::
Set to list of subdirectories, if multiple modules are included.

`RUBY_SETUP`::
Set to the alternative name of setup.rb (default: setup.rb).


[[uses-samba]]
== `samba`

Possible arguments: `build`, `env`, `lib`, `run`

Handle dependency on Samba.
`env` will not add any dependency and only set up the variables.
`build` and `run` will add build-time and run-time dependency on [.filename]#smbd#. `lib` will add a dependency on [.filename]#libsmbclient.so#.
The variables that are exported are:

`SAMBA_PORT`::
The origin of the default Samba port.

`SAMBA_INCLUDEDIR`::
The location of the Samba header files.

`SAMBA_LIBS`::
The directory where the Samba shared libraries are available.

`SAMBA_LDB_PORT`::
The origin of the ldb port used by the selected Samba version (e.g., package:databases/ldb28[]).
It should be used if a port needs to depend on the same ldb version as the selected Samba version.

`SAMBA_TALLOC_PORT`::
The origin of the talloc port used by the selected Samba version.
It should be used if a port needs to depend on the same talloc version as the selected Samba version.

`SAMBA_TDB_PORT`::
The origin of the TDB port used by the selected Samba version.
It should be used if a port needs to depend on the same TDB version as the selected Samba version.

`SAMBA_TEVENT_PORT`::
The origin of the tevent port used by the selected Samba version.
It should be used if a port needs to depend on the same tevent version as the selected Samba version.

[[uses-scons]]
== `scons`

Possible arguments: (none)

Provide support for the use of package:devel/scons[].
See crossref:special[using-scons,Using `scons`] for more information.

[[uses-sdl]]
== `sdl`

Possible arguments: `sdl`

Provide support for the use of `SDL` packages.
The variable `USE_SDL` is mandatory and specifies which components to add as
dependencies.

The current supported `SDL1.2` modules are:

* sdl
* console
* gfx
* image
* mixer
* mm
* net
* pango
* sound
* ttf

The current supported `SDL2` modules are:

 * sdl2
 * gfx2
 * image2
 * mixer2
 * net2
 * sound2
 * ttf2

The current supported `SDL3` modules are:

 * sdl3
 * image3
 * ttf3

[[uses-shared-mime-info]]
== `shared-mime-info`

Possible arguments: (none)

Uses update-mime-database from package:misc/shared-mime-info[].
This uses will automatically add a post-install step in such a way that the port itself still can specify there own post-install step if needed.
It also add an crossref:plist[plist-keywords-shared-mime-info,`@shared-mime-info`] entry to the plist.

[[uses-shebangfix]]
== `shebangfix`

Possible arguments: (none)

A lot of software uses incorrect locations for script interpreters, most notably [.filename]#/usr/bin/perl# and [.filename]#/bin/bash#.
The shebangfix macro fixes shebang lines in scripts listed in `SHEBANG_REGEX`, `SHEBANG_GLOB`, or `SHEBANG_FILES`.

`SHEBANG_REGEX`::
Contains _one_ extended regular expressions, and is used with the `-iregex` argument of man:find[1].
See crossref:uses[uses-shebangfix-ex-regex,`USESshebangfix` with `SHEBANG_REGEX`].

`SHEBANG_GLOB`::
Contains a list of patterns used with the `-name` argument of man:find[1].
See crossref:uses[uses-shebangfix-ex-glob,`USESshebangfix` with `SHEBANG_GLOB`].

`SHEBANG_FILES`::
Contains a list of files or man:sh[1] globs.
The shebangfix macro is run from `${WRKSRC}`, so `SHEBANG_FILES` can contain paths that are relative to `${WRKSRC}`.
It can also deal with absolute paths if files outside of `${WRKSRC}` require patching.
See crossref:uses[uses-shebangfix-ex-files,`USESshebangfix` with `SHEBANG_FILES`].

Currently Bash, Java, Ksh, Lua, Perl, PHP, Python, Ruby, Tcl, and Tk are supported by default.

There are three configuration variables:

`SHEBANG_LANG`::
The list of supported interpreters.

`_interp__CMD`::
The path to the command interpreter on FreeBSD.
The default value is `${LOCALBASE}/bin/_interp_`.

`_interp__OLD_CMD`::
The list of wrong invocations of interpreters.
These are typically obsolete paths, or paths used on other operating systems that are incorrect on FreeBSD.
They will be replaced by the correct path in `_interp__CMD`.
+
[NOTE]
====
These will _always_ be part of `_interp__OLD_CMD`: `"/usr/bin/env _interp_" /bin/_interp_ /usr/bin/_interp_ /usr/local/bin/_interp_`.
====
+
[TIP]
====
`_interp__OLD_CMD` contain multiple values.
Any entry with spaces must be quoted.
See crossref:uses[uses-shebangfix-ex-ksh,Specifying all the Paths When Adding an Interpreter to `USESshebangfix`].
====

[IMPORTANT]
====
The fixing of shebangs is done during the `patch` phase.
If scripts are created with incorrect shebangs during the `build` phase, the build process (for example, the [.filename]#configure# script, or the [.filename]#Makefiles#) must be patched or given the right path (for example, with `CONFIGURE_ENV`, `CONFIGURE_ARGS`, `MAKE_ENV`, or `MAKE_ARGS`) to generate the right shebangs.

Correct paths for supported interpreters are available in `_interp__CMD`.
====

[TIP]
====
When used with crossref:uses[uses-python,`USES=python`], and the aim is only to fix the shebangs but a dependency on Python itself is not wanted, use `USES=python:env` instead.
====

[[uses-shebangfix-ex-lua]]
.Adding Another Interpreter to `USES=shebangfix`
[example]
====
To add another interpreter, set `SHEBANG_LANG`.
For example:

[.programlisting]
....
SHEBANG_LANG=	lua
....

====

[[uses-shebangfix-ex-ksh]]
.Specifying all the Paths When Adding an Interpreter to `USES=shebangfix`
[example]
====
If it was not already defined, and there were no default values for `_interp__OLD_CMD` and `_interp__CMD` the Ksh entry could be defined as:

[.programlisting]
....
SHEBANG_LANG=	ksh
ksh_OLD_CMD=	"/usr/bin/env ksh" /bin/ksh /usr/bin/ksh
ksh_CMD=	${LOCALBASE}/bin/ksh
....

====

[[uses-shebangfix-ex-strange]]
.Adding a Strange Location for an Interpreter
[example]
====
Some software uses strange locations for an interpreter.
For example, an application might expect Python to be located in [.filename]#/opt/bin/python2.7#.
The strange path to be replaced can be declared in the port [.filename]#Makefile#:

[.programlisting]
....
python_OLD_CMD=	/opt/bin/python2.7
....

====

[[uses-shebangfix-ex-regex]]
.`USES=shebangfix` with `SHEBANG_REGEX`
[example]
====
To fix all the files in `${WRKSRC}/scripts` ending in [.filename]#.pl#, [.filename]#.sh#, or [.filename]#.cgi# do:

[.programlisting]
....
USES=	shebangfix
SHEBANG_REGEX=	./scripts/.*\.(sh|pl|cgi)
....

[NOTE]
======
`SHEBANG_REGEX` is used by running `find -E`, which uses modern regular expressions also known as extended regular expressions.
See man:re_format[7] for more information.
======

====

[[uses-shebangfix-ex-glob]]
.`USES=shebangfix` with `SHEBANG_GLOB`
[example]
====
To fix all the files in `${WRKSRC}` ending in [.filename]#.pl# or [.filename]#.sh#, do:

[.programlisting]
....
USES=	shebangfix
SHEBANG_GLOB=	*.sh *.pl
....

====

[[uses-shebangfix-ex-files]]
.`USES=shebangfix` with `SHEBANG_FILES`
[example]
====
To fix the files [.filename]#script/foobar.pl# and [.filename]#script/*.sh# in `${WRKSRC}`, do:

[.programlisting]
....
USES=	shebangfix
SHEBANG_FILES=	scripts/foobar.pl scripts/*.sh
....

====

[[uses-sqlite]]
== `sqlite`

Possible arguments: (none), `2`, `3`

Add a dependency on SQLite.
The default version used is 3, but version 2 is also possible using the `:2` modifier.

[[uses-sbrk]]
== `sbrk`

Possible arguments: (none)

Marks the port as `BROKEN` in `aarch64` and `riscv64`.

[[uses-ssl]]
== `ssl`

Possible arguments: (none), `build`, `run`

Provide support for OpenSSL.
A build- or run-time only dependency can be specified using `build` or `run`.
These variables are available for the port's use, they are also added to `MAKE_ENV`:

`OPENSSLBASE`::
Path to the OpenSSL installation base.

`OPENSSLDIR`::
Path to OpenSSL's configuration files.

`OPENSSLLIB`::
Path to the OpenSSL libraries.

`OPENSSLINC`::
Path to the OpenSSL includes.

`OPENSSLRPATH`::
If defined, the path the linker needs to use to find the OpenSSL libraries.

[TIP]
====
If a port does not build with an OpenSSL flavor, set the `BROKEN_SSL` variable, and possibly the `BROKEN_SSL_REASON__flavor_`:

[.programlisting]
....
BROKEN_SSL=	libressl
BROKEN_SSL_REASON_libressl=	needs features only available in OpenSSL
....

====

[[uses-sudo]]
== `sudo`

Possible arguments: (none)

Adds a run time dependecy on package:security/sudo[].

[[uses-tar]]
== `tar`

Possible arguments: (none), `Z`, `bz2`, `bzip2`, `lzma`, `tbz`, `tbz2`, `tgz`,
`txz`, `xz`, `zst`, `zstd`

Set `EXTRACT_SUFX` to `.tar`, `.tar.Z`, `.tar.bz2`, `.tar.bz2`, `.tar.lzma`,
`.tbz`, `.tbz2`, `.tgz`, `.txz`, `.tar.xz`, `.tar.zst` or `.tar.zstd`  respectively.

[[uses-tcl]]
== `tcl`

Possible arguments: _version_, `wrapper`, `build`, `run`, `tea`

Add a dependency on Tcl. A specific version can be requested using _version_.
The version can be empty, one or more exact version numbers (currently `84`, `85`, or `86`), or a minimal version number (currently `84+`, `85+` or `86+`).
To only request a non version specific wrapper, use `wrapper`.
A build- or run-time only dependency can be specified using `build` or `run`.
To build the port using the Tcl Extension Architecture, use `tea`.
After including [.filename]#bsd.port.pre.mk# the port can inspect the results using these variables:

* `TCL_VER`: chosen major.minor version of Tcl
* `TCLSH`: full path of the Tcl interpreter
* `TCL_LIBDIR`: path of the Tcl libraries
* `TCL_INCLUDEDIR`: path of the Tcl C header files
* `TCL_PKG_LIB_PREFIX`: Library prefix, as per TIP595
* `TCL_PKG_STUB_POSTFIX`: Stub library postfix
* `TK_VER`: chosen major.minor version of Tk
* `WISH`: full path of the Tk interpreter
* `TK_LIBDIR`: path of the Tk libraries
* `TK_INCLUDEDIR`: path of the Tk C header files

[[uses-terminfo]]
== `terminfo`

Possible arguments: (none)

Adds crossref:plist[plist-keywords-terminfo,`@terminfo`] to the [.filename]#plist#.
Use when the port installs [.filename]#*.terminfo# files in [.filename]#${PREFIX}/share/misc#.

[[uses-tex]]
== `tex`

Possible arguments: (none)

Provide support for tex.
Loads all the default variables for TEX related ports and does not add any dependency on any ports.

Variables are used to specify which TEX modules are required.

`USE_TEX`::
The list of required TEX extensions at run-time.
Add `:build` to the extension name to add a build-time dependency, `:run` to add runtime dependency, `:test` for test time dependency, `:extract` for extract time dependency.
Example: `base texmf:build source:run`

Current possible arguments are as follows:

* `base`
* `texmf`
* `source`
* `docs`
* `web2c`
* `kpathsea`
* `ptexenc`
* `basic`
* `tlmgr`
* `texlua`
* `texluajit`
* `synctex`
* `xpdfopen`
* `dvipsk`
* `dvipdfmx`
* `xdvik`
* `gbklatex`
* `formats`
* `tex`
* `latex`
* `pdftex`
* `jadetex`
* `luatex`
* `ptex`
* `xetex`
* `xmltex`
* `texhash`
* `updmap`
* `fmtutil`

[[uses-tk]]
== `tk`

Same as arguments for `tcl`

Small wrapper when using both Tcl and Tk.
The same variables are returned as when using Tcl.

[[uses-trigger]]
== `trigger`

Possible arguments: (none)

Provide support for ports requiring triggers to be executed by man:pkg[8].
Triggers are executed at the end of a transaction if the conditions are met.

The following variable can be set by ports:

`TRIGGERS`::
List of triggers to package. Defaults to `${PORTNAME}`.

Triggers are specified in UCL format and are usually placed in the
[.filename]#files/# directory of the port.

[[uses-uidfix]]
== `uidfix`

Possible arguments: (none)

Changes some default behavior (mostly variables) of the build system to allow installing this port as a normal user.
Try this in the port before using crossref:uses[uses-fakeroot,`USES=fakeroot`] or patching.

[[uses-uniquefiles]]
== `uniquefiles`

Possible arguments: (none), `dirs`

Make files or directories 'unique', by adding a prefix or suffix.
If the `dirs` argument is used, the port needs a prefix (and only a prefix) based on `UNIQUE_PREFIX` for standard directories `DOCSDIR`, `EXAMPLESDIR`, `DATADIR`, `WWWDIR`, `ETCDIR`.
These variables are available for ports:

* `UNIQUE_PREFIX`: The prefix to be used for directories and files. Default: `${PKGNAMEPREFIX}`.
* `UNIQUE_PREFIX_FILES`: A list of files that need to be prefixed. Default: empty.
* `UNIQUE_SUFFIX`: The suffix to be used for files. Default: `${PKGNAMESUFFIX}`.
* `UNIQUE_SUFFIX_FILES`: A list of files that need to be suffixed. Default: empty.

[[uses-vala]]
== `vala`

Possible arguments: `build`, `lib`, `no_depend`

Adds build or library dependencies on package:lang/vala[].
The `no_depend` argument is reserved for package:lang/vala[] itself.

[[uses-varnish]]
== `varnish`

Possible arguments: `4` (default), `6`, `7`

Handle dependencies on Varnish Cache.
Adds a dependency on package:www/varnish*[].

[[uses-waf]]
== `waf`

Possible arguments: (none)

Provide support for ports using the `waf` build system.

It implies `USES=python:build`.

The following variables are exported to be used by the port:

`WAF_CMD`::
Location of the `waf` script. Set this if the `waf` script is not in
[.filename]#WRKSRC/waf#.

`CONFIGURE_TARGET`::
`Configure` target. Default `configure`.

`ALL_TARGET`::
`All` target. Default `build`.

`INSTALL_TARGET`::
`Install` target. Default `install`.

[[uses-webplugin]]
== `webplugin`

Possible arguments: (none), `ARGS`

Automatically create and remove symbolic links for each application that supports the webplugin framework.
`ARGS` can be one of:

* `gecko`: support plug-ins based on Gecko
* `native`: support plug-ins for Gecko, Opera, and WebKit-GTK
* `linux`: support Linux plug-ins
* `all` (default, implicit): support all plug-in types
* (individual entries): support only the browsers listed

These variables can be adjusted:

* `WEBPLUGIN_FILES`: No default, must be set manually. The plug-in files to install.
* `WEBPLUGIN_DIR`: The directory to install the plug-in files to, default [.filename]#PREFIX/lib/browser_plugins/WEBPLUGIN_NAME#. Set this if the port installs plug-in files outside of the default directory to prevent broken symbolic links.
* `WEBPLUGIN_NAME`: The final directory to install the plug-in files into, default `PKGBASE`.

[[uses-xfce]]
== `xfce`

Possible arguments: (none), `gtk2`

Provide support for Xfce related ports.
See crossref:special[using-xfce,Using Xfce] for details.

The `gtk2` argument specifies that the port requires GTK2 support.
It adds additional features provided by some core components, for example, package:x11/libxfce4menu[] and package:x11-wm/xfce4-panel[].

[[uses-xorg]]
== `xorg`

Possible arguments: (none)

Provides an easy way to depend on X.org components.
The components should be listed in `USE_XORG`.
The available components are:

[[using-x11-components]]
.Available X.Org Components
[cols="1,1", frame="none", options="header"]
|===
| Name
| Description

|`dmx`
|DMX extension library

|`fontenc`
|The fontenc Library

|`fontutil`
|Create an index of X font files in a directory

|`ice`
|Inter Client Exchange library for X11

|`libfs`
|The FS library

|`pciaccess`
|Generic PCI access library

|`pixman`
|Low-level pixel manipulation library

|`sm`
|Session Management library for X11

|`x11`
|X11 library

|`xau`
|Authentication Protocol library for X11

|`xaw`
|X Athena Widgets library

|`xaw6`
|X Athena Widgets library

|`xaw7`
|X Athena Widgets library

|`xbitmaps`
|X.Org bitmaps data

|`xcb`
|The X protocol C-language Binding (XCB) library

|`xcomposite`
|X Composite extension library

|`xcursor`
|X client-side cursor loading library

|`xdamage`
|X Damage extension library

|`xdmcp`
|X Display Manager Control Protocol library

|`xext`
|X11 Extension library

|`xfixes`
|X Fixes extension library

|`xfont`
|X font library

|`xfont2`
|X font library

|`xft`
|Client-sided font API for X applications

|`xi`
|X Input extension library

|`xinerama`
|X11 Xinerama library

|`xkbfile`
|XKB file library

|`xmu`
|X Miscellaneous Utilities libraries

|`xmuu`
|X Miscellaneous Utilities libraries

|`xorg-macros`
|X.Org development aclocal macros

|`xorg-server`
|X.Org X server and related programs

|`xorgproto`
|xorg protocol headers

|`xpm`
|X Pixmap library

|`xpresent`
|X Present Extension library

|`xrandr`
|X Resize and Rotate extension library

|`xrender`
|X Render extension library

|`xres`
|X Resource usage library

|`xscrnsaver`
|The XScrnSaver library

|`xshmfence`
|Shared memory 'SyncFence' synchronization primitive

|`xt`
|X Toolkit library

|`xtrans`
|Abstract network code for X

|`xtst`
|X Test extension

|`xv`
|X Video Extension library

|`xvmc`
|X Video Extension Motion Compensation library

|`xxf86dga`
|X DGA Extension

|`xxf86vm`
|X Vidmode Extension
|===

[[uses-xorg-cat]]
== `xorg-cat`

Possible arguments: `app`, `data`, `doc`, `driver`, `font`, `lib`, `proto`, `util`, `xserver` and (none) or one off `autotools` (default), `meson`

Provide support for building Xorg components.
It takes care of setting up common dependencies and an appropriate configuration environment needed.
This is intended only for Xorg components.

The category has to match upstream categories.

The second argument is the build system to use.
autotools is the default, but meson is also supported.

[[uses-zig]]
== `zig`

Possible arguments: (none)

Provide support for building package:lang/zig[] based ports.

The framework exposes the following variables to the port:

`ZIG_TUPLE`::
List of zig dependencies needed to build the port.
Every entry is a triplet of a name, an URL, and a directory where the dependency
is expected to be found.
These triplets can be generated by running:

[source,shell]
....
% make make-zig-tuple
....

[[uses-zip]]
== `zip`

Possible arguments: (none), `infozip`

Indicates that the distribution files use the ZIP compression algorithm.
For files using the InfoZip algorithm the `infozip` argument must be passed to set the appropriate dependencies.
