diff --git a/.gitignore b/.gitignore
index 6db330e..082663a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,7 @@
 /target
 Cargo.lock
 .idea
+.vscode
 build
 backup
 otls/backup
@@ -9,6 +10,8 @@ bindgen/hapi-bindgen/bindings.rs
 env.ps1
 **/*target
 _build
+_tmp
+cpp
 *.hip*
 .cargo
-_*
\ No newline at end of file
+_*
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 9fbe60f..b9286af 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -2,9 +2,10 @@
     "cSpell.enabled": false,
     "python.languageServer": "Pylance",
     "python.analysis.extraPaths": [
-        "C:/Houdini/19.0.455/houdini/python3.7libs"
+        "C:/Houdini/20.5.445/houdini/python3.11libs"
     ],
     "rust-analyzer.linkedProjects": [
         ".\\apps\\viewport\\Cargo.toml"
     ],
+    "rust-analyzer.showUnlinkedFileNotification": false,
 }
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0727404..5092829 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,13 +1,30 @@
 # hapi-rs changelog
 
+## [0.11.0]
+
+- Update to Houdini 20.5.445
+- (new in 20.5) Add APIs for setting/getting of unique attribute values
+- (new in 20.5) Add initial support for async attribute access (new in 20.5). WIP and not working properly yet.
+- (new in 20.5) Add new shared-memory HARS server type
+- (new in 20.5) Add HAPI_GetMessageNodeIds and HAPI_GetNodeCookResult APIs
+- (new in 20.5) Add performance monitor APIs
+- Fixed some issue with PDG blocking cooking
+- `quick_session` now uses shared-memory server type instead of named-pipe.
+- An experimental Bevy example app.
+- Bunch os other small improvements and cleanups
+- Mark `Attribute: Send` (by @BerKai97)
+
+**Some public API have been changed (both on the SideFX and this library side)**
+
 ## [0.10.0]
+
 - **Minimal** Houdini version bumped to 20.0.625.
 - Support new attribute APIs and add some previously missing APIs.
 - **Serveral (minimal) public APIs changed**.
 - Other fixes and cleanup
 
-
 ## [0.9.3]
+
 - Bump Houdini version to `19.5.716`.
 - Add API for working with parameter tags.
 - String parameters of type Node can take `NodeHandle` values.
@@ -15,14 +32,18 @@
 - Expose cache APIs.
 
 ## [0.9.2]
+
 ### New
+
 - Add `NumericAttribute::read_into()` method for reusing a buffer when reading attribute data.
 - Reintroduced an internal reentrant mutex to make sure 2 or more API calls are atomic.
 - Add a demo of OpenGL viewer
 - Update dependencies
 
 ## [0.9.1]
+
 ### Changed:
+
 - Remove internal Mutex from `Session`.
 - Slightly improved `Parameter` APIs.
 - Use `StringHandle` instead of `i32`.
@@ -30,7 +51,9 @@
 - Minor cleanups and improvements across the crate.
 
 ## [0.9.0]
+
 ### New
+
 - New builder pattern for creating nodes.
 - New `start_houdini_server` function will launch Houdini application
   with engine server running in it. See _live_session.rs_ example.
@@ -43,8 +66,8 @@
 - New `Parameter::save_parm_file` to save the file from the parameter to disk.
 - Can now delete geometry attributes.
 
-
 ### Changed
+
 - Simplified `Session::create_node` only take node name now. Use builder pattern for
   more options.
 - `connect_to_pipe` now take an optional timeout parameter, and will try to connect multiple times
@@ -55,10 +78,10 @@
 - Add support for creating nodes for more asset types with less boilerplate code.
 - Fixed setting of array geometry attributes.
 
-
-
 ## [0.8.0]
+
 ### Changed
+
 - AssetLibrary::try_create_first() can now crate nodes other than of Object type.
 - Functions taking optional parent (`Option<NodeHandle>`) are now generic and can take `HoudiniNode` too.
 - Improve the error type handling and printing.
@@ -66,24 +89,30 @@
 - Add lots of `debug_assert!` for input validation.
 
 ### New
+
 - `ManagerType` enum represents a network root node.
 - Add several missing geometry APIs.
 
 ## [0.7.0]
+
 ## Changed
+
 - Reworked parameter APIs
-  - Separate `get/set` and `get_array/set_array` methods
-  - `get/set` now take an index of a parameter tuple.
-  - Eliminate extra String clone for `set_*` string parameters.
+    - Separate `get/set` and `get_array/set_array` methods
+    - `get/set` now take an index of a parameter tuple.
+    - Eliminate extra String clone for `set_*` string parameters.
 
 ## [0.6.0]
+
 ### New
+
 - Switch to HAPI-5.0 (Houdini 19.5) API.
 - Implement most common PDG APIs for event-based (async) cooking.
 - Builder pattern for `SessionOption`
 - Example of event-based cooking of PDG network.
 
 ### Changed
+
 - Make `DataArray` types public.
 - Session creation APIs now require `SessionOptions` argument.
 - Add new metadata to `Session` handle with extra information about connection.
diff --git a/Cargo.toml b/Cargo.toml
index dbef431..8839db2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,28 +6,26 @@ repository = "https://github.com/alexxbb/hapi-rs/"
 keywords = ["vfx", "graphics", "gamedev", "houdini"]
 categories = ["graphics", "game-development"]
 readme = "README.md"
-version = "0.10.0"
+version = "0.11.0"
 authors = ["Aleksei Rusev <hou.alexx@gmail.com>"]
 edition = "2021"
 license = "MIT"
-exclude = [
-    "otls/*",
-]
+include = ["/src", "build.rs", "LICENSE"]
 
 [dependencies]
-log = "0.4.14"
-paste = "1.0.6"
-parking_lot = "0.12.1"
-duplicate = { version = "1.0.0", features = [], default-features = false }
+log = "0.4.22"
+paste = "1.0.15"
+parking_lot = "0.12.3"
+duplicate = { version = "2.0.0", features = [], default-features = false }
 debug-ignore = "1.0.5"
-tempfile = "3.3.0"
+tempfile = "3.13.0"
 
 [dev-dependencies]
-once_cell = "1.5.2"
-env_logger = "0.10.0"
+once_cell = "1.20.2"
+env_logger = "0.11.5"
 prettytable-rs = "0.10.0"
-fastrand = "1.6.0"
-anyhow = "1.0.66"
-argh = "0.1.9"
-ctrlc = "3.2.5"
+fastrand = "2.1.1"
+anyhow = "1.0.91"
+argh = "0.1.12"
+ctrlc = "3.4.5"
 tinyjson = "2.5.1"
diff --git a/LICENSE b/LICENSE
index 923ec44..abb3eba 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) [2022] [Aleksei Rusev]
+Copyright (c) [2024] [Aleksei Rusev]
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/apps/bevy/Cargo.toml b/apps/bevy/Cargo.toml
new file mode 100644
index 0000000..729f5c5
--- /dev/null
+++ b/apps/bevy/Cargo.toml
@@ -0,0 +1,33 @@
+[package]
+name = "hapi-bevy"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+hapi-rs = { path = "../..", version = "*" }
+bevy_panorbit_camera = "0.21.2"
+
+
+[features]
+dev = ["bevy/dynamic_linking"]
+
+
+[dependencies.bevy]
+version = "0.15.0"
+default-features = false
+features = [
+    "bevy_window",
+    "bevy_winit",
+    "bevy_pbr",
+    "bevy_ui",
+    "default_font",
+    "tonemapping_luts",
+    "ktx2",
+    "png",
+    "bevy_state",
+    "bevy_dev_tools",
+    "multi_threaded"
+]
+
+[profile.dev.package."*"]
+opt-level = 3
\ No newline at end of file
diff --git a/apps/bevy/README.md b/apps/bevy/README.md
new file mode 100644
index 0000000..7d4dd47
--- /dev/null
+++ b/apps/bevy/README.md
@@ -0,0 +1,3 @@
+# A simple experimental Bevy app which can load HDA geometry and render it.
+
+`cargo run --release`
\ No newline at end of file
diff --git a/apps/bevy/assets/environment_maps/pisa_diffuse_rgb9e5_zstd.ktx2 b/apps/bevy/assets/environment_maps/pisa_diffuse_rgb9e5_zstd.ktx2
new file mode 100644
index 0000000..e260df2
Binary files /dev/null and b/apps/bevy/assets/environment_maps/pisa_diffuse_rgb9e5_zstd.ktx2 differ
diff --git a/apps/bevy/assets/environment_maps/pisa_specular_rgb9e5_zstd.ktx2 b/apps/bevy/assets/environment_maps/pisa_specular_rgb9e5_zstd.ktx2
new file mode 100644
index 0000000..2018838
Binary files /dev/null and b/apps/bevy/assets/environment_maps/pisa_specular_rgb9e5_zstd.ktx2 differ
diff --git a/apps/bevy/assets/hda/geo.hda b/apps/bevy/assets/hda/geo.hda
new file mode 100644
index 0000000..d97ab95
Binary files /dev/null and b/apps/bevy/assets/hda/geo.hda differ
diff --git a/apps/bevy/src/houdini_mesh.rs b/apps/bevy/src/houdini_mesh.rs
new file mode 100644
index 0000000..03eaca8
--- /dev/null
+++ b/apps/bevy/src/houdini_mesh.rs
@@ -0,0 +1,388 @@
+use bevy::asset::RenderAssetUsages;
+use bevy::prelude::Mesh;
+use bevy::render::mesh::PrimitiveTopology;
+use hapi_rs::attribute::NumericAttr;
+use hapi_rs::geometry::{extra::GeometryExtension, AttributeName, AttributeOwner, Geometry};
+use hapi_rs::Result;
+
+pub enum NormalAttribute {
+    Point(Vec<f32>),
+    Vertex(Vec<f32>),
+}
+
+pub enum ColorAttribute {
+    Point(Vec<f32>),
+    Vertex(Vec<f32>),
+}
+
+pub struct HoudiniMeshData {
+    pub vertex_list: Vec<i32>,
+    pub face_counts: Vec<i32>,
+    pub positions: Option<Vec<f32>>,
+    pub normals: Option<NormalAttribute>,
+    pub colors: Option<ColorAttribute>,
+    pub uvs: Option<Vec<f32>>,
+}
+
+fn get_houdini_geometry_color(geometry: &Geometry) -> Result<Option<ColorAttribute>> {
+    let part = geometry.part_info(0)?.expect("part 0");
+    let mut is_point_attr = false;
+    let mut cd_attr = geometry.get_color_attribute(&part, AttributeOwner::Vertex)?;
+    if cd_attr.is_none() {
+        is_point_attr = true;
+        cd_attr = geometry.get_color_attribute(&part, AttributeOwner::Point)?;
+    }
+    match cd_attr {
+        Some(cd_attr) => {
+            let values = cd_attr.get(0)?;
+            Ok(Some(match is_point_attr {
+                true => ColorAttribute::Point(values),
+                false => ColorAttribute::Vertex(values),
+            }))
+        }
+        None => Ok(None),
+    }
+}
+
+fn get_houdini_geometry_normals(geometry: &Geometry) -> Result<Option<NormalAttribute>> {
+    let part = geometry.part_info(0)?.expect("part 0");
+    let mut is_point_attr = false;
+    let mut n_attr = geometry.get_normal_attribute(&part, AttributeOwner::Vertex)?;
+    if n_attr.is_none() {
+        is_point_attr = true;
+        n_attr = geometry.get_normal_attribute(&part, AttributeOwner::Point)?;
+    }
+    match n_attr {
+        Some(n_attr) => {
+            let values = n_attr.get(0)?;
+            Ok(Some(match is_point_attr {
+                true => NormalAttribute::Point(values),
+                false => NormalAttribute::Vertex(values),
+            }))
+        }
+        None => Ok(None),
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct HoudiniGeometryDataBuilder {
+    positions: bool,
+    normals: bool,
+    colors: bool,
+    uv: bool,
+}
+
+impl HoudiniGeometryDataBuilder {
+    pub fn new() -> Self {
+        Self::default()
+    }
+    pub fn with_positions(mut self) -> HoudiniGeometryDataBuilder {
+        self.positions = true;
+        self
+    }
+
+    pub fn with_normals(mut self) -> HoudiniGeometryDataBuilder {
+        self.normals = true;
+        self
+    }
+
+    pub fn with_uv(mut self) -> HoudiniGeometryDataBuilder {
+        self.uv = true;
+        self
+    }
+
+    pub fn with_color(mut self) -> HoudiniGeometryDataBuilder {
+        self.colors = true;
+        self
+    }
+    pub fn build(self, geometry: &Geometry) -> Result<HoudiniMeshData> {
+        get_houdini_geometry_data_arrays(
+            geometry,
+            self.positions,
+            self.normals,
+            self.colors,
+            self.uv,
+        )
+    }
+}
+
+fn get_houdini_geometry_data_arrays(
+    geometry: &Geometry,
+    build_positions: bool,
+    build_normals: bool,
+    build_colors: bool,
+    build_uv: bool,
+) -> Result<HoudiniMeshData> {
+    let part = geometry.part_info(0)?.unwrap();
+    let vertex_list = geometry.vertex_list(&part)?;
+    let face_counts = geometry.get_face_counts(&part)?;
+    let mut positions = None;
+    let mut normals = None;
+    let mut colors = None;
+    let mut uvs = None;
+    if build_positions {
+        positions = Some(
+            geometry
+                .get_position_attribute(part.part_id())?
+                .get(part.part_id())?,
+        )
+    }
+    if build_normals {
+        normals = get_houdini_geometry_normals(geometry)?;
+    }
+
+    if build_colors {
+        colors = get_houdini_geometry_color(geometry)?;
+    }
+
+    if build_uv {
+        uvs = match geometry.get_attribute(
+            part.part_id(),
+            AttributeOwner::Vertex,
+            AttributeName::Uv,
+        )? {
+            None => None,
+            Some(attr) => Some(
+                attr.downcast::<NumericAttr<f32>>()
+                    .expect("UV is NumericAttribute")
+                    .get(part.part_id())?,
+            ),
+        };
+    }
+
+    Ok(HoudiniMeshData {
+        vertex_list,
+        face_counts,
+        positions,
+        normals,
+        colors,
+        uvs,
+    })
+}
+
+pub fn vertex_deform(geometry: &Geometry) -> Result<BevyMeshData> {
+    let mesh_data = HoudiniGeometryDataBuilder::new()
+        .with_positions()
+        .with_normals()
+        .build(&geometry)?;
+
+    Ok(convert_vertex_data(mesh_data))
+}
+
+struct Offset {
+    global_vertex_offset: (usize, usize, usize),
+    triangle_vertex_offset: (usize, usize, usize),
+}
+
+fn iterate_buffer_offsets(vertex_list: &[i32], face_counts: &[i32], mut func: impl FnMut(Offset)) {
+    let mut offset = 0usize;
+
+    for vertex_per_face in face_counts {
+        let vertex_per_face = *vertex_per_face as usize;
+        let num_tris = vertex_per_face - 2;
+
+        for tr in 0..num_tris {
+            let off0 = offset + tr + 2;
+            let off1 = offset + tr + 1;
+            let off2 = offset + 0;
+
+            let point_0_index = vertex_list[off0] as usize;
+            let point_1_index = vertex_list[off1] as usize;
+            let point_2_index = vertex_list[off2] as usize;
+            let offset = Offset {
+                global_vertex_offset: (off0, off1, off2),
+                triangle_vertex_offset: (point_0_index, point_1_index, point_2_index),
+            };
+            func(offset);
+        }
+        offset += vertex_per_face;
+    }
+}
+
+pub struct BevyMeshData {
+    pub vertices: Option<Vec<[f32; 3]>>,
+    pub normals: Option<Vec<[f32; 3]>>,
+    pub colors: Option<Vec<[f32; 4]>>,
+    pub uvs: Option<Vec<[f32; 2]>>,
+}
+
+pub fn convert_vertex_data(data: HoudiniMeshData) -> BevyMeshData {
+    let HoudiniMeshData {
+        vertex_list,
+        face_counts,
+        positions,
+        normals,
+        colors,
+        uvs,
+    } = data;
+
+    let num_vertices = face_counts.iter().sum::<i32>() as usize;
+    let mut out_vertices = positions
+        .is_some()
+        .then(|| Vec::with_capacity(num_vertices));
+    let mut out_normals = normals.is_some().then(|| Vec::with_capacity(num_vertices));
+    let mut out_colors = colors.is_some().then(|| Vec::with_capacity(num_vertices));
+    let mut out_uvs = uvs.is_some().then(|| Vec::with_capacity(num_vertices));
+
+    iterate_buffer_offsets(&vertex_list, &face_counts, |offset| {
+        let Offset {
+            global_vertex_offset,
+            triangle_vertex_offset,
+            ..
+        } = offset;
+
+        if let (Some(positions), Some(out_vertices)) = (&positions, &mut out_vertices) {
+            out_vertices.push([
+                positions[triangle_vertex_offset.0 * 3 + 0],
+                positions[triangle_vertex_offset.0 * 3 + 1],
+                positions[triangle_vertex_offset.0 * 3 + 2],
+            ]);
+            out_vertices.push([
+                positions[triangle_vertex_offset.1 * 3 + 0],
+                positions[triangle_vertex_offset.1 * 3 + 1],
+                positions[triangle_vertex_offset.1 * 3 + 2],
+            ]);
+            out_vertices.push([
+                positions[triangle_vertex_offset.2 * 3 + 0],
+                positions[triangle_vertex_offset.2 * 3 + 1],
+                positions[triangle_vertex_offset.2 * 3 + 2],
+            ]);
+        }
+
+        if let (Some(normals_attr), Some(out_normals)) = (&normals, &mut out_normals) {
+            let (data, idx_0, idx_1, idx_2) = match normals_attr {
+                NormalAttribute::Point(data) => (
+                    data,
+                    triangle_vertex_offset.0,
+                    triangle_vertex_offset.1,
+                    triangle_vertex_offset.2,
+                ),
+                NormalAttribute::Vertex(data) => (
+                    data,
+                    global_vertex_offset.0,
+                    global_vertex_offset.1,
+                    global_vertex_offset.2,
+                ),
+            };
+            out_normals.push([
+                data[idx_0 * 3 + 0],
+                data[idx_0 * 3 + 1],
+                data[idx_0 * 3 + 2],
+            ]);
+
+            out_normals.push([
+                data[idx_1 * 3 + 0],
+                data[idx_1 * 3 + 1],
+                data[idx_1 * 3 + 2],
+            ]);
+
+            out_normals.push([
+                data[idx_2 * 3 + 0],
+                data[idx_2 * 3 + 1],
+                data[idx_2 * 3 + 2],
+            ]);
+        }
+
+        if let (Some(colors_attr), Some(out_colors)) = (&colors, &mut out_colors) {
+            let (data, idx_0, idx_1, idx_2) = match colors_attr {
+                ColorAttribute::Point(data) => (
+                    data,
+                    triangle_vertex_offset.0,
+                    triangle_vertex_offset.1,
+                    triangle_vertex_offset.2,
+                ),
+                ColorAttribute::Vertex(data) => (
+                    data,
+                    global_vertex_offset.0,
+                    global_vertex_offset.1,
+                    global_vertex_offset.2,
+                ),
+            };
+
+            out_colors.push([
+                data[idx_0 * 3 + 0],
+                data[idx_0 * 3 + 1],
+                data[idx_0 * 3 + 2],
+                0.,
+            ]);
+
+            out_colors.push([
+                data[idx_1 * 3 + 0],
+                data[idx_1 * 3 + 1],
+                data[idx_1 * 3 + 2],
+                0.,
+            ]);
+
+            out_colors.push([
+                data[idx_2 * 3 + 0],
+                data[idx_2 * 3 + 1],
+                data[idx_2 * 3 + 2],
+                0.,
+            ]);
+        }
+
+        if let (Some(uvs), Some(out_uvs)) = (&uvs, &mut out_uvs) {
+            out_uvs.extend([
+                [
+                    uvs[global_vertex_offset.0 * 3 + 0],
+                    1.0 - uvs[global_vertex_offset.0 * 3 + 1],
+                ],
+                [
+                    uvs[global_vertex_offset.1 * 3 + 0],
+                    1.0 - uvs[global_vertex_offset.1 * 3 + 1],
+                ],
+                [
+                    uvs[global_vertex_offset.2 * 3 + 0],
+                    1.0 - uvs[global_vertex_offset.2 * 3 + 1],
+                ],
+            ]);
+        }
+    });
+
+    BevyMeshData {
+        vertices: out_vertices,
+        normals: out_normals,
+        colors: out_colors,
+        uvs: out_uvs,
+    }
+}
+
+pub fn create_bevy_mesh_from_houdini(geometry: &Geometry) -> Result<Mesh> {
+    let mesh_data = HoudiniGeometryDataBuilder::new()
+        .with_positions()
+        .with_normals()
+        .with_color()
+        .with_uv()
+        .build(&geometry)?;
+
+    let bevy_mesh = convert_vertex_data(mesh_data);
+
+    let mut mesh = Mesh::new(
+        PrimitiveTopology::TriangleList,
+        RenderAssetUsages::default(),
+    );
+
+    if let Some(position) = bevy_mesh.vertices {
+        mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, position);
+    }
+    if let Some(colors) = bevy_mesh.colors {
+        mesh.insert_attribute(Mesh::ATTRIBUTE_COLOR, colors);
+    }
+
+    if let Some(uv) = bevy_mesh.uvs {
+        mesh.insert_attribute(Mesh::ATTRIBUTE_UV_0, uv);
+    }
+
+    if let Some(normals) = bevy_mesh.normals {
+        mesh.insert_attribute(Mesh::ATTRIBUTE_NORMAL, normals);
+        if mesh.generate_tangents().is_err() {
+            eprintln!("Could not compute mesh tangents");
+        }
+    } else {
+        // smooth normals can only be computed for an indexed mesh
+        println!("Computing flat normals");
+        mesh.compute_flat_normals();
+    }
+
+    Ok(mesh)
+}
diff --git a/apps/bevy/src/main.rs b/apps/bevy/src/main.rs
new file mode 100644
index 0000000..4aa69c2
--- /dev/null
+++ b/apps/bevy/src/main.rs
@@ -0,0 +1,254 @@
+mod houdini_mesh;
+mod material;
+
+use bevy::dev_tools::fps_overlay::{FpsOverlayConfig, FpsOverlayPlugin};
+use bevy::prelude::*;
+use bevy::render::mesh::VertexAttributeValues;
+use bevy::tasks::{block_on, futures_lite::future};
+use bevy::tasks::{AsyncComputeTaskPool, Task};
+use bevy::text::FontSmoothing;
+use bevy_panorbit_camera::{PanOrbitCamera, PanOrbitCameraPlugin};
+use hapi_rs::geometry::Geometry;
+use hapi_rs::node::HoudiniNode;
+use hapi_rs::parameter::Parameter;
+#[allow(unused_imports)]
+use hapi_rs::session::connect_to_memory_server;
+use hapi_rs::session::{new_in_process, SessionOptions};
+use hapi_rs::Result as HapiResult;
+
+#[derive(Resource)]
+struct HoudiniResource {
+    asset: HoudiniNode,
+    geometry: Geometry,
+}
+
+#[derive(Component)]
+struct HoudiniMesh {
+    animated: bool,
+}
+
+#[derive(Default, Debug, Hash, Eq, PartialEq, Clone, States)]
+enum HoudiniSetupState {
+    #[default]
+    Loading,
+    Ready,
+}
+
+fn main() {
+    App::new()
+        .add_plugins((
+            DefaultPlugins.set(WindowPlugin {
+                primary_window: Some(Window {
+                    title: "HAPI Demo".to_string(),
+                    ..default()
+                }),
+                ..default()
+            }),
+            PanOrbitCameraPlugin,
+            FpsOverlayPlugin {
+                config: FpsOverlayConfig {
+                    text_config: TextFont {
+                        // Here we define size of our overlay
+                        font_size: 16.0,
+                        // If we want, we can use a custom font
+                        font: default(),
+                        // We could also disable font smoothing,
+                        font_smoothing: FontSmoothing::default(),
+                    },
+                    enabled: true,
+                    ..default()
+                },
+            },
+        ))
+        .init_state::<HoudiniSetupState>()
+        .add_systems(Startup, setup_scene)
+        .add_systems(Startup, setup_houdini)
+        .add_systems(
+            Update,
+            get_loading_state.run_if(in_state(HoudiniSetupState::Loading)),
+        )
+        .add_systems(OnEnter(HoudiniSetupState::Ready), houdini_ready)
+        .add_systems(
+            Update,
+            (input_handler, animate).run_if(in_state(HoudiniSetupState::Ready)),
+        )
+        .run();
+}
+
+fn houdini_ready(
+    mut commands: Commands,
+    text: Single<Entity, With<LoadingText>>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut textures: ResMut<Assets<Image>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    res: Res<HoudiniResource>,
+) {
+    commands.entity(text.into_inner()).despawn_recursive();
+
+    let HoudiniResource { asset, geometry } = res.into_inner();
+
+    let tex_maps = material::extract_texture_maps(asset, false).expect("texture maps");
+    let mesh = houdini_mesh::create_bevy_mesh_from_houdini(geometry).expect("Bevy mesh");
+    let mesh_handle = meshes.add(mesh);
+
+    commands.spawn((
+        HoudiniMesh { animated: true },
+        Mesh3d(mesh_handle),
+        MeshMaterial3d(materials.add(StandardMaterial {
+            base_color_texture: tex_maps.color.map(|image| textures.add(image)),
+            metallic_roughness_texture: tex_maps.specular.map(|image| textures.add(image)),
+            normal_map_texture: tex_maps.normal.map(|image| textures.add(image)),
+            reflectance: 0.5,
+            perceptual_roughness: 1.0,
+            ..default()
+        })),
+    ));
+}
+
+#[derive(Debug, Component)]
+pub struct LoadingText;
+
+fn setup_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
+    commands.spawn((
+        LoadingText,
+        Text::new("Initializing Houdini...".to_string()),
+        TextFont {
+            font_size: 50.0,
+            ..Default::default()
+        },
+        Node {
+            align_content: AlignContent::Center,
+            align_self: AlignSelf::Center,
+            ..default()
+        },
+    ));
+    commands.spawn((
+        PanOrbitCamera {
+            focus: Vec3::new(0.0, 1.0, 0.0),
+            orbit_smoothness: 0.6,
+            orbit_sensitivity: 1.8,
+            button_pan: MouseButton::Middle,
+            ..default()
+        },
+        Transform::from_xyz(3.0, 1.0, 0.0).looking_at(Vec3::ZERO, Vec3::Y),
+        EnvironmentMapLight {
+            diffuse_map: asset_server.load("environment_maps/pisa_diffuse_rgb9e5_zstd.ktx2"),
+            specular_map: asset_server.load("environment_maps/pisa_specular_rgb9e5_zstd.ktx2"),
+            intensity: 1800.0,
+            ..default()
+        },
+    ));
+
+    commands.spawn((
+        DirectionalLight {
+            illuminance: 2_500.,
+            ..default()
+        },
+        Transform::from_xyz(50.0, 50.0, 50.0),
+    ));
+}
+
+fn animate(
+    query: Query<(&Mesh3d, &HoudiniMesh)>,
+    session: Res<HoudiniResource>,
+    time: Res<Time>,
+    mut meshes: ResMut<Assets<Mesh>>,
+) {
+    let (mesh3d, houdini_mesh) = query.single();
+    let HoudiniResource { asset, geometry } = session.as_ref();
+    if houdini_mesh.animated {
+        let mesh = meshes.get_mut(&mesh3d.0).expect("Houdini mesh");
+        if let Parameter::Float(parm) = asset.parameter("time").expect("mod parameter") {
+            parm.set(0, time.elapsed_secs()).unwrap();
+        }
+        update_mesh(mesh, &geometry);
+    }
+}
+
+fn update_mesh(mesh: &mut Mesh, geometry: &Geometry) {
+    geometry.node.cook().unwrap();
+    let attr = mesh.attribute_mut(Mesh::ATTRIBUTE_POSITION).expect("P");
+    let houdini_mesh::BevyMeshData {
+        vertices, normals, ..
+    } = houdini_mesh::vertex_deform(&geometry).unwrap();
+    {
+        let VertexAttributeValues::Float32x3(p_values) = attr else {
+            panic!("P is not Float32x3");
+        };
+        let _ = std::mem::replace(p_values, vertices.unwrap());
+    }
+    {
+        let attr = mesh.attribute_mut(Mesh::ATTRIBUTE_NORMAL).expect("N");
+        let VertexAttributeValues::Float32x3(n_values) = attr else {
+            panic!("N is not Float32x3");
+        };
+        let _ = std::mem::replace(n_values, normals.unwrap());
+    }
+}
+
+fn input_handler(
+    keyboard_input: Res<ButtonInput<KeyCode>>,
+    mut query: Single<&mut HoudiniMesh>,
+    mut exit: EventWriter<AppExit>,
+    res: Res<HoudiniResource>,
+) {
+    if keyboard_input.just_pressed(KeyCode::Space) {
+        query.animated ^= true;
+    }
+    if keyboard_input.pressed(KeyCode::Escape) {
+        exit.send(AppExit::Success);
+        res.asset.clone().delete().unwrap()
+    }
+}
+
+fn init_houdini_resource() -> HapiResult<HoudiniResource> {
+    let options = SessionOptions::builder().threaded(false).build();
+    let session = if cfg!(debug_assertions) {
+        connect_to_memory_server("hapi", Some(&options), None)?
+    } else {
+        new_in_process(Some(&options))?
+    };
+    let otl = std::path::absolute(std::env::current_dir()?.join("assets/hda/geo.hda"))?;
+    let lib = session.load_asset_file(otl)?;
+    let asset = lib.try_create_first()?;
+    let geometry = asset.geometry()?.expect("geometry");
+    asset.cook()?;
+    Ok(HoudiniResource { asset, geometry })
+}
+
+#[derive(Resource)]
+struct HoudiniStartupTask(Task<HapiResult<HoudiniResource>>);
+
+fn get_loading_state(
+    mut task: ResMut<HoudiniStartupTask>,
+    text: Single<Entity, With<LoadingText>>,
+    mut next_state: ResMut<NextState<HoudiniSetupState>>,
+    mut commands: Commands,
+) {
+    if let Some(resource) = block_on(future::poll_once(&mut task.0)) {
+        match resource {
+            Ok(resource) => {
+                next_state.set(HoudiniSetupState::Ready);
+                commands.insert_resource(resource);
+            }
+            Err(e) => {
+                commands.spawn((
+                    Text::new(format!("Failed to initialize Houdini:\n\n{:?}", e)),
+                    Node {
+                        align_content: AlignContent::Center,
+                        align_self: AlignSelf::Center,
+                        ..default()
+                    },
+                ));
+
+                commands.entity(text.into_inner()).despawn_recursive();
+            }
+        }
+        commands.remove_resource::<HoudiniStartupTask>();
+    }
+}
+fn setup_houdini(mut commands: Commands) {
+    let task = AsyncComputeTaskPool::get()
+        .spawn::<HapiResult<HoudiniResource>>(async move { init_houdini_resource() });
+    commands.insert_resource(HoudiniStartupTask(task))
+}
diff --git a/apps/bevy/src/material.rs b/apps/bevy/src/material.rs
new file mode 100644
index 0000000..79d05d7
--- /dev/null
+++ b/apps/bevy/src/material.rs
@@ -0,0 +1,82 @@
+use bevy::asset::RenderAssetUsages;
+use bevy::image::{CompressedImageFormats, Image, ImageFormat, ImageSampler, ImageType};
+use hapi_rs::node::{HoudiniNode, Parameter};
+use hapi_rs::parameter::ParmBaseTrait;
+use hapi_rs::Result;
+
+struct MaterialNodeParameters {
+    color: Parameter,
+    normal: Parameter,
+    specular: Parameter,
+}
+
+fn find_material_nodes(asset: &HoudiniNode) -> Result<MaterialNodeParameters> {
+    let session = &asset.session;
+    let Parameter::String(color_parm) = asset.parameter("color_map")? else {
+        return Err("color_map parm not found".into());
+    };
+
+    let Parameter::String(normal_parm) = asset.parameter("normal_map")? else {
+        return Err("normal_map parm not found".into());
+    };
+
+    let Parameter::String(specular_parm) = asset.parameter("specular_map")? else {
+        return Err("specular_map parm not found".into());
+    };
+
+    let mat_node_color_parm = session
+        .find_parameter_from_path(color_parm.get(0)?, asset)?
+        .unwrap();
+
+    let mat_node_normal_parm = session
+        .find_parameter_from_path(normal_parm.get(0)?, asset)?
+        .unwrap();
+
+    let mat_node_specular_parm = session
+        .find_parameter_from_path(specular_parm.get(0)?, asset)?
+        .unwrap();
+
+    Ok(MaterialNodeParameters {
+        color: mat_node_color_parm,
+        normal: mat_node_normal_parm,
+        specular: mat_node_specular_parm,
+    })
+}
+
+fn render_material_texture(parameter: &Parameter) -> Result<Image> {
+    let session = parameter.session();
+    let node = parameter.node();
+
+    session.render_texture_to_image(node, &parameter.name()?)?;
+
+    let image_info = session.get_image_info(node)?;
+    let (width, height) = (image_info.x_res() as usize, image_info.y_res() as usize);
+    let mut pixels = Vec::with_capacity(width * height);
+    session.extract_image_to_memory(node, &mut pixels, "C", "PNG")?;
+
+    let image = Image::from_buffer(
+        &pixels,
+        ImageType::Format(ImageFormat::Png),
+        CompressedImageFormats::all(),
+        true,
+        ImageSampler::default(),
+        RenderAssetUsages::default(),
+    )
+    .expect("Could not create Image");
+    Ok(image)
+}
+
+pub struct TextureMaps {
+    pub color: Option<Image>,
+    pub normal: Option<Image>,
+    pub specular: Option<Image>,
+}
+
+pub fn extract_texture_maps(asset: &HoudiniNode, normals: bool) -> Result<TextureMaps> {
+    let mat_parms = find_material_nodes(asset)?;
+    Ok(TextureMaps {
+        color: Some(render_material_texture(&mat_parms.color)?),
+        normal: normals.then(|| render_material_texture(&mat_parms.normal).unwrap()), // Houdini normals maps are not compatible with Bevy's default shader
+        specular: Some(render_material_texture(&mat_parms.specular)?),
+    })
+}
diff --git a/apps/viewport/env.ps1 b/apps/viewport/env.ps1
deleted file mode 100644
index 5a6ae1c..0000000
--- a/apps/viewport/env.ps1
+++ /dev/null
@@ -1,2 +0,0 @@
-$env:HFS = "C:\Houdini\19.5.462";
-$env:PATH += ";${env:HFS}\bin"
diff --git a/apps/viewport/env_19.0.ps1 b/apps/viewport/env_19.0.ps1
deleted file mode 100644
index 3f85a1e..0000000
--- a/apps/viewport/env_19.0.ps1
+++ /dev/null
@@ -1,2 +0,0 @@
-$env:HFS = "C:\Houdini\19.0.455";
-$env:PATH = "${env:HFS}\bin:${env:PATH}"
diff --git a/apps/viewport/src/setup.rs b/apps/viewport/src/setup.rs
index 10b882e..085fb05 100644
--- a/apps/viewport/src/setup.rs
+++ b/apps/viewport/src/setup.rs
@@ -101,7 +101,8 @@ impl Texture {
     pub fn extract(gl: &glow::Context, geo: &Geometry) -> Result<Option<Self>> {
         use glow::HasContext as _;
 
-        let Some(materials) = geo.get_materials(None)? else {
+        let part = geo.part_info(0)?.unwrap();
+        let Some(materials) = geo.get_materials(&part)? else {
             eprintln!("No texture!");
             return Ok(None);
         };
@@ -308,8 +309,8 @@ impl MeshData {
         let _part = geo.part_info(0)?.expect("Geometry to have partition");
         let _part_id = _part.part_id();
         let positions = geo.get_position_attribute(_part_id)?.get(_part_id)?;
-        let face_counts = geo.get_face_counts(Some(&_part))?;
-        let vertex_list = geo.vertex_list(Some(&_part))?;
+        let face_counts = geo.get_face_counts(&_part)?;
+        let vertex_list = geo.vertex_list(&_part)?;
         let uvs = {
             match geo.get_attribute(_part_id, AttributeOwner::Vertex, "uv")? {
                 Some(uv_attr) => Some(
diff --git a/benchmarks/shared-memory/Cargo.toml b/benchmarks/shared-memory/Cargo.toml
new file mode 100644
index 0000000..5b70688
--- /dev/null
+++ b/benchmarks/shared-memory/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "shared-memory"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+
+hapi-rs = { path = "../.." }
+nanorand = "0.7.0"
diff --git a/benchmarks/shared-memory/benchmark.hda b/benchmarks/shared-memory/benchmark.hda
new file mode 100644
index 0000000..e8f3a87
Binary files /dev/null and b/benchmarks/shared-memory/benchmark.hda differ
diff --git a/benchmarks/shared-memory/src/main.rs b/benchmarks/shared-memory/src/main.rs
new file mode 100644
index 0000000..7121cc1
--- /dev/null
+++ b/benchmarks/shared-memory/src/main.rs
@@ -0,0 +1,127 @@
+#![allow(dead_code)]
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![allow(unused)]
+
+use hapi_rs::asset::AssetLibrary;
+use hapi_rs::attribute::{AsAttribute, NumericAttr, StorageType, StringAttr};
+use hapi_rs::enums::AttributeOwner;
+use hapi_rs::geometry::extra::GeometryExtension;
+use hapi_rs::geometry::AttributeInfo;
+use hapi_rs::node::Geometry;
+use hapi_rs::parameter::{FloatParameter, Parameter};
+use hapi_rs::raw::ThriftSharedMemoryBufferType;
+use hapi_rs::session::{
+    connect_to_memory_server, connect_to_pipe, start_engine_pipe_server,
+    start_shared_memory_server, SessionOptions, ThriftServerOptions,
+};
+use hapi_rs::Result;
+use nanorand::{Rng, WyRand};
+use std::ffi::CStr;
+use std::time::Duration;
+
+use std::sync::{LazyLock, Mutex};
+
+static RNG: LazyLock<Mutex<WyRand>> = LazyLock::new(|| Mutex::new(WyRand::new()));
+
+fn random_string<const SIZE: usize>() -> String {
+    let mut rng = RNG.lock().unwrap();
+    let next = || rng.generate_range(98..122) as u8 as char;
+    std::iter::repeat_with(next).take(SIZE).collect()
+}
+
+const N_RUN: usize = 10;
+
+fn copy_geo(source: &Geometry, input_geo: &Geometry) -> Result<()> {
+    let part = source.part_info(0)?.unwrap();
+    input_geo.set_part_info(&part)?;
+    let position_attr = source.get_position_attribute(part.part_id())?;
+    let positions_data = position_attr.get(0)?;
+    let vertex_list = source.vertex_list(None)?;
+    let face_counts = source.get_face_counts(None)?;
+    input_geo.set_vertex_list(0, &vertex_list)?;
+    input_geo.set_face_counts(0, &face_counts)?;
+
+    let payload_attr = source
+        .get_attribute(part.part_id(), AttributeOwner::Point, "payload")?
+        .expect("Geometry to have payload string attribute");
+
+    let payload_attr = payload_attr
+        .downcast::<StringAttr>()
+        .expect("payload is string type");
+    let payload_data = payload_attr.get(part.part_id())?;
+
+    let payload_c_strings: Vec<&CStr> = payload_data.iter_cstr().collect();
+
+    let color_data = source
+        .get_point_color_attribute(&part)?
+        .expect("Cd attribute")
+        .get(part.part_id())?;
+    input_geo
+        .create_position_attribute(&part)?
+        .set(part.part_id(), &positions_data)?;
+    input_geo
+        .create_point_color_attribute(&part)?
+        .set(part.part_id(), &color_data)?;
+    let dest_payload_attr =
+        input_geo.add_string_attribute("payload", part.part_id(), payload_attr.info().clone())?;
+    dest_payload_attr.set_cstr(part.part_id(), payload_c_strings.iter().cloned())?;
+    input_geo.commit()?;
+
+    Ok(())
+}
+
+fn main() -> Result<()> {
+    let mut args = std::env::args();
+    let server_options = ThriftServerOptions::default().with_shared_memory_buffer_size(200);
+    let session_options = SessionOptions::builder().threaded(false).build();
+    let conn_name = "hapi-bench";
+    let server_type = args.nth(1).expect("server type");
+    let num_runs: usize = match args.next() {
+        None => N_RUN,
+        Some(v) => v.parse().expect("Second argument must be a number"),
+    };
+    println!("Starting \"{server_type}\" server");
+    let session = match server_type.as_str() {
+        "pipe" => {
+            let pid = start_engine_pipe_server(conn_name, None, &server_options)?;
+            connect_to_pipe(conn_name, Some(&session_options), None, Some(pid))?
+        }
+        "memory" => {
+            let pid = start_shared_memory_server(conn_name, &server_options, None)?;
+            connect_to_memory_server(conn_name, Some(&session_options), Some(pid))?
+        }
+        _ => panic!("Server type must be pipe or memory"),
+    };
+    println!("Session created.");
+    let lib = AssetLibrary::from_file(
+        session.clone(),
+        "C:/Github/hapi-rs/benchmarks/shared-memory/benchmark.hda",
+    )?;
+
+    let asset_node = lib.try_create_first()?;
+    println!("Test asset ready.");
+    println!("Running {num_runs} times");
+    let start = std::time::Instant::now();
+    let Ok(Parameter::Float(rotate_parm)) = asset_node.parameter("rotate") else {
+        panic!("Missing rotate parameter");
+    };
+
+    let Ok(Parameter::String(input_str)) = asset_node.parameter("string") else {
+        panic!("Missing string parameter");
+    };
+    for n in 0..num_runs {
+        rotate_parm.set(0, (n * 10) as f32);
+        input_str.set(0, random_string::<10>())?;
+        asset_node.cook()?;
+        let geometry = asset_node.geometry()?.expect("geometry");
+        let input = session.create_input_node(&format!("copy_{n}"), None)?;
+        copy_geo(&geometry, &input)?
+    }
+    println!(
+        "Server type \"{server_type}\" done in {} milliseconds",
+        start.elapsed().as_millis()
+    );
+    // session.save_hip("c:/Temp/junk/bench.hip", true)?;
+    Ok(())
+}
diff --git a/bindgen/coverage/src/main.rs b/bindgen/coverage/src/main.rs
index 2c006c5..493b613 100644
--- a/bindgen/coverage/src/main.rs
+++ b/bindgen/coverage/src/main.rs
@@ -22,7 +22,10 @@ fn raw_hapi_function_names() -> HashSet<Item> {
         "HAPI_BindCustomImplementation",
         "HAPI_GetImageFilePath",
         "HAPI_GetHandleBindingInfo",
-        "HAPI_GetWorkitemResultInfo"
+        "HAPI_GetWorkitemResultInfo",
+        "HAPI_ParmInfo_GetIntValueCount",
+        "HAPI_ParmInfo_GetFloatValueCount",
+        "HAPI_ParmInfo_GetStringValueCount",
     ];
     let raw = Path::new("../../src/ffi/bindings.rs");
     let text = std::fs::read_to_string(&raw).expect("bindings.rs");
@@ -79,9 +82,12 @@ fn wrapped_rs_function_names() -> HashSet<Item> {
 fn main() {
     let raw = raw_hapi_function_names();
     let rs = wrapped_rs_function_names();
+    let mut num_missed: i32 = 0;
     for r in raw.iter() {
         if !rs.contains(r) {
             println!("Missing {r:?}");
+            num_missed += 1;
         }
     }
+    println!("Missed {} functions", num_missed);
 }
diff --git a/bindgen/hapi-bindgen/src/main.rs b/bindgen/hapi-bindgen/src/main.rs
index bdb2320..61ceea0 100644
--- a/bindgen/hapi-bindgen/src/main.rs
+++ b/bindgen/hapi-bindgen/src/main.rs
@@ -70,10 +70,12 @@ static ENUMS: Lazy<HashMap<&str, (&str, i32)>> = Lazy::new(|| {
     map.insert("HAPI_PDG_State", ("PdgState", -1));
     map.insert("HAPI_CacheProperty", ("auto", -2));
     map.insert("HAPI_EnvIntType", ("auto", -2));
-    map.insert("HAPI_PrmScriptType", ("auto", -2));
+    map.insert("HAPI_PrmScriptType", ("auto", -1));
     map.insert("HAPI_Permissions", ("auto", -2));
     map.insert("HAPI_ParmType", ("auto", 2));
-
+    map.insert("HAPI_JobStatus", ("auto", -1));
+    map.insert("HAPI_TCP_PortType", ("TcpPortType", -1));
+    map.insert("HAPI_ThriftSharedMemoryBufferType", ("auto", -1));
     map.insert("HAPI_PartType", ("auto", -1));
     map.insert("HAPI_StatusVerbosity", ("auto", -1));
     map.insert("HAPI_SessionType", ("auto", -1));
@@ -111,18 +113,17 @@ struct Rustifier {
     visited: RefCell<HashMap<String, Vec<String>>>,
 }
 
-impl ParseCallbacks for Rustifier {
-    fn enum_variant_name(
-        &self,
+impl Rustifier {
+    fn parse_enum_variant(&self, 
         _enum_name: Option<&str>,
         _variant_name: &str,
-        _variant_value: EnumVariantValue,
-    ) -> Option<String> {
+        _variant_value: EnumVariantValue) -> Result<Option<String>, String> {
+        
         if _enum_name.is_none() {
-            return None;
+            return Ok(None);
         };
         let name = _enum_name
-            .unwrap()
+            .ok_or("empty _enum_name".to_string())?
             .strip_prefix("enum ")
             .expect("Not enum?");
         self.visited
@@ -130,21 +131,42 @@ impl ParseCallbacks for Rustifier {
             .entry(name.to_string())
             .and_modify(|variants| variants.push(_variant_name.to_string()))
             .or_default();
-        let (_, _mode) = ENUMS.get(name).expect(&format!("Missing enum: {}", name));
+        let (_, _mode) = ENUMS.get(name).ok_or_else(|| format!("Missing enum: {}", name))?;
         let mode = StripMode::new(*_mode);
         let mut striped = mode.strip_long_name(_variant_name);
-        // Two stripped variant names can collide with each other. We take a dumb approach by
+        // Two stripped variant names can collide with each other. We take a naive approach by
         // attempting to strip one more time with increased step
         if let Some(vars) = self.visited.borrow_mut().get_mut(name) {
             let _stripped = striped.to_string();
             if vars.contains(&_stripped) {
+                println!("enum {name}::{_variant_name} stripped down to \"{striped}\" is not unique. \
+                Incrementing step by 1");
                 let mode = StripMode::new(*_mode - 1);
                 striped = mode.strip_long_name(_variant_name);
+                println!("-> new name is {striped}");
             } else {
                 vars.push(_stripped);
             }
         }
-        Some(heck::AsUpperCamelCase(striped).to_string())
+        Ok(Some(heck::AsUpperCamelCase(striped).to_string()))
+
+        }
+}
+
+impl ParseCallbacks for Rustifier {
+    fn enum_variant_name(
+        &self,
+        _enum_name: Option<&str>,
+        _variant_name: &str,
+        _variant_value: EnumVariantValue,
+    ) -> Option<String> {
+        match self.parse_enum_variant(_enum_name, _variant_name, _variant_value) {
+            Err(e) => {
+                eprintln!("Error parsing enum variant: {e}");
+                std::process::exit(1);
+            }
+            Ok(v) => v
+        }
     }
 
     fn item_name(&self, _item_name: &str) -> Option<String> {
diff --git a/env.ps1 b/env.ps1
index d865766..bbdf727 100644
--- a/env.ps1
+++ b/env.ps1
@@ -1,3 +1,4 @@
 #$env:HFS = "C:\Houdini\19.5.805";
-$env:HFS = "C:\Houdini\20.0.636";
+#$env:HFS = "C:\Houdini\20.0.636";
+$env:HFS = "C:\Houdini\20.5.445";
 $env:PATH += ";${env:HFS}\bin"
diff --git a/examples/connecting_assets.rs b/examples/connecting_assets.rs
index 5f47a1f..9a02fa4 100644
--- a/examples/connecting_assets.rs
+++ b/examples/connecting_assets.rs
@@ -4,7 +4,7 @@ use hapi_rs::Result;
 
 fn main() -> Result<()> {
     let session = quick_session(None)?;
-    let geom = session.create_input_node("Cube")?;
+    let geom = session.create_input_node("Cube", None)?;
     geom.node.cook_blocking()?;
     let part_info = PartInfo::default()
         .with_part_type(PartType::Mesh)
diff --git a/examples/cook_pdg.rs b/examples/cook_pdg.rs
index ec532b3..de01413 100644
--- a/examples/cook_pdg.rs
+++ b/examples/cook_pdg.rs
@@ -13,7 +13,7 @@ fn cook_async(node: &TopNode) -> Result<()> {
     let mut num_tasks = 0;
     let mut tasks_done = 0;
     println!("Cooking PDG...");
-    node.cook_async(false, |step| {
+    node.cook_async(true, |step| {
         match step.event.event_type() {
             PdgEventType::EventWorkitemAdd => num_tasks += 1,
             PdgEventType::EventWorkitemRemove => num_tasks -= 1,
@@ -24,7 +24,7 @@ fn cook_async(node: &TopNode) -> Result<()> {
                     for wir in results {
                         // We only interested in geo files;;
                         if wir.tag().unwrap() == "file/geo" {
-                            let file = wir.result().unwrap();
+                            let file = wir.path().unwrap();
                             println!("Completed {file}");
                         }
                         tasks_done += 1;
@@ -71,14 +71,18 @@ fn main() -> Result<()> {
     std::env::set_current_dir(&out_dir).unwrap();
     let options = SessionOptionsBuilder::default()
         .threaded(true)
-        .env_variables([
-            ("PDG_DIR", out_dir.to_string_lossy()),
-            ("JOB", out_dir.to_string_lossy()),
-        ])
+        .env_variables(
+            [
+                ("PDG_DIR", out_dir.to_string_lossy()),
+                ("JOB", out_dir.to_string_lossy()),
+            ]
+            .iter(),
+        )
         .build();
     let session = new_in_process(Some(&options))?;
     let lib = session.load_asset_file(otl)?;
     let asset = lib.try_create_first()?;
+    asset.cook_blocking()?;
     session.save_hip(out_dir.join("cook_pdg_example.hip"), true)?;
     let top_net = asset.find_top_networks()?[0].clone();
     let top_node = top_net.to_top_node().expect("TOP node");
diff --git a/examples/create_pdg_network.rs b/examples/create_pdg_network.rs
index 2b06bd9..bc5abb7 100644
--- a/examples/create_pdg_network.rs
+++ b/examples/create_pdg_network.rs
@@ -31,7 +31,7 @@ fn main() -> anyhow::Result<()> {
     let workitem = generator.create_workitem("test_1", 0, None)?;
     workitem.set_int_data("my_int_data", &[1, 2, 3])?;
     generator.commit_workitems()?;
-    generator.cook_pdg_blocking()?;
+    generator.cook_pdg_blocking(false)?;
     let script_node = session
         .node_builder("pythonscript")
         .with_parent(topnet)
@@ -45,7 +45,7 @@ fn main() -> anyhow::Result<()> {
     script_node.connect_input(0, generator, 0)?;
     script_node.set_display_flag(true)?;
     let script_node = script_node.to_top_node().unwrap();
-    script_node.cook_pdg_blocking()?;
+    script_node.cook_pdg_blocking(false)?;
     let workitems = script_node.get_all_workitems()?;
     let data = workitems[0].get_int_data("my_int_data")?;
     assert_eq!(data, vec![1, 4, 27]);
diff --git a/examples/curve_marshall.rs b/examples/curve_marshall.rs
index 89ea5e4..9413ebd 100644
--- a/examples/curve_marshall.rs
+++ b/examples/curve_marshall.rs
@@ -3,7 +3,7 @@ use hapi_rs::{attribute::*, geometry::*, session::*, Result};
 
 fn main() -> Result<()> {
     let session = quick_session(None)?;
-    let geom = session.create_input_node("Curve")?;
+    let geom = session.create_input_node("Curve", None)?;
     geom.node.cook_blocking()?;
     let part_info = PartInfo::default()
         .with_part_type(PartType::Curve)
diff --git a/examples/curve_output.rs b/examples/curve_output.rs
index 455bc61..00c7047 100644
--- a/examples/curve_output.rs
+++ b/examples/curve_output.rs
@@ -1,5 +1,7 @@
 use hapi_rs::attribute::*;
-use hapi_rs::geometry::{AttributeOwner, CurveOrders, CurveType, Geometry, PartInfo, PartType};
+use hapi_rs::geometry::{
+    AttributeName, AttributeOwner, CurveOrders, CurveType, Geometry, PartInfo, PartType,
+};
 use hapi_rs::node::{NodeFlags, NodeType, ObjectInfo};
 use hapi_rs::session::{quick_session, SessionOptions};
 use hapi_rs::Result;
@@ -68,7 +70,7 @@ fn print_curve_info(geo: &Geometry, obj: &ObjectInfo, part: &PartInfo) -> Result
             continue;
         }
         let attrib = geo
-            .get_attribute(part_id, AttributeOwner::Point, "P")?
+            .get_attribute(part_id, AttributeOwner::Point, AttributeName::P)?
             .unwrap();
         let attrib = attrib.downcast::<NumericAttr<f32>>().unwrap();
         let positions = attrib.get(part_id)?;
diff --git a/examples/groups.rs b/examples/groups.rs
index cf29402..1644afb 100644
--- a/examples/groups.rs
+++ b/examples/groups.rs
@@ -9,7 +9,7 @@ use hapi_rs::session::{quick_session, Session};
 use hapi_rs::Result;
 
 fn create_cube(session: &Session) -> Result<HoudiniNode> {
-    let geometry = session.create_input_node("Cube")?;
+    let geometry = session.create_input_node("Cube", None)?;
     geometry.node.cook()?;
 
     let part_info = PartInfo::default()
@@ -84,7 +84,7 @@ fn main() -> Result<()> {
     let num_points = part.element_count_by_group(GroupType::Point);
     println!("{} points in pointGroup", num_points);
 
-    let membership = geo.get_group_membership(Some(&part), GroupType::Point, "pointGroup")?;
+    let membership = geo.get_group_membership(&part, GroupType::Point, "pointGroup")?;
 
     for (pt, member) in membership.into_iter().enumerate() {
         if member > 0 {
diff --git a/examples/live_session.rs b/examples/live_session.rs
index 06087ef..8bd0a55 100644
--- a/examples/live_session.rs
+++ b/examples/live_session.rs
@@ -68,7 +68,7 @@ fn main() -> Result<()> {
     let curve_info = InputCurveInfo::default()
         .with_curve_type(CurveType::Nurbs)
         .with_order(3);
-    let geo = session.create_input_curve_node("curvy")?;
+    let geo = session.create_input_curve_node("curvy", None)?;
     geo.set_input_curve_info(0, &curve_info)?;
     let running = Arc::new(AtomicBool::new(true));
     let flag = running.clone();
diff --git a/examples/materials.rs b/examples/materials.rs
index 2e58c7d..3a5ae0b 100644
--- a/examples/materials.rs
+++ b/examples/materials.rs
@@ -10,7 +10,8 @@ fn main() -> Result<()> {
     let node = lib.try_create_first()?;
     node.cook()?;
     let geo = node.geometry()?.unwrap();
-    let material = match geo.get_materials(None)?.unwrap() {
+    let part = geo.part_info(0)?.unwrap();
+    let material = match geo.get_materials(&part)?.unwrap() {
         Materials::Single(mat) => mat,
         Materials::Multiple(_) => panic!("All materials should be the same"),
     };
diff --git a/examples/object_geos_parts.rs b/examples/object_geos_parts.rs
index fd38e37..1bc6698 100644
--- a/examples/object_geos_parts.rs
+++ b/examples/object_geos_parts.rs
@@ -7,6 +7,8 @@ use hapi_rs::Result;
 fn main() -> Result<()> {
     let session = quick_session(None)?;
 
+    let profile = session.start_performance_monitor_profile("hapi-rs")?;
+
     let lib = session.load_asset_file("otls/sesi/SideFX_spaceship.hda")?;
     let node = lib.try_create_first()?;
     node.cook_blocking()?;
@@ -24,8 +26,7 @@ fn main() -> Result<()> {
                 geometry.node.path_relative(Some(obj_node.handle))?,
                 part_info.part_id()
             );
-            let attrib_names =
-                geometry.get_attribute_names(AttributeOwner::Point, Some(&part_info))?;
+            let attrib_names = geometry.get_attribute_names(AttributeOwner::Point, &part_info)?;
             println!(
                 "{}",
                 &attrib_names.iter_str().collect::<Vec<&str>>().join("\n")
@@ -43,14 +44,14 @@ fn main() -> Result<()> {
             }
 
             println!("Number of Faces: {}", part_info.face_count());
-            let faces = geometry.get_face_counts(Some(&part_info))?;
+            let faces = geometry.get_face_counts(&part_info)?;
             if part_info.part_type() != PartType::Curve {
                 for face in faces.iter() {
                     print!("{}, ", face);
                 }
                 println!();
             }
-            let vertices = geometry.vertex_list(Some(&part_info))?;
+            let vertices = geometry.vertex_list(&part_info)?;
             println!("Vertex Indices Into Points Array");
             let mut curr_idx = 0;
             assert!(curr_idx < vertices.len());
@@ -67,5 +68,13 @@ fn main() -> Result<()> {
             }
         }
     }
+    let tmp_file = tempfile::Builder::new()
+        .suffix("perf-monitor.json")
+        .tempfile()
+        .expect("per-monitor temp file created");
+    let (_, tmp_file) = tmp_file.keep().unwrap();
+    let out_file = tmp_file.to_string_lossy();
+    session.stop_performance_monitor_profile(profile, &out_file)?;
+    println!("Performance monitor data saved: {}", &out_file);
     Ok(())
 }
diff --git a/hython/async_attr.py b/hython/async_attr.py
new file mode 100644
index 0000000..6e79f87
--- /dev/null
+++ b/hython/async_attr.py
@@ -0,0 +1,51 @@
+
+import hapi
+
+options = hapi.ThriftServerOptions(autoClose=True)
+hapi.startThriftSharedMemoryServer(options, "mem", None)
+session = hapi.createThriftSharedMemorySession("mem", hapi.SessionInfo())
+hapi.initialize(session, hapi.CookOptions(), use_cooking_thread=True)
+
+
+def _create_input_point() -> int:
+    node = hapi.createInputNode(session, -1, "input_node")
+
+    part_info = hapi.PartInfo(
+        vertexCount=0, faceCount=0, pointCount=1, type=hapi.partType.Mesh
+    )
+
+    hapi.setPartInfo(session, node, 0, part_info)
+
+    # Positions
+    p_info = hapi.AttributeInfo(
+        exists=True,
+        owner=hapi.attributeOwner.Point,
+        count=1,
+        tupleSize=3,
+        storage=hapi.storageType.Float,
+        originalOwner=hapi.attributeOwner.Invalid,
+    )
+
+    hapi.addAttribute(session, node, 0, "P", p_info)
+    hapi.setAttributeFloatData(session, node, 0, "P", p_info, [0.0, 0.0, 0.0], 0, 1)
+
+    return p_info, node
+
+info, node = _create_input_point()
+hapi.commitGeo(session, node)
+hapi.cookNode(session, node, None)
+while not hapi.getStatus(session, hapi.statusType.CookState) == hapi.state.Ready:
+    ...
+
+# This is working
+# data = hapi.getAttributeFloatData(session, node, 0, "P", info, -1, 0, info.count)
+
+# This is not
+data, job_id = hapi.getAttributeFloatDataAsync(session, node, 0, "P", info, -1, 0, info.count)
+status = hapi.getJobStatus(session, job_id)
+
+
+
+
+
+
diff --git a/hython/issue_array_attr.py b/hython/issue_array_attr.py
index 130ee1c..1dec9ff 100644
--- a/hython/issue_array_attr.py
+++ b/hython/issue_array_attr.py
@@ -1,10 +1,12 @@
 import hou
 import hapi
 
+info = hapi.SessionInfo()
+
 try:
     session = hapi.createThriftSocketSession('localhost', 9090)
 except:
-    session = hapi.createInProcessSession()
+    session = hapi.createInProcessSession(info)
 
 cook_options = hapi.CookOptions()
 try:
@@ -13,7 +15,7 @@
     pass
 
 
-node = hapi.createInputNode(session, "input_node")
+node = hapi.createInputNode(session, -1, "input_node")
 
 part_info = hapi.PartInfo(
     vertexCount = 0,
@@ -58,9 +60,10 @@
         array_info,
         [1, 2, 3, 4, 5],   # data
         5,              # data length
-        [2, 3],         # sizes array
+        [1, 1],         # sizes array
         0,              # start
         2               # sizes length
 )
 
-hapi.commitGeo(session, node)
\ No newline at end of file
+hapi.commitGeo(session, node)
+hapi.saveHIPFile(session, r"c:/Temp/junk/shit.hip", True)
\ No newline at end of file
diff --git a/hython/issue_presets.py b/hython/issue_presets.py
new file mode 100644
index 0000000..e763b5e
--- /dev/null
+++ b/hython/issue_presets.py
@@ -0,0 +1,34 @@
+import sys
+import hou
+import hapi
+from pathlib import Path
+
+
+session_info = hapi.SessionInfo()
+cook_options = hapi.CookOptions()
+
+try:
+    preset_file = sys.argv[1]
+except IndexError:
+    print("Must pass .idx file")
+    sys.exit(1)
+
+session = hapi.createInProcessSession(session_info)
+try:
+    hapi.initialize(session, cook_options)
+except hapi.AlreadyInitializedError:
+    pass
+
+
+preset_file = Path(preset_file).absolute().as_posix()
+
+buffer = open(preset_file).read()
+
+count = hapi.getPresetCount(session, buffer, len(buffer))
+print(f"Num presets: {count}")
+
+handles = hapi.getPresetNames(session, buffer, len(buffer), count)
+
+for h in handles:
+    str_len = hapi.getStringBufLength(session, h)
+    print(" -" + hapi.getString(session, h, str_len))
diff --git a/hython/set_dictionary_array_attribute.py b/hython/set_dictionary_array_attribute.py
new file mode 100644
index 0000000..1284d67
--- /dev/null
+++ b/hython/set_dictionary_array_attribute.py
@@ -0,0 +1,66 @@
+import hapi
+import json
+
+session = hapi.createInProcessSession(hapi.SessionInfo())
+hapi.initialize(session, hapi.CookOptions())
+
+
+def _create_input_point() -> int:
+    node = hapi.createInputNode(session, -1, "input_node")
+
+    part_info = hapi.PartInfo(
+        vertexCount=0, faceCount=0, pointCount=1, type=hapi.partType.Mesh
+    )
+
+    hapi.setPartInfo(session, node, 0, part_info)
+
+    # Positions
+    p_info = hapi.AttributeInfo(
+        exists=True,
+        owner=hapi.attributeOwner.Point,
+        count=1,
+        tupleSize=3,
+        storage=hapi.storageType.Float,
+        originalOwner=hapi.attributeOwner.Invalid,
+    )
+
+    hapi.addAttribute(session, node, 0, "P", p_info)
+    hapi.setAttributeFloatData(session, node, 0, "P", p_info, [0.0, 0.0, 0.0], 0, 1)
+
+    return node
+
+
+node = _create_input_point()
+
+# Create Dictionary Attribute
+attr_info = hapi.AttributeInfo(
+    exists=True,
+    owner=hapi.attributeOwner.Detail,
+    count=1,
+    tupleSize=1,
+    storage=hapi.storageType.DictionaryArray,
+)
+
+
+data = [json.dumps({"foo": 7}), json.dumps({"bar": 3})]
+
+hapi.addAttribute(session, node, 0, "my_dict_attr", attr_info)
+
+# Uncomment to see HARS segfalt if commiting geo BEFORE setting attribute data
+# hapi.commitGeo(session, node)
+
+hapi.setAttributeDictionaryArrayData(
+    session,
+    node,
+    0,
+    "my_dict_attr",
+    attr_info,
+    data,  # data
+    2,
+    [2],
+    0,  # start
+    1,  # sizes length
+)
+
+hapi.commitGeo(session, node)
+hapi.cookNode(session, node, hapi.CookOptions())
diff --git a/src/asset.rs b/src/asset.rs
index 483e271..d813b49 100644
--- a/src/asset.rs
+++ b/src/asset.rs
@@ -278,10 +278,10 @@ impl AssetLibrary {
         .map(|info| ParmInfo::new(info, self.session.clone(), None));
         let values =
             crate::ffi::get_asset_def_parm_values(self.lib_id, &asset_name, &self.session, &count)?;
-        let menus = values.3.into_iter().map(|info| ParmChoiceInfo {
-            inner: info,
-            session: self.session.clone(),
-        });
+        let menus = values
+            .3
+            .into_iter()
+            .map(|info| ParmChoiceInfo(info, self.session.clone()));
         let values = AssetParmValues {
             int: values.0,
             float: values.1,
diff --git a/src/attribute/bindings.rs b/src/attribute/bindings.rs
index 21a47f8..307e6cf 100644
--- a/src/attribute/bindings.rs
+++ b/src/attribute/bindings.rs
@@ -2,12 +2,14 @@ use super::array::{DataArray, StringMultiArray};
 use crate::ffi::raw;
 use crate::ffi::raw::{HAPI_AttributeInfo, HAPI_StringHandle, StorageType};
 use crate::ffi::AttributeInfo;
+use crate::session::Session;
 use crate::stringhandle::{StringArray, StringHandle};
 use crate::{node::HoudiniNode, Result};
 use duplicate::duplicate_item;
 use std::ffi::CStr;
 
-pub trait AttribAccess: Sized + 'static {
+// TODO make this trait sealed and mark functions unsafe (vs using unsafe blocks in the impl)
+pub trait AttribAccess: Send + Sized + 'static {
     fn storage() -> StorageType;
     fn storage_array() -> StorageType;
     fn get(
@@ -17,6 +19,13 @@ pub trait AttribAccess: Sized + 'static {
         part_id: i32,
         buffer: &mut Vec<Self>,
     ) -> Result<()>;
+    fn get_async(
+        name: &CStr,
+        node: &HoudiniNode,
+        info: &AttributeInfo,
+        part_id: i32,
+        buffer: &mut Vec<Self>,
+    ) -> Result<i32>;
     fn set(
         name: &CStr,
         node: &HoudiniNode,
@@ -26,6 +35,16 @@ pub trait AttribAccess: Sized + 'static {
         start: i32,
         len: i32,
     ) -> Result<()>;
+
+    fn set_unique(
+        name: &CStr,
+        node: &HoudiniNode,
+        info: &AttributeInfo,
+        part_id: i32,
+        data: &[Self],
+        start: i32,
+    ) -> Result<()>;
+
     fn get_array(
         name: &CStr,
         node: &HoudiniNode,
@@ -52,7 +71,9 @@ _val_type [u8]
 _storage [StorageType::Uint8]
 _storage_array [StorageType::Uint8Array]
 _get [HAPI_GetAttributeUInt8Data]
+_get_async [HAPI_GetAttributeUInt8DataAsync]
 _set [HAPI_SetAttributeUInt8Data]
+_set_unique [HAPI_SetAttributeUInt8UniqueData]
 _get_array [HAPI_GetAttributeUInt8ArrayData]
 _set_array [HAPI_SetAttributeUInt8ArrayData]
 ]
@@ -61,7 +82,9 @@ _val_type [i8]
 _storage [StorageType::Int8]
 _storage_array [StorageType::Int8Array]
 _get [HAPI_GetAttributeInt8Data]
+_get_async [HAPI_GetAttributeInt8DataAsync]
 _set [HAPI_SetAttributeInt8Data]
+_set_unique [HAPI_SetAttributeInt8UniqueData]
 _get_array [HAPI_GetAttributeInt8ArrayData]
 _set_array [HAPI_SetAttributeInt8ArrayData]
 ]
@@ -70,7 +93,9 @@ _val_type [i16]
 _storage [StorageType::Int16]
 _storage_array [StorageType::Int16Array]
 _get [HAPI_GetAttributeInt16Data]
+_get_async [HAPI_GetAttributeInt16DataAsync]
 _set [HAPI_SetAttributeInt16Data]
+_set_unique [HAPI_SetAttributeInt16UniqueData]
 _get_array [HAPI_GetAttributeInt16ArrayData]
 _set_array [HAPI_SetAttributeInt16ArrayData]
 ]
@@ -79,7 +104,9 @@ _val_type [i32]
 _storage [StorageType::Int]
 _storage_array [StorageType::IntArray]
 _get [HAPI_GetAttributeIntData]
+_get_async [HAPI_GetAttributeIntDataAsync]
 _set [HAPI_SetAttributeIntData]
+_set_unique [HAPI_SetAttributeIntUniqueData]
 _get_array [HAPI_GetAttributeIntArrayData]
 _set_array [HAPI_SetAttributeIntArrayData]
 ]
@@ -88,7 +115,9 @@ _val_type [i64]
 _storage [StorageType::Int64]
 _storage_array [StorageType::Int64Array]
 _get [HAPI_GetAttributeInt64Data]
+_get_async [HAPI_GetAttributeInt64DataAsync]
 _set [HAPI_SetAttributeInt64Data]
+_set_unique [HAPI_SetAttributeInt64UniqueData]
 _get_array [HAPI_GetAttributeInt64ArrayData]
 _set_array [HAPI_SetAttributeInt64ArrayData]
 ]
@@ -97,7 +126,9 @@ _val_type [f32]
 _storage [StorageType::Float]
 _storage_array [StorageType::FloatArray]
 _get [HAPI_GetAttributeFloatData]
+_get_async [HAPI_GetAttributeFloatDataAsync]
 _set [HAPI_SetAttributeFloatData]
+_set_unique [HAPI_SetAttributeFloatUniqueData]
 _get_array [HAPI_GetAttributeFloatArrayData]
 _set_array [HAPI_SetAttributeFloatArrayData]
 ]
@@ -106,7 +137,9 @@ _val_type [f64]
 _storage [StorageType::Float64]
 _storage_array [StorageType::Float64Array]
 _get [HAPI_GetAttributeFloat64Data]
+_get_async [HAPI_GetAttributeFloat64DataAsync]
 _set [HAPI_SetAttributeFloat64Data]
+_set_unique [HAPI_SetAttributeFloat64UniqueData]
 _get_array [HAPI_GetAttributeFloat64ArrayData]
 _set_array [HAPI_SetAttributeFloat64ArrayData]
 ]
@@ -127,27 +160,54 @@ impl AttribAccess for _val_type {
     ) -> Result<()> {
         debug_assert!(node.is_valid()?);
         buffer.resize(
-            (info.inner.count * info.inner.tupleSize) as usize,
+            (info.0.count * info.0.tupleSize) as usize,
             _val_type::default(),
         );
         unsafe {
-            // SAFETY: Most likely an error in C API, it should not modify the info object,
-            // but for some reason it wants a mut pointer
-            let attr_info = &info.inner as *const _ as *mut HAPI_AttributeInfo;
             raw::_get(
                 node.session.ptr(),
                 node.handle.0,
                 part,
                 name.as_ptr(),
-                attr_info,
+                info.ptr() as *mut _,
                 -1,
                 buffer.as_mut_ptr(),
                 0,
-                info.inner.count,
+                info.0.count,
             )
             .check_err(&node.session, || stringify!(Calling _get))
         }
     }
+    fn get_async(
+        name: &CStr,
+        node: &HoudiniNode,
+        info: &AttributeInfo,
+        part: i32,
+        buffer: &mut Vec<Self>,
+    ) -> Result<i32> {
+        debug_assert!(node.is_valid()?);
+        buffer.resize(
+            (info.0.count * info.0.tupleSize) as usize,
+            _val_type::default(),
+        );
+        let mut job_id: i32 = -1;
+        unsafe {
+            raw::_get_async(
+                node.session.ptr(),
+                node.handle.0,
+                part,
+                name.as_ptr(),
+                info.ptr() as *mut _,
+                -1,
+                buffer.as_mut_ptr(),
+                0,
+                info.0.count,
+                &mut job_id as *mut _,
+            )
+            .check_err(&node.session, || stringify!(Calling _get_async))?;
+            Ok(job_id)
+        }
+    }
     fn set(
         name: &CStr,
         node: &HoudiniNode,
@@ -164,7 +224,7 @@ impl AttribAccess for _val_type {
                 node.handle.0,
                 part,
                 name.as_ptr(),
-                &info.inner,
+                &info.0,
                 data.as_ptr(),
                 start,
                 len,
@@ -172,6 +232,30 @@ impl AttribAccess for _val_type {
             .check_err(&node.session, || stringify!(Calling _set))
         }
     }
+
+    fn set_unique(
+        name: &CStr,
+        node: &HoudiniNode,
+        info: &AttributeInfo,
+        part_id: i32,
+        data: &[_val_type],
+        start: i32,
+    ) -> Result<()> {
+        unsafe {
+            raw::_set_unique(
+                node.session.ptr(),
+                node.handle.0,
+                part_id,
+                name.as_ptr(),
+                info.ptr(),
+                data.as_ptr(),
+                info.0.tupleSize,
+                start,
+                info.0.count,
+            )
+            .check_err(&node.session, || stringify!(Calling _set_unique))
+        }
+    }
     fn get_array(
         name: &CStr,
         node: &HoudiniNode,
@@ -182,20 +266,20 @@ impl AttribAccess for _val_type {
         [Self]: ToOwned<Owned = Vec<Self>>,
     {
         debug_assert!(node.is_valid()?);
-        let mut data = vec![_val_type::default(); info.inner.totalArrayElements as usize];
-        let mut sizes = vec![0; info.inner.count as usize];
+        let mut data = vec![_val_type::default(); info.0.totalArrayElements as usize];
+        let mut sizes = vec![0; info.0.count as usize];
         unsafe {
             raw::_get_array(
                 node.session.ptr(),
                 node.handle.0,
                 part,
                 name.as_ptr(),
-                &info.inner as *const _ as *mut _,
+                &info.0 as *const _ as *mut _,
                 data.as_mut_ptr(),
-                info.inner.totalArrayElements as i32,
+                info.0.totalArrayElements as i32,
                 sizes.as_mut_ptr(),
                 0,
-                info.inner.count,
+                info.0.count,
             )
             .check_err(&node.session, || stringify!(Calling _get_array))?;
         }
@@ -220,12 +304,12 @@ impl AttribAccess for _val_type {
                 node.handle.0,
                 part,
                 name.as_ptr(),
-                &info.inner,
+                &info.0,
                 data.as_ptr(),
-                info.inner.totalArrayElements as i32,
+                info.0.totalArrayElements as i32,
                 sizes.as_ptr(),
                 0,
-                info.inner.count,
+                info.0.count,
             )
             .check_err(&node.session, || stringify!(Calling _set_array))?;
         }
@@ -233,19 +317,18 @@ impl AttribAccess for _val_type {
         Ok(())
     }
 }
-
 #[duplicate_item(
 [
-_rust_fn [get_attribute_string_data]
-_ffi_fn [HAPI_GetAttributeStringData]
+_get_rust_fn [get_attribute_string_data]
+_get_ffi_fn [HAPI_GetAttributeStringData]
 ]
 
 [
-_rust_fn [get_attribute_dictionary_data]
-_ffi_fn [HAPI_GetAttributeDictionaryData]
+_get_rust_fn [get_attribute_dictionary_data]
+_get_ffi_fn [HAPI_GetAttributeDictionaryData]
 ]
 )]
-pub(crate) fn _rust_fn(
+pub(crate) fn _get_rust_fn(
     node: &HoudiniNode,
     part_id: i32,
     name: &CStr,
@@ -258,7 +341,7 @@ pub(crate) fn _rust_fn(
         // SAFETY: Most likely an error in C API, it should not modify the info object,
         // but for some reason it wants a mut pointer
         let attr_info = attr_info as *const _ as *mut HAPI_AttributeInfo;
-        raw::_ffi_fn(
+        raw::_get_ffi_fn(
             node.session.ptr(),
             node.handle.0,
             part_id,
@@ -268,11 +351,81 @@ pub(crate) fn _rust_fn(
             0,
             handles.len() as i32,
         )
-        .check_err(&node.session, || stringify!(Calling _ffi_fn))?;
+        .check_err(&node.session, || stringify!(Calling _get_ffi_fn))?;
         crate::stringhandle::get_string_array(&handles, &node.session)
     }
 }
 
+pub struct AsyncResult<T: Sized + 'static> {
+    pub(crate) job_id: i32,
+    pub(crate) data: T,
+    pub(crate) session: Session,
+}
+
+impl<T: Sized + 'static> AsyncResult<T> {
+    pub fn is_ready(&self) -> Result<bool> {
+        self.session
+            .get_job_status(self.job_id)
+            .map(|status| status == crate::session::JobStatus::Running)
+    }
+
+    pub fn wait(self) -> Result<T> {
+        loop {
+            if self.is_ready()? {
+                return Ok(self.data);
+            }
+        }
+    }
+}
+
+// Async versions for string and dict
+#[duplicate_item(
+[
+_get_async_rust_fn [get_attribute_string_data_async]
+_get_async_ffi_fn [HAPI_GetAttributeStringDataAsync]
+]
+
+[
+_get_async_rust_fn [get_attribute_dictionary_data_async]
+_get_async_ffi_fn [HAPI_GetAttributeDictionaryDataAsync]
+]
+
+)]
+#[allow(unused)] // FIXME
+pub(crate) fn _get_async_rust_fn(
+    node: &HoudiniNode,
+    part_id: i32,
+    name: &CStr,
+    attr_info: &HAPI_AttributeInfo,
+) -> Result<AsyncResult<StringArray>> {
+    unsafe {
+        let mut handles = vec![StringHandle(0); attr_info.count as usize];
+        let session = node.session.clone();
+        // SAFETY: Most likely an error in C API, it should not modify the info object,
+        // but for some reason it wants a mut pointer
+        let attr_info = attr_info as *const _ as *mut HAPI_AttributeInfo;
+        let mut job_id = -1;
+        raw::_get_async_ffi_fn(
+            session.ptr(),
+            node.handle.0,
+            part_id,
+            name.as_ptr(),
+            attr_info,
+            handles.as_mut_ptr() as *mut HAPI_StringHandle,
+            0,
+            handles.len() as i32,
+            &mut job_id,
+        )
+        .check_err(&session, || stringify!(Calling _get_async_ffi_fn))?;
+        let data = crate::stringhandle::get_string_array(&handles, &session)?;
+        Ok(AsyncResult {
+            job_id,
+            data,
+            session,
+        })
+    }
+}
+
 #[duplicate_item(
 [
 _rust_fn [set_attribute_string_data]
@@ -364,7 +517,7 @@ _ffi_fn [HAPI_SetAttributeDictionaryArrayData]
 pub(crate) fn _rust_fn(
     node: &HoudiniNode,
     name: &CStr,
-    info: &raw::HAPI_AttributeInfo,
+    info: &HAPI_AttributeInfo,
     data: &mut [*const i8],
     sizes: &[i32],
 ) -> Result<()> {
@@ -385,3 +538,33 @@ pub(crate) fn _rust_fn(
         .check_err(&node.session, || stringify!(Calling _ffi_fn))
     }
 }
+
+#[duplicate_item(
+[
+_rust_fn [set_attribute_string_unique_data]
+_ffi_fn [HAPI_SetAttributeStringUniqueData]
+_val_type [*const ::std::os::raw::c_char]
+]
+
+)]
+
+pub(crate) unsafe fn _rust_fn(
+    node: &HoudiniNode,
+    name: &CStr,
+    info: &HAPI_AttributeInfo,
+    part: i32,
+    data: _val_type,
+) -> Result<()> {
+    raw::_ffi_fn(
+        node.session.ptr(),
+        node.handle.0,
+        part,
+        name.as_ptr(),
+        info as *const _,
+        data,
+        info.tupleSize,
+        0,
+        info.count,
+    )
+    .check_err(&node.session, || stringify!(Calling _ffi_fn))
+}
diff --git a/src/attribute/mod.rs b/src/attribute/mod.rs
index 1b3c398..a7634b3 100644
--- a/src/attribute/mod.rs
+++ b/src/attribute/mod.rs
@@ -21,6 +21,7 @@
 mod array;
 mod bindings;
 
+use crate::attribute::bindings::AsyncResult;
 use crate::errors::Result;
 pub use crate::ffi::enums::StorageType;
 pub use crate::ffi::AttributeInfo;
@@ -123,6 +124,9 @@ impl<T: AttribAccess> NumericAttr<T> {
         )?;
         Ok(buffer)
     }
+    pub fn get_async(&self, part_id: i32, buffer: &mut Vec<T>) -> Result<i32> {
+        T::get_async(&self.0.name, &self.0.node, &self.0.info, part_id, buffer)
+    }
     /// Read the attribute data into a provided buffer. The buffer will be auto-resized
     /// from the attribute info.
     pub fn read_into(&self, part_id: i32, buffer: &mut Vec<T>) -> Result<()> {
@@ -142,6 +146,14 @@ impl<T: AttribAccess> NumericAttr<T> {
             self.0.info.count(),
         )
     }
+
+    /// Set multiple attribute data to the same value.
+    /// value length must be less or equal to attribute tuple size.
+    pub fn set_unique(&self, part_id: i32, value: &[T]) -> Result<()> {
+        debug_assert_eq!(self.0.info.storage(), T::storage());
+        debug_assert!(value.len() <= self.0.info.tuple_size() as usize);
+        T::set_unique(&self.0.name, &self.0.node, &self.0.info, part_id, value, 0)
+    }
 }
 
 impl StringAttr {
@@ -154,7 +166,16 @@ impl StringAttr {
             &self.0.node,
             part_id,
             self.0.name.as_c_str(),
-            &self.0.info.inner,
+            &self.0.info.0,
+        )
+    }
+
+    pub fn get_async(&self, part_id: i32) -> Result<AsyncResult<StringArray>> {
+        bindings::get_attribute_string_data_async(
+            &self.0.node,
+            part_id,
+            self.0.name.as_c_str(),
+            &self.0.info.0,
         )
     }
     pub fn set(&self, part_id: i32, values: &[&str]) -> Result<()> {
@@ -167,10 +188,34 @@ impl StringAttr {
             &self.0.node,
             part_id,
             self.0.name.as_c_str(),
-            &self.0.info.inner,
+            &self.0.info.0,
             ptrs.as_mut(),
         )
     }
+    pub fn set_cstr<'a>(&self, part_id: i32, values: impl Iterator<Item = &'a CStr>) -> Result<()> {
+        let mut ptrs: Vec<*const i8> = values.map(|cs| cs.as_ptr()).collect();
+        bindings::set_attribute_string_data(
+            &self.0.node,
+            part_id,
+            self.0.name.as_c_str(),
+            &self.0.info.0,
+            ptrs.as_mut(),
+        )
+    }
+    /// Set multiple attribute data to the same value.
+    /// value length must be less or equal to attribute tuple size.
+    pub fn set_unique(&self, part: i32, value: &str) -> Result<()> {
+        let value = CString::new(value)?;
+        unsafe {
+            bindings::set_attribute_string_unique_data(
+                &self.0.node,
+                self.0.name.as_c_str(),
+                &self.0.info.0,
+                part,
+                value.as_ptr(),
+            )
+        }
+    }
 }
 
 impl StringArrayAttr {
@@ -195,7 +240,7 @@ impl StringArrayAttr {
         bindings::set_attribute_string_array_data(
             &self.0.node,
             self.0.name.as_c_str(),
-            &self.0.info.inner,
+            &self.0.info.0,
             ptrs.as_mut(),
             &sizes,
         )
@@ -213,7 +258,7 @@ impl DictionaryAttr {
             &self.0.node,
             part_id,
             self.0.name.as_c_str(),
-            &self.0.info.inner,
+            &self.0.info.0,
         )
     }
 
@@ -228,7 +273,7 @@ impl DictionaryAttr {
             &self.0.node,
             part_id,
             &self.0.name.as_c_str(),
-            &self.0.info.inner,
+            &self.0.info.0,
             cstrings.as_mut(),
         )
     }
@@ -256,7 +301,7 @@ impl DictionaryArrayAttr {
         bindings::set_attribute_dictionary_array_data(
             &self.0.node,
             self.0.name.as_c_str(),
-            &self.0.info.inner,
+            &self.0.info.0,
             ptrs.as_mut(),
             &sizes,
         )
@@ -264,7 +309,7 @@ impl DictionaryArrayAttr {
 }
 
 #[doc(hidden)]
-pub trait AsAttribute {
+pub trait AsAttribute: Send {
     fn info(&self) -> &AttributeInfo;
     fn storage(&self) -> StorageType;
     fn boxed(self) -> Box<dyn AnyAttribWrapper>
@@ -411,6 +456,6 @@ impl Attribute {
         self.0.info()
     }
     pub fn delete(self, part_id: i32) -> Result<()> {
-        crate::ffi::delete_attribute(self.0.node(), part_id, self.0.name(), &self.0.info().inner)
+        crate::ffi::delete_attribute(self.0.node(), part_id, self.0.name(), &self.0.info().0)
     }
 }
diff --git a/src/errors.rs b/src/errors.rs
index 9cc1d87..2f43670 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -16,11 +16,20 @@ pub struct HapiError {
     pub server_message: Option<Cow<'static, str>>,
 }
 
+// This special case for TryFrom<T, Error = HapiError> where conversion can't fail.
+// for example when "impl TryInto<AttributeName>" receives AttributeName.
+impl From<std::convert::Infallible> for HapiError {
+    fn from(_: std::convert::Infallible) -> Self {
+        unreachable!()
+    }
+}
+
 pub(crate) trait ErrorContext<T> {
     fn context<C>(self, context: C) -> Result<T>
     where
         C: Into<Cow<'static, str>>;
 
+    #[allow(unused)]
     fn with_context<C, F>(self, func: F) -> Result<T>
     where
         C: Into<Cow<'static, str>>,
@@ -128,16 +137,6 @@ impl From<std::io::Error> for HapiError {
 }
 
 impl HapiError {
-    pub(crate) fn new_hapi_with_server_message(
-        result: HapiResult,
-        server_message: Cow<'static, str>,
-    ) -> Self {
-        HapiError {
-            kind: Kind::Hapi(result),
-            contexts: vec![],
-            server_message: Some(server_message),
-        }
-    }
     pub(crate) fn new(
         kind: Kind,
         mut static_message: Option<Cow<'static, str>>,
@@ -217,38 +216,42 @@ impl From<std::string::FromUtf8Error> for HapiError {
     }
 }
 
+impl From<&str> for HapiError {
+    fn from(value: &str) -> Self {
+        HapiError::new(Kind::Internal(Cow::Owned(value.to_string())), None, None)
+    }
+}
+
 impl std::error::Error for HapiError {}
 
 impl HapiResult {
-    pub(crate) fn check_err<R: Default, F, M>(self, session: &Session, context: F) -> Result<R>
+    pub(crate) fn check_err<F, M>(self, session: &Session, context: F) -> Result<()>
     where
         M: Into<Cow<'static, str>>,
         F: FnOnce() -> M,
     {
         match self {
-            HapiResult::Success => Ok(R::default()),
+            HapiResult::Success => Ok(()),
             _err => {
                 let server_message = session
                     .get_status_string(StatusType::CallResult, StatusVerbosity::All)
                     .map(Cow::Owned)
                     .unwrap_or_else(|_| Cow::Borrowed("Could not retrieve error message"));
-                let mut err = HapiError::new_hapi_with_server_message(self, server_message);
+                let mut err = HapiError::new(Kind::Hapi(self), None, Some(server_message));
                 err.contexts.push(context().into());
                 Err(err)
             }
         }
     }
 
-    pub(crate) fn error_message<I: Into<Cow<'static, str>>, R: Default>(
-        self,
-        message: I,
-    ) -> Result<R> {
+    pub(crate) fn error_message<I: Into<Cow<'static, str>>>(self, message: I) -> Result<()> {
         match self {
-            HapiResult::Success => Ok(R::default()),
+            HapiResult::Success => Ok(()),
             _err => {
-                let mut err = HapiError::new_hapi_with_server_message(
-                    self,
-                    Cow::Borrowed("Server error message unavailable"),
+                let mut err = HapiError::new(
+                    Kind::Hapi(self),
+                    None,
+                    Some(Cow::Borrowed("Server error message unavailable")),
                 );
                 err.contexts.push(message.into());
                 Err(err)
diff --git a/src/ffi/bindings.rs b/src/ffi/bindings.rs
index 5a20648..3735d0b 100644
--- a/src/ffi/bindings.rs
+++ b/src/ffi/bindings.rs
@@ -1,6 +1,6 @@
 /* automatically generated by rust-bindgen 0.66.1 */
 
