diff --git a/morphir/src/org/finos/morphir/lang/elm/ElmDependencyMap.scala b/morphir/src/org/finos/morphir/lang/elm/ElmDependencyMap.scala
index 75f0f9075..cca293c7a 100644
--- a/morphir/src/org/finos/morphir/lang/elm/ElmDependencyMap.scala
+++ b/morphir/src/org/finos/morphir/lang/elm/ElmDependencyMap.scala
@@ -37,4 +37,8 @@ object ElmDependencyMap extends Subtype[Map[ElmPackageName, ElmPackageVersion]]:
     subtypeCodec[Map[ElmPackageName, ElmPackageVersion], ElmDependencyMap]
 
   def fromMap(map: Map[ElmPackageName, ElmPackageVersion]): ElmDependencyMap = unsafeMake(map)
+
+  def apply(elems: (ElmPackageName, ElmPackageVersion)*): ElmDependencyMap =
+    fromMap(Map.from(elems))
+
 end ElmDependencyMap
diff --git a/morphir/src/org/finos/morphir/lang/elm/project.scala b/morphir/src/org/finos/morphir/lang/elm/project.scala
index 6d274f07f..a1801401e 100644
--- a/morphir/src/org/finos/morphir/lang/elm/project.scala
+++ b/morphir/src/org/finos/morphir/lang/elm/project.scala
@@ -38,6 +38,13 @@ object ElmProject extends ConfigCompanion[ElmProject]:
       case _ => Configured.error("Expected an object")
   }
 
