Terraform is logically split into two main parts: Terraform Core and Terraform Plugins. Terraform Core is the Terraform binary that communicates with plugins to manage infrastructure resources. It provides a common interface that allows you to leverage many different cloud providers, databases, services, and in-house solutions. Terraform Plugins are executable binaries written in Go that communicate with Terraform Core over an RPC interface. Terraform currently supports one type of plugin called providers. Each provider plugin exposes an implementation for a specific service or tool, such as the AWS provider or the cloud-init provider.
Plugin development for Terraform focuses on designing, developing, and testing plugins that connect Terraform to external services. Learning how Terraform Core interacts with plugins is a central part of that work. The design principles HashiCorp developers follow when creating providers guide decisions about resource schemas, state handling, and lifecycle management. Plugin framework benefits and why we recommend using it to develop providers are documented as part of the official guidance. Hands-on tutorials exist for implementing a Provider with the Terraform Plugin Framework. Template repositories on GitHub such as terraform-provider-scaffolding-framework can be cloned to start new work. Creating new providers with the framework documentation, maintaining existing providers with the SDKv2 documentation, publishing your provider on the Terraform Registry to make it publicly available, and getting HashiCorp to officially approve and verify your provider are all steps in the provider lifecycle.
Core Architecture and Provider Model
Terraform Core acts as gRPC client. It interacts with the user, parses HCL/JSON configuration, manages state as whole, asks Provider(s) to mutate provider-specific parts of state, handles backends & provisioners, handles inputs, outputs, modules, and functions, discovers Provider(s) and their versions per configuration, and manages Provider(s) lifecycle.
The plugin model is provider-centric. Providers are the only plugin type Terraform users interact with. Refer to Providers in the Terraform language docs for additional information about providers.
When you initialize a working directory, Terraform installs any providers the Terraform configuration requires. Provider Requirements in the Terraform configuration language information about requiring providers. Refer to the terraform init command documentation for additional information about how initialize the working directory.
By default, Terraform initializes the working directory without any additional interaction, but you must have network access to download providers from their source registry. You can configure Terraform's provider installation behavior to limit or skip network access, and to enable use of providers that are not available through a networked source. Terraform also includes commands that show information about providers and commands that reduce the effort of installing providers in air-gapped environments.
Terraform's configuration file includes options for caching downloaded plugins, or explicitly specifying a local or HTTPS mirror to install plugins from.
Provider Plugin Development and Framework
Plugin development is the process of building executable binaries written in Go that communicate with Terraform Core over an RPC interface. Terraform currently supports one type of plugin called providers. Each provider plugin exposes an implementation for a specific service or tool, such as the AWS provider or the cloud-init provider.
Key learning paths include:
- Learn more about how Terraform Core interacts with plugins
- Learn the design principles HashiCorp developers follow when creating providers
- Learn about plugin framework benefits and why we recommend using it to develop providers
- Try these hands-on tutorials: Implement a Provider with the Terraform Plugin Framework
- Clone these template repositories on GitHub: terraform-provider-scaffolding-framework
- Create new providers with the framework documentation
- Maintain existing providers with the SDKv2 documentation
- Publish your provider on the Terraform Registry to make it publicly available
- Get HashiCorp to officially approve and verify your provider
The Terraform Plugin Framework is a reimagined provider SDK that supports additional capabilities. For new provider development it is recommended to investigate terraform-plugin-framework.
Terraform Plugin SDK
The SDK enables building Terraform plugin which allows Terraform's users to manage existing and popular service providers as well as custom in-house solutions. The SDK is stable and broadly used across the provider ecosystem.
For new provider development it is recommended to investigate terraform-plugin-framework, which is a reimagined provider SDK that supports additional capabilities. Refer to the Which SDK Should I Use? documentation for more information about differences between SDKs.
Version requirements are important:
- Terraform 0.12.0 or later is needed for version 2.0.0 and later of the Plugin SDK
- When running provider tests, Terraform 0.12.26 or later is needed for version 2.0.0 and later of the Plugin SDK. Users can still use any version after 0.12.0
Go support follows the support policy of Go as its support policy. The two latest major releases of Go are supported by the project. Currently, that means Go 1.25 or later must be used when including this project as a dependency.
See Extending Terraform section on the website for additional context.
The SDK acts as gRPC client, interacts with the user, parses HCL/JSON configuration, manages state as whole, asks Provider(s) to mutate provider-specific parts of state, handles backends & provisioners, handles inputs, outputs, modules, and functions, discovers Provider(s) and their versions per configuration, manages Provider(s) lifecycle.
SDK Requirements Summary
| Item | Requirement |
|---|---|
| Terraform for SDK v2.0.0+ | 0.12.0 or later |
| Terraform for SDK v2.0.0+ tests | 0.12.26 or later |
| Go for SDK dependency | 1.25 or later |
| Supported Go policy | Two latest major releases |
Managing Provider Plugins
Manage plugins overview provides an overview of the how to manage plugins that Terraform relies on to manage various types of resources. Providers are the only plugin type Terraform users interact with.
Provider installation behavior can be configured:
- Limit or skip network access
- Enable use of providers that are not available through a networked source
- Cache downloaded plugins
- Explicitly specify a local or HTTPS mirror to install plugins from
Commands exist to show information about providers and commands that reduce the effort of installing providers in air-gapped environments.
TFLint as a Pluggable Linter
TFLint is a framework and each feature is provided by plugins, the key features are as follows:
- Find possible errors like invalid instance types for Major Cloud providers AWS/Azure/GCP
- Warn about deprecated syntax, unused declarations
- Enforce best practices, naming conventions
The TFLint Ruleset for Terraform Language is bundled with TFLint, so you can use it without installing it separately. The bundled plugin enables the "recommended" preset by default, but you can disable the plugin or use a different preset.
Declare the plugin block in .tflint.hcl like this:
plugin "terraform" {
enabled = true
preset = "recommended"
}
See the tflint-ruleset-terraform documentation for more information.
If you are using an AWS/Azure/GCP provider, it is a good idea to install the plugin and try it according to each usage.
If you want to extend TFLint with other plugins, you can declare the plugins in the config file and easily install them with tflint --init.
plugin "foo" {
enabled = true
version = "0.1.0"
source = "github.com/org/tflint-ruleset-foo"
}
See also Configuring Plugins.
You can discover plugins from other organizations on GitHub via the tflint-ruleset topic.
TFLint inspects files under the current directory by default.
Installation options for TFLint are documented with verification steps.
curl -sSLO https://github.com/terraform-linters/tflint/releases/latest/download/tflint_linux_amd64.zip
curl -sSLO https://github.com/terraform-linters/tflint/releases/latest/download/checksums.txt
gh attestation verify checksums.txt -R terraform-linters/tflint
sha256sum --ignore-missing -c checksums.txt
unzip tflint_linux_amd64.zip
sudo install -c -v tflint /usr/local/bin/
Homebrew macOS:
brew install terraform-linters/tap/tflint
WinGet Windows:
winget install -e --id TerraformLinters.tflint
Go:
go install github.com/terraform-linters/tflint@latest
Artifact Attestations are available that can be verified using the GitHub CLI.
gh attestation verify checksums.txt -R terraform-linters/tflint
sha256sum --ignore-missing -c checksums.txt
Warning: Cosign signatures are now deprecated.
Minecraft Terraform Plugins
The term Terraform is also used in the Minecraft modding community for world generation and editing tools.
TerraformGenerator is a world generator plugin that aims to provide an enhanced vanilla feel. The world is playable with all vanilla items obtainable, though thorough testing is recommended before deploying it to a production environment. Pregeneration will take a while as the plugin generates more slowly than vanilla, making small mistakes difficult to fix later on.
There are commands, but they are developer commands and only available via /op. Try not to use them unless you understand what they do.
Source Code for TerraformGenerator is available at https://github.com/Hex27/terraformgenerator.
Native Major MC Version is 1.21.
TerraformGenerator is free, and will stay free. There is a premium version that is also on spigot, but note that that version is the exact same thing.
Support Discord is https://discord.gg/yW7JcqM.
Wiki is https://github.com/Hex27/TerraformGenerator/wiki.
Version compatibility notes:
- TerraformGenerator v13.0.0 does not support anything below 1.18.2. To use TerraformGenerator with 1.16 and 1.17 or 1.18.1, use the version: https://www.spigotmc.org/resources/terraformgenerator-1-18-2-1-20-4.75132/download?version=521877 version 12.0.0
- TerraformGenerator v6.0.0 does not support anything below 1.16.5 anymore
Terraformer is described as a Minecraft World Editing Plugin.
Creators provide a Discord server link to see the current progress on the mod.
The author notes annoyance of how the current mods work, so wanted to create an all in one terraforming tool for minecraft builders. Focus is on making this tool as easy to use as possible, as well as extremely powerfull and with no limitations.
Conclusion
The Terraform plugin ecosystem spans official HashiCorp infrastructure providers and a broad community of tooling extensions. Terraform Core communicates with provider plugins over an RPC interface, with providers being the only plugin type users interact with. Provider development is supported by two main SDK paths: the stable Terraform Plugin SDK and the newer Terraform Plugin Framework, with clear version requirements for Terraform and Go.
Management of provider plugins is handled through terraform init, with configuration options for caching, mirrors, and air-gapped environments. The plugin model is extended beyond providers through tools like TFLint, which is itself a pluggable linter framework with a bundled Terraform ruleset and a plugin declaration model in .tflint.hcl.
Outside of infrastructure, the Terraform name is reused in Minecraft modding for world generation and editing. TerraformGenerator offers an enhanced vanilla feel world generator for Minecraft Java Edition 1.21 with specific version compatibility constraints and a free premium model, while Terraformer positions itself as an all-in-one terraforming tool focused on ease of use and power for builders.
Understanding the separation between Terraform Core responsibilities and provider plugin responsibilities, the SDK requirements, and the management of plugins is essential for reliable infrastructure automation. The same plugin concepts appear in adjacent ecosystems such as linting and game modding, demonstrating how the plugin architecture pattern scales across domains.