-// Houdini version 20.0.625
+// Houdini version 20.5.370
 // hapi-sys version 0.1.0
 
 pub const HAPI_POSITION_VECTOR_SIZE: u32 = 3;
@@ -15,6 +15,7 @@ pub const HAPI_CV_VECTOR_SIZE: u32 = 4;
 pub const HAPI_PRIM_MIN_VERTEX_COUNT: u32 = 1;
 pub const HAPI_PRIM_MAX_VERTEX_COUNT: u32 = 16;
 pub const HAPI_INVALID_PARM_ID: i32 = -1;
+pub const HAPI_MAX_NUM_CONNECTIONS: u32 = 128;
 pub const HAPI_ATTRIB_POSITION: &[u8; 2] = b"P\0";
 pub const HAPI_ATTRIB_UV: &[u8; 3] = b"uv\0";
 pub const HAPI_ATTRIB_UV2: &[u8; 4] = b"uv2\0";
@@ -64,12 +65,12 @@ pub const WCHAR_MAX: u32 = 65535;
 pub const WINT_MIN: u32 = 0;
 pub const WINT_MAX: u32 = 65535;
 pub const HAPI_VERSION_HOUDINI_MAJOR: u32 = 20;
-pub const HAPI_VERSION_HOUDINI_MINOR: u32 = 0;
-pub const HAPI_VERSION_HOUDINI_BUILD: u32 = 625;
+pub const HAPI_VERSION_HOUDINI_MINOR: u32 = 5;
+pub const HAPI_VERSION_HOUDINI_BUILD: u32 = 370;
 pub const HAPI_VERSION_HOUDINI_PATCH: u32 = 0;
