diff --git a/.github/workflows/nix.yml b/.github/workflows/nix.yml
index 62da55672a..cb62f54ee3 100644
--- a/.github/workflows/nix.yml
+++ b/.github/workflows/nix.yml
@@ -17,9 +17,9 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-      - name: Pull musl
+      - name: Pull musl, bdwgc
         run: |
-            git submodule update --init lib/musl
+            git submodule update --init lib/musl lib/bdwgc
       - name: Restore LLVM source cache
         uses: actions/cache/restore@v4
         id: cache-llvm-source
diff --git a/.gitmodules b/.gitmodules
index 4a8820e3a6..1abcc773ff 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -42,3 +42,6 @@
 [submodule "lib/wasi-cli"]
 	path = lib/wasi-cli
 	url = https://github.com/WebAssembly/wasi-cli
+[submodule "lib/bdwgc"]
+	path = lib/bdwgc
+	url = https://github.com/ivmai/bdwgc.git
diff --git a/GNUmakefile b/GNUmakefile
index 94d9c357d2..7c3848fed7 100644
--- a/GNUmakefile
+++ b/GNUmakefile
@@ -850,6 +850,7 @@ wasmtest:
 
 build/release: tinygo gen-device wasi-libc $(if $(filter 1,$(USE_SYSTEM_BINARYEN)),,binaryen)
 	@mkdir -p build/release/tinygo/bin
+	@mkdir -p build/release/tinygo/lib/bdwgc
 	@mkdir -p build/release/tinygo/lib/clang/include
 	@mkdir -p build/release/tinygo/lib/CMSIS/CMSIS
 	@mkdir -p build/release/tinygo/lib/macos-minimal-sdk
