diff --git a/haskell/tools/scratch-build.sh b/haskell/tools/scratch-build.sh
index 218485f2..36e73603 100755
--- a/haskell/tools/scratch-build.sh
+++ b/haskell/tools/scratch-build.sh
@@ -50,6 +50,18 @@ stack exec adlc -- cpp \
  -I $ADL_STDLIB_DIR \
  $ADL_STDLIB_DIR/sys/types.adl $ADL_STDLIB_DIR/sys/adlast.adl $ADL_STDLIB_DIR/sys/dynamic.adl
 
+ # Generate ADL modules for the rust compiler tooling
+stack exec adlc -- rust \
+ --no-overwrite \
+ --verbose \
+ --generate-transitive \
+ --outputdir ../rust/compiler/src \
+ --module adlgen \
+ --runtime-module adlrt \
+ --include-rt \
+ --searchdir  $ADL_STDLIB_DIR \
+ $ADL_STDLIB_DIR/sys/adlast.adl
+
 # Run some tests for each target language
 stack build generated-tests
 (cd ../typescript/tests; ./run-tests.sh)
diff --git a/rust/compiler/.gitignore b/rust/compiler/.gitignore
new file mode 100644
index 00000000..9f970225
--- /dev/null
+++ b/rust/compiler/.gitignore
@@ -0,0 +1 @@
+target/
\ No newline at end of file
diff --git a/rust/compiler/Cargo.lock b/rust/compiler/Cargo.lock
new file mode 100644
index 00000000..cc779cbd
--- /dev/null
+++ b/rust/compiler/Cargo.lock
@@ -0,0 +1,89 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "compiler"
+version = "0.1.0"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "632d02bff7f874a36f33ea8bb416cd484b90cc66c1194b1a1110d067a7013f58"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73b4b750c782965c211b42f022f59af1fbceabdd026623714f104152f1ec149f"
+
+[[package]]
+name = "serde"
+version = "1.0.136"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce31e24b01e1e524df96f1c2fdd054405f8d7376249a5110886fb4b658484789"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.136"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08597e7152fcd306f41838ed3e37be9eaeed2b61c42e2117266a554fab4662f9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e8d9fa5c3b304765ce1fd9c4c8a3de2c8db365a5b91be52f186efc675681d95"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.90"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "704df27628939572cd88d33f171cd6f896f4eaca85252c6e0a72d8d8287ee86f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
diff --git a/rust/compiler/Cargo.toml b/rust/compiler/Cargo.toml
new file mode 100644
index 00000000..7b777b45
--- /dev/null
+++ b/rust/compiler/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "compiler"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serde = { version = "1.0.130", features=["derive"] }
+serde_json = "1.0.68"
diff --git a/rust/compiler/src/adlgen/adlc/config/mod.rs b/rust/compiler/src/adlgen/adlc/config/mod.rs
new file mode 100644
index 00000000..1671ed04
--- /dev/null
+++ b/rust/compiler/src/adlgen/adlc/config/mod.rs
@@ -0,0 +1 @@
+pub mod rust;
\ No newline at end of file
diff --git a/rust/compiler/src/adlgen/adlc/config/rust.rs b/rust/compiler/src/adlgen/adlc/config/rust.rs
new file mode 100644
index 00000000..37b5c853
--- /dev/null
+++ b/rust/compiler/src/adlgen/adlc/config/rust.rs
@@ -0,0 +1,62 @@
+// @generated from adl module adlc.config.rust
+
+use serde::Deserialize;
+use serde::Serialize;
+
+/**
+ * ADL module or declaration annotation to control
+ * whether code is actually generated.
+ */
+pub type RustGenerate = bool;
+
+/**
+ * ADL field annotation giving explicit control over
+ * how a field should be stored.
+ */
+#[derive(Clone,Deserialize,Eq,Hash,PartialEq,Serialize)]
+pub enum RustStorageModel {
+  /**
+   * Standard inline storage
+   */
+  #[serde(rename="standard")]
+  Standard,
+
+  /**
+   * Store the value in a Box<>
+   */
+  #[serde(rename="boxed")]
+  Boxed,
+}
+
+/**
+ * ADL declaration annotation to specify that a custom type
+ * should be used
+ */
+#[derive(Clone,Deserialize,Eq,Hash,PartialEq,Serialize)]
+pub struct RustCustomType {
+  pub rustname: String,
+
+  pub helpers: String,
+
+  #[serde(default="RustCustomType::def_generate_orig_adl_type")]
+  #[serde(rename="generateOrigADLType")]
+  pub generate_orig_adl_type: String,
+
+  #[serde(rename="stdTraits")]
+  pub std_traits: Vec<String>,
+}
+
+impl RustCustomType {
+  pub fn new(rustname: String, helpers: String, std_traits: Vec<String>) -> RustCustomType {
+    RustCustomType {
+      rustname: rustname,
+      helpers: helpers,
+      generate_orig_adl_type: RustCustomType::def_generate_orig_adl_type(),
+      std_traits: std_traits,
+    }
+  }
+
+  pub fn def_generate_orig_adl_type() -> String {
+    "".to_string()
+  }
+}
diff --git a/rust/compiler/src/adlgen/adlc/mod.rs b/rust/compiler/src/adlgen/adlc/mod.rs
new file mode 100644
index 00000000..a1059337
--- /dev/null
+++ b/rust/compiler/src/adlgen/adlc/mod.rs
@@ -0,0 +1 @@
+pub mod config;
\ No newline at end of file
diff --git a/rust/compiler/src/adlgen/mod.rs b/rust/compiler/src/adlgen/mod.rs
new file mode 100644
index 00000000..b9c64637
--- /dev/null
+++ b/rust/compiler/src/adlgen/mod.rs
@@ -0,0 +1,2 @@
+pub mod adlc;
+pub mod sys;
\ No newline at end of file
diff --git a/rust/compiler/src/adlgen/sys/adlast.rs b/rust/compiler/src/adlgen/sys/adlast.rs
new file mode 100644
index 00000000..a8f7620c
--- /dev/null
+++ b/rust/compiler/src/adlgen/sys/adlast.rs
@@ -0,0 +1,246 @@
+// @generated from adl module sys.adlast
+
+use crate::adlrt::custom::sys::types::map::Map;
+use crate::adlrt::custom::sys::types::maybe::Maybe;
+use serde::Deserialize;
+use serde::Serialize;
+
+pub type ModuleName = String;
+
+pub type Ident = String;
+
+pub type Annotations = Map<ScopedName, serde_json::Value>;
+
+#[derive(Clone,Deserialize,Eq,Hash,PartialEq,Serialize)]
+pub struct ScopedName {
+  #[serde(rename="moduleName")]
+  pub module_name: ModuleName,
+
+  pub name: Ident,
+}
+
+impl ScopedName {
+  pub fn new(module_name: ModuleName, name: Ident) -> ScopedName {
+    ScopedName {
+      module_name: module_name,
+      name: name,
+    }
+  }
+}
+
+#[derive(Clone,Deserialize,Eq,Hash,PartialEq,Serialize)]
+pub enum TypeRef {
+  #[serde(rename="primitive")]
+  Primitive(Ident),
+
+  #[serde(rename="typeParam")]
+  TypeParam(Ident),
+
+  #[serde(rename="reference")]
+  Reference(ScopedName),
+}
+
+#[derive(Clone,Deserialize,Eq,Hash,PartialEq,Serialize)]
+pub struct TypeExpr {
+  #[serde(rename="typeRef")]
+  pub type_ref: TypeRef,
+
+  pub parameters: Vec<TypeExpr>,
+}
+
+impl TypeExpr {
+  pub fn new(type_ref: TypeRef, parameters: Vec<TypeExpr>) -> TypeExpr {
+    TypeExpr {
+      type_ref: type_ref,
+      parameters: parameters,
+    }
+  }
+}
+
+#[derive(Deserialize,PartialEq,Serialize)]
+pub struct Field {
+  pub name: Ident,
+
+  #[serde(rename="serializedName")]
+  pub serialized_name: Ident,
+
+  #[serde(rename="typeExpr")]
+  pub type_expr: TypeExpr,
+
+  pub default: Maybe<serde_json::Value>,
+
+  pub annotations: Annotations,
+}
+
+impl Field {
+  pub fn new(name: Ident, serialized_name: Ident, type_expr: TypeExpr, default: Maybe<serde_json::Value>, annotations: Annotations) -> Field {
+    Field {
+      name: name,
+      serialized_name: serialized_name,
+      type_expr: type_expr,
+      default: default,
+      annotations: annotations,
+    }
+  }
+}
+
+#[derive(Deserialize,PartialEq,Serialize)]
+pub struct Struct {
+  #[serde(rename="typeParams")]
+  pub type_params: Vec<Ident>,
+
+  pub fields: Vec<Field>,
+}
+
+impl Struct {
+  pub fn new(type_params: Vec<Ident>, fields: Vec<Field>) -> Struct {
+    Struct {
+      type_params: type_params,
+      fields: fields,
+    }
+  }
+}
+
+#[derive(Deserialize,PartialEq,Serialize)]
+pub struct Union {
+  #[serde(rename="typeParams")]
+  pub type_params: Vec<Ident>,
+
+  pub fields: Vec<Field>,
+}
+
+impl Union {
+  pub fn new(type_params: Vec<Ident>, fields: Vec<Field>) -> Union {
+    Union {
+      type_params: type_params,
+      fields: fields,
+    }
+  }
+}
+
+#[derive(Clone,Deserialize,Eq,Hash,PartialEq,Serialize)]
+pub struct TypeDef {
+  #[serde(rename="typeParams")]
+  pub type_params: Vec<Ident>,
+
+  #[serde(rename="typeExpr")]
+  pub type_expr: TypeExpr,
+}
+
+impl TypeDef {
+  pub fn new(type_params: Vec<Ident>, type_expr: TypeExpr) -> TypeDef {
+    TypeDef {
+      type_params: type_params,
+      type_expr: type_expr,
+    }
+  }
+}
+
+#[derive(Deserialize,PartialEq,Serialize)]
+pub struct NewType {
+  #[serde(rename="typeParams")]
+  pub type_params: Vec<Ident>,
+
+  #[serde(rename="typeExpr")]
+  pub type_expr: TypeExpr,
+
+  pub default: Maybe<serde_json::Value>,
+}
+
+impl NewType {
+  pub fn new(type_params: Vec<Ident>, type_expr: TypeExpr, default: Maybe<serde_json::Value>) -> NewType {
+    NewType {
+      type_params: type_params,
+      type_expr: type_expr,
+      default: default,
+    }
+  }
+}
+
+#[derive(Deserialize,PartialEq,Serialize)]
+pub enum DeclType {
+  #[serde(rename="struct_")]
+  Struct(Struct),
+
+  #[serde(rename="union_")]
+  Union(Union),
+
+  #[serde(rename="type_")]
+  Type(TypeDef),
+
+  #[serde(rename="newtype_")]
+  Newtype(NewType),
+}
+
+#[derive(Deserialize,PartialEq,Serialize)]
+pub struct Decl {
+  pub name: Ident,
+
+  pub version: Maybe<u32>,
+
+  #[serde(rename="type_")]
+  pub r#type: DeclType,
+
+  pub annotations: Annotations,
+}
+
+impl Decl {
+  pub fn new(name: Ident, version: Maybe<u32>, r#type: DeclType, annotations: Annotations) -> Decl {
+    Decl {
+      name: name,
+      version: version,
+      r#type: r#type,
+      annotations: annotations,
+    }
+  }
+}
+
+#[derive(Deserialize,PartialEq,Serialize)]
+pub struct ScopedDecl {
+  #[serde(rename="moduleName")]
+  pub module_name: ModuleName,
+
+  pub decl: Decl,
+}
+
+impl ScopedDecl {
+  pub fn new(module_name: ModuleName, decl: Decl) -> ScopedDecl {
+    ScopedDecl {
+      module_name: module_name,
+      decl: decl,
+    }
+  }
+}
+
+pub type DeclVersions = Vec<Decl>;
+
+#[derive(Clone,Deserialize,Eq,Hash,PartialEq,Serialize)]
+pub enum Import {
+  #[serde(rename="moduleName")]
+  ModuleName(ModuleName),
+
+  #[serde(rename="scopedName")]
+  ScopedName(ScopedName),
+}
+
+#[derive(Deserialize,PartialEq,Serialize)]
+pub struct Module {
+  pub name: ModuleName,
+
+  pub imports: Vec<Import>,
+
+  pub decls: std::collections::HashMap<String,Decl>,
+
+  pub annotations: Annotations,
+}
+
+impl Module {
+  pub fn new(name: ModuleName, imports: Vec<Import>, decls: std::collections::HashMap<String,Decl>, annotations: Annotations) -> Module {
+    Module {
+      name: name,
+      imports: imports,
+      decls: decls,
+      annotations: annotations,
+    }
+  }
+}
diff --git a/rust/compiler/src/adlgen/sys/annotations.rs b/rust/compiler/src/adlgen/sys/annotations.rs
new file mode 100644
index 00000000..2da57f13
--- /dev/null
+++ b/rust/compiler/src/adlgen/sys/annotations.rs
@@ -0,0 +1,23 @@
+// @generated from adl module sys.annotations
+
+use serde::Deserialize;
+use serde::Serialize;
+
+pub type Doc = String;
+
+pub type SerializedName = String;
+
+#[derive(Clone,Deserialize,Eq,Hash,PartialEq,Serialize)]
+pub struct SerializedWithInternalTag {
+  pub tag: String,
+}
+
+impl SerializedWithInternalTag {
+  pub fn new(tag: String) -> SerializedWithInternalTag {
+    SerializedWithInternalTag {
+      tag: tag,
+    }
+  }
+}
+
+pub type CustomSerialization = bool;
diff --git a/rust/compiler/src/adlgen/sys/mod.rs b/rust/compiler/src/adlgen/sys/mod.rs
new file mode 100644
index 00000000..e9398aa9
--- /dev/null
+++ b/rust/compiler/src/adlgen/sys/mod.rs
@@ -0,0 +1,3 @@
+pub mod adlast;
+pub mod annotations;
+pub mod types;
\ No newline at end of file
diff --git a/rust/compiler/src/adlgen/sys/types.rs b/rust/compiler/src/adlgen/sys/types.rs
new file mode 100644
index 00000000..d826c32c
--- /dev/null
+++ b/rust/compiler/src/adlgen/sys/types.rs
@@ -0,0 +1,13 @@
+// @generated from adl module sys.types
+
+use serde::Deserialize;
+use serde::Serialize;
+
+#[derive(Clone,Deserialize,Eq,Hash,PartialEq,Serialize)]
+pub enum Either<T1, T2> {
+  #[serde(rename="left")]
+  Left(T1),
+
+  #[serde(rename="right")]
+  Right(T2),
+}
diff --git a/rust/compiler/src/adlrt/custom/mod.rs b/rust/compiler/src/adlrt/custom/mod.rs
new file mode 100644
index 00000000..86cd4493
--- /dev/null
+++ b/rust/compiler/src/adlrt/custom/mod.rs
@@ -0,0 +1 @@
+pub mod sys;
diff --git a/rust/compiler/src/adlrt/custom/sys/mod.rs b/rust/compiler/src/adlrt/custom/sys/mod.rs
new file mode 100644
index 00000000..cd408564
--- /dev/null
+++ b/rust/compiler/src/adlrt/custom/sys/mod.rs
@@ -0,0 +1 @@
+pub mod types;
diff --git a/rust/compiler/src/adlrt/custom/sys/types/map.rs b/rust/compiler/src/adlrt/custom/sys/types/map.rs
new file mode 100644
index 00000000..27812baf
--- /dev/null
+++ b/rust/compiler/src/adlrt/custom/sys/types/map.rs
@@ -0,0 +1,56 @@
+use serde::{Deserialize, Deserializer};
+use serde::{Serialize, Serializer};
+use std::collections::HashMap;
+use std::hash::Hash;
+use std::result;
+use super::mapentry::MapEntry;
+
+
+#[derive(Clone,Eq,PartialEq)]
+pub struct Map<K:Eq + Hash, V>(HashMap<K, V>);
+
+impl<K:Eq + Hash, V> Map<K, V> {
+    pub fn new(v: Vec<MapEntry<K, V>>) -> Map<K, V>
+    {
+        let mut hm = HashMap::new();
+        for MapEntry{key,value} in v {
+            hm.insert(key,value);
+        }
+        Map(hm)
+    }
+}
+
+impl<K, V> Serialize for Map<K, V>
+where
+    K: Serialize + Eq + Hash,
+    V: Serialize,
+{
+    fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut ventries: Vec<MapEntry<&K, &V>> = Vec::new();
+        for (key, value) in &self.0 {
+            ventries.push(MapEntry{key, value});
+        }
+        MapImpl(ventries).serialize(serializer)
+    }
+}
+
+impl<'de, K, V> Deserialize<'de> for Map<K, V>
+where
+    K: Deserialize<'de> + Eq + Hash,
+    V: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let m = MapImpl::<K, V>::deserialize(deserializer)?;
+        Ok(Map::new(m.0))
+    }
+}
+
+#[derive(Deserialize,Eq,Hash,PartialEq,Serialize)]
+struct MapImpl<K, V>(pub Vec<MapEntry<K, V>>);
+
diff --git a/rust/compiler/src/adlrt/custom/sys/types/mapentry.rs b/rust/compiler/src/adlrt/custom/sys/types/mapentry.rs
new file mode 100644
index 00000000..cb168fec
--- /dev/null
+++ b/rust/compiler/src/adlrt/custom/sys/types/mapentry.rs
@@ -0,0 +1,20 @@
+use serde::{Deserialize};
+use serde::{Serialize};
+
+#[derive(Clone,Deserialize,Eq,Hash,PartialEq,Serialize)]
+pub struct MapEntry<K, V> {
+  #[serde(rename="k")]
+  pub key: K,
+
+  #[serde(rename="v")]
+  pub value: V,
+}
+
+impl<K, V> MapEntry<K, V> {
+  pub fn new(key: K, value: V) -> MapEntry<K, V> {
+    MapEntry {
+      key: key,
+      value: value,
+    }
+  }
+}
diff --git a/rust/compiler/src/adlrt/custom/sys/types/maybe.rs b/rust/compiler/src/adlrt/custom/sys/types/maybe.rs
new file mode 100644
index 00000000..f6faded6
--- /dev/null
+++ b/rust/compiler/src/adlrt/custom/sys/types/maybe.rs
@@ -0,0 +1,57 @@
+use serde::{Deserialize, Deserializer};
+use serde::{Serialize, Serializer};
+use std::result;
+
+// Maybe<T> is a custom mapping to Option<T>,
+// with ADL compatible serialization
+
+#[derive(Clone,Eq,Hash,PartialEq)]
+pub struct Maybe<T> (Option<T>);
+
+impl<T> Maybe<T> {
+  pub fn nothing() -> Maybe<T> {
+      Maybe(Option::None)
+  }
+
+  pub fn just(t: T) -> Maybe<T> {
+      Maybe(Option::Some(t))
+  }
+}
+
+impl<T: Serialize> Serialize for Maybe<T> {
+  fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
+  where
+      S: Serializer,
+  {
+      let m: MaybeImpl<&T> = match self {
+          Maybe(Option::None) => MaybeImpl::Nothing,
+          Maybe(Option::Some(v)) => MaybeImpl::Just(v),
+      };
+      m.serialize(serializer)
+  }
+}
+
+impl<'de, T: Deserialize<'de>> Deserialize<'de> for Maybe<T> {
+  fn deserialize<D>(deserializer: D) -> result::Result<Self, D::Error>
+  where
+      D: Deserializer<'de>,
+  {
+      let m = MaybeImpl::deserialize(deserializer)?;
+      match m {
+        MaybeImpl::Just(v) => Ok(Maybe(Option::Some(v))),
+        MaybeImpl::Nothing => Ok(Maybe(Option::None)),
+      }
+  }
+}
+
+#[derive(Deserialize,Serialize)]
+enum MaybeImpl<T> {
+  #[serde(rename="nothing")]
+  Nothing,
+
+  #[serde(rename="just")]
+  Just(T),
+}
+
+
+
diff --git a/rust/compiler/src/adlrt/custom/sys/types/mod.rs b/rust/compiler/src/adlrt/custom/sys/types/mod.rs
new file mode 100644
index 00000000..ad9171a9
--- /dev/null
+++ b/rust/compiler/src/adlrt/custom/sys/types/mod.rs
@@ -0,0 +1,6 @@
+pub mod mapentry;
+pub mod map;
+pub mod maybe;
+pub mod pair;
+pub mod result;
+pub mod set;
diff --git a/rust/compiler/src/adlrt/custom/sys/types/pair.rs b/rust/compiler/src/adlrt/custom/sys/types/pair.rs
new file mode 100644
index 00000000..aa41a129
--- /dev/null
+++ b/rust/compiler/src/adlrt/custom/sys/types/pair.rs
@@ -0,0 +1,49 @@
+use serde::{Deserialize, Deserializer};
+use serde::{Serialize, Serializer};
+use std::result;
+
+#[derive(Clone,Eq,Hash,PartialEq)]
+pub struct Pair<A,B> (pub (A,B));
+
+impl<A, B> Pair<A, B> {
+    pub fn new(a: A, b: B) -> Pair<A, B> {
+        Pair((a, b))
+    }
+}
+
+impl<A, B> Serialize for Pair<A, B>
+where
+    A: Serialize,
+    B: Serialize,
+{
+    fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let Pair((a, b)) = self;
+        PairImpl { v_1: a, v_2: b }.serialize(serializer)
+    }
+}
+
+impl<'de, A, B> Deserialize<'de> for Pair<A, B>
+where
+    A: Deserialize<'de>,
+    B: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let m = PairImpl::<A, B>::deserialize(deserializer)?;
+        Ok(Pair((m.v_1, m.v_2)))
+    }
+}
+
+#[derive(Deserialize,Serialize)]
+struct PairImpl<A, B> {
+  #[serde(rename="v1")]
+  pub v_1: A,
+
+  #[serde(rename="v2")]
+  pub v_2: B,
+}
diff --git a/rust/compiler/src/adlrt/custom/sys/types/result.rs b/rust/compiler/src/adlrt/custom/sys/types/result.rs
new file mode 100644
index 00000000..fa52edc8
--- /dev/null
+++ b/rust/compiler/src/adlrt/custom/sys/types/result.rs
@@ -0,0 +1,61 @@
+use serde::{Deserialize, Deserializer};
+use serde::{Serialize, Serializer};
+
+
+#[derive(Clone,Eq,Hash,PartialEq)]
+pub struct Result<T, E>(pub std::result::Result<T, E>);
+
+impl<T, E> Result<T, E> {
+    pub fn ok(value: T) -> Result<T, E> {
+        Result(Ok(value))
+    }
+
+    pub fn err(e: E) -> Result<T, E> {
+        Result(Err(e))
+    }
+}
+
+impl<T, E> Serialize for Result<T, E>
+where
+    T: Serialize,
+    E: Serialize,
+{
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let m = match &self.0 {
+            Ok(v) => ResultImpl::Ok(v),
+            Err(e) => ResultImpl::Error(e),
+        };
+        m.serialize(serializer)
+    }
+}
+
+impl<'de, T, E> Deserialize<'de> for Result<T, E>
+where
+    T: Deserialize<'de>,
+    E: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let m = ResultImpl::deserialize(deserializer)?;
+        Ok(match m {
+            ResultImpl::Ok(v) => Result::ok(v),
+            ResultImpl::Error(e) => Result::err(e),
+        })
+    }
+}
+
+
+#[derive(Deserialize,Serialize)]
+enum ResultImpl<T, E> {
+  #[serde(rename="ok")]
+  Ok(T),
+
+  #[serde(rename="error")]
+  Error(E),
+}
+
diff --git a/rust/compiler/src/adlrt/custom/sys/types/set.rs b/rust/compiler/src/adlrt/custom/sys/types/set.rs
new file mode 100644
index 00000000..fcf58940
--- /dev/null
+++ b/rust/compiler/src/adlrt/custom/sys/types/set.rs
@@ -0,0 +1,48 @@
+use serde::{Deserialize, Deserializer};
+use serde::{Serialize, Serializer};
+use std::collections::HashSet;
+use std::hash::Hash;
+use std::result;
+
+#[derive(Clone,Eq,PartialEq)]
+pub struct Set<T:Eq + Hash>(HashSet<T>);
+
+impl<T:Eq + Hash> Set<T> {
+    pub fn new(v: Vec<T>) -> Set<T>
+    {
+        Set(v.into_iter().collect())
+    }
+}
+
+impl<T> Serialize for Set<T>
+where
+    T: Serialize + Eq + Hash,
+{
+    fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut vpairs: Vec<&T> = Vec::new();
+        for t in &self.0 {
+            vpairs.push(t);
+        }
+        SetImpl(vpairs).serialize(serializer)
+    }
+}
+
+impl<'de, T> Deserialize<'de> for Set<T>
+where
+    T: Deserialize<'de> + Eq + Hash,
+{
+    fn deserialize<D>(deserializer: D) -> result::Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let m = SetImpl::<T>::deserialize(deserializer)?;
+        Ok(Set(m.0.into_iter().collect()))
+    }
+}
+
+
+#[derive(Deserialize,Serialize)]
+struct SetImpl<T>(pub Vec<T>);
diff --git a/rust/compiler/src/adlrt/mod.rs b/rust/compiler/src/adlrt/mod.rs
new file mode 100644
index 00000000..d5f90568
--- /dev/null
+++ b/rust/compiler/src/adlrt/mod.rs
@@ -0,0 +1 @@
+pub mod custom;
diff --git a/rust/compiler/src/lib.rs b/rust/compiler/src/lib.rs
new file mode 100644
index 00000000..0db8d741
--- /dev/null
+++ b/rust/compiler/src/lib.rs
@@ -0,0 +1,11 @@
+mod adlgen;
+mod adlrt;
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        let result = 2 + 2;
+        assert_eq!(result, 4);
+    }
+}