diff --git a/Android.bp b/Android.bp
index ee0ede0..3dd9e47 100644
--- a/Android.bp
+++ b/Android.bp
@@ -39,6 +39,7 @@
     pkgPath: "github.com/google/blueprint",
     srcs: [
         "context.go",
+        "incremental.go",
         "levenshtein.go",
         "glob.go",
         "live_tracker.go",
diff --git a/bootstrap/command.go b/bootstrap/command.go
index 3071e3e..5cff57d 100644
--- a/bootstrap/command.go
+++ b/bootstrap/command.go
@@ -16,10 +16,12 @@
 
 import (
 	"bufio"
+	"encoding/gob"
 	"errors"
 	"fmt"
 	"io"
 	"os"
+	"path/filepath"
 	"runtime"
 	"runtime/debug"
 	"runtime/pprof"
@@ -42,7 +44,8 @@
 	TraceFile  string
 
 	// Debug data json file
-	ModuleDebugFile string
+	ModuleDebugFile         string
+	IncrementalBuildActions bool
 }
 
 // RegisterGoModuleTypes adds module types to build tools written in golang
@@ -127,12 +130,29 @@
 		}
 	}
 
+	if ctx.GetIncrementalAnalysis() {
+		var err error = nil
+		err, ctx.BuildActionFromCache = restoreBuildActions(ctx, config)
+		if err != nil {
+			return nil, fatalErrors([]error{err})
+		}
+	}
+
 	if buildActionsDeps, errs := ctx.PrepareBuildActions(config); len(errs) > 0 {
 		return nil, fatalErrors(errs)
 	} else {
 		ninjaDeps = append(ninjaDeps, buildActionsDeps...)
 	}
 
+	buildActionCachingChan := make(chan error, 1)
+	if ctx.GetIncrementalEnabled() {
+		go func() {
+			buildActionCachingChan <- cacheBuildActions(ctx, config)
+		}()
+	} else {
+		buildActionCachingChan <- nil
+	}
+
 	if args.ModuleDebugFile != "" {
 		ctx.GenerateModuleDebugInfo(args.ModuleDebugFile)
 	}
@@ -192,6 +212,11 @@
 		return nil, proptools.MergeErrors(providerValidationErrors)
 	}
 
+	buildActionCachingError := <-buildActionCachingChan
+	if buildActionCachingError != nil {
+		return nil, buildActionCachingError
+	}
+
 	if args.Memprofile != "" {
 		f, err := os.Create(blueprint.JoinPath(ctx.SrcDir(), args.Memprofile))
 		if err != nil {
@@ -204,6 +229,33 @@
 	return ninjaDeps, nil
 }
 
+func cacheBuildActions(ctx *blueprint.Context, config interface{}) error {
+	file, err := os.Create(filepath.Join(ctx.SrcDir(), config.(BootstrapConfig).SoongOutDir(), blueprint.BuildActionsCacheFile))
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	encoder := gob.NewEncoder(file)
+	return encoder.Encode(&ctx.BuildActionToCache)
+}
+
+func restoreBuildActions(ctx *blueprint.Context, config interface{}) (error, blueprint.BuildActionCache) {
+	var cache = make(blueprint.BuildActionCache)
+	file, err := os.Open(filepath.Join(ctx.SrcDir(), config.(BootstrapConfig).SoongOutDir(), blueprint.BuildActionsCacheFile))
+	if err != nil {
+		if os.IsNotExist(err) {
+			err = nil
+		}
+		return err, nil
+	}
+	defer file.Close()
+
+	decoder := gob.NewDecoder(file)
+	err = decoder.Decode(&cache)
+	return err, cache
+}
+
 func fatalErrors(errs []error) error {
 	red := "\x1b[31m"
 	unred := "\x1b[0m"
diff --git a/context.go b/context.go
index 1591b3c..7f57327 100644
--- a/context.go
+++ b/context.go
@@ -53,6 +53,8 @@
 
 const OutFilePermissions = 0666
 
+const BuildActionsCacheFile = "build_actions.gob"
+
 // A Context contains all the state needed to parse a set of Blueprints files
 // and generate a Ninja file.  The process of generating a Ninja file proceeds
 // through a series of four phases.  Each phase corresponds with a some methods
@@ -157,6 +159,15 @@
 	includeTags *IncludeTags
 
 	sourceRootDirs *SourceRootDirs
+
+	incrementalAnalysis bool
+
+	incrementalEnabled bool
+
+	BuildActionToCache     BuildActionCache
+	BuildActionToCacheLock sync.Mutex
+
+	BuildActionFromCache BuildActionCache
 }
 
 // A container for String keys. The keys can be used to gate build graph traversal
@@ -485,6 +496,7 @@
 		requiredNinjaMinor:          7,
 		requiredNinjaMicro:          0,
 		verifyProvidersAreUnchanged: true,
+		BuildActionToCache:          make(BuildActionCache),
 	}
 }
 
@@ -607,6 +619,37 @@
 	c.nameInterface = i
 }
 
