diff --git a/compiler/compiler.go b/compiler/compiler.go
index 981993fe76..8b5f0d1cb2 100644
--- a/compiler/compiler.go
+++ b/compiler/compiler.go
@@ -17,6 +17,7 @@ import (
 
 	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"github.com/tinygo-org/tinygo/loader"
+	"github.com/tinygo-org/tinygo/src/tinygo"
 	"golang.org/x/tools/go/ssa"
 	"golang.org/x/tools/go/types/typeutil"
 	"tinygo.org/x/go-llvm"
@@ -1869,10 +1870,9 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 			}
 			return llvm.ConstInt(b.ctx.Int1Type(), supportsRecover, false), nil
 		case name == "runtime.panicStrategy":
-			// These constants are defined in src/runtime/panic.go.
 			panicStrategy := map[string]uint64{
-				"print": 1, // panicStrategyPrint
-				"trap":  2, // panicStrategyTrap
+				"print": tinygo.PanicStrategyPrint,
+				"trap":  tinygo.PanicStrategyTrap,
 			}[b.Config.PanicStrategy]
 			return llvm.ConstInt(b.ctx.Int8Type(), panicStrategy, false), nil
 		case name == "runtime/interrupt.New":
diff --git a/compiler/map.go b/compiler/map.go
index b4c5267233..71fb3f0da8 100644
--- a/compiler/map.go
+++ b/compiler/map.go
@@ -6,17 +6,11 @@ import (
 	"go/token"
 	"go/types"
 
+	"github.com/tinygo-org/tinygo/src/tinygo"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
 
-// constants for hashmap algorithms; must match src/runtime/hashmap.go
-const (
-	hashmapAlgorithmBinary = iota
-	hashmapAlgorithmString
-	hashmapAlgorithmInterface
-)
-
 // createMakeMap creates a new map object (runtime.hashmap) by allocating and
 // initializing an appropriately sized object.
 func (b *builder) createMakeMap(expr *ssa.MakeMap) (llvm.Value, error) {
@@ -24,20 +18,20 @@ func (b *builder) createMakeMap(expr *ssa.MakeMap) (llvm.Value, error) {
 	keyType := mapType.Key().Underlying()
 	llvmValueType := b.getLLVMType(mapType.Elem().Underlying())
 	var llvmKeyType llvm.Type
-	var alg uint64 // must match values in src/runtime/hashmap.go
+	var alg uint64
 	if t, ok := keyType.(*types.Basic); ok && t.Info()&types.IsString != 0 {
 		// String keys.
 		llvmKeyType = b.getLLVMType(keyType)
-		alg = hashmapAlgorithmString
+		alg = uint64(tinygo.HashmapAlgorithmString)
 	} else if hashmapIsBinaryKey(keyType) {
 		// Trivially comparable keys.
 		llvmKeyType = b.getLLVMType(keyType)
-		alg = hashmapAlgorithmBinary
+		alg = uint64(tinygo.HashmapAlgorithmBinary)
 	} else {
 		// All other keys. Implemented as map[interface{}]valueType for ease of
 		// implementation.
 		llvmKeyType = b.getLLVMRuntimeType("_interface")
-		alg = hashmapAlgorithmInterface
+		alg = uint64(tinygo.HashmapAlgorithmInterface)
 	}
 	keySize := b.targetData.TypeAllocSize(llvmKeyType)
 	valueSize := b.targetData.TypeAllocSize(llvmValueType)
diff --git a/loader/goroot.go b/loader/goroot.go
index 20fee016bf..631cc6e7e6 100644
--- a/loader/goroot.go
+++ b/loader/goroot.go
@@ -256,6 +256,7 @@ func pathsToOverride(goMinor int, needsSyscallPackage bool) map[string]bool {
 		"runtime/":                    false,
 		"sync/":                       true,
 		"testing/":                    true,
+		"tinygo/":                     false,
 		"unique/":                     false,
 	}
 
diff --git a/src/runtime/hashmap.go b/src/runtime/hashmap.go
index 7b46b42bef..ad42fda753 100644
--- a/src/runtime/hashmap.go
+++ b/src/runtime/hashmap.go
@@ -7,6 +7,7 @@ package runtime
 
 import (
 	"reflect"
+	"tinygo"
 	"unsafe"
 )
 
@@ -22,14 +23,6 @@ type hashmap struct {
 	keyHash    func(key unsafe.Pointer, size, seed uintptr) uint32
 }
 
-type hashmapAlgorithm uint8
-
-const (
-	hashmapAlgorithmBinary hashmapAlgorithm = iota
-	hashmapAlgorithmString
-	hashmapAlgorithmInterface
-)
-
 // A hashmap bucket. A bucket is a container of 8 key/value pairs: first the
 // following two entries, then the 8 keys, then the 8 values. This somewhat odd
 // ordering is to make sure the keys and values are well aligned when one of
@@ -76,8 +69,8 @@ func hashmapMake(keySize, valueSize uintptr, sizeHint uintptr, alg uint8) *hashm
 	bucketBufSize := unsafe.Sizeof(hashmapBucket{}) + keySize*8 + valueSize*8
 	buckets := alloc(bucketBufSize*(1<<bucketBits), nil)
 
-	keyHash := hashmapKeyHashAlg(hashmapAlgorithm(alg))
-	keyEqual := hashmapKeyEqualAlg(hashmapAlgorithm(alg))
+	keyHash := hashmapKeyHashAlg(tinygo.HashmapAlgorithm(alg))
+	keyEqual := hashmapKeyEqualAlg(tinygo.HashmapAlgorithm(alg))
 
 	return &hashmap{
 		buckets:    buckets,
@@ -119,13 +112,13 @@ func hashmapClear(m *hashmap) {
 	}
 }
 
-func hashmapKeyEqualAlg(alg hashmapAlgorithm) func(x, y unsafe.Pointer, n uintptr) bool {
+func hashmapKeyEqualAlg(alg tinygo.HashmapAlgorithm) func(x, y unsafe.Pointer, n uintptr) bool {
 	switch alg {
-	case hashmapAlgorithmBinary:
+	case tinygo.HashmapAlgorithmBinary:
 		return memequal
-	case hashmapAlgorithmString:
+	case tinygo.HashmapAlgorithmString:
 		return hashmapStringEqual
-	case hashmapAlgorithmInterface:
+	case tinygo.HashmapAlgorithmInterface:
 		return hashmapInterfaceEqual
 	default:
 		// compiler bug :(
@@ -133,13 +126,13 @@ func hashmapKeyEqualAlg(alg hashmapAlgorithm) func(x, y unsafe.Pointer, n uintpt
 	}
 }
 
-func hashmapKeyHashAlg(alg hashmapAlgorithm) func(key unsafe.Pointer, n, seed uintptr) uint32 {
+func hashmapKeyHashAlg(alg tinygo.HashmapAlgorithm) func(key unsafe.Pointer, n, seed uintptr) uint32 {
 	switch alg {
-	case hashmapAlgorithmBinary:
+	case tinygo.HashmapAlgorithmBinary:
 		return hash32
-	case hashmapAlgorithmString:
+	case tinygo.HashmapAlgorithmString:
 		return hashmapStringPtrHash
-	case hashmapAlgorithmInterface:
+	case tinygo.HashmapAlgorithmInterface:
 		return hashmapInterfacePtrHash
 	default:
 		// compiler bug :(
diff --git a/src/runtime/panic.go b/src/runtime/panic.go
index abe4e7d279..d429171ec6 100644
--- a/src/runtime/panic.go
+++ b/src/runtime/panic.go
@@ -3,6 +3,7 @@ package runtime
 import (
 	"internal/task"
 	"runtime/interrupt"
+	"tinygo"
 	"unsafe"
 )
 
@@ -22,11 +23,6 @@ func tinygo_longjmp(frame *deferFrame)
 // Returns whether recover is supported on the current architecture.
 func supportsRecover() bool
 
-const (
-	panicStrategyPrint = 1
-	panicStrategyTrap  = 2
-)
-
 // Compile intrinsic.
 // Returns which strategy is used. This is usually "print" but can be changed
 // using the -panic= compiler flag.
@@ -48,7 +44,7 @@ type deferFrame struct {
 
 // Builtin function panic(msg), used as a compiler intrinsic.
 func _panic(message interface{}) {
-	if panicStrategy() == panicStrategyTrap {
+	if panicStrategy() == tinygo.PanicStrategyTrap {
 		trap()
 	}
 	// Note: recover is not supported inside interrupts.
@@ -76,7 +72,7 @@ func runtimePanic(msg string) {
 }
 
 func runtimePanicAt(addr unsafe.Pointer, msg string) {
-	if panicStrategy() == panicStrategyTrap {
+	if panicStrategy() == tinygo.PanicStrategyTrap {
 		trap()
 	}
 	if hasReturnAddr {
diff --git a/src/runtime/runtime_unix.go b/src/runtime/runtime_unix.go
index c4fd3285b6..3b20330e20 100644
--- a/src/runtime/runtime_unix.go
+++ b/src/runtime/runtime_unix.go
@@ -5,6 +5,7 @@ package runtime
 import (
 	"math/bits"
 	"sync/atomic"
+	"tinygo"
 	"unsafe"
 )
 
@@ -141,7 +142,7 @@ func tinygo_register_fatal_signals()
 //
 //export tinygo_handle_fatal_signal
 func tinygo_handle_fatal_signal(sig int32, addr uintptr) {
-	if panicStrategy() == panicStrategyTrap {
+	if panicStrategy() == tinygo.PanicStrategyTrap {
 		trap()
 	}
 
diff --git a/src/tinygo/runtime.go b/src/tinygo/runtime.go
new file mode 100644
index 0000000000..c92417ebc6
--- /dev/null
+++ b/src/tinygo/runtime.go
@@ -0,0 +1,17 @@
+// Package tinygo contains constants used between the TinyGo compiler and
+// runtime.
+package tinygo
+
+const (
+	PanicStrategyPrint = iota + 1
+	PanicStrategyTrap
+)
+
+type HashmapAlgorithm uint8
+
+// Constants for hashmap algorithms.
+const (
+	HashmapAlgorithmBinary HashmapAlgorithm = iota
+	HashmapAlgorithmString
+	HashmapAlgorithmInterface
+)