diff --git a/ChangeLog b/ChangeLog
index ee17e98..257e37c 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,8 @@
+# v2.1.0 (2019-02-12)
+
+* Added template import support
+* Added new config parameter: `tpl.recursion_limit`
+
 # v2.0.0 (2019-01-23)
 
 * Added dynamic discovery agent
diff --git a/cmd/run.go b/cmd/run.go
index 7057396..ff5f28f 100644
--- a/cmd/run.go
+++ b/cmd/run.go
@@ -83,6 +83,7 @@ var runCmd = &cobra.Command{
 		params.TLSCertFile = config.GetString("tls.cert")
 		params.TLSKeyFile = config.GetString("tls.key")
 		params.DefaultKeepalive = config.GetDuration("keepalive")
+		params.RecursionLimit = config.GetInt("tpl.recursion_limit")
 		params.CengCtx = cengCtx
 
 		runLog.Infof("Base directory: %s", params.BaseTplDir)
diff --git a/pkg/config/default.go b/pkg/config/default.go
index 8cbe4de..ee58774 100644
--- a/pkg/config/default.go
+++ b/pkg/config/default.go
@@ -35,6 +35,7 @@ keepalive = "2m"
 base_dir = "."
 ws_dir = "/tmp/xenvman/ws"
 mount_dir = "/tmp/xenvman/mount"
+recursion_limit = 1000
 
 [log]
 config = "<root>=trace"
diff --git a/pkg/conteng/conteng_docker.go b/pkg/conteng/conteng_docker.go
index 61c73c6..cc048fb 100644
--- a/pkg/conteng/conteng_docker.go
+++ b/pkg/conteng/conteng_docker.go
@@ -110,7 +110,7 @@ func (de *DockerEngine) CreateNetwork(ctx context.Context,
 	r, err := de.cl.NetworkCreate(ctx, name, netParams)
 
 	if err != nil {
-		return "", "", errors.Wrapf(err, "Error creating docker network")
+		return "", "", errors.Wrapf(err, "Error creating docker network: %s", sub)
 	}
 
 	dockerLog.Debugf("Network created: %s - %s :: %s", name, r.ID, sub)
@@ -367,6 +367,8 @@ func (de *DockerEngine) getSubNet() (string, error) {
 	var nets []*net.IPNet
 
 	for _, addr := range addrs {
+		dockerLog.Debugf("Inspecting interface %s", addr.String())
+
 		_, n, err := net.ParseCIDR(addr.String())
 
 		if err != nil {
diff --git a/pkg/def/output_env.go b/pkg/def/output_env.go
index 4cc1e6f..c4e64ed 100644
--- a/pkg/def/output_env.go
+++ b/pkg/def/output_env.go
@@ -25,6 +25,10 @@
 package def
 
 import (
+	"fmt"
+	"strconv"
+	"strings"
+
 	"github.com/pkg/errors"
 )
 
@@ -46,6 +50,8 @@ func NewContainerData(id, hostname string) *ContainerData {
 type TplData struct {
 	// Container name -> <internal port> -> "<host>:<external-port>"
 	Containers map[string]*ContainerData `json:"containers"`
+	// Imported templates -> tpl name -> [TplData]
+	Templates map[string][]*TplData `json:"templates"`
 }
 
 type OutputEnv struct {
@@ -63,18 +69,53 @@ type OutputEnv struct {
 
 func (e *OutputEnv) GetContainer(tplName string, tplIdx int,
 	contName string) (*ContainerData, error) {
-	tpls, ok := e.Templates[tplName]
 
-	if !ok {
-		return nil, errors.Errorf("Template not found: %s", tplName)
-	}
+	return e.GetContainerByPath([]string{
+		fmt.Sprintf("%s|%d", tplName, tplIdx),
+	}, contName)
+}
+
+// Path element must be defined in the format: <template>|<index>
+func (e *OutputEnv) GetContainerByPath(path []string,
+	contName string) (*ContainerData, error) {
+
+	var data *TplData
+
+	tmap := e.Templates
+
+	for _, el := range path {
+		split := strings.Split(el, "|")
+
+		if len(split) != 2 {
+			return nil, errors.Errorf(
+				"Invalid template path format: %s, expected <template>|<index>",
+				el)
+		}
+
+		tplName := split[0]
+		tplIdx, err := strconv.ParseInt(split[1], 10, 32)
+
+		if err != nil {
+			return nil, errors.Wrapf(err, "Invalid template index in %s",
+				split[1])
+		}
+
+		tpls, ok := tmap[tplName]
+
+		if !ok {
+			return nil, errors.Errorf("Template not found: %s", el)
+		}
+
+		if int(tplIdx) >= len(tpls) {
+			return nil, errors.Errorf("Template %s index %d not found",
+				tplName, tplIdx)
+		}
 
-	if tplIdx >= len(tpls) {
-		return nil, errors.Errorf("Template %s index %d not found",
-			tplName, tplIdx)
+		data = tpls[tplIdx]
+		tmap = data.Templates
 	}
 
-	cont, ok := tpls[tplIdx].Containers[contName]
+	cont, ok := data.Containers[contName]
 
 	if !ok {
 		return nil, errors.Errorf("Container not found: %s", contName)
diff --git a/pkg/env/env.go b/pkg/env/env.go
index ac5ae28..f3b9424 100644
--- a/pkg/env/env.go
+++ b/pkg/env/env.go
@@ -90,6 +90,7 @@ type Params struct {
 	BaseMountDir     string
 	ExportAddress    string
 	DefaultKeepAlive def.Duration
+	RecursionLimit   int
 	Ctx              context.Context
 }
 
@@ -377,8 +378,9 @@ func (env *Env) buildAndFetch(toBuild map[string]*tpl.BuildImage,
 }
 
 type executeResult struct {
-	t   *tpl.Tpl
-	idx int
+	t     *tpl.Tpl
+	imprt []*def.Tpl
+	idx   int
 }
 
 type executeResults []*executeResult
@@ -389,7 +391,11 @@ func (er executeResults) Less(i, j int) bool { return er[i].idx < er[j].idx }
 
 // Execute templates in parallel
 func (env *Env) executeTemplates(tpls []*def.Tpl,
-	needDiscovery bool) ([]*tpl.Tpl, error) {
+	needDiscovery bool, rec int) ([]*tpl.Tpl, error) {
+
+	if rec >= env.params.RecursionLimit {
+		return nil, errors.Errorf("Recursion limit reached")
+	}
 
 	ctx, cancel := context.WithCancel(env.params.Ctx)
 	defer cancel()
@@ -451,6 +457,16 @@ func (env *Env) executeTemplates(tpls []*def.Tpl,
 
 	for i, r := range results {
 		templates[i] = r.t
+
+		if len(r.imprt) > 0 {
+			itpls, err := env.executeTemplates(r.imprt, false, rec+1)
+
+			if err != nil {
+				return nil, errors.Wrap(err, "Error executing imported templates")
+			} else {
+				templates[i].SetImported(itpls)
+			}
+		}
 	}
 
 	return templates, nil
@@ -567,17 +583,36 @@ func (env *Env) Export() *def.OutputEnv {
 	env.RLock()
 	defer env.RUnlock()
 
+	return &def.OutputEnv{
+		Id:              env.id,
+		Name:            env.params.EnvDef.Name,
+		Description:     env.params.EnvDef.Description,
+		WsDir:           env.wsDir,
+		MountDir:        env.mountDir,
+		NetId:           env.netId,
+		Created:         env.created.Format(time.RFC3339),
+		Keepalive:       env.keepalive.String(),
+		ExternalAddress: env.params.ExportAddress,
+		Templates:       env.exportTemplates(env.tpls),
+	}
+}
+
+func (env *Env) exportTemplates(tpls []*tpl.Tpl) map[string][]*def.TplData {
 	templates := map[string][]*def.TplData{}
 
-	for tplName, tpls := range env.ports {
-		for idx, t := range tpls {
-			tpld := &def.TplData{
-				Containers: map[string]*def.ContainerData{},
-			}
+	for _, tplobj := range tpls {
+		name := tplobj.GetName()
+		idx := tplobj.GetIdx()
 
-			for cont, ps := range t {
+		tpld := &def.TplData{
+			Containers: map[string]*def.ContainerData{},
+			Templates:  env.exportTemplates(tplobj.GetImported()),
+		}
+
+		if len(env.ports[name]) > idx {
+			for cont, ps := range env.ports[name][idx] {
 				if _, ok := tpld.Containers[cont]; !ok {
-					cid := env.contIds[tplName][idx][cont]
+					cid := env.contIds[name][idx][cont]
 
 					tpld.Containers[cont] = def.NewContainerData(
 						cid, env.containers[cid].Hostname())
@@ -587,23 +622,12 @@ func (env *Env) Export() *def.OutputEnv {
 					tpld.Containers[cont].Ports[fmt.Sprintf("%d", ip)] = int(ep)
 				}
 			}
-
-			templates[tplName] = append(templates[tplName], tpld)
 		}
-	}
 
-	return &def.OutputEnv{
-		Id:              env.id,
-		Name:            env.params.EnvDef.Name,
-		Description:     env.params.EnvDef.Description,
-		WsDir:           env.wsDir,
-		MountDir:        env.mountDir,
-		NetId:           env.netId,
-		Created:         env.created.Format(time.RFC3339),
-		Keepalive:       env.keepalive.String(),
-		ExternalAddress: env.params.ExportAddress,
-		Templates:       templates,
+		templates[name] = append(templates[name], tpld)
 	}
+
+	return templates
 }
 
 func (env *Env) execTpl(tplObj *def.Tpl, idx int,
@@ -628,12 +652,12 @@ func (env *Env) execTpl(tplObj *def.Tpl, idx int,
 		params.TplDir = env.params.BaseTplDir
 	}
 
-	t, err := tpl.Execute(env.id, tplObj.Tpl, idx, params)
+	t, imprt, err := tpl.Execute(env.id, tplObj.Tpl, idx, params)
 
 	if err != nil {
 		errch <- errors.WithStack(err)
 	} else {
-		rch <- &executeResult{t: t, idx: idx}
+		rch <- &executeResult{t: t, imprt: imprt, idx: idx}
 	}
 }
 
@@ -702,33 +726,13 @@ func (env *Env) ApplyTemplates(tplDefs []*def.Tpl,
 
 	var containers []*tpl.Container
 
-	tpls, err := env.executeTemplates(tplDefs, needDiscovery)
+	tpls, err := env.executeTemplates(tplDefs, needDiscovery, 0)
 
 	if err != nil {
 		return errors.WithStack(err)
 	}
 
-	for _, t := range tpls {
-		// Collect build images
-		for _, bimg := range t.GetBuildImages() {
-			imagesToBuild[bimg.Name()] = bimg
-
-			// Collect containers
-			for _, c := range bimg.Containers() {
-				containers = append(containers, c)
-			}
-		}
-
-		// Collect fetch images
-		for _, fimg := range t.GetFetchImages() {
-			imagesToFetch[fimg.Name()] = fimg
-
-			// Collect containers
-			for _, c := range fimg.Containers() {
-				containers = append(containers, c)
-			}
-		}
-	}
+	env.extractContainers(tpls, &containers, imagesToBuild, imagesToFetch)
 
 	imgPorts, err := env.buildAndFetch(imagesToBuild, imagesToFetch,
 		env.params.ContEng, env.params.Ctx)
@@ -957,3 +961,37 @@ func (env *Env) ApplyTemplates(tplDefs []*def.Tpl,
 
 	return nil
 }
+
+func (env *Env) extractContainers(
+	tpls []*tpl.Tpl, containers *[]*tpl.Container,
+	imagesToBuild map[string]*tpl.BuildImage,
+	imagesToFetch map[string]*tpl.FetchImage) {
+
+	for _, t := range tpls {
+		// Collect build images
+		for _, bimg := range t.GetBuildImages() {
+			imagesToBuild[bimg.Name()] = bimg
+
+			// Collect containers
+			for _, c := range bimg.Containers() {
+				*containers = append(*containers, c)
+			}
+		}
+
+		// Collect fetch images
+		for _, fimg := range t.GetFetchImages() {
+			imagesToFetch[fimg.Name()] = fimg
+
+			// Collect containers
+			for _, c := range fimg.Containers() {
+				*containers = append(*containers, c)
+			}
+		}
+
+		// Process imported templates as well
+		if len(t.GetImported()) > 0 {
+			env.extractContainers(t.GetImported(),
+				containers, imagesToBuild, imagesToFetch)
+		}
+	}
+}
diff --git a/pkg/env/env_test.go b/pkg/env/env_test.go
index f1b04ed..df8a2c9 100644
--- a/pkg/env/env_test.go
+++ b/pkg/env/env_test.go
@@ -57,9 +57,10 @@ func TestEnvNonesistentTemplate(t *testing.T) {
 				},
 			},
 		},
-		ContEng:    ceng,
-		BaseTplDir: "/tmp/nonexistent",
-		Ctx:        ctx,
+		RecursionLimit: 10,
+		ContEng:        ceng,
+		BaseTplDir:     "/tmp/nonexistent",
+		Ctx:            ctx,
 	})
 
 	require.Contains(t, err.Error(), "no such file or directory")
@@ -77,9 +78,10 @@ func TestEnvInvalidTemplateName(t *testing.T) {
 			Name:      "test",
 			Templates: []*def.Tpl{{Tpl: " /etc/passwd"}},
 		},
-		ContEng:    ceng,
-		BaseTplDir: "/tmp/nonexistent",
-		Ctx:        ctx,
+		RecursionLimit: 10,
+		ContEng:        ceng,
+		BaseTplDir:     "/tmp/nonexistent",
+		Ctx:            ctx,
 	}
 
 	_, err := NewEnv(params)
@@ -179,13 +181,14 @@ func TestEnvOk(t *testing.T) {
 				DisableDiscovery: true,
 			},
 		},
-		ContEng:       ceng,
-		BaseTplDir:    filepath.Join(cwd, "./testdata"),
-		BaseWsDir:     filepath.Join(tmpDir, "ws"),
-		BaseMountDir:  filepath.Join(tmpDir, "mount"),
-		PortRange:     lib.NewPortRange(20000, 30000),
-		ExportAddress: "localhost",
-		Ctx:           ctx,
+		RecursionLimit: 10,
+		ContEng:        ceng,
+		BaseTplDir:     filepath.Join(cwd, "./testdata"),
+		BaseWsDir:      filepath.Join(tmpDir, "ws"),
+		BaseMountDir:   filepath.Join(tmpDir, "mount"),
+		PortRange:      lib.NewPortRange(20000, 30000),
+		ExportAddress:  "localhost",
+		Ctx:            ctx,
 	})
 
 	defer os.RemoveAll(tmpDir)
@@ -353,13 +356,14 @@ func TestStartStopContainers(t *testing.T) {
 				DisableDiscovery: true,
 			},
 		},
-		ContEng:       ceng,
-		BaseTplDir:    filepath.Join(cwd, "./testdata"),
-		BaseWsDir:     filepath.Join(tmpDir, "ws"),
-		BaseMountDir:  filepath.Join(tmpDir, "mount"),
-		PortRange:     lib.NewPortRange(20000, 30000),
-		ExportAddress: "localhost",
-		Ctx:           ctx,
+		RecursionLimit: 10,
+		ContEng:        ceng,
+		BaseTplDir:     filepath.Join(cwd, "./testdata"),
+		BaseWsDir:      filepath.Join(tmpDir, "ws"),
+		BaseMountDir:   filepath.Join(tmpDir, "mount"),
+		PortRange:      lib.NewPortRange(20000, 30000),
+		ExportAddress:  "localhost",
+		Ctx:            ctx,
 	})
 
 	defer os.RemoveAll(tmpDir)
@@ -452,19 +456,22 @@ func TestAddTemplates(t *testing.T) {
 				DisableDiscovery: true,
 			},
 		},
-		ContEng:       ceng,
-		BaseTplDir:    filepath.Join(cwd, "./testdata"),
-		BaseWsDir:     filepath.Join(tmpDir, "ws"),
-		BaseMountDir:  filepath.Join(tmpDir, "mount"),
-		PortRange:     lib.NewPortRange(20000, 30000),
-		ExportAddress: "localhost",
-		Ctx:           ctx,
+		RecursionLimit: 10,
+		ContEng:        ceng,
+		BaseTplDir:     filepath.Join(cwd, "./testdata"),
+		BaseWsDir:      filepath.Join(tmpDir, "ws"),
+		BaseMountDir:   filepath.Join(tmpDir, "mount"),
+		PortRange:      lib.NewPortRange(20000, 30000),
+		ExportAddress:  "localhost",
+		Ctx:            ctx,
 	})
 
 	defer os.RemoveAll(tmpDir)
-	defer env.Terminate()
 
 	require.Nil(t, err)
+
+	defer env.Terminate()
+
 	exported := env.Export()
 	cid0 := exported.Templates["simple"][0].Containers[contName].Id
 
@@ -514,3 +521,154 @@ func TestAddTemplates(t *testing.T) {
 	ceng.AssertCalled(t, "RunContainer", mock.Anything,
 		"appended.1.simple.xenv", imgMatcher, mock.Anything)
 }
+
+func TestImport(t *testing.T) {
+	ctx := context.Background()
+	ceng := new(conteng.MockedEngine)
+
+	imgName := "import-image"
+
+	imgMatcher := mock.MatchedBy(func(img string) bool {
+		return strings.Contains(img, imgName)
+	})
+
+	ceng.On("CreateNetwork", mock.Anything, mock.Anything).
+		Return("net-id", "10.0.0.0/24", nil)
+	ceng.On("RemoveNetwork", mock.Anything, mock.AnythingOfType("string")).
+		Return(nil)
+
+	ceng.On("GetImagePorts", mock.Anything,
+		imgMatcher).Return([]uint16(nil), nil)
+	ceng.On("FetchImage", mock.Anything, imgName).Return(nil)
+
+	ceng.On("RunContainer", mock.Anything,
+		"import-cont.0.import.xenv", imgName,
+		mock.Anything).Return("cont-0", nil)
+
+	ceng.On("RunContainer", mock.Anything,
+		"import2-cont.0.import2.xenv", imgName,
+		mock.Anything).Return("cont-1", nil)
+
+	ceng.On("RunContainer", mock.Anything,
+		"import3-cont.0.import3.xenv", imgName,
+		mock.Anything).Return("cont-2", nil)
+
+	ceng.On("RunContainer", mock.Anything,
+		"import4-cont.0.import4.xenv", imgName,
+		mock.Anything).Return("cont-3", nil)
+
+	ceng.On("RemoveContainer", mock.Anything, mock.Anything).Return(nil)
+	ceng.On("RemoveImage", mock.Anything, mock.Anything).Return(nil)
+
+	cwd, err := os.Getwd()
+	require.Nil(t, err)
+
+	tmpDir := filepath.Join(os.TempDir(), "xenvman-test-"+lib.NewId())
+
+	envName := "test"
+	tplName := "import"
+
+	env, err := NewEnv(Params{
+		EnvDef: &def.InputEnv{
+			Name:      envName,
+			Templates: []*def.Tpl{{Tpl: tplName}},
+			Options: &def.EnvOptions{
+				DisableDiscovery: true,
+			},
+		},
+		ContEng:        ceng,
+		BaseTplDir:     filepath.Join(cwd, "./testdata"),
+		BaseWsDir:      filepath.Join(tmpDir, "ws"),
+		BaseMountDir:   filepath.Join(tmpDir, "mount"),
+		PortRange:      lib.NewPortRange(20000, 30000),
+		ExportAddress:  "localhost",
+		RecursionLimit: 10,
+		Ctx:            ctx,
+	})
+
+	defer os.RemoveAll(tmpDir)
+
+	require.Nil(t, err)
+
+	defer env.Terminate()
+
+	exported := env.Export()
+
+	c1, err := exported.GetContainerByPath(
+		[]string{"import|0"}, "import-cont")
+
+	require.Nil(t, err)
+	require.Equal(t, c1.Hostname, "import-cont.0.import.xenv")
+
+	c2, err := exported.GetContainerByPath(
+		[]string{"import|0", "import2|0"}, "import2-cont")
+
+	require.Nil(t, err)
+	require.Equal(t, c2.Hostname, "import2-cont.0.import2.xenv")
+
+	c3, err := exported.GetContainerByPath(
+		[]string{"import|0", "import3|0"}, "import3-cont")
+
+	require.Nil(t, err)
+	require.Equal(t, c3.Hostname, "import3-cont.0.import3.xenv")
+
+	c4, err := exported.GetContainerByPath(
+		[]string{"import|0", "import3|0", "import4|0"}, "import4-cont")
+
+	require.Nil(t, err)
+	require.Equal(t, c4.Hostname, "import4-cont.0.import4.xenv")
+
+	// Mock assertion
+	ceng.AssertNumberOfCalls(t, "FetchImage", 1)
+
+	ceng.AssertCalled(t, "RunContainer", mock.Anything,
+		"import-cont.0.import.xenv", imgName, mock.Anything)
+
+	ceng.AssertCalled(t, "RunContainer", mock.Anything,
+		"import2-cont.0.import2.xenv", imgName, mock.Anything)
+
+	ceng.AssertCalled(t, "RunContainer", mock.Anything,
+		"import3-cont.0.import3.xenv", imgName, mock.Anything)
+
+	ceng.AssertCalled(t, "RunContainer", mock.Anything,
+		"import4-cont.0.import4.xenv", imgName, mock.Anything)
+}
+
+func TestImportLoop(t *testing.T) {
+	ctx := context.Background()
+	ceng := new(conteng.MockedEngine)
+
+	ceng.On("RemoveNetwork", mock.Anything, mock.AnythingOfType("string")).
+		Return(nil)
+
+	cwd, err := os.Getwd()
+	require.Nil(t, err)
+
+	tmpDir := filepath.Join(os.TempDir(), "xenvman-test-"+lib.NewId())
+
+	envName := "test"
+	tplName := "import-loop"
+
+	_, err = NewEnv(Params{
+		EnvDef: &def.InputEnv{
+			Name:      envName,
+			Templates: []*def.Tpl{{Tpl: tplName}},
+			Options: &def.EnvOptions{
+				DisableDiscovery: true,
+			},
+		},
+		ContEng:        ceng,
+		BaseTplDir:     filepath.Join(cwd, "./testdata"),
+		BaseWsDir:      filepath.Join(tmpDir, "ws"),
+		BaseMountDir:   filepath.Join(tmpDir, "mount"),
+		PortRange:      lib.NewPortRange(20000, 30000),
+		ExportAddress:  "localhost",
+		RecursionLimit: 10,
+		Ctx:            ctx,
+	})
+
+	defer os.RemoveAll(tmpDir)
+
+	require.NotNil(t, err)
+	require.Contains(t, err.Error(), "Recursion limit reached")
+}
diff --git a/pkg/env/testdata/import-loop.tpl.js b/pkg/env/testdata/import-loop.tpl.js
new file mode 100644
index 0000000..593fb09
--- /dev/null
+++ b/pkg/env/testdata/import-loop.tpl.js
@@ -0,0 +1,3 @@
+function execute(tpl, params) {
+  import_template("import-loop", {});
+}
diff --git a/pkg/env/testdata/import.tpl.js b/pkg/env/testdata/import.tpl.js
new file mode 100644
index 0000000..65339dd
--- /dev/null
+++ b/pkg/env/testdata/import.tpl.js
@@ -0,0 +1,7 @@
+function execute(tpl, params) {
+  var img = tpl.FetchImage("import-image");
+  var cont = img.NewContainer("import-cont");
+
+  import_template("import2", {});
+  import_template("import3", {});
+}
diff --git a/pkg/env/testdata/import2.tpl.js b/pkg/env/testdata/import2.tpl.js
new file mode 100644
index 0000000..6972df3
--- /dev/null
+++ b/pkg/env/testdata/import2.tpl.js
@@ -0,0 +1,4 @@
+function execute(tpl, params) {
+  var img = tpl.FetchImage("import-image");
+  var cont = img.NewContainer("import2-cont");
+}
diff --git a/pkg/env/testdata/import3.tpl.js b/pkg/env/testdata/import3.tpl.js
new file mode 100644
index 0000000..2fb189a
--- /dev/null
+++ b/pkg/env/testdata/import3.tpl.js
@@ -0,0 +1,6 @@
+function execute(tpl, params) {
+  var img = tpl.FetchImage("import-image");
+  var cont = img.NewContainer("import3-cont");
+
+  import_template("import4", {});
+}
diff --git a/pkg/env/testdata/import4.tpl.js b/pkg/env/testdata/import4.tpl.js
new file mode 100644
index 0000000..1a48194
--- /dev/null
+++ b/pkg/env/testdata/import4.tpl.js
@@ -0,0 +1,4 @@
+function execute(tpl, params) {
+  var img = tpl.FetchImage("import-image");
+  var cont = img.NewContainer("import4-cont");
+}
diff --git a/pkg/server/server.go b/pkg/server/server.go
index aef3716..5d7aa77 100644
--- a/pkg/server/server.go
+++ b/pkg/server/server.go
@@ -63,6 +63,7 @@ type Params struct {
 	TLSCertFile      string
 	TLSKeyFile       string
 	AuthBackend      AuthBackend
+	RecursionLimit   int
 	Ctx              context.Context
 	CengCtx          context.Context
 	DefaultKeepalive time.Duration
@@ -237,6 +238,7 @@ func (s *Server) createEnvHandler(w http.ResponseWriter, req *http.Request) {
 		BaseMountDir:     s.params.BaseMountDir,
 		ExportAddress:    s.params.ExportAddress,
 		DefaultKeepAlive: def.Duration(s.params.DefaultKeepalive),
+		RecursionLimit:   s.params.RecursionLimit,
 		Ctx:              s.params.CengCtx,
 	})
 
diff --git a/pkg/tpl/execute.go b/pkg/tpl/execute.go
index 1f611ad..8e70367 100644
--- a/pkg/tpl/execute.go
+++ b/pkg/tpl/execute.go
@@ -43,6 +43,17 @@ var errCancelled = errors.New("Cancelled execution")
 
 const executeFunctionName = "execute"
 
+type importTpls struct {
+	list []*def.Tpl
+}
+
+func (it *importTpls) Add(tpl string, params map[string]interface{}) {
+	it.list = append(it.list, &def.Tpl{
+		Tpl:        tpl,
+		Parameters: params,
+	})
+}
+
 type ExecuteParams struct {
 	TplDir    string
 	WsDir     string
@@ -52,7 +63,8 @@ type ExecuteParams struct {
 	Ctx       context.Context
 }
 
-func Execute(envId, tplName string, tplIndex int, params ExecuteParams) (tpl *Tpl, err error) {
+func Execute(envId, tplName string, tplIndex int,
+	params ExecuteParams) (tpl *Tpl, _ []*def.Tpl, err error) {
 
 	defer func() {
 		if r := recover(); r != nil {
@@ -74,13 +86,16 @@ func Execute(envId, tplName string, tplIndex int, params ExecuteParams) (tpl *Tp
 
 	vm := otto.New()
 
+	imprt := &importTpls{}
+
 	// Setup library
 	setupLib(vm)
+	_ = vm.Set("import_template", imprt.Add)
 
 	jsFile, dataDir, err := getTplPaths(tplName, params.TplDir)
 
 	if err != nil {
-		return nil, errors.WithStack(err)
+		return nil, nil, errors.WithStack(err)
 	}
 
 	tplLog.Debugf("Executing tpl from %s (%s)", tplName, jsFile)
@@ -88,13 +103,13 @@ func Execute(envId, tplName string, tplIndex int, params ExecuteParams) (tpl *Tp
 	bytes, err := params.Fs.ReadFile(jsFile)
 
 	if err != nil {
-		return nil, errors.Wrapf(err, "Error reading tpl %s", tplName)
+		return nil, nil, errors.Wrapf(err, "Error reading tpl %s", tplName)
 	}
 
 	_, err = vm.Run(bytes)
 
 	if err != nil {
-		return nil, errors.Wrapf(err, "Error executing tpl %s", tplName)
+		return nil, nil, errors.Wrapf(err, "Error executing tpl %s", tplName)
 	}
 
 	// /<ws-dir>/<tpl-name>/<tpl-idx>
@@ -119,9 +134,9 @@ func Execute(envId, tplName string, tplIndex int, params ExecuteParams) (tpl *Tp
 	if err != nil {
 		executeLog.Errorf("%s", err.(*otto.Error).String())
 
-		return nil, errors.Wrapf(err, "Error calling %s function for %s",
+		return nil, nil, errors.Wrapf(err, "Error calling %s function for %s",
 			executeFunctionName, tpl.name)
 	}
 
-	return tpl, nil
+	return tpl, imprt.list, nil
 }
diff --git a/pkg/tpl/tpl.go b/pkg/tpl/tpl.go
index 94d5968..b65bf9a 100644
--- a/pkg/tpl/tpl.go
+++ b/pkg/tpl/tpl.go
@@ -60,6 +60,8 @@ type Tpl struct {
 	mountDir string
 	fs       *Fs
 
+	imported []*Tpl
+
 	ctx context.Context
 	sync.RWMutex
 }
@@ -154,3 +156,11 @@ func (tpl *Tpl) GetBuildImages() []*BuildImage {
 func (tpl *Tpl) GetFetchImages() []*FetchImage {
 	return tpl.fetchImages
 }
+
+func (tpl *Tpl) SetImported(imported []*Tpl) {
+	tpl.imported = imported
+}
+
+func (tpl *Tpl) GetImported() []*Tpl {
+	return tpl.imported
+}
diff --git a/tpl/db/cockroachdb.tpl.js b/tpl/db/cockroachdb.tpl.js
index 2314a90..fd4b88e 100644
--- a/tpl/db/cockroachdb.tpl.js
+++ b/tpl/db/cockroachdb.tpl.js
@@ -18,14 +18,15 @@ function execute(tpl, params) {
   cont.SetLabel("cockroachdb", "true");
   cont.MountData("init.sh", "/init.sh", {});
   cont.SetEntrypoint("/init.sh");
-  cont.SetPorts(26257);
+  cont.SetPorts(8080, 26257);
 
   if(type.IsDefined(params.init)) {
     cont.MountString(params.init.join("\n"), "/init.sql", 0644, {});
   }
 
-  cont.AddReadinessCheck("net", {
-    "protocol": "tcp",
-    "address": '{{.ExternalAddress}}:{{.Self.ExposedPort 26257}}',
+  cont.AddReadinessCheck("http", {
+    "url": 'http://{{.ExternalAddress}}:{{.SelfExposedPort 8080}}/health',
+    "codes": [200],
+    "retry_limit": 10,
   });
 }
\ No newline at end of file