diff --git a/embassy/demos/common/src/server.rs b/embassy/demos/common/src/server.rs
index 1e25df941f74b02b4cc799067e4ebd103ea22e5e..52cccafa9dbb31c3102e55130b0c73c3de37937a 100644
--- a/embassy/demos/common/src/server.rs
+++ b/embassy/demos/common/src/server.rs
@@ -54,7 +54,7 @@ pub async fn listener<D: Driver, S: Shell>(stack: &'static Stack<D>,
     // frames more efficiently, RX doesn't matter so much?
     // How does this interact with the channel copy buffer sizes?
     let mut rx_buffer = [0; 1550];
-    let mut tx_buffer = [0; 1550];
+    let mut tx_buffer = [0; 4500];
 
     loop {
         let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
diff --git a/embassy/demos/picow/src/main.rs b/embassy/demos/picow/src/main.rs
index 1aa7b23e92b4fe1a8a082fb76451874da80064c4..1997203d694a6b6c17e6a03e8047a150dcfd336d 100644
--- a/embassy/demos/picow/src/main.rs
+++ b/embassy/demos/picow/src/main.rs
@@ -148,18 +148,16 @@ impl DemoShell {
         Ok(())
     }
 
-    async fn serial<R, W>(&self, mut sr: R, mut sw: W) -> Result<()>
+    async fn serial<R, W>(&self, mut sshr: R, mut sshw: W) -> Result<()>
         where R: asynch::Read+Io<Error=sunset::Error>,
             W: asynch::Write+Io<Error=sunset::Error> {
 
-        info!("serial top");
-
-        info!("take await");
         let (mut rx, mut tx) = self.ctx.usb_pipe.take().await;
-        info!("take done");
         let r = async {
-            let mut b = [0u8; 64];
-            let mut btrans = Vec::<u8, 128>::new();
+            // TODO: could have a single buffer to translate in-place.
+            const DOUBLE: usize = 2*takepipe::READ_SIZE;
+            let mut b = [0u8; takepipe::READ_SIZE];
+            let mut btrans = Vec::<u8, DOUBLE>::new();
             loop {
                 let n = rx.read(&mut b).await?;
                 let b = &mut b[..n];
@@ -171,7 +169,7 @@ impl DemoShell {
                     }
                     btrans.push(*c).unwrap();
                 }
-                sw.write_all(&btrans).await?;
+                sshw.write_all(&btrans).await?;
             }
             #[allow(unreachable_code)]
             Ok::<(), sunset::Error>(())
@@ -179,7 +177,7 @@ impl DemoShell {
         let w = async {
             let mut b = [0u8; 64];
             loop {
-                let n = sr.read(&mut b).await?;
+                let n = sshr.read(&mut b).await?;
                 if n == 0 {
                     return Err(sunset::Error::ChannelEOF);
                 }
diff --git a/embassy/demos/picow/src/takepipe.rs b/embassy/demos/picow/src/takepipe.rs
index 9be610b3a3efad3fdd5b2edbc19d4b3da5cee82c..64786f5dbb189e8148613078bc7f70f7f277d48b 100644
--- a/embassy/demos/picow/src/takepipe.rs
+++ b/embassy/demos/picow/src/takepipe.rs
@@ -6,7 +6,8 @@ use embassy_futures::select::{select, Either};
 
 use sunset_embassy::{SunsetMutex, SunsetRawMutex};
 
-const SIZE: usize = 64;
+pub const READ_SIZE: usize = 4000;
+pub const WRITE_SIZE: usize = 64;
 
 /// Allows a bidirectional pipe to be shared by many endpoints
 ///
@@ -19,8 +20,8 @@ const SIZE: usize = 64;
 ///
 /// It works a bit like `screen -r -d`.
 pub(crate) struct TakePipe {
-	fanout: Pipe<SunsetRawMutex, SIZE>,
-    fanin: Pipe<SunsetRawMutex, SIZE>,
+	fanout: Pipe<SunsetRawMutex, READ_SIZE>,
+    fanin: Pipe<SunsetRawMutex, WRITE_SIZE>,
     wake: Signal<SunsetRawMutex, ()>,
 }
 
@@ -49,8 +50,8 @@ impl Default for TakePipe {
 }
 
 pub(crate) struct TakeBase<'a> {
-    shared_read: Mutex<SunsetRawMutex, pipe::Reader<'a, SunsetRawMutex, SIZE>>,
-    shared_write: Mutex<SunsetRawMutex, pipe::Writer<'a, SunsetRawMutex, SIZE>>,
+    shared_read: Mutex<SunsetRawMutex, pipe::Reader<'a, SunsetRawMutex, READ_SIZE>>,
+    shared_write: Mutex<SunsetRawMutex, pipe::Writer<'a, SunsetRawMutex, WRITE_SIZE>>,
     pipe: &'a TakePipe,
 }
 
@@ -117,7 +118,7 @@ impl Io for TakeBaseWrite<'_> {
 
 pub(crate) struct TakeRead<'a> {
     pipe: &'a TakePipe,
-    shared: Option<MutexGuard<'a, SunsetRawMutex, pipe::Reader<'a, SunsetRawMutex, SIZE>>>,
+    shared: Option<MutexGuard<'a, SunsetRawMutex, pipe::Reader<'a, SunsetRawMutex, READ_SIZE>>>,
 }
 
 impl asynch::Read for TakeRead<'_> {
@@ -148,7 +149,7 @@ impl Io for TakeRead<'_> {
 
 pub(crate) struct TakeWrite<'a> {
     pipe: &'a TakePipe,
-    shared: Option<MutexGuard<'a, SunsetRawMutex, pipe::Writer<'a, SunsetRawMutex, SIZE>>>,
+    shared: Option<MutexGuard<'a, SunsetRawMutex, pipe::Writer<'a, SunsetRawMutex, WRITE_SIZE>>>,
 }
 
 impl asynch::Write for TakeWrite<'_> {