Live Values & Results for Terraform

Polski · Release history

See the values your Terraform code produces while you edit it. Select an expression or place the cursor in it to inspect the result in VS Code, including changes you have not saved.

The preview covers variables, locals, function calls, collection transformations, local-module outputs and configured resource arguments. It uses your code and selected inputs. You can check a for filter, follow a value through modules or inspect arguments for a for_each instance without adding a debug output or running a plan.

Current release: 0.0.13. The extension ID is bryn1u.valuescope-iac; settings use the valuescope.* prefix.

Author: Michal 'bryn1u' Bryniarski · michal.bryniarski@gmail.com.

If you have the older local extension valuescope.valuescope-iac, disable or uninstall it before using the Marketplace release. The new identifier creates a separate installation. The valuescope.* settings remain compatible, but selections and secrets stored by the previous extension do not migrate automatically.

Start with a value

1. Install Live Values & Results for Terraform by bryn1u from the VS Code Extensions view. To install a local package, use Extensions: Install from VSIX….
2. Open the folder containing your Terraform configuration.
3. If your inputs are in a file such as environment/prod.tfvars, choose it with tfvars file in the results panel.
4. Place the cursor in an expression and press Ctrl+Alt+V (Cmd+Alt+V on macOS). You can also select an expression, hover over it or click Preview above a supported block.

The panel follows your selection. Pin a result to keep inspecting the same source while you move through the code. You can resize the panel, wrap long values and copy the displayed result.

The package includes the calculation engine. Using it requires VS Code 1.90 or later; Go, Node.js and Terraform CLI are not needed. Match the package to the operating system and architecture of your VS Code installation.

VS Code selects the Marketplace package for your operating system and architecture. macOS requires version 13 or later.

All four packages include the variable declaration preview fix. Version 0.0.13 passed VS Code integration tests on Linux. Windows and macOS packages are cross-compiled with archive checks; this release has not been run on those systems.

Linux: an exhausted inotify limit can leave previews showing old values after files change on disk. If your limit is 128, consider increasing it to 1024 on a busy development machine. See Linux: inotify for the explanation and commands.

Demo videos

Both walkthroughs go from the simplest examples to more complex Terraform configurations: variables and locals, collection functions, resource instances, then module outputs. Click markers show where to look, and a border highlights the result. Each recording is about seven minutes long, with captions and no voice-over.

Watch in Polish · English video description

Download the original English MP4 · Download the original Polish MP4

The recordings show version 0.0.11. This release is version 0.0.13.

An example

variable "routes" {
  default = {
    internet = { enabled = true,  prefix = "0.0.0.0/0" }
    internal = { enabled = false, prefix = "10.0.0.0/8" }
  }
}

locals {
  enabled_routes = {
    for name, route in var.routes :
    name => route
    if route.enabled
  }
}

Inspect local.enabled_routes. The result contains internet; the filter removes internal. Change an enabled flag and inspect it again. The next calculation uses the current editor buffer, even before you save.

The same workflow works for supported calls such as merge, flatten, concat and zipmap. For repeated resources, choose an instance to inspect its each.key, each.value or count.index.

What a preview contains

A resource preview describes configuration from code. Provider defaults, generated IDs and the resource's actual cloud state are outside this view. The module header shows existing outputs; it does not list every resource in the module.

In a variable declaration, the header, the type constraint and a selection of the whole block show the variable's value for the current inputs and module context. You can inspect an expression inside default separately; its result may differ from the value overridden by tfvars.

For a direct reference whose value cannot be calculated, the preview may show its target, for example <reference: azurerm_route_table.this["management"].id>. A locally known public name can appear beside it. That tells you where the reference leads without inventing an ID.

Whole-resource expressions still require a complete provider shape. A module preview can therefore show configured fields while jsonencode(module.network.whole_resource) remains unavailable. Configuration previews do not turn partial objects into complete Terraform values.