+func (c *Context) SetIncrementalAnalysis(incremental bool) {
+	c.incrementalAnalysis = incremental
+}
+
+func (c *Context) GetIncrementalAnalysis() bool {
+	return c.incrementalAnalysis
+}
+
+func (c *Context) SetIncrementalEnabled(incremental bool) {
+	c.incrementalEnabled = incremental
+}
+
+func (c *Context) GetIncrementalEnabled() bool {
+	return c.incrementalEnabled
+}
+
+func (c *Context) CacheBuildActions(key *BuildActionCacheKey, data *BuildActionCachedData) {
+	if key != nil {
+		c.BuildActionToCacheLock.Lock()
+		defer c.BuildActionToCacheLock.Unlock()
+		c.BuildActionToCache[*key] = data
+	}
+}
+
+func (c *Context) GetBuildActionCache(key *BuildActionCacheKey) *BuildActionCachedData {
+	if c.BuildActionFromCache != nil && key != nil {
+		return c.BuildActionFromCache[*key]
+	}
+	return nil
+}
+
 func (c *Context) SetSrcDir(path string) {
 	c.srcDir = path
 	c.fs = pathtools.NewOsFs(path)
diff --git a/incremental.go b/incremental.go
new file mode 100644
index 0000000..29533b9
--- /dev/null
+++ b/incremental.go
@@ -0,0 +1,70 @@
+// Copyright 2024 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package blueprint
+
+type BuildActionCacheKey struct {
+	Id        string
+	InputHash uint64
+}
+
+type CachedBuildParams struct {
+	Comment         string
+	Depfile         string
+	Deps            Deps
+	Description     string
+	Rule            string
+	Outputs         []string
+	ImplicitOutputs []string
+	Inputs          []string
+	Implicits       []string
+	OrderOnly       []string
+	Validations     []string
+	Args            map[string]string
+	Optional        bool
+}
+
+type CachedBuildActions struct {
+	BuildParams []CachedBuildParams
+}
+
+type CachedProvider struct {
+	Id    *providerKey
+	Value *any
+}
+
+type BuildActionCachedData struct {
+	BuildActions CachedBuildActions
+	Providers    []CachedProvider
+}
+
+type BuildActionCache = map[BuildActionCacheKey]*BuildActionCachedData
+
+type BuildActionCacheInput struct {
+	PropertiesHash uint64
+	ProvidersHash  [][]uint64
+}
+
+type Incremental interface {
+	IncrementalSupported() bool
+	BuildActionProviderKeys() []AnyProviderKey
+	PackageContextPath() string
+	CachedRules() []Rule
+}
+
+type IncrementalModule struct{}
+
+func (m *IncrementalModule) IncrementalSupported() bool {
+	return true
+}
diff --git a/module_ctx.go b/module_ctx.go
index 920b74e..08993c2 100644
--- a/module_ctx.go
+++ b/module_ctx.go
@@ -361,6 +361,12 @@
 
 	EarlyGetMissingDependencies() []string
 
+	GetIncrementalEnabled() bool
+
+	GetIncrementalAnalysis() bool
+
+	OtherModuleProviderInitialValueHashes(module Module) []uint64
+
 	base() *baseModuleContext
 }
 
@@ -373,6 +379,8 @@
 	// to ensure that each variant of a module gets its own intermediates directory to write to.
 	ModuleSubDir() string
 
+	ModuleId() string
+
 	// Variable creates a new ninja variable scoped to the module.  It can be referenced by calls to Rule and Build
 	// in the same module.
 	Variable(pctx PackageContext, name, value string)
@@ -387,6 +395,10 @@
 	// but do not exist.  It can be used with Context.SetAllowMissingDependencies to allow the primary builder to
 	// handle missing dependencies on its own instead of having Blueprint treat them as an error.
 	GetMissingDependencies() []string
+
+	CacheBuildActions(key *BuildActionCacheKey, im *Incremental)
+
+	RestoreBuildActions(key *BuildActionCacheKey, im *Incremental) bool
 }
 
 var _ BaseModuleContext = (*baseModuleContext)(nil)
@@ -498,6 +510,7 @@
 	scope              *localScope
 	actionDefs         localBuildActions
 	handledMissingDeps bool
+	buildParams        []BuildParams
 }
 
 func (m *baseModuleContext) OtherModuleName(logicModule Module) string {
@@ -610,6 +623,104 @@
 	m.context.setProvider(m.module, provider.provider(), value)
 }
 