-pub const HAPI_VERSION_HOUDINI_ENGINE_MAJOR: u32 = 6;
-pub const HAPI_VERSION_HOUDINI_ENGINE_MINOR: u32 = 2;
-pub const HAPI_VERSION_HOUDINI_ENGINE_API: u32 = 0;
+pub const HAPI_VERSION_HOUDINI_ENGINE_MAJOR: u32 = 7;
+pub const HAPI_VERSION_HOUDINI_ENGINE_MINOR: u32 = 0;
+pub const HAPI_VERSION_HOUDINI_ENGINE_API: u32 = 5;
 pub type HAPI_Bool = ::std::os::raw::c_char;
 pub type va_list = *mut ::std::os::raw::c_char;
 extern "C" {
@@ -171,6 +172,14 @@ pub enum StatusVerbosity {
 #[repr(i32)]
 #[non_exhaustive]
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum JobStatus {
+    Running = 0,
+    Idle = 1,
+    Max = 2,
+}
+#[repr(i32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub enum HapiResult {
     Success = 0,
     Failure = 1,
@@ -327,52 +336,53 @@ pub enum ParmType {
 #[non_exhaustive]
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub enum PrmScriptType {
-    TypeInt = 0,
-    TypeFloat = 1,
-    TypeAngle = 2,
-    TypeString = 3,
-    TypeFile = 4,
-    TypeDirectory = 5,
-    TypeImage = 6,
-    TypeGeometry = 7,
-    TypeToggle = 8,
-    TypeButton = 9,
-    TypeVector2 = 10,
-    TypeVector3 = 11,
-    TypeVector4 = 12,
-    TypeIntvector2 = 13,
-    TypeIntvector3 = 14,
-    TypeIntvector4 = 15,
-    TypeUv = 16,
-    TypeUvw = 17,
-    TypeDir = 18,
-    TypeColor = 19,
-    TypeColor4 = 20,
-    TypeOppath = 21,
-    TypeOplist = 22,
-    TypeObject = 23,
-    TypeObjectlist = 24,
-    TypeRender = 25,
-    TypeSeparator = 26,
-    GeometryData = 27,
-    ValueDict = 28,
-    TypeLabel = 29,
-    TypeRgbamask = 30,
-    TypeOrdinal = 31,
-    RampFlt = 32,
-    RampRgb = 33,
-    FloatLog = 34,
-    IntLog = 35,
-    TypeData = 36,
-    FloatMinmax = 37,
-    IntMinmax = 38,
-    IntStartend = 39,
-    TypeButtonstrip = 40,
-    TypeIconstrip = 41,
-    TypeGroupradio = 1000,
-    TypeGroupcollapsible = 1001,
-    TypeGroupsimple = 1002,
-    TypeGroup = 1003,
+    Int = 0,
+    Float = 1,
+    Angle = 2,
+    String = 3,
+    File = 4,
+    Directory = 5,
+    Image = 6,
+    Geometry = 7,
+    Toggle = 8,
+    Button = 9,
+    Vector2 = 10,
+    Vector3 = 11,
+    Vector4 = 12,
+    Intvector2 = 13,
+    Intvector3 = 14,
+    Intvector4 = 15,
+    Uv = 16,
+    Uvw = 17,
+    Dir = 18,
+    Color = 19,
+    Color4 = 20,
+    Huecircle = 21,
+    Oppath = 22,
+    Oplist = 23,
+    Object = 24,
+    Objectlist = 25,
+    Render = 26,
+    Separator = 27,
+    Data = 28,
+    Dict = 29,
+    Label = 30,
+    Rgbamask = 31,
+    Ordinal = 32,
+    Flt = 33,
+    Rgb = 34,
+    Log = 35,
+    IntLog = 36,
+    TypeData = 37,
+    Minmax = 38,
+    IntMinmax = 39,
+    Startend = 40,
+    Buttonstrip = 41,
+    Iconstrip = 42,
+    Groupradio = 1000,
+    Groupcollapsible = 1001,
+    Groupsimple = 1002,
+    Group = 1003,
 }
 #[repr(i32)]
 #[non_exhaustive]
@@ -754,25 +764,26 @@ pub enum PdgEventType {
     WorkitemSetFloat = 23,
     WorkitemSetString = 24,
     WorkitemSetFile = 25,
-    WorkitemSetPyobject = 26,
-    WorkitemSetGeometry = 27,
-    EventWorkitemMerge = 28,
-    EventWorkitemResult = 29,
-    EventWorkitemPriority = 30,
-    EventCookStart = 31,
-    AddStaticAncestor = 32,
-    RemoveStaticAncestor = 33,
-    NodeProgressUpdate = 34,
-    BatchItemInitialized = 35,
-    PdgEventAll = 36,
-    PdgEventLog = 37,
-    EventSchedulerAdded = 38,
-    EventSchedulerRemoved = 39,
-    EventSetScheduler = 40,
-    ServiceManagerAll = 41,
-    EventNodeCooked = 42,
-    EventNodeGenerated = 43,
-    PdgContextEvents = 44,
+    WorkitemSetDict = 26,
+    WorkitemSetPyobject = 27,
+    WorkitemSetGeometry = 28,
+    EventWorkitemMerge = 29,
+    EventWorkitemResult = 30,
+    EventWorkitemPriority = 31,
+    EventCookStart = 32,
+    AddStaticAncestor = 33,
+    RemoveStaticAncestor = 34,
+    NodeProgressUpdate = 35,
+    BatchItemInitialized = 36,
+    PdgEventAll = 37,
+    PdgEventLog = 38,
+    EventSchedulerAdded = 39,
+    EventSchedulerRemoved = 40,
+    EventSetScheduler = 41,
+    ServiceManagerAll = 42,
+    EventNodeCooked = 43,
+    EventNodeGenerated = 44,
+    PdgContextEvents = 45,
 }
 #[repr(i32)]
 #[non_exhaustive]
@@ -790,6 +801,21 @@ pub enum PdgWorkItemState {
     Dirty = 9,
 }
 pub use self::PdgWorkItemState as HAPI_PDG_WorkitemState;
+#[repr(i32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum TcpPortType {
+    Any = 0,
+    Range = 1,
+    List = 2,
+}
+#[repr(i32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum ThriftSharedMemoryBufferType {
+    Buffer = 0,
+    RingBuffer = 1,
+}
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct HAPI_Transform {
@@ -817,10 +843,23 @@ pub struct HAPI_Session {
 }
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
+pub struct HAPI_SessionInfo {
+    pub connectionCount: ::std::os::raw::c_int,
+    pub portType: TcpPortType,
+    pub minPort: ::std::os::raw::c_int,
+    pub maxPort: ::std::os::raw::c_int,
+    pub ports: [::std::os::raw::c_int; 128usize],
+    pub sharedMemoryBufferType: ThriftSharedMemoryBufferType,
+    pub sharedMemoryBufferSize: HAPI_Int64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
 pub struct HAPI_ThriftServerOptions {
     pub autoClose: HAPI_Bool,
     pub timeoutMs: f32,
     pub verbosity: StatusVerbosity,
+    pub sharedMemoryBufferType: ThriftSharedMemoryBufferType,
+    pub sharedMemoryBufferSize: HAPI_Int64,
 }
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
@@ -1168,6 +1207,12 @@ pub struct HAPI_CompositorOptions {
     pub maximumResolutionX: ::std::os::raw::c_int,
     pub maximumResolutionY: ::std::os::raw::c_int,
 }
+extern "C" {
+    pub fn HAPI_SessionInfo_Init(in_: *mut HAPI_SessionInfo);
+}
+extern "C" {
+    pub fn HAPI_SessionInfo_Create() -> HAPI_SessionInfo;
+}
 extern "C" {
     pub fn HAPI_ThriftServerOptions_Init(in_: *mut HAPI_ThriftServerOptions);
 }
@@ -1382,7 +1427,10 @@ extern "C" {
     pub fn HAPI_SessionSyncInfo_Create() -> HAPI_SessionSyncInfo;
 }
 extern "C" {
-    pub fn HAPI_CreateInProcessSession(session: *mut HAPI_Session) -> HapiResult;
+    pub fn HAPI_CreateInProcessSession(
+        session: *mut HAPI_Session,
+        session_info: *const HAPI_SessionInfo,
+    ) -> HapiResult;
 }
 extern "C" {
     pub fn HAPI_StartThriftSocketServer(
@@ -1397,6 +1445,7 @@ extern "C" {
         session: *mut HAPI_Session,
         host_name: *const ::std::os::raw::c_char,
         port: ::std::os::raw::c_int,
+        session_info: *const HAPI_SessionInfo,
     ) -> HapiResult;
 }
 extern "C" {
@@ -1411,6 +1460,22 @@ extern "C" {
     pub fn HAPI_CreateThriftNamedPipeSession(
         session: *mut HAPI_Session,
         pipe_name: *const ::std::os::raw::c_char,
+        session_info: *const HAPI_SessionInfo,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_StartThriftSharedMemoryServer(
+        options: *const HAPI_ThriftServerOptions,
+        shared_mem_name: *const ::std::os::raw::c_char,
+        process_id: *mut HAPI_ProcessId,
+        log_file: *const ::std::os::raw::c_char,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_CreateThriftSharedMemorySession(
+        session: *mut HAPI_Session,
+        shared_mem_name: *const ::std::os::raw::c_char,
+        session_info: *const HAPI_SessionInfo,
     ) -> HapiResult;
 }
 extern "C" {
@@ -1454,6 +1519,20 @@ extern "C" {
 extern "C" {
     pub fn HAPI_Shutdown(session: *const HAPI_Session) -> HapiResult;
 }
+extern "C" {
+    pub fn HAPI_StartPerformanceMonitorProfile(
+        session: *const HAPI_Session,
+        title: *const ::std::os::raw::c_char,
+        profile_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_StopPerformanceMonitorProfile(
+        session: *const HAPI_Session,
+        profile_id: ::std::os::raw::c_int,
+        file_path: *const ::std::os::raw::c_char,
+    ) -> HapiResult;
+}
 extern "C" {
     pub fn HAPI_GetEnvInt(int_type: EnvIntType, value: *mut ::std::os::raw::c_int) -> HapiResult;
 }
@@ -1819,6 +1898,26 @@ extern "C" {
         choice_length: ::std::os::raw::c_int,
     ) -> HapiResult;
 }
+extern "C" {
+    pub fn HAPI_GetAssetDefinitionParmTagName(
+        session: *const HAPI_Session,
+        library_id: HAPI_AssetLibraryId,
+        asset_name: *const ::std::os::raw::c_char,
+        parm_id: HAPI_ParmId,
+        tag_index: ::std::os::raw::c_int,
+        tag_name: *mut HAPI_StringHandle,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_GetAssetDefinitionParmTagValue(
+        session: *const HAPI_Session,
+        library_id: HAPI_AssetLibraryId,
+        asset_name: *const ::std::os::raw::c_char,
+        parm_id: HAPI_ParmId,
+        tag_name: *const ::std::os::raw::c_char,
+        tag_value: *mut HAPI_StringHandle,
+    ) -> HapiResult;
+}
 extern "C" {
     pub fn HAPI_GetLoadedAssetLibraryCount(
         session: *const HAPI_Session,
@@ -1938,6 +2037,7 @@ extern "C" {
 extern "C" {
     pub fn HAPI_CreateInputNode(
         session: *const HAPI_Session,
+        parent_node_id: HAPI_NodeId,
         node_id: *mut HAPI_NodeId,
         name: *const ::std::os::raw::c_char,
     ) -> HapiResult;
@@ -1945,6 +2045,7 @@ extern "C" {
 extern "C" {
     pub fn HAPI_CreateInputCurveNode(
         session: *const HAPI_Session,
+        parent_node_id: HAPI_NodeId,
         node_id: *mut HAPI_NodeId,
         name: *const ::std::os::raw::c_char,
     ) -> HapiResult;
@@ -2392,6 +2493,23 @@ extern "C" {
         buffer_length: ::std::os::raw::c_int,
     ) -> HapiResult;
 }
+extern "C" {
+    pub fn HAPI_GetPresetCount(
+        session: *const HAPI_Session,
+        buffer: *const ::std::os::raw::c_char,
+        buffer_length: ::std::os::raw::c_int,
+        count: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_GetPresetNames(
+        session: *const HAPI_Session,
+        buffer: *const ::std::os::raw::c_char,
+        buffer_length: ::std::os::raw::c_int,
+        preset_names_array: *mut HAPI_StringHandle,
+        count: ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
 extern "C" {
     pub fn HAPI_GetObjectInfo(
         session: *const HAPI_Session,
@@ -2790,224 +2908,490 @@ extern "C" {
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_GetGroupNames(
+    pub fn HAPI_GetAttributeIntDataAsync(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
-        group_type: GroupType,
-        group_names_array: *mut HAPI_StringHandle,
-        group_count: ::std::os::raw::c_int,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *mut HAPI_AttributeInfo,
+        stride: ::std::os::raw::c_int,
+        data_array: *mut ::std::os::raw::c_int,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_GetGroupMembership(
+    pub fn HAPI_GetAttributeUInt8DataAsync(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
         part_id: HAPI_PartId,
-        group_type: GroupType,
-        group_name: *const ::std::os::raw::c_char,
-        membership_array_all_equal: *mut HAPI_Bool,
-        membership_array: *mut ::std::os::raw::c_int,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *mut HAPI_AttributeInfo,
+        stride: ::std::os::raw::c_int,
+        data_array: *mut HAPI_UInt8,
         start: ::std::os::raw::c_int,
         length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_GetGroupCountOnPackedInstancePart(
+    pub fn HAPI_GetAttributeInt8DataAsync(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
         part_id: HAPI_PartId,
-        pointGroupCount: *mut ::std::os::raw::c_int,
-        primitiveGroupCount: *mut ::std::os::raw::c_int,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *mut HAPI_AttributeInfo,
+        stride: ::std::os::raw::c_int,
+        data_array: *mut HAPI_Int8,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_GetGroupNamesOnPackedInstancePart(
+    pub fn HAPI_GetAttributeInt16DataAsync(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
         part_id: HAPI_PartId,
-        group_type: GroupType,
-        group_names_array: *mut HAPI_StringHandle,
-        group_count: ::std::os::raw::c_int,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *mut HAPI_AttributeInfo,
+        stride: ::std::os::raw::c_int,
+        data_array: *mut HAPI_Int16,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_GetGroupMembershipOnPackedInstancePart(
+    pub fn HAPI_GetAttributeInt64DataAsync(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
         part_id: HAPI_PartId,
-        group_type: GroupType,
-        group_name: *const ::std::os::raw::c_char,
-        membership_array_all_equal: *mut HAPI_Bool,
-        membership_array: *mut ::std::os::raw::c_int,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *mut HAPI_AttributeInfo,
+        stride: ::std::os::raw::c_int,
+        data_array: *mut HAPI_Int64,
         start: ::std::os::raw::c_int,
         length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_GetInstancedPartIds(
+    pub fn HAPI_GetAttributeFloatDataAsync(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
         part_id: HAPI_PartId,
-        instanced_parts_array: *mut HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *mut HAPI_AttributeInfo,
+        stride: ::std::os::raw::c_int,
+        data_array: *mut f32,
         start: ::std::os::raw::c_int,
         length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_GetInstancerPartTransforms(
+    pub fn HAPI_GetAttributeFloat64DataAsync(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
         part_id: HAPI_PartId,
-        rst_order: RSTOrder,
-        transforms_array: *mut HAPI_Transform,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *mut HAPI_AttributeInfo,
+        stride: ::std::os::raw::c_int,
+        data_array: *mut f64,
         start: ::std::os::raw::c_int,
         length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_SetPartInfo(
+    pub fn HAPI_GetAttributeStringDataAsync(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
         part_id: HAPI_PartId,
-        part_info: *const HAPI_PartInfo,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *mut HAPI_AttributeInfo,
+        data_array: *mut HAPI_StringHandle,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_SetFaceCounts(
+    pub fn HAPI_GetAttributeDictionaryDataAsync(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
         part_id: HAPI_PartId,
-        face_counts_array: *const ::std::os::raw::c_int,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *mut HAPI_AttributeInfo,
+        data_array: *mut HAPI_StringHandle,
         start: ::std::os::raw::c_int,
         length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_SetVertexList(
+    pub fn HAPI_GetAttributeIntArrayDataAsync(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
         part_id: HAPI_PartId,
-        vertex_list_array: *const ::std::os::raw::c_int,
+        attr_name: *const ::std::os::raw::c_char,
+        attr_info: *mut HAPI_AttributeInfo,
+        data_fixed_array: *mut ::std::os::raw::c_int,
+        data_fixed_length: ::std::os::raw::c_int,
+        sizes_fixed_array: *mut ::std::os::raw::c_int,
         start: ::std::os::raw::c_int,
-        length: ::std::os::raw::c_int,
+        sizes_fixed_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_AddAttribute(
+    pub fn HAPI_GetAttributeUInt8ArrayDataAsync(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
         part_id: HAPI_PartId,
-        name: *const ::std::os::raw::c_char,
-        attr_info: *const HAPI_AttributeInfo,
+        attr_name: *const ::std::os::raw::c_char,
+        attr_info: *mut HAPI_AttributeInfo,
+        data_fixed_array: *mut HAPI_UInt8,
+        data_fixed_length: ::std::os::raw::c_int,
+        sizes_fixed_array: *mut ::std::os::raw::c_int,
+        start: ::std::os::raw::c_int,
+        sizes_fixed_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_DeleteAttribute(
+    pub fn HAPI_GetAttributeInt8ArrayDataAsync(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
         part_id: HAPI_PartId,
-        name: *const ::std::os::raw::c_char,
-        attr_info: *const HAPI_AttributeInfo,
+        attr_name: *const ::std::os::raw::c_char,
+        attr_info: *mut HAPI_AttributeInfo,
+        data_fixed_array: *mut HAPI_Int8,
+        data_fixed_length: ::std::os::raw::c_int,
+        sizes_fixed_array: *mut ::std::os::raw::c_int,
+        start: ::std::os::raw::c_int,
+        sizes_fixed_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_SetAttributeIntData(
+    pub fn HAPI_GetAttributeInt16ArrayDataAsync(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
         part_id: HAPI_PartId,
-        name: *const ::std::os::raw::c_char,
-        attr_info: *const HAPI_AttributeInfo,
-        data_array: *const ::std::os::raw::c_int,
+        attr_name: *const ::std::os::raw::c_char,
+        attr_info: *mut HAPI_AttributeInfo,
+        data_fixed_array: *mut HAPI_Int16,
+        data_fixed_length: ::std::os::raw::c_int,
+        sizes_fixed_array: *mut ::std::os::raw::c_int,
         start: ::std::os::raw::c_int,
-        length: ::std::os::raw::c_int,
+        sizes_fixed_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_SetAttributeUInt8Data(
+    pub fn HAPI_GetAttributeInt64ArrayDataAsync(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
         part_id: HAPI_PartId,
-        name: *const ::std::os::raw::c_char,
-        attr_info: *const HAPI_AttributeInfo,
-        data_array: *const HAPI_UInt8,
+        attr_name: *const ::std::os::raw::c_char,
+        attr_info: *mut HAPI_AttributeInfo,
+        data_fixed_array: *mut HAPI_Int64,
+        data_fixed_length: ::std::os::raw::c_int,
+        sizes_fixed_array: *mut ::std::os::raw::c_int,
         start: ::std::os::raw::c_int,
-        length: ::std::os::raw::c_int,
+        sizes_fixed_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_SetAttributeInt8Data(
+    pub fn HAPI_GetAttributeFloatArrayDataAsync(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
         part_id: HAPI_PartId,
-        name: *const ::std::os::raw::c_char,
-        attr_info: *const HAPI_AttributeInfo,
-        data_array: *const HAPI_Int8,
+        attr_name: *const ::std::os::raw::c_char,
+        attr_info: *mut HAPI_AttributeInfo,
+        data_fixed_array: *mut f32,
+        data_fixed_length: ::std::os::raw::c_int,
+        sizes_fixed_array: *mut ::std::os::raw::c_int,
         start: ::std::os::raw::c_int,
-        length: ::std::os::raw::c_int,
+        sizes_fixed_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_SetAttributeInt16Data(
+    pub fn HAPI_GetAttributeFloat64ArrayDataAsync(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
         part_id: HAPI_PartId,
-        name: *const ::std::os::raw::c_char,
-        attr_info: *const HAPI_AttributeInfo,
-        data_array: *const HAPI_Int16,
+        attr_name: *const ::std::os::raw::c_char,
+        attr_info: *mut HAPI_AttributeInfo,
+        data_fixed_array: *mut f64,
+        data_fixed_length: ::std::os::raw::c_int,
+        sizes_fixed_array: *mut ::std::os::raw::c_int,
         start: ::std::os::raw::c_int,
-        length: ::std::os::raw::c_int,
+        sizes_fixed_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_SetAttributeInt64Data(
+    pub fn HAPI_GetAttributeStringArrayDataAsync(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
         part_id: HAPI_PartId,
-        name: *const ::std::os::raw::c_char,
-        attr_info: *const HAPI_AttributeInfo,
-        data_array: *const HAPI_Int64,
+        attr_name: *const ::std::os::raw::c_char,
+        attr_info: *mut HAPI_AttributeInfo,
+        data_fixed_array: *mut HAPI_StringHandle,
+        data_fixed_length: ::std::os::raw::c_int,
+        sizes_fixed_array: *mut ::std::os::raw::c_int,
         start: ::std::os::raw::c_int,
-        length: ::std::os::raw::c_int,
+        sizes_fixed_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_SetAttributeFloatData(
+    pub fn HAPI_GetAttributeDictionaryArrayDataAsync(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
         part_id: HAPI_PartId,
-        name: *const ::std::os::raw::c_char,
-        attr_info: *const HAPI_AttributeInfo,
-        data_array: *const f32,
+        attr_name: *const ::std::os::raw::c_char,
+        attr_info: *mut HAPI_AttributeInfo,
+        data_fixed_array: *mut HAPI_StringHandle,
+        data_fixed_length: ::std::os::raw::c_int,
+        sizes_fixed_array: *mut ::std::os::raw::c_int,
         start: ::std::os::raw::c_int,
-        length: ::std::os::raw::c_int,
+        sizes_fixed_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_SetAttributeFloat64Data(
+    pub fn HAPI_GetJobStatus(
         session: *const HAPI_Session,
-        node_id: HAPI_NodeId,
-        part_id: HAPI_PartId,
-        name: *const ::std::os::raw::c_char,
-        attr_info: *const HAPI_AttributeInfo,
-        data_array: *const f64,
-        start: ::std::os::raw::c_int,
-        length: ::std::os::raw::c_int,
+        job_id: ::std::os::raw::c_int,
+        job_status: *mut JobStatus,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_SetAttributeStringData(
+    pub fn HAPI_GetGroupNames(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
-        part_id: HAPI_PartId,
-        name: *const ::std::os::raw::c_char,
-        attr_info: *const HAPI_AttributeInfo,
-        data_array: *mut *const ::std::os::raw::c_char,
-        start: ::std::os::raw::c_int,
-        length: ::std::os::raw::c_int,
+        group_type: GroupType,
+        group_names_array: *mut HAPI_StringHandle,
+        group_count: ::std::os::raw::c_int,
     ) -> HapiResult;
 }
 extern "C" {
-    pub fn HAPI_SetAttributeIndexedStringData(
+    pub fn HAPI_GetGroupMembership(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        group_type: GroupType,
+        group_name: *const ::std::os::raw::c_char,
+        membership_array_all_equal: *mut HAPI_Bool,
+        membership_array: *mut ::std::os::raw::c_int,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_GetGroupCountOnPackedInstancePart(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        pointGroupCount: *mut ::std::os::raw::c_int,
+        primitiveGroupCount: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_GetGroupNamesOnPackedInstancePart(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        group_type: GroupType,
+        group_names_array: *mut HAPI_StringHandle,
+        group_count: ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_GetGroupMembershipOnPackedInstancePart(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        group_type: GroupType,
+        group_name: *const ::std::os::raw::c_char,
+        membership_array_all_equal: *mut HAPI_Bool,
+        membership_array: *mut ::std::os::raw::c_int,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_GetInstancedPartIds(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        instanced_parts_array: *mut HAPI_PartId,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_GetInstancerPartTransforms(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        rst_order: RSTOrder,
+        transforms_array: *mut HAPI_Transform,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetPartInfo(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        part_info: *const HAPI_PartInfo,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetFaceCounts(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        face_counts_array: *const ::std::os::raw::c_int,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetVertexList(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        vertex_list_array: *const ::std::os::raw::c_int,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_AddAttribute(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_DeleteAttribute(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeIntData(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const ::std::os::raw::c_int,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeUInt8Data(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const HAPI_UInt8,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeInt8Data(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const HAPI_Int8,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeInt16Data(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const HAPI_Int16,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeInt64Data(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const HAPI_Int64,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeFloatData(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const f32,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeFloat64Data(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const f64,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeStringData(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *mut *const ::std::os::raw::c_char,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeIndexedStringData(
         session: *const HAPI_Session,
         node_id: HAPI_NodeId,
         part_id: HAPI_PartId,
@@ -3262,6 +3646,385 @@ extern "C" {
         sizes_fixed_length: ::std::os::raw::c_int,
     ) -> HapiResult;
 }
+extern "C" {
+    pub fn HAPI_SetAttributeIntDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const ::std::os::raw::c_int,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeUInt8DataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const HAPI_UInt8,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeInt8DataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const HAPI_Int8,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeInt16DataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const HAPI_Int16,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeInt64DataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const HAPI_Int64,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeFloatDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const f32,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeFloat64DataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const f64,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeStringDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *mut *const ::std::os::raw::c_char,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeIndexedStringDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        string_array: *mut *const ::std::os::raw::c_char,
+        string_count: ::std::os::raw::c_int,
+        indices_array: *const ::std::os::raw::c_int,
+        indices_start: ::std::os::raw::c_int,
+        indices_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeStringUniqueDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const ::std::os::raw::c_char,
+        data_length: ::std::os::raw::c_int,
+        start_index: ::std::os::raw::c_int,
+        num_indices: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeIntUniqueDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const ::std::os::raw::c_int,
+        data_length: ::std::os::raw::c_int,
+        start_index: ::std::os::raw::c_int,
+        num_indices: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeUInt8UniqueDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const HAPI_UInt8,
+        data_length: ::std::os::raw::c_int,
+        start_index: ::std::os::raw::c_int,
+        num_indices: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeInt8UniqueDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const HAPI_Int8,
+        data_length: ::std::os::raw::c_int,
+        start_index: ::std::os::raw::c_int,
+        num_indices: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeInt16UniqueDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const HAPI_Int16,
+        data_length: ::std::os::raw::c_int,
+        start_index: ::std::os::raw::c_int,
+        num_indices: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeInt64UniqueDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const HAPI_Int64,
+        data_length: ::std::os::raw::c_int,
+        start_index: ::std::os::raw::c_int,
+        num_indices: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeFloatUniqueDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const f32,
+        data_length: ::std::os::raw::c_int,
+        start_index: ::std::os::raw::c_int,
+        num_indices: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeFloat64UniqueDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *const f64,
+        data_length: ::std::os::raw::c_int,
+        start_index: ::std::os::raw::c_int,
+        num_indices: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeDictionaryDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_array: *mut *const ::std::os::raw::c_char,
+        start: ::std::os::raw::c_int,
+        length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeIntArrayDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_fixed_array: *const ::std::os::raw::c_int,
+        data_fixed_length: ::std::os::raw::c_int,
+        sizes_fixed_array: *const ::std::os::raw::c_int,
+        start: ::std::os::raw::c_int,
+        sizes_fixed_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeUInt8ArrayDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_fixed_array: *const HAPI_UInt8,
+        data_fixed_length: ::std::os::raw::c_int,
+        sizes_fixed_array: *const ::std::os::raw::c_int,
+        start: ::std::os::raw::c_int,
+        sizes_fixed_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeInt8ArrayDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_fixed_array: *const HAPI_Int8,
+        data_fixed_length: ::std::os::raw::c_int,
+        sizes_fixed_array: *const ::std::os::raw::c_int,
+        start: ::std::os::raw::c_int,
+        sizes_fixed_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeInt16ArrayDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_fixed_array: *const HAPI_Int16,
+        data_fixed_length: ::std::os::raw::c_int,
+        sizes_fixed_array: *const ::std::os::raw::c_int,
+        start: ::std::os::raw::c_int,
+        sizes_fixed_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeInt64ArrayDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_fixed_array: *const HAPI_Int64,
+        data_fixed_length: ::std::os::raw::c_int,
+        sizes_fixed_array: *const ::std::os::raw::c_int,
+        start: ::std::os::raw::c_int,
+        sizes_fixed_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeFloatArrayDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_fixed_array: *const f32,
+        data_fixed_length: ::std::os::raw::c_int,
+        sizes_fixed_array: *const ::std::os::raw::c_int,
+        start: ::std::os::raw::c_int,
+        sizes_fixed_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeFloat64ArrayDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_fixed_array: *const f64,
+        data_fixed_length: ::std::os::raw::c_int,
+        sizes_fixed_array: *const ::std::os::raw::c_int,
+        start: ::std::os::raw::c_int,
+        sizes_fixed_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeStringArrayDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_fixed_array: *mut *const ::std::os::raw::c_char,
+        data_fixed_length: ::std::os::raw::c_int,
+        sizes_fixed_array: *const ::std::os::raw::c_int,
+        start: ::std::os::raw::c_int,
+        sizes_fixed_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
+extern "C" {
+    pub fn HAPI_SetAttributeDictionaryArrayDataAsync(
+        session: *const HAPI_Session,
+        node_id: HAPI_NodeId,
+        part_id: HAPI_PartId,
+        name: *const ::std::os::raw::c_char,
+        attr_info: *const HAPI_AttributeInfo,
+        data_fixed_array: *mut *const ::std::os::raw::c_char,
+        data_fixed_length: ::std::os::raw::c_int,
+        sizes_fixed_array: *const ::std::os::raw::c_int,
+        start: ::std::os::raw::c_int,
+        sizes_fixed_length: ::std::os::raw::c_int,
+        job_id: *mut ::std::os::raw::c_int,
+    ) -> HapiResult;
+}
 extern "C" {
     pub fn HAPI_AddGroup(
         session: *const HAPI_Session,
diff --git a/src/ffi/functions.rs b/src/ffi/functions.rs
index b3d191f..79b569c 100644
--- a/src/ffi/functions.rs
+++ b/src/ffi/functions.rs
@@ -8,6 +8,7 @@ use std::vec;
 
 use raw::HAPI_PDG_EventInfo;
 
+use super::raw;
 use crate::ffi::bindings::HAPI_StringHandle;
 use crate::ffi::raw::{HAPI_InputCurveInfo, HAPI_NodeId, HAPI_ParmId, RSTOrder};
 use crate::ffi::{CookOptions, CurveInfo, GeoInfo, ImageInfo, InputCurveInfo, PartInfo, Viewport};
@@ -19,8 +20,6 @@ use crate::{
     stringhandle::{StringArray, StringHandle},
 };
 
-use super::raw;
-
 macro_rules! uninit {
     () => {
         MaybeUninit::uninit()
@@ -695,8 +694,8 @@ pub fn get_string(session: &Session, handle: i32, length: i32) -> Result<Vec<u8>
     unsafe {
         raw::HAPI_GetString(session.ptr(), handle, buffer.as_mut_ptr() as *mut _, length)
             .check_err(session, || "Calling HAPI_GetString")?;
-        buffer.truncate(length as usize - 1);
     }
+    buffer.truncate(length as usize - 1);
     Ok(buffer)
 }
 
@@ -771,10 +770,10 @@ pub fn set_cache_property(
     }
 }
 
-pub fn create_inprocess_session() -> Result<raw::HAPI_Session> {
+pub fn create_inprocess_session(info: &raw::HAPI_SessionInfo) -> Result<raw::HAPI_Session> {
     let mut ses = uninit!();
     unsafe {
-        match raw::HAPI_CreateInProcessSession(ses.as_mut_ptr()) {
+        match raw::HAPI_CreateInProcessSession(ses.as_mut_ptr(), info as *const _) {
             err @ raw::HapiResult::Failure => Err(HapiError::new(
                 Kind::Hapi(err),
                 None,
@@ -873,21 +872,72 @@ pub fn start_thrift_socket_server(
     }
 }
 
-pub fn new_thrift_piped_session(path: &CStr) -> Result<raw::HAPI_Session> {
+pub fn start_thrift_shared_memory_server(
+    mem_name: &CStr,
+    options: &raw::HAPI_ThriftServerOptions,
+    log_file: Option<&CStr>,
+) -> Result<u32> {
+    let mut pid = uninit!();
+    unsafe {
+        raw::HAPI_StartThriftSharedMemoryServer(
+            options as *const _,
+            mem_name.as_ptr(),
+            pid.as_mut_ptr(),
+            log_file.map_or(null(), CStr::as_ptr),
+        )
+        .error_message("Calling HAPI_StartThriftSharedMemoryServer")?;
+        Ok(pid.assume_init())
+    }
+}
+
+pub fn new_thrift_piped_session(
+    path: &CStr,
+    info: &raw::HAPI_SessionInfo,
+) -> Result<raw::HAPI_Session> {
     let mut handle = uninit!();
     let session = unsafe {
-        raw::HAPI_CreateThriftNamedPipeSession(handle.as_mut_ptr(), path.as_ptr())
-            .error_message("Calling HAPI_CreateThriftNamedPipeSession: failed")?;
+        raw::HAPI_CreateThriftNamedPipeSession(
+            handle.as_mut_ptr(),
+            path.as_ptr(),
+            info as *const _,
+        )
+        .error_message("Calling HAPI_CreateThriftNamedPipeSession: failed")?;
+        handle.assume_init()
+    };
+    Ok(session)
+}
+
+pub fn new_thrift_socket_session(
+    port: i32,
+    host: &CStr,
+    info: &raw::HAPI_SessionInfo,
+) -> Result<raw::HAPI_Session> {
+    let mut handle = uninit!();
+    let session = unsafe {
+        raw::HAPI_CreateThriftSocketSession(
+            handle.as_mut_ptr(),
+            host.as_ptr(),
+            port,
+            info as *const _,
+        )
+        .error_message("Calling HAPI_CreateThriftSocketSession: failed")?;
         handle.assume_init()
     };
     Ok(session)
 }
 
-pub fn new_thrift_socket_session(port: i32, host: &CStr) -> Result<raw::HAPI_Session> {
+pub fn new_thrift_shared_memory_session(
+    mem_name: &CStr,
+    info: &raw::HAPI_SessionInfo,
+) -> Result<raw::HAPI_Session> {
     let mut handle = uninit!();
     let session = unsafe {
-        raw::HAPI_CreateThriftSocketSession(handle.as_mut_ptr(), host.as_ptr(), port)
-            .error_message("Calling HAPI_CreateThriftSocketSession: failed")?;
+        raw::HAPI_CreateThriftSharedMemorySession(
+            handle.as_mut_ptr(),
+            mem_name.as_ptr(),
+            info as *const _,
+        )
+        .error_message("Calling HAPI_CreateThriftSharedMemorySession")?;
         handle.assume_init()
     };
     Ok(session)
@@ -1085,20 +1135,38 @@ pub fn create_node(
     }
 }
 
-pub fn create_input_node(session: &Session, name: &CStr) -> Result<raw::HAPI_NodeId> {
+pub fn create_input_node(
+    session: &Session,
+    name: &CStr,
+    parent: Option<NodeHandle>,
+) -> Result<raw::HAPI_NodeId> {
     let mut id = uninit!();
     unsafe {
-        raw::HAPI_CreateInputNode(session.ptr(), id.as_mut_ptr(), name.as_ptr())
-            .check_err(session, || "Calling HAPI_CreateInputNode")?;
+        raw::HAPI_CreateInputNode(
+            session.ptr(),
+            parent.unwrap_or_default().0,
+            id.as_mut_ptr(),
+            name.as_ptr(),
+        )
+        .check_err(session, || "Calling HAPI_CreateInputNode")?;
         Ok(id.assume_init())
     }
 }
 
-pub fn create_input_curve_node(session: &Session, name: &CStr) -> Result<raw::HAPI_NodeId> {
+pub fn create_input_curve_node(
+    session: &Session,
+    name: &CStr,
+    parent: Option<NodeHandle>,
+) -> Result<raw::HAPI_NodeId> {
     let mut id = uninit!();
     unsafe {
-        raw::HAPI_CreateInputCurveNode(session.ptr(), id.as_mut_ptr(), name.as_ptr())
-            .check_err(session, || "Calling HAPI_CreateInputCurveNode")?;
+        raw::HAPI_CreateInputCurveNode(
+            session.ptr(),
+            parent.unwrap_or_default().0,
+            id.as_mut_ptr(),
+            name.as_ptr(),
+        )
+        .check_err(session, || "Calling HAPI_CreateInputCurveNode")?;
         Ok(id.assume_init())
     }
 }
@@ -1469,6 +1537,7 @@ pub fn get_output_geo_count(node: &HoudiniNode) -> Result<i32> {
 
 pub fn get_output_names(node: &HoudiniNode) -> Result<Vec<String>> {
     let mut names = Vec::new();
+    let _ = node.session.lock();
     for output_idx in 0..node.info.output_count() {
         let mut handle = uninit!();
         unsafe {
@@ -1506,7 +1575,7 @@ pub fn get_output_geos(node: &HoudiniNode) -> Result<Vec<raw::HAPI_GeoInfo>> {
 pub fn get_group_count_by_type(geo_info: &GeoInfo, group_type: raw::GroupType) -> i32 {
     // SAFETY: Not sure why but many HAPI functions take a mutable pointer where they
     // actually shouldn't?
-    let ptr = (&geo_info.inner as *const _) as *mut raw::HAPI_GeoInfo;
+    let ptr = (&geo_info.0 as *const _) as *mut raw::HAPI_GeoInfo;
     unsafe { raw::HAPI_GeoInfo_GetGroupCountByType(ptr, group_type) }
 }
 
@@ -1517,7 +1586,7 @@ pub fn get_element_count_by_attribute_owner(
     unsafe {
         // SAFETY: Not sure why but many HAPI functions take a mutable pointer where they
         // actually shouldn't?
-        let ptr = (&part.inner as *const _) as *mut raw::HAPI_PartInfo;
+        let ptr = (&part.0 as *const _) as *mut raw::HAPI_PartInfo;
         Ok(raw::HAPI_PartInfo_GetElementCountByAttributeOwner(
             ptr, owner,
         ))
@@ -1528,7 +1597,7 @@ pub fn get_attribute_count_by_owner(part: &PartInfo, owner: raw::AttributeOwner)
     unsafe {
         // SAFETY: Not sure why but many HAPI functions take a mutable pointer where they
         // actually shouldn't?
-        let ptr = (&part.inner as *const _) as *mut raw::HAPI_PartInfo;
+        let ptr = (&part.0 as *const _) as *mut raw::HAPI_PartInfo;
         Ok(raw::HAPI_PartInfo_GetAttributeCountByOwner(ptr, owner))
     }
 }
@@ -1857,21 +1926,52 @@ pub fn create_heightfield_input_volume(
     Ok(NodeHandle(volume_node))
 }
 
-pub fn set_part_info(node: &HoudiniNode, info: &PartInfo) -> Result<()> {
+pub fn get_heightfield_data(node: &HoudiniNode, part_id: i32, length: i32) -> Result<Vec<f32>> {
+    unsafe {
+        let mut buffer = vec![0f32; length as usize];
+        raw::HAPI_GetHeightFieldData(
+            node.session.ptr(),
+            node.handle.0,
+            part_id,
+            buffer.as_mut_ptr(),
+            0,
+            length,
+        )
+        .check_err(&node.session, || "Calling HAPI_GetHeightFieldData")?;
+        Ok(buffer)
+    }
+}
+
+pub fn set_heightfield_data(
+    node: &HoudiniNode,
+    part_id: i32,
+    name: &CStr,
+    values: &[f32],
+) -> Result<()> {
     unsafe {
-        super::raw::HAPI_SetPartInfo(
+        raw::HAPI_SetHeightFieldData(
             node.session.ptr(),
             node.handle.0,
-            info.part_id(),
-            &info.inner,
+            part_id,
+            name.as_ptr(),
+            values.as_ptr(),
+            0,
+            values.len() as i32,
         )
-        .check_err(&node.session, || "Calling HAPI_SetPartInfo")
+        .check_err(&node.session, || "Calling HAPI_SetHeightFieldData")
+    }
+}
+
+pub fn set_part_info(node: &HoudiniNode, info: &PartInfo) -> Result<()> {
+    unsafe {
+        raw::HAPI_SetPartInfo(node.session.ptr(), node.handle.0, info.part_id(), &info.0)
+            .check_err(&node.session, || "Calling HAPI_SetPartInfo")
     }
 }
 
 pub fn set_curve_info(node: &HoudiniNode, part_id: i32, info: &CurveInfo) -> Result<()> {
     unsafe {
-        super::raw::HAPI_SetCurveInfo(node.session.ptr(), node.handle.0, part_id, &info.inner)
+        super::raw::HAPI_SetCurveInfo(node.session.ptr(), node.handle.0, part_id, &info.0)
             .check_err(&node.session, || "Calling HAPI_SetCurveInfo")
     }
 }
@@ -2284,7 +2384,7 @@ pub fn get_face_counts(
 pub fn get_element_count_by_group(part_info: &PartInfo, group_type: raw::GroupType) -> i32 {
     // SAFETY: Not sure why but many HAPI functions take a mutable pointer where they
     // actually shouldn't?
-    let ptr = (&part_info.inner as *const raw::HAPI_PartInfo) as *mut raw::HAPI_PartInfo;
+    let ptr = (&part_info.0 as *const raw::HAPI_PartInfo) as *mut raw::HAPI_PartInfo;
     unsafe { raw::HAPI_PartInfo_GetElementCountByGroupType(ptr, group_type) }
 }
 
@@ -2734,6 +2834,33 @@ pub fn set_preset(
     }
 }
 
+pub fn get_preset_names(session: &Session, preset_bytes: &[u8]) -> Result<Vec<StringHandle>> {
+    let _lock = session.lock();
+    unsafe {
+        let mut count = -1;
+        raw::HAPI_GetPresetCount(
+            session.ptr(),
+            preset_bytes.as_ptr() as *const i8,
+            preset_bytes.len() as i32,
+            &mut count as *mut _,
+        )
+        .check_err(session, || "Calling HAPI_GetPresetCount")?;
+        if count < 1 {
+            return Ok(vec![]);
+        }
+        let mut handles = vec![StringHandle(0); count as usize];
+        raw::HAPI_GetPresetNames(
+            session.ptr(),
+            preset_bytes.as_ptr() as *const i8,
+            preset_bytes.len() as i32,
+            handles.as_mut_ptr() as *mut HAPI_StringHandle,
+            count,
+        )
+        .check_err(session, || "Calling HAPI_GetPresetNames")?;
+        Ok(handles)
+    }
+}
+
 pub fn get_material_info(session: &Session, node: NodeHandle) -> Result<raw::HAPI_MaterialInfo> {
     unsafe {
         let mut mat = uninit!();
@@ -3085,9 +3212,12 @@ pub fn cook_pdg(
     all_outputs: bool,
 ) -> Result<()> {
     unsafe {
+        let _fn_name;
         let cook_fn = if all_outputs {
+            _fn_name = "HAPI_CookPDGAllOutputs";
             raw::HAPI_CookPDGAllOutputs
         } else {
+            _fn_name = "HAPI_CookPDG";
             raw::HAPI_CookPDG
         };
         cook_fn(
@@ -3096,7 +3226,9 @@ pub fn cook_pdg(
             generate_only as i32,
             blocking as i32,
         )
-        .check_err(session, || "Calling HAPI_CookPDG")
+        .check_err(session, || {
+            std::borrow::Cow::Owned(format!("Calling {}", _fn_name))
+        })
     }
 }
 
@@ -3209,23 +3341,20 @@ pub fn get_workitem_result(
     workitem_id: i32,
     count: i32,
 ) -> Result<Vec<raw::HAPI_PDG_WorkitemResultInfo>> {
-    let _info = raw::HAPI_PDG_WorkItemOutputFile {
-        filePathSH: -1,
-        tagSH: -1,
-        hash: -1,
-    };
-    let mut infos = vec![_info; count as usize];
+    let mut infos =
+        Vec::<MaybeUninit<raw::HAPI_PDG_WorkItemOutputFile>>::with_capacity(count as usize);
     unsafe {
         raw::HAPI_GetWorkItemOutputFiles(
             session.ptr(),
             pdg_node.0,
             workitem_id,
-            infos.as_mut_ptr(),
+            infos.as_mut_ptr() as *mut raw::HAPI_PDG_WorkItemOutputFile,
             count,
         )
         .check_err(session, || "Calling HAPI_GetWorkItemOutputFiles")?;
+        infos.set_len(count as usize);
+        Ok(infos.into_iter().map(|mi| mi.assume_init()).collect())
     }
-    Ok(infos)
 }
 
 pub fn get_pdg_workitems(session: &Session, pdg_node: NodeHandle) -> Result<Vec<i32>> {
@@ -3234,7 +3363,9 @@ pub fn get_pdg_workitems(session: &Session, pdg_node: NodeHandle) -> Result<Vec<
         let mut num = -1;
         raw::HAPI_GetNumWorkitems(session.ptr(), pdg_node.0, &mut num as *mut i32)
             .check_err(session, || "Calling HAPI_GetNumWorkitems")?;
-        debug_assert!(num > 0);
+        if num <= 0 {
+            return Ok(vec![]);
+        }
         let mut array = vec![-1; num as usize];
         raw::HAPI_GetWorkitems(session.ptr(), pdg_node.0, array.as_mut_ptr(), num)
             .check_err(session, || "Calling HAPI_GetWorkitems")?;
@@ -3524,3 +3655,68 @@ pub fn python_thread_interpreter_lock(session: &Session, lock: bool) -> Result<(
             .check_err(session, || "Calling HAPI_PythonThreadInterpreterLock")
     }
 }
+
+pub fn set_compositor_options(
+    session: &Session,
+    options: &raw::HAPI_CompositorOptions,
+) -> Result<()> {
+    unsafe {
+        raw::HAPI_SetCompositorOptions(session.ptr(), options as *const _)
+            .check_err(&session, || "Calling HAPI_SetCompositorOptions")
+    }
+}
+
+pub fn get_compositor_options(session: &Session) -> Result<raw::HAPI_CompositorOptions> {
+    unsafe {
+        let mut opts = raw::HAPI_CompositorOptions_Create();
+        raw::HAPI_GetCompositorOptions(session.ptr(), &mut opts as *mut _)
+            .check_err(&session, || "Calling HAPI_GetCompositorOptions")?;
+        Ok(opts)
+    }
+}
+
+pub fn get_volume_visual_info(
+    node: &HoudiniNode,
+    part_id: i32,
+) -> Result<raw::HAPI_VolumeVisualInfo> {
+    unsafe {
+        let mut info = uninit!();
+        raw::HAPI_GetVolumeVisualInfo(
+            node.session.ptr(),
+            node.handle.0,
+            part_id,
+            info.as_mut_ptr(),
+        )
+        .check_err(&node.session, || "Calling HAPI_GetVolumeVisualInfo")?;
+        Ok(info.assume_init())
+    }
+}
+
+pub fn start_performance_monitor_profile(session: &Session, title: &CStr) -> Result<i32> {
+    unsafe {
+        let mut id = -1;
+        raw::HAPI_StartPerformanceMonitorProfile(session.ptr(), title.as_ptr(), &mut id)
+            .check_err(&session, || "Calling HAPI_StartPerformanceMonitorProfile")?;
+        Ok(id)
+    }
+}
+
+pub fn stop_performance_monitor_profile(
+    session: &Session,
+    profile_id: i32,
+    file_path: &CStr,
+) -> Result<()> {
+    unsafe {
+        raw::HAPI_StopPerformanceMonitorProfile(session.ptr(), profile_id, file_path.as_ptr())
+            .check_err(&session, || "Calling HAPI_StopPerformanceMonitorProfile")
+    }
+}
+
+pub fn get_job_status(session: &Session, job_id: i32) -> Result<raw::JobStatus> {
+    unsafe {
+        let mut job_status = uninit!();
+        raw::HAPI_GetJobStatus(session.ptr(), job_id, job_status.as_mut_ptr())
+            .check_err(&session, || "Calling HAPI_GetJobStatus")?;
+        Ok(job_status.assume_init())
+    }
+}
diff --git a/src/ffi/mod.rs b/src/ffi/mod.rs
index 8d05070..a51fd13 100644
--- a/src/ffi/mod.rs
+++ b/src/ffi/mod.rs
@@ -20,7 +20,7 @@ pub mod enums {
     pub use super::bindings::{
         AttributeOwner, AttributeTypeInfo, CacheProperty, ChoiceListType, CurveOrders, CurveType,
         EnvIntType, GeoType, GroupType, HapiResult, HeightFieldSampling, ImageDataFormat,
-        ImagePacking, InputType, License, PackedPrimInstancingMode, ParmType, PartType,
+        ImagePacking, InputType, JobStatus, License, PackedPrimInstancingMode, ParmType, PartType,
         PdgEventType, PdgState, PdgWorkItemState, Permissions, PresetType, PrmScriptType, RSTOrder,
         RampType, SessionEnvIntType, SessionType, State, StatusType, StatusVerbosity, StorageType,
         TransformComponent, VolumeType, VolumeVisualType, XYZOrder,
diff --git a/src/ffi/structs.rs b/src/ffi/structs.rs
index 1ebed79..0e0a926 100644
--- a/src/ffi/structs.rs
+++ b/src/ffi/structs.rs
@@ -16,7 +16,7 @@ macro_rules! get {
     ($method:ident->$field:ident->bool) => {
         #[inline]
         pub fn $method(&self) -> bool {
-            self.inner.$field == 1
+            self.0.$field == 1
         }
     };
 
@@ -24,7 +24,7 @@ macro_rules! get {
     ($method:ident->$field:ident->[handle: $hdl:ident]) => {
         #[inline]
         pub fn $method(&self) -> $hdl {
-            $hdl(self.inner.$field)
+            $hdl(self.0.$field)
         }
     };
 
@@ -39,7 +39,7 @@ macro_rules! get {
         #[inline]
         pub fn $method(&self) -> Result<String> {
             use crate::stringhandle::StringHandle;
-            crate::stringhandle::get_string(StringHandle(self.inner.$field), &self.session)
+            crate::stringhandle::get_string(StringHandle(self.0.$field), &self.1)
         }
     };
 
@@ -47,7 +47,7 @@ macro_rules! get {
         #[inline]
         pub fn $method(&self, session: &Session) -> Result<String> {
             use crate::stringhandle::StringHandle;
-            crate::stringhandle::get_string(StringHandle(self.inner.$field), session)
+            crate::stringhandle::get_string(StringHandle(self.0.$field), session)
         }
     };
 
@@ -55,14 +55,14 @@ macro_rules! get {
         #[inline]
         pub fn $method(&self) -> Result<CString> {
             use crate::stringhandle::StringHandle;
-            crate::stringhandle::get_cstring(StringHandle(self.inner.$field), &self.session)
+            crate::stringhandle::get_cstring(StringHandle(self.0.$field), &self.1)
         }
     };
 
     ($method:ident->$field:ident->$tp:ty) => {
         #[inline]
         pub fn $method(&self) -> $tp {
-            self.inner.$field
+            self.0.$field
         }
     };
 
@@ -85,28 +85,28 @@ macro_rules! get {
 //
 // Special case for string handles:
 // [get+session] name->name->[ValueType]
-// fn get_name(&self, session: &Session) -> Result<String> { session.get_string(self.inner.name) }
+// fn get_name(&self, session: &Session) -> Result<String> { session.get_string(self.0.name) }
 //
 
 macro_rules! wrap {
     (_with_ $method:ident->$field:ident->bool) => {
         paste!{
-            pub fn [<with_ $method>](mut self, val: bool) -> Self {self.inner.$field = val as i8; self}
+            pub fn [<with_ $method>](mut self, val: bool) -> Self {self.0.$field = val as i8; self}
         }
     };
     (_with_ $method:ident->$field:ident->$tp:ty) => {
         paste!{
-            pub fn [<with_ $method>](mut self, val: $tp) -> Self {self.inner.$field = val; self}
+            pub fn [<with_ $method>](mut self, val: $tp) -> Self {self.0.$field = val; self}
         }
     };
     (_set_ $method:ident->$field:ident->bool) => {
         paste!{
-            pub fn [<set_ $method>](&mut self, val: bool)  {self.inner.$field = val as i8}
+            pub fn [<set_ $method>](&mut self, val: bool)  {self.0.$field = val as i8}
         }
     };
     (_set_ $method:ident->$field:ident->$tp:ty) => {
         paste!{
-            pub fn [<set_ $method>](&mut self, val: $tp)  {self.inner.$field = val}
+            pub fn [<set_ $method>](&mut self, val: $tp)  {self.0.$field = val}
         }
     };
 
@@ -137,20 +137,11 @@ macro_rules! wrap {
         $(wrap!{_with_ $method->$field->$tp})*
     };
 
-    (New $object:ident [$create_func:path=>$ffi_tp:ty]; $($rest:tt)*) => {
-        impl $object {
-            pub fn new(session: Session) -> Self {
-                Self{inner:  $create_func() , session}
-            }
-        }
-        wrap!{_impl_methods_ $object $ffi_tp $($rest)*}
-    };
-
     (Default $object:ident [$create_func:path=>$ffi_tp:ty]; $($rest:tt)*) => {
         impl Default for $object {
             fn default() -> Self {
                 #[allow(unused_unsafe)]
-                Self{inner: unsafe { $create_func() }}
+                Self(unsafe { $create_func() })
             }
         }
         wrap!{_impl_methods_ $object $ffi_tp $($rest)*}
@@ -169,25 +160,59 @@ macro_rules! wrap {
 
             #[inline]
             pub fn ptr(&self) -> *const $ffi_tp {
-                &self.inner as *const _
+                &self.0 as *const _
             }
         }
     };
 }
 
-/// Menu parameter label and value
+/// Configurations for sessions
+#[derive(Clone, Debug)]
+pub struct SessionInfo(pub(crate) HAPI_SessionInfo);
+
+wrap! {
+    Default SessionInfo [HAPI_SessionInfo_Create => HAPI_SessionInfo];
+    [get] connection_count->connectionCount->[i32];
+    [get|set|with] port_type->portType->[TcpPortType];
+    [get] min_port->minPort->[i32];
+    [get] max_port->maxPort->[i32];
+    [get] ports->ports->[[i32;128usize]];
+    [get|set|with] shared_memory_buffer_type->sharedMemoryBufferType->[ThriftSharedMemoryBufferType];
+    [get|set|with] shared_memory_buffer_size->sharedMemoryBufferSize->[i64];
+}
+
+/// Options to configure a Thrift server being started from HARC.
 #[derive(Clone)]
-pub struct ParmChoiceInfo {
-    pub(crate) inner: HAPI_ParmChoiceInfo,
-    pub(crate) session: Session,
+pub struct ThriftServerOptions(pub(crate) HAPI_ThriftServerOptions);
+
+wrap! {
+    Default ThriftServerOptions [HAPI_ThriftServerOptions_Create => HAPI_ThriftServerOptions];
+    [get|set|with] auto_close->autoClose->[bool];
+    [get|set|with] timeout_ms->timeoutMs->[f32];
+    [get|set|with] verbosity->verbosity->[StatusVerbosity];
+    [get|set|with] shared_memory_buffer_type->sharedMemoryBufferType->[ThriftSharedMemoryBufferType];
+    [get|set|with] shared_memory_buffer_size->sharedMemoryBufferSize->[i64];
 }
 
+#[derive(Clone)]
+pub struct CompositorOptions(pub(crate) HAPI_CompositorOptions);
+
+wrap! {
+    Default CompositorOptions [HAPI_CompositorOptions_Create => HAPI_CompositorOptions];
+    [get|set] max_resolution_x->maximumResolutionX->[i32];
+    [get|set] max_resolution_y->maximumResolutionY->[i32];
+}
+
+/// Menu parameter label and value
+#[derive(Clone)]
+pub struct ParmChoiceInfo(pub(crate) HAPI_ParmChoiceInfo, pub(crate) Session);
+
 impl std::fmt::Debug for ParmChoiceInfo {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         use std::borrow::Cow;
 
         let get_str = |h: i32| -> Cow<str> {
-            match crate::stringhandle::get_string_bytes(StringHandle(h), &self.session) {
+            match crate::stringhandle::get_string_bytes(StringHandle(h), &self.1) {
                 // SAFETY: Don't care about utf in Debug
                 Ok(bytes) => unsafe { Cow::Owned(String::from_utf8_unchecked(bytes)) },
                 Err(_) => Cow::Borrowed("!!! Could not retrieve string"),
@@ -195,8 +220,8 @@ impl std::fmt::Debug for ParmChoiceInfo {
         };
 
         f.debug_struct("ParmChoiceInfo")
-            .field("label", &get_str(self.inner.labelSH))
-            .field("value", &get_str(self.inner.valueSH))
+            .field("label", &get_str(self.0.labelSH))
+            .field("value", &get_str(self.0.valueSH))
             .finish()
     }
 }
@@ -208,19 +233,15 @@ impl ParmChoiceInfo {
 
 /// [Documentation](https://www.sidefx.com/docs/hengine/struct_h_a_p_i___parm_info.html)
 #[derive(Debug)]
-pub struct ParmInfo {
-    pub(crate) inner: HAPI_ParmInfo,
-    pub(crate) session: DebugIgnore<Session>,
-    pub(crate) name: Option<CString>,
-}
+pub struct ParmInfo(
+    pub(crate) HAPI_ParmInfo,
+    pub(crate) DebugIgnore<Session>,
+    pub(crate) Option<CString>,
+);
 
 impl ParmInfo {
     pub(crate) fn new(inner: HAPI_ParmInfo, session: Session, name: Option<CString>) -> Self {
-        Self {
-            inner,
-            session: DebugIgnore(session),
-            name,
-        }
+        Self(inner, DebugIgnore(session), name)
     }
 }
 
@@ -272,10 +293,7 @@ impl ParmInfo {
 
 // #[derive(Clone)]
 /// [Documentation](https://www.sidefx.com/docs/hengine/struct_h_a_p_i___node_info.html)
-pub struct NodeInfo {
-    pub(crate) inner: HAPI_NodeInfo,
-    pub(crate) session: DebugIgnore<Session>,
-}
+pub struct NodeInfo(pub(crate) HAPI_NodeInfo, pub(crate) DebugIgnore<Session>);
 
 impl NodeInfo {
     get!(name->nameSH->Result<String>);
@@ -300,10 +318,7 @@ impl NodeInfo {
     pub(crate) fn new(session: &Session, node: NodeHandle) -> Result<Self> {
         let session = session.clone();
         let inner = crate::ffi::get_node_info(node, &session)?;
-        Ok(Self {
-            inner,
-            session: DebugIgnore(session),
-        })
+        Ok(Self(inner, DebugIgnore(session)))
     }
 }
 
@@ -330,9 +345,7 @@ impl std::fmt::Debug for NodeInfo {
 
 /// [Documentation](https://www.sidefx.com/docs/hengine/struct_h_a_p_i___cook_options.html)
 #[derive(Debug, Clone)]
-pub struct CookOptions {
-    pub(crate) inner: HAPI_CookOptions,
-}
+pub struct CookOptions(pub(crate) HAPI_CookOptions);
 
 wrap!(
     Default CookOptions [HAPI_CookOptions_Create => HAPI_CookOptions];
@@ -354,16 +367,14 @@ wrap!(
 );
 
 #[derive(Debug, Clone)]
-pub struct AttributeInfo {
-    pub(crate) inner: HAPI_AttributeInfo,
-}
+pub struct AttributeInfo(pub(crate) HAPI_AttributeInfo);
 
 impl Default for AttributeInfo {
     fn default() -> Self {
         let mut inner = unsafe { HAPI_AttributeInfo_Create() };
         // FIXME: Uninitialized variable in Houdini 20.0.625
         inner.totalArrayElements = 0;
-        Self { inner }
+        Self(inner)
     }
 }
 wrap! {
@@ -384,18 +395,15 @@ impl AttributeInfo {
         owner: AttributeOwner,
         name: &CStr,
     ) -> Result<Self> {
-        Ok(Self {
-            inner: crate::ffi::get_attribute_info(node, part_id, owner, name)?,
-        })
+        Ok(Self(crate::ffi::get_attribute_info(
+            node, part_id, owner, name,
+        )?))
     }
 }
 
 /// [Documentation](https://www.sidefx.com/docs/hengine/struct_h_a_p_i___asset_info.html)
 #[derive(Debug)]
-pub struct AssetInfo {
-    pub(crate) inner: HAPI_AssetInfo,
-    pub session: DebugIgnore<Session>,
-}
+pub struct AssetInfo(pub(crate) HAPI_AssetInfo, pub DebugIgnore<Session>);
 
 impl AssetInfo {
     get!(node_id->nodeId->[handle: NodeHandle]);
@@ -419,10 +427,10 @@ impl AssetInfo {
 
 /// [Documentation](https://www.sidefx.com/docs/hengine/struct_h_a_p_i___object_info.html)
 #[derive(Debug)]
-pub struct ObjectInfo<'session> {
-    pub(crate) inner: HAPI_ObjectInfo,
-    pub session: DebugIgnore<&'session Session>,
-}
+pub struct ObjectInfo<'session>(
+    pub(crate) HAPI_ObjectInfo,
+    pub DebugIgnore<&'session Session>,
+);
 
 impl<'s> ObjectInfo<'s> {
     get!(name->nameSH->Result<String>);
@@ -436,15 +444,13 @@ impl<'s> ObjectInfo<'s> {
     get!(node_id->nodeId->[handle: NodeHandle]);
     get!(object_to_instance_id->objectToInstanceId->[handle: NodeHandle]);
     pub fn to_node(&self) -> Result<HoudiniNode> {
-        self.node_id().to_node(&self.session)
+        self.node_id().to_node(&self.1)
     }
 }
 
 #[derive(Debug, Clone)]
 /// [Documentation](https://www.sidefx.com/docs/hengine/struct_h_a_p_i___geo_info.html)
-pub struct GeoInfo {
-    pub(crate) inner: HAPI_GeoInfo,
-}
+pub struct GeoInfo(pub(crate) HAPI_GeoInfo);
 
 impl<'s> GeoInfo {
     get!(geo_type->type_->GeoType);
@@ -464,14 +470,13 @@ impl<'s> GeoInfo {
         GeoInfo::from_handle(node.handle, &node.session)
     }
     pub fn from_handle(handle: NodeHandle, session: &'s Session) -> Result<GeoInfo> {
-        crate::ffi::get_geo_info(session, handle).map(|inner| GeoInfo { inner })
+        crate::ffi::get_geo_info(session, handle).map(|inner| GeoInfo(inner))
     }
 }
 
 #[derive(Debug)]
-pub struct PartInfo {
-    pub(crate) inner: HAPI_PartInfo,
-}
+pub struct PartInfo(pub(crate) HAPI_PartInfo);
+
 wrap!(
     Default PartInfo [HAPI_PartInfo_Create => HAPI_PartInfo];
     [get] part_id->id->[i32];
@@ -488,9 +493,7 @@ wrap!(
 );
 
 #[derive(Debug, Clone)]
-pub struct TimelineOptions {
-    pub(crate) inner: HAPI_TimelineOptions,
-}
+pub struct TimelineOptions(pub(crate) HAPI_TimelineOptions);
 
 wrap!(
     Default TimelineOptions [HAPI_TimelineOptions_Create => HAPI_TimelineOptions];
@@ -500,9 +503,7 @@ wrap!(
 );
 
 #[derive(Debug, Clone)]
-pub struct CurveInfo {
-    pub(crate) inner: HAPI_CurveInfo,
-}
+pub struct CurveInfo(pub(crate) HAPI_CurveInfo);
 
 wrap!(
     Default CurveInfo [HAPI_CurveInfo_Create => HAPI_CurveInfo];
@@ -518,9 +519,7 @@ wrap!(
 );
 
 #[derive(Debug, Clone)]
-pub struct Viewport {
-    pub(crate) inner: HAPI_Viewport,
-}
+pub struct Viewport(pub(crate) HAPI_Viewport);
 
 wrap!(
     Default Viewport [HAPI_Viewport_Create => HAPI_Viewport];
@@ -531,9 +530,7 @@ wrap!(
 
 #[derive(Debug, Clone)]
 /// [Documentation](https://www.sidefx.com/docs/hengine/struct_h_a_p_i___transform.html)
-pub struct Transform {
-    pub(crate) inner: HAPI_Transform,
-}
+pub struct Transform(pub(crate) HAPI_Transform);
 
 wrap!(
     Default Transform [HAPI_Transform_Create => HAPI_Transform];
@@ -546,20 +543,17 @@ wrap!(
 
 impl Transform {
     pub fn from_matrix(session: &Session, matrix: &[f32; 16], rst_order: RSTOrder) -> Result<Self> {
-        crate::ffi::convert_matrix_to_quat(session, matrix, rst_order)
-            .map(|inner| Transform { inner })
+        crate::ffi::convert_matrix_to_quat(session, matrix, rst_order).map(|inner| Transform(inner))
     }
 
     pub fn convert_to_matrix(&self, session: &Session) -> Result<[f32; 16]> {
-        crate::ffi::convert_transform_quat_to_matrix(session, &self.inner)
+        crate::ffi::convert_transform_quat_to_matrix(session, &self.0)
     }
 }
 
 #[derive(Debug, Clone)]
 /// [Documentation](https://www.sidefx.com/docs/hengine/struct_h_a_p_i___transform_euler.html)
-pub struct TransformEuler {
-    pub(crate) inner: HAPI_TransformEuler,
-}
+pub struct TransformEuler(pub(crate) HAPI_TransformEuler);
 
 wrap!(
     Default TransformEuler [HAPI_TransformEuler_Create => HAPI_TransformEuler];
@@ -578,8 +572,8 @@ impl TransformEuler {
         rst_order: RSTOrder,
         rot_order: XYZOrder,
     ) -> Result<Self> {
-        crate::ffi::convert_transform(session, &self.inner, rst_order, rot_order)
-            .map(|inner| TransformEuler { inner })
+        crate::ffi::convert_transform(session, &self.0, rst_order, rot_order)
+            .map(|inner| TransformEuler(inner))
     }
 
     pub fn from_matrix(
@@ -589,18 +583,16 @@ impl TransformEuler {
         rot_order: XYZOrder,
     ) -> Result<Self> {
         crate::ffi::convert_matrix_to_euler(session, matrix, rst_order, rot_order)
-            .map(|inner| TransformEuler { inner })
+            .map(|inner| TransformEuler(inner))
     }
 
     pub fn convert_to_matrix(&self, session: &Session) -> Result<[f32; 16]> {
-        crate::ffi::convert_transform_euler_to_matrix(session, &self.inner)
+        crate::ffi::convert_transform_euler_to_matrix(session, &self.0)
     }
 }
 
 #[derive(Debug, Clone)]
-pub struct SessionSyncInfo {
-    pub(crate) inner: HAPI_SessionSyncInfo,
-}
+pub struct SessionSyncInfo(pub(crate) HAPI_SessionSyncInfo);
 
 wrap!(
     Default SessionSyncInfo [HAPI_SessionSyncInfo_Create => HAPI_SessionSyncInfo];
@@ -609,10 +601,9 @@ wrap!(
 );
 
 #[derive(Debug, Clone)]
-pub struct BoxInfo {
-    pub(crate) inner: HAPI_BoxInfo,
-}
+pub struct BoxInfo(pub(crate) HAPI_BoxInfo);
 
+// TODO: Why not impl Default?
 fn _create_box_info() -> HAPI_BoxInfo {
     HAPI_BoxInfo {
         center: Default::default(),
@@ -629,10 +620,9 @@ wrap!(
 );
 
 #[derive(Debug, Clone)]
-pub struct SphereInfo {
-    pub(crate) inner: HAPI_SphereInfo,
-}
+pub struct SphereInfo(pub(crate) HAPI_SphereInfo);
 
+// TODO: Why not impl Default?
 fn _create_sphere_info() -> HAPI_SphereInfo {
     HAPI_SphereInfo {
         center: Default::default(),
@@ -648,9 +638,7 @@ wrap!(
 
 #[repr(C)]
 #[derive(Debug, Clone)]
-pub struct ImageInfo {
-    pub(crate) inner: HAPI_ImageInfo,
-}
+pub struct ImageInfo(pub(crate) HAPI_ImageInfo);
 
 wrap!(
     Default ImageInfo [HAPI_ImageInfo_Create => HAPI_ImageInfo];
@@ -674,10 +662,10 @@ pub struct KeyFrame {
 }
 
 #[derive(Debug, Clone)]
-pub struct ImageFileFormat<'a> {
-    pub(crate) inner: HAPI_ImageFileFormat,
-    pub(crate) session: DebugIgnore<&'a Session>,
-}
+pub struct ImageFileFormat<'a>(
+    pub(crate) HAPI_ImageFileFormat,
+    pub(crate) DebugIgnore<&'a Session>,
+);
 
 impl<'a> ImageFileFormat<'a> {
     get!(name->nameSH->Result<String>);
@@ -686,9 +674,7 @@ impl<'a> ImageFileFormat<'a> {
 }
 
 #[derive(Debug, Clone)]
-pub struct VolumeInfo {
-    pub(crate) inner: HAPI_VolumeInfo,
-}
+pub struct VolumeInfo(pub(crate) HAPI_VolumeInfo);
 
 wrap!(
     impl VolumeInfo => HAPI_VolumeInfo;
@@ -710,23 +696,19 @@ wrap!(
 
 impl VolumeInfo {
     fn transform(&self) -> Transform {
-        Transform {
-            inner: self.inner.transform,
-        }
+        Transform(self.0.transform)
     }
     fn set_transform(&mut self, transform: Transform) {
-        self.inner.transform = transform.inner
+        self.0.transform = transform.0
     }
     fn with_transform(mut self, transform: Transform) -> Self {
-        self.inner.transform = transform.inner;
+        self.0.transform = transform.0;
         self
     }
 }
 
 #[derive(Debug, Clone)]
-pub struct VolumeTileInfo {
-    pub(crate) inner: HAPI_VolumeTileInfo,
-}
+pub struct VolumeTileInfo(pub(crate) HAPI_VolumeTileInfo);
 
 wrap!(
     impl VolumeTileInfo => HAPI_VolumeTileInfo;
@@ -737,9 +719,7 @@ wrap!(
 );
 
 #[derive(Debug, Clone)]
-pub struct VolumeVisualInfo {
-    pub(crate) inner: HAPI_VolumeVisualInfo,
-}
+pub struct VolumeVisualInfo(pub(crate) HAPI_VolumeVisualInfo);
 
 wrap!(
     impl VolumeVisualInfo => HAPI_VolumeVisualInfo;
@@ -749,9 +729,7 @@ wrap!(
 );
 
 #[derive(Debug, Clone)]
-pub struct InputCurveInfo {
-    pub(crate) inner: HAPI_InputCurveInfo,
-}
+pub struct InputCurveInfo(pub(crate) HAPI_InputCurveInfo);
 
 wrap!(
     Default InputCurveInfo [HAPI_InputCurveInfo_Create => HAPI_InputCurveInfo];
@@ -764,9 +742,7 @@ wrap!(
 );
 
 #[derive(Debug, Copy, Clone)]
-pub struct PDGEventInfo {
-    pub(crate) inner: HAPI_PDG_EventInfo,
-}
+pub struct PDGEventInfo(pub(crate) HAPI_PDG_EventInfo);
 
 impl PDGEventInfo {
     get!(node_id->nodeId->[handle: NodeHandle]);
@@ -774,31 +750,29 @@ impl PDGEventInfo {
     get!(dependency_id->dependencyId->i32);
     get!(with_session message->msgSH->Result<String>);
     pub fn current_state(&self) -> PdgWorkItemState {
-        unsafe { std::mem::transmute::<i32, PdgWorkItemState>(self.inner.currentState) }
+        unsafe { std::mem::transmute::<i32, PdgWorkItemState>(self.0.currentState) }
     }
     pub fn last_state(&self) -> PdgWorkItemState {
-        unsafe { std::mem::transmute::<i32, PdgWorkItemState>(self.inner.lastState) }
+        unsafe { std::mem::transmute::<i32, PdgWorkItemState>(self.0.lastState) }
     }
     pub fn event_type(&self) -> PdgEventType {
-        unsafe { std::mem::transmute::<i32, PdgEventType>(self.inner.eventType) }
+        unsafe { std::mem::transmute::<i32, PdgEventType>(self.0.eventType) }
     }
 }
 
 #[derive(Debug)]
-pub struct PDGWorkItemOutputFile<'session> {
-    pub(crate) inner: HAPI_PDG_WorkItemOutputFile,
-    pub(crate) session: DebugIgnore<&'session Session>,
-}
+pub struct PDGWorkItemOutputFile<'session>(
+    pub(crate) HAPI_PDG_WorkItemOutputFile,
+    pub(crate) DebugIgnore<&'session Session>,
+);
 
 impl<'session> PDGWorkItemOutputFile<'session> {
-    get!(result->filePathSH->Result<String>);
+    get!(path->filePathSH->Result<String>);
     get!(tag->tagSH->Result<String>);
     get!(sha->hash->i64);
 }
 
-pub struct PDGWorkItemInfo {
-    pub(crate) inner: HAPI_PDG_WorkItemInfo,
-}
+pub struct PDGWorkItemInfo(pub(crate) HAPI_PDG_WorkItemInfo);
 
 wrap! {
     impl PDGWorkItemInfo => HAPI_PDG_WorkItemInfo;
diff --git a/src/geometry.rs b/src/geometry.rs
index af29265..2cd43d9 100644
--- a/src/geometry.rs
+++ b/src/geometry.rs
@@ -1,7 +1,6 @@
 //! Access to geometry data, attributes, reading and writing geometry to and from disk
 //!
 //!
-use std::ffi::{CStr, CString};
 
 use crate::attribute::*;
 use crate::errors::Result;
@@ -14,6 +13,7 @@ use crate::node::{HoudiniNode, NodeHandle};
 use crate::stringhandle::StringArray;
 use crate::utils::unwrap_or_create;
 use crate::volume::{Tile, VolumeBounds, VolumeStorage};
+use std::ffi::{CStr, CString};
 
 #[derive(Debug, Clone)]
 /// Represents a SOP node with methods for manipulating geometry.
@@ -51,6 +51,55 @@ impl GeoFormat {
     }
 }
 
+/// Common geometry attribute names
+#[derive(Debug)]
+pub enum AttributeName {
+    Cd,
+    P,
+    N,
+    Uv,
+    TangentU,
+    TangentV,
+    Scale,
+    User(CString),
+}
+
+impl TryFrom<&str> for AttributeName {
+    type Error = std::ffi::NulError;
+
+    fn try_from(value: &str) -> std::result::Result<Self, Self::Error> {
+        CString::new(value).map(AttributeName::User)
+    }
+}
+
+impl TryFrom<String> for AttributeName {
+    type Error = std::ffi::NulError;
+
+    fn try_from(value: String) -> std::result::Result<Self, Self::Error> {
+        CString::new(value).map(AttributeName::User)
+    }
+}
+
+impl From<AttributeName> for CString {
+    fn from(name: AttributeName) -> Self {
+        macro_rules! cstr {
+            ($attr:expr) => {
+                unsafe { CStr::from_bytes_with_nul_unchecked($attr).to_owned() }
+            };
+        }
+        match name {
+            AttributeName::Cd => cstr!(crate::raw::HAPI_ATTRIB_COLOR),
+            AttributeName::P => cstr!(crate::raw::HAPI_ATTRIB_POSITION),
+            AttributeName::N => cstr!(crate::raw::HAPI_ATTRIB_NORMAL),
+            AttributeName::Uv => cstr!(crate::raw::HAPI_ATTRIB_UV),
+            AttributeName::TangentU => cstr!(crate::raw::HAPI_ATTRIB_TANGENT),
+            AttributeName::TangentV => cstr!(crate::raw::HAPI_ATTRIB_TANGENT2),
+            AttributeName::Scale => cstr!(crate::raw::HAPI_ATTRIB_SCALE),
+            AttributeName::User(val) => val,
+        }
+    }
+}
+
 impl Geometry {
     /// Get geometry partition info by index.
     /// Returns an Option if given an incorrect part id.
@@ -58,21 +107,22 @@ impl Geometry {
     /// after node created or after calling `[Geometry::commit]`
     pub fn part_info(&self, part_id: i32) -> Result<Option<PartInfo>> {
         // TODO: Consider taking a u32 and cast to i32 for ffi.
+        // FIXME: Rething returning Option. Why?
         use crate::errors::Kind;
         match crate::ffi::get_part_info(&self.node, part_id) {
-            Ok(inner) => Ok(Some(PartInfo { inner })),
+            Ok(inner) => Ok(Some(PartInfo(inner))),
             Err(err) if matches!(err.kind, Kind::Hapi(HapiResult::InvalidArgument)) => Ok(None),
             Err(err) => Err(err),
         }
     }
 
     pub fn volume_info(&self, part_id: i32) -> Result<VolumeInfo> {
-        crate::ffi::get_volume_info(&self.node, part_id).map(|inner| VolumeInfo { inner })
+        crate::ffi::get_volume_info(&self.node, part_id).map(VolumeInfo)
     }
 
     pub fn set_volume_info(&self, part_id: i32, info: &VolumeInfo) -> Result<()> {
         debug_assert!(self.node.is_valid()?);
-        crate::ffi::set_volume_info(&self.node, part_id, &info.inner)
+        crate::ffi::set_volume_info(&self.node, part_id, &info.0)
     }
 
     pub fn volume_bounds(&self, part_id: i32) -> Result<VolumeBounds> {
@@ -82,6 +132,9 @@ impl Geometry {
         );
         crate::ffi::get_volume_bounds(&self.node, part_id)
     }
+    pub fn get_volume_visual_info(&self, part_id: i32) -> Result<VolumeVisualInfo> {
+        crate::ffi::get_volume_visual_info(&self.node, part_id).map(VolumeVisualInfo)
+    }
 
     /// Get information about Node's geometry.
     /// Note: The node must be cooked before calling this method.
@@ -103,8 +156,7 @@ impl Geometry {
             self.node.get_info()?.total_cook_count() > 0,
             "Node not cooked"
         );
-        crate::ffi::get_box_info(self.node.handle, &self.node.session, part_id)
-            .map(|inner| BoxInfo { inner })
+        crate::ffi::get_box_info(self.node.handle, &self.node.session, part_id).map(BoxInfo)
     }
 
     pub fn sphere_info(&self, part_id: i32) -> Result<BoxInfo> {
@@ -112,8 +164,7 @@ impl Geometry {
             self.node.get_info()?.total_cook_count() > 0,
             "Node not cooked"
         );
-        crate::ffi::get_box_info(self.node.handle, &self.node.session, part_id)
-            .map(|inner| BoxInfo { inner })
+        crate::ffi::get_box_info(self.node.handle, &self.node.session, part_id).map(BoxInfo)
     }
 
     pub fn set_curve_info(&self, part_id: i32, info: &CurveInfo) -> Result<()> {
@@ -128,7 +179,7 @@ impl Geometry {
 
     pub fn get_input_curve_info(&self, part_id: i32) -> Result<InputCurveInfo> {
         debug_assert!(self.node.is_valid()?);
-        crate::ffi::get_input_curve_info(&self.node, part_id).map(|inner| InputCurveInfo { inner })
+        crate::ffi::get_input_curve_info(&self.node, part_id).map(InputCurveInfo)
     }
 
     pub fn set_input_curve_positions(&self, part_id: i32, positions: &[f32]) -> Result<()> {
@@ -181,7 +232,7 @@ impl Geometry {
             self.node.get_info()?.total_cook_count() > 0,
             "Node not cooked"
         );
-        crate::ffi::get_curve_info(&self.node, part_id).map(|inner| CurveInfo { inner })
+        crate::ffi::get_curve_info(&self.node, part_id).map(CurveInfo)
     }
 
     /// Retrieve the number of vertices for each curve in the part.
@@ -214,14 +265,11 @@ impl Geometry {
     /// Get array containing the vertex-point associations where the
     /// ith element in the array is the point index the ith vertex
     /// associates with.
-    pub fn vertex_list(&self, part: Option<&PartInfo>) -> Result<Vec<i32>> {
-        // TODO: Consider taking a ref to an existing PartInfo instead of Option
+    pub fn vertex_list(&self, part: &PartInfo) -> Result<Vec<i32>> {
         debug_assert!(
             self.node.get_info()?.total_cook_count() > 0,
             "Node not cooked"
         );
-        let tmp;
-        let part = unwrap_or_create!(tmp, part, self.part_info(0)?.expect("partition id=0"));
         crate::ffi::get_geo_vertex_list(
             &self.node.session,
             self.node.handle,
@@ -241,13 +289,11 @@ impl Geometry {
             .collect()
     }
 
-    pub fn get_face_counts(&self, part: Option<&PartInfo>) -> Result<Vec<i32>> {
+    pub fn get_face_counts(&self, part: &PartInfo) -> Result<Vec<i32>> {
         debug_assert!(
             self.node.get_info()?.total_cook_count() > 0,
             "Node not cooked"
         );
-        let tmp;
-        let part = unwrap_or_create!(tmp, part, self.part_info(0)?.expect("partition id=0"));
         crate::ffi::get_face_counts(
             &self.node.session,
             self.node.handle,
@@ -258,13 +304,11 @@ impl Geometry {
     }
 
     /// Return material nodes applied to geometry.
-    pub fn get_materials(&self, part: Option<&PartInfo>) -> Result<Option<Materials>> {
+    pub fn get_materials(&self, part: &PartInfo) -> Result<Option<Materials>> {
         debug_assert!(
             self.node.get_info()?.total_cook_count() > 0,
             "Node not cooked"
         );
-        let tmp;
-        let part = unwrap_or_create!(tmp, part, self.part_info(0)?.expect("partition id=0"));
         let (all_the_same, mats) = crate::ffi::get_material_node_ids_on_faces(
             &self.node.session,
             self.node.handle,
@@ -328,36 +372,30 @@ impl Geometry {
     /// Get num geometry elements by type (points, prims, vertices).
     pub fn get_element_count_by_owner(
         &self,
-        part: Option<&PartInfo>,
+        part: &PartInfo,
         owner: AttributeOwner,
     ) -> Result<i32> {
-        let tmp;
-        let part = unwrap_or_create!(tmp, part, self.part_info(0)?.expect("partition id=0"));
         crate::ffi::get_element_count_by_attribute_owner(part, owner)
     }
 
     /// Get number of attributes by type.
     pub fn get_attribute_count_by_owner(
         &self,
-        part: Option<&PartInfo>,
+        part: &PartInfo,
         owner: AttributeOwner,
     ) -> Result<i32> {
-        let tmp;
-        let part = unwrap_or_create!(tmp, part, self.part_info(0)?.expect("partition id=0"));
         crate::ffi::get_attribute_count_by_owner(part, owner)
     }
 
     pub fn get_attribute_names(
         &self,
         owner: AttributeOwner,
-        part: Option<&PartInfo>,
+        part: &PartInfo,
     ) -> Result<StringArray> {
         debug_assert!(
             self.node.get_info()?.total_cook_count() > 0,
             "Node not cooked"
         );
-        let tmp;
-        let part = unwrap_or_create!(tmp, part, self.part_info(0)?.expect("partition id=0"));
         let counts = part.attribute_counts();
         let count = match owner {
             AttributeOwner::Invalid => panic!("Invalid AttributeOwner"),
@@ -376,7 +414,9 @@ impl Geometry {
             self.node.get_info()?.total_cook_count() > 0,
             "Node not cooked"
         );
-        let name = CString::new("P")?;
+        let name = unsafe {
+            CStr::from_bytes_with_nul_unchecked(crate::raw::HAPI_ATTRIB_POSITION).to_owned()
+        };
         let info = AttributeInfo::new(&self.node, part_id, AttributeOwner::Point, name.as_c_str())?;
         Ok(NumericAttr::new(name, info, self.node.clone()))
     }
@@ -393,17 +433,22 @@ impl Geometry {
     }
 
     /// Get geometry attribute by name and owner.
-    pub fn get_attribute(
+    pub fn get_attribute<T>(
         &self,
         part_id: i32,
         owner: AttributeOwner,
-        name: &str,
-    ) -> Result<Option<Attribute>> {
+        name: T,
+    ) -> Result<Option<Attribute>>
+    where
+        T: TryInto<AttributeName>,
+        T::Error: Into<crate::HapiError>,
+    {
         debug_assert!(
             self.node.get_info()?.total_cook_count() > 0,
             "Node not cooked"
         );
-        let name = CString::new(name)?;
+        let name: AttributeName = name.try_into().map_err(Into::into)?;
+        let name: CString = name.into();
         let info = AttributeInfo::new(&self.node, part_id, owner, &name)?;
         let storage = info.storage();
         if !info.exists() {
@@ -451,7 +496,7 @@ impl Geometry {
         );
         log::debug!("Adding numeric geometry attriubute: {name}");
         let name = CString::new(name)?;
-        crate::ffi::add_attribute(&self.node, part_id, &name, &info.inner)?;
+        crate::ffi::add_attribute(&self.node, part_id, &name, &info.0)?;
         Ok(NumericAttr::<T>::new(name, info, self.node.clone()))
     }
 
@@ -473,7 +518,7 @@ impl Geometry {
         );
         log::debug!("Adding numeric array geometry attriubute: {name}");
         let name = CString::new(name)?;
-        crate::ffi::add_attribute(&self.node, part_id, &name, &info.inner)?;
+        crate::ffi::add_attribute(&self.node, part_id, &name, &info.0)?;
         Ok(NumericArrayAttr::<T>::new(name, info, self.node.clone()))
     }
 
@@ -493,7 +538,7 @@ impl Geometry {
         );
         log::debug!("Adding string geometry attriubute: {name}");
         let name = CString::new(name)?;
-        crate::ffi::add_attribute(&self.node, part_id, &name, &info.inner)?;
+        crate::ffi::add_attribute(&self.node, part_id, &name, &info.0)?;
         Ok(StringAttr::new(name, info, self.node.clone()))
     }
 
@@ -513,7 +558,7 @@ impl Geometry {
         );
         log::debug!("Adding string array geometry attriubute: {name}");
         let name = CString::new(name)?;
-        crate::ffi::add_attribute(&self.node, part_id, &name, &info.inner)?;
+        crate::ffi::add_attribute(&self.node, part_id, &name, &info.0)?;
         Ok(StringArrayAttr::new(name, info, self.node.clone()))
     }
 
@@ -533,7 +578,7 @@ impl Geometry {
         );
         log::debug!("Adding dictionary geometry attriubute: {name}");
         let name = CString::new(name)?;
-        crate::ffi::add_attribute(&self.node, part_id, &name, &info.inner)?;
+        crate::ffi::add_attribute(&self.node, part_id, &name, &info.0)?;
         Ok(DictionaryAttr::new(name, info, self.node.clone()))
     }
 
@@ -553,7 +598,7 @@ impl Geometry {
         );
         log::debug!("Adding dictionary array geometry attriubute: {name}");
         let name = CString::new(name)?;
-        crate::ffi::add_attribute(&self.node, part_id, &name, &info.inner)?;
+        crate::ffi::add_attribute(&self.node, part_id, &name, &info.0)?;
         Ok(DictionaryArrayAttr::new(name, info, self.node.clone()))
     }
 
@@ -628,7 +673,7 @@ impl Geometry {
     /// Get element membership for a group.
     pub fn get_group_membership(
         &self,
-        part_info: Option<&PartInfo>,
+        part: &PartInfo,
         group_type: GroupType,
         group_name: &str,
     ) -> Result<Vec<i32>> {
@@ -636,8 +681,6 @@ impl Geometry {
             self.node.get_info()?.total_cook_count() > 0,
             "Node not cooked"
         );
-        let tmp;
-        let part = unwrap_or_create!(tmp, part_info, self.part_info(0)?.expect("partition id=0"));
         let group_name = CString::new(group_name)?;
         crate::ffi::get_group_membership(
             &self.node.session,
@@ -664,13 +707,11 @@ impl Geometry {
         Ok(crate::ffi::get_group_count_by_type(info, group_type))
     }
 
-    pub fn get_instanced_part_ids(&self, part_info: Option<&PartInfo>) -> Result<Vec<i32>> {
+    pub fn get_instanced_part_ids(&self, part: &PartInfo) -> Result<Vec<i32>> {
         debug_assert!(
             self.node.get_info()?.total_cook_count() > 0,
             "Node not cooked"
         );
-        let tmp;
-        let part = unwrap_or_create!(tmp, part_info, self.part_info(0)?.expect("partition id=0"));
         crate::ffi::get_instanced_part_ids(
             &self.node.session,
             self.node.handle,
@@ -679,16 +720,11 @@ impl Geometry {
         )
     }
 
-    pub fn get_group_count_on_packed_instance(
-        &self,
-        part_info: Option<&PartInfo>,
-    ) -> Result<(i32, i32)> {
+    pub fn get_group_count_on_packed_instance(&self, part: &PartInfo) -> Result<(i32, i32)> {
         debug_assert!(
             self.node.get_info()?.total_cook_count() > 0,
             "Node not cooked"
         );
-        let tmp;
-        let part = unwrap_or_create!(tmp, part_info, self.part_info(0)?.expect("partition id=0"));
         crate::ffi::get_group_count_on_instance_part(
             &self.node.session,
             self.node.handle,
@@ -715,15 +751,13 @@ impl Geometry {
 
     pub fn get_instance_part_transforms(
         &self,
-        part_info: Option<&PartInfo>,
+        part: &PartInfo,
         order: RSTOrder,
     ) -> Result<Vec<Transform>> {
         debug_assert!(
             self.node.get_info()?.total_cook_count() > 0,
             "Node not cooked"
         );
-        let tmp;
-        let part = unwrap_or_create!(tmp, part_info, self.part_info(0)?.expect("partition id=0"));
         crate::ffi::get_instanced_part_transforms(
             &self.node.session,
             self.node.handle,
@@ -731,7 +765,7 @@ impl Geometry {
             order,
             part.instance_count(),
         )
-        .map(|vec| vec.into_iter().map(|inner| Transform { inner }).collect())
+        .map(|vec| vec.into_iter().map(Transform).collect())
     }
 
     /// Save geometry to a file.
@@ -795,7 +829,7 @@ impl Geometry {
             self.node.get_info()?.total_cook_count() > 0,
             "Node not cooked"
         );
-        T::read_tile(&self.node, part, fill, values, &tile.inner)
+        T::read_tile(&self.node, part, fill, values, &tile.0)
     }
 
     pub fn write_volume_tile<T: VolumeStorage>(
@@ -808,7 +842,7 @@ impl Geometry {
             self.node.get_info()?.total_cook_count() > 0,
             "Node not cooked"
         );
-        T::write_tile(&self.node, part, values, &tile.inner)
+        T::write_tile(&self.node, part, values, &tile.0)
     }
 
     pub fn read_volume_voxel<T: VolumeStorage>(
@@ -856,6 +890,15 @@ impl Geometry {
         crate::volume::iterate_tiles(&self.node, part, tile_size, callback)
     }
 
+    pub fn get_heightfield_data(&self, part_id: i32, volume_info: &VolumeInfo) -> Result<Vec<f32>> {
+        let length = volume_info.x_length() * volume_info.y_length();
+        crate::ffi::get_heightfield_data(&self.node, part_id, length)
+    }
+
+    pub fn set_heightfield_data(&self, part_id: i32, name: &str, data: &[f32]) -> Result<()> {
+        crate::ffi::set_heightfield_data(&self.node, part_id, &CString::new(name)?, data)
+    }
+
     pub fn create_heightfield_input(
         &self,
         parent: impl Into<Option<NodeHandle>>,
@@ -918,3 +961,90 @@ impl PartInfo {
         crate::ffi::get_element_count_by_group(self, group_type)
     }
 }
+
+/// Geometry extension trait with some useful utilities
+pub mod extra {
+    use super::*;
+    pub trait GeometryExtension {
+        fn create_position_attribute(&self, part: &PartInfo) -> Result<NumericAttr<f32>>;
+        fn create_point_color_attribute(&self, part: &PartInfo) -> Result<NumericAttr<f32>>;
+        fn get_color_attribute(
+            &self,
+            part: &PartInfo,
+            owner: AttributeOwner,
+        ) -> Result<Option<NumericAttr<f32>>>;
+        fn get_normal_attribute(
+            &self,
+            part: &PartInfo,
+            owner: AttributeOwner,
+        ) -> Result<Option<NumericAttr<f32>>>;
+        fn get_position_attribute(&self, part: &PartInfo) -> Result<Option<NumericAttr<f32>>>;
+    }
+
+    impl GeometryExtension for Geometry {
+        fn create_position_attribute(&self, part: &PartInfo) -> Result<NumericAttr<f32>> {
+            create_point_tuple_attribute::<3>(self, part, AttributeName::P)
+        }
+
+        fn create_point_color_attribute(&self, part: &PartInfo) -> Result<NumericAttr<f32>> {
+            create_point_tuple_attribute::<3>(self, part, AttributeName::Cd)
+        }
+
+        fn get_color_attribute(
+            &self,
+            part: &PartInfo,
+            owner: AttributeOwner,
+        ) -> Result<Option<NumericAttr<f32>>> {
+            debug_assert!(matches!(
+                owner,
+                AttributeOwner::Point | AttributeOwner::Vertex
+            ));
+            get_tuple3_attribute(self, part, AttributeName::Cd, owner)
+        }
+        fn get_normal_attribute(
+            &self,
+            part: &PartInfo,
+            owner: AttributeOwner,
+        ) -> Result<Option<NumericAttr<f32>>> {
+            debug_assert!(matches!(
+                owner,
+                AttributeOwner::Point | AttributeOwner::Vertex
+            ));
+            get_tuple3_attribute(self, part, AttributeName::N, owner)
+        }
+        fn get_position_attribute(&self, part: &PartInfo) -> Result<Option<NumericAttr<f32>>> {
+            get_tuple3_attribute(self, part, AttributeName::P, AttributeOwner::Point)
+        }
+    }
+
+    #[inline]
+    fn create_point_tuple_attribute<const N: usize>(
+        geo: &Geometry,
+        part: &PartInfo,
+        name: AttributeName,
+    ) -> Result<NumericAttr<f32>> {
+        log::debug!("Creating point attriute {:?}", name);
+        let name: CString = name.try_into()?;
+        let attr_info = AttributeInfo::default()
+            .with_count(part.point_count())
+            .with_tuple_size(N as i32)
+            .with_owner(AttributeOwner::Point)
+            .with_storage(StorageType::Float);
+        crate::ffi::add_attribute(&geo.node, part.part_id(), &name, &attr_info.0)
+            .map(|_| NumericAttr::new(name, attr_info, geo.node.clone()))
+    }
+
+    #[inline]
+    fn get_tuple3_attribute<'a>(
+        geo: &'a Geometry,
+        part: &PartInfo,
+        name: AttributeName,
+        owner: AttributeOwner,
+    ) -> Result<Option<NumericAttr<f32>>> {
+        let name: CString = name.try_into()?;
+        AttributeInfo::new(&geo.node, part.part_id(), owner, &name).map(|info| {
+            info.exists()
+                .then(|| NumericAttr::new(name, info, geo.node.clone()))
+        })
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 34d548e..71f5a2c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -27,7 +27,7 @@
 //! Add a cargo config file to your project: `.cargo/config`
 //!```text
 //! [target.'cfg(target_os = "linux")']
-//! rustflags = ["-C", "link-arg=-Wl,-rpath=/opt/hfs/19.5.368/dsolib"]
+//! rustflags = ["-C", "link-arg=-Wl,-rpath=/opt/hfs/20.5.445/dsolib"]
 //! [target.x86_64-apple-darwin]
 //! rustflags = ["-C",
 //!     "link-arg=-Wl,-rpath,/Applications/Houdini/Current/Frameworks/Houdini.framework/Versions/Current/Libraries",
diff --git a/src/material.rs b/src/material.rs
index 6333f08..8bb830c 100644
--- a/src/material.rs
+++ b/src/material.rs
@@ -70,8 +70,7 @@ impl Material {
 
     pub fn get_image_info(&self) -> Result<ImageInfo> {
         debug_assert!(self.session.is_valid());
-        crate::ffi::get_image_info(&self.session, self.node_handle())
-            .map(|inner| ImageInfo { inner })
+        crate::ffi::get_image_info(&self.session, self.node_handle()).map(ImageInfo)
     }
 
     pub fn get_image_planes(&self) -> Result<Vec<String>> {
diff --git a/src/node.rs b/src/node.rs
index 97890a5..98d2078 100644
--- a/src/node.rs
+++ b/src/node.rs
@@ -165,6 +165,12 @@ impl AsRef<NodeHandle> for NodeHandle {
     }
 }
 
+impl Default for NodeHandle {
+    fn default() -> Self {
+        NodeHandle(-1)
+    }
+}
+
 impl NodeHandle {
     /// Retrieve info about the node this handle belongs to
     pub fn info(&self, session: &Session) -> Result<NodeInfo> {
@@ -174,7 +180,7 @@ impl NodeHandle {
     /// Check if the handle is valid (node wasn't deleted)
     pub fn is_valid(&self, session: &Session) -> Result<bool> {
         let info = self.info(session)?;
-        crate::ffi::is_node_valid(session, &info.inner)
+        crate::ffi::is_node_valid(session, &info.0)
     }
 
     /// Upgrade the handle to HoudiniNode, which has more capabilities.
@@ -349,10 +355,8 @@ impl HoudiniNode {
     /// If the node is of Object type, get the information object about it.
     pub fn get_object_info(&self) -> Result<ObjectInfo<'_>> {
         debug_assert!(self.is_valid()?, "Invalid node: {}", self.path()?);
-        crate::ffi::get_object_info(&self.session, self.handle).map(|info| ObjectInfo {
-            inner: info,
-            session: (&self.session).into(),
-        })
+        crate::ffi::get_object_info(&self.session, self.handle)
+            .map(|info| ObjectInfo(info, (&self.session).into()))
     }
 
     /// Get a new NodeInfo even for this node.
@@ -371,10 +375,7 @@ impl HoudiniNode {
         let infos = crate::ffi::get_composed_object_list(&self.session, parent)?;
         Ok(infos
             .into_iter()
-            .map(|inner| ObjectInfo {
-                inner,
-                session: (&self.session).into(),
-            })
+            .map(|inner| ObjectInfo(inner, (&self.session).into()))
             .collect())
     }
 
@@ -471,10 +472,10 @@ impl HoudiniNode {
     /// If node is an HDA, return [`AssetInfo'] about it.
     pub fn asset_info(&self) -> Result<AssetInfo> {
         debug_assert!(self.is_valid()?, "Invalid node: {}", self.path()?);
-        Ok(AssetInfo {
-            inner: crate::ffi::get_asset_info(self)?,
-            session: self.session.clone().into(),
-        })
+        Ok(AssetInfo(
+            crate::ffi::get_asset_info(self)?,
+            self.session.clone().into(),
+        ))
     }
     /// Recursively check all nodes for a specific error.
     pub fn check_for_specific_error(&self, error_bits: i32) -> Result<ErrorCode> {
@@ -566,7 +567,7 @@ impl HoudiniNode {
                 info: GeoInfo::from_node(self)?,
             })),
             NodeType::Obj => {
-                let info = crate::ffi::get_geo_display_info(self).map(|inner| GeoInfo { inner })?;
+                let info = crate::ffi::get_geo_display_info(self).map(GeoInfo)?;
                 Ok(Some(Geometry {
                     node: info.node_id().to_node(&self.session)?,
                     info,
@@ -603,7 +604,7 @@ impl HoudiniNode {
                         .to_node(&self.session)
                         .map(|node| Geometry {
                             node,
-                            info: GeoInfo { inner },
+                            info: GeoInfo(inner),
                         })
                 })
                 .collect::<Result<Vec<_>>>()
@@ -623,13 +624,13 @@ impl HoudiniNode {
             relative_to.into(),
             rst_order.unwrap_or(RSTOrder::Default),
         )
-        .map(|inner| Transform { inner })
+        .map(Transform)
     }
 
     /// Set transform on the Object
     pub fn set_transform(&self, transform: &TransformEuler) -> Result<()> {
         debug_assert!(self.is_valid()?, "Invalid node: {}", self.path()?);
-        crate::ffi::set_object_transform(&self.session, self.handle, &transform.inner)
+        crate::ffi::set_object_transform(&self.session, self.handle, &transform.0)
     }
 
     /// Set keyframes animation on the Object.
diff --git a/src/parameter/access.rs b/src/parameter/access.rs
index 4fa71a9..2f4d188 100644
--- a/src/parameter/access.rs
+++ b/src/parameter/access.rs
@@ -9,7 +9,7 @@ use crate::errors::Result;
 impl IntParameter {
     /// Set parameter value at index.
     pub fn set(&self, index: i32, value: i32) -> Result<()> {
-        let session = &self.0.info.session;
+        let session = &self.0.info.1;
         debug_assert!(self.0.node.is_valid(session)?);
         let name = self.c_name()?;
         crate::ffi::set_parm_int_value(self.0.node, session, &name, index, value)
@@ -17,7 +17,7 @@ impl IntParameter {
 
     /// Get parameter value at index.
     pub fn get(&self, index: i32) -> Result<i32> {
-        let session = &self.0.info.session;
+        let session = &self.0.info.1;
         debug_assert!(self.0.node.is_valid(session)?);
         let name = self.c_name()?;
         crate::ffi::get_parm_int_value(self.0.node, session, &name, index)
@@ -25,7 +25,7 @@ impl IntParameter {
 
     /// Set all parameter tuple values
     pub fn set_array(&self, val: impl AsRef<[i32]>) -> Result<()> {
-        let session = &self.0.info.session;
+        let session = &self.0.info.1;
         debug_assert!(self.0.node.is_valid(session)?);
         crate::ffi::set_parm_int_values(
             self.0.node,
@@ -38,7 +38,7 @@ impl IntParameter {
 
     /// Set parameter tuple values
     pub fn get_array(&self) -> Result<Vec<i32>> {
-        let session = &self.0.info.session;
+        let session = &self.0.info.1;
         debug_assert!(self.0.node.is_valid(session)?);
         crate::ffi::get_parm_int_values(
             self.0.node,
@@ -60,7 +60,7 @@ impl IntParameter {
 impl FloatParameter {
     /// Set parameter value at index.
     pub fn set(&self, index: i32, value: f32) -> Result<()> {
-        let session = &self.0.info.session;
+        let session = &self.0.info.1;
         debug_assert!(self.0.node.is_valid(session)?);
         let name = self.c_name()?;
         crate::ffi::set_parm_float_value(self.0.node, session, &name, index, value)
@@ -68,7 +68,7 @@ impl FloatParameter {
 
     /// Get parameter value at index.
     pub fn get(&self, index: i32) -> Result<f32> {
-        let session = &self.0.info.session;
+        let session = &self.0.info.1;
         debug_assert!(self.0.node.is_valid(session)?);
         let name = self.c_name()?;
         crate::ffi::get_parm_float_value(self.0.node, session, &name, index)
@@ -76,7 +76,7 @@ impl FloatParameter {
 
     /// Set all parameter tuple values
     pub fn set_array(&self, values: impl AsRef<[f32]>) -> Result<()> {
-        let session = &self.0.info.session;
+        let session = &self.0.info.1;
         debug_assert!(self.0.node.is_valid(session)?);
         let mut size = self.0.info.size() as usize;
         let values = values.as_ref();
@@ -102,7 +102,7 @@ impl FloatParameter {
 
     /// Get all parameter tuple values
     pub fn get_array(&self) -> Result<Vec<f32>> {
-        let session = &self.0.info.session;
+        let session = &self.0.info.1;
         debug_assert!(self.0.node.is_valid(session)?);
         crate::ffi::get_parm_float_values(
             self.0.node,
@@ -116,7 +116,7 @@ impl FloatParameter {
 impl StringParameter {
     /// Set parameter value at index.
     pub fn set(&self, index: i32, value: impl AsRef<str>) -> Result<()> {
-        let session = &self.0.info.session;
+        let session = &self.0.info.1;
         debug_assert!(self.0.node.is_valid(session)?);
         let value = CString::new(value.as_ref())?;
         crate::ffi::set_parm_string_value(self.0.node, session, self.0.info.id(), index, &value)
@@ -124,14 +124,14 @@ impl StringParameter {
 
     /// Get parameter value at index.
     pub fn get(&self, index: i32) -> Result<String> {
-        let session = &self.0.info.session;
+        let session = &self.0.info.1;
         debug_assert!(self.0.node.is_valid(session)?);
         let name = self.c_name()?;
         crate::ffi::get_parm_string_value(self.0.node, session, &name, index)
     }
     /// Set all parameter tuple values
     pub fn set_array<T: AsRef<str>>(&self, val: impl AsRef<[T]>) -> Result<()> {
-        let session = &self.0.info.session;
+        let session = &self.0.info.1;
         debug_assert!(self.0.node.is_valid(session)?);
         let values = val
             .as_ref()
@@ -143,7 +143,7 @@ impl StringParameter {
 
     /// Get all parameter tuple values
     pub fn get_array(&self) -> Result<Vec<String>> {
-        let session = &self.0.info.session;
+        let session = &self.0.info.1;
         debug_assert!(self.0.node.is_valid(session)?);
         crate::ffi::get_parm_string_values(
             self.0.node,
@@ -165,7 +165,7 @@ impl StringParameter {
         let dest_dir = crate::utils::path_to_cstring(destination_dir)?;
         let dest_file = CString::new(filename)?;
         crate::ffi::get_file_parm(
-            &self.0.info.session,
+            &self.0.info.1,
             self.0.node,
             &self.c_name()?,
             &dest_dir,
diff --git a/src/parameter/base.rs b/src/parameter/base.rs
index 0513760..4269765 100644
--- a/src/parameter/base.rs
+++ b/src/parameter/base.rs
@@ -5,7 +5,6 @@ use crate::session::Session;
 use crate::Result;
 use std::borrow::Cow;
 use std::ffi::{CStr, CString};
-use std::ops::Deref;
 
 use super::Parameter;
 
@@ -14,7 +13,7 @@ pub trait ParmBaseTrait {
     #[inline]
     fn name(&self) -> Result<Cow<str>> {
         let inner = self.inner();
-        match inner.info.name.as_ref() {
+        match inner.info.2.as_ref() {
             None => inner.info.name().map(Cow::Owned),
             Some(c_name) => Ok(c_name.to_string_lossy()),
         }
@@ -22,7 +21,7 @@ pub trait ParmBaseTrait {
 
     #[inline]
     fn session(&self) -> &Session {
-        &self.info().session
+        &self.info().1
     }
 
     #[inline]
@@ -44,10 +43,9 @@ pub trait ParmBaseTrait {
     /// for example children added to a multi-parm or the menu was updated.
     fn update(&mut self) -> Result<()> {
         let inner = self.inner_mut();
-        let name = inner.info.name.take();
-        let mut info =
-            ParmInfo::from_parm_handle(inner.info.id(), inner.node, &inner.info.session)?;
-        info.name = name;
+        let name = inner.info.2.take();
+        let mut info = ParmInfo::from_parm_handle(inner.info.id(), inner.node, &inner.info.1)?;
+        info.2 = name;
         inner.info = info;
         Ok(())
     }
@@ -63,22 +61,21 @@ pub trait ParmBaseTrait {
             return Ok(None);
         }
         let inner = self.inner();
-        debug_assert!(inner.info.session.is_valid());
+        debug_assert!(inner.info.1.is_valid());
         if inner.info.choice_count() == 0 {
             return Ok(Some(Vec::new()));
         }
         let parms = crate::ffi::get_parm_choice_list(
             inner.node,
-            &inner.info.session,
+            &inner.info.1,
             inner.info.choice_index(),
             inner.info.choice_count(),
         );
         let parms = parms.map(|v| {
+            use std::ops::Deref;
+
             v.into_iter()
-                .map(|p| ParmChoiceInfo {
-                    inner: p,
-                    session: inner.info.session.deref().clone(),
-                })
+                .map(|p| ParmChoiceInfo(p, inner.info.1.deref().clone()))
                 .collect::<Vec<ParmChoiceInfo>>()
         })?;
         Ok(Some(parms))
@@ -92,7 +89,7 @@ pub trait ParmBaseTrait {
         if inner.info.parm_type() != ParmType::Multiparmlist {
             return Ok(None);
         }
-        let node = inner.node.to_node(&inner.info.session)?;
+        let node = inner.node.to_node(&inner.info.1)?;
         let mut all_parameters = node.parameters()?;
         all_parameters.retain(|parm| {
             parm.info().is_child_of_multi_parm() && parm.info().parent_id() == inner.info.id()
@@ -104,83 +101,66 @@ pub trait ParmBaseTrait {
     /// Returns a parameter expression string
     fn expression(&self, index: i32) -> Result<Option<String>> {
         let inner = self.inner();
-        debug_assert!(inner.info.session.is_valid());
+        debug_assert!(inner.info.1.is_valid());
         let name = self.c_name()?;
-        crate::ffi::get_parm_expression(inner.node, &inner.info.session, &name, index)
+        crate::ffi::get_parm_expression(inner.node, &inner.info.1, &name, index)
     }
 
     /// Checks if parameter has an expression
     fn has_expression(&self, index: i32) -> Result<bool> {
         let inner = self.inner();
-        debug_assert!(inner.info.session.is_valid());
+        debug_assert!(inner.info.1.is_valid());
         let name = self.c_name()?;
-        crate::ffi::parm_has_expression(inner.node, &inner.info.session, &name, index)
+        crate::ffi::parm_has_expression(inner.node, &inner.info.1, &name, index)
     }
 
     /// Set parameter expression
     fn set_expression(&self, value: &str, index: i32) -> Result<()> {
         let inner = self.inner();
-        debug_assert!(inner.info.session.is_valid());
+        debug_assert!(inner.info.1.is_valid());
         let value = CString::new(value)?;
-        crate::ffi::set_parm_expression(
-            inner.node,
-            &inner.info.session,
-            inner.info.id(),
-            &value,
-            index,
-        )
+        crate::ffi::set_parm_expression(inner.node, &inner.info.1, inner.info.id(), &value, index)
     }
 
     /// Remove parameter expression
     fn remove_expression(&self, index: i32) -> Result<()> {
         let inner = self.inner();
-        debug_assert!(inner.info.session.is_valid());
-        crate::ffi::remove_parm_expression(inner.node, &inner.info.session, inner.info.id(), index)
+        debug_assert!(inner.info.1.is_valid());
+        crate::ffi::remove_parm_expression(inner.node, &inner.info.1, inner.info.id(), index)
     }
 
     /// Revert parameter at index to its default value. If `index` is None - reset all instances.
     fn revert_to_default(&self, index: Option<i32>) -> Result<()> {
         let inner = self.inner();
-        crate::ffi::revert_parameter_to_default(
-            inner.node,
-            &inner.info.session,
-            &self.c_name()?,
-            index,
-        )
+        crate::ffi::revert_parameter_to_default(inner.node, &inner.info.1, &self.c_name()?, index)
     }
 
     /// Set keyframes on the parameter
     fn set_anim_curve(&self, index: i32, keys: &[KeyFrame]) -> Result<()> {
         let inner = self.inner();
-        debug_assert!(inner.info.session.is_valid());
+        debug_assert!(inner.info.1.is_valid());
         // SAFETY: Both structures have the same memory layout.
         let keys =
             unsafe { std::mem::transmute::<&[KeyFrame], &[crate::ffi::raw::HAPI_Keyframe]>(keys) };
-        crate::ffi::set_parm_anim_curve(
-            &inner.info.session,
-            inner.node,
-            inner.info.id(),
-            index,
-            keys,
-        )
+        crate::ffi::set_parm_anim_curve(&inner.info.1, inner.node, inner.info.id(), index, keys)
     }
 
     fn has_tag(&self, tag: &str) -> Result<bool> {
         let inner = self.inner();
         let tag = CString::new(tag)?;
-        crate::ffi::parm_has_tag(&inner.info.session, inner.node, inner.info.id(), &tag)
+        crate::ffi::parm_has_tag(&inner.info.1, inner.node, inner.info.id(), &tag)
     }
 
     /// Get parameter tag name by index. The number of tags is stored in `self.info().tag_count()`
     fn get_tag_name(&self, tag_index: i32) -> Result<String> {
         let inner = self.inner();
-        crate::ffi::get_parm_tag_name(&inner.info.session, inner.node, inner.info.id(), tag_index)
+        crate::ffi::get_parm_tag_name(&inner.info.1, inner.node, inner.info.id(), tag_index)
     }
 
     fn get_tag_value(&self, tag_name: &str) -> Result<String> {
         let inner = self.inner();
         let tag = CString::new(tag_name)?;
-        crate::ffi::get_parm_tag_value(&inner.info.session, inner.node, inner.info.id(), &tag)
+        crate::ffi::get_parm_tag_value(&inner.info.1, inner.node, inner.info.id(), &tag)
     }
 
     #[doc(hidden)]
@@ -188,7 +168,7 @@ pub trait ParmBaseTrait {
     // we store the name in the info struct, otherwise, call API to get name
     fn c_name(&self) -> Result<Cow<CStr>> {
         let inner = self.inner();
-        match inner.info.name.as_deref() {
+        match inner.info.2.as_deref() {
             None => inner.info.name_cstr().map(Cow::Owned),
             Some(name) => Ok(Cow::Borrowed(name)),
         }
diff --git a/src/parameter/mod.rs b/src/parameter/mod.rs
index c7a1129..e7daa24 100644
--- a/src/parameter/mod.rs
+++ b/src/parameter/mod.rs
@@ -101,17 +101,13 @@ impl Parameter {
     /// Parameter parent if any (examples are multi-parm or Folder type parameters)
     pub fn parent(&self) -> Result<Option<ParmInfo>> {
         let wrap = self.base();
-        debug_assert!(wrap.info.session.is_valid());
+        debug_assert!(wrap.info.1.is_valid());
         match wrap.info.parent_id() {
             ParmHandle(-1) => Ok(None),
             handle => {
-                let session = wrap.info.session.clone();
+                let session = wrap.info.1.clone();
                 let info = crate::ffi::get_parm_info(wrap.node, &session, handle)?;
-                Ok(Some(ParmInfo {
-                    inner: info,
-                    session,
-                    name: None,
-                }))
+                Ok(Some(ParmInfo(info, session, None)))
             }
         }
     }
diff --git a/src/pdg.rs b/src/pdg.rs
index 6d91aa1..2263a73 100644
--- a/src/pdg.rs
+++ b/src/pdg.rs
@@ -28,6 +28,12 @@ impl std::fmt::Debug for PDGWorkItem<'_> {
     }
 }
 
+impl From<WorkItemId> for i32 {
+    fn from(value: WorkItemId) -> Self {
+        value.0
+    }
+}
+
 impl From<TopNode> for NodeHandle {
     fn from(value: TopNode) -> Self {
         value.node.handle
@@ -36,8 +42,7 @@ impl From<TopNode> for NodeHandle {
 
 impl<'session> PDGWorkItem<'session> {
     pub fn get_info(&self) -> Result<PDGWorkItemInfo> {
-        ffi::get_workitem_info(&self.node.session, self.context_id, self.id.0)
-            .map(|inner| PDGWorkItemInfo { inner })
+        ffi::get_workitem_info(&self.node.session, self.context_id, self.id.0).map(PDGWorkItemInfo)
     }
     /// Retrieve the results of work, if the work item has any.
     pub fn get_results(&self) -> Result<Vec<PDGWorkItemOutputFile<'session>>> {
@@ -52,10 +57,7 @@ impl<'session> PDGWorkItem<'session> {
                 )?;
                 let results = results
                     .into_iter()
-                    .map(|inner| PDGWorkItemOutputFile {
-                        inner,
-                        session: (&self.node.session).into(),
-                    })
+                    .map(|inner| PDGWorkItemOutputFile(inner, (&self.node.session).into()))
                     .collect();
 
                 Ok(results)
@@ -249,7 +251,7 @@ impl TopNode {
             debug_assert_eq!(graph_ids.len(), graph_names.len());
             for (graph_id, graph_name) in graph_ids.into_iter().zip(graph_names) {
                 for event in ffi::get_pdg_events(session, graph_id, &mut events)? {
-                    let event = PDGEventInfo { inner: *event };
+                    let event = PDGEventInfo(*event);
                     match event.event_type() {
                         PdgEventType::EventCookComplete => break 'main,
                         _ => {
@@ -276,43 +278,17 @@ impl TopNode {
         Ok(())
     }
 
-    pub fn cook_pdg_blocking(&self) -> Result<()> {
-        ffi::cook_pdg(&self.node.session, self.node.handle, false, true, false)
-    }
-
-    // FIXME. Observing some weird behaviour. The output files are intermixed with tags
-    #[allow(dead_code)]
-    #[allow(unreachable_code)]
-    fn cook_blocking_with_results(
-        &self,
-        _all_outputs: bool,
-    ) -> Result<Vec<PDGWorkItemOutputFile<'_>>> {
-        unimplemented!();
+    /// Trigger PDG cooking and wait for completion.
+    /// If all_outputs is true and this TOP node is of topnet type, cook all network outptus.
+    /// Results can then be retrieved from workitems with get_all_workitems()
+    pub fn cook_pdg_blocking(&self, all_outputs: bool) -> Result<()> {
         ffi::cook_pdg(
             &self.node.session,
             self.node.handle,
             false,
             true,
-            _all_outputs,
-        )?;
-        let workitems: Vec<PDGWorkItem> = {
-            let context_id = self.get_context_id()?;
-            ffi::get_pdg_workitems(&self.node.session, self.node.handle)?
-                .into_iter()
-                .map(|workitem_id| {
-                    Ok(PDGWorkItem {
-                        id: WorkItemId(workitem_id),
-                        context_id,
-                        node: &self.node,
-                    })
-                })
-                .collect::<Result<Vec<_>>>()?
-        };
-        let mut all_results = Vec::new();
-        for wi in workitems {
-            all_results.extend(wi.get_results()?)
-        }
-        Ok(all_results)
+            all_outputs,
+        )
     }
 
     /// Get the graph(context) id of this node in PDG.
diff --git a/src/session.rs b/src/session.rs
index 574237f..ec77829 100644
--- a/src/session.rs
+++ b/src/session.rs
@@ -26,7 +26,10 @@ use std::{ffi::CString, path::Path, sync::Arc};
 pub use crate::{
     asset::AssetLibrary,
     errors::*,
-    ffi::{enums::*, CookOptions, ImageFileFormat, SessionSyncInfo, TimelineOptions, Viewport},
+    ffi::{
+        enums::*, CompositorOptions, CookOptions, ImageFileFormat, SessionInfo, SessionSyncInfo,
+        ThriftServerOptions, TimelineOptions, Viewport,
+    },
     node::{HoudiniNode, ManagerNode, ManagerType, NodeHandle, NodeType, Transform},
     parameter::Parameter,
     stringhandle::StringArray,
@@ -34,6 +37,7 @@ pub use crate::{
 
 pub type SessionState = State;
 
+use crate::ffi::ImageInfo;
 use crate::stringhandle::StringHandle;
 use crate::{ffi::raw, utils};
 
@@ -153,6 +157,7 @@ pub enum CookResult {
 pub enum ConnectionType {
     ThriftPipe(OsString),
     ThriftSocket(std::net::SocketAddrV4),
+    SharedMemory(String),
     InProcess,
     Custom,
 }
@@ -282,22 +287,30 @@ impl Session {
     }
 
     /// Create an input geometry node which can accept modifications
-    pub fn create_input_node(&self, name: &str) -> Result<crate::geometry::Geometry> {
+    pub fn create_input_node(
+        &self,
+        name: &str,
+        parent: Option<NodeHandle>,
+    ) -> Result<crate::geometry::Geometry> {
         debug!("Creating input node: {}", name);
         debug_assert!(self.is_valid());
         let name = CString::new(name)?;
-        let id = crate::ffi::create_input_node(self, &name)?;
+        let id = crate::ffi::create_input_node(self, &name, parent)?;
         let node = HoudiniNode::new(self.clone(), NodeHandle(id), None)?;
         let info = crate::geometry::GeoInfo::from_node(&node)?;
         Ok(crate::geometry::Geometry { node, info })
     }
 
     /// Create an input geometry node with [`crate::enums::PartType`] set to `Curve`
-    pub fn create_input_curve_node(&self, name: &str) -> Result<crate::geometry::Geometry> {
+    pub fn create_input_curve_node(
+        &self,
+        name: &str,
+        parent: Option<NodeHandle>,
+    ) -> Result<crate::geometry::Geometry> {
         debug!("Creating input curve node: {}", name);
         debug_assert!(self.is_valid());
         let name = CString::new(name)?;
-        let id = crate::ffi::create_input_curve_node(self, &name)?;
+        let id = crate::ffi::create_input_curve_node(self, &name, parent)?;
         let node = HoudiniNode::new(self.clone(), NodeHandle(id), None)?;
         let info = crate::geometry::GeoInfo::from_node(&node)?;
         Ok(crate::geometry::Geometry { node, info })
@@ -375,14 +388,18 @@ impl Session {
         }
     }
 
-    /// Find a parameter by its absolute path
-    pub fn find_parameter_from_path(&self, path: impl AsRef<str>) -> Result<Option<Parameter>> {
+    /// Find a parameter by path, absolute or relative to a start node.
+    pub fn find_parameter_from_path(
+        &self,
+        path: impl AsRef<str>,
+        start: impl Into<Option<NodeHandle>>,
+    ) -> Result<Option<Parameter>> {
         debug_assert!(self.is_valid());
         debug!("Searching parameter at path: {}", path.as_ref());
         let Some((path, parm)) = path.as_ref().rsplit_once('/') else {
             return Ok(None);
         };
-        let Some(node) = self.get_node_from_path(path, None)? else {
+        let Some(node) = self.get_node_from_path(path, start)? else {
             debug!("Node {} not found", path);
             return Ok(None);
         };
@@ -409,14 +426,8 @@ impl Session {
         rst_order: RSTOrder,
     ) -> Result<Vec<Transform>> {
         debug_assert!(self.is_valid());
-        crate::ffi::get_composed_object_transforms(self, *parent.as_ref(), rst_order).map(
-            |transforms| {
-                transforms
-                    .into_iter()
-                    .map(|tr| Transform { inner: tr })
-                    .collect()
-            },
-        )
+        crate::ffi::get_composed_object_transforms(self, *parent.as_ref(), rst_order)
+            .map(|transforms| transforms.into_iter().map(Transform).collect())
     }
 
     /// Save current session to hip file
@@ -581,13 +592,13 @@ impl Session {
     /// Set Houdini timeline options
     pub fn set_timeline_options(&self, options: TimelineOptions) -> Result<()> {
         debug_assert!(self.is_valid());
-        crate::ffi::set_timeline_options(self, &options.inner)
+        crate::ffi::set_timeline_options(self, &options.0)
     }
 
     /// Get Houdini timeline options
     pub fn get_timeline_options(&self) -> Result<TimelineOptions> {
         debug_assert!(self.is_valid());
-        crate::ffi::get_timeline_options(self).map(|opt| TimelineOptions { inner: opt })
+        crate::ffi::get_timeline_options(self).map(TimelineOptions)
     }
 
     /// Set session to use Houdini time
@@ -605,7 +616,7 @@ impl Session {
     /// Get the viewport(camera) position
     pub fn get_viewport(&self) -> Result<Viewport> {
         debug_assert!(self.is_valid());
-        crate::ffi::get_viewport(self).map(|inner| Viewport { inner })
+        crate::ffi::get_viewport(self).map(Viewport)
     }
 
     /// Set the viewport(camera) position
@@ -622,13 +633,13 @@ impl Session {
     /// Get session sync info
     pub fn get_sync_info(&self) -> Result<SessionSyncInfo> {
         debug_assert!(self.is_valid());
-        crate::ffi::get_session_sync_info(self).map(|inner| SessionSyncInfo { inner })
+        crate::ffi::get_session_sync_info(self).map(SessionSyncInfo)
     }
 
     /// Set session sync info
     pub fn set_sync_info(&self, info: &SessionSyncInfo) -> Result<()> {
         debug_assert!(self.is_valid());
-        crate::ffi::set_session_sync_info(self, &info.inner)
+        crate::ffi::set_session_sync_info(self, &info.0)
     }
 
     /// Get license type used by this session
@@ -651,6 +662,43 @@ impl Session {
         crate::material::extract_image_to_file(self, cop_node, image_planes, path)
     }
 
+    pub fn render_texture_to_image(
+        &self,
+        node: impl Into<NodeHandle>,
+        parm_name: &str,
+    ) -> Result<()> {
+        debug_assert!(self.is_valid());
+        let name = CString::new(parm_name)?;
+        let node = node.into();
+        let id = crate::ffi::get_parm_id_from_name(&name, node, self)?;
+        crate::ffi::render_texture_to_image(&self, node, crate::parameter::ParmHandle(id))
+    }
+
+    pub fn extract_image_to_file(
+        &self,
+        node: impl Into<NodeHandle>,
+        image_planes: &str,
+        path: impl AsRef<Path>,
+    ) -> Result<String> {
+        crate::material::extract_image_to_file(self, node.into(), image_planes, path)
+    }
+
+    pub fn extract_image_to_memory(
+        &self,
+        node: impl Into<NodeHandle>,
+        buffer: &mut Vec<u8>,
+        image_planes: impl AsRef<str>,
+        format: impl AsRef<str>,
+    ) -> Result<()> {
+        debug_assert!(self.is_valid());
+        crate::material::extract_image_to_memory(self, node.into(), buffer, image_planes, format)
+    }
+
+    pub fn get_image_info(&self, node: impl Into<NodeHandle>) -> Result<ImageInfo> {
+        debug_assert!(self.is_valid());
+        crate::ffi::get_image_info(self, node.into()).map(ImageInfo)
+    }
+
     /// Render a COP node to a memory buffer
     pub fn render_cop_to_memory(
         &self,
@@ -670,10 +718,7 @@ impl Session {
         debug_assert!(self.is_valid());
         crate::ffi::get_supported_image_file_formats(self).map(|v| {
             v.into_iter()
-                .map(|inner| ImageFileFormat {
-                    inner,
-                    session: self.into(),
-                })
+                .map(|inner| ImageFileFormat(inner, self.into()))
                 .collect()
         })
     }
@@ -706,6 +751,41 @@ impl Session {
         debug_assert!(self.is_valid());
         crate::ffi::python_thread_interpreter_lock(self, lock)
     }
+    pub fn get_compositor_options(&self) -> Result<CompositorOptions> {
+        crate::ffi::get_compositor_options(self).map(CompositorOptions)
+    }
+
+    pub fn set_compositor_options(&self, options: &CompositorOptions) -> Result<()> {
+        crate::ffi::set_compositor_options(self, &options.0)
+    }
+
+    pub fn get_preset_names(&self, bytes: &[u8]) -> Result<Vec<String>> {
+        debug_assert!(self.is_valid());
+        let mut handles = vec![];
+        for handle in crate::ffi::get_preset_names(self, bytes)? {
+            let v = crate::stringhandle::get_string(handle, self)?;
+            handles.push(v);
+        }
+        Ok(handles)
+    }
+
+    pub fn start_performance_monitor_profile(&self, title: &str) -> Result<i32> {
+        let title = CString::new(title)?;
+        crate::ffi::start_performance_monitor_profile(self, &title)
+    }
+
+    pub fn stop_performance_monitor_profile(
+        &self,
+        profile_id: i32,
+        output_file: &str,
+    ) -> Result<()> {
+        let output_file = CString::new(output_file)?;
+        crate::ffi::stop_performance_monitor_profile(self, profile_id, &output_file)
+    }
+
+    pub fn get_job_status(&self, job_id: i32) -> Result<JobStatus> {
+        crate::ffi::get_job_status(self, job_id)
+    }
 }
 
 impl Drop for Session {
@@ -751,12 +831,13 @@ pub fn connect_to_pipe(
     let c_str = utils::path_to_cstring(&pipe)?;
     let pipe = pipe.as_ref().as_os_str().to_os_string();
     let timeout = timeout.unwrap_or_default();
+    let options = options.cloned().unwrap_or_default();
     let mut waited = Duration::from_secs(0);
     let wait_ms = Duration::from_millis(100);
     let handle = loop {
         let mut last_error = None;
         debug!("Trying to connect to pipe server");
-        match crate::ffi::new_thrift_piped_session(&c_str) {
+        match crate::ffi::new_thrift_piped_session(&c_str, &options.session_info.0) {
             Ok(handle) => break handle,
             Err(e) => {
                 last_error.replace(e);
@@ -770,12 +851,25 @@ pub fn connect_to_pipe(
         }
     };
     let connection = ConnectionType::ThriftPipe(pipe);
-    let session = Session::new(
-        handle,
-        connection,
-        options.cloned().unwrap_or_default(),
-        pid,
-    );
+    let session = Session::new(handle, connection, options, pid);
+    session.initialize()?;
+    Ok(session)
+}
+
+pub fn connect_to_memory_server(
+    memory_name: &str,
+    options: Option<&SessionOptions>,
+    pid: Option<u32>,
+) -> Result<Session> {
+    let mem_name = String::from(memory_name);
+    let mem_name_cstr = CString::new(memory_name)?;
+
+    let options = options.cloned().unwrap_or_default();
+    let handle =
+        crate::ffi::new_thrift_shared_memory_session(&mem_name_cstr, &options.session_info.0)?;
+
+    let connection = ConnectionType::SharedMemory(mem_name);
+    let session = Session::new(handle, connection, options, pid);
     session.initialize()?;
     Ok(session)
 }
@@ -787,14 +881,11 @@ pub fn connect_to_socket(
 ) -> Result<Session> {
     debug!("Connecting to socket server: {:?}", addr);
     let host = CString::new(addr.ip().to_string()).expect("SocketAddr->CString");
-    let handle = crate::ffi::new_thrift_socket_session(addr.port() as i32, &host)?;
+    let options = options.cloned().unwrap_or_default();
+    let handle =
+        crate::ffi::new_thrift_socket_session(addr.port() as i32, &host, &options.session_info.0)?;
     let connection = ConnectionType::ThriftSocket(addr);
-    let session = Session::new(
-        handle,
-        connection,
-        options.cloned().unwrap_or_default(),
-        None,
-    );
+    let session = Session::new(handle, connection, options, None);
     session.initialize()?;
     Ok(session)
 }
@@ -802,14 +893,10 @@ pub fn connect_to_socket(
 /// Create in-process session
 pub fn new_in_process(options: Option<&SessionOptions>) -> Result<Session> {
     debug!("Creating new in-process session");
-    let handle = crate::ffi::create_inprocess_session()?;
+    let options = options.cloned().unwrap_or_default();
+    let handle = crate::ffi::create_inprocess_session(&options.session_info.0)?;
     let connection = ConnectionType::InProcess;
-    let session = Session::new(
-        handle,
-        connection,
-        options.cloned().unwrap_or_default(),
-        Some(std::process::id()),
-    );
+    let session = Session::new(handle, connection, options, Some(std::process::id()));
     session.initialize()?;
     Ok(session)
 }
@@ -819,6 +906,8 @@ pub fn new_in_process(options: Option<&SessionOptions>) -> Result<Session> {
 pub struct SessionOptions {
     /// Session cook options
     pub cook_opt: CookOptions,
+    /// Session connection options
+    pub session_info: SessionInfo,
     /// Create a Threaded server connection
     pub threaded: bool,
     /// Cleanup session upon close
@@ -837,6 +926,7 @@ impl Default for SessionOptions {
     fn default() -> Self {
         SessionOptions {
             cook_opt: CookOptions::default(),
+            session_info: SessionInfo::default(),
             threaded: false,
             cleanup: false,
             ignore_already_init: true,
@@ -854,6 +944,7 @@ impl Default for SessionOptions {
 /// A build for SessionOptions.
 pub struct SessionOptionsBuilder {
     cook_opt: CookOptions,
+    session_info: SessionInfo,
     threaded: bool,
     cleanup: bool,
     ignore_already_init: bool,
@@ -881,16 +972,15 @@ impl SessionOptionsBuilder {
     /// Set the server environment variables. See also [`Session::set_server_var`].
     /// The difference is this method writes out a temp file with the variables and
     /// implicitly pass it to the engine (as if [`Self::houdini_env_files`] was used.
-    pub fn env_variables<I, K, V>(mut self, variables: I) -> Self
+    pub fn env_variables<'a, I, K, V>(mut self, variables: I) -> Self
     where
-        I: IntoIterator<Item = (K, V)>,
-        K: Into<String>,
-        V: Into<String>,
+        I: Iterator<Item = &'a (K, V)>,
+        K: ToString + 'a,
+        V: ToString + 'a,
     {
         self.env_variables.replace(
             variables
-                .into_iter()
-                .map(|(k, v)| (k.into(), v.into()))
+                .map(|(k, v)| (k.to_string(), v.to_string()))
                 .collect(),
         );
         self
@@ -956,6 +1046,12 @@ impl SessionOptionsBuilder {
         self
     }
 
+    /// Session init options [`SessionInfo`]
+    pub fn session_info(mut self, info: SessionInfo) -> Self {
+        self.session_info = info;
+        self
+    }
+
     /// Makes the server operate in threaded mode. See the official docs for more info.
     pub fn threaded(mut self, threaded: bool) -> Self {
         self.threaded = threaded;
@@ -973,6 +1069,7 @@ impl SessionOptionsBuilder {
         self.write_temp_env_file();
         SessionOptions {
             cook_opt: self.cook_opt,
+            session_info: self.session_info,
             threaded: self.threaded,
             cleanup: self.cleanup,
             ignore_already_init: self.cleanup,
@@ -1034,7 +1131,7 @@ impl From<i32> for SessionState {
             5 => SessionState::StartingLoad,
             6 => SessionState::Loading,
             7 => SessionState::Max,
-            _ => unreachable!(),
+            _ => panic!("Unmatched SessionState - {s}"),
         }
     }
 }
@@ -1042,43 +1139,29 @@ impl From<i32> for SessionState {
 /// Spawn a new pipe Engine process and return its PID
 pub fn start_engine_pipe_server(
     path: impl AsRef<Path>,
-    auto_close: bool,
-    timeout: f32,
-    verbosity: StatusVerbosity,
     log_file: Option<&str>,
+    options: &ThriftServerOptions,
 ) -> Result<u32> {
     debug!("Starting named pipe server: {:?}", path.as_ref());
-    let opts = crate::ffi::raw::HAPI_ThriftServerOptions {
-        autoClose: auto_close as i8,
-        timeoutMs: timeout,
-        verbosity,
-    };
     let log_file = log_file.map(CString::new).transpose()?;
     let c_str = utils::path_to_cstring(path)?;
     crate::ffi::clear_connection_error()?;
-    crate::ffi::start_thrift_pipe_server(&c_str, &opts, log_file.as_deref())
+    crate::ffi::start_thrift_pipe_server(&c_str, &options.0, log_file.as_deref())
 }
 
 /// Spawn a new socket Engine server and return its PID
 pub fn start_engine_socket_server(
     port: u16,
-    auto_close: bool,
-    timeout: i32,
-    verbosity: StatusVerbosity,
     log_file: Option<&str>,
+    options: &ThriftServerOptions,
 ) -> Result<u32> {
     debug!("Starting socket server on port: {}", port);
-    let opts = crate::ffi::raw::HAPI_ThriftServerOptions {
-        autoClose: auto_close as i8,
-        timeoutMs: timeout as f32,
-        verbosity,
-    };
     let log_file = log_file.map(CString::new).transpose()?;
     crate::ffi::clear_connection_error()?;
-    crate::ffi::start_thrift_socket_server(port as i32, &opts, log_file.as_deref())
+    crate::ffi::start_thrift_socket_server(port as i32, &options.0, log_file.as_deref())
 }
 
-/// Start a interactive Houdini session with engine server embedded.
+/// Start an interactive Houdini session with engine server embedded.
 pub fn start_houdini_server(
     pipe_name: impl AsRef<str>,
     houdini_executable: impl AsRef<Path>,
@@ -1098,15 +1181,27 @@ pub fn start_houdini_server(
         .map_err(HapiError::from)
 }
 
+/// Spawn a new Engine server utilizing shared memory to transfer data.
+pub fn start_shared_memory_server(
+    memory_name: &str,
+    options: &ThriftServerOptions,
+    log_file: Option<&str>,
+) -> Result<u32> {
+    debug!("Starting shared memory server name: {memory_name}");
+    let memory_name = CString::new(memory_name)?;
+    let log_file = log_file.map(CString::new).transpose()?;
+    crate::ffi::clear_connection_error()?;
+    crate::ffi::start_thrift_shared_memory_server(&memory_name, &options.0, log_file.as_deref())
+}
+
 /// A quick drop-in session, useful for on-off jobs
-/// It starts a **single-threaded** pipe server and initialize a session with default options
+/// It starts a **single-threaded** shared memory server and initialize a session with default options
 pub fn quick_session(options: Option<&SessionOptions>) -> Result<Session> {
-    let file = tempfile::Builder::new()
-        .suffix("-hars.pipe")
-        .tempfile()
-        .expect("new temp file");
-    let (_, file) = file.keep().expect("persistent temp file");
-    let pid =
-        start_engine_pipe_server(&file, true, 4000.0, StatusVerbosity::Statusverbosity1, None)?;
-    connect_to_pipe(file, options, None, Some(pid))
+    let server_options = ThriftServerOptions::default()
+        .with_auto_close(true)
+        .with_timeout_ms(4000f32)
+        .with_verbosity(StatusVerbosity::Statusverbosity1);
+    let rand_memory_name = format!("shared-memory-{}", utils::random_string(16));
+    let pid = start_shared_memory_server(&rand_memory_name, &server_options, None)?;
+    connect_to_memory_server(&rand_memory_name, options, Some(pid))
 }
diff --git a/src/stringhandle.rs b/src/stringhandle.rs
index 9f0713c..d4cde9e 100644
--- a/src/stringhandle.rs
+++ b/src/stringhandle.rs
@@ -69,6 +69,10 @@ pub struct CStringIter<'a> {
 }
 
 impl<'a> StringArray {
+    /// Create an empty StringArray
+    pub fn empty() -> StringArray {
+        StringArray(vec![])
+    }
     /// Return an iterator over &str
     pub fn iter_str(&'a self) -> StringIter<'a> {
         StringIter { inner: &self.0 }
diff --git a/src/utils.rs b/src/utils.rs
index dd3e21a..50aa897 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -44,3 +44,16 @@ where
     }
     buf
 }
+
+/// Generates a random ascii a-z sequence of specified length
+pub fn random_string(len: usize) -> String {
+    use std::collections::hash_map::RandomState;
+    use std::hash::{BuildHasher, Hasher};
+
+    let mut seed = RandomState::new().build_hasher().finish();
+    let next = || {
+        seed = seed.wrapping_mul(1103515245).wrapping_add(12345);
+        ((seed % 26) + 97) as u8 as char
+    };
+    std::iter::repeat_with(next).take(len).collect()
+}
diff --git a/src/volume.rs b/src/volume.rs
index c41794f..9540c6c 100644
--- a/src/volume.rs
+++ b/src/volume.rs
@@ -153,9 +153,7 @@ pub(crate) fn iterate_tiles(
     tile_size: usize,
     callback: impl Fn(Tile),
 ) -> Result<()> {
-    let mut tile = VolumeTileInfo {
-        inner: crate::ffi::get_volume_first_tile_info(node, part)?,
-    };
+    let mut tile = VolumeTileInfo(crate::ffi::get_volume_first_tile_info(node, part)?);
     let mut tile_num = 0;
     while tile.is_valid() {
         callback(Tile {
@@ -163,7 +161,7 @@ pub(crate) fn iterate_tiles(
             size: tile_size,
             index: tile_num,
         });
-        crate::ffi::get_volume_next_tile_info(node, part, &mut tile.inner)?;
+        crate::ffi::get_volume_next_tile_info(node, part, &mut tile.0)?;
         tile_num += 1;
     }
     Ok(())
diff --git a/tests/data/bone.idx b/tests/data/bone.idx
new file mode 100644
index 0000000..5a1fb88
Binary files /dev/null and b/tests/data/bone.idx differ
diff --git a/tests/geometry.rs b/tests/geometry.rs
index 48ef59a..67a1777 100644
--- a/tests/geometry.rs
+++ b/tests/geometry.rs
@@ -69,7 +69,7 @@ fn _create_triangle(geo: &Geometry) {
 }
 
 fn _create_single_point_geo(session: &Session) -> Result<Geometry> {
-    let geo = session.create_input_node("dummy")?;
+    let geo = session.create_input_node("dummy", None)?;
     let part = PartInfo::default()
         .with_part_type(PartType::Mesh)
         .with_point_count(1);
@@ -111,14 +111,17 @@ fn geometry_attribute_names() {
         let node = session.create_node("Object/hapi_geo").unwrap();
         node.cook_blocking().unwrap();
         let geo = node.geometry().unwrap().expect("geometry");
+        let part = geo.part_info(0).unwrap().unwrap();
         let iter = geo
-            .get_attribute_names(AttributeOwner::Point, None)
+            .get_attribute_names(AttributeOwner::Point, &part)
             .unwrap();
         let names: Vec<_> = iter.iter_str().collect();
         assert!(names.contains(&"Cd"));
         assert!(names.contains(&"my_float_array"));
         assert!(names.contains(&"pscale"));
-        let iter = geo.get_attribute_names(AttributeOwner::Prim, None).unwrap();
+        let iter = geo
+            .get_attribute_names(AttributeOwner::Prim, &part)
+            .unwrap();
         let names: Vec<_> = iter.iter_str().collect();
         assert!(names.contains(&"primname"));
         assert!(names.contains(&"shop_materialpath"));
@@ -128,7 +131,7 @@ fn geometry_attribute_names() {
 #[test]
 fn geometry_numeric_attributes() {
     SESSION.with(|session| {
-        let geo = session.create_input_node("test").unwrap();
+        let geo = session.create_input_node("test", None).unwrap();
         _create_triangle(&geo);
         // Generic way to get an attribute
         let _attr_p = geo
@@ -147,7 +150,7 @@ fn geometry_numeric_attributes() {
 #[test]
 fn geometry_create_string_attrib() {
     SESSION.with(|session| {
-        let geo = session.create_input_node("test").unwrap();
+        let geo = session.create_input_node("test", None).unwrap();
         _create_triangle(&geo);
         let part = geo.part_info(0).unwrap().expect("part 0");
         let info = AttributeInfo::default()
@@ -171,14 +174,67 @@ fn geometry_create_string_attrib() {
         let mut iter = str_array.iter_str();
         assert_eq!(iter.next(), Some("pt0"));
         assert_eq!(iter.last(), Some("pt2"));
+
         geo.node.delete().unwrap();
     })
 }
 
+#[test]
+fn geometry_set_unique_str_attrib_value() {
+    SESSION.with(|session| {
+        let geo = session
+            .create_input_node("unique-attr-value", None)
+            .unwrap();
+        _create_triangle(&geo);
+        let part = geo.part_info(0).unwrap().expect("part 0");
+        let info = AttributeInfo::default()
+            .with_owner(AttributeOwner::Point)
+            .with_storage(StorageType::String)
+            .with_tuple_size(1)
+            .with_count(part.point_count());
+
+        let attr = geo.add_string_attribute("name", 0, info).unwrap();
+        attr.set_unique(part.part_id(), "unique").unwrap();
+        geo.commit().unwrap();
+        geo.node.cook_blocking().unwrap();
+
+        let str_array = attr.get(part.part_id()).unwrap();
+        let mut iter = str_array.iter_str();
+        assert_eq!(iter.next(), Some("unique"));
+        assert_eq!(iter.last(), Some("unique"));
+    })
+}
+
+#[test]
+fn geometry_set_unique_int_attrib_value() {
+    SESSION.with(|session| {
+        let geo = session
+            .create_input_node("unique-int-attr-value", None)
+            .unwrap();
+        _create_triangle(&geo);
+        let part = geo.part_info(0).unwrap().expect("part 0");
+        let info = AttributeInfo::default()
+            .with_owner(AttributeOwner::Point)
+            .with_storage(StorageType::Int)
+            .with_tuple_size(2)
+            .with_count(part.point_count());
+
+        let data_size = (info.tuple_size() * info.count()) as usize;
+        let attr = geo.add_numeric_attribute::<i32>("value", 0, info).unwrap();
+        attr.set_unique(part.part_id(), &[8, 1]).unwrap();
+        geo.commit().unwrap();
+        geo.node.cook_blocking().unwrap();
+
+        let str_array = attr.get(part.part_id()).unwrap();
+        assert_eq!(str_array.len(), data_size);
+        assert_eq!(&str_array[0..=1], &[8, 1]);
+    })
+}
+
 #[test]
 fn geometry_create_string_array_attrib() {
     SESSION.with(|session| {
-        let geo = session.create_input_node("test").unwrap();
+        let geo = session.create_input_node("test", None).unwrap();
         _create_triangle(&geo);
         let part = geo.part_info(0).unwrap().expect("part 0");
         let info = AttributeInfo::default()
@@ -238,7 +294,7 @@ fn geometry_read_array_attributes() {
 #[test]
 fn geometry_create_and_set_array_attributes() {
     SESSION.with(|session| {
-        let input = session.create_input_node("test").unwrap();
+        let input = session.create_input_node("test", None).unwrap();
         let part = PartInfo::default()
             .with_part_type(PartType::Mesh)
             .with_face_count(0)
@@ -337,14 +393,14 @@ fn geometry_string_array_attribute() {
 #[test]
 fn geometry_save_and_load_to_file() {
     SESSION.with(|session| {
-        let geo = session.create_input_node("triangle").unwrap();
+        let geo = session.create_input_node("triangle", None).unwrap();
         _create_triangle(&geo);
         let tmp_file = std::env::temp_dir().join("triangle.geo");
         geo.save_to_file(&tmp_file.to_string_lossy())
             .expect("save_to_file");
         geo.node.delete().unwrap();
 
-        let geo = session.create_input_node("dummy").unwrap();
+        let geo = session.create_input_node("dummy", None).unwrap();
         geo.load_from_file(&tmp_file.to_string_lossy())
             .expect("load_from_file");
         geo.node.cook().unwrap();
@@ -356,14 +412,14 @@ fn geometry_save_and_load_to_file() {
 #[test]
 fn geometry_save_and_load_to_memory() {
     SESSION.with(|session| {
-        let src_geo = session.create_input_node("source").unwrap();
+        let src_geo = session.create_input_node("source", None).unwrap();
         _create_triangle(&src_geo);
         let blob = src_geo
             .save_to_memory(GeoFormat::Geo)
             .expect("save_geo_to_memory");
         src_geo.node.delete().unwrap();
 
-        let dest_geo = session.create_input_node("dest").unwrap();
+        let dest_geo = session.create_input_node("dest", None).unwrap();
         _create_triangle(&dest_geo);
         dest_geo
             .load_from_memory(&blob, GeoFormat::Geo)
@@ -375,7 +431,7 @@ fn geometry_save_and_load_to_memory() {
 #[test]
 fn geometry_commit_and_revert() {
     SESSION.with(|session| {
-        let geo = session.create_input_node("input").unwrap();
+        let geo = session.create_input_node("input", None).unwrap();
         _create_triangle(&geo);
         geo.commit().unwrap();
         geo.node.cook_blocking().unwrap();
@@ -396,30 +452,30 @@ fn geometry_elements() {
         let part = geo.part_info(0).unwrap().expect("part 0");
         // Cube
         let points = geo
-            .get_element_count_by_owner(Some(&part), AttributeOwner::Point)
+            .get_element_count_by_owner(&part, AttributeOwner::Point)
             .unwrap();
         assert_eq!(points, 8);
         assert_eq!(points, part.point_count());
         let prims = geo
-            .get_element_count_by_owner(Some(&part), AttributeOwner::Prim)
+            .get_element_count_by_owner(&part, AttributeOwner::Prim)
             .unwrap();
         assert_eq!(prims, 6);
         assert_eq!(prims, part.face_count());
         let vtx = geo
-            .get_element_count_by_owner(Some(&part), AttributeOwner::Vertex)
+            .get_element_count_by_owner(&part, AttributeOwner::Vertex)
             .unwrap();
         assert_eq!(vtx, 24);
         assert_eq!(vtx, part.vertex_count());
         let num_pt = geo
-            .get_attribute_count_by_owner(Some(&part), AttributeOwner::Point)
+            .get_attribute_count_by_owner(&part, AttributeOwner::Point)
             .unwrap();
         assert_eq!(num_pt, 8);
         let num_pr = geo
-            .get_attribute_count_by_owner(Some(&part), AttributeOwner::Prim)
+            .get_attribute_count_by_owner(&part, AttributeOwner::Prim)
             .unwrap();
         assert_eq!(num_pr, 3);
         let num_det = geo
-            .get_attribute_count_by_owner(Some(&part), AttributeOwner::Detail)
+            .get_attribute_count_by_owner(&part, AttributeOwner::Detail)
             .unwrap();
         assert_eq!(num_det, 4);
         let pr_groups = geo.get_group_names(GroupType::Prim).unwrap();
@@ -437,7 +493,7 @@ fn geometry_elements() {
 #[test]
 fn geometry_delete_attribute() {
     SESSION.with(|session| {
-        let geo = session.create_input_node("input").unwrap();
+        let geo = session.create_input_node("input", None).unwrap();
         _create_triangle(&geo);
         let id_attr = geo
             .get_attribute(0, AttributeOwner::Point, "id")
@@ -456,7 +512,7 @@ fn geometry_delete_attribute() {
 #[test]
 fn geometry_partitions() {
     SESSION.with(|session| {
-        let geo = session.create_input_node("input").unwrap();
+        let geo = session.create_input_node("input", None).unwrap();
         _create_triangle(&geo);
         assert_eq!(geo.partitions().unwrap().len(), 1);
         assert!(matches!(geo.part_info(100), Ok(None)));
@@ -466,7 +522,7 @@ fn geometry_partitions() {
 #[test]
 fn geometry_add_and_delete_group() {
     SESSION.with(|session| {
-        let geo = session.create_input_node("input").unwrap();
+        let geo = session.create_input_node("input", None).unwrap();
         _create_triangle(&geo);
         geo.add_group(0, GroupType::Point, "test", Some(&[1, 1, 1]))
             .unwrap();
@@ -494,26 +550,26 @@ fn geometry_basic_instancing() {
         let opt =
             CookOptions::default().with_packed_prim_instancing_mode(PackedPrimInstancingMode::Flat);
         node.cook_with_options(&opt, true).unwrap();
-        let outputs = node.geometry_output_nodes().unwrap();
-        let instancer = outputs.get(1).unwrap();
-        let ids = instancer.get_instanced_part_ids(None).unwrap();
+        let instancer = node
+            .get_child_by_path("instance")
+            .unwrap()
+            .expect("instance node");
+        let geo = instancer.geometry().unwrap().expect("geometry");
+        let part = geo.part_info(0).unwrap().expect("part id=0");
+        let ids = geo.get_instanced_part_ids(&part).unwrap();
         assert_eq!(ids.len(), 1);
-        let names = instancer
+        let names = geo
             .get_instance_part_groups_names(GroupType::Prim, ids[0])
             .unwrap();
         let names: Vec<String> = names.into_iter().collect();
-        assert_eq!(names.first().unwrap(), "group_1");
-        assert_eq!(names.last().unwrap(), "group_6");
-        let transforms = instancer
-            .get_instance_part_transforms(None, RSTOrder::Srt)
+        assert!(names.contains(&String::from("group_1")));
+        assert!(names.contains(&String::from("group_6")));
+        let transforms = geo
+            .get_instance_part_transforms(&part, RSTOrder::Srt)
             .unwrap();
         assert_eq!(
             transforms.len() as i32,
-            instancer
-                .part_info(0)
-                .unwrap()
-                .expect("part 0")
-                .instance_count()
+            geo.part_info(0).unwrap().expect("part 0").instance_count()
         );
     })
 }
@@ -524,7 +580,8 @@ fn geometry_get_face_materials() {
         let node = session.create_node("Object/spaceship").unwrap();
         node.cook_blocking().unwrap();
         let geo = node.geometry().expect("geometry").unwrap();
-        let mats = geo.get_materials(None).expect("materials");
+        let part = geo.part_info(0).unwrap().expect("part id=0");
+        let mats = geo.get_materials(&part).expect("materials");
         assert!(matches!(mats, Some(Materials::Single(_))));
     })
 }
@@ -532,7 +589,7 @@ fn geometry_get_face_materials() {
 #[test]
 fn geometry_create_input_curve() {
     SESSION.with(|session| {
-        let geo = session.create_input_curve_node("InputCurve").unwrap();
+        let geo = session.create_input_curve_node("InputCurve", None).unwrap();
         let positions = &[0.0, 0.0, 0.0, 1.0, 1.0, 1.0];
         geo.set_input_curve_positions(0, positions).unwrap();
         let p = geo.get_position_attribute(0).unwrap();
@@ -544,7 +601,7 @@ fn geometry_create_input_curve() {
 #[test]
 fn geometry_multiple_input_curves() {
     SESSION.with(|session| {
-        let geo = session.create_input_node("InputCurves").unwrap();
+        let geo = session.create_input_node("InputCurves", None).unwrap();
         let points = vec![
             0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 2.0, 0.0, 0.0, 2.0, 1.0,
             0.0,
@@ -589,7 +646,7 @@ fn geometry_read_write_volume() {
         let source = node.geometry().unwrap().unwrap();
         let source_part = source.part_info(0).unwrap().expect("part 0");
         let vol_info = source.volume_info(0).unwrap();
-        let dest_geo = session.create_input_node("volume_copy").unwrap();
+        let dest_geo = session.create_input_node("volume_copy", None).unwrap();
         dest_geo.node.cook_blocking().unwrap();
         dest_geo.set_part_info(&source_part).unwrap();
         dest_geo.set_volume_info(0, &vol_info).unwrap();
@@ -636,6 +693,46 @@ fn geometry_test_get_dictionary_attributes() {
     })
 }
 
+#[test]
+#[ignore]
+fn geometry_test_get_numeric_attribute_async() {
+    SESSION.with(|session| {
+        let geo = _load_test_geometry(&session).unwrap();
+        let float_attr = geo
+            .get_attribute(0, AttributeOwner::Point, "pscale")
+            .unwrap()
+            .unwrap();
+        let Some(attr) = float_attr.downcast::<NumericAttr<f32>>() else {
+            panic!("Not a numeric attribute");
+        };
+
+        let mut buf = Vec::new();
+        let job = attr.get_async(0, &mut buf).unwrap();
+        while JobStatus::Idle != session.get_job_status(job).unwrap() {
+            println!("Cooking");
+        }
+        dbg!(buf);
+    })
+}
+
+#[test]
+#[ignore]
+fn geometry_test_get_string_attribute_async() {
+    SESSION.with(|session| {
+        let geo = _load_test_geometry(&session).unwrap();
+        let str_attr = geo
+            .get_attribute(0, AttributeOwner::Point, "ptname")
+            .unwrap()
+            .unwrap();
+        let Some(attr) = str_attr.downcast::<StringAttr>() else {
+            panic!("Not a string attribute");
+        };
+
+        let result = attr.get_async(0).unwrap();
+        let _data = result.wait().unwrap();
+    })
+}
+
 #[test]
 fn geometry_test_set_dictionary_attributes() {
     use std::collections::HashMap;
@@ -679,15 +776,13 @@ fn geometry_test_get_set_dictionary_array_attribute() {
     SESSION.with(|session| {
         let geo = _create_single_point_geo(session).expect("Sphere geometry");
         let info = AttributeInfo::default()
-            .with_count(2)
+            .with_count(1)
             .with_tuple_size(1)
             .with_owner(AttributeOwner::Detail)
             .with_storage(StorageType::DictionaryArray);
         let attr = geo
             .add_dictionary_array_attribute("my_dict_attr", 0, info)
             .expect("Dictionary array attribute");
-        geo.commit().unwrap();
-        geo.node.cook_blocking().unwrap();
 
         let dict_1: HashMap<String, JsonValue> = [
             ("number".to_string(), JsonValue::Number(1.0)),
@@ -706,5 +801,24 @@ fn geometry_test_get_set_dictionary_array_attribute() {
         ];
         attr.set(&data, &[2])
             .expect("Dictionary array attribute set");
+        geo.commit().unwrap();
+    })
+}
+
+#[test]
+fn test_attribute_send() {
+    SESSION.with(|session| {
+        let geo = _load_test_geometry(&session).unwrap();
+        let str_attr = geo
+            .get_attribute(0, AttributeOwner::Point, "pscale")
+            .unwrap()
+            .unwrap();
+        std::thread::spawn(move || {
+            if let Some(attr) = str_attr.downcast::<NumericAttr<f32>>() {
+                let _ = attr.get(0);
+            }
+        })
+        .join()
+        .unwrap();
     })
 }
diff --git a/tests/material.rs b/tests/material.rs
index 564f64f..d00d502 100644
--- a/tests/material.rs
+++ b/tests/material.rs
@@ -27,7 +27,8 @@ fn image_extract_api() {
     let node = SESSION.create_node("Object/spaceship").unwrap();
     node.cook_blocking().unwrap();
     let geo = node.geometry().expect("geometry").unwrap();
-    let mats = geo.get_materials(None).unwrap().expect("materials");
+    let part = geo.part_info(0).unwrap().unwrap();
+    let mats = geo.get_materials(&part).unwrap().expect("materials");
     if let Materials::Single(mat) = mats {
         let mut info = mat.get_image_info().unwrap();
         info.set_x_res(512);
diff --git a/tests/parameters.rs b/tests/parameters.rs
index 1c74fde..8b6f079 100644
--- a/tests/parameters.rs
+++ b/tests/parameters.rs
@@ -145,9 +145,9 @@ fn parameter_tags() {
         if let Ok(Parameter::Button(parm)) = node.parameter("button") {
             assert!(parm.has_tag("script_callback").unwrap());
             let tag_name = parm.get_tag_name(0).unwrap();
-            assert_eq!(tag_name, "script_callback");
-            let tag_value = parm.get_tag_value("script_callback").unwrap();
-            assert_eq!(tag_value, "hou.phm().callback(kwargs)");
+            assert_eq!(tag_name, "script_callback_language");
+            let tag_value = parm.get_tag_value("script_callback_language").unwrap();
+            assert_eq!(tag_value, "python");
         }
     })
 }
diff --git a/tests/pdg.rs b/tests/pdg.rs
index ff6e1c9..4aa58af 100644
--- a/tests/pdg.rs
+++ b/tests/pdg.rs
@@ -27,7 +27,7 @@ fn pdg_create_workitems() -> Result<()> {
     workitem.set_int_data("my_int_data", &[1, 2, 3])?;
     workitem.set_float_data("my_float_data", &[1.0, 2.0, 3.0])?;
     generator.commit_workitems()?;
-    generator.cook_pdg_blocking()?;
+    generator.cook_pdg_blocking(false)?;
     let i_data = workitem.get_int_data("my_int_data")?;
     assert_eq!(&i_data, &[1, 2, 3]);
     let f_data = workitem.get_float_data("my_float_data")?;
diff --git a/tests/session.rs b/tests/session.rs
index 2aa4a4e..e64e6e5 100644
--- a/tests/session.rs
+++ b/tests/session.rs
@@ -50,7 +50,7 @@ fn session_init_and_teardown() {
     let ses = quick_session(Some(&opt)).unwrap();
     assert!(matches!(
         ses.connection_type(),
-        ConnectionType::ThriftPipe(_)
+        ConnectionType::SharedMemory(_)
     ));
     assert!(ses.is_initialized());
     assert!(ses.is_valid());
@@ -144,3 +144,21 @@ fn cache_properties() {
         assert_eq!(cache_val, 2048);
     })
 }
+
+#[test]
+fn test_license_set_via_environment() {
+    let env = [("HOUDINI_PLUGIN_LIC_OPT", "--check-licenses=Engine")];
+    let options = SessionOptions::builder().env_variables(env.iter()).build();
+    let session = quick_session(Some(&options)).expect("Could not start session");
+    let plugin_lic_opt = session.get_server_var::<str>(&env[0].0).unwrap();
+    assert_eq!(plugin_lic_opt, env[0].1.to_string());
+}
+
+#[test]
+fn test_get_preset_names() {
+    let bytes = std::fs::read("tests/data/bone.idx").expect("read file");
+    SESSION.with(|session| {
+        log::info!("Reading preset file");
+        session.get_preset_names(&bytes).expect("2 presets");
+    })
+}