diff --git a/src/Daqifi.Core.Tests/Communication/Consumers/CompositeMessageParserTests.cs b/src/Daqifi.Core.Tests/Communication/Consumers/CompositeMessageParserTests.cs
new file mode 100644
index 0000000..20f2f33
--- /dev/null
+++ b/src/Daqifi.Core.Tests/Communication/Consumers/CompositeMessageParserTests.cs
@@ -0,0 +1,192 @@
+using Daqifi.Core.Communication.Consumers;
+using Daqifi.Core.Communication.Messages;
+using System.Text;
+
+namespace Daqifi.Core.Tests.Communication.Consumers;
+
+public class CompositeMessageParserTests
+{
+    [Fact]
+    public void CompositeMessageParser_ParseMessages_WithTextData_ShouldUseTextParser()
+    {
+        // Arrange
+        var parser = new CompositeMessageParser();
+        var textData = Encoding.UTF8.GetBytes("*IDN?\r\nDAQiFi Device v1.0\r\n");
+        
+        // Act
+        var messages = parser.ParseMessages(textData, out var consumedBytes);
+        
+        // Assert
+        Assert.Equal(2, messages.Count());
+        Assert.All(messages, msg => Assert.IsType<string>(msg.Data));
+        Assert.Equal("*IDN?", messages.First().Data);
+        Assert.Equal("DAQiFi Device v1.0", messages.Last().Data);
+        Assert.Equal(textData.Length, consumedBytes);
+    }
+
+    [Fact]
+    public void CompositeMessageParser_ParseMessages_WithBinaryData_ShouldUseProtobufParser()
+    {
+        // Arrange
+        var parser = new CompositeMessageParser();
+        // Binary data with null bytes should trigger protobuf parsing attempt
+        var binaryDataWithNulls = new byte[] { 0x00, 0x01, 0x00, 0x02 };
+        
+        // Act
+        var messages = parser.ParseMessages(binaryDataWithNulls, out var consumedBytes);
+        
+        // Assert - Should attempt protobuf parsing due to null bytes
+        // Even if parsing fails, should not throw exceptions
+        Assert.True(consumedBytes >= 0);
+    }
+
+    [Fact]
+    public void CompositeMessageParser_ParseMessages_WithNullBytes_ShouldDetectAsBinary()
+    {
+        // Arrange
+        var parser = new CompositeMessageParser();
+        var dataWithNulls = new byte[] { 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x00, 0x57, 0x6F, 0x72, 0x6C, 0x64 }; // "Hello\0World"
+        
+        // Act
+        var messages = parser.ParseMessages(dataWithNulls, out var consumedBytes);
+        
+        // Assert - Should try protobuf parser first due to null bytes
+        // May return empty if not valid protobuf, but should have attempted protobuf parsing
+        Assert.True(consumedBytes >= 0);
+    }
+
+    [Fact]
+    public void CompositeMessageParser_ParseMessages_WithNoNullBytes_ShouldDetectAsText()
+    {
+        // Arrange
+        var parser = new CompositeMessageParser();
+        var textOnlyData = Encoding.UTF8.GetBytes("Hello World\r\n");
+        
+        // Act
+        var messages = parser.ParseMessages(textOnlyData, out var consumedBytes);
+        
+        // Assert
+        Assert.Single(messages);
+        Assert.IsType<string>(messages.First().Data);
+        Assert.Equal("Hello World", messages.First().Data);
+        Assert.Equal(textOnlyData.Length, consumedBytes);
+    }
+
+    [Fact]
+    public void CompositeMessageParser_ParseMessages_WithEmptyData_ShouldReturnEmpty()
+    {
+        // Arrange
+        var parser = new CompositeMessageParser();
+        var emptyData = new byte[0];
+        
+        // Act
+        var messages = parser.ParseMessages(emptyData, out var consumedBytes);
+        
+        // Assert
+        Assert.Empty(messages);
+        Assert.Equal(0, consumedBytes);
+    }
+
+    [Fact]
+    public void CompositeMessageParser_ParseMessages_WithCustomParsers_ShouldUseProvided()
+    {
+        // Arrange
+        var mockTextParser = new LineBasedMessageParser("\n"); // Custom line ending
+        var mockProtobufParser = new ProtobufMessageParser();
+        var parser = new CompositeMessageParser(mockTextParser, mockProtobufParser);
+        
+        var textData = Encoding.UTF8.GetBytes("Line 1\nLine 2\n");
+        
+        // Act
+        var messages = parser.ParseMessages(textData, out var consumedBytes);
+        
+        // Assert
+        Assert.Equal(2, messages.Count());
+        Assert.All(messages, msg => Assert.IsType<string>(msg.Data));
+        Assert.Equal("Line 1", messages.First().Data);
+        Assert.Equal("Line 2", messages.Last().Data);
+    }
+
+    [Fact]
+    public void CompositeMessageParser_ParseMessages_WithNullTextParser_ShouldStillWork()
+    {
+        // Arrange
+        var parser = new CompositeMessageParser(null, new ProtobufMessageParser());
+        var textData = Encoding.UTF8.GetBytes("Hello World\r\n");
+        
+        // Act
+        var messages = parser.ParseMessages(textData, out var consumedBytes);
+        
+        // Assert - Should fallback to protobuf parser, which likely won't parse text successfully
+        // But should not throw an exception
+        Assert.True(consumedBytes >= 0);
+    }
+
+    [Fact]
+    public void CompositeMessageParser_ParseMessages_WithNullProtobufParser_ShouldStillWork()
+    {
+        // Arrange
+        var parser = new CompositeMessageParser(new LineBasedMessageParser(), null);
+        var binaryData = new byte[] { 0x00, 0x01, 0x02, 0x03 }; // Binary data with null bytes
+        
+        // Act
+        var messages = parser.ParseMessages(binaryData, out var consumedBytes);
+        
+        // Assert - Should try text parser even for binary data
+        Assert.True(consumedBytes >= 0);
+    }
+
+    [Fact]
+    public void CompositeMessageParser_ParseMessages_ReturnsDifferentMessageTypes()
+    {
+        // Arrange
+        var parser = new CompositeMessageParser();
+        
+        // Test text message
+        var textData = Encoding.UTF8.GetBytes("Text Message\r\n");
+        var textMessages = parser.ParseMessages(textData, out _);
+        
+        // Test binary message (mock binary data)
+        var binaryData = new byte[] { 0x00, 0x08, 0x01 }; // Mock binary with null bytes
+        var binaryMessages = parser.ParseMessages(binaryData, out _);
+        
+        // Assert
+        if (textMessages.Any())
+        {
+            Assert.IsType<string>(textMessages.First().Data);
+        }
+        
+        // Binary messages might not parse successfully, but should not throw
+        Assert.True(binaryMessages.Count() >= 0);
+    }
+
+    [Fact]
+    public void CompositeMessageParser_ParseMessages_WithMixedScenarios_ShouldHandleGracefully()
+    {
+        // Arrange
+        var parser = new CompositeMessageParser();
+        
+        // Test various data patterns that might come from real DAQiFi devices
+        var scenarios = new[]
+        {
+            Encoding.UTF8.GetBytes("*IDN?\r\n"),                    // SCPI command
+            Encoding.UTF8.GetBytes("SYST:ERR?\r\n"),               // SCPI query
+            new byte[] { 0x0A, 0x04, 0x74, 0x65, 0x73, 0x74 },   // Mock protobuf-like
+            new byte[] { 0x00, 0x00, 0x00, 0x01 },                // Binary with nulls
+            Encoding.UTF8.GetBytes(""),                             // Empty
+            new byte[] { 0xFF }                                     // Single byte
+        };
+        
+        // Act & Assert - Should not throw exceptions for any scenario
+        foreach (var scenario in scenarios)
+        {
+            var exception = Record.Exception(() => 
+            {
+                var messages = parser.ParseMessages(scenario, out var consumed);
+                Assert.True(consumed >= 0);
+            });
+            
+            Assert.Null(exception);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Daqifi.Core.Tests/Communication/Consumers/ProtobufMessageParserTests.cs b/src/Daqifi.Core.Tests/Communication/Consumers/ProtobufMessageParserTests.cs
new file mode 100644
index 0000000..71b78ae
--- /dev/null
+++ b/src/Daqifi.Core.Tests/Communication/Consumers/ProtobufMessageParserTests.cs
@@ -0,0 +1,126 @@
+using Daqifi.Core.Communication.Consumers;
+using Daqifi.Core.Communication.Messages;
+using Google.Protobuf;
+
+namespace Daqifi.Core.Tests.Communication.Consumers;
+
+public class ProtobufMessageParserTests
+{
+    [Fact]
+    public void ProtobufMessageParser_ParseMessages_WithValidProtobuf_ShouldReturnMessage()
+    {
+        // Arrange
+        var parser = new ProtobufMessageParser();
+        // Create minimal valid protobuf data (empty message)
+        var data = new byte[] { }; // Empty protobuf message
+        
+        // Act
+        var messages = parser.ParseMessages(data, out var consumedBytes);
+        
+        // Assert - Empty message should parse successfully
+        if (messages.Any())
+        {
+            Assert.IsType<ProtobufMessage>(messages.First());
+        }
+        Assert.True(consumedBytes >= 0);
+    }
+
+    [Fact]
+    public void ProtobufMessageParser_ParseMessages_WithInvalidData_ShouldReturnEmpty()
+    {
+        // Arrange
+        var parser = new ProtobufMessageParser();
+        var invalidData = new byte[] { 0xFF, 0xFF, 0xFF, 0xFF }; // Invalid protobuf data
+        
+        // Act
+        var messages = parser.ParseMessages(invalidData, out var consumedBytes);
+        
+        // Assert
+        Assert.Empty(messages);
+        Assert.Equal(0, consumedBytes);
+    }
+
+    [Fact]
+    public void ProtobufMessageParser_ParseMessages_WithEmptyData_ShouldReturnEmpty()
+    {
+        // Arrange
+        var parser = new ProtobufMessageParser();
+        var data = new byte[0];
+        
+        // Act
+        var messages = parser.ParseMessages(data, out var consumedBytes);
+        
+        // Assert
+        Assert.Empty(messages);
+        Assert.Equal(0, consumedBytes);
+    }
+
+    [Fact]
+    public void ProtobufMessageParser_ParseMessages_WithNullBytes_ShouldHandleCorrectly()
+    {
+        // Arrange - This simulates the actual issue with binary protobuf containing null bytes
+        var parser = new ProtobufMessageParser();
+        // Create data with null bytes that would break LineBasedMessageParser
+        var dataWithNulls = new byte[] { 0x00, 0x01, 0x02, 0x00, 0x03 };
+        
+        // Act - Parser should handle the null bytes gracefully
+        var messages = parser.ParseMessages(dataWithNulls, out var consumedBytes);
+        
+        // Assert - Should not throw exceptions, even if parsing fails
+        Assert.True(consumedBytes >= 0);
+    }
+
+    [Fact]
+    public void ProtobufMessageParser_ParseMessages_WithIncompleteData_ShouldReturnEmpty()
+    {
+        // Arrange
+        var parser = new ProtobufMessageParser();
+        var originalMessage = new DaqifiOutMessage();
+        var completeData = originalMessage.ToByteArray();
+        var incompleteData = completeData.Take(completeData.Length / 2).ToArray(); // Half the data
+        
+        // Act
+        var messages = parser.ParseMessages(incompleteData, out var consumedBytes);
+        
+        // Assert - Should not parse incomplete protobuf
+        Assert.Empty(messages);
+        Assert.Equal(0, consumedBytes);
+    }
+
+    [Fact]
+    public void ProtobufMessageParser_ParseMessages_WithMultipleMessages_ShouldParseFirst()
+    {
+        // Arrange
+        var parser = new ProtobufMessageParser();
+        // Create combined mock protobuf data
+        var data1 = new byte[] { 0x08, 0x01 }; // Mock protobuf message 1
+        var data2 = new byte[] { 0x08, 0x02 }; // Mock protobuf message 2
+        var combinedData = data1.Concat(data2).ToArray();
+        
+        // Act
+        var messages = parser.ParseMessages(combinedData, out var consumedBytes);
+        
+        // Assert - Should attempt to parse and consume some data
+        Assert.True(consumedBytes >= 0);
+    }
+
+    [Fact]
+    public void ProtobufMessageParser_ParseMessages_ReturnsCorrectMessageType()
+    {
+        // Arrange
+        var parser = new ProtobufMessageParser();
+        var data = new byte[] { }; // Empty protobuf
+        
+        // Act
+        var messages = parser.ParseMessages(data, out var consumedBytes);
+        
+        // Assert - If parsing succeeds, should return correct types
+        if (messages.Any())
+        {
+            var message = messages.First();
+            Assert.IsType<ProtobufMessage>(message);
+            Assert.IsType<DaqifiOutMessage>(message.Data);
+        }
+        Assert.True(consumedBytes >= 0);
+    }
+}
\ No newline at end of file
diff --git a/src/Daqifi.Core.Tests/Integration/Desktop/BackwardCompatibilityTests.cs b/src/Daqifi.Core.Tests/Integration/Desktop/BackwardCompatibilityTests.cs
new file mode 100644
index 0000000..cec4342
--- /dev/null
+++ b/src/Daqifi.Core.Tests/Integration/Desktop/BackwardCompatibilityTests.cs
@@ -0,0 +1,300 @@
+using Daqifi.Core.Communication.Consumers;
+using Daqifi.Core.Communication.Messages;
+using Daqifi.Core.Communication.Transport;
+using Daqifi.Core.Integration.Desktop;
+using System.Text;
+
+namespace Daqifi.Core.Tests.Integration.Desktop;
+
+/// <summary>
+/// Tests to ensure backward compatibility with existing DAQiFi Desktop applications.
+/// These tests verify that existing desktop code patterns continue to work after the v0.4.0 changes.
+/// </summary>
+public class BackwardCompatibilityTests
+{
+    [Fact]
+    public void BackwardCompatibility_ExistingFactoryMethods_ShouldStillWork()
+    {
+        // Arrange & Act - These are the factory methods that existing desktop code uses
+        using var tcpAdapter = CoreDeviceAdapter.CreateTcpAdapter("192.168.1.100", 12345);
+        using var serialAdapter = CoreDeviceAdapter.CreateSerialAdapter("COM1", 115200);
+        
+        // Assert - All should work exactly as before
+        Assert.NotNull(tcpAdapter);
+        Assert.NotNull(serialAdapter);
+        Assert.IsType<TcpStreamTransport>(tcpAdapter.Transport);
+        Assert.IsType<SerialStreamTransport>(serialAdapter.Transport);
+    }
+
+    [Fact]
+    public void BackwardCompatibility_BasicProperties_ShouldBehaveSame()
+    {
+        // Arrange
+        using var adapter = CoreDeviceAdapter.CreateTcpAdapter("192.168.1.100", 12345);
+        
+        // Act & Assert - Properties that desktop code relies on
+        Assert.False(adapter.IsConnected);
+        Assert.Contains("192.168.1.100", adapter.ConnectionInfo);
+        Assert.Contains("12345", adapter.ConnectionInfo);
+        Assert.NotNull(adapter.Transport);
+        Assert.Null(adapter.MessageProducer); // Null until connected
+        Assert.Null(adapter.MessageConsumer); // Null until connected
+    }
+
+    [Fact]
+    public void BackwardCompatibility_WriteMethod_ShouldBehaveSame()
+    {
+        // Arrange
+        using var adapter = CoreDeviceAdapter.CreateTcpAdapter("192.168.1.100", 12345);
+        
+        // Act - Test all the SCPI commands that desktop applications typically send
+        var commands = new[]
+        {
+            "*IDN?",
+            "*RST",
+            "SYST:ERR?",
+            "CONF:VOLT:DC",
+            "READ?"
+        };
+        
+        // Assert - All should return true (queued successfully)
+        foreach (var command in commands)
+        {
+            var result = adapter.Write(command);
+            Assert.True(result);
+        }
+    }
+
+    [Fact]
+    public void BackwardCompatibility_EventSubscription_ShouldWorkWithNewType()
+    {
+        // Arrange
+        using var adapter = CoreDeviceAdapter.CreateTcpAdapter("192.168.1.100", 12345);
+        
+        var messageReceived = false;
+        var connectionStatusChanged = false;
+        var errorOccurred = false;
+        
+        // Act - Subscribe to events as existing desktop code does
+        adapter.MessageReceived += (sender, args) =>
+        {
+            messageReceived = true;
+            // Desktop code should be able to handle the new object type
+            var data = args.Message.Data;
+            if (data is string textMessage)
+            {
+                // Handle SCPI text responses as before
+            }
+            else if (data is DaqifiOutMessage protobufMessage)
+            {
+                // Handle new protobuf messages
+            }
+        };
+        
+        adapter.ConnectionStatusChanged += (sender, args) =>
+        {
+            connectionStatusChanged = true;
+            // Desktop code typically checks these properties
+            var isConnected = args.IsConnected;
+            var connectionInfo = args.ConnectionInfo;
+            var error = args.Error;
+        };
+        
+        adapter.ErrorOccurred += (sender, args) =>
+        {
+            errorOccurred = true;
+            // Desktop code typically logs these errors
+            var error = args.Error;
+            var rawData = args.RawData;
+        };
+        
+        // Assert - Event subscription should work without compilation errors
+        Assert.False(messageReceived); // Events won't fire without connection
+        Assert.False(connectionStatusChanged);
+        Assert.False(errorOccurred);
+    }
+
+    [Fact]
+    public void BackwardCompatibility_ConnectDisconnect_ShouldBehaveSame()
+    {
+        // Arrange
+        using var adapter = CoreDeviceAdapter.CreateTcpAdapter("localhost", 12345);
+        
+        // Act - Test both sync and async methods that desktop code uses
+        var connectResult = adapter.Connect(); // Sync version
+        var disconnectResult = adapter.Disconnect(); // Sync version
+        
+        // Also test async versions
+        var connectAsyncResult = adapter.ConnectAsync().GetAwaiter().GetResult();
+        var disconnectAsyncResult = adapter.DisconnectAsync().GetAwaiter().GetResult();
+        
+        // Assert - Behavior should be the same (will fail with test address, but methods work)
+        Assert.False(connectResult); // Expected to fail with invalid address
+        Assert.True(disconnectResult); // Should succeed
+        Assert.False(connectAsyncResult);
+        Assert.True(disconnectAsyncResult);
+    }
+
+    [Fact]
+    public void BackwardCompatibility_DisposalPattern_ShouldBehaveSame()
+    {
+        // Arrange & Act - Test disposal patterns that desktop code might use
+        var adapter = CoreDeviceAdapter.CreateTcpAdapter("localhost", 12345);
+        
+        // Using statement should work
+        using (adapter)
+        {
+            var isConnected = adapter.IsConnected;
+            Assert.False(isConnected);
+        }
+        
+        // Multiple disposal should be safe
+        adapter.Dispose();
+        adapter.Dispose(); // Should not throw
+    }
+
+    [Fact]
+    public void BackwardCompatibility_SerialPortEnumeration_ShouldStillWork()
+    {
+        // Act - Static method that desktop applications use for port discovery
+        var availablePorts = CoreDeviceAdapter.GetAvailableSerialPorts();
+        
+        // Assert - Should return array (might be empty on test systems)
+        Assert.NotNull(availablePorts);
+        Assert.IsType<string[]>(availablePorts);
+    }
+
+    [Fact]
+    public void BackwardCompatibility_ConstructorOverloads_ShouldMaintainCompatibility()
+    {
+        // Arrange
+        using var transport = new TcpStreamTransport("localhost", 12345);
+        
+        // Act - Original constructor should still work
+        using var adapter1 = new CoreDeviceAdapter(transport);
+        
+        // New constructor with parser should also work
+        using var adapter2 = new CoreDeviceAdapter(transport, null);
+        using var adapter3 = new CoreDeviceAdapter(transport, new CompositeMessageParser());
+        
+        // Assert - All constructors should work
+        Assert.NotNull(adapter1);
+        Assert.NotNull(adapter2);
+        Assert.NotNull(adapter3);
+        Assert.Same(transport, adapter1.Transport);
+        Assert.Same(transport, adapter2.Transport);
+        Assert.Same(transport, adapter3.Transport);
+    }
+
+    [Fact]
+    public void BackwardCompatibility_ExistingDesktopCodePattern_ShouldCompileAndRun()
+    {
+        // This test simulates the exact pattern used in existing desktop applications
+        
+        // Arrange - Typical desktop application usage
+        using var device = CoreDeviceAdapter.CreateTcpAdapter("192.168.1.100", 12345);
+        
+        // Subscribe to events (this is how desktop apps get device responses)
+        device.MessageReceived += (sender, args) =>
+        {
+            // Desktop apps typically cast or check the message data
+            var response = args.Message.Data?.ToString()?.Trim() ?? "";
+            
+            if (response.StartsWith("DAQiFi"))
+            {
+                // Handle device identification
+            }
+            else if (response.Contains("Error"))
+            {
+                // Handle error responses
+            }
+        };
+        
+        device.ConnectionStatusChanged += (sender, args) =>
+        {
+            if (args.IsConnected)
+            {
+                // Device connected - send identification command
+                device.Write("*IDN?");
+            }
+        };
+        
+        // Act - Typical connection sequence
+        var connected = device.Connect(); // This will fail with test IP, but pattern works
+        
+        if (connected)
+        {
+            device.Write("*IDN?");
+            device.Write("SYST:ERR?");
+            
+            // Wait for responses (in real app)
+            Thread.Sleep(100);
+            
+            device.Disconnect();
+        }
+        
+        // Assert - Code pattern should work without exceptions
+        Assert.False(connected); // Expected with test IP
+    }
+
+    [Fact]
+    public void BackwardCompatibility_MessageHandling_ShouldSupportBothTypes()
+    {
+        // Arrange - Test that desktop apps can handle both old and new message types
+        using var adapter = CoreDeviceAdapter.CreateTcpAdapter("localhost", 12345);
+        
+        var handledTextMessages = 0;
+        var handledProtobufMessages = 0;
+        var handledUnknownMessages = 0;
+        
+        adapter.MessageReceived += (sender, args) =>
+        {
+            var messageData = args.Message.Data;
+            
+            // Pattern that desktop applications should use for compatibility
+            switch (messageData)
+            {
+                case string textMessage:
+                    handledTextMessages++;
+                    // Handle SCPI text responses as before
+                    break;
+                    
+                case DaqifiOutMessage protobufMessage:
+                    handledProtobufMessages++;
+                    // Handle new binary protobuf messages
+                    break;
+                    
+                default:
+                    handledUnknownMessages++;
+                    // Handle any other message types gracefully
+                    break;
+            }
+        };
+        
+        // Assert - Event handler setup should work
+        Assert.Equal(0, handledTextMessages);
+        Assert.Equal(0, handledProtobufMessages);
+        Assert.Equal(0, handledUnknownMessages);
+    }
+
+    [Fact]
+    public void BackwardCompatibility_PerformanceCharacteristics_ShouldBeComparable()
+    {
+        // Arrange - Test that performance hasn't degraded significantly
+        using var adapter = CoreDeviceAdapter.CreateTcpAdapter("localhost", 12345);
+        
+        // Act - Time basic operations
+        var startTime = DateTime.UtcNow;
+        
+        for (int i = 0; i < 1000; i++)
+        {
+            adapter.Write($"Command {i}");
+        }
+        
+        var endTime = DateTime.UtcNow;
+        var elapsed = endTime - startTime;
+        
+        // Assert - Should complete quickly (basic sanity check)
+        Assert.True(elapsed.TotalMilliseconds < 1000); // Should be very fast for 1000 commands
+    }
+}
\ No newline at end of file
diff --git a/src/Daqifi.Core.Tests/Integration/Desktop/CoreDeviceAdapterTests.cs b/src/Daqifi.Core.Tests/Integration/Desktop/CoreDeviceAdapterTests.cs
index 7ff89f3..9b4155c 100644
--- a/src/Daqifi.Core.Tests/Integration/Desktop/CoreDeviceAdapterTests.cs
+++ b/src/Daqifi.Core.Tests/Integration/Desktop/CoreDeviceAdapterTests.cs
@@ -192,7 +192,7 @@ public void CoreDeviceAdapter_MessageReceived_ShouldProvideEventAccess()
         var eventHandlerAdded = false;
         
         // Act - Just verify we can add/remove event handlers without exceptions
-        EventHandler<MessageReceivedEventArgs<string>> handler = (sender, args) => { };
+        EventHandler<MessageReceivedEventArgs<object>> handler = (sender, args) => { };
         adapter.MessageReceived += handler;
         eventHandlerAdded = true;
         adapter.MessageReceived -= handler;
@@ -294,4 +294,146 @@ public void CoreDeviceAdapter_IntegrationUsagePattern_ShouldWorkAsExpected()
         Assert.NotEmpty(connectionInfo);
         Assert.False(isConnected);
     }
+
+    [Fact]
+    public void CoreDeviceAdapter_WithCustomMessageParser_ShouldUseProvidedParser()
+    {
+        // Arrange
+        using var transport = new TcpStreamTransport("localhost", 12345);
+        var customParser = new CompositeMessageParser();
+        
+        // Act
+        using var adapter = new CoreDeviceAdapter(transport, customParser);
+        
+        // Assert
+        Assert.NotNull(adapter);
+        Assert.Same(transport, adapter.Transport);
+    }
+
+    [Fact]
+    public void CoreDeviceAdapter_WithNullMessageParser_ShouldUseDefaultCompositeParser()
+    {
+        // Arrange
+        using var transport = new TcpStreamTransport("localhost", 12345);
+        
+        // Act
+        using var adapter = new CoreDeviceAdapter(transport, null);
+        
+        // Assert
+        Assert.NotNull(adapter);
+        Assert.Same(transport, adapter.Transport);
+    }
+
+    [Fact]
+    public void CoreDeviceAdapter_CreateTextOnlyTcpAdapter_ShouldCreateCorrectly()
+    {
+        // Act
+        using var adapter = CoreDeviceAdapter.CreateTextOnlyTcpAdapter("192.168.1.100", 12345);
+        
+        // Assert
+        Assert.NotNull(adapter);
+        Assert.IsType<TcpStreamTransport>(adapter.Transport);
+        Assert.Contains("192.168.1.100", adapter.ConnectionInfo);
+        Assert.Contains("12345", adapter.ConnectionInfo);
+        Assert.False(adapter.IsConnected);
+    }
+
+    [Fact]
+    public void CoreDeviceAdapter_CreateProtobufOnlyTcpAdapter_ShouldCreateCorrectly()
+    {
+        // Act
+        using var adapter = CoreDeviceAdapter.CreateProtobufOnlyTcpAdapter("192.168.1.100", 12345);
+        
+        // Assert
+        Assert.NotNull(adapter);
+        Assert.IsType<TcpStreamTransport>(adapter.Transport);
+        Assert.Contains("192.168.1.100", adapter.ConnectionInfo);
+        Assert.Contains("12345", adapter.ConnectionInfo);
+        Assert.False(adapter.IsConnected);
+    }
+
+    [Fact]
+    public void CoreDeviceAdapter_CreateTcpAdapterWithCustomParser_ShouldCreateCorrectly()
+    {
+        // Arrange
+        var customParser = new CompositeMessageParser(new LineBasedMessageParser("\n"), null);
+        
+        // Act
+        using var adapter = CoreDeviceAdapter.CreateTcpAdapter("192.168.1.100", 12345, customParser);
+        
+        // Assert
+        Assert.NotNull(adapter);
+        Assert.IsType<TcpStreamTransport>(adapter.Transport);
+        Assert.Contains("192.168.1.100", adapter.ConnectionInfo);
+    }
+
+    [Fact]
+    public void CoreDeviceAdapter_CreateSerialAdapterWithCustomParser_ShouldCreateCorrectly()
+    {
+        // Arrange
+        var customParser = new CompositeMessageParser();
+        
+        // Act
+        using var adapter = CoreDeviceAdapter.CreateSerialAdapter("COM1", 115200, customParser);
+        
+        // Assert
+        Assert.NotNull(adapter);
+        Assert.IsType<SerialStreamTransport>(adapter.Transport);
+        Assert.Contains("COM1", adapter.ConnectionInfo);
+        // Note: ConnectionInfo format may vary, just check that it's not empty
+        Assert.NotEmpty(adapter.ConnectionInfo);
+    }
+
+    [Fact]
+    public void CoreDeviceAdapter_MessageConsumerType_ShouldHandleObjectMessages()
+    {
+        // Arrange
+        using var adapter = CoreDeviceAdapter.CreateTcpAdapter("localhost", 12345);
+        
+        // Act & Assert - Verify the MessageConsumer can handle object messages
+        Assert.True(adapter.MessageConsumer == null); // Not connected yet
+        
+        // Verify event handler can be assigned with object type
+        EventHandler<MessageReceivedEventArgs<object>> handler = (sender, args) => 
+        {
+            // Should be able to handle both string and protobuf messages
+            if (args.Message.Data is string textMsg)
+            {
+                // Handle text message
+            }
+            else if (args.Message.Data is DaqifiOutMessage protobufMsg)
+            {
+                // Handle protobuf message
+            }
+        };
+        
+        adapter.MessageReceived += handler;
+        adapter.MessageReceived -= handler;
+    }
+
+    [Fact]
+    public void CoreDeviceAdapter_BackwardCompatibility_ShouldStillSupportBasicOperations()
+    {
+        // Arrange - Test that existing desktop code patterns still work
+        using var adapter = CoreDeviceAdapter.CreateTcpAdapter("192.168.1.100", 12345);
+        
+        // Act & Assert - Basic operations that desktop code relies on
+        Assert.False(adapter.IsConnected);
+        Assert.NotEmpty(adapter.ConnectionInfo);
+        Assert.NotNull(adapter.Transport);
+        
+        // Event subscription should work
+        var messageReceived = false;
+        adapter.MessageReceived += (sender, args) => messageReceived = true;
+        
+        var statusChanged = false;
+        adapter.ConnectionStatusChanged += (sender, args) => statusChanged = true;
+        
+        var errorOccurred = false;
+        adapter.ErrorOccurred += (sender, args) => errorOccurred = true;
+        
+        // Write method should work even when not connected
+        var writeResult = adapter.Write("*IDN?");
+        Assert.True(writeResult); // Should return true for queuing
+    }
 }
\ No newline at end of file
diff --git a/src/Daqifi.Core.Tests/Integration/Desktop/MessageTypeDetectionTests.cs b/src/Daqifi.Core.Tests/Integration/Desktop/MessageTypeDetectionTests.cs
new file mode 100644
index 0000000..88cfc8f
--- /dev/null
+++ b/src/Daqifi.Core.Tests/Integration/Desktop/MessageTypeDetectionTests.cs
@@ -0,0 +1,221 @@
+using Daqifi.Core.Communication.Consumers;
+using Daqifi.Core.Communication.Messages;
+using Daqifi.Core.Communication.Transport;
+using Daqifi.Core.Integration.Desktop;
+using System.Text;
+
+namespace Daqifi.Core.Tests.Integration.Desktop;
+
+/// <summary>
+/// Tests that verify message type detection and routing works correctly for DAQiFi Desktop integration.
+/// These tests simulate the exact scenarios that caused issue #35.
+/// </summary>
+public class MessageTypeDetectionTests
+{
+    [Fact]
+    public void MessageTypeDetection_ScpiCommandResponse_ShouldBeDetectedAsText()
+    {
+        // Arrange - Simulate typical SCPI command/response pattern
+        var parser = new CompositeMessageParser();
+        var scpiResponse = Encoding.UTF8.GetBytes("DAQiFi Device v1.0.2\r\n");
+        
+        // Act
+        var messages = parser.ParseMessages(scpiResponse, out var consumedBytes);
+        
+        // Assert
+        Assert.Single(messages);
+        Assert.IsType<string>(messages.First().Data);
+        Assert.Equal("DAQiFi Device v1.0.2", messages.First().Data);
+        Assert.Equal(scpiResponse.Length, consumedBytes);
+    }
+
+    [Fact]
+    public void MessageTypeDetection_MultipleScpiResponses_ShouldAllBeDetectedAsText()
+    {
+        // Arrange - Multiple SCPI responses in one buffer
+        var parser = new CompositeMessageParser();
+        var multipleResponses = Encoding.UTF8.GetBytes("*IDN?\r\nDAQiFi Device v1.0.2\r\nSYST:ERR?\r\n0,\"No error\"\r\n");
+        
+        // Act
+        var messages = parser.ParseMessages(multipleResponses, out var consumedBytes);
+        
+        // Assert
+        Assert.Equal(4, messages.Count());
+        Assert.All(messages, msg => Assert.IsType<string>(msg.Data));
+        Assert.Equal("*IDN?", messages.ElementAt(0).Data);
+        Assert.Equal("DAQiFi Device v1.0.2", messages.ElementAt(1).Data);
+        Assert.Equal("SYST:ERR?", messages.ElementAt(2).Data);
+        Assert.Equal("0,\"No error\"", messages.ElementAt(3).Data);
+    }
+
+    [Fact]
+    public void MessageTypeDetection_ProtobufMessage_ShouldBeDetectedAsBinary()
+    {
+        // Arrange - Create mock binary protobuf data
+        var parser = new CompositeMessageParser();
+        var protobufData = new byte[] { 0x08, 0x01, 0x12, 0x04 }; // Mock protobuf
+        
+        // Act
+        var messages = parser.ParseMessages(protobufData, out var consumedBytes);
+        
+        // Assert - Should attempt protobuf parsing (may succeed or fail)
+        Assert.True(consumedBytes >= 0);
+    }
+
+    [Fact]
+    public void MessageTypeDetection_DataWithNullBytes_ShouldTriggerProtobufParsing()
+    {
+        // Arrange - This simulates the exact issue from #35 where null bytes caused problems
+        var parser = new CompositeMessageParser();
+        var dataWithNulls = new byte[] 
+        { 
+            0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x00, // "Hello" + null byte
+            0x57, 0x6F, 0x72, 0x6C, 0x64, 0x00  // "World" + null byte
+        };
+        
+        // Act
+        var messages = parser.ParseMessages(dataWithNulls, out var consumedBytes);
+        
+        // Assert - Should attempt protobuf parsing first due to null bytes
+        // Even if parsing fails, it should not throw exceptions
+        Assert.True(consumedBytes >= 0);
+    }
+
+    [Fact]
+    public void MessageTypeDetection_CoreDeviceAdapter_ShouldHandleBothMessageTypes()
+    {
+        // Arrange - Test the complete CoreDeviceAdapter integration
+        using var adapter = CoreDeviceAdapter.CreateTcpAdapter("localhost", 12345);
+        
+        var receivedTextMessages = new List<string>();
+        var receivedProtobufMessages = new List<DaqifiOutMessage>();
+        
+        adapter.MessageReceived += (sender, args) =>
+        {
+            if (args.Message.Data is string textMsg)
+            {
+                receivedTextMessages.Add(textMsg);
+            }
+            else if (args.Message.Data is DaqifiOutMessage protobufMsg)
+            {
+                receivedProtobufMessages.Add(protobufMsg);
+            }
+        };
+        
+        // Act & Assert - Event handler setup should work without exceptions
+        Assert.Empty(receivedTextMessages);
+        Assert.Empty(receivedProtobufMessages);
+        
+        // Verify the adapter works correctly (MessageConsumer will be null until connected)
+        Assert.Null(adapter.MessageConsumer); // Should be null until connected
+    }
+
+    [Fact]
+    public void MessageTypeDetection_DaqifiDesktopScenario_ShouldWorkEndToEnd()
+    {
+        // Arrange - Simulate the exact scenario from DAQiFi Desktop
+        // 1. Initial SCPI communication for device identification
+        // 2. Switch to protobuf for data streaming
+        
+        var textOnlyAdapter = CoreDeviceAdapter.CreateTextOnlyTcpAdapter("localhost", 12345);
+        var protobufOnlyAdapter = CoreDeviceAdapter.CreateProtobufOnlyTcpAdapter("localhost", 12345);
+        var compositeAdapter = CoreDeviceAdapter.CreateTcpAdapter("localhost", 12345); // Default composite
+        
+        // Act & Assert - All adapters should create successfully
+        Assert.NotNull(textOnlyAdapter);
+        Assert.NotNull(protobufOnlyAdapter);
+        Assert.NotNull(compositeAdapter);
+        
+        // Verify they all have the expected transport type
+        Assert.All(new[] { textOnlyAdapter, protobufOnlyAdapter, compositeAdapter }, 
+            adapter => Assert.IsType<TcpStreamTransport>(adapter.Transport));
+        
+        // Clean up
+        textOnlyAdapter.Dispose();
+        protobufOnlyAdapter.Dispose();
+        compositeAdapter.Dispose();
+    }
+
+    [Fact]
+    public void MessageTypeDetection_PerformanceWithLargeMessages_ShouldBeReasonable()
+    {
+        // Arrange - Test performance with larger messages that might occur in streaming
+        var parser = new CompositeMessageParser();
+        var largeTextMessage = new string('A', 1000) + "\r\n";
+        var largeTextData = Encoding.UTF8.GetBytes(largeTextMessage);
+        
+        // Act - Measure basic performance (not exact timing, just ensure it completes)
+        var startTime = DateTime.UtcNow;
+        var messages = parser.ParseMessages(largeTextData, out var consumedBytes);
+        var endTime = DateTime.UtcNow;
+        
+        // Assert - Should complete quickly and correctly
+        Assert.Single(messages);
+        Assert.IsType<string>(messages.First().Data);
+        Assert.True((endTime - startTime).TotalMilliseconds < 100); // Should be very fast
+        Assert.Equal(largeTextData.Length, consumedBytes);
+    }
+
+    [Fact]
+    public void MessageTypeDetection_EdgeCases_ShouldHandleGracefully()
+    {
+        // Arrange - Test various edge cases that might occur in real usage
+        var parser = new CompositeMessageParser();
+        
+        var edgeCases = new[]
+        {
+            new byte[0],                           // Empty data
+            new byte[] { 0x00 },                   // Single null byte
+            new byte[] { 0xFF },                   // Single non-null byte
+            Encoding.UTF8.GetBytes("\r\n"),       // Just line ending
+            Encoding.UTF8.GetBytes("\r"),         // Incomplete line ending
+            Encoding.UTF8.GetBytes("\n"),         // Alternative line ending
+            new byte[] { 0x00, 0x00, 0x00, 0x00 }, // Multiple nulls
+            Encoding.UTF8.GetBytes("No line ending"), // Text without terminator
+        };
+        
+        // Act & Assert - None should throw exceptions
+        foreach (var edgeCase in edgeCases)
+        {
+            var exception = Record.Exception(() =>
+            {
+                var messages = parser.ParseMessages(edgeCase, out var consumed);
+                Assert.True(consumed >= 0);
+            });
+            
+            Assert.Null(exception);
+        }
+    }
+
+    [Fact]
+    public void MessageTypeDetection_Issue35ReproductionTest_ShouldBeFixed()
+    {
+        // Arrange - Reproduce the exact conditions from issue #35
+        // "MessageReceived events never fire" for protobuf responses
+        
+        using var adapter = CoreDeviceAdapter.CreateTcpAdapter("localhost", 12345);
+        var messageReceivedEventFired = false;
+        var receivedMessageData = new List<object>();
+        
+        adapter.MessageReceived += (sender, args) =>
+        {
+            messageReceivedEventFired = true;
+            receivedMessageData.Add(args.Message.Data);
+        };
+        
+        // Act - Simulate the scenario where protobuf messages would be received
+        // Test that the composite parser can handle binary data with null bytes
+        var compositeParser = new CompositeMessageParser();
+        var mockProtobufData = new byte[] { 0x00, 0x08, 0x01, 0x12, 0x04, 0x00 }; // Mock with nulls
+        var parsedMessages = compositeParser.ParseMessages(mockProtobufData, out var consumed);
+        
+        // Assert - The fix should allow protobuf messages to be parsed
+        // Even if the specific protobuf parsing fails, it should not cause the
+        // "never fire" condition that was reported in the issue
+        Assert.True(consumed >= 0); // Parser should consume some bytes or none, not fail
+        
+        // The key fix is that the adapter now uses CompositeMessageParser by default
+        // instead of LineBasedMessageParser, so it can handle both text and binary
+        Assert.NotNull(adapter); // Adapter creation should succeed
+    }
+}
\ No newline at end of file
diff --git a/src/Daqifi.Core/Communication/Consumers/CompositeMessageParser.cs b/src/Daqifi.Core/Communication/Consumers/CompositeMessageParser.cs
new file mode 100644
index 0000000..ea8909b
--- /dev/null
+++ b/src/Daqifi.Core/Communication/Consumers/CompositeMessageParser.cs
@@ -0,0 +1,219 @@
+using Daqifi.Core.Communication.Messages;
+
+namespace Daqifi.Core.Communication.Consumers;
+
+/// <summary>
+/// A composite message parser that attempts to parse messages using multiple parsers.
+/// This allows handling different message formats (text-based SCPI and binary protobuf) in the same stream.
+/// </summary>
+public class CompositeMessageParser : IMessageParser<object>
+{
+    private readonly IMessageParser<string> _textParser;
+    private readonly IMessageParser<DaqifiOutMessage> _protobufParser;
+
+    /// <summary>
+    /// Initializes a new instance of the CompositeMessageParser class.
+    /// </summary>
+    /// <param name="textParser">Parser for text-based messages (e.g., SCPI responses).</param>
+    /// <param name="protobufParser">Parser for binary protobuf messages.</param>
+    public CompositeMessageParser(
+        IMessageParser<string>? textParser = null, 
+        IMessageParser<DaqifiOutMessage>? protobufParser = null)
+    {
+        _textParser = textParser ?? new LineBasedMessageParser();
+        _protobufParser = protobufParser ?? new ProtobufMessageParser();
+    }
+
+    /// <summary>
+    /// Parses raw data by intelligently trying both text and protobuf parsers.
+    /// Uses heuristics beyond simple null byte detection to determine message type.
+    /// </summary>
+    /// <param name="data">The raw data to parse.</param>
+    /// <param name="consumedBytes">The number of bytes consumed from the data during parsing.</param>
+    /// <returns>A collection of parsed messages of various types.</returns>
+    public IEnumerable<IInboundMessage<object>> ParseMessages(byte[] data, out int consumedBytes)
+    {
+        var messages = new List<IInboundMessage<object>>();
+        consumedBytes = 0;
+
+        if (data.Length == 0)
+            return messages;
+
+        // Use improved heuristics to detect message type
+        var messageTypeHint = DetectMessageType(data);
+
+        if (messageTypeHint == MessageTypeHint.LikelyProtobuf)
+        {
+            // Try protobuf parser first
+            var protobufMessages = _protobufParser.ParseMessages(data, out int protobufConsumed);
+            if (protobufMessages.Any())
+            {
+                foreach (var msg in protobufMessages)
+                {
+                    messages.Add(new ObjectInboundMessage(msg.Data));
+                }
+                consumedBytes = protobufConsumed;
+                return messages;
+            }
+        }
+
+        if (messageTypeHint == MessageTypeHint.LikelyText)
+        {
+            // Try text parser first
+            var textMessages = _textParser.ParseMessages(data, out int textConsumed);
+            if (textMessages.Any())
+            {
+                foreach (var msg in textMessages)
+                {
+                    messages.Add(new ObjectInboundMessage(msg.Data));
+                }
+                consumedBytes = textConsumed;
+                return messages;
+            }
+        }
+
+        // If heuristics are uncertain or first attempt failed, try the other parser
+        if (messageTypeHint != MessageTypeHint.LikelyText)
+        {
+            var textMessages = _textParser.ParseMessages(data, out int textConsumed);
+            if (textMessages.Any())
+            {
+                foreach (var msg in textMessages)
+                {
+                    messages.Add(new ObjectInboundMessage(msg.Data));
+                }
+                consumedBytes = textConsumed;
+                return messages;
+            }
+        }
+
+        if (messageTypeHint != MessageTypeHint.LikelyProtobuf)
+        {
+            var protobufMessages = _protobufParser.ParseMessages(data, out int protobufConsumed);
+            if (protobufMessages.Any())
+            {
+                foreach (var msg in protobufMessages)
+                {
+                    messages.Add(new ObjectInboundMessage(msg.Data));
+                }
+                consumedBytes = protobufConsumed;
+            }
+        }
+
+        return messages;
+    }
+
+    /// <summary>
+    /// Message type hints for improved detection.
+    /// </summary>
+    private enum MessageTypeHint
+    {
+        Uncertain,
+        LikelyText,
+        LikelyProtobuf
+    }
+
+    /// <summary>
+    /// Uses multiple heuristics to detect the likely message type.
+    /// Goes beyond simple null byte detection to avoid false positives.
+    /// </summary>
+    /// <param name="data">The data to analyze.</param>
+    /// <returns>A hint about the likely message type.</returns>
+    private static MessageTypeHint DetectMessageType(byte[] data)
+    {
+        if (data.Length == 0)
+            return MessageTypeHint.Uncertain;
+
+        // Heuristic 1: Check for printable ASCII (common in SCPI) - prioritize this
+        var printableRatio = data.Count(b => b >= 32 && b <= 126) / (double)data.Length;
+        if (printableRatio > 0.8) // More than 80% printable ASCII
+        {
+            return MessageTypeHint.LikelyText;
+        }
+
+        // Heuristic 2: Check for common text patterns (SCPI commands)
+        if (data.Length > 3 && IsLikelyTextCommand(data))
+        {
+            return MessageTypeHint.LikelyText;
+        }
+
+        // Heuristic 3: High ratio of null bytes suggests binary
+        var nullByteRatio = data.Count(b => b == 0) / (double)data.Length;
+        if (nullByteRatio > 0.1) // More than 10% null bytes
+        {
+            return MessageTypeHint.LikelyProtobuf;
+        }
+
+        // Heuristic 4: Check for protobuf-like patterns (be more conservative)
+        if (nullByteRatio > 0.05 && IsLikelyProtobufData(data)) // Only if some null bytes present
+        {
+            return MessageTypeHint.LikelyProtobuf;
+        }
+
+        return MessageTypeHint.Uncertain;
+    }
+
+    /// <summary>
+    /// Checks if the data looks like a text command (SCPI-style).
+    /// </summary>
+    /// <param name="data">The data to check.</param>
+    /// <returns>True if it looks like a text command.</returns>
+    private static bool IsLikelyTextCommand(byte[] data)
+    {
+        // Check for common SCPI patterns
+        var text = System.Text.Encoding.ASCII.GetString(data, 0, Math.Min(data.Length, 10));
+        var fullText = System.Text.Encoding.ASCII.GetString(data);
+        
+        return text.StartsWith("*") || text.StartsWith("SYST") || text.StartsWith("CONF") || 
+               text.StartsWith("READ", StringComparison.OrdinalIgnoreCase) ||
+               fullText.EndsWith("\r\n") || fullText.EndsWith("\n");
+    }
+
+    /// <summary>
+    /// Checks if the data has protobuf-like characteristics.
+    /// </summary>
+    /// <param name="data">The data to check.</param>
+    /// <returns>True if it looks like protobuf data.</returns>
+    private static bool IsLikelyProtobufData(byte[] data)
+    {
+        if (data.Length < 2)
+            return false;
+
+        // Protobuf messages often start with field tags (varint encoded)
+        // Check for patterns that suggest protobuf field encoding
+        for (int i = 0; i < Math.Min(data.Length - 1, 5); i++)
+        {
+            var byte1 = data[i];
+            var byte2 = data[i + 1];
+            
+            // Look for varint patterns (field number + wire type)
+            if ((byte1 & 0x07) <= 5 && // Valid wire type (0-5)
+                (byte1 >> 3) > 0)      // Non-zero field number
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
+
+/// <summary>
+/// Simple implementation of IInboundMessage for generic object data.
+/// </summary>
+public class ObjectInboundMessage : IInboundMessage<object>
+{
+    /// <summary>
+    /// Initializes a new instance of the ObjectInboundMessage class.
+    /// </summary>
+    /// <param name="data">The object data of the message.</param>
+    public ObjectInboundMessage(object data)
+    {
+        Data = data;
+    }
+
+    /// <summary>
+    /// Gets the object data of the message.
+    /// </summary>
+    public object Data { get; }
+}
\ No newline at end of file
diff --git a/src/Daqifi.Core/Communication/Consumers/ProtobufMessageParser.cs b/src/Daqifi.Core/Communication/Consumers/ProtobufMessageParser.cs
new file mode 100644
index 0000000..dccaefa
--- /dev/null
+++ b/src/Daqifi.Core/Communication/Consumers/ProtobufMessageParser.cs
@@ -0,0 +1,80 @@
+using Daqifi.Core.Communication.Messages;
+using Google.Protobuf;
+
+namespace Daqifi.Core.Communication.Consumers;
+
+/// <summary>
+/// Message parser for binary protobuf messages.
+/// Uses CodedInputStream to properly track consumed bytes and handle variable-length messages.
+/// </summary>
+public class ProtobufMessageParser : IMessageParser<DaqifiOutMessage>
+{
+    private const int MaxRetryAttempts = 3;
+    
+    /// <summary>
+    /// Parses raw data into protobuf messages.
+    /// </summary>
+    /// <param name="data">The raw data to parse.</param>
+    /// <param name="consumedBytes">The number of bytes consumed from the data during parsing.</param>
+    /// <returns>A collection of parsed protobuf messages.</returns>
+    public IEnumerable<IInboundMessage<DaqifiOutMessage>> ParseMessages(byte[] data, out int consumedBytes)
+    {
+        var messages = new List<IInboundMessage<DaqifiOutMessage>>();
+        consumedBytes = 0;
+
+        if (data.Length == 0)
+            return messages;
+
+        var currentIndex = 0;
+        var retryCount = 0;
+        
+        while (currentIndex < data.Length && retryCount < MaxRetryAttempts)
+        {
+            try
+            {
+                // Use CodedInputStream for proper byte tracking
+                var remainingData = new ReadOnlySpan<byte>(data, currentIndex, data.Length - currentIndex);
+                var codedInput = new CodedInputStream(remainingData.ToArray());
+                
+                // Record the position before parsing
+                var startPosition = codedInput.Position;
+                
+                // Try to parse a protobuf message
+                var message = DaqifiOutMessage.Parser.ParseFrom(codedInput);
+                
+                // Calculate actual bytes consumed by the parser
+                var bytesConsumed = codedInput.Position - startPosition;
+                
+                if (bytesConsumed > 0)
+                {
+                    currentIndex += (int)bytesConsumed;
+                    consumedBytes = currentIndex;
+                    messages.Add(new ProtobufMessage(message));
+                    retryCount = 0; // Reset retry count on successful parse
+                }
+                else
+                {
+                    // If no bytes were consumed, we might be stuck - advance by 1
+                    currentIndex++;
+                    consumedBytes = currentIndex;
+                    retryCount++;
+                }
+            }
+            catch (InvalidProtocolBufferException)
+            {
+                // If we can't parse a complete message, stop parsing
+                // This is expected when we don't have a complete message
+                break;
+            }
+            catch (Exception)
+            {
+                // For other exceptions, advance by one byte and retry
+                currentIndex++;
+                consumedBytes = currentIndex;
+                retryCount++;
+            }
+        }
+
+        return messages;
+    }
+}
\ No newline at end of file
diff --git a/src/Daqifi.Core/Integration/Desktop/CoreDeviceAdapter.cs b/src/Daqifi.Core/Integration/Desktop/CoreDeviceAdapter.cs
index 784ddb3..483ea2e 100644
--- a/src/Daqifi.Core/Integration/Desktop/CoreDeviceAdapter.cs
+++ b/src/Daqifi.Core/Integration/Desktop/CoreDeviceAdapter.cs
@@ -14,17 +14,20 @@ namespace Daqifi.Core.Integration.Desktop;
 public class CoreDeviceAdapter : IDisposable
 {
     private readonly IStreamTransport _transport;
+    private readonly IMessageParser<object>? _messageParser;
     private IMessageProducer<string>? _messageProducer;
-    private IMessageConsumer<string>? _messageConsumer;
+    private IMessageConsumer<object>? _messageConsumer;
     private bool _disposed;
 
     /// <summary>
     /// Initializes a new CoreDeviceAdapter with the specified transport.
     /// </summary>
     /// <param name="transport">The transport to use for device communication.</param>
-    public CoreDeviceAdapter(IStreamTransport transport)
+    /// <param name="messageParser">Optional message parser. If not provided, uses CompositeMessageParser for both text and protobuf messages.</param>
+    public CoreDeviceAdapter(IStreamTransport transport, IMessageParser<object>? messageParser = null)
     {
         _transport = transport ?? throw new ArgumentNullException(nameof(transport));
+        _messageParser = messageParser ?? new CompositeMessageParser();
     }
 
     /// <summary>
@@ -43,7 +46,7 @@ public CoreDeviceAdapter(IStreamTransport transport)
     /// Gets the message consumer for receiving responses from the device.
     /// Desktop applications can subscribe to MessageReceived events.
     /// </summary>
-    public IMessageConsumer<string>? MessageConsumer => _messageConsumer;
+    public IMessageConsumer<object>? MessageConsumer => _messageConsumer;
 
     /// <summary>
     /// Gets the connection status from the underlying transport.
@@ -68,7 +71,7 @@ public async Task<bool> ConnectAsync()
             {
                 // Create message producer and consumer after connection is established
                 _messageProducer = new MessageProducer<string>(_transport.Stream);
-                _messageConsumer = new StreamMessageConsumer<string>(_transport.Stream, new LineBasedMessageParser());
+                _messageConsumer = new StreamMessageConsumer<object>(_transport.Stream, _messageParser!);
                 
                 _messageProducer.Start();
                 _messageConsumer.Start();
@@ -161,11 +164,12 @@ public bool Write(string command)
     /// </summary>
     /// <param name="host">The hostname or IP address.</param>
     /// <param name="port">The port number.</param>
+    /// <param name="messageParser">Optional message parser. If not provided, uses CompositeMessageParser for both text and protobuf messages.</param>
     /// <returns>A new CoreDeviceAdapter configured for TCP communication.</returns>
-    public static CoreDeviceAdapter CreateTcpAdapter(string host, int port)
+    public static CoreDeviceAdapter CreateTcpAdapter(string host, int port, IMessageParser<object>? messageParser = null)
     {
         var transport = new TcpStreamTransport(host, port);
-        return new CoreDeviceAdapter(transport);
+        return new CoreDeviceAdapter(transport, messageParser);
     }
 
     /// <summary>
@@ -174,11 +178,12 @@ public static CoreDeviceAdapter CreateTcpAdapter(string host, int port)
     /// </summary>
     /// <param name="portName">The serial port name (e.g., "COM3", "/dev/ttyUSB0").</param>
     /// <param name="baudRate">The baud rate (default: 115200).</param>
+    /// <param name="messageParser">Optional message parser. If not provided, uses CompositeMessageParser for both text and protobuf messages.</param>
     /// <returns>A new CoreDeviceAdapter configured for Serial communication.</returns>
-    public static CoreDeviceAdapter CreateSerialAdapter(string portName, int baudRate = 115200)
+    public static CoreDeviceAdapter CreateSerialAdapter(string portName, int baudRate = 115200, IMessageParser<object>? messageParser = null)
     {
         var transport = new SerialStreamTransport(portName, baudRate);
-        return new CoreDeviceAdapter(transport);
+        return new CoreDeviceAdapter(transport, messageParser);
     }
 
     /// <summary>
@@ -191,6 +196,32 @@ public static string[] GetAvailableSerialPorts()
         return SerialStreamTransport.GetAvailablePortNames();
     }
 
+    /// <summary>
+    /// Creates a TCP adapter configured specifically for text-based SCPI communication.
+    /// </summary>
+    /// <param name="host">The hostname or IP address.</param>
+    /// <param name="port">The port number.</param>
+    /// <returns>A new CoreDeviceAdapter configured for text-only communication.</returns>
+    public static CoreDeviceAdapter CreateTextOnlyTcpAdapter(string host, int port)
+    {
+        var transport = new TcpStreamTransport(host, port);
+        var textParser = new CompositeMessageParser(new LineBasedMessageParser(), null);
+        return new CoreDeviceAdapter(transport, textParser);
+    }
+
+    /// <summary>
+    /// Creates a TCP adapter configured specifically for binary protobuf communication.
+    /// </summary>
+    /// <param name="host">The hostname or IP address.</param>
+    /// <param name="port">The port number.</param>
+    /// <returns>A new CoreDeviceAdapter configured for protobuf-only communication.</returns>
+    public static CoreDeviceAdapter CreateProtobufOnlyTcpAdapter(string host, int port)
+    {
+        var transport = new TcpStreamTransport(host, port);
+        var protobufParser = new CompositeMessageParser(null, new ProtobufMessageParser());
+        return new CoreDeviceAdapter(transport, protobufParser);
+    }
+
     /// <summary>
     /// Provides access to the underlying data stream for compatibility with existing desktop code.
     /// Some desktop components may need direct stream access during migration.
@@ -211,7 +242,7 @@ public event EventHandler<TransportStatusEventArgs>? ConnectionStatusChanged
     /// Event that fires when a message is received from the device.
     /// Desktop applications can subscribe to this instead of creating their own consumers.
     /// </summary>
-    public event EventHandler<MessageReceivedEventArgs<string>>? MessageReceived
+    public event EventHandler<MessageReceivedEventArgs<object>>? MessageReceived
     {
         add 
         { 
diff --git a/src/Daqifi.Core/Integration/Desktop/Examples/DesktopIntegrationExample.cs b/src/Daqifi.Core/Integration/Desktop/Examples/DesktopIntegrationExample.cs
index d6d7fcb..f7331dc 100644
--- a/src/Daqifi.Core/Integration/Desktop/Examples/DesktopIntegrationExample.cs
+++ b/src/Daqifi.Core/Integration/Desktop/Examples/DesktopIntegrationExample.cs
@@ -23,7 +23,7 @@ public static async Task<bool> ConnectToWiFiDeviceExample()
         
         // Subscribe to events before connecting
         device.MessageReceived += (sender, args) => {
-            var response = args.Message.Data.Trim();
+            var response = args.Message.Data?.ToString()?.Trim() ?? "";
             Console.WriteLine($"Device: {response}");
             
             // Handle specific responses as your existing code does
@@ -78,7 +78,7 @@ public static async Task<bool> ConnectToUsbDeviceExample()
         using var device = CoreDeviceAdapter.CreateSerialAdapter(availablePorts[0], 115200);
         
         device.MessageReceived += (sender, args) => {
-            var response = args.Message.Data.Trim();
+            var response = args.Message.Data?.ToString()?.Trim() ?? "";
             Console.WriteLine($"USB Device: {response}");
         };
         
@@ -114,7 +114,7 @@ public class ModernStreamingDevice : IDisposable
         
         // Adapter provides these interfaces that desktop code expects
         public IMessageProducer<string>? MessageProducer => _coreAdapter?.MessageProducer;  
-        public IMessageConsumer<string>? MessageConsumer => _coreAdapter?.MessageConsumer;
+        public IMessageConsumer<object>? MessageConsumer => _coreAdapter?.MessageConsumer;
         
         /// <summary>
         /// Replace existing Connect() method with this implementation.
@@ -185,20 +185,27 @@ public void StopStreaming()
         }
         
         // Event handlers that translate Core events to desktop patterns
-        private void OnMessageReceived(object? sender, MessageReceivedEventArgs<string> e)
+        private void OnMessageReceived(object? sender, MessageReceivedEventArgs<object> e)
         {
             var message = e.Message.Data;
             
-            // Handle protobuf messages as existing desktop code does
-            if (message.StartsWith("protobuf:"))
+            // Handle different message types
+            if (message is DaqifiOutMessage protobufMsg)
             {
-                // Process binary protobuf data
-                ProcessProtobufMessage(e.RawData);
+                // Process binary protobuf data - existing desktop code patterns
+                Console.WriteLine($"Received protobuf message: {protobufMsg}");
+                // Call existing protobuf processing methods here
+            }
+            else if (message is string textMsg)
+            {
+                // Handle text responses - existing desktop code patterns
+                Console.WriteLine($"Received text: {textMsg}");
+                // Call existing text processing methods here
             }
             else
             {
-                // Handle text responses
-                ProcessTextResponse(message);
+                // Handle other message types
+                Console.WriteLine($"Received message: {message}");
             }
         }
         
@@ -354,7 +361,7 @@ private async Task<bool> ConnectWithRetryAsync(int maxRetries = 3)
                     _device = CoreDeviceAdapter.CreateTcpAdapter(_host, _port);
                     
                     _device.MessageReceived += (sender, args) => {
-                        DeviceMessageReceived?.Invoke(args.Message.Data);
+                        DeviceMessageReceived?.Invoke(args.Message.Data?.ToString() ?? "");
                     };
                     
                     _device.ConnectionStatusChanged += (sender, args) => {
diff --git a/src/Daqifi.Core/Integration/Desktop/LegacyCompatibilityWrapper.cs b/src/Daqifi.Core/Integration/Desktop/LegacyCompatibilityWrapper.cs
new file mode 100644
index 0000000..92c249c
--- /dev/null
+++ b/src/Daqifi.Core/Integration/Desktop/LegacyCompatibilityWrapper.cs
@@ -0,0 +1,105 @@
+using Daqifi.Core.Communication.Consumers;
+using Daqifi.Core.Communication.Messages;
+
+namespace Daqifi.Core.Integration.Desktop;
+
+/// <summary>
+/// Provides backward compatibility for applications that expect string-based message events.
+/// This wrapper converts object-based messages back to string format for legacy code.
+/// </summary>
+public class LegacyMessageEventArgs : EventArgs
+{
+    public LegacyMessageEventArgs(string message)
+    {
+        Message = message;
+    }
+
+    public string Message { get; }
+}
+
+/// <summary>
+/// Wrapper that provides backward-compatible string-based events from object-based CoreDeviceAdapter.
+/// Use this for gradual migration of existing desktop applications.
+/// </summary>
+public class LegacyCoreDeviceAdapter : IDisposable
+{
+    private readonly CoreDeviceAdapter _coreAdapter;
+    private bool _disposed;
+
+    /// <summary>
+    /// Initializes a new LegacyCoreDeviceAdapter with backward-compatible string events.
+    /// </summary>
+    /// <param name="coreAdapter">The modern CoreDeviceAdapter to wrap.</param>
+    public LegacyCoreDeviceAdapter(CoreDeviceAdapter coreAdapter)
+    {
+        _coreAdapter = coreAdapter ?? throw new ArgumentNullException(nameof(coreAdapter));
+        _coreAdapter.MessageReceived += OnCoreMessageReceived;
+    }
+
+    /// <summary>
+    /// Legacy event that fires with string messages (backward compatible).
+    /// </summary>
+    public event EventHandler<LegacyMessageEventArgs>? MessageReceived;
+
+    /// <summary>
+    /// Pass-through properties from the underlying adapter.
+    /// </summary>
+    public bool IsConnected => _coreAdapter.IsConnected;
+    public string ConnectionInfo => _coreAdapter.ConnectionInfo;
+
+    /// <summary>
+    /// Pass-through methods from the underlying adapter.
+    /// </summary>
+    public bool Connect() => _coreAdapter.Connect();
+    public async Task<bool> ConnectAsync() => await _coreAdapter.ConnectAsync();
+    public bool Disconnect() => _coreAdapter.Disconnect();
+    public async Task<bool> DisconnectAsync() => await _coreAdapter.DisconnectAsync();
+    public bool Write(string command) => _coreAdapter.Write(command);
+
+    /// <summary>
+    /// Creates a legacy-compatible TCP adapter for existing desktop applications.
+    /// </summary>
+    /// <param name="host">The hostname or IP address.</param>
+    /// <param name="port">The port number.</param>
+    /// <returns>A legacy-compatible adapter.</returns>
+    public static LegacyCoreDeviceAdapter CreateTcpAdapter(string host, int port)
+    {
+        var coreAdapter = CoreDeviceAdapter.CreateTcpAdapter(host, port);
+        return new LegacyCoreDeviceAdapter(coreAdapter);
+    }
+
+    /// <summary>
+    /// Creates a legacy-compatible Serial adapter for existing desktop applications.
+    /// </summary>
+    /// <param name="portName">The serial port name.</param>
+    /// <param name="baudRate">The baud rate.</param>
+    /// <returns>A legacy-compatible adapter.</returns>
+    public static LegacyCoreDeviceAdapter CreateSerialAdapter(string portName, int baudRate = 115200)
+    {
+        var coreAdapter = CoreDeviceAdapter.CreateSerialAdapter(portName, baudRate);
+        return new LegacyCoreDeviceAdapter(coreAdapter);
+    }
+
+    private void OnCoreMessageReceived(object? sender, MessageReceivedEventArgs<object> e)
+    {
+        // Convert object messages to string format for backward compatibility
+        string messageText = e.Message.Data switch
+        {
+            string textMsg => textMsg,
+            DaqifiOutMessage protobufMsg => $"[Protobuf Message: {protobufMsg.GetType().Name}]",
+            _ => e.Message.Data?.ToString() ?? ""
+        };
+
+        MessageReceived?.Invoke(this, new LegacyMessageEventArgs(messageText));
+    }
+
+    public void Dispose()
+    {
+        if (!_disposed)
+        {
+            _coreAdapter.MessageReceived -= OnCoreMessageReceived;
+            _coreAdapter?.Dispose();
+            _disposed = true;
+        }
+    }
+}
\ No newline at end of file