diff --git a/.gitignore b/.gitignore
index 08fb4c6..d76d9aa 100644
--- a/.gitignore
+++ b/.gitignore
@@ -42,8 +42,8 @@ yalc.lock
 .vscode/settings.json
 
 # ignore Rust compiler files
-/server/target
-backend
+/backend/target
+/backend/out
 /bin
 
 # packaged teasers
diff --git a/server/Cargo.lock b/backend/Cargo.lock
similarity index 98%
rename from server/Cargo.lock
rename to backend/Cargo.lock
index 7c22aad..1411f60 100644
--- a/server/Cargo.lock
+++ b/backend/Cargo.lock
@@ -2,6 +2,28 @@
 # It is not intended for manual editing.
 version = 3
 
+[[package]]
+name = "async-recursion"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2cda8f4bcc10624c4e85bc66b3f452cca98cfa5ca002dc83a16aad2367641bea"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "async-trait"
+version = "0.1.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76464446b8bc32758d7e88ee1a804d9914cd9b1cb264c029899680b0be29826f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "autocfg"
 version = "1.1.0"
@@ -349,10 +371,12 @@ checksum = "112c678d4050afce233f4f2852bb2eb519230b3cf12f33585275537d7e41578d"
 name = "kaylon"
 version = "0.1.0"
 dependencies = [
+ "async-trait",
  "log",
  "serde",
  "serde_json",
  "simplelog",
+ "tokio",
  "usdpl-back",
 ]
 
