<a name="common.deps"></a>
<p><code>List of <a href="../build-ref.html#labels">labels</a>; optional</code></p>

<p>
Dependencies for this target. Generally should only list rule targets. (Though
some rules permit files to be listed directly in <code>deps</code>, this
should be avoided when possible.)
</p>

<p>
Language-specific rules generally limit the listed targets to those with
specific <a href="../skylark/rules.html#providers">providers</a>.
</p>

<p>
The precise semantics of what it means for a target to depend on another using
<code>deps</code> are specific to the kind of rule, and the rule-specific
documentation goes into more detail. For rules which process source code,
<code>deps</code> generally specifies code dependencies used by the code in
<a href="#typical.srcs"><code>srcs</code></a>.
</p>

<p>
Most often, a <code>deps</code> dependency is used to allow one module to use
symbols defined in another module written in the same programming language and
separately compiled.  Cross-language dependencies are also permitted in many
cases: For example, a <code>java_library</code> target may depend on C++ code
in a <code>cc_library</code> target, by listing the latter in the
<code>deps</code> attribute.  See the definition of
<a href="../build-ref.html#deps">dependencies</a> for more information.
</p>