@@ -871,6 +872,7 @@ build/release: tinygo gen-device wasi-libc $(if $(filter 1,$(USE_SYSTEM_BINARYEN
 ifneq ($(USE_SYSTEM_BINARYEN),1)
 	@cp -p  build/wasm-opt$(EXE)         build/release/tinygo/bin
 endif
+	@cp -rp lib/bdwgc/*                  build/release/tinygo/lib/bdwgc
 	@cp -p $(abspath $(CLANG_SRC))/lib/Headers/*.h build/release/tinygo/lib/clang/include
 	@cp -rp lib/CMSIS/CMSIS/Include      build/release/tinygo/lib/CMSIS/CMSIS
 	@cp -rp lib/CMSIS/README.md          build/release/tinygo/lib/CMSIS
@@ -884,9 +886,11 @@ endif
 	@cp -rp lib/musl/crt/crt1.c          build/release/tinygo/lib/musl/crt
 	@cp -rp lib/musl/COPYRIGHT           build/release/tinygo/lib/musl
 	@cp -rp lib/musl/include             build/release/tinygo/lib/musl
+	@cp -rp lib/musl/src/ctype           build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/env             build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/errno           build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/exit            build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/fcntl           build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/include         build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/internal        build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/legacy          build/release/tinygo/lib/musl/src
@@ -895,9 +899,12 @@ endif
 	@cp -rp lib/musl/src/malloc          build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/mman            build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/math            build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/misc            build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/multibyte       build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/sched           build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/signal          build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/stdio           build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/stdlib          build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/string          build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/thread          build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/time            build/release/tinygo/lib/musl/src
diff --git a/builder/bdwgc.go b/builder/bdwgc.go
new file mode 100644
index 0000000000..c7c797636e
--- /dev/null
+++ b/builder/bdwgc.go
@@ -0,0 +1,71 @@
+package builder
+
+// The well-known conservative Boehm-Demers-Weiser GC.
+// This file provides a way to compile this GC for use with TinyGo.
+
+import (
+	"path/filepath"
+
+	"github.com/tinygo-org/tinygo/goenv"
+)
+
+var BoehmGC = Library{
+	name: "bdwgc",
+	cflags: func(target, headerPath string) []string {
+		libdir := filepath.Join(goenv.Get("TINYGOROOT"), "lib/bdwgc")
+		return []string{
+			// use a modern environment
+			"-DUSE_MMAP",              // mmap is available
+			"-DUSE_MUNMAP",            // return memory to the OS using munmap
+			"-DGC_BUILTIN_ATOMIC",     // use compiler intrinsics for atomic operations
+			"-DNO_EXECUTE_PERMISSION", // don't make the heap executable
+
+			// specific flags for TinyGo
+			"-DALL_INTERIOR_POINTERS",  // scan interior pointers (needed for Go)
+			"-DIGNORE_DYNAMIC_LOADING", // we don't support dynamic loading at the moment
+			"-DNO_GETCONTEXT",          // musl doesn't support getcontext()
+
+			// Special flag to work around the lack of __data_start in ld.lld.
+			// TODO: try to fix this in LLVM/lld directly so we don't have to
+			// work around it anymore.
+			"-DGC_DONT_REGISTER_MAIN_STATIC_DATA",
+
+			// Do not scan the stack. We have our own mechanism to do this.
+			"-DSTACK_NOT_SCANNED",
+
+			// Assertions can be enabled while debugging GC issues.
+			//"-DGC_ASSERTIONS",
+
+			// Threading is not yet supported, so these are disabled.
+			//"-DGC_THREADS",
+			//"-DTHREAD_LOCAL_ALLOC",
+
+			"-I" + libdir + "/include",
+		}
+	},
+	sourceDir: func() string {
+		return filepath.Join(goenv.Get("TINYGOROOT"), "lib/bdwgc")
+	},
+	librarySources: func(target string) ([]string, error) {
+		return []string{
+			"allchblk.c",
+			"alloc.c",
+			"blacklst.c",
+			"dbg_mlc.c",
+			"dyn_load.c",
+			"finalize.c",
+			"headers.c",
+			"mach_dep.c",
+			"malloc.c",
+			"mark.c",
+			"mark_rts.c",
+			"misc.c",
+			"new_hblk.c",
+			"obj_map.c",
+			"os_dep.c",
+			"pthread_stop_world.c",
+			"pthread_support.c",
+			"reclaim.c",
+		}, nil
+	},
+}
diff --git a/builder/build.go b/builder/build.go
index 780dc8df49..7491f3d25b 100644
--- a/builder/build.go
+++ b/builder/build.go
@@ -143,20 +143,22 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 	// the libc needs them.
 	root := goenv.Get("TINYGOROOT")
 	var libcDependencies []*compileJob
+	var libcJob *compileJob
 	switch config.Target.Libc {
 	case "darwin-libSystem":
 		job := makeDarwinLibSystemJob(config, tmpdir)
 		libcDependencies = append(libcDependencies, job)
 	case "musl":
-		job, unlock, err := libMusl.load(config, tmpdir)
+		var unlock func()
+		libcJob, unlock, err = libMusl.load(config, tmpdir, nil)
 		if err != nil {
 			return BuildResult{}, err
 		}
 		defer unlock()
-		libcDependencies = append(libcDependencies, dummyCompileJob(filepath.Join(filepath.Dir(job.result), "crt1.o")))
-		libcDependencies = append(libcDependencies, job)
+		libcDependencies = append(libcDependencies, dummyCompileJob(filepath.Join(filepath.Dir(libcJob.result), "crt1.o")))
+		libcDependencies = append(libcDependencies, libcJob)
 	case "picolibc":
-		libcJob, unlock, err := libPicolibc.load(config, tmpdir)
+		libcJob, unlock, err := libPicolibc.load(config, tmpdir, nil)
 		if err != nil {
 			return BuildResult{}, err
 		}
@@ -169,14 +171,14 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		}
 		libcDependencies = append(libcDependencies, dummyCompileJob(path))
 	case "wasmbuiltins":
-		libcJob, unlock, err := libWasmBuiltins.load(config, tmpdir)
+		libcJob, unlock, err := libWasmBuiltins.load(config, tmpdir, nil)
 		if err != nil {
 			return BuildResult{}, err
 		}
 		defer unlock()
 		libcDependencies = append(libcDependencies, libcJob)
 	case "mingw-w64":
-		job, unlock, err := libMinGW.load(config, tmpdir)
+		job, unlock, err := libMinGW.load(config, tmpdir, nil)
 		if err != nil {
 			return BuildResult{}, err
 		}
@@ -652,7 +654,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 	// Add compiler-rt dependency if needed. Usually this is a simple load from
 	// a cache.
 	if config.Target.RTLib == "compiler-rt" {
-		job, unlock, err := libCompilerRT.load(config, tmpdir)
+		job, unlock, err := libCompilerRT.load(config, tmpdir, nil)
 		if err != nil {
 			return result, err
 		}
@@ -660,6 +662,19 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		linkerDependencies = append(linkerDependencies, job)
 	}
 
+	// The Boehm collector is stored in a separate C library.
+	if config.GC() == "boehm" {
+		if libcJob == nil {
+			return BuildResult{}, fmt.Errorf("boehm GC isn't supported with libc %s", config.Target.Libc)
+		}
+		job, unlock, err := BoehmGC.load(config, tmpdir, libcJob)
+		if err != nil {
+			return BuildResult{}, err
+		}
+		defer unlock()
+		linkerDependencies = append(linkerDependencies, job)
+	}
+
 	// Add jobs to compile extra files. These files are in C or assembly and
 	// contain things like the interrupt vector table and low level operations
 	// such as stack switching.
diff --git a/builder/library.go b/builder/library.go
index c79f7ce3f3..1b6afe2fcd 100644
--- a/builder/library.go
+++ b/builder/library.go
@@ -43,7 +43,11 @@ type Library struct {
 // output archive file, it is expected to be removed after use.
 // As a side effect, this call creates the library header files if they didn't
 // exist yet.
-func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJob, abortLock func(), err error) {
+// The provided libc job (if not null) will cause this libc to be added as a
+// dependency for all C compiler jobs, and adds libc headers for the given
+// target config. In other words, pass this libc if the library needs a libc to
+// compile.
+func (l *Library) load(config *compileopts.Config, tmpdir string, libc *compileJob) (job *compileJob, abortLock func(), err error) {
 	outdir, precompiled := config.LibcPath(l.name)
 	archiveFilePath := filepath.Join(outdir, "lib.a")
 	if precompiled {
@@ -181,6 +185,9 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 			args = append(args, "-mfpu=vfpv2")
 		}
 	}
+	if libc != nil {
+		args = append(args, config.LibcCFlags()...)
+	}
 
 	var once sync.Once
 
@@ -233,7 +240,7 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 		objpath := filepath.Join(dir, cleanpath+".o")
 		os.MkdirAll(filepath.Dir(objpath), 0o777)
 		objs = append(objs, objpath)
-		job.dependencies = append(job.dependencies, &compileJob{
+		objfile := &compileJob{
 			description: "compile " + srcpath,
 			run: func(*compileJob) error {
 				var compileArgs []string
@@ -248,7 +255,11 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 				}
 				return nil
 			},
-		})
+		}
+		if libc != nil {
+			objfile.dependencies = append(objfile.dependencies, libc)
+		}
+		job.dependencies = append(job.dependencies, objfile)
 	}
 
 	// Create crt1.o job, if needed.
@@ -257,7 +268,7 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 	// won't make much of a difference in speed).
 	if l.crt1Source != "" {
 		srcpath := filepath.Join(sourceDir, l.crt1Source)
-		job.dependencies = append(job.dependencies, &compileJob{
+		crt1Job := &compileJob{
 			description: "compile " + srcpath,
 			run: func(*compileJob) error {
 				var compileArgs []string
@@ -277,7 +288,11 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 				}
 				return os.Rename(tmpfile.Name(), filepath.Join(outdir, "crt1.o"))
 			},
-		})
+		}
+		if libc != nil {
+			crt1Job.dependencies = append(crt1Job.dependencies, libc)
+		}
+		job.dependencies = append(job.dependencies, crt1Job)
 	}
 
 	ok = true
diff --git a/builder/musl.go b/builder/musl.go
index 8130981e6c..8855d81cf2 100644
--- a/builder/musl.go
+++ b/builder/musl.go
@@ -113,23 +113,31 @@ var libMusl = Library{
 	librarySources: func(target string) ([]string, error) {
 		arch := compileopts.MuslArchitecture(target)
 		globs := []string{
+			"ctype/*.c",
 			"env/*.c",
 			"errno/*.c",
 			"exit/*.c",
+			"fcntl/*.c",
 			"internal/defsysinfo.c",
+			"internal/intscan.c",
 			"internal/libc.c",
+			"internal/shgetc.c",
 			"internal/syscall_ret.c",
 			"internal/vdso.c",
 			"legacy/*.c",
 			"locale/*.c",
 			"linux/*.c",
+			"locale/*.c",
 			"malloc/*.c",
 			"malloc/mallocng/*.c",
 			"mman/*.c",
 			"math/*.c",
+			"misc/*.c",
 			"multibyte/*.c",
+			"sched/*.c",
 			"signal/*.c",
 			"stdio/*.c",
+			"stdlib/*.c",
 			"string/*.c",
 			"thread/" + arch + "/*.s",
 			"thread/*.c",
diff --git a/compileopts/config.go b/compileopts/config.go
index 18d3c9e4d8..7ffddf1f6d 100644
--- a/compileopts/config.go
+++ b/compileopts/config.go
@@ -250,6 +250,10 @@ func (c *Config) LibcPath(name string) (path string, precompiled bool) {
 	if c.Target.SoftFloat {
 		archname += "-softfloat"
 	}
+	if name == "bdwgc" {
+		// Boehm GC is compiled against a particular libc.
+		archname += "-" + c.Target.Libc
+	}
 
 	// Try to load a precompiled library.
 	precompiledDir := filepath.Join(goenv.Get("TINYGOROOT"), "pkg", archname, name)
@@ -304,81 +308,92 @@ func (c *Config) CFlags(libclang bool) []string {
 			"-resource-dir="+resourceDir,
 		)
 	}
+	cflags = append(cflags, c.LibcCFlags()...)
+	// Always emit debug information. It is optionally stripped at link time.
+	cflags = append(cflags, "-gdwarf-4")
+	// Use the same optimization level as TinyGo.
+	cflags = append(cflags, "-O"+c.Options.Opt)
+	// Set the LLVM target triple.
+	cflags = append(cflags, "--target="+c.Triple())
+	// Set the -mcpu (or similar) flag.
+	if c.Target.CPU != "" {
+		if c.GOARCH() == "amd64" || c.GOARCH() == "386" {
+			// x86 prefers the -march flag (-mcpu is deprecated there).
+			cflags = append(cflags, "-march="+c.Target.CPU)
+		} else if strings.HasPrefix(c.Triple(), "avr") {
+			// AVR MCUs use -mmcu instead of -mcpu.
+			cflags = append(cflags, "-mmcu="+c.Target.CPU)
+		} else {
+			// The rest just uses -mcpu.
+			cflags = append(cflags, "-mcpu="+c.Target.CPU)
+		}
+	}
+	// Set the -mabi flag, if needed.
+	if c.ABI() != "" {
+		cflags = append(cflags, "-mabi="+c.ABI())
+	}
+	return cflags
+}
+
+// LibcCFlags returns the C compiler flags for the configured libc.
+// It only uses flags that are part of the libc path (triple, cpu, abi, libc
+// name) so it can safely be used to compile another C library.
+func (c *Config) LibcCFlags() []string {
 	switch c.Target.Libc {
 	case "darwin-libSystem":
 		root := goenv.Get("TINYGOROOT")
-		cflags = append(cflags,
+		return []string{
 			"-nostdlibinc",
 			"-isystem", filepath.Join(root, "lib/macos-minimal-sdk/src/usr/include"),
-		)
+		}
 	case "picolibc":
 		root := goenv.Get("TINYGOROOT")
 		picolibcDir := filepath.Join(root, "lib", "picolibc", "newlib", "libc")
 		path, _ := c.LibcPath("picolibc")
-		cflags = append(cflags,
+		return []string{
 			"-nostdlibinc",
 			"-isystem", filepath.Join(path, "include"),
 			"-isystem", filepath.Join(picolibcDir, "include"),
 			"-isystem", filepath.Join(picolibcDir, "tinystdio"),
-		)
+		}
 	case "musl":
 		root := goenv.Get("TINYGOROOT")
 		path, _ := c.LibcPath("musl")
 		arch := MuslArchitecture(c.Triple())
-		cflags = append(cflags,
+		return []string{
 			"-nostdlibinc",
 			"-isystem", filepath.Join(path, "include"),
 			"-isystem", filepath.Join(root, "lib", "musl", "arch", arch),
+			"-isystem", filepath.Join(root, "lib", "musl", "arch", "generic"),
 			"-isystem", filepath.Join(root, "lib", "musl", "include"),
-		)
+		}
 	case "wasi-libc":
 		root := goenv.Get("TINYGOROOT")
-		cflags = append(cflags,
+		return []string{
 			"-nostdlibinc",
-			"-isystem", root+"/lib/wasi-libc/sysroot/include")
+			"-isystem", root + "/lib/wasi-libc/sysroot/include",
+		}
 	case "wasmbuiltins":
 		// nothing to add (library is purely for builtins)
+		return nil
 	case "mingw-w64":
 		root := goenv.Get("TINYGOROOT")
 		path, _ := c.LibcPath("mingw-w64")
-		cflags = append(cflags,
+		return []string{
 			"-nostdlibinc",
 			"-isystem", filepath.Join(path, "include"),
 			"-isystem", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "crt"),
 			"-isystem", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "defaults", "include"),
 			"-D_UCRT",
-		)
+		}
 	case "":
 		// No libc specified, nothing to add.
+		return nil
 	default:
 		// Incorrect configuration. This could be handled in a better way, but
 		// usually this will be found by developers (not by TinyGo users).
 		panic("unknown libc: " + c.Target.Libc)
 	}
-	// Always emit debug information. It is optionally stripped at link time.
-	cflags = append(cflags, "-gdwarf-4")
-	// Use the same optimization level as TinyGo.
-	cflags = append(cflags, "-O"+c.Options.Opt)
-	// Set the LLVM target triple.
-	cflags = append(cflags, "--target="+c.Triple())
-	// Set the -mcpu (or similar) flag.
-	if c.Target.CPU != "" {
-		if c.GOARCH() == "amd64" || c.GOARCH() == "386" {
-			// x86 prefers the -march flag (-mcpu is deprecated there).
-			cflags = append(cflags, "-march="+c.Target.CPU)
-		} else if strings.HasPrefix(c.Triple(), "avr") {
-			// AVR MCUs use -mmcu instead of -mcpu.
-			cflags = append(cflags, "-mmcu="+c.Target.CPU)
-		} else {
-			// The rest just uses -mcpu.
-			cflags = append(cflags, "-mcpu="+c.Target.CPU)
-		}
-	}
-	// Set the -mabi flag, if needed.
-	if c.ABI() != "" {
-		cflags = append(cflags, "-mabi="+c.ABI())
-	}
-	return cflags
 }
 
 // LDFlags returns the flags to pass to the linker. A few more flags are needed
diff --git a/compileopts/options.go b/compileopts/options.go
index 9601ae3221..1774b5b15f 100644
--- a/compileopts/options.go
+++ b/compileopts/options.go
@@ -8,7 +8,7 @@ import (
 )
 
 var (
-	validGCOptions            = []string{"none", "leaking", "conservative", "custom", "precise"}
+	validGCOptions            = []string{"none", "leaking", "conservative", "custom", "precise", "boehm"}
 	validSchedulerOptions     = []string{"none", "tasks", "asyncify"}
 	validSerialOptions        = []string{"none", "uart", "usb", "rtt"}
 	validPrintSizeOptions     = []string{"none", "short", "full"}
diff --git a/compileopts/options_test.go b/compileopts/options_test.go
index 23ffec465f..62aa4e127a 100644
--- a/compileopts/options_test.go
+++ b/compileopts/options_test.go
@@ -9,7 +9,7 @@ import (
 
 func TestVerifyOptions(t *testing.T) {
 
-	expectedGCError := errors.New(`invalid gc option 'incorrect': valid values are none, leaking, conservative, custom, precise`)
+	expectedGCError := errors.New(`invalid gc option 'incorrect': valid values are none, leaking, conservative, custom, precise, boehm`)
 	expectedSchedulerError := errors.New(`invalid scheduler option 'incorrect': valid values are none, tasks, asyncify`)
 	expectedPrintSizeError := errors.New(`invalid size option 'incorrect': valid values are none, short, full`)
 	expectedPanicStrategyError := errors.New(`invalid panic option 'incorrect': valid values are print, trap`)
diff --git a/compileopts/target.go b/compileopts/target.go
index 26a91086b9..4fa054b2e1 100644
--- a/compileopts/target.go
+++ b/compileopts/target.go
@@ -245,7 +245,6 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 		GOOS:             options.GOOS,
 		GOARCH:           options.GOARCH,
 		BuildTags:        []string{options.GOOS, options.GOARCH},
-		GC:               "precise",
 		Scheduler:        "tasks",
 		Linker:           "cc",
 		DefaultStackSize: 1024 * 64, // 64kB
@@ -372,6 +371,7 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 	llvmvendor := "unknown"
 	switch options.GOOS {
 	case "darwin":
+		spec.GC = "precise"
 		platformVersion := "10.12.0"
 		if options.GOARCH == "arm64" {
 			platformVersion = "11.0.0" // first macosx platform with arm64 support
@@ -391,6 +391,7 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 		spec.ExtraFiles = append(spec.ExtraFiles,
 			"src/runtime/runtime_unix.c")
 	case "linux":
+		spec.GC = "boehm"
 		spec.Linker = "ld.lld"
 		spec.RTLib = "compiler-rt"
 		spec.Libc = "musl"
@@ -410,8 +411,10 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 			spec.CFlags = append(spec.CFlags, "-mno-outline-atomics")
 		}
 		spec.ExtraFiles = append(spec.ExtraFiles,
+			"src/runtime/gc_boehm.c",
 			"src/runtime/runtime_unix.c")
 	case "windows":
+		spec.GC = "precise"
 		spec.Linker = "ld.lld"
 		spec.Libc = "mingw-w64"
 		// Note: using a medium code model, low image base and no ASLR
diff --git a/lib/bdwgc b/lib/bdwgc
new file mode 160000
index 0000000000..d1ff06cc50
--- /dev/null
+++ b/lib/bdwgc
@@ -0,0 +1 @@
+Subproject commit d1ff06cc503a74dca0150d5e988f2c93158b0cdf
diff --git a/src/runtime/gc_blocks.go b/src/runtime/gc_blocks.go
index 7db6b7a1cf..77eef30b84 100644
--- a/src/runtime/gc_blocks.go
+++ b/src/runtime/gc_blocks.go
@@ -37,6 +37,7 @@ import (
 )
 
 const gcDebug = false
+const needsStaticHeap = true
 
 // Some globals + constants for the entire GC.
 
@@ -495,6 +496,12 @@ func markRoots(start, end uintptr) {
 	}
 }
 
+func markCurrentGoroutineStack(sp uintptr) {
+	// This could be optimized by only marking the stack area that's currently
+	// in use.
+	markRoot(0, sp)
+}
+
 // stackOverflow is a flag which is set when the GC scans too deep while marking.
 // After it is set, all marked allocations must be re-scanned.
 var stackOverflow bool
diff --git a/src/runtime/gc_boehm.c b/src/runtime/gc_boehm.c
new file mode 100644
index 0000000000..50d7edc916
--- /dev/null
+++ b/src/runtime/gc_boehm.c
@@ -0,0 +1,16 @@
+//go:build none
+
+// This file is included in the build on systems that support the Boehm GC.
+
+typedef void (* GC_push_other_roots_proc)(void);
+void GC_set_push_other_roots(GC_push_other_roots_proc);
+
+void tinygo_runtime_bdwgc_callback(void);
+
+static void callback(void) {
+    tinygo_runtime_bdwgc_callback();
+}
+
+void tinygo_runtime_bdwgc_init(void) {
+    GC_set_push_other_roots(callback);
+}
diff --git a/src/runtime/gc_boehm.go b/src/runtime/gc_boehm.go
new file mode 100644
index 0000000000..aabd426843
--- /dev/null
+++ b/src/runtime/gc_boehm.go
@@ -0,0 +1,163 @@
+//go:build gc.boehm
+
+package runtime
+
+import (
+	"unsafe"
+)
+
+// Layout value for a pointer free object.
+const pointerFreeLayout = 0x3
+
+const needsStaticHeap = false
+
+// zeroSizedAlloc is just a sentinel that gets returned when allocating 0 bytes.
+var zeroSizedAlloc uint8
+
+func initHeap() {
+	libgc_init()
+
+	gcInit()
+}
+
+//export tinygo_runtime_bdwgc_init
+func gcInit()
+
+//export tinygo_runtime_bdwgc_callback
+func gcCallback() {
+	// Mark the system stack and (if we're on a goroutine stack) also the
+	// current goroutine stack.
+	markStack()
+
+	findGlobals(func(start, end uintptr) {
+		libgc_push_all(start, end)
+	})
+}
+
+func markRoots(start, end uintptr) {
+	libgc_push_all(start, end)
+}
+
+func markCurrentGoroutineStack(sp uintptr) {
+	// Only mark the area of the stack that is currently in use.
+	// (This doesn't work for other goroutines, but at least it doesn't keep
+	// more pointers alive than needed on the current stack).
+	base := libgc_base(sp)
+	if base == 0 { // && asserts
+		runtimePanic("goroutine stack not in a heap allocation?")
+	}
+	stackBottom := base + libgc_size(base)
+	libgc_push_all_stack(sp, stackBottom)
+}
+
+//go:noinline
+func alloc(size uintptr, layout unsafe.Pointer) unsafe.Pointer {
+	if size == 0 {
+		return unsafe.Pointer(&zeroSizedAlloc)
+	}
+
+	var ptr unsafe.Pointer
+	if uintptr(layout) == pointerFreeLayout {
+		// This object is entirely pointer free, for example make([]int, ...).
+		// Make sure the GC knows this so it doesn't scan the object
+		// unnecessarily to improve performance.
+		ptr = libgc_malloc_atomic(size)
+		// Memory returned from libgc_malloc_atomic has not been zeroed so we
+		// have to do that manually.
+		memzero(ptr, size)
+	} else {
+		// TODO: bdwgc supports typed allocations, which could be useful to
+		// implement a mostly-precise GC.
+		ptr = libgc_malloc(size)
+		// Memory returned from libgc_malloc has already been zeroed, so nothing
+		// to do here.
+	}
+	if ptr == nil {
+		runtimePanic("gc: out of memory")
+	}
+
+	return ptr
+}
+
+func free(ptr unsafe.Pointer) {
+	libgc_free(ptr)
+}
+
+func GC() {
+	libgc_gcollect()
+}
+
+// This should be stack-allocated, but we don't currently have a good way of
+// ensuring that happens.
+var gcMemStats libgc_prof_stats
+
+func ReadMemStats(m *MemStats) {
+	libgc_get_prof_stats(&gcMemStats, unsafe.Sizeof(gcMemStats))
+
+	// Fill in MemStats as well as we can, given the information that bdwgc
+	// provides to us.
+	m.HeapIdle = uint64(gcMemStats.free_bytes_full - gcMemStats.unmapped_bytes)
+	m.HeapInuse = uint64(gcMemStats.heapsize_full - gcMemStats.unmapped_bytes)
+	m.HeapReleased = uint64(gcMemStats.unmapped_bytes)
+	m.HeapSys = uint64(m.HeapInuse + m.HeapIdle)
+	m.GCSys = 0 // not provided by bdwgc
+	m.TotalAlloc = uint64(gcMemStats.allocd_bytes_before_gc + gcMemStats.bytes_allocd_since_gc)
+	m.Mallocs = 0 // not provided by bdwgc
+	m.Frees = 0   // not provided by bdwgc
+	m.Sys = uint64(gcMemStats.obtained_from_os_bytes)
+}
+
+func setHeapEnd(newHeapEnd uintptr) {
+	runtimePanic("gc: did not expect setHeapEnd call")
+}
+
+//export GC_init
+func libgc_init()
+
+//export GC_malloc
+func libgc_malloc(uintptr) unsafe.Pointer
+
+//export GC_malloc_atomic
+func libgc_malloc_atomic(uintptr) unsafe.Pointer
+
+//export GC_free
+func libgc_free(unsafe.Pointer)
+
+//export GC_base
+func libgc_base(ptr uintptr) uintptr
+
+//export GC_size
+func libgc_size(ptr uintptr) uintptr
+
+//export GC_push_all
+func libgc_push_all(bottom, top uintptr)
+
+//export GC_push_all_stack
+func libgc_push_all_stack(bottom, top uintptr)
+
+//export GC_gcollect
+func libgc_gcollect()
+
+//export GC_get_prof_stats
+func libgc_get_prof_stats(*libgc_prof_stats, uintptr) uintptr
+
+type libgc_prof_stats struct {
+	heapsize_full             uintptr
+	free_bytes_full           uintptr
+	unmapped_bytes            uintptr
+	bytes_allocd_since_gc     uintptr
+	allocd_bytes_before_gc    uintptr
+	non_gc_bytes              uintptr
+	gc_no                     uintptr
+	markers_m1                uintptr
+	bytes_reclaimed_since_gc  uintptr
+	reclaimed_bytes_before_gc uintptr
+	expl_freed_bytes_since_gc uintptr
+	obtained_from_os_bytes    uintptr
+}
+
+func SetFinalizer(obj interface{}, finalizer interface{}) {
+	// Unimplemented.
+	// The GC *does* support finalization, so this could be added relatively
+	// easily I think.
+}
diff --git a/src/runtime/gc_custom.go b/src/runtime/gc_custom.go
index a34b7dce69..0125f1688b 100644
--- a/src/runtime/gc_custom.go
+++ b/src/runtime/gc_custom.go
@@ -36,6 +36,8 @@ import (
 	"unsafe"
 )
 
+const needsStaticHeap = false
+
 // initHeap is called when the heap is first initialized at program start.
 func initHeap()
 
diff --git a/src/runtime/gc_globals.go b/src/runtime/gc_globals.go
index f27911ec51..3e8f857618 100644
--- a/src/runtime/gc_globals.go
+++ b/src/runtime/gc_globals.go
@@ -1,4 +1,4 @@
-//go:build (gc.conservative || gc.precise) && (baremetal || tinygo.wasm)
+//go:build baremetal || tinygo.wasm
 
 package runtime
 
diff --git a/src/runtime/gc_leaking.go b/src/runtime/gc_leaking.go
index 5c9594277c..545536da63 100644
--- a/src/runtime/gc_leaking.go
+++ b/src/runtime/gc_leaking.go
@@ -10,6 +10,8 @@ import (
 	"unsafe"
 )
 
+const needsStaticHeap = true
+
 // Ever-incrementing pointer: no memory is freed.
 var heapptr = heapStart
 
diff --git a/src/runtime/gc_none.go b/src/runtime/gc_none.go
index 43d3c4904b..173c1f6439 100644
--- a/src/runtime/gc_none.go
+++ b/src/runtime/gc_none.go
@@ -10,6 +10,8 @@ import (
 	"unsafe"
 )
 
+const needsStaticHeap = false
+
 var gcTotalAlloc uint64 // for runtime.MemStats
 var gcMallocs uint64
 var gcFrees uint64
diff --git a/src/runtime/gc_stack_raw.go b/src/runtime/gc_stack_raw.go
index 5ee18622db..01ec0208c2 100644
--- a/src/runtime/gc_stack_raw.go
+++ b/src/runtime/gc_stack_raw.go
@@ -1,4 +1,4 @@
-//go:build (gc.conservative || gc.precise) && !tinygo.wasm
+//go:build (gc.conservative || gc.precise || gc.boehm) && !tinygo.wasm
 
 package runtime
 
@@ -33,7 +33,6 @@ func scanstack(sp uintptr) {
 		markRoots(sp, stackTop)
 	} else {
 		// This is a goroutine stack.
-		// It is an allocation, so scan it as if it were a value in a global.
-		markRoot(0, sp)
+		markCurrentGoroutineStack(sp)
 	}
 }
diff --git a/src/runtime/runtime_unix.go b/src/runtime/runtime_unix.go
index ba5d5a5938..405013f138 100644
--- a/src/runtime/runtime_unix.go
+++ b/src/runtime/runtime_unix.go
@@ -71,7 +71,10 @@ var stackTop uintptr
 //
 //export main
 func main(argc int32, argv *unsafe.Pointer) int {
-	preinit()
+	if needsStaticHeap {
+		// Allocate area for the heap if the GC needs it.
+		allocateHeap()
+	}
 
 	// Store argc and argv for later use.
 	main_argc = argc
@@ -267,7 +270,7 @@ var heapMaxSize uintptr
 
 var heapStart, heapEnd uintptr
 
-func preinit() {
+func allocateHeap() {
 	// Allocate a large chunk of virtual memory. Because it is virtual, it won't
 	// really be allocated in RAM. Memory will only be allocated when it is
 	// first touched.