@@ -959,11 +983,12 @@ dependencies = [
 
 [[package]]
 name = "usdpl-back"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbbc0781e83ba990f8239142e33173a2d2548701775f3db66702d1af4fd0319a"
+version = "0.7.0"
 dependencies = [
+ "async-recursion",
+ "async-trait",
  "bytes",
+ "log",
  "tokio",
  "usdpl-core",
  "warp",
@@ -972,8 +997,6 @@ dependencies = [
 [[package]]
 name = "usdpl-core"
 version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "862153581fac266458521f49e5906a71c1eee1665cb4c7d71e9586bd34b45394"
 dependencies = [
  "base64",
 ]
diff --git a/server/Cargo.toml b/backend/Cargo.toml
similarity index 68%
rename from server/Cargo.toml
rename to backend/Cargo.toml
index 149dc12..8f61ea2 100644
--- a/server/Cargo.toml
+++ b/backend/Cargo.toml
@@ -6,8 +6,13 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-usdpl-back = { version = "0.6.0", features = ["decky"] }
+usdpl-back = { version = "0.7.0", features = ["decky"], path = "../../usdpl-rs/usdpl-back" }
 
+# async
+tokio = { version = "*", features = ["sync", "time"] }
+async-trait = "0.1.57"
+
+# json
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 
diff --git a/server/Cross.toml b/backend/Cross.toml
similarity index 100%
rename from server/Cross.toml
rename to backend/Cross.toml
diff --git a/backend/build.sh b/backend/build.sh
new file mode 100755
index 0000000..37223e7
--- /dev/null
+++ b/backend/build.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+#cargo build --release --target x86_64-unknown-linux-musl
+cargo build --target x86_64-unknown-linux-musl
+#cross build --release
+
+mkdir -p ../bin
+#cp ./target/x86_64-unknown-linux-musl/release/kaylon ../bin/backend
+cp ./target/x86_64-unknown-linux-musl/debug/kaylon ../bin/backend
+#cp ./target/release/kaylon ../bin/backend
+
+cp ../kaylon.json ../bin/kaylon.json
diff --git a/backend/src/api/about.rs b/backend/src/api/about.rs
new file mode 100644
index 0000000..410cf70
--- /dev/null
+++ b/backend/src/api/about.rs
@@ -0,0 +1,25 @@
+use std::sync::{Mutex, mpsc::{Sender, channel}};
+
+use super::ApiParameterType;
+
+use crate::runtime::{QueueAction, QueueItem};
+
+pub fn get_about(sender: Sender<QueueItem>) -> impl Fn(ApiParameterType) -> ApiParameterType {
+    let sender = Mutex::new(sender);
+    move |_| {
+        log::debug!("API: get_about");
+        let (rx, tx) = channel();
+        sender.lock().unwrap().send(
+            QueueItem {
+                action: QueueAction::GetAbout {
+                    respond_to: rx,
+                }
+            }
+        ).unwrap();
+        vec![
+            usdpl_back::core::serdes::Primitive::Json(
+                serde_json::to_string(&tx.recv().unwrap()).unwrap()
+            )
+        ]
+    }
+}
diff --git a/backend/src/api/get_display.rs b/backend/src/api/get_display.rs
new file mode 100644
index 0000000..10233d1
--- /dev/null
+++ b/backend/src/api/get_display.rs
@@ -0,0 +1,72 @@
+use std::sync::{Mutex, mpsc::{Sender, channel, self}};
+
+use usdpl_back::core::serdes::Primitive;
+use usdpl_back::AsyncCallable;
+
+use super::ApiParameterType;
+
+use crate::runtime::{QueueAction, QueueItem};
+
+pub struct GetDisplayEndpoint {
+    //sender: tokio::sync::mpsc::Sender<SetCallbackAsync>,
+    //receiver: Mutex<Option<tokio::sync::mpsc::Receiver<SetCallbackAsync>>>,
+    sync_sender: Mutex<Sender<QueueItem>>,
+}
+
+impl GetDisplayEndpoint {
+    pub fn new(sender: Sender<QueueItem>) -> Self {
+        //let (async_tx, async_rx) = tokio::sync::mpsc::channel::<SetCallbackAsync>(64);
+        Self {
+            //sender: async_tx,
+            //receiver: Mutex::new(Some(async_rx)),
+            sync_sender: Mutex::new(sender),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl AsyncCallable for GetDisplayEndpoint {
+    async fn call(&self, params: ApiParameterType) -> ApiParameterType {
+        log::debug!("API: get_display");
+        if let Some(Primitive::F64(index)) = params.get(0) {
+            let index = *index as usize;
+            let (respond_to, receiver) = channel();
+            log::info!("requesting display for item #{}", index);
+            let send_result = self.sync_sender.lock().unwrap().send(
+                QueueItem {
+                    action: QueueAction::SetCallback {
+                        index,
+                        respond_to,
+                    }
+                }
+            );
+            if let Ok(_) = send_result {
+                // TODO: don't poll for response
+                log::info!("waiting for display for item #{}", index);
+                let sleep_duration = std::time::Duration::from_millis(10);
+                let receiver = Mutex::new(receiver);
+                loop {
+                    let received = receiver.lock().unwrap().try_recv();
+                    match received {
+                        Err(mpsc::TryRecvError::Disconnected) => {
+                            log::info!("Failed to response for get_display for #{}", index);
+                            return vec![Primitive::Empty];
+                        },
+                        Err(_) => {},
+                        Ok(x) => {
+                            log::debug!("got display for item #{}", index);
+                            return vec![x];
+                        },
+                    }
+                    tokio::time::sleep(sleep_duration).await;
+                }
+            } else {
+                log::info!("Failed to get_display for #{}", index);
+                vec![Primitive::Empty]
+            }
+
+        } else {
+            vec![Primitive::Empty]
+        }
+    }
+}
diff --git a/backend/src/api/get_item.rs b/backend/src/api/get_item.rs
new file mode 100644
index 0000000..b9b8c39
--- /dev/null
+++ b/backend/src/api/get_item.rs
@@ -0,0 +1,26 @@
+use std::sync::{Mutex, mpsc::{Sender, channel}};
+
+use super::ApiParameterType;
+
+use crate::runtime::{QueueAction, QueueItem};
+
+pub fn get_items(sender: Sender<QueueItem>) -> impl Fn(ApiParameterType) -> ApiParameterType {
+    let sender = Mutex::new(sender);
+    move |_| {
+        log::debug!("API: get_items");
+        let (rx, tx) = channel();
+        sender.lock().unwrap().send(
+            QueueItem {
+                action: QueueAction::DoReload {
+                    respond_to: rx,
+                }
+            }
+        ).unwrap();
+        log::info!("waiting for items");
+        vec![
+            usdpl_back::core::serdes::Primitive::Json(
+                serde_json::to_string(&tx.recv().unwrap()).unwrap()
+            )
+        ]
+    }
+}
diff --git a/backend/src/api/mod.rs b/backend/src/api/mod.rs
new file mode 100644
index 0000000..b2a8844
--- /dev/null
+++ b/backend/src/api/mod.rs
@@ -0,0 +1,13 @@
+mod about;
+mod get_display;
+mod get_item;
+mod on_update;
+mod reload;
+
+pub use about::get_about;
+pub use get_display::GetDisplayEndpoint;
+pub use get_item::get_items;
+pub use on_update::on_update;
+pub use reload::reload;
+
+pub(super) type ApiParameterType = Vec<usdpl_back::core::serdes::Primitive>;
diff --git a/backend/src/api/on_update.rs b/backend/src/api/on_update.rs
new file mode 100644
index 0000000..d0beb68
--- /dev/null
+++ b/backend/src/api/on_update.rs
@@ -0,0 +1,34 @@
+use std::sync::{Mutex, mpsc::Sender};
+
+use usdpl_back::core::serdes::Primitive;
+
+use super::ApiParameterType;
+
+use crate::runtime::{QueueAction, QueueItem};
+
+pub fn on_update(sender: Sender<QueueItem>) -> impl Fn(ApiParameterType) -> ApiParameterType {
+    let sender = Mutex::new(sender);
+    move |mut params: ApiParameterType| {
+        log::debug!("API: on_update");
+        if params.len() == 2 {
+            if let Primitive::F64(index) = params.remove(0) {
+                let index = index as usize;
+                let val = params.remove(0);
+                sender.lock().unwrap().send(
+                    QueueItem {
+                        action: QueueAction::DoUpdate {
+                            index,
+                            value: val,
+                        }
+                    }
+                ).unwrap();
+                log::info!("Sent update for #{}", index);
+                vec![true.into()]
+            } else {
+                vec![false.into()]
+            }
+        } else {
+            vec![false.into()]
+        }
+    }
+}
diff --git a/backend/src/api/reload.rs b/backend/src/api/reload.rs
new file mode 100644
index 0000000..869211e
--- /dev/null
+++ b/backend/src/api/reload.rs
@@ -0,0 +1,26 @@
+use std::sync::{Mutex, mpsc::{Sender, channel}};
+
+use super::ApiParameterType;
+
+use crate::runtime::{QueueAction, QueueItem};
+
+pub fn reload(sender: Sender<QueueItem>) -> impl Fn(ApiParameterType) -> ApiParameterType {
+    let sender = Mutex::new(sender);
+    move |_| {
+        log::debug!("API: reload");
+        let (rx, tx) = channel();
+        sender.lock().unwrap().send(
+            QueueItem {
+                action: QueueAction::DoReload {
+                    respond_to: rx,
+                }
+            }
+        ).unwrap();
+        log::info!("waiting for JSON reload");
+        vec![
+            usdpl_back::core::serdes::Primitive::Json(
+                serde_json::to_string(&tx.recv().unwrap()).unwrap()
+            )
+        ]
+    }
+}
diff --git a/backend/src/config/about.rs b/backend/src/config/about.rs
new file mode 100644
index 0000000..7a90230
--- /dev/null
+++ b/backend/src/config/about.rs
@@ -0,0 +1,24 @@
+use serde::{Serialize, Deserialize};
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct AboutConfig {
+    pub name: String,
+    pub version: String,
+    pub description: String,
+    pub url: Option<String>,
+    pub authors: Vec<String>,
+    pub license: Option<String>,
+}
+
+impl Default for AboutConfig {
+    fn default() -> Self {
+        Self {
+            name: env!("CARGO_PKG_NAME").to_owned(),
+            version: env!("CARGO_PKG_VERSION").to_owned(),
+            description: env!("CARGO_PKG_DESCRIPTION").to_owned(),
+            url: Some(env!("CARGO_PKG_HOMEPAGE").to_owned()),
+            authors: env!("CARGO_PKG_AUTHORS").split(':').map(|x| x.to_owned()).collect(),
+            license: Some(env!("CARGO_PKG_LICENSE").to_owned())
+        }
+    }
+}
diff --git a/server/src/config/action.rs b/backend/src/config/action.rs
similarity index 100%
rename from server/src/config/action.rs
rename to backend/src/config/action.rs
diff --git a/backend/src/config/base.rs b/backend/src/config/base.rs
new file mode 100644
index 0000000..157df98
--- /dev/null
+++ b/backend/src/config/base.rs
@@ -0,0 +1,52 @@
+use serde::{Serialize, Deserialize};
+
+use super::{ElementConfig, AboutConfig};
+
+#[derive(Serialize, Deserialize, Clone)]
+#[serde(tag = "api-version")]
+pub enum BaseConfig {
+    #[serde(rename = "v0.0.0")]
+    V0 {
+        items: Vec<ElementConfig>,
+        about: AboutConfig,
+    },
+}
+
+impl BaseConfig {
+    pub fn load<P: AsRef<std::path::Path>>(path: P) -> Self {
+        //let path = std::path::Path::new("./").join(path);
+        let path = path.as_ref();
+        match std::fs::File::open(&path) {
+            Ok(file) => {
+                let reader = std::io::BufReader::new(file);
+                match serde_json::from_reader(reader) {
+                    Ok(conf) => return conf,
+                    Err(e) => log::error!("Failed to deserialize {}: {}", path.display(), e),
+                }
+            },
+            Err(e) => log::error!("Failed to open {}: {}", path.display(), e),
+        }
+        panic!("Cannot open {}", path.display())
+    }
+
+    #[inline]
+    pub fn get_about(&self) -> &AboutConfig {
+        match self {
+            Self::V0 {about, ..} => about,
+        }
+    }
+
+    #[inline]
+    pub fn get_item(&self, index: usize) -> Option<&ElementConfig> {
+        match self {
+            Self::V0 {items, ..} => items.get(index),
+        }
+    }
+
+    #[inline]
+    pub fn items(&self) -> &Vec<ElementConfig> {
+        match self {
+            Self::V0 {items, ..} => items,
+        }
+    }
+}
diff --git a/server/src/config/button.rs b/backend/src/config/button.rs
similarity index 100%
rename from server/src/config/button.rs
rename to backend/src/config/button.rs
diff --git a/server/src/config/element.rs b/backend/src/config/element.rs
similarity index 73%
rename from server/src/config/element.rs
rename to backend/src/config/element.rs
index 09bb59b..0d10d13 100644
--- a/server/src/config/element.rs
+++ b/backend/src/config/element.rs
@@ -1,6 +1,6 @@
 use serde::{Serialize, Deserialize};
 
-use super::{ButtonConfig, ToggleConfig, SliderConfig, ReadingConfig};
+use super::{ButtonConfig, ToggleConfig, SliderConfig, ReadingConfig, ResultDisplayConfig};
 
 #[derive(Serialize, Deserialize, Clone)]
 #[serde(tag = "element")]
@@ -12,5 +12,7 @@ pub enum ElementConfig {
     #[serde(rename = "slider")]
     Slider(SliderConfig),
     #[serde(rename = "reading")]
-    Reading(ReadingConfig),
+    ReadingDisplay(ReadingConfig),
+    #[serde(rename = "result-display")]
+    ResultDisplay(ResultDisplayConfig),
 }
diff --git a/server/src/config/mod.rs b/backend/src/config/mod.rs
similarity index 79%
rename from server/src/config/mod.rs
rename to backend/src/config/mod.rs
index 32f9b4f..d922af5 100644
--- a/server/src/config/mod.rs
+++ b/backend/src/config/mod.rs
@@ -4,6 +4,7 @@ mod base;
 mod button;
 mod element;
 mod reading;
+mod result_display;
 mod slider;
 mod toggle;
 
@@ -13,6 +14,7 @@ pub use base::BaseConfig;
 pub use button::ButtonConfig;
 pub use element::ElementConfig;
 pub use reading::ReadingConfig;
+pub use result_display::ResultDisplayConfig;
 pub use slider::SliderConfig;
 pub use toggle::ToggleConfig;
 
@@ -31,8 +33,7 @@ mod test {
                 ElementConfig::Toggle(ToggleConfig {
                     title: "Test Toggle".into(),
                     description: Some("Toggle description".into()),
-                    on_enable: ActionConfig::Command(CommandAction{run: "echo 'hello toggle 1'".into()}),
-                    on_disable: ActionConfig::Command(CommandAction{run: "echo 'hello toggle 0'".into()}),
+                    on_toggle: ActionConfig::Command(CommandAction{run: "echo 'hello toggle $KAYLON_VALUE'".into()}),
                 }),
                 ElementConfig::Slider(SliderConfig {
                     title: "Test Slider".into(),
@@ -41,18 +42,22 @@ mod test {
                     notches: None,
                     on_set: ActionConfig::Command(CommandAction{run: "echo 'hello slider'".into()}),
                 }),
-                ElementConfig::Reading(ReadingConfig {
+                ElementConfig::ReadingDisplay(ReadingConfig {
                     title: "Test Reading".into(),
                     period_ms: 10000,
                     on_period: ActionConfig::Command(CommandAction{run: "echo 'hello reading'".into()})
                 }),
+                ElementConfig::ResultDisplay(ResultDisplayConfig {
+                    title: "Test Reading".into(),
+                    result_of: 1,
+                }),
             ],
             about: AboutConfig {
                 name: "Test name".into(),
                 version: "v0.42.0".into(),
                 description: "Test description".into(),
                 url: Some("https://github.com/NGnius/kaylon".into()),
-                author: Some("NGnius <ngniusness@gmail.com>".into()),
+                authors: vec!["NGnius <ngniusness@gmail.com>".into()],
                 license: Some("MIT".into()),
             },
         };
diff --git a/server/src/config/reading.rs b/backend/src/config/reading.rs
similarity index 100%
rename from server/src/config/reading.rs
rename to backend/src/config/reading.rs
diff --git a/backend/src/config/result_display.rs b/backend/src/config/result_display.rs
new file mode 100644
index 0000000..d2e9146
--- /dev/null
+++ b/backend/src/config/result_display.rs
@@ -0,0 +1,8 @@
+use serde::{Serialize, Deserialize};
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct ResultDisplayConfig {
+    pub title: String,
+    /// index of element who's action's result will be used
+    pub result_of: usize,
+}
diff --git a/server/src/config/slider.rs b/backend/src/config/slider.rs
similarity index 100%
rename from server/src/config/slider.rs
rename to backend/src/config/slider.rs
diff --git a/server/src/config/toggle.rs b/backend/src/config/toggle.rs
similarity index 74%
rename from server/src/config/toggle.rs
rename to backend/src/config/toggle.rs
index 871ae13..ffb57e3 100644
--- a/server/src/config/toggle.rs
+++ b/backend/src/config/toggle.rs
@@ -6,6 +6,5 @@ use super::ActionConfig;
 pub struct ToggleConfig {
     pub title: String,
     pub description: Option<String>,
-    pub on_enable: ActionConfig,
-    pub on_disable: ActionConfig,
+    pub on_toggle: ActionConfig,
 }
diff --git a/backend/src/consts.rs b/backend/src/consts.rs
new file mode 100644
index 0000000..66a88b6
--- /dev/null
+++ b/backend/src/consts.rs
@@ -0,0 +1,6 @@
+pub const PORT: u16 = 25717;
+
+pub const PACKAGE_NAME: &'static str = env!("CARGO_PKG_NAME");
+pub const PACKAGE_VERSION: &'static str = env!("CARGO_PKG_VERSION");
+
+pub const FILEPATH: &'static str = "./bin/kaylon.json";
diff --git a/backend/src/main.rs b/backend/src/main.rs
new file mode 100644
index 0000000..aaf4245
--- /dev/null
+++ b/backend/src/main.rs
@@ -0,0 +1,34 @@
+mod api;
+mod config;
+mod consts;
+mod runtime;
+
+use simplelog::{WriteLogger, LevelFilter};
+
+use usdpl_back::Instance;
+use usdpl_back::core::serdes::Primitive;
+
+fn main() -> Result<(), ()> {
+    let log_filepath = format!("/tmp/{}.log", consts::PACKAGE_NAME);
+    WriteLogger::init(
+        #[cfg(debug_assertions)]{LevelFilter::Debug},
+        #[cfg(not(debug_assertions))]{LevelFilter::Info},
+        Default::default(),
+        std::fs::File::create(&log_filepath).unwrap()
+    ).unwrap();
+
+    let kaylon_conf = config::BaseConfig::load(consts::FILEPATH);
+    let (executor, sender) = runtime::RuntimeExecutor::new(kaylon_conf);
+
+    log::info!("Starting back-end ({} v{})", consts::PACKAGE_NAME, consts::PACKAGE_VERSION);
+    println!("Starting back-end ({} v{})", consts::PACKAGE_NAME, consts::PACKAGE_VERSION);
+    let instance = Instance::new(consts::PORT)
+        .register("hello", |_: Vec<Primitive>| vec![format!("Hello {}", consts::PACKAGE_NAME).into()])
+        .register_blocking("get_about", api::get_about(sender.clone()))
+        .register_async("get_display", api::GetDisplayEndpoint::new(sender.clone()))
+        .register_blocking("get_items", api::get_items(sender.clone()))
+        .register("on_update", api::on_update(sender.clone()))
+        .register_blocking("reload", api::reload(sender.clone()));
+    let _exec_handle = executor.spawn();
+    instance.run_blocking()
+}
diff --git a/backend/src/runtime/actor.rs b/backend/src/runtime/actor.rs
new file mode 100644
index 0000000..52695d8
--- /dev/null
+++ b/backend/src/runtime/actor.rs
@@ -0,0 +1,68 @@
+use usdpl_back::core::serdes::Primitive;
+
+use crate::config::{ElementConfig, ActionConfig};
+
+pub type ActError = String;
+
+pub trait Act: Sized {
+    type Param;
+    type Config: ?Sized;
+    type Return;
+    fn build(config: &Self::Config, parameter: Self::Param) -> Result<Self, ActError>;
+    fn run(self) -> Self::Return;
+}
+
+pub struct Actor {
+    actor_type: ActorType,
+    index: usize,
+}
+
+impl Act for Actor {
+    type Param = (usize, Primitive);
+    type Config = ElementConfig;
+    type Return = Primitive;
+
+    fn build(config: &ElementConfig, parameter: Self::Param) -> Result<Self, ActError> {
+        let a_type = match config {
+            ElementConfig::Button(b) => ActorType::build(&b.on_click, parameter.1),
+            ElementConfig::Toggle(t) => ActorType::build(&t.on_toggle, parameter.1),
+            ElementConfig::Slider(s) => ActorType::build(&s.on_set, parameter.1),
+            ElementConfig::ReadingDisplay(r) => ActorType::build(&r.on_period, parameter.1),
+            ElementConfig::ResultDisplay(_) => Err(format!("Item #{} is a ResultDisplay, which can't act", parameter.0)),
+        }?;
+        Ok(Self {
+            actor_type: a_type,
+            index: parameter.0,
+        })
+    }
+
+    fn run(self) -> Self::Return {
+        log::info!("Running act for item {}", self.index);
+        let result = self.actor_type.run();
+        log::info!("Completed act for item {}", self.index);
+        result
+    }
+}
+
+pub enum ActorType {
+    Command(super::CommandActor),
+}
+
+impl Act for ActorType {
+    type Param = Primitive;
+    type Config = ActionConfig;
+    type Return = Primitive;
+
+    fn build(config: &Self::Config, parameter: Self::Param) -> Result<Self, ActError> {
+        Ok(match config {
+            ActionConfig::Command(c) =>
+                Self::Command(super::CommandActor::build(c, parameter)?),
+        })
+    }
+
+    fn run(self) -> Self::Return {
+        match self {
+            Self::Command(c) => c.run().into(),
+        }
+    }
+}
diff --git a/backend/src/runtime/command_actor.rs b/backend/src/runtime/command_actor.rs
new file mode 100644
index 0000000..a4ec49c
--- /dev/null
+++ b/backend/src/runtime/command_actor.rs
@@ -0,0 +1,61 @@
+use std::process::Command;
+
+use usdpl_back::core::serdes::Primitive;
+
+use crate::config::CommandAction;
+use super::{Act, ActError};
+
+const VALUE_ENV_VAR: &str = "KAYLON_VALUE";
+
+pub struct CommandActor {
+    shell: String,
+    run: String,
+    variable: String,
+}
+
+impl CommandActor {
+    fn primitive_to_string(obj: Primitive) -> String {
+        match obj {
+            Primitive::Empty => String::new(),
+            Primitive::String(s) => s,
+            Primitive::F32(f) => f.to_string(),
+            Primitive::F64(f) => f.to_string(),
+            Primitive::I32(i) => i.to_string(),
+            Primitive::I64(i) => i.to_string(),
+            Primitive::U32(u) => u.to_string(),
+            Primitive::U64(u) => u.to_string(),
+            Primitive::Bool(b) => b.to_string().to_uppercase(),
+            Primitive::Json(j) => j,
+        }
+    }
+}
+
+impl Act for CommandActor {
+    type Param = Primitive;
+    type Config = CommandAction;
+    type Return = String;
+
+    fn build(config: &CommandAction, parameter: Primitive) -> Result<Self, ActError> {
+        Ok(
+            Self {
+                shell: "bash".to_owned(),
+                run: config.run.clone(),
+                variable: Self::primitive_to_string(parameter),
+            }
+        )
+    }
+
+    fn run(self) -> Self::Return {
+        let output = Command::new(&self.shell)
+            .args(["-c", &self.run])
+            .env(VALUE_ENV_VAR, &self.variable)
+            .output()
+            .expect(&format!("Cannot run `{}`", &self.run));
+        if !output.stderr.is_empty() {
+            log::error!("Error running `{}`: {}", &self.run, String::from_utf8(output.stderr).unwrap_or_else(|_| "<non utf-8 stderr output>".to_owned()))
+        }
+        let result = String::from_utf8(output.stdout).expect(&format!("Cannot parse stdout from `{}` as UTF-8", self.run));
+        log::debug!("CommandActor ran `{}` (${}=\"{}\") -> `{}`", &self.run, VALUE_ENV_VAR, &self.variable, &result);
+        result
+    }
+}
diff --git a/backend/src/runtime/communication.rs b/backend/src/runtime/communication.rs
new file mode 100644
index 0000000..5eff8fe
--- /dev/null
+++ b/backend/src/runtime/communication.rs
@@ -0,0 +1,26 @@
+use std::sync::mpsc::Sender;
+
+use usdpl_back::core::serdes::Primitive;
+
+use crate::config::{AboutConfig, ElementConfig};
+
+pub enum QueueAction {
+    GetAbout {
+        respond_to: Sender<AboutConfig>,
+    },
+    DoUpdate {
+        index: usize,
+        value: Primitive,
+    },
+    DoReload {
+        respond_to: Sender<Vec<ElementConfig>>
+    },
+    SetCallback {
+        index: usize,
+        respond_to: Sender<Primitive>,
+    }
+}
+
+pub struct QueueItem {
+    pub action: QueueAction,
+}
diff --git a/backend/src/runtime/executor.rs b/backend/src/runtime/executor.rs
new file mode 100644
index 0000000..33a576f
--- /dev/null
+++ b/backend/src/runtime/executor.rs
@@ -0,0 +1,121 @@
+use std::thread;
+use std::sync::mpsc::{self, Receiver, Sender};
+
+use crate::config::{BaseConfig, ElementConfig};
+use super::{QueueItem, QueueAction, Act};
+use super::{ResultRouter, RouterCommand};
+
+pub struct RuntimeExecutor {
+    config_data: BaseConfig,
+    tasks_receiver: Receiver<QueueItem>
+}
+
+impl RuntimeExecutor {
+    pub fn new(conf: BaseConfig) -> (Self, Sender<QueueItem>) {
+        let (tx, rx) = mpsc::channel();
+        (Self {
+            config_data: conf,
+            tasks_receiver: rx,
+        }, tx)
+    }
+
+    pub fn spawn(self) -> thread::JoinHandle<()> {
+        thread::spawn(move || self.run_loop())
+    }
+
+    fn run_loop(self) {
+        let (mut state, tasks_receiver) = self.split();
+        state.populate_router();
+        for item in tasks_receiver.iter() {
+            state.handle_item(item);
+        }
+    }
+
+    fn split(self) -> (ExecutorState, Receiver<QueueItem>) {
+        (
+            ExecutorState {
+                result_handler: ExecutorState::build_router(self.config_data.items().len()),
+                config_data: self.config_data,
+            },
+            self.tasks_receiver
+        )
+    }
+}
+
+struct ExecutorState {
+    config_data: BaseConfig,
+    result_handler: Sender<RouterCommand>,
+}
+
+impl ExecutorState {
+    fn handle_item(&mut self, item: QueueItem) {
+        match item.action {
+            QueueAction::GetAbout { respond_to } => {
+                respond_to.send(self.config_data.get_about().clone()).unwrap_or(());
+            },
+            QueueAction::DoUpdate { index, value } => {
+                if let Some(item) = self.config_data.get_item(index) {
+                    match super::Actor::build(item, (index, value)) {
+                        Ok(act) => {
+                            let respond_to = self.result_handler.clone();
+                            thread::spawn(move || {
+                                let result = act.run();
+                                match respond_to.send(RouterCommand::HandleResult{index, result}) {
+                                    Ok(_) => {},
+                                    Err(_) => log::warn!("Failed to send DoUpdate response for item #{}", index),
+                                }
+                            });
+                        },
+                        Err(e) => log::error!("Failed to build DoUpdate actor for item #{}: {}", index, e)
+                    }
+                } else {
+                    log::warn!("Received DoUpdate on non-existent item #{} with value `{}`", index, super::primitive_utils::debug(&value))
+                }
+            },
+            QueueAction::DoReload { respond_to } => {
+                self.config_data = BaseConfig::load(crate::consts::FILEPATH);
+                self.populate_router();
+                respond_to.send(self.config_data.items().clone()).unwrap_or(());
+            },
+            QueueAction::SetCallback { index, respond_to } => {
+                if let Some(elem) = self.config_data.get_item(index) {
+                    let display_of = match elem {
+                        ElementConfig::ResultDisplay(c) => c.result_of,
+                        _ => index,
+                    };
+                    if let Err(_) = self.result_handler.send(
+                        RouterCommand::AddSender {
+                            index: display_of,
+                            sender: respond_to,
+                    }) {
+                        log::warn!("Failed to send to ResultRouter, rebuilding router");
+                        self.result_handler = ExecutorState::build_router(self.config_data.items().len());
+                    }
+                }
+            }
+        }
+    }
+
+    fn build_router(items_len: usize) -> Sender<RouterCommand> {
+        let router = ResultRouter::build(&(), items_len).unwrap();
+        let result = router.run();
+        result
+    }
+
+    fn populate_router(&mut self) {
+        if let Err(_) = self.result_handler.send(RouterCommand::Clear{}) {
+            return;
+        }
+        // start reading displays with periodic actions
+        for (index, item) in self.config_data.items().iter().enumerate() {
+            match item {
+                ElementConfig::ReadingDisplay(r) => {
+                    if let Ok(actor) = super::PeriodicActor::build(r, (index, self.result_handler.clone())) {
+                        actor.run();
+                    }
+                },
+                _ => {}
+            }
+        }
+    }
+}
diff --git a/backend/src/runtime/mod.rs b/backend/src/runtime/mod.rs
new file mode 100644
index 0000000..53e89cb
--- /dev/null
+++ b/backend/src/runtime/mod.rs
@@ -0,0 +1,14 @@
+mod actor;
+mod command_actor;
+mod communication;
+mod executor;
+mod periodic_actor;
+mod primitive_utils;
+mod result_router;
+
+pub use actor::{Actor, Act, ActError, ActorType};
+pub use command_actor::CommandActor;
+pub use communication::{QueueItem, QueueAction};
+pub use executor::RuntimeExecutor;
+pub use periodic_actor::PeriodicActor;
+pub use result_router::{ResultRouter, RouterCommand};
diff --git a/backend/src/runtime/periodic_actor.rs b/backend/src/runtime/periodic_actor.rs
new file mode 100644
index 0000000..3109519
--- /dev/null
+++ b/backend/src/runtime/periodic_actor.rs
@@ -0,0 +1,57 @@
+use std::sync::mpsc::Sender;
+use std::time::Duration;
+
+use usdpl_back::core::serdes::Primitive;
+
+use crate::config::ReadingConfig;
+use super::{Act, ActError, ActorType, RouterCommand};
+
+pub struct PeriodicActor {
+    config: ReadingConfig,
+    result_handler: Sender<RouterCommand>,
+    index: usize,
+}
+
+impl Act for PeriodicActor {
+    type Param = (usize, Sender<RouterCommand>);
+    type Config = ReadingConfig;
+    type Return = ();
+
+    fn build(config: &Self::Config, parameter: Self::Param) -> Result<Self, ActError> {
+        ActorType::build(&config.on_period, Primitive::Empty)?;
+        Ok(
+            Self {
+                config: config.clone(),
+                result_handler: parameter.1,
+                index: parameter.0,
+            }
+        )
+    }
+
+    fn run(self) -> Self::Return {
+        std::thread::spawn(move || {
+            let sleep_duration = Duration::from_millis(self.config.period_ms);
+            loop {
+                let actor = match ActorType::build(&self.config.on_period, Primitive::Empty) {
+                    Ok(x) => x,
+                    Err(e) => {
+                        log::error!("PeriodicActor failed to build for item #{}: {}", self.index, e);
+                        break;
+                    }
+                };
+                let result = actor.run();
+                match self.result_handler.send(RouterCommand::HandleResult {
+                    index: self.index, result
+                }) {
+                    Ok(_) => {},
+                    Err(_e) => {
+                        log::warn!("PeriodicActor failed to handle result for item #{}", self.index);
+                        break;
+                    }
+                }
+                std::thread::sleep(sleep_duration);
+            }
+            log::info!("PeriodicActor completed for #{}", self.index);
+        });
+    }
+}
diff --git a/backend/src/runtime/primitive_utils.rs b/backend/src/runtime/primitive_utils.rs
new file mode 100644
index 0000000..715d2a5
--- /dev/null
+++ b/backend/src/runtime/primitive_utils.rs
@@ -0,0 +1,84 @@
+use usdpl_back::core::serdes::Primitive;
+
+//use super::ActError;
+
+/*macro_rules! map_primitive_number_impl {
+    ($type:ty, $type_name:literal, $fn_name:ident) => {
+        pub fn $fn_name (param: Primitive) -> Result<$type, ActError> {
+            match param {
+                Primitive::I64(a) => Ok(a as $type),
+                Primitive::I32(a) => Ok(a as $type),
+                Primitive::U64(a) => Ok(a as $type),
+                Primitive::U32(a) => Ok(a as $type),
+                Primitive::F64(a) => Ok(a as $type),
+                Primitive::F32(a) => Ok(a as $type),
+                _ => Err(format!("Parameter must be {} type", $type_name))
+            }
+        }
+    }
+}*/
+
+/*macro_rules! map_primitive_impl {
+    ($type:ty, $primitive:ident, $type_name:literal, $fn_name:ident) => {
+        pub fn $fn_name (param: Primitive) -> Result<$type, ActError> {
+            match param {
+                Primitive::$primitive(a) => Ok(a),
+                _ => Err(format!("Parameter must be {} type", $type_name))
+            }
+        }
+    }
+}*/
+
+//map_primitive_impl!{bool, Bool, "boolean", try_primitive_bool}
+
+//map_primitive_impl!{String, String, "string", try_primitive_string}
+
+//map_primitive_number_impl!{usize, "uinteger", try_primitive_usize}
+
+#[inline]
+pub fn debug(primitive: &Primitive) -> String {
+    match primitive {
+        Primitive::Empty => "Primitive::Empty".to_owned(),
+        Primitive::String(x) => format!("Primitive::String(`{}`)", x),
+        Primitive::F32(x) => format!("Primitive::F32(`{}`)", x),
+        Primitive::F64(x) => format!("Primitive::F64(`{}`)", x),
+        Primitive::U32(x) => format!("Primitive::U32(`{}`)", x),
+        Primitive::U64(x) => format!("Primitive::U64(`{}`)", x),
+        Primitive::I32(x) => format!("Primitive::I32(`{}`)", x),
+        Primitive::I64(x) => format!("Primitive::I64(`{}`)", x),
+        Primitive::Bool(x) => format!("Primitive::Bool(`{}`)", x),
+        Primitive::Json(x) => format!("Primitive::Json(`{}`)", x),
+    }
+}
+
+/*#[inline]
+pub fn display(primitive: Primitive) -> String {
+    match primitive {
+        Primitive::Empty => "".to_owned(),
+        Primitive::String(x) => x,
+        Primitive::F32(x) => x.to_string(),
+        Primitive::F64(x) => x.to_string(),
+        Primitive::U32(x) => x.to_string(),
+        Primitive::U64(x) => x.to_string(),
+        Primitive::I32(x) => x.to_string(),
+        Primitive::I64(x) => x.to_string(),
+        Primitive::Bool(x) => x.to_string(),
+        Primitive::Json(x) => x,
+    }
+}*/
+
+#[inline]
+pub fn clone(primitive: &Primitive) -> Primitive {
+    match primitive {
+        Primitive::Empty => Primitive::Empty,
+        Primitive::String(x) => Primitive::String(x.clone()),
+        Primitive::F32(x) => Primitive::F32(*x),
+        Primitive::F64(x) => Primitive::F64(*x),
+        Primitive::U32(x) => Primitive::U32(*x),
+        Primitive::U64(x) => Primitive::U64(*x),
+        Primitive::I32(x) => Primitive::I32(*x),
+        Primitive::I64(x) => Primitive::I64(*x),
+        Primitive::Bool(x) => Primitive::Bool(*x),
+        Primitive::Json(x) => Primitive::Json(x.clone()),
+    }
+}
diff --git a/backend/src/runtime/result_router.rs b/backend/src/runtime/result_router.rs
new file mode 100644
index 0000000..8f0ad4f
--- /dev/null
+++ b/backend/src/runtime/result_router.rs
@@ -0,0 +1,133 @@
+use std::sync::mpsc::{self, Receiver, Sender};
+
+use usdpl_back::core::serdes::Primitive;
+
+//use crate::config::ElementConfig;
+use super::{Act, ActError};
+
+const MAX_HANDLERS_PER_ITEM: usize = 8;
+
+pub enum RouterCommand {
+    AddSender {
+        index: usize,
+        sender: Sender<Primitive>,
+    },
+    HandleResult {
+        index: usize,
+        result: Primitive,
+    },
+    Clear{}
+}
+
+pub struct ResultRouter {
+    comm: Receiver<RouterCommand>,
+    senders: Vec<[Option<Sender<Primitive>>; MAX_HANDLERS_PER_ITEM]>,
+    comm_tx: Option<Sender<RouterCommand>>,
+    cache: Vec<Option<Primitive>>,
+}
+
+impl ResultRouter {
+    fn all_senders_none(senders: &[Option<Sender<Primitive>>]) -> bool {
+        let mut all_none = true;
+        for s in senders.iter() {
+            all_none &= s.is_none();
+        }
+        all_none
+    }
+}
+
+impl Act for ResultRouter {
+    type Param = usize;
+    type Config = ();
+    type Return = Sender<RouterCommand>;
+
+    fn build(_config: &Self::Config, parameter: Self::Param) -> Result<Self, ActError> {
+        let (tx, rx) = mpsc::channel();
+        let mut cache_vec = Vec::with_capacity(parameter);
+        for _ in 0..parameter {
+            cache_vec.push(None);
+        }
+        Ok(Self {
+            comm: rx,
+            senders: vec![[(); MAX_HANDLERS_PER_ITEM].map(|_| None); parameter],
+            comm_tx: Some(tx),
+            cache: cache_vec,
+        })
+    }
+
+    fn run(mut self) -> Self::Return {
+        let result = self.comm_tx.take().unwrap();
+        std::thread::spawn(move || {
+            log::debug!("ResultRouter starting");
+            for command in self.comm.iter() {
+                match command {
+                    RouterCommand::AddSender { index, sender } => {
+                        log::debug!("Handling AddSender for item #{}", index);
+                        if let Some(senders) = self.senders.get_mut(index) {
+                            // send cached value, if available
+                            if self.cache[index].is_some() {
+                                log::debug!("Routing cached result for item #{}", index);
+                                let result = self.cache[index].take().unwrap();
+                                match sender.send(result) {
+                                    Ok(_) => {},
+                                    Err(e) => {
+                                        self.cache[index] = Some(e.0);
+                                        log::debug!("ResultRouter ignoring AddSender since sending cached value failed");
+                                        continue;
+                                    },
+                                }
+                            }
+                            // save sender for future results
+                            let mut was_set = false;
+                            'inner_loop: for sender_opt in senders {
+                                if sender_opt.is_none() {
+                                    *sender_opt = Some(sender);
+                                    was_set = true;
+                                    break 'inner_loop;
+                                }
+                            }
+                            if !was_set {
+                                log::warn!("ResultRouter could not add another sender for index {}", index);
+                            }
+                        } else {
+                            log::warn!("ResultRouter got AddSender command for invalid index {} (max: {})", index, self.senders.len());
+                        }
+                    }
+                    RouterCommand::HandleResult {index, result} => {
+                        log::debug!("Handling HandleResult for item #{}", index);
+                        if let Some(senders) = self.senders.get_mut(index) {
+                            if Self::all_senders_none(senders) {
+                                self.cache[index] = Some(result);
+                                log::debug!("Cached result for item #{}", index);
+                            } else {
+                                for (i, sender_opt) in senders.iter_mut().enumerate() {
+                                    if let Some(sender) = sender_opt {
+                                        match sender.send(super::primitive_utils::clone(&result)) {
+                                            Ok(_) => {},
+                                            Err(_) => {
+                                                log::debug!("Removing sender {} because it seems closed", i);
+                                                *sender_opt = None;
+                                            }
+                                        }
+                                    }
+                                }
+                                log::debug!("Routed result for item #{}", index);
+                            }
+                        } else {
+                            log::warn!("ResultRouter got AddSender command for invalid index {} (max: {})", index, self.senders.len());
+                        }
+                    },
+                    RouterCommand::Clear {} => {
+                        log::debug!("Handling Clear");
+                        for i in 0..self.senders.len() {
+                            self.senders[i] = [(); MAX_HANDLERS_PER_ITEM].map(|_| None);
+                            self.cache[i] = None;
+                        }
+                    }
+                }
+            }
+            log::warn!("ResultRouter completed");
+        });
+        result
+    }
+}
diff --git a/kaylon.json b/kaylon.json
new file mode 100644
index 0000000..42a0d6f
--- /dev/null
+++ b/kaylon.json
@@ -0,0 +1,57 @@
+{
+  "api-version": "v0.0.0",
+  "items": [
+    {
+      "element": "button",
+      "title": "Test Button",
+      "on_click": {
+        "action": "command",
+        "run": "echo 'hello button'"
+      }
+    },
+    {
+      "element": "toggle",
+      "title": "Test Toggle",
+      "description": "Toggle description",
+      "on_toggle": {
+        "action": "command",
+        "run": "echo 'hello toggle ${KAYLON_VALUE}'"
+      }
+    },
+    {
+      "element": "slider",
+      "title": "Test Slider",
+      "min": 0,
+      "max": 3,
+      "notches": null,
+      "on_set": {
+        "action": "command",
+        "run": "echo 'hello slider'"
+      }
+    },
+    {
+      "element": "reading",
+      "title": "Test Reading",
+      "period_ms": 10000,
+      "on_period": {
+        "action": "command",
+        "run": "echo 'hello reading'"
+      }
+    },
+    {
+      "element": "result-display",
+      "title": "Test Result",
+      "result_of": 1
+    }
+  ],
+  "about": {
+    "name": "Test name",
+    "version": "v0.42.0",
+    "description": "Test description",
+    "url": "https://github.com/NGnius/kaylon",
+    "authors": [
+      "NGnius <ngniusness@gmail.com>"
+    ],
+    "license": "MIT"
+  }
+}
diff --git a/main.py b/main.py
index e7435f5..6c1ab39 100644
--- a/main.py
+++ b/main.py
@@ -11,6 +11,6 @@ class Plugin:
     # Asyncio-compatible long-running code, executed in a task when the plugin is loaded
     async def _main(self):
         # startup
-        self.backend_proc = subprocess.Popen([PARENT_DIR + "/bin/backend"])
+        #self.backend_proc = subprocess.Popen([PARENT_DIR + "/bin/backend"])
         while True:
-            asyncio.sleep(1)
+            await asyncio.sleep(1)
diff --git a/package.json b/package.json
index 83cb20c..730b5b1 100644
--- a/package.json
+++ b/package.json
@@ -38,7 +38,7 @@
     "typescript": "^4.6.4"
   },
   "dependencies": {
-    "decky-frontend-lib": "^1.0.1",
+    "decky-frontend-lib": "*",
     "react-icons": "^4.3.1",
     "usdpl-front": "file:./src/usdpl_front"
   },
diff --git a/server/build.sh b/server/build.sh
deleted file mode 100755
index d9b898f..0000000
--- a/server/build.sh
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/bin/bash
-
-cargo build --release
-mkdir ../bin
-# TODO replace "backend" \/ with binary name
-cp ./target/release/backend ../bin/backend
diff --git a/server/src/config/about.rs b/server/src/config/about.rs
deleted file mode 100644
index 0144937..0000000
--- a/server/src/config/about.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-use serde::{Serialize, Deserialize};
-
-#[derive(Serialize, Deserialize, Clone)]
-pub struct AboutConfig {
-    pub name: String,
-    pub version: String,
-    pub description: String,
-    pub url: Option<String>,
-    pub author: Option<String>,
-    pub license: Option<String>,
-}
diff --git a/server/src/config/base.rs b/server/src/config/base.rs
deleted file mode 100644
index f2665d1..0000000
--- a/server/src/config/base.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-use serde::{Serialize, Deserialize};
-
-use super::{ElementConfig, AboutConfig};
-
-#[derive(Serialize, Deserialize, Clone)]
-#[serde(tag = "api-version")]
-pub enum BaseConfig {
-    #[serde(rename = "v0.0.0")]
-    V0 {
-        items: Vec<ElementConfig>,
-        about: AboutConfig,
-    },
-}
diff --git a/server/src/main.rs b/server/src/main.rs
deleted file mode 100644
index 747e6f5..0000000
--- a/server/src/main.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-mod config;
-
-use simplelog::{WriteLogger, LevelFilter};
-
-use usdpl_back::Instance;
-use usdpl_back::core::serdes::Primitive;
-
-const PORT: u16 = 54321; // TODO replace with something unique
-
-const PACKAGE_NAME: &'static str = env!("CARGO_PKG_NAME");
-const PACKAGE_VERSION: &'static str = env!("CARGO_PKG_VERSION");
-
-fn main() -> Result<(), ()> {
-    let log_filepath = format!("/tmp/{}.log", PACKAGE_NAME);
-    WriteLogger::init(
-        #[cfg(debug_assertions)]{LevelFilter::Debug},
-        #[cfg(not(debug_assertions))]{LevelFilter::Info},
-        Default::default(),
-        std::fs::File::create(&log_filepath).unwrap()
-    ).unwrap();
-
-    log::info!("Starting back-end ({} v{})", PACKAGE_NAME, PACKAGE_VERSION);
-    println!("Starting back-end ({} v{})", PACKAGE_NAME, PACKAGE_VERSION);
-    Instance::new(PORT)
-        .register("hello", |_: Vec<Primitive>| vec![format!("Hello {}", PACKAGE_NAME).into()])
-        .run_blocking()
-}
diff --git a/src/backend.ts b/src/backend.ts
index c27ec8b..7012d34 100644
--- a/src/backend.ts
+++ b/src/backend.ts
@@ -1,4 +1,4 @@
-import {init_usdpl, target, init_embedded, call_backend} from "usdpl-front";
+import {init_usdpl, target_usdpl, init_embedded, call_backend} from "usdpl-front";
 
 const USDPL_PORT: number = 25717;
 
@@ -20,7 +20,7 @@ export async function initBackend() {
     // init usdpl
     await init_embedded();
     init_usdpl(USDPL_PORT);
-    console.log("USDPL started for framework: " + target());
+    console.log("USDPL started for framework: " + target_usdpl());
     //setReady(true);
 }
 
@@ -29,7 +29,7 @@ export type CAbout = {
     version: string;
     description: string;
     url: string | null;
-    author: string | null;
+    authors: string[];
     license: string | null;
 }
 
@@ -58,18 +58,24 @@ export type CReading = {
     period_ms: number;
 }
 
-export type CElement = CButton | CToggle | CSlider | CReading;
+export type CResultDisplay = {
+    element: string; // "result-display"
+    title: string;
+    result_of: number;
+}
+
+export type CElement = CButton | CToggle | CSlider | CReading | CResultDisplay;
 
 export async function getElements(): Promise<CElement[]> {
-    return await call_backend("get_items", []);
+    return (await call_backend("get_items", []))[0];
 }
 
 export async function onUpdate(index: number, value: any): Promise<any> {
     return (await call_backend("on_update", [index, value]))[0];
 }
 
-export async function getReading(index: number): Promise<string | null> {
-    return (await call_backend("get_reading", [index]))[0];
+export async function getDisplay(index: number): Promise<string | null> {
+    return (await call_backend("get_display", [index]))[0];
 }
 
 export async function getAbout(): Promise<CAbout> {
@@ -77,5 +83,5 @@ export async function getAbout(): Promise<CAbout> {
 }
 
 export async function reload(): Promise<CElement[]> {
-    return await call_backend("reload", []);
+    return (await call_backend("reload", []))[0];
 }
diff --git a/src/index.tsx b/src/index.tsx
index f3a910a..42f3347 100755
--- a/src/index.tsx
+++ b/src/index.tsx
@@ -1,7 +1,7 @@
 import {
   ButtonItem,
   definePlugin,
-  DialogButton,
+  //DialogButton,
   //Menu,
   //MenuItem,
   PanelSection,
@@ -19,72 +19,93 @@ import {
 import { VFC, useState } from "react";
 import { GiWashingMachine } from "react-icons/gi";
 
-import { call_backend } from "usdpl-front";
+import { get_value, set_value } from "usdpl-front";
 import * as backend from "./backend";
 
-// interface AddMethodArgs {
-//   left: number;
-//   right: number;
-// }
-
 const FieldWithSeparator = joinClassNames(gamepadDialogClasses.Field, gamepadDialogClasses.WithBottomSeparatorStandard);
 
+const DISPLAY_KEY = "display";
+const VALUE_KEY = "value";
+
 let items: backend.CElement[] = [];
+let about: backend.CAbout | null = null;
+
+let update = () => {};
+
+function displayCallback(index: number) {
+  return (newVal: any) => {
+    set_value(DISPLAY_KEY + index.toString(), newVal);
+    backend.resolve(backend.getDisplay(index), displayCallback(index));
+    console.log("Got display for " + index.toString(), newVal);
+    update();
+  }
+}
+
+// init USDPL WASM frontend
+// this is required to interface with the backend
+(async () => {
+  await backend.initBackend();
+  let about_promise = backend.getAbout();
+  let elements_promise = backend.getElements();
+  about = await about_promise;
+  console.log("KAYLON: got about", about);
+  let result = await elements_promise;
+  console.log("KAYLON: got elements", result);
+  if (result != null) {
+    items = await backend.getElements();
+    for (let i = 0; i < items.length; i++) {
+      console.log("KAYLON: req display for item #" + i.toString());
+      backend.resolve(backend.getDisplay(i), displayCallback(i));
+    }
+  } else {
+    console.warn("KAYLON: backend connection failed");
+  }
+})();
 
 const Content: VFC<{ serverAPI: ServerAPI }> = ({}) => {
-  // const [result, setResult] = useState<number | undefined>();
-
-  // const onClick = async () => {
-  //   const result = await serverAPI.callPluginMethod<AddMethodArgs, number>(
-  //     "add",
-  //     {
-  //       left: 2,
-  //       right: 2,
-  //     }
-  //   );
-  //   if (result.success) {
-  //     setResult(result.result);
-  //   }
-  // };
 
   const [triggerInternal, updateInternal] = useState<boolean>(false);
 
-  function update() {
+  update = () => {
     updateInternal(!triggerInternal);
   }
 
   function updateIdc(_: any) {
     update();
   }
-  
-  // call hello callback on backend
-  (async () => {
-    let response = await call_backend("hello", []);
-    console.log("Backend says:", response);
-  })();
 
   return (
-    <PanelSection title="Panel Section">
+    <PanelSection>
       {items.map(
         (elem, i) => {
           return <PanelSectionRow>{buildHtmlElement(elem, i, updateIdc)}</PanelSectionRow>
         })
       }
+      { about != null && buildAbout() }
+      <PanelSectionRow>
+        <ButtonItem
+          layout="below"
+          onClick={(_: MouseEvent) => {
+            backend.resolve(backend.reload(),
+              (reload_items: backend.CElement[]) => {
+                items = reload_items;
+                console.log("KAYLON: got elements", reload_items);
+                update();
+              });
+            backend.resolve(backend.getAbout(),
+              (new_about: backend.CAbout) => {
+                about = new_about;
+                console.log("KAYLON: got about", about);
+                update();
+              });
+          }}>
+          Reload
+        </ButtonItem>
+      </PanelSectionRow>
     </PanelSection>
   );
 };
 
-const DeckyPluginRouterTest: VFC = () => {
-  return (
-    <div style={{ marginTop: "50px", color: "white" }}>
-      Hello World!
-      <DialogButton onClick={() => {}}>
-        Go to Store
-      </DialogButton>
-    </div>
-  );
-};
-
 function buildHtmlElement(element: backend.CElement, index: number, updateIdc: any) {
   switch (element.element) {
     case "button":
@@ -95,8 +116,11 @@ function buildHtmlElement(element: backend.CElement, index: number, updateIdc: a
       return buildToggle(element as backend.CToggle, index, updateIdc);
     case "reading":
       return buildReading(element as backend.CReading, index, updateIdc);
+    case "result-display":
+      return buildResultDisplay(element as backend.CResultDisplay, index, updateIdc);
   }
-  return "Unsupported";
+  console.error("KAYLON: Unsupported element", element);
+  return <div>Unsupported</div>;
 }
 
 function buildButton(element: backend.CButton, index: number, updateIdc: any) {
@@ -110,62 +134,175 @@ function buildButton(element: backend.CButton, index: number, updateIdc: any) {
 }
 
 function buildSlider(element: backend.CSlider, index: number, updateIdc: any) {
+  const KEY = VALUE_KEY + index.toString();
+  if (get_value(KEY) == null) {
+    set_value(KEY, element.min);
+  }
   return (
     <SliderField
       label={element.title}
-      value={element.min}
+      value={get_value(KEY)}
       max={element.max}
       min={element.min}
       showValue={true}
       onChange={(value: number) => {
-        backend.resolve(backend.onUpdate(index, value), updateIdc)
+        backend.resolve(backend.onUpdate(index, value), updateIdc);
+        set_value(KEY, value);
       }}
     />
   );
 }
 
 function buildToggle(element: backend.CToggle, index: number, updateIdc: any) {
+  const KEY = VALUE_KEY + index.toString();
+  if (get_value(KEY) == null) {
+    set_value(KEY, false);
+  }
   return (
     <ToggleField
-      checked={false}
+      checked={get_value(KEY)}
       label={element.title}
       description={element.description!}
       onChange={(value: boolean) => {
-        backend.resolve(backend.onUpdate(index, value), updateIdc)
+        backend.resolve(backend.onUpdate(index, value), updateIdc);
+        set_value(KEY, value);
       }}
     />
   );
 }
 
-function buildReading(element: backend.CReading, _index: number, _updateIdc: any) {
+function buildReading(element: backend.CReading, index: number, _updateIdc: any) {
   return (
     <div className={FieldWithSeparator}>
       <div className={gamepadDialogClasses.FieldLabelRow}>
         <div className={gamepadDialogClasses.FieldLabel}>{element.title}</div>
-        <div className={gamepadDialogClasses.FieldChildren}>{"idk"}</div>
+        <div className={gamepadDialogClasses.FieldChildren}>{get_value(DISPLAY_KEY + index.toString())}</div>
       </div>
     </div>
   );
 }
 
-export default definePlugin((serverApi: ServerAPI) => {
-  serverApi.routerHook.addRoute("/decky-plugin-test", DeckyPluginRouterTest, {
-    exact: true,
-  });
-  
-  // init USDPL WASM frontend
-  // this is required to interface with the backend
-  (async () => {
-    await backend.initBackend();
-    items = await backend.getElements();
-  })();
+function buildResultDisplay(element: backend.CResultDisplay, index: number, _updateIdc: any) {
+  return (
+    <div className={FieldWithSeparator}>
+      <div className={gamepadDialogClasses.FieldLabelRow}>
+        <div className={gamepadDialogClasses.FieldLabel}>{element.title}</div>
+        <div className={gamepadDialogClasses.FieldChildren}>{get_value(DISPLAY_KEY + index.toString())}</div>
+      </div>
+    </div>
+  );
+}
 
+function buildAbout() {
+  if (about == null) {
+    return [];
+  } else {
+    let elements = [
+      <div className={staticClasses.PanelSectionTitle}>
+        About
+      </div>,
+      <PanelSectionRow>
+        <div className={FieldWithSeparator}>
+          <div className={gamepadDialogClasses.FieldLabelRow}>
+            <div className={gamepadDialogClasses.FieldLabel}>Name</div>
+            <div className={gamepadDialogClasses.FieldChildren}>{about.name}</div>
+          </div>
+        </div>
+      </PanelSectionRow>,
+      <PanelSectionRow>
+        <div className={FieldWithSeparator}>
+          <div className={gamepadDialogClasses.FieldLabelRow}>
+            <div className={gamepadDialogClasses.FieldLabel}>Version</div>
+            <div className={gamepadDialogClasses.FieldChildren}>{about.version}</div>
+          </div>
+        </div>
+      </PanelSectionRow>,
+      <PanelSectionRow>
+        <div className={FieldWithSeparator}>
+          <div className={gamepadDialogClasses.FieldLabelRow}>
+            <div className={gamepadDialogClasses.FieldLabel}>Description</div>
+            <div className={gamepadDialogClasses.FieldDescription}>{about.description}</div>
+          </div>
+        </div>
+      </PanelSectionRow>
+    ];
+    if (about.url != null) {
+      elements.push(
+        <PanelSectionRow>
+          <div className={FieldWithSeparator}>
+            <div className={gamepadDialogClasses.FieldLabelRow}>
+              <div className={gamepadDialogClasses.FieldLabel}>URL</div>
+              <div className={gamepadDialogClasses.FieldDescription}>{about.url}</div>
+            </div>
+          </div>
+        </PanelSectionRow>
+      );
+    }
+    if (about.authors.length > 1) {
+      let authors = about.authors.map((elem, i) => {
+        if (i == about!.authors.length - 1) {
+          return <p>{elem}</p>;
+        } else {
+          return <span>{elem}</span>;
+        }
+      });
+      elements.push(
+        <PanelSectionRow>
+          <div className={FieldWithSeparator}>
+            <div className={gamepadDialogClasses.FieldLabelRow}>
+              <div className={gamepadDialogClasses.FieldLabel}>Authors</div>
+              <div className={gamepadDialogClasses.FieldDescription}>{authors}</div>
+            </div>
+          </div>
+        </PanelSectionRow>
+      );
+    } else if (about.authors.length == 1) {
+      elements.push(
+        <PanelSectionRow>
+          <div className={FieldWithSeparator}>
+            <div className={gamepadDialogClasses.FieldLabelRow}>
+              <div className={gamepadDialogClasses.FieldLabel}>Author</div>
+              <div className={gamepadDialogClasses.FieldDescription}>{about.authors[0]}</div>
+            </div>
+          </div>
+        </PanelSectionRow>
+      );
+    } else {
+      elements.push(
+        <PanelSectionRow>
+          <div className={FieldWithSeparator}>
+            <div className={gamepadDialogClasses.FieldLabelRow}>
+              <div className={gamepadDialogClasses.FieldLabel}>Author</div>
+              <div className={gamepadDialogClasses.FieldDescription}>NGnius</div>
+            </div>
+          </div>
+        </PanelSectionRow>
+      );
+    }
+
+    if (about.license != null) {
+      elements.push(
+        <PanelSectionRow>
+          <div className={FieldWithSeparator}>
+            <div className={gamepadDialogClasses.FieldLabelRow}>
+              <div className={gamepadDialogClasses.FieldLabel}>License</div>
+              <div className={gamepadDialogClasses.FieldChildren}>{about.license}</div>
+            </div>
+          </div>
+        </PanelSectionRow>
+      );
+    }
+    return elements;
+  }
+}
+
+export default definePlugin((serverApi: ServerAPI) => {
   return {
-    title: <div className={staticClasses.Title}>Example Plugin</div>,
+    title: <div className={staticClasses.Title}>{about == null? "Kaylon": about.name}</div>,
     content: <Content serverAPI={serverApi} />,
     icon: <GiWashingMachine />,
     onDismount() {
-      serverApi.routerHook.removeRoute("/decky-plugin-test");
+      //serverApi.routerHook.removeRoute("/decky-plugin-test");
     },
   };
 });
diff --git a/src/usdpl_front/README.md b/src/usdpl_front/README.md
new file mode 100644
index 0000000..fd771f8
--- /dev/null
+++ b/src/usdpl_front/README.md
@@ -0,0 +1,9 @@
+[![Crates.io](https://img.shields.io/crates/v/usdpl-front?style=flat-square)](https://crates.io/crates/usdpl-front)
+
+# usdpl-front-front
+
+Front-end library to be called from Javascript.
+Targets WASM.
+
+In true Javascript tradition, this part of the library does not support error handling.
+
diff --git a/src/usdpl_front/package.json b/src/usdpl_front/package.json
index bd572fc..fd8c535 100644
--- a/src/usdpl_front/package.json
+++ b/src/usdpl_front/package.json
@@ -4,7 +4,7 @@
     "NGnius (Graham) <ngniusness@gmail.com>"
   ],
   "description": "Universal Steam Deck Plugin Library front-end designed for WASM",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "license": "GPL-3.0-only",
   "repository": {
     "type": "git",
diff --git a/src/usdpl_front/usdpl_front.d.ts b/src/usdpl_front/usdpl_front.d.ts
index 5ca612b..b986bed 100644
--- a/src/usdpl_front/usdpl_front.d.ts
+++ b/src/usdpl_front/usdpl_front.d.ts
@@ -9,7 +9,25 @@ export function init_usdpl(port: number): void;
 * Get the targeted plugin framework, or "any" if unknown
 * @returns {string}
 */
-export function target(): string;
+export function target_usdpl(): string;
+/**
+* Get the UDSPL front-end version
+* @returns {string}
+*/
+export function version_usdpl(): string;
+/**
+* Get the targeted plugin framework, or "any" if unknown
+* @param {string} key
+* @param {any} value
+* @returns {any}
+*/
+export function set_value(key: string, value: any): any;
+/**
+* Get the targeted plugin framework, or "any" if unknown
+* @param {string} key
+* @returns {any}
+*/
+export function get_value(key: string): any;
 /**
 * Call a function on the back-end.
 * Returns null (None) if this fails for any reason.
@@ -24,7 +42,10 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
   readonly init_usdpl: (a: number) => void;
-  readonly target: (a: number) => void;
+  readonly target_usdpl: (a: number) => void;
+  readonly version_usdpl: (a: number) => void;
+  readonly set_value: (a: number, b: number, c: number) => number;
+  readonly get_value: (a: number, b: number) => number;
   readonly call_backend: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_export_0: (a: number) => number;
   readonly __wbindgen_export_1: (a: number, b: number, c: number) => number;
diff --git a/src/usdpl_front/usdpl_front.js b/src/usdpl_front/usdpl_front.js
index 0610e88..3cd2e54 100644
--- a/src/usdpl_front/usdpl_front.js
+++ b/src/usdpl_front/usdpl_front.js
@@ -21,6 +21,15 @@ function takeObject(idx) {
     return ret;
 }
 
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
 let WASM_VECTOR_LEN = 0;
 
 let cachedUint8Memory0;
@@ -104,15 +113,6 @@ function getStringFromWasm0(ptr, len) {
     return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
 }
 
-function addHeapObject(obj) {
-    if (heap_next === heap.length) heap.push(heap.length + 1);
-    const idx = heap_next;
-    heap_next = heap[idx];
-
-    heap[idx] = obj;
-    return idx;
-}
-
 let cachedFloat64Memory0;
 function getFloat64Memory0() {
     if (cachedFloat64Memory0.byteLength === 0) {
@@ -121,6 +121,71 @@ function getFloat64Memory0() {
     return cachedFloat64Memory0;
 }
 
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
 function makeMutClosure(arg0, arg1, dtor, f) {
     const state = { a: arg0, b: arg1, cnt: 1, dtor };
     const real = (...args) => {
@@ -145,7 +210,7 @@ function makeMutClosure(arg0, arg1, dtor, f) {
 
     return real;
 }
-function __wbg_adapter_26(arg0, arg1, arg2) {
+function __wbg_adapter_28(arg0, arg1, arg2) {
     wasm.__wbindgen_export_3(arg0, arg1, addHeapObject(arg2));
 }
 
@@ -161,10 +226,10 @@ export function init_usdpl(port) {
 * Get the targeted plugin framework, or "any" if unknown
 * @returns {string}
 */
-export function target() {
+export function target_usdpl() {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.target(retptr);
+        wasm.target_usdpl(retptr);
         var r0 = getInt32Memory0()[retptr / 4 + 0];
         var r1 = getInt32Memory0()[retptr / 4 + 1];
         return getStringFromWasm0(r0, r1);
@@ -174,6 +239,48 @@ export function target() {
     }
 }
 
+/**
+* Get the UDSPL front-end version
+* @returns {string}
+*/
+export function version_usdpl() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.version_usdpl(retptr);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export_4(r0, r1);
+    }
+}
+
+/**
+* Get the targeted plugin framework, or "any" if unknown
+* @param {string} key
+* @param {any} value
+* @returns {any}
+*/
+export function set_value(key, value) {
+    const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.set_value(ptr0, len0, addHeapObject(value));
+    return takeObject(ret);
+}
+
+/**
+* Get the targeted plugin framework, or "any" if unknown
+* @param {string} key
+* @returns {any}
+*/
+export function get_value(key) {
+    const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.get_value(ptr0, len0);
+    return takeObject(ret);
+}
+
 let cachedUint32Memory0;
 function getUint32Memory0() {
     if (cachedUint32Memory0.byteLength === 0) {
@@ -214,7 +321,7 @@ function handleError(f, args) {
         wasm.__wbindgen_export_5(addHeapObject(e));
     }
 }
-function __wbg_adapter_54(arg0, arg1, arg2, arg3) {
+function __wbg_adapter_69(arg0, arg1, arg2, arg3) {
     wasm.__wbindgen_export_6(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
@@ -255,6 +362,16 @@ function getImports() {
     imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
         takeObject(arg0);
     };
+    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
+        const ret = getObject(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_log_191da5bcf5c562e5 = function(arg0, arg1) {
+        console.log(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg_error_2ef4335ee3b7ff61 = function(arg0, arg1) {
+        console.error(getStringFromWasm0(arg0, arg1));
+    };
     imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
         const obj = getObject(arg1);
         const ret = typeof(obj) === 'string' ? obj : undefined;
@@ -290,6 +407,24 @@ function getImports() {
         const ret = getObject(arg0) === undefined;
         return ret;
     };
+    imports.wbg.__wbg_new_693216e109162396 = function() {
+        const ret = new Error();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_stack_0ddaca5d1abfb52f = function(arg0, arg1) {
+        const ret = getObject(arg1).stack;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_error_09919627ac0992f5 = function(arg0, arg1) {
+        try {
+            console.error(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_export_4(arg0, arg1);
+        }
+    };
     imports.wbg.__wbg_instanceof_Window_a2a08d3918d7d4d0 = function(arg0) {
         const ret = getObject(arg0) instanceof Window;
         return ret;
@@ -317,10 +452,6 @@ function getImports() {
         const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
-        const ret = getObject(arg0);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbindgen_cb_drop = function(arg0) {
         const obj = takeObject(arg0).original;
         if (obj.cnt-- == 1) {
@@ -380,7 +511,7 @@ function getImports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_54(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_69(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -415,11 +546,18 @@ function getImports() {
         const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
         return ret;
     }, arguments) };
+    imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
+        const ret = debugString(getObject(arg1));
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
     imports.wbg.__wbindgen_throw = function(arg0, arg1) {
         throw new Error(getStringFromWasm0(arg0, arg1));
     };
-    imports.wbg.__wbindgen_closure_wrapper631 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 71, __wbg_adapter_26);
+    imports.wbg.__wbindgen_closure_wrapper365 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 78, __wbg_adapter_28);
         return addHeapObject(ret);
     };
 
@@ -475,7 +613,7 @@ export default init;
 
 
 // USDPL customization
-const encoded = "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";
+const encoded = "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";
 
 function asciiToBinary(str) {
   if (typeof atob === 'function') {
diff --git a/src/usdpl_front/usdpl_front_bg.wasm b/src/usdpl_front/usdpl_front_bg.wasm
index 8c70a8b..b7ceffe 100644
Binary files a/src/usdpl_front/usdpl_front_bg.wasm and b/src/usdpl_front/usdpl_front_bg.wasm differ
diff --git a/src/usdpl_front/usdpl_front_bg.wasm.d.ts b/src/usdpl_front/usdpl_front_bg.wasm.d.ts
index 357dc02..1e96bc2 100644
--- a/src/usdpl_front/usdpl_front_bg.wasm.d.ts
+++ b/src/usdpl_front/usdpl_front_bg.wasm.d.ts
@@ -2,7 +2,10 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export function init_usdpl(a: number): void;
-export function target(a: number): void;
+export function target_usdpl(a: number): void;
+export function version_usdpl(a: number): void;
+export function set_value(a: number, b: number, c: number): number;
+export function get_value(a: number, b: number): number;
 export function call_backend(a: number, b: number, c: number, d: number): number;
 export function __wbindgen_export_0(a: number): number;
 export function __wbindgen_export_1(a: number, b: number, c: number): number;