diff --git a/Cargo.toml b/Cargo.toml
index 514bb6e4..6ac50511 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,18 +1,19 @@
 [workspace]
 members = [
     "examples/echo_client_native",
-    #"examples/echo_client_wt", # requires wasm32-unknown-unknown target
+    #"examples/echo_client_wasm", # requires wasm32-unknown-unknown target
     "examples/echo_server_cross",
     "demo_chat",
     "demo_bevy",
     "bevy_renet2",
     "bevy_replicon_renet2",
     "renet2",
+    "renet2_netcode",
     "renet2_visualizer",
     "renet2_steam",
     "renetcode2",
 ]
 exclude = [
-    "examples/echo_client_wt",
+    "examples/echo_client_wasm",
 ]
 resolver = "2"
diff --git a/README.md b/README.md
index fc63748a..e3516891 100644
--- a/README.md
+++ b/README.md
@@ -28,13 +28,15 @@ Provides the following features:
 Renet2 extends the original [netcode](https://github.com/networkprotocol/netcode) protocol with:
 
 - Optional packet encryption. This supports data transports that do their own encryption.
-- Servers with multiple concurrent data sources (e.g. UDP sockets and WebTransport).
+- Optional transport reliability. This supports data transports that are automatically reliable.
+- Servers with multiple concurrent data transports (e.g. UDP sockets and WebTransport).
 
 See `renetcode2/NETCODE_EXTENSIONS.md`.
 
 ### Features
 
 - Includes built-in data transports: UDP, memory channels, WebTransport, WebSockets.
+    - See `src/examples` for a fully cross-platform demo.
 
 
 ## Building docs
@@ -44,10 +46,10 @@ Build workspace docs (no WASM):
 cargo doc --open --no-deps --all-features
 ```
 
-Build WASM docs (`renet2` workspace crate only):
+Build WASM docs (`renet2_netcode` workspace crate only):
 ```
-cd renet2 &&\
-cargo doc --open --no-deps --no-default-features --features=wt_client_transport,ws_client_transport,transport --target wasm32-unknown-unknown
+cd renet2_netcode &&\
+cargo doc --open --no-deps --no-default-features --features=wt_client_transport,ws_client_transport --target wasm32-unknown-unknown
 ```
 
 
@@ -133,7 +135,7 @@ loop {
     // Send a text message for all clients
     server.broadcast_message(DefaultChannel::ReliableOrdered, "server message");
 
-    let client_id = ClientId::from_raw(0);
+    let client_id = 0;
     // Send a text message for all clients except for Client 0
     server.broadcast_message_except(client_id, DefaultChannel::ReliableOrdered, "server message");
     
diff --git a/bevy_renet2/Cargo.toml b/bevy_renet2/Cargo.toml
index 0284db9a..8e156463 100644
--- a/bevy_renet2/Cargo.toml
+++ b/bevy_renet2/Cargo.toml
@@ -9,32 +9,39 @@ readme = "README.md"
 repository = "https://github.com/UkoeHB/renet2"
 
 [package.metadata.docs.rs]
-features = ["default", "serde", "native_transport", "memory_transport", "wt_server_transport"]
+features = ["default", "serde"]
 rustdoc-args = ["-Zunstable-options", "--cfg", "docsrs"]
 
 [features]
-default = ["transport"]
-serde = ["renet2/serde"]
-transport = ["renet2/transport"]
-native_transport = ["transport", "renet2/native_transport"]
-memory_transport = ["transport", "renet2/memory_transport"]
-wt_server_transport = ["transport", "renet2/wt_server_transport"]
-wt_client_transport = ["transport", "renet2/wt_client_transport"]
+default = ["netcode"]
+serde = ["renet2_netcode/serde"]
+steam = ["dep:renet2_steam", "dep:steamworks"]
+netcode = ["dep:renet2_netcode"]
+native_transport = ["netcode", "renet2_netcode/native_transport"]
+memory_transport = ["netcode", "renet2_netcode/memory_transport"]
+wt_server_transport = ["netcode", "renet2_netcode/wt_server_transport"]
+wt_client_transport = ["netcode", "renet2_netcode/wt_client_transport"]
+ws_server_transport = ["netcode", "renet2_netcode/ws_server_transport"]
+ws_client_transport = ["netcode", "renet2_netcode/ws_client_transport"]
 
 [[example]]
 name = "simple"
-required-features = ["serde", "transport"]
+required-features = ["serde", "netcode"]
 
 [dependencies]
 bevy_app = {version = "0.15", default-features = false}
 bevy_ecs = {version = "0.15", default-features = false}
 bevy_time = {version = "0.15", default-features = false}
 renet2 = {path = "../renet2", version = "0.0.7", default-features = false, features = ["bevy"]}
+renet2_netcode = {path = "../renet2_netcode", version = "0.0.7", optional = true, default-features = false, features = ["bevy"]}
+renet2_steam = {path = "../renet2_steam", version = "0.0.7", optional = true, default-features = false, features = ["bevy"]}
+steamworks = {version = "0.11", optional = true}
 
 [dev-dependencies]
 bevy = {version = "0.15", default-features = false, features = ["bevy_core_pipeline", "bevy_render", "bevy_asset", "bevy_pbr", "x11", "tonemapping_luts", "ktx2", "zstd"]}
 bincode = "1.3"
 env_logger = "0.11"
-renet2 = {path = "../renet2", version = "0.0.7", default-features = false, features = ["bevy", "memory_transport"]}
+renet2 = {path = "../renet2", version = "0.0.7", default-features = false, features = ["bevy"] }
+renet2_netcode = {path = "../renet2_netcode", version = "0.0.7", default-features = false, features = ["bevy", "memory_transport"]}
 serde = {version = "1.0", features = ["derive"]}
 tracing-subscriber = { version = "0.3", features = [ "env-filter", "std", "tracing-log" ] }
diff --git a/bevy_renet2/examples/simple.rs b/bevy_renet2/examples/simple.rs
index b5a3ea91..8891ada3 100644
--- a/bevy_renet2/examples/simple.rs
+++ b/bevy_renet2/examples/simple.rs
@@ -1,16 +1,11 @@
 use bevy::{prelude::*, render::mesh::PlaneMeshBuilder};
-use bevy_renet2::{
-    client_connected,
-    renet2::{
-        transport::{ClientAuthentication, ServerAuthentication, ServerSetupConfig},
-        ConnectionConfig, DefaultChannel, RenetClient, RenetServer, ServerEvent,
-    },
-    transport::{NetcodeClientPlugin, NetcodeServerPlugin},
-    RenetClientPlugin, RenetServerPlugin,
+use bevy_renet2::netcode::{
+    ClientAuthentication, NativeSocket, NetcodeClientPlugin, NetcodeClientTransport, NetcodeServerPlugin, NetcodeServerTransport,
+    NetcodeTransportError, ServerAuthentication, ServerSetupConfig,
 };
-use renet2::{
-    transport::{NativeSocket, NetcodeClientTransport, NetcodeServerTransport, NetcodeTransportError},
-    ClientId,
+use bevy_renet2::prelude::{
+    client_connected, ClientId, ConnectionConfig, DefaultChannel, RenetClient, RenetClientPlugin, RenetServer, RenetServerPlugin,
+    ServerEvent,
 };
 
 use std::time::SystemTime;
diff --git a/bevy_renet2/src/lib.rs b/bevy_renet2/src/lib.rs
index db7460f3..f614995e 100644
--- a/bevy_renet2/src/lib.rs
+++ b/bevy_renet2/src/lib.rs
@@ -1,117 +1,15 @@
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
-pub use renet2;
 
-use bevy_app::prelude::*;
-use bevy_ecs::prelude::*;
-use bevy_time::prelude::*;
+#[cfg(feature = "netcode")]
+pub mod netcode;
 
-use renet2::{RenetClient, RenetServer, ServerEvent};
+#[cfg(feature = "steam")]
+pub mod steam;
 
-#[cfg(feature = "transport")]
-pub mod transport;
+mod renet2;
+mod run_conditions;
 
-/// This system set is where all transports receive messages
-///
-/// If you want to ensure data has arrived in the [`RenetClient`] or [`RenetServer`], then schedule your
-/// system after this set.
-///
-/// This system set runs in PreUpdate.
-#[derive(Debug, SystemSet, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct RenetReceive;
-
-/// This system set is where all transports send messages
-///
-/// If you want to ensure your packets have been registered by the [`RenetClient`] or [`RenetServer`], then
-/// schedule your system before this set.
-///
-/// This system set runs in PostUpdate.
-#[derive(Debug, SystemSet, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct RenetSend;
-
-pub struct RenetServerPlugin;
-
-pub struct RenetClientPlugin;
-
-impl Plugin for RenetServerPlugin {
-    fn build(&self, app: &mut App) {
-        app.init_resource::<Events<ServerEvent>>();
-        app.add_systems(PreUpdate, Self::update_system.run_if(resource_exists::<RenetServer>));
-        app.add_systems(
-            PreUpdate,
-            Self::emit_server_events_system
-                .in_set(RenetReceive)
-                .run_if(resource_exists::<RenetServer>)
-                .after(Self::update_system),
-        );
-    }
-}
-
-impl RenetServerPlugin {
-    pub fn update_system(mut server: ResMut<RenetServer>, time: Res<Time>) {
-        server.update(time.delta());
-    }
-
-    pub fn emit_server_events_system(mut server: ResMut<RenetServer>, mut server_events: EventWriter<ServerEvent>) {
-        while let Some(event) = server.get_event() {
-            server_events.send(event);
-        }
-    }
-}
-
-impl Plugin for RenetClientPlugin {
-    fn build(&self, app: &mut App) {
-        app.add_systems(PreUpdate, Self::update_system.run_if(client_should_update()));
-    }
-}
-
-impl RenetClientPlugin {
-    pub fn update_system(mut client: ResMut<RenetClient>, time: Res<Time>) {
-        client.update(time.delta());
-    }
-}
-
-pub fn client_connected(client: Option<Res<RenetClient>>) -> bool {
-    match client {
-        Some(client) => client.is_connected(),
-        None => false,
-    }
-}
-
-pub fn client_disconnected(client: Option<Res<RenetClient>>) -> bool {
-    match client {
-        Some(client) => client.is_disconnected(),
-        None => true,
-    }
-}
-
-pub fn client_connecting(client: Option<Res<RenetClient>>) -> bool {
-    match client {
-        Some(client) => client.is_connecting(),
-        None => false,
-    }
-}
-
-pub fn client_just_connected(mut last_connected: Local<bool>, client: Option<Res<RenetClient>>) -> bool {
-    let connected = client.map(|client| client.is_connected()).unwrap_or(false);
-
-    let just_connected = !*last_connected && connected;
-    *last_connected = connected;
-    just_connected
-}
-
-pub fn client_just_disconnected(mut last_connected: Local<bool>, client: Option<Res<RenetClient>>) -> bool {
-    let disconnected = client.map(|client| client.is_disconnected()).unwrap_or(true);
-
-    let just_disconnected = *last_connected && disconnected;
-    *last_connected = !disconnected;
-    just_disconnected
-}
-
-pub fn client_should_update() -> impl Condition<()> {
-    // (just_disconnected || !disconnected) && exists<RenetClient>
-    IntoSystem::into_system(
-        client_just_disconnected
-            .or(not(client_disconnected))
-            .and(resource_exists::<RenetClient>),
-    )
+pub mod prelude {
+    pub use crate::renet2::*;
+    pub use crate::run_conditions::*;
 }
diff --git a/bevy_renet2/src/transport.rs b/bevy_renet2/src/netcode.rs
similarity index 94%
rename from bevy_renet2/src/transport.rs
rename to bevy_renet2/src/netcode.rs
index 1bf139bd..ad025617 100644
--- a/bevy_renet2/src/transport.rs
+++ b/bevy_renet2/src/netcode.rs
@@ -1,13 +1,12 @@
-use renet2::{
-    transport::{NetcodeClientTransport, NetcodeServerTransport, NetcodeTransportError},
-    RenetClient, RenetServer,
-};
+pub use renet2_netcode::*;
+
+use renet2::{RenetClient, RenetServer};
 
 use bevy_app::{prelude::*, AppExit};
 use bevy_ecs::prelude::*;
 use bevy_time::prelude::*;
 
-use crate::{client_should_update, RenetClientPlugin, RenetReceive, RenetSend, RenetServerPlugin};
+use crate::prelude::{client_should_update, RenetClientPlugin, RenetReceive, RenetSend, RenetServerPlugin};
 
 pub struct NetcodeServerPlugin;
 
diff --git a/bevy_renet2/src/renet2.rs b/bevy_renet2/src/renet2.rs
new file mode 100644
index 00000000..ea03d078
--- /dev/null
+++ b/bevy_renet2/src/renet2.rs
@@ -0,0 +1,67 @@
+pub use renet2::*;
+
+use bevy_app::prelude::*;
+use bevy_ecs::prelude::*;
+use bevy_time::prelude::*;
+
+use crate::prelude::client_should_update;
+
+/// This system set is where all transports receive messages
+///
+/// If you want to ensure data has arrived in the [`RenetClient`] or [`RenetServer`], then schedule your
+/// system after this set.
+///
+/// This system set runs in PreUpdate.
+#[derive(Debug, SystemSet, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct RenetReceive;
+
+/// This system set is where all transports send messages
+///
+/// If you want to ensure your packets have been registered by the [`RenetClient`] or [`RenetServer`], then
+/// schedule your system before this set.
+///
+/// This system set runs in PostUpdate.
+#[derive(Debug, SystemSet, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct RenetSend;
+
+pub struct RenetServerPlugin;
+
+pub struct RenetClientPlugin;
+
+impl Plugin for RenetServerPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<Events<ServerEvent>>();
+        app.add_systems(PreUpdate, Self::update_system.run_if(resource_exists::<RenetServer>));
+        app.add_systems(
+            PreUpdate,
+            Self::emit_server_events_system
+                .in_set(RenetReceive)
+                .run_if(resource_exists::<RenetServer>)
+                .after(Self::update_system),
+        );
+    }
+}
+
+impl RenetServerPlugin {
+    pub fn update_system(mut server: ResMut<RenetServer>, time: Res<Time>) {
+        server.update(time.delta());
+    }
+
+    pub fn emit_server_events_system(mut server: ResMut<RenetServer>, mut server_events: EventWriter<ServerEvent>) {
+        while let Some(event) = server.get_event() {
+            server_events.send(event);
+        }
+    }
+}
+
+impl Plugin for RenetClientPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(PreUpdate, Self::update_system.run_if(client_should_update()));
+    }
+}
+
+impl RenetClientPlugin {
+    pub fn update_system(mut client: ResMut<RenetClient>, time: Res<Time>) {
+        client.update(time.delta());
+    }
+}
diff --git a/bevy_renet2/src/run_conditions.rs b/bevy_renet2/src/run_conditions.rs
new file mode 100644
index 00000000..0230e6bb
--- /dev/null
+++ b/bevy_renet2/src/run_conditions.rs
@@ -0,0 +1,49 @@
+use bevy_ecs::prelude::*;
+
+use renet2::RenetClient;
+
+pub fn client_connected(client: Option<Res<RenetClient>>) -> bool {
+    match client {
+        Some(client) => client.is_connected(),
+        None => false,
+    }
+}
+
+pub fn client_disconnected(client: Option<Res<RenetClient>>) -> bool {
+    match client {
+        Some(client) => client.is_disconnected(),
+        None => true,
+    }
+}
+
+pub fn client_connecting(client: Option<Res<RenetClient>>) -> bool {
+    match client {
+        Some(client) => client.is_connecting(),
+        None => false,
+    }
+}
+
+pub fn client_just_connected(mut last_connected: Local<bool>, client: Option<Res<RenetClient>>) -> bool {
+    let connected = client.map(|client| client.is_connected()).unwrap_or(false);
+
+    let just_connected = !*last_connected && connected;
+    *last_connected = connected;
+    just_connected
+}
+
+pub fn client_just_disconnected(mut last_connected: Local<bool>, client: Option<Res<RenetClient>>) -> bool {
+    let disconnected = client.map(|client| client.is_disconnected()).unwrap_or(true);
+
+    let just_disconnected = *last_connected && disconnected;
+    *last_connected = !disconnected;
+    just_disconnected
+}
+
+pub fn client_should_update() -> impl Condition<()> {
+    // (just_disconnected || !disconnected) && exists<RenetClient>
+    IntoSystem::into_system(
+        client_just_disconnected
+            .or(not(client_disconnected))
+            .and(resource_exists::<RenetClient>),
+    )
+}
diff --git a/renet2_steam/src/bevy.rs b/bevy_renet2/src/steam.rs
similarity index 94%
rename from renet2_steam/src/bevy.rs
rename to bevy_renet2/src/steam.rs
index eb73ea2f..6059b636 100644
--- a/renet2_steam/src/bevy.rs
+++ b/bevy_renet2/src/steam.rs
@@ -1,11 +1,11 @@
+pub use renet2_steam::*;
+
 use bevy_app::{prelude::*, AppExit};
 use bevy_ecs::prelude::*;
 use renet2::{RenetClient, RenetServer};
 use steamworks::SteamError;
 
-use bevy_renet2::{client_should_update, RenetClientPlugin, RenetReceive, RenetSend, RenetServerPlugin};
-
-pub use crate::{AccessPermission, SteamClientTransport, SteamServerConfig, SteamServerTransport};
+use crate::prelude::{client_should_update, RenetClientPlugin, RenetReceive, RenetSend, RenetServerPlugin};
 
 pub struct SteamServerPlugin;
 
diff --git a/bevy_renet2/tests/memory_sockets.rs b/bevy_renet2/tests/memory_sockets.rs
index e91aaef7..8f556c21 100644
--- a/bevy_renet2/tests/memory_sockets.rs
+++ b/bevy_renet2/tests/memory_sockets.rs
@@ -1,17 +1,11 @@
 use std::time::SystemTime;
 
 use bevy::prelude::*;
-use bevy_renet2::{
-    transport::{NetcodeClientPlugin, NetcodeServerPlugin},
-    RenetClientPlugin, RenetServerPlugin,
-};
-use renet2::{
-    transport::{
-        in_memory_server_addr, new_memory_sockets, ClientAuthentication, MemorySocketClient, NetcodeClientTransport,
-        NetcodeServerTransport, ServerAuthentication, ServerSetupConfig,
-    },
-    ClientId, ConnectionConfig, DefaultChannel, RenetClient, RenetServer,
+use bevy_renet2::netcode::{
+    in_memory_server_addr, new_memory_sockets, ClientAuthentication, MemorySocketClient, NetcodeClientPlugin, NetcodeClientTransport,
+    NetcodeServerPlugin, NetcodeServerTransport, ServerAuthentication, ServerSetupConfig,
 };
+use bevy_renet2::prelude::{ConnectionConfig, DefaultChannel, RenetClient, RenetClientPlugin, RenetServer, RenetServerPlugin};
 
 #[derive(Debug, Default, Resource, PartialEq, Eq, Deref, DerefMut)]
 pub struct ServerReceived(Vec<(u64, Vec<u8>)>);
@@ -74,7 +68,7 @@ fn create_server_app(num_clients: usize) -> (App, Vec<MemorySocketClient>) {
         .add_systems(Update, |mut server: ResMut<RenetServer>, mut received: ResMut<ServerReceived>| {
             for client_id in server.clients_id() {
                 while let Some(packet) = server.receive_message(client_id, DefaultChannel::ReliableOrdered) {
-                    received.push((client_id.raw(), packet.to_vec()));
+                    received.push((client_id, packet.to_vec()));
                 }
             }
         });
@@ -281,7 +275,7 @@ fn disconnect_client() {
     let mut client = clients.pop().unwrap();
 
     server.update();
-    assert_eq!(server.world().resource::<RenetServer>().clients_id(), vec![ClientId::from_raw(1)]);
+    assert_eq!(server.world().resource::<RenetServer>().clients_id(), vec![1]);
     assert!(client.world().resource::<NetcodeClientTransport>().is_connected());
 
     client.world_mut().send_event(AppExit::Success);
@@ -301,7 +295,7 @@ fn disconnect_server() {
     let (mut server, mut clients) = create_and_connect_apps(1);
     let mut client = clients.pop().unwrap();
 
-    assert_eq!(server.world().resource::<RenetServer>().clients_id(), [ClientId::from_raw(1)]);
+    assert_eq!(server.world().resource::<RenetServer>().clients_id(), [1]);
     assert!(client.world().resource::<NetcodeClientTransport>().is_connected());
 
     server.world_mut().send_event(AppExit::Success);
diff --git a/bevy_replicon_renet2/Cargo.toml b/bevy_replicon_renet2/Cargo.toml
index 2074b9ce..4dec51db 100644
--- a/bevy_replicon_renet2/Cargo.toml
+++ b/bevy_replicon_renet2/Cargo.toml
@@ -43,7 +43,7 @@ log = "0.4"
 tracing-subscriber = { version = "0.3", features = [ "env-filter", "std", "tracing-log" ] }
 
 [features]
-default = ["renet_serde", "transport", "client", "server"]
+default = ["renet_serde", "netcode", "client", "server"]
 
 # Re-exports of bevy_replicon features
 client = ["bevy_replicon/client"]
@@ -51,11 +51,13 @@ server = ["bevy_replicon/server"]
 
 # Re-exports of renet features
 renet_serde = ["bevy_renet2/serde"]
-transport = ["bevy_renet2/transport"]
-native_transport = ["transport", "bevy_renet2/native_transport"]
-memory_transport = ["transport", "bevy_renet2/memory_transport"]
-wt_server_transport = ["transport", "bevy_renet2/wt_server_transport"]
-wt_client_transport = ["transport", "bevy_renet2/wt_client_transport"]
+netcode = ["bevy_renet2/netcode"]
+native_transport = ["netcode", "bevy_renet2/native_transport"]
+memory_transport = ["netcode", "bevy_renet2/memory_transport"]
+wt_server_transport = ["netcode", "bevy_renet2/wt_server_transport"]
+wt_client_transport = ["netcode", "bevy_renet2/wt_client_transport"]
+ws_server_transport = ["netcode", "bevy_renet2/ws_server_transport"]
+ws_client_transport = ["netcode", "bevy_renet2/ws_client_transport"]
 
 [[test]]
 name = "transport"
diff --git a/bevy_replicon_renet2/examples/simple_box.rs b/bevy_replicon_renet2/examples/simple_box.rs
index 77ad4720..c1d7bfa0 100644
--- a/bevy_replicon_renet2/examples/simple_box.rs
+++ b/bevy_replicon_renet2/examples/simple_box.rs
@@ -14,12 +14,10 @@ use bevy::{
 };
 use bevy_replicon::prelude::*;
 use bevy_replicon_renet2::{
-    renet2::{
-        transport::{
-            ClientAuthentication, NativeSocket, NetcodeClientTransport, NetcodeServerTransport, ServerAuthentication, ServerSetupConfig,
-        },
-        ConnectionConfig, RenetClient, RenetServer,
+    netcode::{
+        ClientAuthentication, NativeSocket, NetcodeClientTransport, NetcodeServerTransport, ServerAuthentication, ServerSetupConfig,
     },
+    renet2::{ConnectionConfig, RenetClient, RenetServer},
     RenetChannelsExt, RepliconRenetPlugins,
 };
 use clap::Parser;
diff --git a/bevy_replicon_renet2/examples/tic_tac_toe.rs b/bevy_replicon_renet2/examples/tic_tac_toe.rs
index f31c3460..4274f3ee 100644
--- a/bevy_replicon_renet2/examples/tic_tac_toe.rs
+++ b/bevy_replicon_renet2/examples/tic_tac_toe.rs
@@ -11,12 +11,10 @@ use std::{
 use bevy::prelude::*;
 use bevy_replicon::prelude::*;
 use bevy_replicon_renet2::{
-    renet2::{
-        transport::{
-            ClientAuthentication, NativeSocket, NetcodeClientTransport, NetcodeServerTransport, ServerAuthentication, ServerSetupConfig,
-        },
-        ConnectionConfig, RenetClient, RenetServer,
+    netcode::{
+        ClientAuthentication, NativeSocket, NetcodeClientTransport, NetcodeServerTransport, ServerAuthentication, ServerSetupConfig,
     },
+    renet2::{ConnectionConfig, RenetClient, RenetServer},
     RenetChannelsExt, RepliconRenetPlugins,
 };
 use clap::{Parser, ValueEnum};
diff --git a/bevy_replicon_renet2/src/client.rs b/bevy_replicon_renet2/src/client.rs
index 3e4c004a..95409d5b 100644
--- a/bevy_replicon_renet2/src/client.rs
+++ b/bevy_replicon_renet2/src/client.rs
@@ -1,10 +1,7 @@
-#[cfg(feature = "transport")]
-use crate::renet2::transport::NetcodeClientTransport;
-#[cfg(feature = "transport")]
-use crate::transport::NetcodeClientPlugin;
-use crate::{renet2::RenetClient, ClientIdExt};
+#[cfg(feature = "netcode")]
+use crate::netcode::{NetcodeClientPlugin, NetcodeClientTransport};
+use crate::renet2::{RenetClient, RenetClientPlugin, RenetReceive, RenetSend};
 use bevy::prelude::*;
-use bevy_renet2::{RenetClientPlugin, RenetReceive, RenetSend};
 use bevy_replicon::prelude::*;
 
 pub struct RepliconRenetClientPlugin;
@@ -17,10 +14,10 @@ impl Plugin for RepliconRenetClientPlugin {
             .add_systems(
                 PreUpdate,
                 (
-                    Self::set_connecting.run_if(bevy_renet2::client_connecting),
-                    Self::set_disconnected.run_if(bevy_renet2::client_just_disconnected),
-                    Self::set_connected.run_if(bevy_renet2::client_just_connected),
-                    Self::receive_packets.run_if(bevy_renet2::client_connected),
+                    Self::set_connecting.run_if(crate::renet2::client_connecting),
+                    Self::set_disconnected.run_if(crate::renet2::client_just_disconnected),
+                    Self::set_connected.run_if(crate::renet2::client_just_connected),
+                    Self::receive_packets.run_if(crate::renet2::client_connected),
                 )
                     .chain()
                     .in_set(ClientSet::ReceivePackets),
@@ -29,10 +26,10 @@ impl Plugin for RepliconRenetClientPlugin {
                 PostUpdate,
                 Self::send_packets
                     .in_set(ClientSet::SendPackets)
-                    .run_if(bevy_renet2::client_connected),
+                    .run_if(crate::renet2::client_connected),
             );
 
-        #[cfg(feature = "transport")]
+        #[cfg(feature = "netcode")]
         app.add_plugins(NetcodeClientPlugin);
     }
 }
@@ -48,12 +45,12 @@ impl RepliconRenetClientPlugin {
         }
     }
 
-    fn set_connected(mut client: ResMut<RepliconClient>, #[cfg(feature = "transport")] transport: Res<NetcodeClientTransport>) {
+    fn set_connected(mut client: ResMut<RepliconClient>, #[cfg(feature = "netcode")] transport: Res<NetcodeClientTransport>) {
         // In renet only transport knows the ID.
         // TODO: Pending renet issue https://github.com/lucaspoffo/renet/issues/153
-        #[cfg(feature = "transport")]
-        let client_id = Some(transport.client_id().to_replicon());
-        #[cfg(not(feature = "transport"))]
+        #[cfg(feature = "netcode")]
+        let client_id = Some(ClientId::new(transport.client_id()));
+        #[cfg(not(feature = "netcode"))]
         let client_id = None;
 
         client.set_status(RepliconClientStatus::Connected { client_id });
diff --git a/bevy_replicon_renet2/src/lib.rs b/bevy_replicon_renet2/src/lib.rs
index 9d266236..f6eef064 100644
--- a/bevy_replicon_renet2/src/lib.rs
+++ b/bevy_replicon_renet2/src/lib.rs
@@ -58,9 +58,10 @@ For a full example of how to initialize a server or client see the example in th
 repository.
 */
 
-pub use bevy_renet2::renet2;
-#[cfg(feature = "transport")]
-pub use bevy_renet2::transport;
+pub use bevy_renet2::prelude as renet2;
+
+#[cfg(feature = "netcode")]
+pub use bevy_renet2::netcode;
 
 #[cfg(feature = "client")]
 pub mod client;
@@ -73,11 +74,8 @@ pub use client::*;
 pub use server::*;
 
 use bevy::{app::PluginGroupBuilder, prelude::*};
-use bevy_replicon::{
-    core::ClientId,
-    prelude::{ChannelKind, RepliconChannel, RepliconChannels},
-};
-use renet2::{ChannelConfig, SendType};
+use bevy_renet2::prelude::{ChannelConfig, SendType};
+use bevy_replicon::prelude::{ChannelKind, RepliconChannel, RepliconChannels};
 
 pub struct RepliconRenetPlugins;
 
@@ -139,24 +137,3 @@ fn create_configs(channels: &[RepliconChannel], default_max_bytes: usize) -> Vec
     }
     channel_configs
 }
-
-/// External trait for [`ClientId`] to provide convenient conversion into [`renet2::ClientId`].
-pub trait Renet2ClientIdExt {
-    /// Returns renet's Client ID.
-    fn to_renet2(&self) -> renet2::ClientId;
-}
-impl Renet2ClientIdExt for ClientId {
-    fn to_renet2(&self) -> renet2::ClientId {
-        renet2::ClientId::from_raw(self.get())
-    }
-}
-/// External trait for [`renet2::ClientId`] to provide convenient conversion into [`ClientId`].
-pub trait ClientIdExt {
-    /// Returns replicon's Client ID.
-    fn to_replicon(&self) -> ClientId;
-}
-impl ClientIdExt for renet2::ClientId {
-    fn to_replicon(&self) -> ClientId {
-        ClientId::new(self.raw())
-    }
-}
diff --git a/bevy_replicon_renet2/src/server.rs b/bevy_replicon_renet2/src/server.rs
index a0420f53..820f138f 100644
--- a/bevy_replicon_renet2/src/server.rs
+++ b/bevy_replicon_renet2/src/server.rs
@@ -1,8 +1,7 @@
-#[cfg(feature = "transport")]
-use crate::transport::NetcodeServerPlugin;
-use crate::{renet2::RenetServer, ClientIdExt, Renet2ClientIdExt};
+#[cfg(feature = "netcode")]
+use crate::netcode::NetcodeServerPlugin;
+use crate::renet2::{RenetReceive, RenetSend, RenetServer, RenetServerPlugin};
 use bevy::prelude::*;
-use bevy_renet2::{RenetReceive, RenetSend, RenetServerPlugin};
 use bevy_replicon::prelude::*;
 
 pub struct RepliconRenetServerPlugin;
@@ -32,7 +31,7 @@ impl Plugin for RepliconRenetServerPlugin {
                     .run_if(resource_exists::<RenetServer>),
             );
 
-        #[cfg(feature = "transport")]
+        #[cfg(feature = "netcode")]
         app.add_plugins(NetcodeServerPlugin);
     }
 }
@@ -53,10 +52,10 @@ impl RepliconRenetServerPlugin {
         for event in renet_server_events.read() {
             let replicon_event = match event {
                 crate::renet2::ServerEvent::ClientConnected { client_id } => ServerEvent::ClientConnected {
-                    client_id: client_id.to_replicon(),
+                    client_id: ClientId::new(*client_id),
                 },
                 crate::renet2::ServerEvent::ClientDisconnected { client_id, reason } => ServerEvent::ClientDisconnected {
-                    client_id: client_id.to_replicon(),
+                    client_id: ClientId::new(*client_id),
                     reason: reason.to_string(),
                 },
             };
@@ -72,7 +71,7 @@ impl RepliconRenetServerPlugin {
         mut replicon_server: ResMut<RepliconServer>,
     ) {
         for connected in connected_clients.iter().copied() {
-            let renet_client_id = connected.id().to_renet2();
+            let renet_client_id = connected.id().get();
             for channel_id in 0..channels.client_channels().len() as u8 {
                 while let Some(message) = renet_server.receive_message(renet_client_id, channel_id) {
                     replicon_server.insert_received(connected.id(), channel_id, message);
@@ -83,8 +82,7 @@ impl RepliconRenetServerPlugin {
 
     fn send_packets(mut renet_server: ResMut<RenetServer>, mut replicon_server: ResMut<RepliconServer>) {
         for (client_id, channel_id, message) in replicon_server.drain_sent() {
-            let client_id = client_id.to_renet2();
-            renet_server.send_message(client_id, channel_id, message)
+            renet_server.send_message(client_id.get(), channel_id, message)
         }
     }
 }
diff --git a/demo_bevy/Cargo.toml b/demo_bevy/Cargo.toml
index ad15ccc2..64c8dbbd 100644
--- a/demo_bevy/Cargo.toml
+++ b/demo_bevy/Cargo.toml
@@ -4,15 +4,13 @@ version = "0.1.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [[bin]]
 name = "server"
 path = "src/bin/server.rs"
 
 [features]
-transport = ["bevy_renet2/transport"]
-steam = ["dep:renet2_steam", "steamworks"]
+netcode = ["bevy_renet2/netcode"]
+steam = ["bevy_renet2/steam"]
 
 [dependencies]
 bevy = { version = "0.15", default-features = false, features = [
@@ -25,8 +23,7 @@ bevy = { version = "0.15", default-features = false, features = [
     "ktx2",
     "zstd",
 ] }
-bevy_renet2 = { path = "../bevy_renet2", features = ["serde"] }
-renet2_steam = { path = "../renet2_steam", features = ["bevy"], optional = true }
+bevy_renet2 = { path = "../bevy_renet2", default-features = false }
 serde = { version = "1.0", features = ["derive"] }
 bincode = "1.3"
 bevy_egui = "0.31"
diff --git a/demo_bevy/src/bin/client.rs b/demo_bevy/src/bin/client.rs
index 0c1515f7..9cc394b3 100644
--- a/demo_bevy/src/bin/client.rs
+++ b/demo_bevy/src/bin/client.rs
@@ -6,10 +6,7 @@ use bevy::{
     window::PrimaryWindow,
 };
 use bevy_egui::{EguiContexts, EguiPlugin};
-use bevy_renet2::{
-    renet2::{ClientId, RenetClient},
-    RenetClientPlugin,
-};
+use bevy_renet2::prelude::{ClientId, RenetClient, RenetClientPlugin};
 use demo_bevy::{setup_level, ClientChannel, NetworkedEntities, PlayerCommand, PlayerInput, ServerChannel, ServerMessages};
 use renet2_visualizer::{RenetClientVisualizer, RenetVisualizerStyle};
 use smooth_bevy_cameras::{LookTransform, LookTransformBundle, LookTransformPlugin, Smoother};
@@ -37,14 +34,14 @@ struct CurrentClientId(u64);
 #[derive(SystemSet, Debug, Clone, Copy, PartialEq, Eq, Hash)]
 struct Connected;
 
-#[cfg(feature = "transport")]
+#[cfg(feature = "netcode")]
 fn add_netcode_network(app: &mut App) {
-    use bevy_renet2::client_connected;
-    use bevy_renet2::renet2::transport::{ClientAuthentication, NativeSocket, NetcodeClientTransport, NetcodeTransportError};
+    use bevy_renet2::netcode::{ClientAuthentication, NativeSocket, NetcodeClientTransport, NetcodeTransportError};
+    use bevy_renet2::prelude::client_connected;
     use demo_bevy::{connection_config, PROTOCOL_ID};
     use std::{net::UdpSocket, time::SystemTime};
 
-    app.add_plugins(bevy_renet2::transport::NetcodeClientPlugin);
+    app.add_plugins(bevy_renet2::netcode::NetcodeClientPlugin);
 
     app.configure_sets(Update, Connected.run_if(client_connected));
 
@@ -81,9 +78,9 @@ fn add_netcode_network(app: &mut App) {
 
 #[cfg(feature = "steam")]
 fn add_steam_network(app: &mut App) {
-    use bevy_renet2::client_connected;
+    use bevy_renet2::prelude::client_connected;
+    use bevy_renet2::steam::{SteamClientPlugin, SteamClientTransport, SteamTransportError};
     use demo_bevy::connection_config;
-    use renet2_steam::bevy::{SteamClientPlugin, SteamClientTransport, SteamTransportError};
     use steamworks::{SingleClient, SteamId};
 
     let (steam_client, single) = steamworks::Client::init_app(480).unwrap();
@@ -131,7 +128,7 @@ fn main() {
     app.add_plugins(LogDiagnosticsPlugin::default());
     app.add_plugins(EguiPlugin);
 
-    #[cfg(feature = "transport")]
+    #[cfg(feature = "netcode")]
     add_netcode_network(&mut app);
 
     #[cfg(feature = "steam")]
@@ -227,7 +224,7 @@ fn client_sync_players(
                     Transform::from_xyz(translation[0], translation[1], translation[2]),
                 ));
 
-                if client_id == id.raw() {
+                if client_id == id {
                     client_entity.insert(ControlledPlayer);
                 }
 
diff --git a/demo_bevy/src/bin/server.rs b/demo_bevy/src/bin/server.rs
index 4d016c5e..6f267aa8 100644
--- a/demo_bevy/src/bin/server.rs
+++ b/demo_bevy/src/bin/server.rs
@@ -5,10 +5,7 @@ use bevy::{
     prelude::*,
 };
 use bevy_egui::{EguiContexts, EguiPlugin};
-use bevy_renet2::{
-    renet2::{ClientId, RenetServer, ServerEvent},
-    RenetServerPlugin,
-};
+use bevy_renet2::prelude::*;
 use demo_bevy::{
     setup_level, spawn_fireball, ClientChannel, NetworkedEntities, Player, PlayerCommand, PlayerInput, Projectile, ServerChannel,
     ServerMessages, Velocity,
@@ -30,10 +27,9 @@ struct Bot {
 #[derive(Debug, Resource)]
 struct BotId(u64);
 
-#[cfg(feature = "transport")]
+#[cfg(feature = "netcode")]
 fn add_netcode_network(app: &mut App) {
-    use bevy_renet2::renet2::transport::{NativeSocket, NetcodeServerTransport, ServerAuthentication, ServerSetupConfig};
-    use bevy_renet2::transport::NetcodeServerPlugin;
+    use bevy_renet2::netcode::{NativeSocket, NetcodeServerPlugin, NetcodeServerTransport, ServerAuthentication, ServerSetupConfig};
     use demo_bevy::{connection_config, PROTOCOL_ID};
     use std::{net::UdpSocket, time::SystemTime};
 
@@ -59,9 +55,8 @@ fn add_netcode_network(app: &mut App) {
 
 #[cfg(feature = "steam")]
 fn add_steam_network(app: &mut App) {
+    use bevy_renet2::steam::{AccessPermission, SteamServerConfig, SteamServerPlugin, SteamServerTransport};
     use demo_bevy::connection_config;
-    use renet2_steam::bevy::{SteamServerConfig, SteamServerPlugin, SteamServerTransport};
-    use renet2_steam::AccessPermission;
     use steamworks::SingleClient;
 
     let (steam_client, single) = steamworks::Client::init_app(480).unwrap();
@@ -100,7 +95,7 @@ fn main() {
 
     app.insert_resource(RenetServerVisualizer::<200>::default());
 
-    #[cfg(feature = "transport")]
+    #[cfg(feature = "netcode")]
     add_netcode_network(&mut app);
 
     #[cfg(feature = "steam")]
@@ -299,7 +294,7 @@ fn spawn_bot(
     mut commands: Commands,
 ) {
     if keyboard_input.just_pressed(KeyCode::Space) {
-        let client_id = ClientId::from_raw(bot_id.0);
+        let client_id = bot_id.0;
         bot_id.0 += 1;
         // Spawn new player
         let transform = Transform::from_xyz((fastrand::f32() - 0.5) * 40., 0.51, (fastrand::f32() - 0.5) * 40.);
diff --git a/demo_bevy/src/lib.rs b/demo_bevy/src/lib.rs
index 3d8fa364..6d3f30da 100644
--- a/demo_bevy/src/lib.rs
+++ b/demo_bevy/src/lib.rs
@@ -1,12 +1,12 @@
 use std::{f32::consts::PI, time::Duration};
 
 use bevy::prelude::*;
-use bevy_renet2::renet2::{ChannelConfig, ClientId, ConnectionConfig, SendType};
+use bevy_renet2::prelude::{ChannelConfig, ClientId, ConnectionConfig, SendType};
 use serde::{Deserialize, Serialize};
 
-#[cfg(feature = "transport")]
-pub const PRIVATE_KEY: &[u8; bevy_renet2::renet2::transport::NETCODE_KEY_BYTES] = b"an example very very secret key."; // 32-bytes
-#[cfg(feature = "transport")]
+#[cfg(feature = "netcode")]
+pub const PRIVATE_KEY: &[u8; bevy_renet2::prelude::NETCODE_KEY_BYTES] = b"an example very very secret key."; // 32-bytes
+#[cfg(feature = "netcode")]
 pub const PROTOCOL_ID: u64 = 7;
 
 #[derive(Debug, Component)]
diff --git a/demo_chat/Cargo.toml b/demo_chat/Cargo.toml
index 2a0a2124..25dc113b 100644
--- a/demo_chat/Cargo.toml
+++ b/demo_chat/Cargo.toml
@@ -5,10 +5,9 @@ authors = ["koe <ukoe@protonmail.com>"]
 license = "MIT OR Apache-2.0"
 edition = "2021"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
-renet2 = { path = "../renet2", features = ["transport", "serde"] }
+renet2 = { path = "../renet2" }
+renet2_netcode = { path = "../renet2_netcode", features = ["native_transport", "serde"] }
 renet2_visualizer = { path = "../renet2_visualizer" }
 eframe = "0.29"
 serde = { version = "1.0", features = ["derive"] }
diff --git a/demo_chat/src/client.rs b/demo_chat/src/client.rs
index b209658b..eda0f583 100644
--- a/demo_chat/src/client.rs
+++ b/demo_chat/src/client.rs
@@ -1,7 +1,8 @@
 use bincode::Options;
 use eframe::egui;
 use log::error;
-use renet2::{transport::NetcodeClientTransport, ClientId, DefaultChannel, RenetClient};
+use renet2::{ClientId, DefaultChannel, RenetClient};
+use renet2_netcode::NetcodeClientTransport;
 use renet2_visualizer::RenetClientVisualizer;
 
 use std::{collections::HashMap, time::Instant};
diff --git a/demo_chat/src/main.rs b/demo_chat/src/main.rs
index d48409f4..8d8c8238 100644
--- a/demo_chat/src/main.rs
+++ b/demo_chat/src/main.rs
@@ -1,6 +1,7 @@
 use client::ChatApp;
 use eframe::{egui, App};
-use renet2::{transport::NETCODE_USER_DATA_BYTES, ClientId};
+use renet2::ClientId;
+use renet2_netcode::NETCODE_USER_DATA_BYTES;
 use serde::{Deserialize, Serialize};
 
 use std::collections::HashMap;
diff --git a/demo_chat/src/server.rs b/demo_chat/src/server.rs
index ee711a72..42f12288 100644
--- a/demo_chat/src/server.rs
+++ b/demo_chat/src/server.rs
@@ -5,18 +5,16 @@ use std::{
     time::{Duration, SystemTime},
 };
 
-use renet2::{
-    transport::{NativeSocket, NetcodeServerTransport, ServerAuthentication, ServerSetupConfig},
-    ClientId, ConnectionConfig, DefaultChannel, RenetServer, ServerEvent,
-};
+use renet2::{ClientId, ConnectionConfig, DefaultChannel, RenetServer, ServerEvent};
+use renet2_netcode::{NativeSocket, NetcodeServerTransport, ServerAuthentication, ServerSetupConfig};
 use renet2_visualizer::RenetServerVisualizer;
 
 use crate::{ClientMessages, Message, ServerMessages, Username, PROTOCOL_ID};
 use bincode::Options;
 use log::info;
 
-pub const SYSTEM_MESSAGE_CLIENT_ID: ClientId = ClientId::from_raw(0);
-pub const HOST_CLIENT_ID: ClientId = ClientId::from_raw(1);
+pub const SYSTEM_MESSAGE_CLIENT_ID: ClientId = 0;
+pub const HOST_CLIENT_ID: ClientId = 1;
 
 pub struct ChatServer {
     pub server: RenetServer,
diff --git a/demo_chat/src/ui.rs b/demo_chat/src/ui.rs
index a60b3fe1..3d271196 100644
--- a/demo_chat/src/ui.rs
+++ b/demo_chat/src/ui.rs
@@ -3,10 +3,8 @@ use eframe::{
     egui::{self, lerp, Color32, Layout, Pos2, Ui, Vec2},
     epaint::PathShape,
 };
-use renet2::{
-    transport::{ClientAuthentication, NativeSocket, NetcodeClientTransport},
-    ClientId, ConnectionConfig, DefaultChannel, RenetClient,
-};
+use renet2::{ClientId, ConnectionConfig, DefaultChannel, RenetClient};
+use renet2_netcode::{ClientAuthentication, NativeSocket, NetcodeClientTransport};
 
 use std::{
     collections::HashMap,
diff --git a/examples/echo_client_native/Cargo.toml b/examples/echo_client_native/Cargo.toml
index 70f30e4f..4aca1a22 100644
--- a/examples/echo_client_native/Cargo.toml
+++ b/examples/echo_client_native/Cargo.toml
@@ -15,5 +15,6 @@ log = "0.4"
 reqwest = { version = "0.12", features = ["json"] }
 tokio = { version = "1", features = ["full"] }
 
-renet2 = { path = "../../renet2", default-features = false, features = ["native_transport"] }
+renet2 = { path = "../../renet2", default-features = false }
+renet2_netcode = { path = "../../renet2_netcode", default-features = false, features = ["native_transport"] }
 renetcode2 = { path = "../../renetcode2" }
diff --git a/examples/echo_client_native/src/main.rs b/examples/echo_client_native/src/main.rs
index 7c67ef69..2cd36267 100644
--- a/examples/echo_client_native/src/main.rs
+++ b/examples/echo_client_native/src/main.rs
@@ -5,10 +5,8 @@ use std::{
     time::{Duration, Instant, SystemTime},
 };
 
-use renet2::{
-    transport::{ClientAuthentication, ClientSocket, NativeSocket, NetcodeClientTransport},
-    ConnectionConfig, DefaultChannel, RenetClient,
-};
+use renet2::{ConnectionConfig, DefaultChannel, RenetClient};
+use renet2_netcode::{ClientAuthentication, ClientSocket, NativeSocket, NetcodeClientTransport};
 
 fn main() {
     env_logger::init();
diff --git a/examples/echo_client_wt/.gitignore b/examples/echo_client_wasm/.gitignore
similarity index 100%
rename from examples/echo_client_wt/.gitignore
rename to examples/echo_client_wasm/.gitignore
diff --git a/examples/echo_client_wt/Cargo.toml b/examples/echo_client_wasm/Cargo.toml
similarity index 77%
rename from examples/echo_client_wt/Cargo.toml
rename to examples/echo_client_wasm/Cargo.toml
index 82302a14..6dc25189 100644
--- a/examples/echo_client_wt/Cargo.toml
+++ b/examples/echo_client_wasm/Cargo.toml
@@ -23,7 +23,10 @@ wasm-bindgen-futures = "0.4"
 wasm-timer = "0.2"
 console_error_panic_hook = "0.1"
 
-renet2 = { path = "../../renet2", default-features = false, features = ["serde", "wt_client_transport", "ws_client_transport"] }
+renet2 = { path = "../../renet2", default-features = false }
+renet2_netcode = { path = "../../renet2_netcode", default-features = false, features = [
+    "serde", "wt_client_transport", "ws_client_transport"
+] }
 renetcode2 = { path = "../../renetcode2" }
 
 [profile.release]
diff --git a/examples/echo_client_wt/README.md b/examples/echo_client_wasm/README.md
similarity index 100%
rename from examples/echo_client_wt/README.md
rename to examples/echo_client_wasm/README.md
diff --git a/examples/echo_client_wt/src/lib.rs b/examples/echo_client_wasm/src/lib.rs
similarity index 93%
rename from examples/echo_client_wt/src/lib.rs
rename to examples/echo_client_wasm/src/lib.rs
index f0cf9475..215b34c6 100644
--- a/examples/echo_client_wt/src/lib.rs
+++ b/examples/echo_client_wasm/src/lib.rs
@@ -1,8 +1,6 @@
-use renet2::{
-    transport::{
-        webtransport_is_available_with_cert_hashes, ClientSocket, CongestionControl, NetcodeClientTransport, ServerCertHash, WebServerDestination, WebSocketClient, WebSocketClientConfig, WebTransportClient, WebTransportClientConfig
-    },
-    ConnectionConfig, DefaultChannel, RenetClient,
+use renet2::{ConnectionConfig, DefaultChannel, RenetClient};
+use renet2_netcode::{
+    webtransport_is_available_with_cert_hashes, ClientSocket, CongestionControl, NetcodeClientTransport, ServerCertHash, WebServerDestination, WebSocketClient, WebSocketClientConfig, WebTransportClient, WebTransportClientConfig
 };
 use renetcode2::ClientAuthentication;
 use std::time::Duration;
diff --git a/examples/echo_client_wt/wasm-app/.gitignore b/examples/echo_client_wasm/wasm-app/.gitignore
similarity index 100%
rename from examples/echo_client_wt/wasm-app/.gitignore
rename to examples/echo_client_wasm/wasm-app/.gitignore
diff --git a/examples/echo_client_wt/wasm-app/.travis.yml b/examples/echo_client_wasm/wasm-app/.travis.yml
similarity index 100%
rename from examples/echo_client_wt/wasm-app/.travis.yml
rename to examples/echo_client_wasm/wasm-app/.travis.yml
diff --git a/examples/echo_client_wt/wasm-app/bootstrap.js b/examples/echo_client_wasm/wasm-app/bootstrap.js
similarity index 100%
rename from examples/echo_client_wt/wasm-app/bootstrap.js
rename to examples/echo_client_wasm/wasm-app/bootstrap.js
diff --git a/examples/echo_client_wt/wasm-app/index.html b/examples/echo_client_wasm/wasm-app/index.html
similarity index 100%
rename from examples/echo_client_wt/wasm-app/index.html
rename to examples/echo_client_wasm/wasm-app/index.html
diff --git a/examples/echo_client_wt/wasm-app/index.js b/examples/echo_client_wasm/wasm-app/index.js
similarity index 100%
rename from examples/echo_client_wt/wasm-app/index.js
rename to examples/echo_client_wasm/wasm-app/index.js
diff --git a/examples/echo_client_wt/wasm-app/package.json b/examples/echo_client_wasm/wasm-app/package.json
similarity index 100%
rename from examples/echo_client_wt/wasm-app/package.json
rename to examples/echo_client_wasm/wasm-app/package.json
diff --git a/examples/echo_client_wt/wasm-app/webpack.config.js b/examples/echo_client_wasm/wasm-app/webpack.config.js
similarity index 100%
rename from examples/echo_client_wt/wasm-app/webpack.config.js
rename to examples/echo_client_wasm/wasm-app/webpack.config.js
diff --git a/examples/echo_server_cross/Cargo.toml b/examples/echo_server_cross/Cargo.toml
index 337cd09b..a76d3aef 100644
--- a/examples/echo_server_cross/Cargo.toml
+++ b/examples/echo_server_cross/Cargo.toml
@@ -15,7 +15,8 @@ tokio = { version = "1", features = ["full"] }
 url = "2.4"
 warp = "0.3"
 
-renet2 = { path = "../../renet2", default-features = false, features = [
+renet2 = { path = "../../renet2", default-features = false }
+renet2_netcode = { path = "../../renet2_netcode", default-features = false, features = [
     "serde", "native_transport", "wt_server_transport", "ws_server_transport"
 ] }
 renetcode2 = { path = "../../renetcode2" }
diff --git a/examples/echo_server_cross/src/main.rs b/examples/echo_server_cross/src/main.rs
index 35976ccf..f5e161f1 100644
--- a/examples/echo_server_cross/src/main.rs
+++ b/examples/echo_server_cross/src/main.rs
@@ -5,12 +5,10 @@ use std::{
 use warp::Filter;
 
 use log::{debug, info, trace};
-use renet2::{
-    transport::{
-        BoxedSocket, NativeSocket, NetcodeServerTransport, ServerCertHash, ServerSetupConfig, ServerSocket, WebServerDestination,
-        WebSocketServer, WebSocketServerConfig, WebTransportServer, WebTransportServerConfig,
-    },
-    ConnectionConfig, DefaultChannel, RenetServer, ServerEvent,
+use renet2::{ConnectionConfig, DefaultChannel, RenetServer, ServerEvent};
+use renet2_netcode::{
+    BoxedSocket, NativeSocket, NetcodeServerTransport, ServerCertHash, ServerSetupConfig, ServerSocket, WebServerDestination,
+    WebSocketServer, WebSocketServerConfig, WebTransportServer, WebTransportServerConfig,
 };
 use renetcode2::ServerAuthentication;
 
diff --git a/renet2/Cargo.toml b/renet2/Cargo.toml
index 6aae40c7..c52077d9 100644
--- a/renet2/Cargo.toml
+++ b/renet2/Cargo.toml
@@ -10,170 +10,21 @@ readme = "../README.md"
 repository = "https://github.com/UkoeHB/renet2"
 
 [package.metadata.docs.rs]
-features = ["default", "bevy", "serde", "memory_transport", "wt_server_transport", "ws_server_transport"]
+features = ["default", "bevy"]
 rustdoc-args = ["-Zunstable-options", "--cfg", "docsrs"]
 
 [features]
 # Default features
-default = ["native_transport"]
+default = []
 
 # Enable bevy integration
-bevy = ["dep:bevy_ecs", "dep:bevy_reflect"]
-
-# Enable serialization
-serde = ["dep:serde", "serde/serde_derive", "url/serde"]
-
-# Enable transports
-transport = [
-    "dep:renetcode2",
-    "dep:hmac-sha256",
-    "dep:url",
-]
-
-# Enable native UdpSocket transports
-native_transport = ["transport"]
-
-# Enable in-memory transports
-memory_transport = ["transport", "dep:crossbeam"]
-
-# Enable the WebTransport server transport
-wt_server_transport = [
-    "transport",
-    "dep:crossbeam",
-    "dep:anyhow",
-    "dep:wtransport",
-
-    "dep:rustls",
-    "dep:rustls-pki-types",
-    "dep:rcgen",
-    "dep:quinn",
-    "dep:http",
-
-    "dep:tokio",
-    "dep:futures",
-    "dep:time",
-    #"dep:x509-cert",
-    #"dep:spki",
-    #"dep:base64",
-    "dep:urlencoding",
-]
-
-# Enable the WebTransport client transport (WASM only)
-wt_client_transport = [
-    "transport",
-    "dep:async-channel",
-    "dep:fragile",
-    "dep:wasm-bindgen",
-    "dep:wasm-bindgen-futures",
-    "dep:futures",
-    "dep:js-sys",
-    "dep:send_wrapper",
-    "dep:getrandom",
-    "dep:web-sys",
-    "dep:urlencoding",
-]
-
-# Enable the WebSocket server transport
-ws_server_transport = [
-    "transport",
-    "dep:tungstenite",
-    "dep:tokio-tungstenite",
-    "dep:http",
-    "dep:urlencoding",
-]
-
-# Enable rustls acceptors for WebSocket server transports.
-ws-rustls = ["dep:tokio-rustls"]
-
-# Enable native TLS acceptors for WebSocket server transports.
-ws-native-tls = ["dep:tokio-native-tls"]
-
-# Enable the WebSocket client transport (WASM only)
-ws_client_transport = [
-    "transport",
-    "dep:anyhow",
-    "dep:async-channel",
-    "dep:wasm-bindgen",
-    "dep:wasm-bindgen-futures",
-    "dep:futures",
-    "dep:js-sys",
-    "dep:web-sys",
-    "dep:serde_json",
-    "dep:futures-util",
-    "dep:futures-channel",
-    "dep:urlencoding",
-]
+bevy = ["dep:bevy_ecs"]
 
 [dependencies]
 bevy_ecs = { version = "0.15", optional = true }
-bevy_reflect = { version = "0.15", optional = true }
 bytes = "1.1"
 log = "0.4"
 octets = "0.3"
-renetcode2 = { path = "../renetcode2", version = "0.0.7", optional = true }
-serde = { version = "1.0", optional = true }
-hmac-sha256 = { version = "1.1", optional = true }
-url = { version = "2.4", optional = true }
-
-# In-memory transport socket
-crossbeam = { version = "0.8", optional = true }
-
-# WebTransport shared
-futures = { version = "0.3", optional = true }
-serde_json = { version = "1.0", optional = true }
-urlencoding = { version = "2.1", optional = true }
-
-# WebTransport server
-anyhow = { version = "1.0", optional = true }
-wtransport = { version = "0.5", optional = true, default-features = false, features = ["quinn", "self-signed"] }
-rustls = { version = "0.23.5", optional = true }  #locked to 0.23.5 until quinn updates
-rustls-pki-types = { version = "1.7", optional = true }  #locked to 1.7 until quinn updates
-rcgen = { version = "0.13", optional = true }
-quinn = { version = "0.11.6", optional = true, default-features = false, features = [
-    "rustls-ring",
-] }
-http = { version = "1.0", optional = true }
-tokio = { version = "1.32", optional = true, features = ["full"] }
-time = { version = "0.3", optional = true }
-#x509-cert = { version = "0.2", optional = true }
-#spki = { version = "0.7", optional = true, features = ["fingerprint"] }
-#base64 = { version = "0.22", optional = true }
-
-# WebTransport client
-async-channel = { version = "2.2", optional = true }
-fragile = { version = "2.0", optional = true }
-wasm-bindgen = { version = "0.2", optional = true }
-wasm-bindgen-futures = { version = "0.4", optional = true }
-js-sys = { version = "0.3", optional = true }
-send_wrapper = { version = "0.6", optional = true, features = ["futures"] }
-getrandom = { version = "0.2", optional = true, features = ["js"] }
-
-# WebSocket server
-tungstenite = { version = "0.26.1", optional = true }
-tokio-tungstenite = { version = "0.26.1", optional = true }
-tokio-rustls = { version = "0.26.1", optional = true }
-tokio-native-tls = { version = "0.3.1", optional = true }
-
-# WebSocket client
-futures-util = { version = "0.3", optional = true, default-features = false, features = [ "std" ] }
-futures-channel = { version = "0.3", optional = true }
-
-[dependencies.web-sys]
-version = "0.3"
-optional = true
-features = [
-    "DomException",
-    "ReadableStream",
-    "WritableStream",
-    "ReadableStreamDefaultReader",
-    "WritableStreamDefaultWriter",
-    "WebSocket",
-    "MessageEvent",
-    "CloseEvent",
-    "Event",
-    "ErrorEvent",
-    "BinaryType",
-]
 
 [dev-dependencies]
 env_logger = "0.11"
diff --git a/renet2/src/lib.rs b/renet2/src/lib.rs
index 55026158..520ea3b2 100644
--- a/renet2/src/lib.rs
+++ b/renet2/src/lib.rs
@@ -7,60 +7,13 @@ mod packet;
 mod remote_connection;
 mod server;
 
-#[cfg(feature = "transport")]
-pub mod transport;
-
 pub use channel::{ChannelConfig, DefaultChannel, SendType};
 pub use error::{ChannelError, ClientNotFound, DisconnectReason};
+pub use packet::Payload;
 pub use remote_connection::{ConnectionConfig, NetworkInfo, RenetClient, RenetConnectionStatus};
 pub use server::{RenetServer, ServerEvent};
 
 pub use bytes::Bytes;
 
 /// Unique identifier for clients.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, Ord, PartialOrd)]
-#[cfg_attr(feature = "bevy", derive(bevy_reflect::Reflect))]
-pub struct ClientId(u64);
-
-impl ClientId {
-    /// Creates a [`ClientId`] from a raw 64 bit value.
-    pub const fn from_raw(value: u64) -> Self {
-        Self(value)
-    }
-
-    /// Returns the raw 64 bit value of the [`ClientId`]
-    pub fn raw(&self) -> u64 {
-        self.0
-    }
-}
-
-impl std::fmt::Display for ClientId {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for ClientId {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        self.0.serialize(serializer)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> serde::Deserialize<'de> for ClientId {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        u64::deserialize(deserializer).map(ClientId::from_raw)
-    }
-}
-
-#[cfg(feature = "bevy")]
-impl bevy_ecs::component::Component for ClientId {
-    const STORAGE_TYPE: bevy_ecs::component::StorageType = bevy_ecs::component::StorageType::Table;
-}
+pub type ClientId = u64;
diff --git a/renet2/tests/lib.rs b/renet2/tests/lib.rs
index efa03157..1dc6ab28 100644
--- a/renet2/tests/lib.rs
+++ b/renet2/tests/lib.rs
@@ -1,5 +1,5 @@
 use bytes::Bytes;
-use renet2::{ClientId, ConnectionConfig, DefaultChannel, DisconnectReason, RenetClient, RenetServer, ServerEvent};
+use renet2::{ConnectionConfig, DefaultChannel, DisconnectReason, RenetClient, RenetServer, ServerEvent};
 
 pub fn init_log() {
     let _ = env_logger::builder().is_test(true).try_init();
@@ -11,7 +11,7 @@ fn test_remote_connection_reliable_channel() {
     let mut server = RenetServer::new(ConnectionConfig::test());
     let mut client = RenetClient::new(ConnectionConfig::test(), false);
 
-    let client_id = ClientId::from_raw(0);
+    let client_id = 0;
     server.add_connection(client_id, false);
     assert_eq!(server.connected_clients(), 1);
     assert!(server.has_connections());
diff --git a/renet2_netcode/Cargo.toml b/renet2_netcode/Cargo.toml
new file mode 100644
index 00000000..bdab241e
--- /dev/null
+++ b/renet2_netcode/Cargo.toml
@@ -0,0 +1,168 @@
+[package]
+name = "renet2_netcode"
+version = "0.0.7"
+authors = ["koe <ukoe@protonmail.com>"]
+description = "Netcode integration for renet2"
+edition = "2021"
+keywords = ["gamedev", "networking"]
+license = "MIT OR Apache-2.0"
+readme = "../README.md"
+repository = "https://github.com/UkoeHB/renet2"
+
+[package.metadata.docs.rs]
+features = ["default", "bevy", "serde", "memory_transport", "wt_server_transport", "ws_server_transport"]
+rustdoc-args = ["-Zunstable-options", "--cfg", "docsrs"]
+
+[features]
+# Default features
+default = ["native_transport"]
+
+# Enable bevy integration
+bevy = ["dep:bevy_ecs"]
+
+# Enable serialization
+serde = ["dep:serde", "serde/serde_derive", "url/serde"]
+
+# Enable native UdpSocket transports
+native_transport = []
+
+# Enable in-memory transports
+memory_transport = ["dep:crossbeam"]
+
+# Enable the WebTransport server transport
+wt_server_transport = [
+    "dep:crossbeam",
+    "dep:anyhow",
+    "dep:wtransport",
+
+    "dep:rustls",
+    "dep:rustls-pki-types",
+    "dep:rcgen",
+    "dep:quinn",
+    "dep:http",
+
+    "dep:tokio",
+    "dep:futures",
+    "dep:time",
+    #"dep:x509-cert",
+    #"dep:spki",
+    #"dep:base64",
+    "dep:urlencoding",
+]
+
+# Enable the WebTransport client transport (WASM only)
+wt_client_transport = [
+    "dep:async-channel",
+    "dep:fragile",
+    "dep:wasm-bindgen",
+    "dep:wasm-bindgen-futures",
+    "dep:futures",
+    "dep:js-sys",
+    "dep:send_wrapper",
+    "dep:getrandom",
+    "dep:web-sys",
+    "dep:urlencoding",
+]
+
+# Enable the WebSocket server transport
+ws_server_transport = [
+    "dep:tungstenite",
+    "dep:tokio-tungstenite",
+    "dep:http",
+    "dep:urlencoding",
+]
+
+# Enable rustls acceptors for WebSocket server transports.
+ws-rustls = ["dep:tokio-rustls"]
+
+# Enable native TLS acceptors for WebSocket server transports.
+ws-native-tls = ["dep:tokio-native-tls"]
+
+# Enable the WebSocket client transport (WASM only)
+ws_client_transport = [
+    "dep:anyhow",
+    "dep:async-channel",
+    "dep:wasm-bindgen",
+    "dep:wasm-bindgen-futures",
+    "dep:futures",
+    "dep:js-sys",
+    "dep:web-sys",
+    "dep:serde_json",
+    "dep:futures-util",
+    "dep:futures-channel",
+    "dep:urlencoding",
+]
+
+[dependencies]
+bytes = "1.1"
+log = "0.4"
+octets = "0.3"
+renetcode2 = { path = "../renetcode2", version = "0.0.7" }
+renet2 = { path = "../renet2", version = "0.0.7" }
+hmac-sha256 = { version = "1.1" }
+url = { version = "2.4" }
+bevy_ecs = { version = "0.15", optional = true }
+serde = { version = "1.0", optional = true, features = ["derive"] }
+
+# In-memory transport socket
+crossbeam = { version = "0.8", optional = true }
+
+# WebTransport shared
+futures = { version = "0.3", optional = true }
+serde_json = { version = "1.0", optional = true }
+urlencoding = { version = "2.1", optional = true }
+
+# WebTransport server
+anyhow = { version = "1.0", optional = true }
+wtransport = { version = "0.5", optional = true, default-features = false, features = ["quinn", "self-signed"] }
+rustls = { version = "0.23.5", optional = true }  #locked to 0.23.5 until quinn updates
+rustls-pki-types = { version = "1.7", optional = true }  #locked to 1.7 until quinn updates
+rcgen = { version = "0.13", optional = true }
+quinn = { version = "0.11.6", optional = true, default-features = false, features = [
+    "rustls-ring",
+] }
+http = { version = "1.0", optional = true }
+tokio = { version = "1.32", optional = true, features = ["full"] }
+time = { version = "0.3", optional = true }
+#x509-cert = { version = "0.2", optional = true }
+#spki = { version = "0.7", optional = true, features = ["fingerprint"] }
+#base64 = { version = "0.22", optional = true }
+
+# WebTransport client
+async-channel = { version = "2.2", optional = true }
+fragile = { version = "2.0", optional = true }
+wasm-bindgen = { version = "0.2", optional = true }
+wasm-bindgen-futures = { version = "0.4", optional = true }
+js-sys = { version = "0.3", optional = true }
+send_wrapper = { version = "0.6", optional = true, features = ["futures"] }
+getrandom = { version = "0.2", optional = true, features = ["js"] }
+
+# WebSocket server
+tungstenite = { version = "0.26.1", optional = true }
+tokio-tungstenite = { version = "0.26.1", optional = true }
+tokio-rustls = { version = "0.26.1", optional = true }
+tokio-native-tls = { version = "0.3.1", optional = true }
+
+# WebSocket client
+futures-util = { version = "0.3", optional = true, default-features = false, features = [ "std" ] }
+futures-channel = { version = "0.3", optional = true }
+
+[dependencies.web-sys]
+version = "0.3"
+optional = true
+features = [
+    "DomException",
+    "ReadableStream",
+    "WritableStream",
+    "ReadableStreamDefaultReader",
+    "WritableStreamDefaultWriter",
+    "WebSocket",
+    "MessageEvent",
+    "CloseEvent",
+    "Event",
+    "ErrorEvent",
+    "BinaryType",
+]
+
+[dev-dependencies]
+env_logger = "0.11"
diff --git a/renet2/examples/echo_native.rs b/renet2_netcode/examples/echo_native.rs
similarity index 95%
rename from renet2/examples/echo_native.rs
rename to renet2_netcode/examples/echo_native.rs
index 63677826..e5192e22 100644
--- a/renet2/examples/echo_native.rs
+++ b/renet2_netcode/examples/echo_native.rs
@@ -6,12 +6,10 @@ use std::{
     time::{Duration, Instant, SystemTime},
 };
 
-use renet2::{
-    transport::{
-        ClientAuthentication, NativeSocket, NetcodeClientTransport, NetcodeServerTransport, ServerAuthentication, ServerSetupConfig,
-        NETCODE_USER_DATA_BYTES,
-    },
-    ClientId, ConnectionConfig, DefaultChannel, RenetClient, RenetServer, ServerEvent,
+use renet2::{ClientId, ConnectionConfig, DefaultChannel, RenetClient, RenetServer, ServerEvent};
+use renet2_netcode::{
+    ClientAuthentication, NativeSocket, NetcodeClientTransport, NetcodeServerTransport, ServerAuthentication, ServerSetupConfig,
+    NETCODE_USER_DATA_BYTES,
 };
 
 // Helper struct to pass an username in the user data
diff --git a/renet2/src/transport/client.rs b/renet2_netcode/src/client.rs
similarity index 98%
rename from renet2/src/transport/client.rs
rename to renet2_netcode/src/client.rs
index 91c84c51..885d7daf 100644
--- a/renet2/src/transport/client.rs
+++ b/renet2_netcode/src/client.rs
@@ -2,7 +2,7 @@ use std::{io, net::SocketAddr, time::Duration};
 
 use renetcode2::{ClientAuthentication, DisconnectReason, NetcodeClient, NetcodeError, NETCODE_MAX_PACKET_BYTES};
 
-use crate::{remote_connection::RenetClient, ClientId};
+use renet2::{ClientId, RenetClient};
 
 use super::{ClientSocket, NetcodeTransportError};
 
@@ -40,7 +40,7 @@ impl NetcodeClientTransport {
 
     /// Returns the client's id.
     pub fn client_id(&self) -> ClientId {
-        ClientId(self.netcode_client.client_id())
+        self.netcode_client.client_id()
     }
 
     /// Returns `true` if the netcode client is connected.
diff --git a/renet2/src/transport/mod.rs b/renet2_netcode/src/lib.rs
similarity index 86%
rename from renet2/src/transport/mod.rs
rename to renet2_netcode/src/lib.rs
index bf7342ab..2c3848a1 100644
--- a/renet2/src/transport/mod.rs
+++ b/renet2_netcode/src/lib.rs
@@ -1,3 +1,7 @@
+//! Integrates the `netcode` authentication and encryption protocol with `renet2`'s reliability layer.
+//!
+//! Includes built-in data transports.
+
 use std::{error::Error, fmt};
 
 mod client;
@@ -31,7 +35,7 @@ pub use renetcode2::{
 #[cfg_attr(feature = "bevy", derive(bevy_ecs::prelude::Event))]
 pub enum NetcodeTransportError {
     Netcode(NetcodeError),
-    Renet(crate::DisconnectReason),
+    Renet(renet2::DisconnectReason),
     IO(std::io::Error),
 }
 
@@ -59,8 +63,8 @@ impl From<renetcode2::TokenGenerationError> for NetcodeTransportError {
     }
 }
 
-impl From<crate::DisconnectReason> for NetcodeTransportError {
-    fn from(inner: crate::DisconnectReason) -> Self {
+impl From<renet2::DisconnectReason> for NetcodeTransportError {
+    fn from(inner: renet2::DisconnectReason) -> Self {
         NetcodeTransportError::Renet(inner)
     }
 }
diff --git a/renet2/src/transport/memory_socket/client.rs b/renet2_netcode/src/memory_socket/client.rs
similarity index 97%
rename from renet2/src/transport/memory_socket/client.rs
rename to renet2_netcode/src/memory_socket/client.rs
index a802a484..8d37da64 100644
--- a/renet2/src/transport/memory_socket/client.rs
+++ b/renet2_netcode/src/memory_socket/client.rs
@@ -1,6 +1,6 @@
 use std::{io::ErrorKind, net::SocketAddr};
 
-use crate::transport::{ClientSocket, NetcodeTransportError};
+use crate::{ClientSocket, NetcodeTransportError};
 use renetcode2::NETCODE_MAX_PACKET_BYTES;
 
 use super::*;
diff --git a/renet2/src/transport/memory_socket/mod.rs b/renet2_netcode/src/memory_socket/mod.rs
similarity index 100%
rename from renet2/src/transport/memory_socket/mod.rs
rename to renet2_netcode/src/memory_socket/mod.rs
diff --git a/renet2/src/transport/memory_socket/server.rs b/renet2_netcode/src/memory_socket/server.rs
similarity index 98%
rename from renet2/src/transport/memory_socket/server.rs
rename to renet2_netcode/src/memory_socket/server.rs
index 7bd46ff2..73ecf970 100644
--- a/renet2/src/transport/memory_socket/server.rs
+++ b/renet2_netcode/src/memory_socket/server.rs
@@ -1,6 +1,6 @@
 use std::{io::ErrorKind, net::SocketAddr};
 
-use crate::transport::{NetcodeTransportError, ServerSocket};
+use crate::{NetcodeTransportError, ServerSocket};
 
 use super::*;
 
diff --git a/renet2/src/transport/native_socket.rs b/renet2_netcode/src/native_socket.rs
similarity index 100%
rename from renet2/src/transport/native_socket.rs
rename to renet2_netcode/src/native_socket.rs
diff --git a/renet2/src/transport/server.rs b/renet2_netcode/src/server.rs
similarity index 95%
rename from renet2/src/transport/server.rs
rename to renet2_netcode/src/server.rs
index 3b123fd6..c501f95e 100644
--- a/renet2/src/transport/server.rs
+++ b/renet2_netcode/src/server.rs
@@ -3,9 +3,7 @@ use std::{io, net::SocketAddr, time::Duration};
 use renetcode2::{NetcodeServer, ServerConfig, ServerResult, NETCODE_MAX_PACKET_BYTES, NETCODE_USER_DATA_BYTES};
 use renetcode2::{ServerAuthentication, ServerSocketConfig};
 
-use crate::packet::Payload;
-use crate::ClientId;
-use crate::RenetServer;
+use renet2::{ClientId, Payload, RenetServer};
 
 use super::{NetcodeTransportError, ServerSocket};
 
@@ -120,12 +118,12 @@ impl NetcodeServerTransport {
 
     /// Returns the user data for client if connected.
     pub fn user_data(&self, client_id: ClientId) -> Option<[u8; NETCODE_USER_DATA_BYTES]> {
-        self.netcode_server.user_data(client_id.raw())
+        self.netcode_server.user_data(client_id)
     }
 
     /// Returns the client socket id and address if connected.
     pub fn client_addr(&self, client_id: ClientId) -> Option<(usize, SocketAddr)> {
-        self.netcode_server.client_addr(client_id.raw())
+        self.netcode_server.client_addr(client_id)
     }
 
     /// Disconnects all connected clients.
@@ -143,7 +141,7 @@ impl NetcodeServerTransport {
     ///
     /// Useful to detect users that are timing out.
     pub fn time_since_last_received_packet(&self, client_id: ClientId) -> Option<Duration> {
-        self.netcode_server.time_since_last_received_packet(client_id.raw())
+        self.netcode_server.time_since_last_received_packet(client_id)
     }
 
     /// Advances the transport by the duration, and receive packets from the network.
@@ -176,7 +174,7 @@ impl NetcodeServerTransport {
         }
 
         for disconnection_id in server.disconnections_id() {
-            let server_result = self.netcode_server.disconnect(disconnection_id.raw());
+            let server_result = self.netcode_server.disconnect(disconnection_id);
             handle_server_result(server_result, &mut self.sockets, server);
         }
 
@@ -216,7 +214,7 @@ fn send_packet_to_client(
     packet: &Payload,
     client_id: ClientId,
 ) -> bool {
-    let (send_result, socket_id, addr) = match netcode_server.generate_payload_packet(client_id.raw(), packet) {
+    let (send_result, socket_id, addr) = match netcode_server.generate_payload_packet(client_id, packet) {
         Ok((socket_id, addr, payload)) => (sockets[socket_id].send(addr, payload), socket_id, addr),
         Err(e) => {
             log::error!("Failed to encrypt payload packet for client {client_id}: {e}");
@@ -230,7 +228,7 @@ fn send_packet_to_client(
             // Manually disconnect the client if the client's address is disconnected.
             reliable_server.remove_connection(client_id);
             // Ignore the server result since this client is not connected.
-            let _ = netcode_server.disconnect(client_id.raw());
+            let _ = netcode_server.disconnect(client_id);
 
             false
         }
@@ -272,7 +270,6 @@ fn handle_server_result(server_result: ServerResult, sockets: &mut [Box<dyn Serv
             send_packet(sockets, payload, socket_id, addr);
         }
         ServerResult::Payload { client_id, payload } => {
-            let client_id = ClientId::from_raw(client_id);
             if let Err(e) = reliable_server.process_packet_from(payload, client_id) {
                 log::error!("Error while processing payload for {}: {}", client_id, e);
             }
@@ -284,7 +281,7 @@ fn handle_server_result(server_result: ServerResult, sockets: &mut [Box<dyn Serv
             payload,
             socket_id,
         } => {
-            reliable_server.add_connection(ClientId::from_raw(client_id), sockets[socket_id].is_reliable());
+            reliable_server.add_connection(client_id, sockets[socket_id].is_reliable());
             send_packet(sockets, payload, socket_id, addr);
         }
         ServerResult::ClientDisconnected {
@@ -293,7 +290,7 @@ fn handle_server_result(server_result: ServerResult, sockets: &mut [Box<dyn Serv
             payload,
             socket_id,
         } => {
-            reliable_server.remove_connection(ClientId::from_raw(client_id));
+            reliable_server.remove_connection(client_id);
             if let Some(payload) = payload {
                 send_packet(sockets, payload, socket_id, addr);
             }
diff --git a/renet2/src/transport/sockets.rs b/renet2_netcode/src/sockets.rs
similarity index 100%
rename from renet2/src/transport/sockets.rs
rename to renet2_netcode/src/sockets.rs
diff --git a/renet2/src/transport/websocket_socket/client/mod.rs b/renet2_netcode/src/websocket_socket/client/mod.rs
similarity index 100%
rename from renet2/src/transport/websocket_socket/client/mod.rs
rename to renet2_netcode/src/websocket_socket/client/mod.rs
diff --git a/renet2/src/transport/websocket_socket/client/socket.rs b/renet2_netcode/src/websocket_socket/client/socket.rs
similarity index 99%
rename from renet2/src/transport/websocket_socket/client/socket.rs
rename to renet2_netcode/src/websocket_socket/client/socket.rs
index 62f1cd47..bea2140e 100644
--- a/renet2/src/transport/websocket_socket/client/socket.rs
+++ b/renet2_netcode/src/websocket_socket/client/socket.rs
@@ -13,7 +13,7 @@ use wasm_bindgen::{closure::Closure, JsCast};
 use wasm_bindgen_futures::spawn_local;
 use web_sys::{BinaryType, CloseEvent, ErrorEvent, MessageEvent, WebSocket};
 
-use crate::transport::{ClientSocket, NetcodeTransportError, HTTP_CONNECT_REQ};
+use crate::{ClientSocket, NetcodeTransportError, HTTP_CONNECT_REQ};
 
 /// Configuration for setting up a [`WebSocketClient`].
 #[derive(Debug, Clone)]
diff --git a/renet2/src/transport/websocket_socket/mod.rs b/renet2_netcode/src/websocket_socket/mod.rs
similarity index 100%
rename from renet2/src/transport/websocket_socket/mod.rs
rename to renet2_netcode/src/websocket_socket/mod.rs
diff --git a/renet2/src/transport/websocket_socket/server/mod.rs b/renet2_netcode/src/websocket_socket/server/mod.rs
similarity index 100%
rename from renet2/src/transport/websocket_socket/server/mod.rs
rename to renet2_netcode/src/websocket_socket/server/mod.rs
diff --git a/renet2/src/transport/websocket_socket/server/socket.rs b/renet2_netcode/src/websocket_socket/server/socket.rs
similarity index 99%
rename from renet2/src/transport/websocket_socket/server/socket.rs
rename to renet2_netcode/src/websocket_socket/server/socket.rs
index 0c5fc840..ecaaef48 100644
--- a/renet2/src/transport/websocket_socket/server/socket.rs
+++ b/renet2_netcode/src/websocket_socket/server/socket.rs
@@ -19,7 +19,7 @@ use anyhow::Error;
 use bytes::Bytes;
 use tokio::sync::mpsc;
 
-use crate::transport::{client_idx_from_addr, client_idx_to_addr, NetcodeTransportError, ServerSocket, HTTP_CONNECT_REQ};
+use crate::{client_idx_from_addr, client_idx_to_addr, NetcodeTransportError, ServerSocket, HTTP_CONNECT_REQ};
 
 /// Acceptor config for WebSocket connections.
 ///
diff --git a/renet2/src/transport/webtransport_socket/client/availability_utils.rs b/renet2_netcode/src/webtransport_socket/client/availability_utils.rs
similarity index 95%
rename from renet2/src/transport/webtransport_socket/client/availability_utils.rs
rename to renet2_netcode/src/webtransport_socket/client/availability_utils.rs
index 792c595a..9120c569 100644
--- a/renet2/src/transport/webtransport_socket/client/availability_utils.rs
+++ b/renet2_netcode/src/webtransport_socket/client/availability_utils.rs
@@ -1,7 +1,7 @@
 use std::net::SocketAddr;
 
 use super::bindings::WebTransport;
-use crate::transport::{ServerCertHash, WebTransportClientConfig};
+use crate::{ServerCertHash, WebTransportClientConfig};
 
 /// Checks if the current WASM operating environment supports WebTransport.
 ///
diff --git a/renet2/src/transport/webtransport_socket/client/bindings.rs b/renet2_netcode/src/webtransport_socket/client/bindings.rs
similarity index 100%
rename from renet2/src/transport/webtransport_socket/client/bindings.rs
rename to renet2_netcode/src/webtransport_socket/client/bindings.rs
diff --git a/renet2/src/transport/webtransport_socket/client/mod.rs b/renet2_netcode/src/webtransport_socket/client/mod.rs
similarity index 100%
rename from renet2/src/transport/webtransport_socket/client/mod.rs
rename to renet2_netcode/src/webtransport_socket/client/mod.rs
diff --git a/renet2/src/transport/webtransport_socket/client/socket.rs b/renet2_netcode/src/webtransport_socket/client/socket.rs
similarity index 99%
rename from renet2/src/transport/webtransport_socket/client/socket.rs
rename to renet2_netcode/src/webtransport_socket/client/socket.rs
index f6ab8ace..a4a58d1d 100644
--- a/renet2/src/transport/webtransport_socket/client/socket.rs
+++ b/renet2_netcode/src/webtransport_socket/client/socket.rs
@@ -16,7 +16,7 @@ use wasm_bindgen::{prelude::Closure, JsValue};
 use wasm_bindgen_futures::{spawn_local, JsFuture};
 use web_sys::{ReadableStreamDefaultReader, WritableStreamDefaultWriter};
 
-use crate::transport::{ClientSocket, NetcodeTransportError, ServerCertHash, WebServerDestination, HTTP_CONNECT_REQ};
+use crate::{ClientSocket, NetcodeTransportError, ServerCertHash, WebServerDestination, HTTP_CONNECT_REQ};
 
 use super::bindings::{
     ReadableStreamDefaultReadResult, WebTransport, WebTransportCongestionControl, WebTransportError, WebTransportHash, WebTransportOptions,
diff --git a/renet2/src/transport/webtransport_socket/mod.rs b/renet2_netcode/src/webtransport_socket/mod.rs
similarity index 100%
rename from renet2/src/transport/webtransport_socket/mod.rs
rename to renet2_netcode/src/webtransport_socket/mod.rs
diff --git a/renet2/src/transport/webtransport_socket/server/cert_utils.rs b/renet2_netcode/src/webtransport_socket/server/cert_utils.rs
similarity index 98%
rename from renet2/src/transport/webtransport_socket/server/cert_utils.rs
rename to renet2_netcode/src/webtransport_socket/server/cert_utils.rs
index 3b1352bd..a118f3b4 100644
--- a/renet2/src/transport/webtransport_socket/server/cert_utils.rs
+++ b/renet2_netcode/src/webtransport_socket/server/cert_utils.rs
@@ -5,7 +5,7 @@ use time::{ext::NumericalDuration, OffsetDateTime};
 
 use std::path::PathBuf;
 
-use crate::transport::{ServerCertHash, WebServerDestination};
+use crate::{ServerCertHash, WebServerDestination};
 
 /// Generates a self-signed certificate for use in `WebTransportConfig`.
 ///
diff --git a/renet2/src/transport/webtransport_socket/server/mod.rs b/renet2_netcode/src/webtransport_socket/server/mod.rs
similarity index 100%
rename from renet2/src/transport/webtransport_socket/server/mod.rs
rename to renet2_netcode/src/webtransport_socket/server/mod.rs
diff --git a/renet2/src/transport/webtransport_socket/server/socket.rs b/renet2_netcode/src/webtransport_socket/server/socket.rs
similarity index 99%
rename from renet2/src/transport/webtransport_socket/server/socket.rs
rename to renet2_netcode/src/webtransport_socket/server/socket.rs
index 22ee2f04..db691317 100644
--- a/renet2/src/transport/webtransport_socket/server/socket.rs
+++ b/renet2_netcode/src/webtransport_socket/server/socket.rs
@@ -22,12 +22,10 @@ use std::{
     vec,
 };
 
-use crate::transport::{
-    client_idx_from_addr, client_idx_to_addr, NetcodeTransportError, ServerSocket, WebServerDestination, HTTP_CONNECT_REQ,
+use crate::{
+    client_idx_from_addr, client_idx_to_addr, NetcodeTransportError, ServerCertHash, ServerSocket, WebServerDestination, HTTP_CONNECT_REQ,
 };
 
-use crate::transport::ServerCertHash;
-
 use super::{generate_self_signed_certificate_opinionated, get_server_cert_hash};
 
 /// Configuration for setting up a [`WebTransportServer`].
diff --git a/renet2/src/transport/webtransport_socket/utils.rs b/renet2_netcode/src/webtransport_socket/utils.rs
similarity index 100%
rename from renet2/src/transport/webtransport_socket/utils.rs
rename to renet2_netcode/src/webtransport_socket/utils.rs
diff --git a/renet2_steam/Cargo.toml b/renet2_steam/Cargo.toml
index c5f29ba6..d8b84b3f 100644
--- a/renet2_steam/Cargo.toml
+++ b/renet2_steam/Cargo.toml
@@ -13,16 +13,14 @@ all-features = true
 rustdoc-args = ["-Zunstable-options", "--cfg", "docsrs"]
 
 [features]
-bevy = ["dep:bevy_app", "dep:bevy_ecs", "dep:bevy_renet2"]
+# Enable bevy integration
+bevy = ["dep:bevy_ecs"]
 
 [dependencies]
 renet2 = { version = "0.0.7", path = "../renet2" }
-# its version 0.10 but we need to use the rev because of a missing feature
 steamworks = "0.11"
 log = "0.4.19"
 bevy_ecs = { version = "0.15", optional = true }
-bevy_app = { version = "0.15", optional = true }
-bevy_renet2 = { version = "0.0.7", optional = true, path = "../bevy_renet2" }
 
 [dev-dependencies]
 env_logger = "0.11"
diff --git a/renet2_steam/README.md b/renet2_steam/README.md
index 30a77d21..b1446571 100644
--- a/renet2_steam/README.md
+++ b/renet2_steam/README.md
@@ -4,7 +4,7 @@
 ![MIT](https://img.shields.io/badge/license-MIT-blue.svg)
 ![Apache](https://img.shields.io/badge/license-Apache-blue.svg)
 
-Transport layer for the [renet](https://github.com/lucaspoffo/renet) crate using the steamworks-rs.
+Transport layer for the [renet2](https://github.com/UkoeHB/renet2) crate using the steamworks-rs.
 
 ## Usage
 
@@ -108,6 +108,6 @@ The LOBBY_ID is printed in the console when the server starts.
 
 ## Bevy
 
-If you are using bevy, you can enable the `bevy` feature and instead of using the default transport that comes in `bevy_renet` you can use `SteamServerPlugin` and `SteamClientPlugin`, the setup should be similar.
+If you are using bevy, you can use the `bevy_renet2` crate with the `steam` feature. That crate has `SteamServerPlugin` and `SteamClientPlugin`, with a similar setup.
 
-You can check the [Bevy Demo](https://github.com/lucaspoffo/renet/tree/master/demo_bevy) for how to use the default and steam transport switching between them using feature flags.
+You can check the [Bevy Demo](https://github.com/UkoeHB/renet2/tree/master/demo_bevy) for how to use the default and steam transport switching between them using feature flags.
diff --git a/renet2_steam/src/lib.rs b/renet2_steam/src/lib.rs
index 2997e5f8..9d59567a 100644
--- a/renet2_steam/src/lib.rs
+++ b/renet2_steam/src/lib.rs
@@ -5,9 +5,6 @@ const MAX_MESSAGE_BATCH_SIZE: usize = 512;
 mod client;
 mod server;
 
-#[cfg(feature = "bevy")]
-pub mod bevy;
-
 pub use client::SteamClientTransport;
 pub use server::{AccessPermission, SteamServerConfig, SteamServerTransport};
 
diff --git a/renet2_steam/src/server.rs b/renet2_steam/src/server.rs
index a9a0bee1..bc3f99c1 100644
--- a/renet2_steam/src/server.rs
+++ b/renet2_steam/src/server.rs
@@ -91,14 +91,14 @@ impl<T: Manager + 'static> SteamServerTransport<T> {
             match event {
                 ListenSocketEvent::Connected(event) => {
                     if let Some(steam_id) = event.remote().steam_id() {
-                        let client_id = ClientId::from_raw(steam_id.raw());
+                        let client_id = steam_id.raw();
                         server.add_connection(client_id, false);
                         self.connections.insert(client_id, event.take_connection());
                     }
                 }
                 ListenSocketEvent::Disconnected(event) => {
                     if let Some(steam_id) = event.remote().steam_id() {
-                        let client_id = ClientId::from_raw(steam_id.raw());
+                        let client_id = steam_id.raw();
                         server.remove_connection(client_id);
                         self.connections.remove(&client_id);
                     }