+  given confEncoder: ConfEncoder[ElmProject] = new ConfEncoder[ElmProject] {
+    def write(project: ElmProject): Conf = project match
+      case app: ElmApplication =>
+        ElmApplication.confEncoder.write(app)
+      case pack: ElmPackage => ElmPackage.confEncoder.write(pack)
+  }
+
   final case class ElmApplication(
     @ExtraName("source-directories") override val sourceDirectories: List[String],
     @ExtraName("elm-version") elmVersion: SemVerString,
@@ -59,13 +66,13 @@ object ElmProject extends ConfigCompanion[ElmProject]:
   end ElmApplication
 
   final case class ElmPackage(
-    name: ElmPackageName,
+    @ExtraName("name") name: ElmPackageName,
     summary: Option[String],
     version: ElmPackageVersion,
-    elmVersion: String,
-    exposedModules: List[ElmModuleName],
+    @ExtraName("elm-version") elmVersion: String,
+    @ExtraName("exposed-modules") exposedModules: List[ElmModuleName],
     dependencies: Map[String, String],
-    testDependencies: Map[String, String]
+    @ExtraName("test-dependencies") testDependencies: Map[String, String]
   ) extends ElmProject
 
   object ElmPackage:
diff --git a/morphir/test/src/org/finos/morphir/lang/elm/ElmProjectSpec.scala b/morphir/test/src/org/finos/morphir/lang/elm/ElmProjectSpec.scala
index 00afca8ec..a9c2d241a 100644
--- a/morphir/test/src/org/finos/morphir/lang/elm/ElmProjectSpec.scala
+++ b/morphir/test/src/org/finos/morphir/lang/elm/ElmProjectSpec.scala
@@ -2,15 +2,11 @@ package org.finos.morphir.lang.elm
 
 import org.finos.morphir.testing.{MorphirKyoSpecDefault, MorphirSpecDefault}
 import kyo.*
-import metaconfig.{Conf, ConfDecoder, ConfEncoder, Configured, Input}
-import org.finos.morphir.NonNegativeInt
+import metaconfig.{Conf, Configured, Input}
 import zio.test.*
 import zio.test.Assertion.*
 import org.finos.morphir.config.*
-import org.finos.morphir.lang.elm.ElmProjectSpec.{compileError, test}
-import org.finos.morphir.api.MajorVersionNumber
-import org.finos.morphir.api.MinorVersionNumber
-import org.finos.morphir.api.PatchVersionNumber
+import org.finos.morphir.api.{MajorVersionNumber, MinorVersionNumber, PatchVersionNumber, SemVerString}
 
 object ElmProjectSpec extends MorphirSpecDefault {
   def spec = suite("ElmProjectSuite")(
@@ -22,8 +18,6 @@ object ElmProjectSpec extends MorphirSpecDefault {
   )
 
   private def elmProjectSuite =
-//    import ElmApplication.given
-
     suite("ElmProjectSpec")(
       test("should be able to read an application elm.json file") {
         val workspaceFilePath = os.resource / "org" / "finos" / "morphir" / "lang" / "elm" / "application" / "elm.json"
@@ -31,6 +25,85 @@ object ElmProjectSpec extends MorphirSpecDefault {
         val input: metaconfig.Input = Input.String(contents)
         val actual                  = ElmProject.parseInput(input)
         assertTrue(actual.isInstanceOf[kyo.Result.Success[ElmProject]])
+      },
+      test("should be able to create an application elm.json file") {
+        val app = ElmProject.ElmApplication(
+          List("sourceOne", "sourceTwo"),
+          SemVerString("v0.0.2"),
+          ElmApplicationDependencies(
+            ElmDependencyMap(ElmPackageName("author/direct")   -> ElmPackageVersion.default),
+            ElmDependencyMap(ElmPackageName("author/indirect") -> ElmPackageVersion.default)
+          ),
+          ElmApplicationDependencies(
+            ElmDependencyMap(ElmPackageName("author/direct2")   -> ElmPackageVersion.default),
+            ElmDependencyMap(ElmPackageName("author/indirect2") -> ElmPackageVersion.default)
+          )
+        )
+        val result = ElmProject.confEncoder.write(app)
+        assertTrue(
+          result ==
+            Conf.Obj(
+              "sourceDirectories" -> Conf.Lst(Conf.Str("sourceOne"), Conf.Str("sourceTwo")),
+              "elmVersion"        -> Conf.Str("v0.0.2"),
+              "dependencies" -> Conf.Obj(
+                "direct" -> Conf.Obj(
+                  "author/direct" -> Conf.Str("0.0.1")
+                ),
+                "indirect" -> Conf.Obj(
+                  "author/indirect" -> Conf.Str("0.0.1")
+                )
+              ),
+              "testDependencies" -> Conf.Obj(
+                "direct" -> Conf.Obj(
+                  "author/direct2" -> Conf.Str("0.0.1")
+                ),
+                "indirect" -> Conf.Obj(
+                  "author/indirect2" -> Conf.Str("0.0.1")
+                )
+              )
+            )
+        )
+      },
+      test("should be able to read an package elm.json file") {
+        val workspaceFilePath = os.resource / "org" / "finos" / "morphir" / "lang" / "elm" / "elm-package" / "elm.json"
+        val contents: String  = os.read(workspaceFilePath)
+        val input: metaconfig.Input = Input.String(contents)
+        val actual                  = ElmProject.parseInput(input)
+        assertTrue(actual.isInstanceOf[kyo.Result.Success[ElmProject]])
+      } @@ TestAspect.ignore, // TODO: doesn't match the field names in file
+      test("should be able to create a package elm.json file") {
+        val pack = ElmProject.ElmPackage(
+          ElmPackageName("author/package"),
+          None,
+          ElmPackageVersion.default,
+          "0.19.0 <= v < 0.20.0",
+          List(
+            ElmModuleName("Morphir.SDK.Decimal"),
+            ElmModuleName("Morphir.SDK.String")
+          ),
+          Map("elm/pack"  -> "0.1.0 <= v < 0.2.0"),
+          Map("test/pack" -> "4.2.0 <= v < 5.0.0")
+        )
+        val result = ElmProject.confEncoder.write(pack)
+        assertTrue(
+          result ==
+            Conf.Obj(
+              "name"       -> Conf.Str("author/package"),
+              "summary"    -> Conf.Null(),
+              "version"    -> Conf.Str("0.0.1"),
+              "elmVersion" -> Conf.Str("0.19.0 <= v < 0.20.0"),
+              "exposedModules" -> Conf.Lst(
+                Conf.Str("Morphir.SDK.Decimal"),
+                Conf.Str("Morphir.SDK.String")
+              ),
+              "dependencies" -> Conf.Obj(
+                "elm/pack" -> Conf.Str("0.1.0 <= v < 0.2.0")
+              ),
+              "testDependencies" -> Conf.Obj(
+                "test/pack" -> Conf.Str("4.2.0 <= v < 5.0.0")
+              )
+            )
+        )
       }
     )