When a value is incomplete

The panel shows the reason and the affected path. A missing variable, an invalid expression and an unsupported function need different fixes. Without provider schema information, a field may be unavailable even if Terraform could evaluate it with that information. A field named id is not assumed to be a known string.

An error outside the inspected expression's dependencies should not block its result. Large values are shortened for display and marked as truncated; hidden elements still contribute to the reported status. When the engine cannot trace an unresolved value precisely through a transformation, the result says so.

Choose inputs and context

The extension automatically reads root-level terraform.tfvars, terraform.tfvars.json and ordered *.auto.tfvars / *.auto.tfvars.json files. Other files must be selected explicitly. Choosing a tfvars directory changes the file picker, not the active environment. The default directory is environment under the root module.

The selected file is remembered locally for each root module. In a trusted workspace you can explicitly select one local tfvars file outside the workspace. This does not grant access to its entire directory or extend access for file() and templatefile().

Profiles combine named sets of inputs. For example:

{
  "valuescope.profiles": [
    {
      "id": "lab",
      "name": "Local lab",
      "varFiles": ["environment/lab.tfvars"],
      "vars": {
        "environment": "lab",
        "zones": "[\"a\", \"b\"]"
      }
    }
  ]
}

Input precedence is: defaults, configured TF_VAR_* inputs, automatic root variable files, profile files in order, then explicit profile vars. Strings use plain text; collections use HCL text. Use Set Secret Value for protected inputs. Store only secret names in profile settings.

If a module is called more than once, select the root module, module context and instance you want to inspect. Child inputs are evaluated in the calling instance's context. The preview follows local modules; it does not download remote modules.

Language and editor integration

Use Language in the panel to choose English, Polish or automatic selection. The choice is stored locally. The base setting is valuescope.language: auto, en or pl. Automatic selection uses Polish for a Polish VS Code locale and English otherwise.

Changing language keeps the current result, input file and pin. About opens this guide in the selected language. Command titles and Settings descriptions follow VS Code's own display language; the panel can use a different language. Values, HCL syntax and raw engine diagnostics are preserved.

The extension works alongside your Terraform language extension. It does not change file associations, syntax colours or formatting. It recognises .tf, .tfvars, .tf.json and .tfvars.json filenames as well as Terraform language IDs. A language companion supplies completion and syntax highlighting.

Complete registered function catalogue

The registry contains 118 names: 97 locally implemented functions, 4 deliberately deferred functions and 17 explicitly unsupported functions. These are not 118 fully supported Terraform functions. Implementation within a tested subset is not exhaustive compatibility with every Terraform version, provider or possible input.

Locally implemented: 97

Qualifications:

• try/can distinguish catchable dynamic errors from static errors and tool limitations. A missing schema or unsupported feature is not silently converted to a successful fallback.
• file/templatefile require UTF-8; filebase64 supports binary content. Reads require a trusted workspace, an allowed path and a file of at most 4 MiB. They do not write data.
• Relative file paths and abspath use the root module as evaluation base. path.cwd uses launch-directory context, configurable by a profile. path.root/path.module preserve the tested relative Terraform-style representation.
• templatefile uses supplied variables and the available registry. Recursive template calls are unsupported.
• range follows the library's 1,024-element limit. A known setproduct result is bounded to 10,000 combinations.
• Structural wrappers preserve known leaves and origin paths where supported. formatlist, split, regex/decode operations, setproduct and templatefile can require explicit attribution fallback for unresolved inputs.
• nonsensitive is not a general secret-reveal permission. Declaration marks and recognizable credential-format redaction still apply at presentation boundaries.

Deliberately deferred: 4

Explicitly unsupported: 17

base64gzip, cidrcontains, cidrhost, cidrnetmask, cidrsubnet, cidrsubnets, fileset, matchkeys, pathexpand, rsadecrypt, templatestring, textdecodebase64, textencodebase64, timecmp, uuidv5, yamldecode, yamlencode.

