diff --git a/.gitignore b/.gitignore
index b473e04..21e8434 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,3 +14,4 @@ build/
 .out
 .cicd/
 test-results/
+.pkl-lsp
diff --git a/cmd/internal/gen-snippets/gen-snippets.go b/cmd/internal/gen-snippets/gen-snippets.go
index 247604a..8fa0957 100644
--- a/cmd/internal/gen-snippets/gen-snippets.go
+++ b/cmd/internal/gen-snippets/gen-snippets.go
@@ -55,7 +55,12 @@ func makeGoCode(evaluator pkl.Evaluator, snippetsDir string) {
 		panic(err)
 	}
 	codegenDir := filepath.Join(snippetsDir, "..")
-	settings, err := generatorsettings.LoadFromPath(context.Background(), "codegen/snippet-tests/generator-settings.pkl")
+
+	_, filename, _, ok := runtime.Caller(0)
+	if !ok {
+		panic("Can't find runtime caller")
+	}
+	settings, err := generatorsettings.LoadFromPath(context.Background(), filepath.Join(filename, "../../../../codegen/snippet-tests/generator-settings.pkl"))
 	if err != nil {
 		panic(err)
 	}
@@ -72,6 +77,7 @@ func makeGoCode(evaluator pkl.Evaluator, snippetsDir string) {
 			basename := strings.TrimSuffix(filepath.Base(file.Name()), ".pkl")
 			errContents := strings.ReplaceAll(err.Error(), codegenDir, "<codegen_dir>")
 			errContents = stripLineNumbers(errContents)
+			os.MkdirAll(outputDir, os.ModePerm)
 			if err = os.WriteFile(filepath.Join(outputDir, basename), []byte(errContents), 0o666); err != nil {
 				panic(err)
 			}
diff --git a/cmd/pkl-gen-go/generatorsettings/GeneratorSettings.pkl.go b/cmd/pkl-gen-go/generatorsettings/GeneratorSettings.pkl.go
index ca8d712..a65e329 100644
--- a/cmd/pkl-gen-go/generatorsettings/GeneratorSettings.pkl.go
+++ b/cmd/pkl-gen-go/generatorsettings/GeneratorSettings.pkl.go
@@ -71,11 +71,16 @@ type GeneratorSettings struct {
 	//
 	// This corresponds to the `--project-dir` flag in the Pkl CLI.
 	// Relative paths are resolved against the enclosing file.
+	//
+	// Paths must use `/` as the path separator.
 	ProjectDir *string `pkl:"projectDir"`
 
 	// The cache directory for storing packages.
 	//
 	// This corresponds to the `--cache-dir` flag in the Pkl CLI.
+	// Relative paths are resolved against the enclosing file.
+	//
+	// Paths must use `/` as the path separator.
 	CacheDir *string `pkl:"cacheDir"`
 
 	// Print out the names of the files that will be generated, but skip writing anything to disk.
@@ -86,10 +91,10 @@ type GeneratorSettings struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a GeneratorSettings
-func LoadFromPath(ctx context.Context, path string) (ret *GeneratorSettings, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret GeneratorSettings, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return GeneratorSettings{}, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -102,10 +107,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *GeneratorSettings, err
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a GeneratorSettings
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*GeneratorSettings, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (GeneratorSettings, error) {
 	var ret GeneratorSettings
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/cmd/pkl-gen-go/generatorsettings/init.pkl.go b/cmd/pkl-gen-go/generatorsettings/init.pkl.go
index edef33b..cbf000f 100644
--- a/cmd/pkl-gen-go/generatorsettings/init.pkl.go
+++ b/cmd/pkl-gen-go/generatorsettings/init.pkl.go
@@ -4,5 +4,5 @@ package generatorsettings
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("pkl.golang.GeneratorSettings", GeneratorSettings{})
+	pkl.RegisterStrictMapping("pkl.golang.GeneratorSettings", GeneratorSettings{})
 }
diff --git a/cmd/pkl-gen-go/pkg/generate.go b/cmd/pkl-gen-go/pkg/generate.go
index c5045a3..e2d9c18 100644
--- a/cmd/pkl-gen-go/pkg/generate.go
+++ b/cmd/pkl-gen-go/pkg/generate.go
@@ -43,7 +43,7 @@ var (
 )
 
 type TemplateValues struct {
-	*generatorsettings.GeneratorSettings
+	generatorsettings.GeneratorSettings
 	PklModulePath string
 }
 
@@ -78,7 +78,7 @@ func doFormat(src string) ([]byte, string, error) {
 	return formatted, cmp.Diff(src, strFormatted), nil
 }
 
-func generateDryRun(evaluator pkl.Evaluator, tmpFile *os.File, outputPath string, settings *generatorsettings.GeneratorSettings) error {
+func generateDryRun(evaluator pkl.Evaluator, tmpFile *os.File, outputPath string, settings generatorsettings.GeneratorSettings) error {
 	var filenames []string
 	err := evaluator.EvaluateExpression(context.Background(), pkl.FileSource(tmpFile.Name()), "output.files.toMap().keys.toList()", &filenames)
 	if err != nil {
@@ -105,7 +105,7 @@ func log(format string, a ...any) {
 func GenerateGo(
 	evaluator pkl.Evaluator,
 	pklModulePath string,
-	settings *generatorsettings.GeneratorSettings,
+	settings generatorsettings.GeneratorSettings,
 	silent bool,
 	outputPath string,
 ) error {
@@ -124,7 +124,7 @@ func GenerateGo(
 		}
 		log("Using custom generator script: \033[36m%s\033[0m\n", settings.GeneratorScriptPath)
 	}
-	if err = determineBasePath(settings); err != nil {
+	if err = determineBasePath(&settings); err != nil {
 		return err
 	}
 	tmpFile, err := os.CreateTemp(os.TempDir(), "pkl-gen-go.*.pkl")
diff --git a/cmd/pkl-gen-go/pkl-gen-go.go b/cmd/pkl-gen-go/pkl-gen-go.go
index 28dff6a..5d083b1 100644
--- a/cmd/pkl-gen-go/pkl-gen-go.go
+++ b/cmd/pkl-gen-go/pkl-gen-go.go
@@ -121,7 +121,7 @@ func evaluatorOptions(opts *pkl.EvaluatorOptions) {
 }
 
 var (
-	settings         *generatorsettings.GeneratorSettings
+	settings         generatorsettings.GeneratorSettings
 	suppressWarnings bool
 	outputPath       string
 	printVersion     bool
@@ -189,7 +189,7 @@ func findProjectDir(projectDirFlag string) string {
 
 // Loads the settings for controlling codegen.
 // Uses a Pkl evaluator that is separate from what's used for actually running codegen.
-func loadGeneratorSettings(generatorSettingsPath string, projectDirFlag string, cacheDirFlag string) (*generatorsettings.GeneratorSettings, error) {
+func loadGeneratorSettings(generatorSettingsPath string, projectDirFlag string, cacheDirFlag string) (generatorsettings.GeneratorSettings, error) {
 	projectDir := findProjectDir(projectDirFlag)
 	var evaluator pkl.Evaluator
 	var err error
@@ -216,7 +216,7 @@ func loadGeneratorSettings(generatorSettingsPath string, projectDirFlag string,
 	}
 	s, err := generatorsettings.Load(context.Background(), evaluator, source)
 	if err != nil {
-		return nil, err
+		return s, err
 	}
 	settingsFilePath := path.Dir(source.Uri.Path)
 	if s.ProjectDir != nil && !path.IsAbs(*s.ProjectDir) {
diff --git a/codegen/snippet-tests/input/CyclicModule.pkl b/codegen/snippet-tests/input/CyclicModule.pkl
index da622af..0fade72 100644
--- a/codegen/snippet-tests/input/CyclicModule.pkl
+++ b/codegen/snippet-tests/input/CyclicModule.pkl
@@ -25,5 +25,5 @@ class Cyclic {
 
   b: Int
 
-  myself: Cyclic
+  myself: Cyclic?
 }
diff --git a/codegen/snippet-tests/input/ModuleType.pkl b/codegen/snippet-tests/input/ModuleType.pkl
index b409c53..2b35e78 100644
--- a/codegen/snippet-tests/input/ModuleType.pkl
+++ b/codegen/snippet-tests/input/ModuleType.pkl
@@ -21,10 +21,10 @@ import ".../src/go.pkl"
 
 myStr: String
 
-foo: module
+foo: module?
 
 lib: lib4.MyLib4
 
-fooAgain: Myself
+fooAgain: Myself?
 
 typealias Myself = module
diff --git a/codegen/snippet-tests/output/bugholder/B.pkl.go b/codegen/snippet-tests/output/bugholder/B.pkl.go
index e6638b4..bb1f4b2 100644
--- a/codegen/snippet-tests/output/bugholder/B.pkl.go
+++ b/codegen/snippet-tests/output/bugholder/B.pkl.go
@@ -7,7 +7,7 @@ type B interface {
 	GetB() string
 }
 
-var _ B = (*BImpl)(nil)
+var _ B = BImpl{}
 
 type BImpl struct {
 	B string `pkl:"b"`
@@ -15,10 +15,10 @@ type BImpl struct {
 	A string `pkl:"a"`
 }
 
-func (rcv *BImpl) GetB() string {
+func (rcv BImpl) GetB() string {
 	return rcv.B
 }
 
-func (rcv *BImpl) GetA() string {
+func (rcv BImpl) GetA() string {
 	return rcv.A
 }
diff --git a/codegen/snippet-tests/output/bugholder/Bike.pkl.go b/codegen/snippet-tests/output/bugholder/Bike.pkl.go
index 676d213..8a84815 100644
--- a/codegen/snippet-tests/output/bugholder/Bike.pkl.go
+++ b/codegen/snippet-tests/output/bugholder/Bike.pkl.go
@@ -7,5 +7,5 @@ type Bike struct {
 	// Wheels are the front and back wheels.
 	//
 	// There are typically two of them.
-	Wheels []*Wheel `pkl:"wheels"`
+	Wheels []Wheel `pkl:"wheels"`
 }
diff --git a/codegen/snippet-tests/output/bugholder/Bug.pkl.go b/codegen/snippet-tests/output/bugholder/Bug.pkl.go
index ef6eae9..233b15f 100644
--- a/codegen/snippet-tests/output/bugholder/Bug.pkl.go
+++ b/codegen/snippet-tests/output/bugholder/Bug.pkl.go
@@ -15,9 +15,9 @@ type Bug struct {
 	Age *int `pkl:"age"`
 
 	// How long the bug holds its breath for
-	HoldsBreathFor *pkl.Duration `pkl:"holdsBreathFor"`
+	HoldsBreathFor pkl.Duration `pkl:"holdsBreathFor"`
 
-	Size *pkl.DataSize `pkl:"size"`
+	Size pkl.DataSize `pkl:"size"`
 
 	Kind bugkind.BugKind `pkl:"kind"`
 
@@ -27,5 +27,5 @@ type Bug struct {
 
 	Kind4 string `pkl:"kind4"`
 
-	BagOfStuff *pkl.Object `pkl:"bagOfStuff"`
+	BagOfStuff pkl.Object `pkl:"bagOfStuff"`
 }
diff --git a/codegen/snippet-tests/output/bugholder/BugHolder.pkl.go b/codegen/snippet-tests/output/bugholder/BugHolder.pkl.go
index c975eb3..dd93731 100644
--- a/codegen/snippet-tests/output/bugholder/BugHolder.pkl.go
+++ b/codegen/snippet-tests/output/bugholder/BugHolder.pkl.go
@@ -8,9 +8,9 @@ import (
 )
 
 type BugHolder struct {
-	Bug *Bug `pkl:"bug"`
+	Bug Bug `pkl:"bug"`
 
-	N蚊子 *Bug `pkl:"蚊子"`
+	N蚊子 Bug `pkl:"蚊子"`
 
 	ThisPerson ThisPerson `pkl:"thisPerson"`
 
@@ -18,10 +18,10 @@ type BugHolder struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a BugHolder
-func LoadFromPath(ctx context.Context, path string) (ret *BugHolder, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret BugHolder, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -34,10 +34,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *BugHolder, err error)
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a BugHolder
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*BugHolder, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (BugHolder, error) {
 	var ret BugHolder
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/bugholder/C.pkl.go b/codegen/snippet-tests/output/bugholder/C.pkl.go
index d9d3940..eaa2e8a 100644
--- a/codegen/snippet-tests/output/bugholder/C.pkl.go
+++ b/codegen/snippet-tests/output/bugholder/C.pkl.go
@@ -7,14 +7,14 @@ type C interface {
 	GetC() string
 }
 
-var _ C = (*CImpl)(nil)
+var _ C = CImpl{}
 
 type CImpl struct {
-	*BImpl
+	BImpl
 
 	C string `pkl:"c"`
 }
 
-func (rcv *CImpl) GetC() string {
+func (rcv CImpl) GetC() string {
 	return rcv.C
 }
diff --git a/codegen/snippet-tests/output/bugholder/D.pkl.go b/codegen/snippet-tests/output/bugholder/D.pkl.go
index 3f57020..d4becf6 100644
--- a/codegen/snippet-tests/output/bugholder/D.pkl.go
+++ b/codegen/snippet-tests/output/bugholder/D.pkl.go
@@ -7,14 +7,14 @@ type D interface {
 	GetD() string
 }
 
-var _ D = (*DImpl)(nil)
+var _ D = DImpl{}
 
 type DImpl struct {
-	*CImpl
+	CImpl
 
 	D string `pkl:"d"`
 }
 
-func (rcv *DImpl) GetD() string {
+func (rcv DImpl) GetD() string {
 	return rcv.D
 }
diff --git a/codegen/snippet-tests/output/bugholder/Person.pkl.go b/codegen/snippet-tests/output/bugholder/Person.pkl.go
index b7fe930..e1b2993 100644
--- a/codegen/snippet-tests/output/bugholder/Person.pkl.go
+++ b/codegen/snippet-tests/output/bugholder/Person.pkl.go
@@ -4,7 +4,7 @@ package bugholder
 type Person interface {
 	Being
 
-	GetBike() *Bike
+	GetBike() Bike
 
 	GetFirstName() *uint16
 
@@ -13,13 +13,13 @@ type Person interface {
 	GetThings() map[int]struct{}
 }
 
-var _ Person = (*PersonImpl)(nil)
+var _ Person = PersonImpl{}
 
 // A Person!
 type PersonImpl struct {
 	IsAlive bool `pkl:"isAlive"`
 
-	Bike *Bike `pkl:"bike"`
+	Bike Bike `pkl:"bike"`
 
 	// The person's first name
 	FirstName *uint16 `pkl:"firstName"`
@@ -30,24 +30,24 @@ type PersonImpl struct {
 	Things map[int]struct{} `pkl:"things"`
 }
 
-func (rcv *PersonImpl) GetIsAlive() bool {
+func (rcv PersonImpl) GetIsAlive() bool {
 	return rcv.IsAlive
 }
 
-func (rcv *PersonImpl) GetBike() *Bike {
+func (rcv PersonImpl) GetBike() Bike {
 	return rcv.Bike
 }
 
 // The person's first name
-func (rcv *PersonImpl) GetFirstName() *uint16 {
+func (rcv PersonImpl) GetFirstName() *uint16 {
 	return rcv.FirstName
 }
 
 // The person's last name
-func (rcv *PersonImpl) GetLastName() map[string]*uint32 {
+func (rcv PersonImpl) GetLastName() map[string]*uint32 {
 	return rcv.LastName
 }
 
-func (rcv *PersonImpl) GetThings() map[int]struct{} {
+func (rcv PersonImpl) GetThings() map[int]struct{} {
 	return rcv.Things
 }
diff --git a/codegen/snippet-tests/output/bugholder/ThisPerson.pkl.go b/codegen/snippet-tests/output/bugholder/ThisPerson.pkl.go
index ff66a6a..a1d3c77 100644
--- a/codegen/snippet-tests/output/bugholder/ThisPerson.pkl.go
+++ b/codegen/snippet-tests/output/bugholder/ThisPerson.pkl.go
@@ -9,20 +9,20 @@ type ThisPerson interface {
 	GetSomeoneElse() Person
 }
 
-var _ ThisPerson = (*ThisPersonImpl)(nil)
+var _ ThisPerson = ThisPersonImpl{}
 
 type ThisPersonImpl struct {
-	*PersonImpl
+	PersonImpl
 
 	Myself ThisPerson `pkl:"myself"`
 
 	SomeoneElse Person `pkl:"someoneElse"`
 }
 
-func (rcv *ThisPersonImpl) GetMyself() ThisPerson {
+func (rcv ThisPersonImpl) GetMyself() ThisPerson {
 	return rcv.Myself
 }
 
-func (rcv *ThisPersonImpl) GetSomeoneElse() Person {
+func (rcv ThisPersonImpl) GetSomeoneElse() Person {
 	return rcv.SomeoneElse
 }
diff --git a/codegen/snippet-tests/output/bugholder/init.pkl.go b/codegen/snippet-tests/output/bugholder/init.pkl.go
index 6194911..4fb0797 100644
--- a/codegen/snippet-tests/output/bugholder/init.pkl.go
+++ b/codegen/snippet-tests/output/bugholder/init.pkl.go
@@ -4,13 +4,13 @@ package bugholder
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("org.foo.BugHolder", BugHolder{})
-	pkl.RegisterMapping("org.foo.BugHolder#Bug", Bug{})
-	pkl.RegisterMapping("org.foo.BugHolder#Person", PersonImpl{})
-	pkl.RegisterMapping("org.foo.BugHolder#Bike", Bike{})
-	pkl.RegisterMapping("org.foo.BugHolder#Wheel", Wheel{})
-	pkl.RegisterMapping("org.foo.BugHolder#ThisPerson", ThisPersonImpl{})
-	pkl.RegisterMapping("org.foo.BugHolder#D", DImpl{})
-	pkl.RegisterMapping("org.foo.BugHolder#C", CImpl{})
-	pkl.RegisterMapping("org.foo.BugHolder#B", BImpl{})
+	pkl.RegisterStrictMapping("org.foo.BugHolder", BugHolder{})
+	pkl.RegisterStrictMapping("org.foo.BugHolder#Bug", Bug{})
+	pkl.RegisterStrictMapping("org.foo.BugHolder#Person", PersonImpl{})
+	pkl.RegisterStrictMapping("org.foo.BugHolder#Bike", Bike{})
+	pkl.RegisterStrictMapping("org.foo.BugHolder#Wheel", Wheel{})
+	pkl.RegisterStrictMapping("org.foo.BugHolder#ThisPerson", ThisPersonImpl{})
+	pkl.RegisterStrictMapping("org.foo.BugHolder#D", DImpl{})
+	pkl.RegisterStrictMapping("org.foo.BugHolder#C", CImpl{})
+	pkl.RegisterStrictMapping("org.foo.BugHolder#B", BImpl{})
 }
diff --git a/codegen/snippet-tests/output/cyclicmodule/CyclicModule.pkl.go b/codegen/snippet-tests/output/cyclicmodule/CyclicModule.pkl.go
index 0c186c6..333aa7f 100644
--- a/codegen/snippet-tests/output/cyclicmodule/CyclicModule.pkl.go
+++ b/codegen/snippet-tests/output/cyclicmodule/CyclicModule.pkl.go
@@ -8,14 +8,14 @@ import (
 )
 
 type CyclicModule struct {
-	Thing *Cyclic `pkl:"thing"`
+	Thing Cyclic `pkl:"thing"`
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a CyclicModule
-func LoadFromPath(ctx context.Context, path string) (ret *CyclicModule, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret CyclicModule, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -28,10 +28,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *CyclicModule, err erro
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a CyclicModule
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*CyclicModule, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (CyclicModule, error) {
 	var ret CyclicModule
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/cyclicmodule/init.pkl.go b/codegen/snippet-tests/output/cyclicmodule/init.pkl.go
index 6df5e7a..b780897 100644
--- a/codegen/snippet-tests/output/cyclicmodule/init.pkl.go
+++ b/codegen/snippet-tests/output/cyclicmodule/init.pkl.go
@@ -4,6 +4,6 @@ package cyclicmodule
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("CyclicModule", CyclicModule{})
-	pkl.RegisterMapping("CyclicModule#Cyclic", Cyclic{})
+	pkl.RegisterStrictMapping("CyclicModule", CyclicModule{})
+	pkl.RegisterStrictMapping("CyclicModule#Cyclic", Cyclic{})
 }
diff --git a/codegen/snippet-tests/output/emptyopenmodule/EmptyOpenModule.pkl.go b/codegen/snippet-tests/output/emptyopenmodule/EmptyOpenModule.pkl.go
index ed2c8d1..fe35a52 100644
--- a/codegen/snippet-tests/output/emptyopenmodule/EmptyOpenModule.pkl.go
+++ b/codegen/snippet-tests/output/emptyopenmodule/EmptyOpenModule.pkl.go
@@ -10,7 +10,7 @@ import (
 type EmptyOpenModule interface {
 }
 
-var _ EmptyOpenModule = (*EmptyOpenModuleImpl)(nil)
+var _ EmptyOpenModule = EmptyOpenModuleImpl{}
 
 type EmptyOpenModuleImpl struct {
 }
@@ -19,7 +19,7 @@ type EmptyOpenModuleImpl struct {
 func LoadFromPath(ctx context.Context, path string) (ret EmptyOpenModule, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -34,8 +34,6 @@ func LoadFromPath(ctx context.Context, path string) (ret EmptyOpenModule, err er
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a EmptyOpenModule
 func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (EmptyOpenModule, error) {
 	var ret EmptyOpenModuleImpl
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/emptyopenmodule/init.pkl.go b/codegen/snippet-tests/output/emptyopenmodule/init.pkl.go
index e93cc11..84766e1 100644
--- a/codegen/snippet-tests/output/emptyopenmodule/init.pkl.go
+++ b/codegen/snippet-tests/output/emptyopenmodule/init.pkl.go
@@ -4,5 +4,5 @@ package emptyopenmodule
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("EmptyOpenModule", EmptyOpenModuleImpl{})
+	pkl.RegisterStrictMapping("EmptyOpenModule", EmptyOpenModuleImpl{})
 }
diff --git a/codegen/snippet-tests/output/explicitname/ExplicitlyCoolName.pkl.go b/codegen/snippet-tests/output/explicitname/ExplicitlyCoolName.pkl.go
index 414aef2..82d6d9b 100644
--- a/codegen/snippet-tests/output/explicitname/ExplicitlyCoolName.pkl.go
+++ b/codegen/snippet-tests/output/explicitname/ExplicitlyCoolName.pkl.go
@@ -8,14 +8,14 @@ import (
 )
 
 type ExplicitlyCoolName struct {
-	MyCoolProp *SomethingVeryFunny `pkl:"myProp"`
+	MyCoolProp SomethingVeryFunny `pkl:"myProp"`
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a ExplicitlyCoolName
-func LoadFromPath(ctx context.Context, path string) (ret *ExplicitlyCoolName, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret ExplicitlyCoolName, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -28,10 +28,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *ExplicitlyCoolName, er
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a ExplicitlyCoolName
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*ExplicitlyCoolName, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (ExplicitlyCoolName, error) {
 	var ret ExplicitlyCoolName
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/explicitname/init.pkl.go b/codegen/snippet-tests/output/explicitname/init.pkl.go
index 6276cb7..b7a3202 100644
--- a/codegen/snippet-tests/output/explicitname/init.pkl.go
+++ b/codegen/snippet-tests/output/explicitname/init.pkl.go
@@ -4,6 +4,6 @@ package explicitname
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("ExplicitName", ExplicitlyCoolName{})
-	pkl.RegisterMapping("ExplicitName#SomethingFunny", SomethingVeryFunny{})
+	pkl.RegisterStrictMapping("ExplicitName", ExplicitlyCoolName{})
+	pkl.RegisterStrictMapping("ExplicitName#SomethingFunny", SomethingVeryFunny{})
 }
diff --git a/codegen/snippet-tests/output/extendabstractclass/C.pkl.go b/codegen/snippet-tests/output/extendabstractclass/C.pkl.go
index e3cfb86..926b28f 100644
--- a/codegen/snippet-tests/output/extendabstractclass/C.pkl.go
+++ b/codegen/snippet-tests/output/extendabstractclass/C.pkl.go
@@ -12,7 +12,7 @@ type C interface {
 	GetD() string
 }
 
-var _ C = (*CImpl)(nil)
+var _ C = CImpl{}
 
 type CImpl struct {
 	B string `pkl:"b"`
@@ -24,18 +24,18 @@ type CImpl struct {
 	C lib3.GoGoGo `pkl:"c"`
 }
 
-func (rcv *CImpl) GetB() string {
+func (rcv CImpl) GetB() string {
 	return rcv.B
 }
 
-func (rcv *CImpl) GetD() string {
+func (rcv CImpl) GetD() string {
 	return rcv.D
 }
 
-func (rcv *CImpl) GetE() cities.Cities {
+func (rcv CImpl) GetE() cities.Cities {
 	return rcv.E
 }
 
-func (rcv *CImpl) GetC() lib3.GoGoGo {
+func (rcv CImpl) GetC() lib3.GoGoGo {
 	return rcv.C
 }
diff --git a/codegen/snippet-tests/output/extendabstractclass/ExtendsAbstractClass.pkl.go b/codegen/snippet-tests/output/extendabstractclass/ExtendsAbstractClass.pkl.go
index 8599679..f5f9706 100644
--- a/codegen/snippet-tests/output/extendabstractclass/ExtendsAbstractClass.pkl.go
+++ b/codegen/snippet-tests/output/extendabstractclass/ExtendsAbstractClass.pkl.go
@@ -12,10 +12,10 @@ type ExtendsAbstractClass struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a ExtendsAbstractClass
-func LoadFromPath(ctx context.Context, path string) (ret *ExtendsAbstractClass, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret ExtendsAbstractClass, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -28,10 +28,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *ExtendsAbstractClass,
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a ExtendsAbstractClass
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*ExtendsAbstractClass, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (ExtendsAbstractClass, error) {
 	var ret ExtendsAbstractClass
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/extendabstractclass/init.pkl.go b/codegen/snippet-tests/output/extendabstractclass/init.pkl.go
index b81171f..c73e576 100644
--- a/codegen/snippet-tests/output/extendabstractclass/init.pkl.go
+++ b/codegen/snippet-tests/output/extendabstractclass/init.pkl.go
@@ -4,6 +4,6 @@ package extendabstractclass
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("ExtendsAbstractClass", ExtendsAbstractClass{})
-	pkl.RegisterMapping("ExtendsAbstractClass#C", CImpl{})
+	pkl.RegisterStrictMapping("ExtendsAbstractClass", ExtendsAbstractClass{})
+	pkl.RegisterStrictMapping("ExtendsAbstractClass#C", CImpl{})
 }
diff --git a/codegen/snippet-tests/output/extendmodule/ExtendModule.pkl.go b/codegen/snippet-tests/output/extendmodule/ExtendModule.pkl.go
index 936de62..081e4ff 100644
--- a/codegen/snippet-tests/output/extendmodule/ExtendModule.pkl.go
+++ b/codegen/snippet-tests/output/extendmodule/ExtendModule.pkl.go
@@ -14,15 +14,15 @@ type ExtendModule interface {
 	GetBar() string
 }
 
-var _ ExtendModule = (*ExtendModuleImpl)(nil)
+var _ ExtendModule = ExtendModuleImpl{}
 
 type ExtendModuleImpl struct {
-	*openmodule.MyModuleImpl
+	openmodule.MyModuleImpl
 
 	Bar string `pkl:"bar"`
 }
 
-func (rcv *ExtendModuleImpl) GetBar() string {
+func (rcv ExtendModuleImpl) GetBar() string {
 	return rcv.Bar
 }
 
@@ -30,7 +30,7 @@ func (rcv *ExtendModuleImpl) GetBar() string {
 func LoadFromPath(ctx context.Context, path string) (ret ExtendModule, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -45,8 +45,6 @@ func LoadFromPath(ctx context.Context, path string) (ret ExtendModule, err error
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a ExtendModule
 func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (ExtendModule, error) {
 	var ret ExtendModuleImpl
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/extendmodule/init.pkl.go b/codegen/snippet-tests/output/extendmodule/init.pkl.go
index ec9f22a..3ff107d 100644
--- a/codegen/snippet-tests/output/extendmodule/init.pkl.go
+++ b/codegen/snippet-tests/output/extendmodule/init.pkl.go
@@ -4,5 +4,5 @@ package extendmodule
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("ExtendModule", ExtendModuleImpl{})
+	pkl.RegisterStrictMapping("ExtendModule", ExtendModuleImpl{})
 }
diff --git a/codegen/snippet-tests/output/extendopenclass/ExtendingOpenClass.pkl.go b/codegen/snippet-tests/output/extendopenclass/ExtendingOpenClass.pkl.go
index b03cf7b..a7448b6 100644
--- a/codegen/snippet-tests/output/extendopenclass/ExtendingOpenClass.pkl.go
+++ b/codegen/snippet-tests/output/extendopenclass/ExtendingOpenClass.pkl.go
@@ -14,10 +14,10 @@ type ExtendingOpenClass struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a ExtendingOpenClass
-func LoadFromPath(ctx context.Context, path string) (ret *ExtendingOpenClass, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret ExtendingOpenClass, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -30,10 +30,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *ExtendingOpenClass, er
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a ExtendingOpenClass
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*ExtendingOpenClass, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (ExtendingOpenClass, error) {
 	var ret ExtendingOpenClass
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/extendopenclass/MyClass.pkl.go b/codegen/snippet-tests/output/extendopenclass/MyClass.pkl.go
index ab5a4b1..d542203 100644
--- a/codegen/snippet-tests/output/extendopenclass/MyClass.pkl.go
+++ b/codegen/snippet-tests/output/extendopenclass/MyClass.pkl.go
@@ -7,14 +7,14 @@ type MyClass interface {
 	GetMyBoolean() bool
 }
 
-var _ MyClass = (*MyClassImpl)(nil)
+var _ MyClass = MyClassImpl{}
 
 type MyClassImpl struct {
-	*MyOpenClassImpl
+	MyOpenClassImpl
 
 	MyBoolean bool `pkl:"myBoolean"`
 }
 
-func (rcv *MyClassImpl) GetMyBoolean() bool {
+func (rcv MyClassImpl) GetMyBoolean() bool {
 	return rcv.MyBoolean
 }
diff --git a/codegen/snippet-tests/output/extendopenclass/MyClass2.pkl.go b/codegen/snippet-tests/output/extendopenclass/MyClass2.pkl.go
index 75f0f83..c534e84 100644
--- a/codegen/snippet-tests/output/extendopenclass/MyClass2.pkl.go
+++ b/codegen/snippet-tests/output/extendopenclass/MyClass2.pkl.go
@@ -9,14 +9,14 @@ type MyClass2 interface {
 	GetMyBoolean() bool
 }
 
-var _ MyClass2 = (*MyClass2Impl)(nil)
+var _ MyClass2 = MyClass2Impl{}
 
 type MyClass2Impl struct {
-	*lib3.GoGoGoImpl
+	lib3.GoGoGoImpl
 
 	MyBoolean bool `pkl:"myBoolean"`
 }
 
-func (rcv *MyClass2Impl) GetMyBoolean() bool {
+func (rcv MyClass2Impl) GetMyBoolean() bool {
 	return rcv.MyBoolean
 }
diff --git a/codegen/snippet-tests/output/extendopenclass/MyOpenClass.pkl.go b/codegen/snippet-tests/output/extendopenclass/MyOpenClass.pkl.go
index aa1f64f..e7e1d30 100644
--- a/codegen/snippet-tests/output/extendopenclass/MyOpenClass.pkl.go
+++ b/codegen/snippet-tests/output/extendopenclass/MyOpenClass.pkl.go
@@ -5,12 +5,12 @@ type MyOpenClass interface {
 	GetMyStr() string
 }
 
-var _ MyOpenClass = (*MyOpenClassImpl)(nil)
+var _ MyOpenClass = MyOpenClassImpl{}
 
 type MyOpenClassImpl struct {
 	MyStr string `pkl:"myStr"`
 }
 
-func (rcv *MyOpenClassImpl) GetMyStr() string {
+func (rcv MyOpenClassImpl) GetMyStr() string {
 	return rcv.MyStr
 }
diff --git a/codegen/snippet-tests/output/extendopenclass/init.pkl.go b/codegen/snippet-tests/output/extendopenclass/init.pkl.go
index 9a8e3a6..770d95b 100644
--- a/codegen/snippet-tests/output/extendopenclass/init.pkl.go
+++ b/codegen/snippet-tests/output/extendopenclass/init.pkl.go
@@ -4,8 +4,8 @@ package extendopenclass
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("ExtendingOpenClass", ExtendingOpenClass{})
-	pkl.RegisterMapping("ExtendingOpenClass#MyClass", MyClassImpl{})
-	pkl.RegisterMapping("ExtendingOpenClass#MyOpenClass", MyOpenClassImpl{})
-	pkl.RegisterMapping("ExtendingOpenClass#MyClass2", MyClass2Impl{})
+	pkl.RegisterStrictMapping("ExtendingOpenClass", ExtendingOpenClass{})
+	pkl.RegisterStrictMapping("ExtendingOpenClass#MyClass", MyClassImpl{})
+	pkl.RegisterStrictMapping("ExtendingOpenClass#MyOpenClass", MyOpenClassImpl{})
+	pkl.RegisterStrictMapping("ExtendingOpenClass#MyClass2", MyClass2Impl{})
 }
diff --git a/codegen/snippet-tests/output/hiddenproperties/HiddenProperties.pkl.go b/codegen/snippet-tests/output/hiddenproperties/HiddenProperties.pkl.go
index 8ae108b..4eb18a6 100644
--- a/codegen/snippet-tests/output/hiddenproperties/HiddenProperties.pkl.go
+++ b/codegen/snippet-tests/output/hiddenproperties/HiddenProperties.pkl.go
@@ -12,10 +12,10 @@ type HiddenProperties struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a HiddenProperties
-func LoadFromPath(ctx context.Context, path string) (ret *HiddenProperties, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret HiddenProperties, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -28,10 +28,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *HiddenProperties, err
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a HiddenProperties
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*HiddenProperties, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (HiddenProperties, error) {
 	var ret HiddenProperties
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/hiddenproperties/init.pkl.go b/codegen/snippet-tests/output/hiddenproperties/init.pkl.go
index bb3d86f..da8e6a3 100644
--- a/codegen/snippet-tests/output/hiddenproperties/init.pkl.go
+++ b/codegen/snippet-tests/output/hiddenproperties/init.pkl.go
@@ -4,5 +4,5 @@ package hiddenproperties
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("HiddenProperties", HiddenProperties{})
+	pkl.RegisterStrictMapping("HiddenProperties", HiddenProperties{})
 }
diff --git a/codegen/snippet-tests/output/moduletype/ModuleType.pkl.go b/codegen/snippet-tests/output/moduletype/ModuleType.pkl.go
index 2f60f2b..5bebd41 100644
--- a/codegen/snippet-tests/output/moduletype/ModuleType.pkl.go
+++ b/codegen/snippet-tests/output/moduletype/ModuleType.pkl.go
@@ -13,16 +13,16 @@ type ModuleType struct {
 
 	Foo *ModuleType `pkl:"foo"`
 
-	Lib *lib4.MyLib4 `pkl:"lib"`
+	Lib lib4.MyLib4 `pkl:"lib"`
 
 	FooAgain *ModuleType `pkl:"fooAgain"`
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a ModuleType
-func LoadFromPath(ctx context.Context, path string) (ret *ModuleType, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret ModuleType, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -35,10 +35,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *ModuleType, err error)
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a ModuleType
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*ModuleType, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (ModuleType, error) {
 	var ret ModuleType
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/moduletype/init.pkl.go b/codegen/snippet-tests/output/moduletype/init.pkl.go
index 3327f60..2e6427d 100644
--- a/codegen/snippet-tests/output/moduletype/init.pkl.go
+++ b/codegen/snippet-tests/output/moduletype/init.pkl.go
@@ -4,5 +4,5 @@ package moduletype
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("ModuleType", ModuleType{})
+	pkl.RegisterStrictMapping("ModuleType", ModuleType{})
 }
diff --git a/codegen/snippet-tests/output/moduleusinglib/ModuleUsingLib.pkl.go b/codegen/snippet-tests/output/moduleusinglib/ModuleUsingLib.pkl.go
index e024d9d..273340c 100644
--- a/codegen/snippet-tests/output/moduleusinglib/ModuleUsingLib.pkl.go
+++ b/codegen/snippet-tests/output/moduleusinglib/ModuleUsingLib.pkl.go
@@ -21,10 +21,10 @@ type ModuleUsingLib struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a ModuleUsingLib
-func LoadFromPath(ctx context.Context, path string) (ret *ModuleUsingLib, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret ModuleUsingLib, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -37,10 +37,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *ModuleUsingLib, err er
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a ModuleUsingLib
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*ModuleUsingLib, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (ModuleUsingLib, error) {
 	var ret ModuleUsingLib
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/moduleusinglib/init.pkl.go b/codegen/snippet-tests/output/moduleusinglib/init.pkl.go
index 1586561..380d0c5 100644
--- a/codegen/snippet-tests/output/moduleusinglib/init.pkl.go
+++ b/codegen/snippet-tests/output/moduleusinglib/init.pkl.go
@@ -4,5 +4,5 @@ package moduleusinglib
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("ModuleUsingLib", ModuleUsingLib{})
+	pkl.RegisterStrictMapping("ModuleUsingLib", ModuleUsingLib{})
 }
diff --git a/codegen/snippet-tests/output/override/Bar.pkl.go b/codegen/snippet-tests/output/override/Bar.pkl.go
index 8ae0e66..d54ad85 100644
--- a/codegen/snippet-tests/output/override/Bar.pkl.go
+++ b/codegen/snippet-tests/output/override/Bar.pkl.go
@@ -5,12 +5,12 @@ type Bar interface {
 	Foo
 }
 
-var _ Bar = (*BarImpl)(nil)
+var _ Bar = BarImpl{}
 
 type BarImpl struct {
 	MyProp string `pkl:"myProp"`
 }
 
-func (rcv *BarImpl) GetMyProp() string {
+func (rcv BarImpl) GetMyProp() string {
 	return rcv.MyProp
 }
diff --git a/codegen/snippet-tests/output/override/Override.pkl.go b/codegen/snippet-tests/output/override/Override.pkl.go
index b447298..6ac75f1 100644
--- a/codegen/snippet-tests/output/override/Override.pkl.go
+++ b/codegen/snippet-tests/output/override/Override.pkl.go
@@ -12,10 +12,10 @@ type Override struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a Override
-func LoadFromPath(ctx context.Context, path string) (ret *Override, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret Override, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -28,10 +28,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *Override, err error) {
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Override
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Override, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Override, error) {
 	var ret Override
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/override/init.pkl.go b/codegen/snippet-tests/output/override/init.pkl.go
index f51b9b5..955b31a 100644
--- a/codegen/snippet-tests/output/override/init.pkl.go
+++ b/codegen/snippet-tests/output/override/init.pkl.go
@@ -4,6 +4,6 @@ package override
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("override", Override{})
-	pkl.RegisterMapping("override#Bar", BarImpl{})
+	pkl.RegisterStrictMapping("override", Override{})
+	pkl.RegisterStrictMapping("override#Bar", BarImpl{})
 }
diff --git a/codegen/snippet-tests/output/override2/MySubclass.pkl.go b/codegen/snippet-tests/output/override2/MySubclass.pkl.go
index 0724854..1775168 100644
--- a/codegen/snippet-tests/output/override2/MySubclass.pkl.go
+++ b/codegen/snippet-tests/output/override2/MySubclass.pkl.go
@@ -7,16 +7,16 @@ type MySubclass interface {
 	GetFoo() string
 }
 
-var _ MySubclass = (*MySubclassImpl)(nil)
+var _ MySubclass = MySubclassImpl{}
 
 type MySubclassImpl struct {
-	*Override2Impl
+	Override2Impl
 
 	// Different doc comments
 	Foo string `pkl:"foo"`
 }
 
 // Different doc comments
-func (rcv *MySubclassImpl) GetFoo() string {
+func (rcv MySubclassImpl) GetFoo() string {
 	return rcv.Foo
 }
diff --git a/codegen/snippet-tests/output/override2/Override2.pkl.go b/codegen/snippet-tests/output/override2/Override2.pkl.go
index d35fd89..7271610 100644
--- a/codegen/snippet-tests/output/override2/Override2.pkl.go
+++ b/codegen/snippet-tests/output/override2/Override2.pkl.go
@@ -11,7 +11,7 @@ type Override2 interface {
 	GetFoo() string
 }
 
-var _ Override2 = (*Override2Impl)(nil)
+var _ Override2 = Override2Impl{}
 
 type Override2Impl struct {
 	// Doc comments
@@ -19,7 +19,7 @@ type Override2Impl struct {
 }
 
 // Doc comments
-func (rcv *Override2Impl) GetFoo() string {
+func (rcv Override2Impl) GetFoo() string {
 	return rcv.Foo
 }
 
@@ -27,7 +27,7 @@ func (rcv *Override2Impl) GetFoo() string {
 func LoadFromPath(ctx context.Context, path string) (ret Override2, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -42,8 +42,6 @@ func LoadFromPath(ctx context.Context, path string) (ret Override2, err error) {
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Override2
 func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Override2, error) {
 	var ret Override2Impl
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/override2/init.pkl.go b/codegen/snippet-tests/output/override2/init.pkl.go
index 921a38e..7d6e524 100644
--- a/codegen/snippet-tests/output/override2/init.pkl.go
+++ b/codegen/snippet-tests/output/override2/init.pkl.go
@@ -4,6 +4,6 @@ package override2
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("Override2", Override2Impl{})
-	pkl.RegisterMapping("Override2#MySubclass", MySubclassImpl{})
+	pkl.RegisterStrictMapping("Override2", Override2Impl{})
+	pkl.RegisterStrictMapping("Override2#MySubclass", MySubclassImpl{})
 }
diff --git a/codegen/snippet-tests/output/structtags/StructTags.pkl.go b/codegen/snippet-tests/output/structtags/StructTags.pkl.go
index d2f1004..cb77bb4 100644
--- a/codegen/snippet-tests/output/structtags/StructTags.pkl.go
+++ b/codegen/snippet-tests/output/structtags/StructTags.pkl.go
@@ -32,10 +32,10 @@ type StructTags struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a StructTags
-func LoadFromPath(ctx context.Context, path string) (ret *StructTags, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret StructTags, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -48,10 +48,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *StructTags, err error)
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a StructTags
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*StructTags, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (StructTags, error) {
 	var ret StructTags
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/structtags/init.pkl.go b/codegen/snippet-tests/output/structtags/init.pkl.go
index aee717b..e8648c0 100644
--- a/codegen/snippet-tests/output/structtags/init.pkl.go
+++ b/codegen/snippet-tests/output/structtags/init.pkl.go
@@ -4,5 +4,5 @@ package structtags
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("StructTags", StructTags{})
+	pkl.RegisterStrictMapping("StructTags", StructTags{})
 }
diff --git a/codegen/snippet-tests/output/support/lib/Lib.pkl.go b/codegen/snippet-tests/output/support/lib/Lib.pkl.go
index 3155a02..1d0fb06 100644
--- a/codegen/snippet-tests/output/support/lib/Lib.pkl.go
+++ b/codegen/snippet-tests/output/support/lib/Lib.pkl.go
@@ -11,10 +11,10 @@ type Lib struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a Lib
-func LoadFromPath(ctx context.Context, path string) (ret *Lib, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret Lib, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -27,10 +27,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *Lib, err error) {
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Lib
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Lib, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Lib, error) {
 	var ret Lib
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/support/lib/MyClass.pkl.go b/codegen/snippet-tests/output/support/lib/MyClass.pkl.go
index f1fe8c3..3da26e1 100644
--- a/codegen/snippet-tests/output/support/lib/MyClass.pkl.go
+++ b/codegen/snippet-tests/output/support/lib/MyClass.pkl.go
@@ -5,12 +5,12 @@ type MyClass interface {
 	GetThing() string
 }
 
-var _ MyClass = (*MyClassImpl)(nil)
+var _ MyClass = MyClassImpl{}
 
 type MyClassImpl struct {
 	Thing string `pkl:"thing"`
 }
 
-func (rcv *MyClassImpl) GetThing() string {
+func (rcv MyClassImpl) GetThing() string {
 	return rcv.Thing
 }
diff --git a/codegen/snippet-tests/output/support/lib/init.pkl.go b/codegen/snippet-tests/output/support/lib/init.pkl.go
index 599f09e..ce787fc 100644
--- a/codegen/snippet-tests/output/support/lib/init.pkl.go
+++ b/codegen/snippet-tests/output/support/lib/init.pkl.go
@@ -4,6 +4,6 @@ package lib
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("lib#MyClass", MyClassImpl{})
-	pkl.RegisterMapping("lib", Lib{})
+	pkl.RegisterStrictMapping("lib#MyClass", MyClassImpl{})
+	pkl.RegisterStrictMapping("lib", Lib{})
 }
diff --git a/codegen/snippet-tests/output/support/lib3/GoGoGo.pkl.go b/codegen/snippet-tests/output/support/lib3/GoGoGo.pkl.go
index d2e18b7..20c27b5 100644
--- a/codegen/snippet-tests/output/support/lib3/GoGoGo.pkl.go
+++ b/codegen/snippet-tests/output/support/lib3/GoGoGo.pkl.go
@@ -5,12 +5,12 @@ type GoGoGo interface {
 	GetDuck() string
 }
 
-var _ GoGoGo = (*GoGoGoImpl)(nil)
+var _ GoGoGo = GoGoGoImpl{}
 
 type GoGoGoImpl struct {
 	Duck string `pkl:"duck"`
 }
 
-func (rcv *GoGoGoImpl) GetDuck() string {
+func (rcv GoGoGoImpl) GetDuck() string {
 	return rcv.Duck
 }
diff --git a/codegen/snippet-tests/output/support/lib3/Lib3.pkl.go b/codegen/snippet-tests/output/support/lib3/Lib3.pkl.go
index 4d31e86..caf279d 100644
--- a/codegen/snippet-tests/output/support/lib3/Lib3.pkl.go
+++ b/codegen/snippet-tests/output/support/lib3/Lib3.pkl.go
@@ -11,10 +11,10 @@ type Lib3 struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a Lib3
-func LoadFromPath(ctx context.Context, path string) (ret *Lib3, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret Lib3, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -27,10 +27,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *Lib3, err error) {
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Lib3
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Lib3, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Lib3, error) {
 	var ret Lib3
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/support/lib3/init.pkl.go b/codegen/snippet-tests/output/support/lib3/init.pkl.go
index c0a6088..c5aeab6 100644
--- a/codegen/snippet-tests/output/support/lib3/init.pkl.go
+++ b/codegen/snippet-tests/output/support/lib3/init.pkl.go
@@ -4,6 +4,6 @@ package lib3
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("lib3#GoGoGo", GoGoGoImpl{})
-	pkl.RegisterMapping("lib3", Lib3{})
+	pkl.RegisterStrictMapping("lib3#GoGoGo", GoGoGoImpl{})
+	pkl.RegisterStrictMapping("lib3", Lib3{})
 }
diff --git a/codegen/snippet-tests/output/support/lib4/Lib4.pkl.go b/codegen/snippet-tests/output/support/lib4/Lib4.pkl.go
index 7626de8..7f7c070 100644
--- a/codegen/snippet-tests/output/support/lib4/Lib4.pkl.go
+++ b/codegen/snippet-tests/output/support/lib4/Lib4.pkl.go
@@ -12,10 +12,10 @@ type Lib4 struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a Lib4
-func LoadFromPath(ctx context.Context, path string) (ret *Lib4, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret Lib4, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -28,10 +28,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *Lib4, err error) {
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Lib4
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Lib4, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Lib4, error) {
 	var ret Lib4
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/support/lib4/MyLib4.pkl.go b/codegen/snippet-tests/output/support/lib4/MyLib4.pkl.go
index ba1ee23..360454e 100644
--- a/codegen/snippet-tests/output/support/lib4/MyLib4.pkl.go
+++ b/codegen/snippet-tests/output/support/lib4/MyLib4.pkl.go
@@ -2,5 +2,5 @@
 package lib4
 
 type MyLib4 struct {
-	Foo *Lib4 `pkl:"foo"`
+	Foo Lib4 `pkl:"foo"`
 }
diff --git a/codegen/snippet-tests/output/support/lib4/init.pkl.go b/codegen/snippet-tests/output/support/lib4/init.pkl.go
index bde57fc..f88c085 100644
--- a/codegen/snippet-tests/output/support/lib4/init.pkl.go
+++ b/codegen/snippet-tests/output/support/lib4/init.pkl.go
@@ -4,6 +4,6 @@ package lib4
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("lib4#MyLib4", MyLib4{})
-	pkl.RegisterMapping("lib4", Lib4{})
+	pkl.RegisterStrictMapping("lib4#MyLib4", MyLib4{})
+	pkl.RegisterStrictMapping("lib4", Lib4{})
 }
diff --git a/codegen/snippet-tests/output/support/openmodule/MyModule.pkl.go b/codegen/snippet-tests/output/support/openmodule/MyModule.pkl.go
index 819cd6f..5868732 100644
--- a/codegen/snippet-tests/output/support/openmodule/MyModule.pkl.go
+++ b/codegen/snippet-tests/output/support/openmodule/MyModule.pkl.go
@@ -11,13 +11,13 @@ type MyModule interface {
 	GetFoo() string
 }
 
-var _ MyModule = (*MyModuleImpl)(nil)
+var _ MyModule = MyModuleImpl{}
 
 type MyModuleImpl struct {
 	Foo string `pkl:"foo"`
 }
 
-func (rcv *MyModuleImpl) GetFoo() string {
+func (rcv MyModuleImpl) GetFoo() string {
 	return rcv.Foo
 }
 
@@ -25,7 +25,7 @@ func (rcv *MyModuleImpl) GetFoo() string {
 func LoadFromPath(ctx context.Context, path string) (ret MyModule, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -40,8 +40,6 @@ func LoadFromPath(ctx context.Context, path string) (ret MyModule, err error) {
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a MyModule
 func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (MyModule, error) {
 	var ret MyModuleImpl
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/support/openmodule/init.pkl.go b/codegen/snippet-tests/output/support/openmodule/init.pkl.go
index a1e95c5..e58119a 100644
--- a/codegen/snippet-tests/output/support/openmodule/init.pkl.go
+++ b/codegen/snippet-tests/output/support/openmodule/init.pkl.go
@@ -4,5 +4,5 @@ package openmodule
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("MyModule", MyModuleImpl{})
+	pkl.RegisterStrictMapping("MyModule", MyModuleImpl{})
 }
diff --git a/codegen/snippet-tests/output/union/Union.pkl.go b/codegen/snippet-tests/output/union/Union.pkl.go
index 6b26ed1..408d0c5 100644
--- a/codegen/snippet-tests/output/union/Union.pkl.go
+++ b/codegen/snippet-tests/output/union/Union.pkl.go
@@ -26,10 +26,10 @@ type Union struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a Union
-func LoadFromPath(ctx context.Context, path string) (ret *Union, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret Union, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -42,10 +42,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *Union, err error) {
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Union
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Union, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Union, error) {
 	var ret Union
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/union/init.pkl.go b/codegen/snippet-tests/output/union/init.pkl.go
index 9fdf264..4cd7e70 100644
--- a/codegen/snippet-tests/output/union/init.pkl.go
+++ b/codegen/snippet-tests/output/union/init.pkl.go
@@ -4,5 +4,5 @@ package union
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("union", Union{})
+	pkl.RegisterStrictMapping("union", Union{})
 }
diff --git a/codegen/snippet-tests/output/unionnamekeyword/UnionNameKeyword.pkl.go b/codegen/snippet-tests/output/unionnamekeyword/UnionNameKeyword.pkl.go
index d7ee5e9..ed44174 100644
--- a/codegen/snippet-tests/output/unionnamekeyword/UnionNameKeyword.pkl.go
+++ b/codegen/snippet-tests/output/unionnamekeyword/UnionNameKeyword.pkl.go
@@ -13,10 +13,10 @@ type UnionNameKeyword struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a UnionNameKeyword
-func LoadFromPath(ctx context.Context, path string) (ret *UnionNameKeyword, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret UnionNameKeyword, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -29,10 +29,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *UnionNameKeyword, err
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a UnionNameKeyword
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*UnionNameKeyword, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (UnionNameKeyword, error) {
 	var ret UnionNameKeyword
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/codegen/snippet-tests/output/unionnamekeyword/init.pkl.go b/codegen/snippet-tests/output/unionnamekeyword/init.pkl.go
index 7690ede..d8f63bc 100644
--- a/codegen/snippet-tests/output/unionnamekeyword/init.pkl.go
+++ b/codegen/snippet-tests/output/unionnamekeyword/init.pkl.go
@@ -4,5 +4,5 @@ package unionnamekeyword
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("UnionNameKeyword", UnionNameKeyword{})
+	pkl.RegisterStrictMapping("UnionNameKeyword", UnionNameKeyword{})
 }
diff --git a/codegen/src/internal/ClassGen.pkl b/codegen/src/internal/ClassGen.pkl
index 14b1159..7761ab7 100644
--- a/codegen/src/internal/ClassGen.pkl
+++ b/codegen/src/internal/ClassGen.pkl
@@ -43,7 +43,7 @@ contents = new Listing {
     interface
     when (!isAbstract) {
       ""
-      "var _ \(classInfo.interface.name) = (\(classInfo.struct.type.render(classInfo.goPackage)))(nil)"
+      "var _ \(classInfo.interface.name) = \(classInfo.struct.type.render(classInfo.goPackage)){}"
     }
   }
   when (!isAbstract) {
@@ -60,7 +60,7 @@ contents = new Listing {
     "func LoadFromPath(ctx context.Context, path string) (ret \(classInfo.type.render(classInfo.goPackage)), err error) {"
     "\tevaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)"
     "\tif err != nil {"
-    "\t\treturn nil, err"
+    "\t\treturn ret, err"
     "\t}"
     "\tdefer func() {"
     "\t\tcerr := evaluator.Close()"
@@ -75,10 +75,8 @@ contents = new Listing {
     "// Load loads the pkl module at the given source and evaluates it with the given evaluator into a \(classInfo.name)"
     "func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (\(classInfo.type.render(classInfo.goPackage)), error) {"
     "\tvar ret \(classInfo.struct.name)"
-    "\tif err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {"
-    "\t\treturn nil, err"
-    "\t}"
-    "\treturn &ret, nil"
+    "\terr := evaluator.EvaluateModule(ctx, source, &ret)"
+    "\treturn ret, err"
     "}"
   }
   ""
@@ -201,7 +199,7 @@ local interface: String? =
       new Listing {
         "type \(classInfo.interface.name) interface {"
         when (superClass != null) {
-          "\t\(superClass.type.render(classInfo.goPackage))"
+          "\t\(superClass.interface.type.render(classInfo.goPackage))"
           when (!methodsToGenerate.isEmpty) {
             ""
           }
@@ -280,4 +278,4 @@ local class GoStructField {
 
   /// The Pkl property behind the field
   property: reflect.Property
-}
+}
\ No newline at end of file
diff --git a/codegen/src/internal/GoMapping.pkl b/codegen/src/internal/GoMapping.pkl
index 2a68557..357ca20 100644
--- a/codegen/src/internal/GoMapping.pkl
+++ b/codegen/src/internal/GoMapping.pkl
@@ -108,18 +108,16 @@ class Class extends GoMapping {
   struct: Struct? =
     if (clazz.modifiers.contains("abstract")) null
     else
-      let (structName =  if (interface == null) name else "\(name)Impl")
+      let (structName = if (self.interface == null) name else "\(self.name)Impl")
         new Struct {
           name = structName
           clazz = self.clazz
-          type = new Type.Pointer {
-            elem = new Type.Declared {
+          type = new Type.Declared {
               typeName = structName
               importPath = self.goPackage
               package = self.goPackageShort
             }
           }
-        }
 
 }
 
diff --git a/codegen/src/internal/Package.pkl b/codegen/src/internal/Package.pkl
index 8948384..8cb8f8f 100644
--- a/codegen/src/internal/Package.pkl
+++ b/codegen/src/internal/Package.pkl
@@ -94,7 +94,7 @@ local initFile: String =
     ""
     "func init() {"
     for (struct in structs) {
-        #"\#tpkl.RegisterMapping(\#(utils.toGoString(struct.clazz.reflectee.toString())), \#(struct.name){})"#
+        #"\#tpkl.RegisterStrictMapping(\#(utils.toGoString(struct.clazz.reflectee.toString())), \#(struct.name){})"#
     }
     "}"
     ""
diff --git a/codegen/src/internal/typegen.pkl b/codegen/src/internal/typegen.pkl
index 63f9f65..faad02a 100644
--- a/codegen/src/internal/typegen.pkl
+++ b/codegen/src/internal/typegen.pkl
@@ -27,17 +27,17 @@ function generateType(
   enclosing: reflect.TypeDeclaration,
   seenMappings: List<GoMapping>
 ): Type =
-  if (type is reflect.DeclaredType)
+  if (type is reflect.NullableType)
+    let (_elem = generateType(type.member, enclosing, seenMappings))
+      // No double pointers
+      if (_elem is Type.Pointer) _elem
+      else new Type.Pointer { elem = _elem }
+  else if (type is reflect.DeclaredType)
     generateDeclaredType(type, enclosing, seenMappings)
   else if (type is reflect.ModuleType)
     let (moduleClass = enclosing.enclosingDeclaration.moduleClass)
       generateType(reflect.DeclaredType(moduleClass), moduleClass, seenMappings)
   else if (type is reflect.UnionType) generateUnionType(type, seenMappings)
-  else if (type is reflect.NullableType)
-    let (_elem = generateType(type.member, enclosing, seenMappings))
-      // No double pointers
-      if (_elem is Type.Pointer) _elem
-      else new Type.Pointer { elem = _elem }
   else if (type is reflect.UnknownType) anyType
   else if (type is reflect.NothingType) throw("Unable to generate Go for the `nothing` type")
   else if (type is reflect.StringLiteralType) new Type.Declared { typeName = "string" }
@@ -152,31 +152,25 @@ mappedTypes: Mapping<Class|TypeAlias, Type> = new {
   [Boolean] = new Type.Declared { typeName = "bool" }
   [Null] = anyType
   [Any] = anyType
-  [Duration] = new Type.Pointer {
-    elem = new Type.Declared {
-      package = "pkl"
-      typeName = "Duration"
-      importPath = "github.com/apple/pkl-go/pkl"
-    }
+  [Duration] = new Type.Declared {
+    package = "pkl"
+    typeName = "Duration"
+    importPath = "github.com/apple/pkl-go/pkl"
   }
   [DurationUnit] = new Type.Declared {
     package = "pkl"
     typeName = "DurationUnit"
     importPath = "github.com/apple/pkl-go/pkl"
   }
-  [Dynamic] = new Type.Pointer {
-    elem = new Type.Declared {
-      package = "pkl"
-      typeName = "Object"
-      importPath = "github.com/apple/pkl-go/pkl"
-    }
+  [Dynamic] = new Type.Declared {
+    package = "pkl"
+    typeName = "Object"
+    importPath = "github.com/apple/pkl-go/pkl"
   }
-  [DataSize] = new Type.Pointer {
-    elem = new Type.Declared {
-      package = "pkl"
-      typeName = "DataSize"
-      importPath = "github.com/apple/pkl-go/pkl"
-    }
+  [DataSize] = new Type.Declared {
+    package = "pkl"
+    typeName = "DataSize"
+    importPath = "github.com/apple/pkl-go/pkl"
   }
   [DataSizeUnit] = new Type.Declared {
     package = "pkl"
diff --git a/codegen/src/tests/typegen.pkl b/codegen/src/tests/typegen.pkl
index e34f12a..85887b0 100644
--- a/codegen/src/tests/typegen.pkl
+++ b/codegen/src/tests/typegen.pkl
@@ -80,9 +80,9 @@ facts {
     generateType(reflect.uint32Type) == "uint32"
     generateType(reflect.uintType) == "uint"
     generateType(reflect.anyType) == "any"
-    generateType(reflect.dynamicType) == "*pkl.Object"
-    generateType(reflect.dataSizeType) == "*pkl.DataSize"
-    generateType(reflect.durationType) == "*pkl.Duration"
+    generateType(reflect.dynamicType) == "pkl.Object"
+    generateType(reflect.dataSizeType) == "pkl.DataSize"
+    generateType(reflect.durationType) == "pkl.Duration"
   }
   ["maps"] {
     generateType(reflectedMaps.properties["res1"].type) == "map[string]string"
diff --git a/pkl/decode_struct.go b/pkl/decode_struct.go
index 5a570cc..1b99bc0 100644
--- a/pkl/decode_struct.go
+++ b/pkl/decode_struct.go
@@ -149,13 +149,8 @@ func (d *decoder) decodeObjectGeneric(moduleUri, name string) (*reflect.Value, e
 	return &ret, nil
 }
 
-func (d *decoder) decodeTyped(name string, typ reflect.Type) (*reflect.Value, error) {
-	if t, exists := d.schemas[name]; exists {
-		// if we have a known schema by name, use that type instead of the input typ.
-		// this is important if the Pkl value is a subtype of the input type, e.g.
-		// in polymorphic cases.
-		typ = t
-	} else if typ.Kind() != reflect.Struct {
+func (d *decoder) doDecodeTyped(name string, typ reflect.Type) (*reflect.Value, error) {
+	if typ.Kind() != reflect.Struct {
 		return nil, fmt.Errorf("cannot decode Pkl value of type `%s` into Go type `%s`. Define a custom mapping for this using `pkl.RegisterMapping`", name, typ)
 	}
 	out, err := d.getOutputValue(typ)
@@ -175,6 +170,25 @@ func (d *decoder) decodeTyped(name string, typ reflect.Type) (*reflect.Value, er
 	return out, nil
 }
 
+func (d *decoder) decodeTyped(name string, typ reflect.Type) (*reflect.Value, error) {
+	if t, exists := d.schemas[name]; exists {
+		// if we have a known schema by name, use that type instead of the input type.
+		// this is important if the Pkl value is a subtype of the input type, e.g.
+		// in polymorphic cases.
+		typ = t
+	}
+	if typ.Kind() == reflect.Ptr {
+		underlying, err := d.doDecodeTyped(name, typ.Elem())
+		if err != nil {
+			return nil, err
+		}
+		ret := reflect.New(typ.Elem())
+		ret.Elem().Set(*underlying)
+		return &ret, nil
+	}
+	return d.doDecodeTyped(name, typ)
+}
+
 func (d *decoder) decodeDuration() (*reflect.Value, error) {
 	value, err := d.dec.DecodeFloat64()
 	if err != nil {
@@ -306,8 +320,15 @@ func getStructFields(typ reflect.Type) map[string]structField {
 		field := typ.Field(i)
 		// embedded
 		if field.Anonymous {
-			for k, v := range getStructFields(field.Type.Elem()) {
-				ret[k] = v
+			switch field.Type.Kind() {
+			case reflect.Ptr:
+				for k, v := range getStructFields(field.Type.Elem()) {
+					ret[k] = v
+				}
+			case reflect.Struct:
+				for k, v := range getStructFields(field.Type) {
+					ret[k] = v
+				}
 			}
 		} else {
 			opts := parseStructOpts(&field)
@@ -328,13 +349,22 @@ func (d *decoder) getOutputValue(typ reflect.Type) (*reflect.Value, error) {
 	for i := 0; i < numFields; i++ {
 		field := typ.Field(i)
 		if field.Anonymous {
-			fieldValue := reflect.New(field.Type.Elem())
-			// Assertion: all embedded fields are pointers to structs.
-			structValue, err := d.getOutputValue(field.Type.Elem())
-			if err != nil {
-				return nil, err
+			var fieldValue reflect.Value
+			switch field.Type.Kind() {
+			case reflect.Ptr:
+				{
+					fieldValue = reflect.New(field.Type.Elem())
+					structValue, err := d.getOutputValue(field.Type.Elem())
+					if err != nil {
+						return nil, err
+					}
+					fieldValue.Elem().Set(*structValue)
+				}
+			case reflect.Struct:
+				{
+					fieldValue = reflect.New(field.Type).Elem()
+				}
 			}
-			fieldValue.Elem().Set(*structValue)
 			ret.FieldByName(field.Name).Set(fieldValue)
 		}
 	}
diff --git a/pkl/decoder.go b/pkl/decoder.go
index 114bc5b..8552549 100644
--- a/pkl/decoder.go
+++ b/pkl/decoder.go
@@ -117,7 +117,6 @@ func (d *decoder) Decode(typ reflect.Type) (res *reflect.Value, err error) {
 }
 
 func (d *decoder) decodePointer(inType reflect.Type) (*reflect.Value, error) {
-	ret := reflect.New(inType.Elem())
 	code, err := d.dec.PeekCode()
 	if err != nil {
 		return nil, err
@@ -126,13 +125,18 @@ func (d *decoder) decodePointer(inType reflect.Type) (*reflect.Value, error) {
 		if err = d.dec.Skip(); err != nil {
 			return nil, err
 		}
-		ret = reflect.Zero(inType)
+		ret := reflect.Zero(inType)
 		return &ret, nil
 	}
 	val, err := d.Decode(inType.Elem())
 	if err != nil {
 		return nil, err
 	}
+	// if the decoded is already a pointer, we can just return it
+	if val.Kind() == reflect.Ptr {
+		return val, nil
+	}
+	ret := reflect.New(inType.Elem())
 	ret.Elem().Set(*val)
 	return &ret, nil
 }
@@ -206,13 +210,7 @@ func (d *decoder) decodePklObject(typ reflect.Type) (*reflect.Value, error) {
 	}
 	switch code {
 	case codeObject:
-		obj, err := d.decodeObject(typ)
-		if err != nil {
-			return nil, err
-		}
-		ret := reflect.New(obj.Type())
-		ret.Elem().Set(*obj)
-		return &ret, nil
+		return d.decodeObject(typ)
 	case codeMap:
 		fallthrough
 	case codeMapping:
diff --git a/pkl/evaluator_options.go b/pkl/evaluator_options.go
index 8063ba8..2648340 100644
--- a/pkl/evaluator_options.go
+++ b/pkl/evaluator_options.go
@@ -404,9 +404,6 @@ var WithFs = func(fs fs.FS, scheme string) func(opts *EvaluatorOptions) {
 var WithProjectEvaluatorSettings = func(project *Project) func(opts *EvaluatorOptions) {
 	return func(opts *EvaluatorOptions) {
 		evaluatorSettings := project.EvaluatorSettings
-		if evaluatorSettings == nil {
-			return
-		}
 		opts.Properties = evaluatorSettings.ExternalProperties
 		opts.Env = evaluatorSettings.Env
 		if evaluatorSettings.AllowedModules != nil {
diff --git a/pkl/evaluator_test.go b/pkl/evaluator_test.go
index dc86741..166415c 100644
--- a/pkl/evaluator_test.go
+++ b/pkl/evaluator_test.go
@@ -443,6 +443,46 @@ age = 43
 		}
 	})
 
+	t.Run("evaluate into legacy pointer-style types", func(t *testing.T) {
+		type TestLegacyBar struct {
+			Name string `pkl:"name"`
+		}
+
+		type TestLegacyType struct {
+			SomeDuration *Duration             `pkl:"someDuration"`
+			SomePair     *Pair[string, string] `pkl:"somePair"`
+			Bar          *TestLegacyBar        `pkl:"bar"`
+		}
+
+		RegisterMapping("TestLegacyType", TestLegacyType{})
+		RegisterMapping("TestLegacyType#Bar", TestLegacyBar{})
+		ev, err := manager.NewEvaluator(context.Background(), PreconfiguredOptions)
+		if assert.NoError(t, err) {
+			var out *TestLegacyType
+			err = ev.EvaluateModule(context.Background(), TextSource(`
+module TestLegacyType
+
+someDuration = 5.min
+
+somePair = Pair("one", "two")
+
+bar = new Bar { name = "Barney" } 
+
+class Bar {
+  name: String
+}
+`), &out)
+			assert.NoError(t, err)
+			assert.Equal(t, &TestLegacyType{
+				SomeDuration: &Duration{5, Minute},
+				SomePair:     &Pair[string, string]{"one", "two"},
+				Bar: &TestLegacyBar{
+					Name: "Barney",
+				},
+			}, out)
+		}
+	})
+
 	t.Run("concurrent evaluations", func(t *testing.T) {
 		ev, err := manager.NewEvaluator(context.Background(), PreconfiguredOptions)
 		if err != nil {
diff --git a/pkl/project.go b/pkl/project.go
index 3e1c794..2111dac 100644
--- a/pkl/project.go
+++ b/pkl/project.go
@@ -24,20 +24,20 @@ import (
 
 // needed for mapping Project.RawDependencies, because the value is defined as any.
 func init() {
-	RegisterMapping("pkl.Project", Project{})
-	RegisterMapping("pkl.Project#RemoteDependency", ProjectRemoteDependency{})
+	RegisterStrictMapping("pkl.Project", &Project{})
+	RegisterStrictMapping("pkl.Project#RemoteDependency", &ProjectRemoteDependency{})
 }
 
 // Project is the go representation of pkl.Project.
 type Project struct {
-	ProjectFileUri    string                    `pkl:"projectFileUri"`
-	Package           *ProjectPackage           `pkl:"package"`
-	EvaluatorSettings *ProjectEvaluatorSettings `pkl:"evaluatorSettings"`
-	Tests             []string                  `pkl:"tests"`
-	Annotations       []Object                  `pkl:"annotations"`
+	ProjectFileUri    string                   `pkl:"projectFileUri"`
+	Package           *ProjectPackage          `pkl:"package"`
+	EvaluatorSettings ProjectEvaluatorSettings `pkl:"evaluatorSettings"`
+	Tests             []string                 `pkl:"tests"`
+	Annotations       []Object                 `pkl:"annotations"`
 
 	// internal field; use Project.Dependencies instead.
-	// values are either *Project or *ProjectRemoteDependency
+	// values are either Project or ProjectRemoteDependency
 	RawDependencies map[string]any `pkl:"dependencies"`
 
 	dependencies *ProjectDependencies `pkl:"-"`
@@ -136,9 +136,9 @@ func LoadProject(context context.Context, path string) (*Project, error) {
 }
 
 func LoadProjectFromEvaluator(context context.Context, ev Evaluator, path string) (*Project, error) {
-	var proj Project
+	var proj *Project
 	if err := ev.EvaluateOutputValue(context, FileSource(path), &proj); err != nil {
 		return nil, err
 	}
-	return &proj, nil
+	return proj, nil
 }
diff --git a/pkl/project_test.go b/pkl/project_test.go
index 3fad79f..10bdd19 100644
--- a/pkl/project_test.go
+++ b/pkl/project_test.go
@@ -197,7 +197,7 @@ func TestLoadProject(t *testing.T) {
 
 		t.Run("evaluatorSettings", func(t *testing.T) {
 			fals := false
-			expectedSettings := &ProjectEvaluatorSettings{
+			expectedSettings := ProjectEvaluatorSettings{
 				Timeout: Duration{
 					Value: 5,
 					Unit:  Minute,
@@ -278,7 +278,7 @@ func TestLoadProjectWithProxy(t *testing.T) {
 	project, err := LoadProject(context.Background(), tempDir+"/pigeons/PklProject")
 	if assert.NoError(t, err) {
 		t.Run("evaluatorSettings", func(t *testing.T) {
-			expectedSettings := &ProjectEvaluatorSettings{
+			expectedSettings := ProjectEvaluatorSettings{
 				Http: &ProjectEvaluatorSettingsHttp{
 					Proxy: &ProjectEvaluatorSettingsProxy{
 						Address: &[]string{"http://localhost:80"}[0],
@@ -313,7 +313,7 @@ func TestLoadProjectWithExternalReaders(t *testing.T) {
 	project, err := LoadProject(context.Background(), tempDir+"/pigeons/PklProject")
 	if assert.NoError(t, err) {
 		t.Run("evaluatorSettings", func(t *testing.T) {
-			expectedSettings := &ProjectEvaluatorSettings{
+			expectedSettings := ProjectEvaluatorSettings{
 				ExternalModuleReaders: map[string]ProjectEvaluatorSettingExternalReader{
 					"scheme1": {Executable: "reader1"},
 					"scheme2": {Executable: "reader2", Arguments: []string{"with", "args"}},
diff --git a/pkl/schema.go b/pkl/schema.go
index 9151412..7320c63 100644
--- a/pkl/schema.go
+++ b/pkl/schema.go
@@ -20,9 +20,19 @@ import "reflect"
 
 var schemas = make(map[string]reflect.Type)
 
-// RegisterMapping associates the type given the Pkl name to the corresponding Go type.
+// RegisterStrictMapping associates the type given the Pkl name to the corresponding Go type.
 //
 //goland:noinspection GoUnusedExportedFunction
-func RegisterMapping(name string, value any) {
+func RegisterStrictMapping(name string, value any) {
 	schemas[name] = reflect.TypeOf(value)
 }
+
+// RegisterMapping is like RegisterStrictMapping, but casts it to a pointer.
+//
+// This method exists to preserve compatibility with legacy generated code, where object types were generated as
+// pointers.
+//
+//goland:noinspection GoUnusedExportedFunction
+func RegisterMapping(name string, value any) {
+	schemas[name] = reflect.PointerTo(reflect.TypeOf(value))
+}
diff --git a/pkl/test_fixtures/classes.pkl b/pkl/test_fixtures/classes.pkl
index bc273d7..0db0aa1 100644
--- a/pkl/test_fixtures/classes.pkl
+++ b/pkl/test_fixtures/classes.pkl
@@ -24,6 +24,11 @@ animals: Listing<Animal> = new {
   new Cat { name = "Millie"; meows = true }
 }
 
+nullableAnimals: Listing<Animal?> = new {
+  null
+  new Greyhound { name = "Uni"; barks = false; canRoach = true }
+}
+
 myAnimal: Animal = new Greyhound {
   name = "Uni"
   barks = false
diff --git a/pkl/test_fixtures/gen/any/Any.pkl.go b/pkl/test_fixtures/gen/any/Any.pkl.go
index 1bc3b6b..a980bac 100644
--- a/pkl/test_fixtures/gen/any/Any.pkl.go
+++ b/pkl/test_fixtures/gen/any/Any.pkl.go
@@ -16,10 +16,10 @@ type Any struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a Any
-func LoadFromPath(ctx context.Context, path string) (ret *Any, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret Any, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -32,10 +32,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *Any, err error) {
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Any
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Any, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Any, error) {
 	var ret Any
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/pkl/test_fixtures/gen/any/init.pkl.go b/pkl/test_fixtures/gen/any/init.pkl.go
index c522037..d6585ab 100644
--- a/pkl/test_fixtures/gen/any/init.pkl.go
+++ b/pkl/test_fixtures/gen/any/init.pkl.go
@@ -4,6 +4,6 @@ package any
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("any", Any{})
-	pkl.RegisterMapping("any#Person", Person{})
+	pkl.RegisterStrictMapping("any", Any{})
+	pkl.RegisterStrictMapping("any#Person", Person{})
 }
diff --git a/pkl/test_fixtures/gen/classes/Cat.pkl.go b/pkl/test_fixtures/gen/classes/Cat.pkl.go
index 84aba1a..40534d6 100644
--- a/pkl/test_fixtures/gen/classes/Cat.pkl.go
+++ b/pkl/test_fixtures/gen/classes/Cat.pkl.go
@@ -7,7 +7,7 @@ type Cat interface {
 	GetMeows() bool
 }
 
-var _ Cat = (*CatImpl)(nil)
+var _ Cat = CatImpl{}
 
 type CatImpl struct {
 	Meows bool `pkl:"meows"`
@@ -15,10 +15,10 @@ type CatImpl struct {
 	Name string `pkl:"name"`
 }
 
-func (rcv *CatImpl) GetMeows() bool {
+func (rcv CatImpl) GetMeows() bool {
 	return rcv.Meows
 }
 
-func (rcv *CatImpl) GetName() string {
+func (rcv CatImpl) GetName() string {
 	return rcv.Name
 }
diff --git a/pkl/test_fixtures/gen/classes/Classes.pkl.go b/pkl/test_fixtures/gen/classes/Classes.pkl.go
index 13f5089..80962c5 100644
--- a/pkl/test_fixtures/gen/classes/Classes.pkl.go
+++ b/pkl/test_fixtures/gen/classes/Classes.pkl.go
@@ -10,16 +10,18 @@ import (
 type Classes struct {
 	Animals []Animal `pkl:"animals"`
 
+	NullableAnimals []*Animal `pkl:"nullableAnimals"`
+
 	MyAnimal Animal `pkl:"myAnimal"`
 
-	House *House `pkl:"house"`
+	House House `pkl:"house"`
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a Classes
-func LoadFromPath(ctx context.Context, path string) (ret *Classes, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret Classes, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -32,10 +34,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *Classes, err error) {
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Classes
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Classes, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Classes, error) {
 	var ret Classes
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/pkl/test_fixtures/gen/classes/Dog.pkl.go b/pkl/test_fixtures/gen/classes/Dog.pkl.go
index 2f23bbc..ccff6b2 100644
--- a/pkl/test_fixtures/gen/classes/Dog.pkl.go
+++ b/pkl/test_fixtures/gen/classes/Dog.pkl.go
@@ -9,7 +9,7 @@ type Dog interface {
 	GetBreed() string
 }
 
-var _ Dog = (*DogImpl)(nil)
+var _ Dog = DogImpl{}
 
 type DogImpl struct {
 	Barks bool `pkl:"barks"`
@@ -19,14 +19,14 @@ type DogImpl struct {
 	Name string `pkl:"name"`
 }
 
-func (rcv *DogImpl) GetBarks() bool {
+func (rcv DogImpl) GetBarks() bool {
 	return rcv.Barks
 }
 
-func (rcv *DogImpl) GetBreed() string {
+func (rcv DogImpl) GetBreed() string {
 	return rcv.Breed
 }
 
-func (rcv *DogImpl) GetName() string {
+func (rcv DogImpl) GetName() string {
 	return rcv.Name
 }
diff --git a/pkl/test_fixtures/gen/classes/Greyhound.pkl.go b/pkl/test_fixtures/gen/classes/Greyhound.pkl.go
index b891025..8102426 100644
--- a/pkl/test_fixtures/gen/classes/Greyhound.pkl.go
+++ b/pkl/test_fixtures/gen/classes/Greyhound.pkl.go
@@ -7,14 +7,14 @@ type Greyhound interface {
 	GetCanRoach() bool
 }
 
-var _ Greyhound = (*GreyhoundImpl)(nil)
+var _ Greyhound = GreyhoundImpl{}
 
 type GreyhoundImpl struct {
-	*DogImpl
+	DogImpl
 
 	CanRoach bool `pkl:"canRoach"`
 }
 
-func (rcv *GreyhoundImpl) GetCanRoach() bool {
+func (rcv GreyhoundImpl) GetCanRoach() bool {
 	return rcv.CanRoach
 }
diff --git a/pkl/test_fixtures/gen/classes/init.pkl.go b/pkl/test_fixtures/gen/classes/init.pkl.go
index 6fd024e..6f54cb5 100644
--- a/pkl/test_fixtures/gen/classes/init.pkl.go
+++ b/pkl/test_fixtures/gen/classes/init.pkl.go
@@ -4,9 +4,9 @@ package classes
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("classes", Classes{})
-	pkl.RegisterMapping("classes#House", House{})
-	pkl.RegisterMapping("classes#Dog", DogImpl{})
-	pkl.RegisterMapping("classes#Greyhound", GreyhoundImpl{})
-	pkl.RegisterMapping("classes#Cat", CatImpl{})
+	pkl.RegisterStrictMapping("classes", Classes{})
+	pkl.RegisterStrictMapping("classes#House", House{})
+	pkl.RegisterStrictMapping("classes#Dog", DogImpl{})
+	pkl.RegisterStrictMapping("classes#Greyhound", GreyhoundImpl{})
+	pkl.RegisterStrictMapping("classes#Cat", CatImpl{})
 }
diff --git a/pkl/test_fixtures/gen/collections/Collections.pkl.go b/pkl/test_fixtures/gen/collections/Collections.pkl.go
index 3630fab..557cf61 100644
--- a/pkl/test_fixtures/gen/collections/Collections.pkl.go
+++ b/pkl/test_fixtures/gen/collections/Collections.pkl.go
@@ -36,10 +36,10 @@ type Collections struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a Collections
-func LoadFromPath(ctx context.Context, path string) (ret *Collections, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret Collections, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -52,10 +52,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *Collections, err error
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Collections
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Collections, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Collections, error) {
 	var ret Collections
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/pkl/test_fixtures/gen/collections/init.pkl.go b/pkl/test_fixtures/gen/collections/init.pkl.go
index bfd77c7..72859d2 100644
--- a/pkl/test_fixtures/gen/collections/init.pkl.go
+++ b/pkl/test_fixtures/gen/collections/init.pkl.go
@@ -4,5 +4,5 @@ package collections
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("collections", Collections{})
+	pkl.RegisterStrictMapping("collections", Collections{})
 }
diff --git a/pkl/test_fixtures/gen/datasize/Datasize.pkl.go b/pkl/test_fixtures/gen/datasize/Datasize.pkl.go
index 3d03f0e..e44f487 100644
--- a/pkl/test_fixtures/gen/datasize/Datasize.pkl.go
+++ b/pkl/test_fixtures/gen/datasize/Datasize.pkl.go
@@ -8,36 +8,36 @@ import (
 )
 
 type Datasize struct {
-	Res1 *pkl.DataSize `pkl:"res1"`
+	Res1 pkl.DataSize `pkl:"res1"`
 
-	Res2 *pkl.DataSize `pkl:"res2"`
+	Res2 pkl.DataSize `pkl:"res2"`
 
-	Res3 *pkl.DataSize `pkl:"res3"`
+	Res3 pkl.DataSize `pkl:"res3"`
 
-	Res4 *pkl.DataSize `pkl:"res4"`
+	Res4 pkl.DataSize `pkl:"res4"`
 
-	Res5 *pkl.DataSize `pkl:"res5"`
+	Res5 pkl.DataSize `pkl:"res5"`
 
-	Res6 *pkl.DataSize `pkl:"res6"`
+	Res6 pkl.DataSize `pkl:"res6"`
 
-	Res7 *pkl.DataSize `pkl:"res7"`
+	Res7 pkl.DataSize `pkl:"res7"`
 
-	Res8 *pkl.DataSize `pkl:"res8"`
+	Res8 pkl.DataSize `pkl:"res8"`
 
-	Res9 *pkl.DataSize `pkl:"res9"`
+	Res9 pkl.DataSize `pkl:"res9"`
 
-	Res10 *pkl.DataSize `pkl:"res10"`
+	Res10 pkl.DataSize `pkl:"res10"`
 
-	Res11 *pkl.DataSize `pkl:"res11"`
+	Res11 pkl.DataSize `pkl:"res11"`
 
 	Res12 pkl.DataSizeUnit `pkl:"res12"`
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a Datasize
-func LoadFromPath(ctx context.Context, path string) (ret *Datasize, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret Datasize, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -50,10 +50,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *Datasize, err error) {
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Datasize
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Datasize, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Datasize, error) {
 	var ret Datasize
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/pkl/test_fixtures/gen/datasize/init.pkl.go b/pkl/test_fixtures/gen/datasize/init.pkl.go
index 4cb59a0..fe798bc 100644
--- a/pkl/test_fixtures/gen/datasize/init.pkl.go
+++ b/pkl/test_fixtures/gen/datasize/init.pkl.go
@@ -4,5 +4,5 @@ package datasize
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("datasize", Datasize{})
+	pkl.RegisterStrictMapping("datasize", Datasize{})
 }
diff --git a/pkl/test_fixtures/gen/duration/Duration.pkl.go b/pkl/test_fixtures/gen/duration/Duration.pkl.go
index e781970..26561c8 100644
--- a/pkl/test_fixtures/gen/duration/Duration.pkl.go
+++ b/pkl/test_fixtures/gen/duration/Duration.pkl.go
@@ -8,28 +8,28 @@ import (
 )
 
 type Duration struct {
-	Res1 *pkl.Duration `pkl:"res1"`
+	Res1 pkl.Duration `pkl:"res1"`
 
-	Res2 *pkl.Duration `pkl:"res2"`
+	Res2 pkl.Duration `pkl:"res2"`
 
-	Res3 *pkl.Duration `pkl:"res3"`
+	Res3 pkl.Duration `pkl:"res3"`
 
-	Res4 *pkl.Duration `pkl:"res4"`
+	Res4 pkl.Duration `pkl:"res4"`
 
-	Res5 *pkl.Duration `pkl:"res5"`
+	Res5 pkl.Duration `pkl:"res5"`
 
-	Res6 *pkl.Duration `pkl:"res6"`
+	Res6 pkl.Duration `pkl:"res6"`
 
-	Res7 *pkl.Duration `pkl:"res7"`
+	Res7 pkl.Duration `pkl:"res7"`
 
 	Res8 pkl.DurationUnit `pkl:"res8"`
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a Duration
-func LoadFromPath(ctx context.Context, path string) (ret *Duration, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret Duration, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -42,10 +42,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *Duration, err error) {
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Duration
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Duration, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Duration, error) {
 	var ret Duration
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/pkl/test_fixtures/gen/duration/init.pkl.go b/pkl/test_fixtures/gen/duration/init.pkl.go
index 8e54071..7375aca 100644
--- a/pkl/test_fixtures/gen/duration/init.pkl.go
+++ b/pkl/test_fixtures/gen/duration/init.pkl.go
@@ -4,5 +4,5 @@ package duration
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("duration", Duration{})
+	pkl.RegisterStrictMapping("duration", Duration{})
 }
diff --git a/pkl/test_fixtures/gen/dynamic/Dynamic.pkl.go b/pkl/test_fixtures/gen/dynamic/Dynamic.pkl.go
index d57fd74..7c10242 100644
--- a/pkl/test_fixtures/gen/dynamic/Dynamic.pkl.go
+++ b/pkl/test_fixtures/gen/dynamic/Dynamic.pkl.go
@@ -8,14 +8,14 @@ import (
 )
 
 type Dynamic struct {
-	Res1 *pkl.Object `pkl:"res1"`
+	Res1 pkl.Object `pkl:"res1"`
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a Dynamic
-func LoadFromPath(ctx context.Context, path string) (ret *Dynamic, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret Dynamic, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -28,10 +28,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *Dynamic, err error) {
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Dynamic
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Dynamic, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Dynamic, error) {
 	var ret Dynamic
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/pkl/test_fixtures/gen/dynamic/init.pkl.go b/pkl/test_fixtures/gen/dynamic/init.pkl.go
index e7097c9..2300c90 100644
--- a/pkl/test_fixtures/gen/dynamic/init.pkl.go
+++ b/pkl/test_fixtures/gen/dynamic/init.pkl.go
@@ -4,6 +4,6 @@ package dynamic
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("dynamic", Dynamic{})
-	pkl.RegisterMapping("dynamic#MyClass", MyClass{})
+	pkl.RegisterStrictMapping("dynamic", Dynamic{})
+	pkl.RegisterStrictMapping("dynamic#MyClass", MyClass{})
 }
diff --git a/pkl/test_fixtures/gen/nullables/Nullables.pkl.go b/pkl/test_fixtures/gen/nullables/Nullables.pkl.go
index 6908dee..7fcdd61 100644
--- a/pkl/test_fixtures/gen/nullables/Nullables.pkl.go
+++ b/pkl/test_fixtures/gen/nullables/Nullables.pkl.go
@@ -70,10 +70,10 @@ type Nullables struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a Nullables
-func LoadFromPath(ctx context.Context, path string) (ret *Nullables, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret Nullables, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -86,10 +86,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *Nullables, err error)
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Nullables
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Nullables, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Nullables, error) {
 	var ret Nullables
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/pkl/test_fixtures/gen/nullables/init.pkl.go b/pkl/test_fixtures/gen/nullables/init.pkl.go
index cdf0884..d861265 100644
--- a/pkl/test_fixtures/gen/nullables/init.pkl.go
+++ b/pkl/test_fixtures/gen/nullables/init.pkl.go
@@ -4,6 +4,6 @@ package nullables
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("nullables", Nullables{})
-	pkl.RegisterMapping("nullables#MyClass", MyClass{})
+	pkl.RegisterStrictMapping("nullables", Nullables{})
+	pkl.RegisterStrictMapping("nullables#MyClass", MyClass{})
 }
diff --git a/pkl/test_fixtures/gen/primitives/Primitives.pkl.go b/pkl/test_fixtures/gen/primitives/Primitives.pkl.go
index 6083eb4..c0db1da 100644
--- a/pkl/test_fixtures/gen/primitives/Primitives.pkl.go
+++ b/pkl/test_fixtures/gen/primitives/Primitives.pkl.go
@@ -38,10 +38,10 @@ type Primitives struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a Primitives
-func LoadFromPath(ctx context.Context, path string) (ret *Primitives, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret Primitives, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -54,10 +54,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *Primitives, err error)
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Primitives
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Primitives, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Primitives, error) {
 	var ret Primitives
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/pkl/test_fixtures/gen/primitives/init.pkl.go b/pkl/test_fixtures/gen/primitives/init.pkl.go
index f639209..62721dd 100644
--- a/pkl/test_fixtures/gen/primitives/init.pkl.go
+++ b/pkl/test_fixtures/gen/primitives/init.pkl.go
@@ -4,5 +4,5 @@ package primitives
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("primitives", Primitives{})
+	pkl.RegisterStrictMapping("primitives", Primitives{})
 }
diff --git a/pkl/test_fixtures/gen/unions/Unions.pkl.go b/pkl/test_fixtures/gen/unions/Unions.pkl.go
index 43898a9..c6a236a 100644
--- a/pkl/test_fixtures/gen/unions/Unions.pkl.go
+++ b/pkl/test_fixtures/gen/unions/Unions.pkl.go
@@ -16,10 +16,10 @@ type Unions struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a Unions
-func LoadFromPath(ctx context.Context, path string) (ret *Unions, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret Unions, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -32,10 +32,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *Unions, err error) {
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Unions
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Unions, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Unions, error) {
 	var ret Unions
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/pkl/test_fixtures/gen/unions/init.pkl.go b/pkl/test_fixtures/gen/unions/init.pkl.go
index 8bcc483..e55b3bb 100644
--- a/pkl/test_fixtures/gen/unions/init.pkl.go
+++ b/pkl/test_fixtures/gen/unions/init.pkl.go
@@ -4,5 +4,5 @@ package unions
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("unions", Unions{})
+	pkl.RegisterStrictMapping("unions", Unions{})
 }
diff --git a/pkl/test_fixtures/gen/unknown_type/UnknownType.pkl.go b/pkl/test_fixtures/gen/unknown_type/UnknownType.pkl.go
index 414a997..5c147ad 100644
--- a/pkl/test_fixtures/gen/unknown_type/UnknownType.pkl.go
+++ b/pkl/test_fixtures/gen/unknown_type/UnknownType.pkl.go
@@ -12,10 +12,10 @@ type UnknownType struct {
 }
 
 // LoadFromPath loads the pkl module at the given path and evaluates it into a UnknownType
-func LoadFromPath(ctx context.Context, path string) (ret *UnknownType, err error) {
+func LoadFromPath(ctx context.Context, path string) (ret UnknownType, err error) {
 	evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
 	if err != nil {
-		return nil, err
+		return ret, err
 	}
 	defer func() {
 		cerr := evaluator.Close()
@@ -28,10 +28,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *UnknownType, err error
 }
 
 // Load loads the pkl module at the given source and evaluates it with the given evaluator into a UnknownType
-func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*UnknownType, error) {
+func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (UnknownType, error) {
 	var ret UnknownType
-	if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
-		return nil, err
-	}
-	return &ret, nil
+	err := evaluator.EvaluateModule(ctx, source, &ret)
+	return ret, err
 }
diff --git a/pkl/test_fixtures/gen/unknown_type/init.pkl.go b/pkl/test_fixtures/gen/unknown_type/init.pkl.go
index 3e77691..2659d0a 100644
--- a/pkl/test_fixtures/gen/unknown_type/init.pkl.go
+++ b/pkl/test_fixtures/gen/unknown_type/init.pkl.go
@@ -4,5 +4,5 @@ package unknowntype
 import "github.com/apple/pkl-go/pkl"
 
 func init() {
-	pkl.RegisterMapping("unknown_type", UnknownType{})
+	pkl.RegisterStrictMapping("unknown_type", UnknownType{})
 }
diff --git a/pkl/test_fixtures/msgpack/classes.pkl.msgpack b/pkl/test_fixtures/msgpack/classes.pkl.msgpack
index b8f84aa..9e76b12 100644
--- a/pkl/test_fixtures/msgpack/classes.pkl.msgpack
+++ b/pkl/test_fixtures/msgpack/classes.pkl.msgpack
@@ -1 +1 @@
-�
�classes�$pklgo:/pkl/test_fixtures/classes.pkl���animals���
�classes#Greyhound�$pklgo:/pkl/test_fixtures/classes.pkl���name�Uni��barks“�breed�Greyhound��canRoachÔ
�classes#Cat�$pklgo:/pkl/test_fixtures/classes.pkl���name�Millie��meows�myAnimal�
�classes#Greyhound�$pklgo:/pkl/test_fixtures/classes.pkl���name�Uni��barks“�breed�Greyhound��canRoachÓ�house�
�classes#House�$pklgo:/pkl/test_fixtures/classes.pkl���area��bedrooms��bathrooms
\ No newline at end of file
+�
�classes�$pklgo:/pkl/test_fixtures/classes.pkl���animals���
�classes#Greyhound�$pklgo:/pkl/test_fixtures/classes.pkl���name�Uni��barks“�breed�Greyhound��canRoachÔ
�classes#Cat�$pklgo:/pkl/test_fixtures/classes.pkl���name�Millie��meows�nullableAnimals����
�classes#Greyhound�$pklgo:/pkl/test_fixtures/classes.pkl���name�Uni��barks“�breed�Greyhound��canRoachÓ�myAnimal�
�classes#Greyhound�$pklgo:/pkl/test_fixtures/classes.pkl���name�Uni��barks“�breed�Greyhound��canRoachÓ�house�
�classes#House�$pklgo:/pkl/test_fixtures/classes.pkl���area��bedrooms��bathrooms
\ No newline at end of file
diff --git a/pkl/unmarshal_test.go b/pkl/unmarshal_test.go
index fd8cf24..c676d2f 100644
--- a/pkl/unmarshal_test.go
+++ b/pkl/unmarshal_test.go
@@ -169,31 +169,31 @@ func TestUnmarshall_Collections(t *testing.T) {
 func TestUnmarshal_Duration(t *testing.T) {
 	var res duration.Duration
 	expected := duration.Duration{
-		Res1: &pkl.Duration{
+		Res1: pkl.Duration{
 			Value: 1,
 			Unit:  pkl.Nanosecond,
 		},
-		Res2: &pkl.Duration{
+		Res2: pkl.Duration{
 			Value: 2,
 			Unit:  pkl.Microsecond,
 		},
-		Res3: &pkl.Duration{
+		Res3: pkl.Duration{
 			Value: 3,
 			Unit:  pkl.Millisecond,
 		},
-		Res4: &pkl.Duration{
+		Res4: pkl.Duration{
 			Value: 4,
 			Unit:  pkl.Second,
 		},
-		Res5: &pkl.Duration{
+		Res5: pkl.Duration{
 			Value: 5,
 			Unit:  pkl.Minute,
 		},
-		Res6: &pkl.Duration{
+		Res6: pkl.Duration{
 			Value: 6,
 			Unit:  pkl.Hour,
 		},
-		Res7: &pkl.Duration{
+		Res7: pkl.Duration{
 			Value: 7,
 			Unit:  pkl.Day,
 		},
@@ -207,17 +207,17 @@ func TestUnmarshal_Duration(t *testing.T) {
 func TestUnmarshal_DataSize(t *testing.T) {
 	var res datasize.Datasize
 	expected := datasize.Datasize{
-		Res1:  &pkl.DataSize{Value: 1, Unit: pkl.Bytes},
-		Res2:  &pkl.DataSize{Value: 2, Unit: pkl.Kilobytes},
-		Res3:  &pkl.DataSize{Value: 3, Unit: pkl.Megabytes},
-		Res4:  &pkl.DataSize{Value: 4, Unit: pkl.Gigabytes},
-		Res5:  &pkl.DataSize{Value: 5, Unit: pkl.Terabytes},
-		Res6:  &pkl.DataSize{Value: 6, Unit: pkl.Petabytes},
-		Res7:  &pkl.DataSize{Value: 7, Unit: pkl.Kibibytes},
-		Res8:  &pkl.DataSize{Value: 8, Unit: pkl.Mebibytes},
-		Res9:  &pkl.DataSize{Value: 9, Unit: pkl.Gibibytes},
-		Res10: &pkl.DataSize{Value: 10, Unit: pkl.Tebibytes},
-		Res11: &pkl.DataSize{Value: 11, Unit: pkl.Pebibytes},
+		Res1:  pkl.DataSize{Value: 1, Unit: pkl.Bytes},
+		Res2:  pkl.DataSize{Value: 2, Unit: pkl.Kilobytes},
+		Res3:  pkl.DataSize{Value: 3, Unit: pkl.Megabytes},
+		Res4:  pkl.DataSize{Value: 4, Unit: pkl.Gigabytes},
+		Res5:  pkl.DataSize{Value: 5, Unit: pkl.Terabytes},
+		Res6:  pkl.DataSize{Value: 6, Unit: pkl.Petabytes},
+		Res7:  pkl.DataSize{Value: 7, Unit: pkl.Kibibytes},
+		Res8:  pkl.DataSize{Value: 8, Unit: pkl.Mebibytes},
+		Res9:  pkl.DataSize{Value: 9, Unit: pkl.Gibibytes},
+		Res10: pkl.DataSize{Value: 10, Unit: pkl.Tebibytes},
+		Res11: pkl.DataSize{Value: 11, Unit: pkl.Pebibytes},
 		Res12: pkl.Megabytes,
 	}
 	if assert.NoError(t, pkl.Unmarshal(datasizeInput, &res)) {
@@ -279,25 +279,25 @@ func TestUnmarshal_Nullables(t *testing.T) {
 func TestUnmarshal_Dynamic(t *testing.T) {
 	var res dynamic.Dynamic
 	expected := dynamic.Dynamic{
-		Res1: &pkl.Object{
+		Res1: pkl.Object{
 			ModuleUri: "pkl:base",
 			Name:      "Dynamic",
 			Properties: map[string]any{
-				"res2": &pkl.Object{
+				"res2": pkl.Object{
 					ModuleUri:  "pkl:base",
 					Name:       "Dynamic",
 					Properties: map[string]any{"res3": 5},
 					Entries:    map[any]any{},
 					Elements:   []any{},
 				},
-				"res5": &dynamic.MyClass{MyValue: 8},
+				"res5": dynamic.MyClass{MyValue: 8},
 			},
 			Entries: map[any]any{
 				"res4": 6,
 				5:      9,
 			},
 			Elements: []any{
-				&dynamic.MyClass{
+				dynamic.MyClass{
 					MyValue: 7,
 				},
 			},
@@ -309,30 +309,36 @@ func TestUnmarshal_Dynamic(t *testing.T) {
 }
 
 func TestUnmarshal_Classes(t *testing.T) {
+	var greyhound = classes.GreyhoundImpl{
+		DogImpl: classes.DogImpl{
+			Name:  "Uni",
+			Barks: false,
+			Breed: "Greyhound",
+		},
+		CanRoach: true,
+	}
+	var animal classes.Animal = greyhound
 	expected := classes.Classes{
 		Animals: []classes.Animal{
-			&classes.GreyhoundImpl{
-				DogImpl: &classes.DogImpl{
-					Name:  "Uni",
-					Barks: false,
-					Breed: "Greyhound",
-				},
-				CanRoach: true,
-			},
-			&classes.CatImpl{
+			greyhound,
+			classes.CatImpl{
 				Name:  "Millie",
 				Meows: true,
 			},
 		},
-		MyAnimal: &classes.GreyhoundImpl{
-			DogImpl: &classes.DogImpl{
+		NullableAnimals: []*classes.Animal{
+			nil,
+			&animal,
+		},
+		MyAnimal: classes.GreyhoundImpl{
+			DogImpl: classes.DogImpl{
 				Name:  "Uni",
 				Barks: false,
 				Breed: "Greyhound",
 			},
 			CanRoach: true,
 		},
-		House: &classes.House{
+		House: classes.House{
 			Area:      2000,
 			Bedrooms:  3,
 			Bathrooms: 2,
@@ -420,15 +426,15 @@ func TestUnmarshal_AnyType(t *testing.T) {
 	}
 	assert.Equal(t, any2.Any{
 		Res1: []any{
-			&any2.Person{
+			any2.Person{
 				Name: "Barney",
 			},
 		},
-		Res2: &any2.Person{
+		Res2: any2.Person{
 			Name: "Bobby",
 		},
 		Res3: map[any]any{
-			"Wilma": &any2.Person{
+			"Wilma": any2.Person{
 				Name: "Wilma",
 			},
 		},