Skip to content
Temporary home for experimental new version of HCL
Branch: master
Clone or download
apparentlymart ext/dynblock: Allow interrogation of _all_ references in blocks
Our API previously had a function only for retrieving the variables used
in the for_each and labels arguments used during an Expand call, and
expected callers to then interrogate the resulting expanded block to find
the other variables required to fully decode the content.

That approach is insufficient for any application that needs to know the
full set of required variables before any evaluation begins, such as when
a dependency graph will be constructed to allow a topological traversal
through blocks while evaluating.

Now we have WalkVariables, which finds both the variables used to expand
_and_ the variables within any blocks. This also renames
WalkForEachVariables to WalkExpandVariables since that name is more
accurate with the addition of the "label" argument into the expand-time
dependency set.

There is also a hcldec-based helper wrapper for each of those, allowing
single-shot analysis of blocks for applications that use hcldec.

This is a breaking change to the dynblock package API, because the old
WalkForEachVariables and ForEachVariablesHCLDec functions are no longer
Latest commit f9f92da Mar 19, 2019
Type Name Latest commit message Commit time
Failed to load latest commit information.
cmd cmd/hclspecsuite: Generate correct ranges in diagnostic-diagnostics Dec 14, 2018
ext ext/dynblock: Allow interrogation of _all_ references in blocks Mar 18, 2019
extras/grammar update go.mod (#60) Nov 29, 2018
gohcl gohcl: EncodeIntoBody and EncodeAsBlock functions Nov 4, 2018
guide guide: A section on input file naming conventions Sep 5, 2018
hcl json: Eval json null values as cty.Null (#90) Mar 5, 2019
hcled hcled: Introduce ContextDefRange (#58) Nov 26, 2018
hclparse hclparse: rename ParseZCL to ParseHCL Sep 12, 2017
hcltest Fix "attribute" vs "argument" terminology in diagnostics Jul 18, 2018
hclwrite hclwrite: heredoc tokens are in line.lead, not line.assign (#95) Mar 15, 2019
specsuite build: capture code coverage stats during Travis-CI run Jun 2, 2017
.travis.yml build: test with Go 1.9.x Sep 12, 2017
LICENSE README: Clarify that HCL is just syntax Jan 27, 2018
go.sum dependencies: go get Jan 24, 2019


HCL is a toolkit for creating structured configuration languages that are both human- and machine-friendly, for use with command-line tools. Although intended to be generally useful, it is primarily targeted towards devops tools, servers, etc.

HCL has both a native syntax, intended to be pleasant to read and write for humans, and a JSON-based variant that is easier for machines to generate and parse.

The HCL native syntax is inspired by libucl, nginx configuration, and others.

It includes an expression syntax that allows basic inline computation and, with support from the calling application, use of variables and functions for more dynamic configuration languages.

HCL provides a set of constructs that can be used by a calling application to construct a configuration language. The application defines which attribute names and nested block types are expected, and HCL parses the configuration file, verifies that it conforms to the expected structure, and returns high-level objects that the application can use for further processing.

Experimental HCL2

This repository contains the experimental version 2 of HCL. This new version combines the initial iteration of HCL with the interpolation language HIL to produce a single configuration language that supports arbitrary expressions.

At this time the HCL2 syntax and the Go API are still evolving. Backward-compatibility is not guaranteed and so any application using this library should use vendoring.

The new implementation has a completely new parser and Go API, with no direct migration path. Although the syntax is similar, the implementation takes some very different approaches to improve on some "rough edges" that existed with the original implementation and to allow for more robust error handling.

Once this new implementation reaches stability, its package paths will be changed to reflect that it is the current HCL implementation. At that time, the original implementation will be archived.


Newcomers to HCL often ask: why not JSON, YAML, etc?

Whereas JSON and YAML are formats for serializing data structures, HCL is a syntax and API specifically designed for building structured configuration formats.

HCL attempts to strike a compromise between generic serialization formats such as JSON and configuration formats built around full programming languages such as Ruby. HCL syntax is designed to be easily read and written by humans, and allows declarative logic to permit its use in more complex applications.

HCL is intended as a base syntax for configuration formats built around key-value pairs and heirarchical blocks whose structure is well-defined by the calling application, and this definition of the configuration structure allows for better error messages and more convenient definition within the calling application.

It can't be denied that JSON is very convenient as a lingua franca for interoperability between different pieces of software. Because of this, HCL defines a common configuration model that can be parsed from either its native syntax or from a well-defined equivalent JSON structure. This allows configuration to be provided as a mixture of human-authored configuration files in the native syntax and machine-generated files in JSON.

Information Model and Syntax

HCL is built around two primary concepts: attributes and blocks. In native syntax, a configuration file for a hypothetical application might look something like this:

io_mode = "async"

service "http" "web_proxy" {
  listen_addr = ""
  process "main" {
    command = ["/usr/local/bin/awesome-app", "server"]

  process "mgmt" {
    command = ["/usr/local/bin/awesome-app", "mgmt"]

The JSON equivalent of this configuration is the following:

  "io_mode": "async",
  "service": {
    "http": {
      "web_proxy": {
        "listen_addr": "",
        "process": {
          "main": {
            "command": ["/usr/local/bin/awesome-app", "server"]
          "mgmt": {
            "command": ["/usr/local/bin/awesome-app", "mgmt"]

Regardless of which syntax is used, the API within the calling application is the same. It can either work directly with the low-level attributes and blocks, for more advanced use-cases, or it can use one of the decoder packages to declaratively extract into either Go structs or dynamic value structures.

Attribute values can be expressions as well as just literal values:

# Arithmetic with literals and application-provided variables
sum = 1 + addend

# String interpolation and templates
message = "Hello, ${name}!"

# Application-provided functions
shouty_message = upper(message)

Although JSON syntax doesn't permit direct use of expressions, the interpolation syntax allows use of arbitrary expressions within JSON strings:

  "sum": "${1 + addend}",
  "message": "Hello, ${name}!",
  "shouty_message": "${upper(message)}"

For more information, see the detailed specifications:


HCL was heavily inspired by libucl, by Vsevolod Stakhov.

HCL and HIL originate in HashiCorp Terraform, with the original parsers for each written by Mitchell Hashimoto.

The original HCL parser was ported to pure Go (from yacc) by Fatih Arslan. The structure-related portions of the new native syntax parser build on that work.

The original HIL parser was ported to pure Go (from yacc) by Martin Atkins. The expression-related portions of the new native syntax parser build on that work.

HCL2, which merged the original HCL and HIL languages into this single new language, builds on design and prototyping work by Martin Atkins in zcl.

You can’t perform that action at this time.