These produce an explicit tool limitation. Provider-defined functions are not executed. Unregistered names are not supported merely because they are valid in some Terraform version.

Commands

IDs are stable across languages. Palette titles follow VS Code's locale; descriptions below name the actions.

Settings

Local calculation and privacy

The engine calculates values on your computer. Previewing code does not run Terraform, a provider, a backend or a cloud query. Your code, tfvars and results stay on your computer. The extension reads your Terraform files; input selections and interface preferences are stored separately in VS Code.

Secret inputs use VS Code SecretStorage. Values marked sensitive or ephemeral are protected in the displayed result and reference details. Recognisable credential formats are also masked, but patterns cannot identify every secret. The copy action copies the displayed, redacted value. Logs contain event codes rather than expressions or raw RPC messages.

File access is restricted in untrusted workspaces. The bundled engine checksum and version handshake detect changed or mismatched files; they do not replace publisher signing.

Limits and unsupported workflows

The deadline is cooperative. An extreme HCL expression can require an engine restart; this is not a complete sandbox against malicious workloads. Outlines may repeat an edge when a very long boundary line wraps, a limitation of VS Code's stable decoration API.

The evaluator is not restricted to Azure resource names: it works with HCL values and configured arguments. Azure examples reflect the workflows exercised most directly, not comprehensive certification of Azure, AWS, Google Cloud or another provider.

Troubleshooting

Linux: inotify

inotify delivers Linux file and directory change notifications. The fs.inotify.max_user_instances limit is shared by applications running under the same user account. A value of 128 means 128 instances, each able to watch many paths. The separate fs.inotify.max_user_watches setting limits watched paths. Linux documentation.

The extension uses VS Code file events to detect changes to Terraform files, selected tfvars and dependencies of file() or templatefile(). If VS Code cannot start the required watcher, a disk edit can leave the preview showing an earlier result. Typing in an open Terraform document may still update it through editor events, so that alone does not prove disk watching works.

An EMFILE error in file-watcher logs can mean the instance limit is exhausted; it can also mean a process has exhausted its file descriptors. Check the logs before attributing every stale result to inotify. Error definitions.

If your instance limit is 128 and several applications are using file watchers, consider increasing it to 1024. This resolved watcher failures in our Linux tests. The value is a starting point, not a requirement for every computer. Keep a higher existing limit.

Check your settings and note the original value:

sysctl fs.inotify.max_user_instances fs.inotify.max_user_watches

If the instance limit is lower than 1024, an administrator can change it for the current boot:

sudo sysctl -w fs.inotify.max_user_instances=1024

This command does not save a boot-time setting. After a temporary test, restore your recorded value with sudo sysctl -w fs.inotify.max_user_instances=VALUE. sysctl commands.

To keep 1024 after reboot on a system using sysctl.d, open the local configuration file:

sudoedit /etc/sysctl.d/90-live-values-results-inotify.conf

Add or update this line, then save:

fs.inotify.max_user_instances = 1024

Apply that file and verify the active value:

sudo sysctl -p /etc/sysctl.d/90-live-values-results-inotify.conf
sysctl fs.inotify.max_user_instances

Other system settings can override this value at boot; verify it after restarting Linux. See sysctl.d configuration.

Restart VS Code after changing the limit and check a preview after editing a dependency on disk. The extension does not change system limits automatically.

Licenses

From version 0.0.12, the original application is distributed under a proprietary license. You may use official releases free of charge for personal and commercial work; modification and redistribution of the original application are restricted as stated in that license.

Third-party libraries retain their own licenses: notices and source availability. The package includes the unmodified HCL source archive required for its MPL-2.0 components. The application development sources are private.

Live Values & Results for Terraform is not affiliated with, endorsed by or sponsored by HashiCorp. Terraform is a HashiCorp trademark. Compatibility descriptions identify the language and do not imply an official relationship.