diff --git a/Cargo.lock b/Cargo.lock
index 4de8d09dcab8..d78c0f765d88 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -560,6 +560,18 @@ version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
+[[package]]
+name = "embedded-io"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced"
+
+[[package]]
+name = "embedded-io"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
+
 [[package]]
 name = "ena"
 version = "0.14.3"
@@ -1785,6 +1797,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24"
 dependencies = [
  "cobs",
+ "embedded-io 0.4.0",
+ "embedded-io 0.6.1",
  "heapless",
  "serde",
 ]
@@ -1820,6 +1834,7 @@ dependencies = [
  "indexmap",
  "intern",
  "paths",
+ "postcard",
  "proc-macro-srv",
  "rustc-hash 2.1.1",
  "serde",
diff --git a/Cargo.toml b/Cargo.toml
index 8ff7e0e8a2a9..946e54b40b02 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -127,6 +127,7 @@ object = { version = "0.36.7", default-features = false, features = [
     "macho",
     "pe",
 ] }
+postcard = {version = "1.1.3", features = ["alloc"]}
 process-wrap = { version = "8.2.1", features = ["std"] }
 pulldown-cmark-to-cmark = "10.0.4"
 pulldown-cmark = { version = "0.9.6", default-features = false }
diff --git a/crates/proc-macro-api/Cargo.toml b/crates/proc-macro-api/Cargo.toml
index 63745b9f7493..4077e11b7185 100644
--- a/crates/proc-macro-api/Cargo.toml
+++ b/crates/proc-macro-api/Cargo.toml
@@ -29,6 +29,7 @@ proc-macro-srv = {workspace = true, optional = true}
 span = { path = "../span", version = "0.0.0", default-features = false}
 
 intern.workspace = true
+postcard.workspace = true
 
 [features]
 sysroot-abi = ["proc-macro-srv", "proc-macro-srv/sysroot-abi"]
diff --git a/crates/proc-macro-api/src/codec.rs b/crates/proc-macro-api/src/codec.rs
new file mode 100644
index 000000000000..baccaa6be4c2
--- /dev/null
+++ b/crates/proc-macro-api/src/codec.rs
@@ -0,0 +1,12 @@
+//! Protocol codec
+
+use std::io;
+
+use serde::de::DeserializeOwned;
+
+use crate::framing::Framing;
+
+pub trait Codec: Framing {
+    fn encode<T: serde::Serialize>(msg: &T) -> io::Result<Self::Buf>;
+    fn decode<T: DeserializeOwned>(buf: &mut Self::Buf) -> io::Result<T>;
+}
diff --git a/crates/proc-macro-api/src/framing.rs b/crates/proc-macro-api/src/framing.rs
new file mode 100644
index 000000000000..a1e6fc05ca11
--- /dev/null
+++ b/crates/proc-macro-api/src/framing.rs
@@ -0,0 +1,14 @@
+//! Protocol framing
+
+use std::io::{self, BufRead, Write};
+
+pub trait Framing {
+    type Buf: Default;
+
+    fn read<'a, R: BufRead>(
+        inp: &mut R,
+        buf: &'a mut Self::Buf,
+    ) -> io::Result<Option<&'a mut Self::Buf>>;
+
+    fn write<W: Write>(out: &mut W, buf: &Self::Buf) -> io::Result<()>;
+}
diff --git a/crates/proc-macro-api/src/legacy_protocol.rs b/crates/proc-macro-api/src/legacy_protocol.rs
index 0a72052cc53b..c2b132ddcc1d 100644
--- a/crates/proc-macro-api/src/legacy_protocol.rs
+++ b/crates/proc-macro-api/src/legacy_protocol.rs
@@ -2,6 +2,7 @@
 
 pub mod json;
 pub mod msg;