+func (m *baseModuleContext) GetIncrementalEnabled() bool {
+	return m.context.GetIncrementalEnabled()
+}
+
+func (m *baseModuleContext) GetIncrementalAnalysis() bool {
+	return m.context.GetIncrementalAnalysis()
+}
+
+func (m *baseModuleContext) OtherModuleProviderInitialValueHashes(module Module) []uint64 {
+	return m.context.moduleInfo[module].providerInitialValueHashes
+}
+
+func (m *moduleContext) CacheBuildActions(key *BuildActionCacheKey, im *Incremental) {
+	var providers []CachedProvider
+	for _, pKey := range (*im).BuildActionProviderKeys() {
+		if pKey.provider().mutator == "" {
+			providers = append(providers,
+				CachedProvider{
+					Id: &providerKey{
+						id:      pKey.provider().id,
+						typ:     pKey.provider().typ,
+						mutator: pKey.provider().mutator,
+					},
+					Value: &m.module.providers[pKey.provider().id],
+				})
+		}
+	}
+
+	var buildParams []CachedBuildParams
+	for _, params := range m.buildParams {
+		buildParams = append(buildParams, CachedBuildParams{
+			Comment:         params.Comment,
+			Depfile:         params.Depfile,
+			Deps:            params.Deps,
+			Description:     params.Description,
+			Rule:            params.Rule.name(),
+			Outputs:         params.Outputs,
+			ImplicitOutputs: params.ImplicitOutputs,
+			Inputs:          params.Inputs,
+			Implicits:       params.Implicits,
+			OrderOnly:       params.OrderOnly,
+			Validations:     params.Validations,
+			Args:            params.Args,
+			Optional:        params.Optional,
+		})
+	}
+
+	if len(providers) > 0 || len(buildParams) > 0 {
+		data := BuildActionCachedData{
+			Providers: providers,
+			BuildActions: CachedBuildActions{
+				BuildParams: buildParams,
+			},
+		}
+		m.context.CacheBuildActions(key, &data)
+	}
+}
+
+func (m *moduleContext) RestoreBuildActions(key *BuildActionCacheKey, im *Incremental) bool {
+	data := m.context.GetBuildActionCache(key)
+	if data != nil {
+		for _, provider := range data.Providers {
+			m.context.setProvider(m.module, provider.Id, *provider.Value)
+		}
+
+		for _, params := range data.BuildActions.BuildParams {
+			var rule Rule
+			for _, r := range (*im).CachedRules() {
+				if params.Rule == r.name() {
+					rule = r
+					break
+				}
+			}
+			if rule == nil {
+				return false
+			}
+			buildParams := BuildParams{
+				Comment:         params.Comment,
+				Depfile:         params.Depfile,
+				Deps:            params.Deps,
+				Description:     params.Description,
+				Outputs:         params.Outputs,
+				ImplicitOutputs: params.ImplicitOutputs,
+				Inputs:          params.Inputs,
+				Implicits:       params.Implicits,
+				OrderOnly:       params.OrderOnly,
+				Validations:     params.Validations,
+				Args:            params.Args,
+				Optional:        params.Optional,
+			}
+			buildParams.Rule = rule
+			m.Build(packageContexts[(*im).PackageContextPath()], buildParams)
+		}
+		return true
+	}
+	return false
+}
+
 func (m *baseModuleContext) GetDirectDep(name string) (Module, DependencyTag) {
 	for _, dep := range m.module.directDeps {
 		if dep.module.Name() == name {
@@ -761,6 +872,10 @@
 	return m.module.variant.name
 }
 
+func (m *moduleContext) ModuleId() string {
+	return strings.Join([]string{m.ModuleDir(), m.ModuleName(), m.module.variant.name, m.ModuleType()}, "$")
+}
+
 func (m *moduleContext) Variable(pctx PackageContext, name, value string) {
 	m.scope.ReparentTo(pctx)
 
@@ -795,6 +910,11 @@
 		panic(err)
 	}
 
+	if m.GetIncrementalEnabled() {
+		if im, ok := m.module.logicModule.(Incremental); ok && im.IncrementalSupported() {
+			m.buildParams = append(m.buildParams, params)
+		}
+	}
 	m.actionDefs.buildDefs = append(m.actionDefs.buildDefs, def)
 }
 
diff --git a/provider.go b/provider.go
index b2e0876..5d63e39 100644
--- a/provider.go
+++ b/provider.go
@@ -15,6 +15,9 @@
 package blueprint
 
 import (
+	"bytes"
+	"encoding/gob"
+	"errors"
 	"fmt"
 
 	"github.com/google/blueprint/proptools"
@@ -53,6 +56,28 @@
 	mutator string
 }
 
+func (m *providerKey) GobEncode() ([]byte, error) {
+	w := new(bytes.Buffer)
+	encoder := gob.NewEncoder(w)
+	err := errors.Join(encoder.Encode(m.id), encoder.Encode(m.typ), encoder.Encode(m.mutator))
+	if err != nil {
+		return nil, err
+	}
+
+	return w.Bytes(), nil
+}
+
+func (m *providerKey) GobDecode(data []byte) error {
+	r := bytes.NewBuffer(data)
+	decoder := gob.NewDecoder(r)
+	err := errors.Join(decoder.Decode(&m.id), decoder.Decode(&m.typ), decoder.Decode(&m.mutator))
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func (p *providerKey) provider() *providerKey { return p }
 
 type AnyProviderKey interface {