+pub mod postcard;
 
 use std::{
     io::{BufRead, Write},
@@ -13,13 +14,15 @@ use span::Span;
 
 use crate::{
     ProcMacro, ProcMacroKind, ServerError,
+    codec::Codec,
     legacy_protocol::{
-        json::{read_json, write_json},
+        json::JsonProtocol,
         msg::{
             ExpandMacro, ExpandMacroData, ExpnGlobals, FlatTree, Message, Request, Response,
             ServerConfig, SpanDataIndexMap, deserialize_span_data_index_map,
             flat::serialize_span_data_index_map,
         },
+        postcard::PostcardProtocol,
     },
     process::ProcMacroServerProcess,
     version,
@@ -151,21 +154,25 @@ fn send_task(srv: &ProcMacroServerProcess, req: Request) -> Result<Response, Ser
         return Err(server_error.clone());
     }
 
-    srv.send_task(send_request, req)
+    if srv.use_postcard() {
+        srv.send_task(send_request::<PostcardProtocol>, req)
+    } else {
+        srv.send_task(send_request::<JsonProtocol>, req)
+    }
 }
 
 /// Sends a request to the server and reads the response.
-fn send_request(
+fn send_request<P: Codec>(
     mut writer: &mut dyn Write,
     mut reader: &mut dyn BufRead,
     req: Request,
-    buf: &mut String,
+    buf: &mut P::Buf,
 ) -> Result<Option<Response>, ServerError> {
-    req.write(write_json, &mut writer).map_err(|err| ServerError {
+    req.write::<_, P>(&mut writer).map_err(|err| ServerError {
         message: "failed to write request".into(),
         io: Some(Arc::new(err)),
     })?;
-    let res = Response::read(read_json, &mut reader, buf).map_err(|err| ServerError {
+    let res = Response::read::<_, P>(&mut reader, buf).map_err(|err| ServerError {
         message: "failed to read response".into(),
         io: Some(Arc::new(err)),
     })?;
diff --git a/crates/proc-macro-api/src/legacy_protocol/json.rs b/crates/proc-macro-api/src/legacy_protocol/json.rs
index c8f774031b58..1359c0568402 100644
--- a/crates/proc-macro-api/src/legacy_protocol/json.rs
+++ b/crates/proc-macro-api/src/legacy_protocol/json.rs
@@ -1,36 +1,58 @@
 //! Protocol functions for json.
 use std::io::{self, BufRead, Write};
 
-/// Reads a JSON message from the input stream.
-pub fn read_json<'a>(
-    inp: &mut impl BufRead,
-    buf: &'a mut String,
-) -> io::Result<Option<&'a String>> {
-    loop {
-        buf.clear();
-
-        inp.read_line(buf)?;
-        buf.pop(); // Remove trailing '\n'
-
-        if buf.is_empty() {
-            return Ok(None);
-        }
+use serde::{Serialize, de::DeserializeOwned};
+
+use crate::{codec::Codec, framing::Framing};
+
+pub struct JsonProtocol;
+
+impl Framing for JsonProtocol {
+    type Buf = String;
+
+    fn read<'a, R: BufRead>(
+        inp: &mut R,
+        buf: &'a mut String,
+    ) -> io::Result<Option<&'a mut String>> {
+        loop {
+            buf.clear();
+
+            inp.read_line(buf)?;
+            buf.pop(); // Remove trailing '\n'
 
-        // Some ill behaved macro try to use stdout for debugging
-        // We ignore it here
-        if !buf.starts_with('{') {
-            tracing::error!("proc-macro tried to print : {}", buf);
-            continue;
+            if buf.is_empty() {
+                return Ok(None);
+            }
+
+            // Some ill behaved macro try to use stdout for debugging
+            // We ignore it here
+            if !buf.starts_with('{') {
+                tracing::error!("proc-macro tried to print : {}", buf);
+                continue;
+            }
+
+            return Ok(Some(buf));
         }
+    }
 
-        return Ok(Some(buf));
+    fn write<W: Write>(out: &mut W, buf: &String) -> io::Result<()> {
+        tracing::debug!("> {}", buf);
+        out.write_all(buf.as_bytes())?;
+        out.write_all(b"\n")?;
+        out.flush()
     }
 }
 
-/// Writes a JSON message to the output stream.
-pub fn write_json(out: &mut impl Write, msg: &str) -> io::Result<()> {
-    tracing::debug!("> {}", msg);
-    out.write_all(msg.as_bytes())?;
-    out.write_all(b"\n")?;
-    out.flush()
+impl Codec for JsonProtocol {
+    fn encode<T: Serialize>(msg: &T) -> io::Result<String> {
+        Ok(serde_json::to_string(msg)?)
+    }
+
+    fn decode<T: DeserializeOwned>(buf: &mut String) -> io::Result<T> {
+        let mut deserializer = serde_json::Deserializer::from_str(buf);
+        // Note that some proc-macro generate very deep syntax tree
+        // We have to disable the current limit of serde here
+        deserializer.disable_recursion_limit();
+        Ok(T::deserialize(&mut deserializer)?)
+    }
 }
diff --git a/crates/proc-macro-api/src/legacy_protocol/msg.rs b/crates/proc-macro-api/src/legacy_protocol/msg.rs
index 487f50b145e8..1c77863aac34 100644
--- a/crates/proc-macro-api/src/legacy_protocol/msg.rs
+++ b/crates/proc-macro-api/src/legacy_protocol/msg.rs
@@ -8,7 +8,7 @@ use paths::Utf8PathBuf;
 use serde::de::DeserializeOwned;
 use serde_derive::{Deserialize, Serialize};
 
-use crate::ProcMacroKind;
+use crate::{ProcMacroKind, codec::Codec};
 
 /// Represents requests sent from the client to the proc-macro-srv.
 #[derive(Debug, Serialize, Deserialize)]
@@ -149,39 +149,21 @@ impl ExpnGlobals {
 }
 
 pub trait Message: serde::Serialize + DeserializeOwned {
-    fn read<R: BufRead>(
-        from_proto: ProtocolRead<R>,
-        inp: &mut R,
-        buf: &mut String,
-    ) -> io::Result<Option<Self>> {
-        Ok(match from_proto(inp, buf)? {
+    fn read<R: BufRead, C: Codec>(inp: &mut R, buf: &mut C::Buf) -> io::Result<Option<Self>> {
+        Ok(match C::read(inp, buf)? {
             None => None,
-            Some(text) => {
-                let mut deserializer = serde_json::Deserializer::from_str(text);
-                // Note that some proc-macro generate very deep syntax tree
-                // We have to disable the current limit of serde here
-                deserializer.disable_recursion_limit();
-                Some(Self::deserialize(&mut deserializer)?)
-            }
+            Some(buf) => C::decode(buf)?,
         })
     }
-    fn write<W: Write>(self, to_proto: ProtocolWrite<W>, out: &mut W) -> io::Result<()> {
-        let text = serde_json::to_string(&self)?;
-        to_proto(out, &text)
+    fn write<W: Write, C: Codec>(self, out: &mut W) -> io::Result<()> {
+        let value = C::encode(&self)?;
+        C::write(out, &value)
     }
 }
 
 impl Message for Request {}
 impl Message for Response {}
 
-/// Type alias for a function that reads protocol messages from a buffered input stream.
-#[allow(type_alias_bounds)]
-type ProtocolRead<R: BufRead> =
-    for<'i, 'buf> fn(inp: &'i mut R, buf: &'buf mut String) -> io::Result<Option<&'buf String>>;
-/// Type alias for a function that writes protocol messages to an output stream.
-#[allow(type_alias_bounds)]
-type ProtocolWrite<W: Write> = for<'o, 'msg> fn(out: &'o mut W, msg: &'msg str) -> io::Result<()>;
-
 #[cfg(test)]
 mod tests {
     use intern::{Symbol, sym};
diff --git a/crates/proc-macro-api/src/legacy_protocol/postcard.rs b/crates/proc-macro-api/src/legacy_protocol/postcard.rs
new file mode 100644
index 000000000000..c28a9bfe3a1a
--- /dev/null
+++ b/crates/proc-macro-api/src/legacy_protocol/postcard.rs
@@ -0,0 +1,40 @@
+//! Postcard encode and decode implementations.
+
+use std::io::{self, BufRead, Write};
+
+use serde::{Serialize, de::DeserializeOwned};
+
+use crate::{codec::Codec, framing::Framing};
+
+pub struct PostcardProtocol;
+
+impl Framing for PostcardProtocol {
+    type Buf = Vec<u8>;
+
+    fn read<'a, R: BufRead>(
+        inp: &mut R,
+        buf: &'a mut Vec<u8>,
+    ) -> io::Result<Option<&'a mut Vec<u8>>> {
+        buf.clear();
+        let n = inp.read_until(0, buf)?;
+        if n == 0 {
+            return Ok(None);
+        }
+        Ok(Some(buf))
+    }
+
+    fn write<W: Write>(out: &mut W, buf: &Vec<u8>) -> io::Result<()> {
+        out.write_all(buf)?;
+        out.flush()
+    }
+}
+
+impl Codec for PostcardProtocol {
+    fn encode<T: Serialize>(msg: &T) -> io::Result<Vec<u8>> {
+        postcard::to_allocvec_cobs(msg).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
+    }
+
+    fn decode<T: DeserializeOwned>(buf: &mut Self::Buf) -> io::Result<T> {
+        postcard::from_bytes_cobs(buf).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
+    }
+}
diff --git a/crates/proc-macro-api/src/lib.rs b/crates/proc-macro-api/src/lib.rs
index 870d81f97684..a725b94f04b2 100644
--- a/crates/proc-macro-api/src/lib.rs
+++ b/crates/proc-macro-api/src/lib.rs
@@ -12,6 +12,8 @@
 )]
 #![allow(internal_features)]
 
+mod codec;
+mod framing;
 pub mod legacy_protocol;
 mod process;
 
@@ -19,7 +21,8 @@ use paths::{AbsPath, AbsPathBuf};
 use span::{ErasedFileAstId, FIXUP_ERASED_FILE_AST_ID_MARKER, Span};
 use std::{fmt, io, sync::Arc, time::SystemTime};
 
-use crate::process::ProcMacroServerProcess;
+pub use crate::codec::Codec;
+use crate::{legacy_protocol::SpanMode, process::ProcMacroServerProcess};
 
 /// The versions of the server protocol
 pub mod version {
@@ -123,7 +126,11 @@ impl ProcMacroClient {
             Item = (impl AsRef<std::ffi::OsStr>, &'a Option<impl 'a + AsRef<std::ffi::OsStr>>),
         > + Clone,
     ) -> io::Result<ProcMacroClient> {
-        let process = ProcMacroServerProcess::run(process_path, env)?;
+        let process = ProcMacroServerProcess::run(
+            process_path,
+            env,
+            process::Protocol::Postcard { mode: SpanMode::Id },
+        )?;
         Ok(ProcMacroClient { process: Arc::new(process), path: process_path.to_owned() })
     }
 
diff --git a/crates/proc-macro-api/src/process.rs b/crates/proc-macro-api/src/process.rs
index fe274a027a80..1365245f9846 100644
--- a/crates/proc-macro-api/src/process.rs
+++ b/crates/proc-macro-api/src/process.rs
@@ -28,9 +28,10 @@ pub(crate) struct ProcMacroServerProcess {
     exited: OnceLock<AssertUnwindSafe<ServerError>>,
 }
 
-#[derive(Debug)]
-enum Protocol {
+#[derive(Debug, Clone)]
+pub(crate) enum Protocol {
     LegacyJson { mode: SpanMode },
+    Postcard { mode: SpanMode },
 }
 
 /// Maintains the state of the proc-macro server process.
@@ -48,50 +49,82 @@ impl ProcMacroServerProcess {
         env: impl IntoIterator<
             Item = (impl AsRef<std::ffi::OsStr>, &'a Option<impl 'a + AsRef<std::ffi::OsStr>>),
         > + Clone,
+        protocol: Protocol,
     ) -> io::Result<ProcMacroServerProcess> {
-        let create_srv = || {
-            let mut process = Process::run(process_path, env.clone())?;
+        let mut srv = {
+            let mut process = match Process::run(process_path, env.clone(), &protocol) {
+                Ok(process) => process,
+                Err(e) => {
+                    // fallback
+                    if matches!(protocol, Protocol::Postcard { .. }) {
+                        // retry with json
+                        return Self::run(
+                            process_path,
+                            env,
+                            Protocol::LegacyJson { mode: SpanMode::Id },
+                        );
+                    }
+                    return Err(e);
+                }
+            };
             let (stdin, stdout) = process.stdio().expect("couldn't access child stdio");
 
-            io::Result::Ok(ProcMacroServerProcess {
+            ProcMacroServerProcess {
                 state: Mutex::new(ProcessSrvState { process, stdin, stdout }),
                 version: 0,
-                protocol: Protocol::LegacyJson { mode: SpanMode::Id },
+                protocol: protocol.clone(),
                 exited: OnceLock::new(),
-            })
+            }
         };
-        let mut srv = create_srv()?;
         tracing::info!("sending proc-macro server version check");
-        match srv.version_check() {
-            Ok(v) if v > version::CURRENT_API_VERSION => {
-                #[allow(clippy::disallowed_methods)]
-                let process_version = Command::new(process_path)
-                    .arg("--version")
-                    .output()
-                    .map(|output| String::from_utf8_lossy(&output.stdout).trim().to_owned())
-                    .unwrap_or_else(|_| "unknown version".to_owned());
-                Err(io::Error::other(format!(
-                    "Your installed proc-macro server is too new for your rust-analyzer. API version: {}, server version: {process_version}. \
-                        This will prevent proc-macro expansion from working. Please consider updating your rust-analyzer to ensure compatibility with your current toolchain.",
-                    version::CURRENT_API_VERSION
-                )))
-            }
-            Ok(v) => {
-                tracing::info!("Proc-macro server version: {v}");
-                srv.version = v;
-                if srv.version >= version::RUST_ANALYZER_SPAN_SUPPORT
-                    && let Ok(mode) = srv.enable_rust_analyzer_spans()
-                {
-                    srv.protocol = Protocol::LegacyJson { mode };
-                }
-                tracing::info!("Proc-macro server protocol: {:?}", srv.protocol);
-                Ok(srv)
-            }
+        let version = match srv.version_check() {
+            Ok(v) => v,
             Err(e) => {
+                if matches!(protocol, Protocol::Postcard { .. }) {
+                    // retry with json
+                    return Self::run(
+                        process_path,
+                        env,
+                        Protocol::LegacyJson { mode: SpanMode::Id },
+                    );
+                }
+
                 tracing::info!(%e, "proc-macro version check failed");
-                Err(io::Error::other(format!("proc-macro server version check failed: {e}")))
+                return Err(io::Error::other(format!(
+                    "proc-macro server version check failed: {e}"
+                )));
             }
+        };
+
+        if version > version::CURRENT_API_VERSION {
+            #[allow(clippy::disallowed_methods)]
+            let process_version = Command::new(process_path)
+                .arg("--version")
+                .output()
+                .map(|out| String::from_utf8_lossy(&out.stdout).trim().to_owned())
+                .unwrap_or_else(|_| "unknown version".to_owned());
+
+            return Err(io::Error::other(format!(
+                "Your installed proc-macro server is too new for your rust-analyzer. API version: {}, server version: {process_version}. \
+                        This will prevent proc-macro expansion from working. Please consider updating your rust-analyzer to ensure compatibility with your current toolchain.",
+                version::CURRENT_API_VERSION
+            )));
         }
+
+        tracing::info!("proc-macro server version: {version}");
+
+        srv.version = version;
+
+        if version >= version::RUST_ANALYZER_SPAN_SUPPORT
+            && let Ok(new_mode) = srv.enable_rust_analyzer_spans()
+        {
+            match &mut srv.protocol {
+                Protocol::Postcard { mode } | Protocol::LegacyJson { mode } => *mode = new_mode,
+            };
+        }
+
+        tracing::info!("proc-macro server protocol: {:?}", srv.protocol);
+        Ok(srv)
     }
 
     /// Returns the server error if the process has exited.
@@ -99,6 +132,10 @@ impl ProcMacroServerProcess {
         self.exited.get().map(|it| &it.0)
     }
 
+    pub(crate) fn use_postcard(&self) -> bool {
+        matches!(self.protocol, Protocol::Postcard { .. })
+    }
+
     /// Retrieves the API version of the proc-macro server.
     pub(crate) fn version(&self) -> u32 {
         self.version
@@ -108,6 +145,7 @@ impl ProcMacroServerProcess {
     pub(crate) fn rust_analyzer_spans(&self) -> bool {
         match self.protocol {
             Protocol::LegacyJson { mode } => mode == SpanMode::RustAnalyzer,
+            Protocol::Postcard { mode } => mode == SpanMode::RustAnalyzer,
         }
     }
 
@@ -115,6 +153,7 @@ impl ProcMacroServerProcess {
     fn version_check(&self) -> Result<u32, ServerError> {
         match self.protocol {
             Protocol::LegacyJson { .. } => legacy_protocol::version_check(self),
+            Protocol::Postcard { .. } => legacy_protocol::version_check(self),
         }
     }
 
@@ -122,6 +161,7 @@ impl ProcMacroServerProcess {
     fn enable_rust_analyzer_spans(&self) -> Result<SpanMode, ServerError> {
         match self.protocol {
             Protocol::LegacyJson { .. } => legacy_protocol::enable_rust_analyzer_spans(self),
+            Protocol::Postcard { .. } => legacy_protocol::enable_rust_analyzer_spans(self),
         }
     }
 
@@ -132,21 +172,25 @@ impl ProcMacroServerProcess {
     ) -> Result<Result<Vec<(String, ProcMacroKind)>, String>, ServerError> {
         match self.protocol {
             Protocol::LegacyJson { .. } => legacy_protocol::find_proc_macros(self, dylib_path),
+            Protocol::Postcard { .. } => legacy_protocol::find_proc_macros(self, dylib_path),
         }
     }
 
-    pub(crate) fn send_task<Request, Response>(
+    pub(crate) fn send_task<Request, Response, Buf>(
         &self,
         serialize_req: impl FnOnce(
             &mut dyn Write,
             &mut dyn BufRead,
             Request,
-            &mut String,
+            &mut Buf,
         ) -> Result<Option<Response>, ServerError>,
         req: Request,
-    ) -> Result<Response, ServerError> {
+    ) -> Result<Response, ServerError>
+    where
+        Buf: Default,
+    {
         let state = &mut *self.state.lock().unwrap();
-        let mut buf = String::new();
+        let mut buf = Buf::default();
         serialize_req(&mut state.stdin, &mut state.stdout, req, &mut buf)
             .and_then(|res| {
                 res.ok_or_else(|| {
@@ -203,8 +247,9 @@ impl Process {
         env: impl IntoIterator<
             Item = (impl AsRef<std::ffi::OsStr>, &'a Option<impl 'a + AsRef<std::ffi::OsStr>>),
         >,
+        protocol: &Protocol,
     ) -> io::Result<Process> {
-        let child = JodChild(mk_child(path, env)?);
+        let child = JodChild(mk_child(path, env, protocol)?);
         Ok(Process { child })
     }
 
@@ -224,9 +269,15 @@ fn mk_child<'a>(
     extra_env: impl IntoIterator<
         Item = (impl AsRef<std::ffi::OsStr>, &'a Option<impl 'a + AsRef<std::ffi::OsStr>>),
     >,
+    protocol: &Protocol,
 ) -> io::Result<Child> {
     #[allow(clippy::disallowed_methods)]
     let mut cmd = Command::new(path);
+    if matches!(protocol, Protocol::LegacyJson { .. }) {
+        cmd.args(["--format", "json"]);
+    } else {
+        cmd.args(["--format", "postcard"]);
+    }
     for env in extra_env {
         match env {
             (key, Some(val)) => cmd.env(key, val),
diff --git a/crates/proc-macro-srv-cli/Cargo.toml b/crates/proc-macro-srv-cli/Cargo.toml
index dd31e74915bf..aa153897fa96 100644
--- a/crates/proc-macro-srv-cli/Cargo.toml
+++ b/crates/proc-macro-srv-cli/Cargo.toml
@@ -14,14 +14,13 @@ publish = false
 proc-macro-srv.workspace = true
 proc-macro-api.workspace = true
 tt.workspace = true
+postcard.workspace = true
 clap = {version = "4.5.42", default-features = false, features = ["std"]}
-postcard = { version = "1.1.3", optional = true }
 
 [features]
-default = ["postcard"]
+default = []
 sysroot-abi = ["proc-macro-srv/sysroot-abi", "proc-macro-api/sysroot-abi"]
 in-rust-tree = ["proc-macro-srv/in-rust-tree", "sysroot-abi"]
-postcard = ["dep:postcard"]
 
 
 [[bin]]
diff --git a/crates/proc-macro-srv-cli/src/main.rs b/crates/proc-macro-srv-cli/src/main.rs
index 9d74fa637aa9..b6c38da45475 100644
--- a/crates/proc-macro-srv-cli/src/main.rs
+++ b/crates/proc-macro-srv-cli/src/main.rs
@@ -51,26 +51,23 @@ fn main() -> std::io::Result<()> {
 #[derive(Copy, Clone)]
 enum ProtocolFormat {
     Json,
-    #[cfg(feature = "postcard")]
     Postcard,
 }
 
 impl ValueEnum for ProtocolFormat {
     fn value_variants<'a>() -> &'a [Self] {
-        &[ProtocolFormat::Json]
+        &[ProtocolFormat::Json, ProtocolFormat::Postcard]
     }
 
     fn to_possible_value(&self) -> Option<clap::builder::PossibleValue> {
         match self {
             ProtocolFormat::Json => Some(clap::builder::PossibleValue::new("json")),
-            #[cfg(feature = "postcard")]
             ProtocolFormat::Postcard => Some(clap::builder::PossibleValue::new("postcard")),
         }
     }
     fn from_str(input: &str, _ignore_case: bool) -> Result<Self, String> {
         match input {
             "json" => Ok(ProtocolFormat::Json),
-            #[cfg(feature = "postcard")]
             "postcard" => Ok(ProtocolFormat::Postcard),
             _ => Err(format!("unknown protocol format: {input}")),
         }
diff --git a/crates/proc-macro-srv-cli/src/main_loop.rs b/crates/proc-macro-srv-cli/src/main_loop.rs
index 55331075704a..029ab6eca941 100644
--- a/crates/proc-macro-srv-cli/src/main_loop.rs
+++ b/crates/proc-macro-srv-cli/src/main_loop.rs
@@ -2,19 +2,20 @@
 use std::io;
 
 use proc_macro_api::{
+    Codec,
     legacy_protocol::{
-        json::{read_json, write_json},
+        json::JsonProtocol,
         msg::{
             self, ExpandMacroData, ExpnGlobals, Message, SpanMode, SpanTransformer,
             deserialize_span_data_index_map, serialize_span_data_index_map,
         },
+        postcard::PostcardProtocol,
     },
     version::CURRENT_API_VERSION,
 };
 use proc_macro_srv::{EnvSnapshot, SpanId};
 
 use crate::ProtocolFormat;
-
 struct SpanTrans;
 
 impl SpanTransformer for SpanTrans {
@@ -36,13 +37,12 @@ impl SpanTransformer for SpanTrans {
 
 pub(crate) fn run(format: ProtocolFormat) -> io::Result<()> {
     match format {
-        ProtocolFormat::Json => run_json(),
-        #[cfg(feature = "postcard")]
-        ProtocolFormat::Postcard => unimplemented!(),
+        ProtocolFormat::Json => run_::<JsonProtocol>(),
+        ProtocolFormat::Postcard => run_::<PostcardProtocol>(),
     }
 }
 
-fn run_json() -> io::Result<()> {
+fn run_<C: Codec>() -> io::Result<()> {
     fn macro_kind_to_api(kind: proc_macro_srv::ProcMacroKind) -> proc_macro_api::ProcMacroKind {
         match kind {
             proc_macro_srv::ProcMacroKind::CustomDerive => {
@@ -53,9 +53,9 @@ fn run_json() -> io::Result<()> {
         }
     }
 
-    let mut buf = String::new();
-    let mut read_request = || msg::Request::read(read_json, &mut io::stdin().lock(), &mut buf);
-    let write_response = |msg: msg::Response| msg.write(write_json, &mut io::stdout().lock());
+    let mut buf = C::Buf::default();
+    let mut read_request = || msg::Request::read::<_, C>(&mut io::stdin().lock(), &mut buf);
+    let write_response = |msg: msg::Response| msg.write::<_, C>(&mut io::stdout().lock());
 
     let env = EnvSnapshot::default();
     let srv = proc_macro_srv::ProcMacroSrv::new(&env);