diff --git a/internal/wire/frame_parser.go b/internal/wire/frame_parser.go
index fdba2a71..59a8459d 100644
--- a/internal/wire/frame_parser.go
+++ b/internal/wire/frame_parser.go
@@ -60,7 +60,8 @@ func parseFrame(r *bytes.Reader, typeByte byte, v protocol.VersionNumber) (Frame
 		frame, err = parseStreamsBlockedFrame(r, v)
 	case 0x18:
 		frame, err = parseNewConnectionIDFrame(r, v)
-	// TODO: implement RETIRE_CONNECTION_ID frame
+	case 0x19:
+		frame, err = parseRetireConnectionIDFrame(r, v)
 	case 0x1a:
 		frame, err = parsePathChallengeFrame(r, v)
 	case 0x1b:
diff --git a/internal/wire/frame_parser_test.go b/internal/wire/frame_parser_test.go
index 053f6682..5245c4e8 100644
--- a/internal/wire/frame_parser_test.go
+++ b/internal/wire/frame_parser_test.go
@@ -196,6 +196,15 @@ var _ = Describe("Frame parsing", func() {
 		Expect(frame).To(Equal(f))
 	})
 
+	It("unpacks RETIRE_CONNECTION_ID frames", func() {
+		f := &RetireConnectionIDFrame{SequenceNumber: 0x1337}
+		buf := &bytes.Buffer{}
+		Expect(f.Write(buf, versionIETFFrames)).To(Succeed())
+		frame, err := ParseNextFrame(bytes.NewReader(buf.Bytes()), versionIETFFrames)
+		Expect(err).ToNot(HaveOccurred())
+		Expect(frame).To(Equal(f))
+	})
+
 	It("unpacks PATH_CHALLENGE frames", func() {
 		f := &PathChallengeFrame{Data: [8]byte{1, 2, 3, 4, 5, 6, 7, 8}}
 		err := f.Write(buf, versionIETFFrames)
diff --git a/internal/wire/retire_connection_id_frame.go b/internal/wire/retire_connection_id_frame.go
new file mode 100644
index 00000000..9a715a4c
--- /dev/null
+++ b/internal/wire/retire_connection_id_frame.go
@@ -0,0 +1,36 @@
+package wire
+
+import (
+	"bytes"
+
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+	"github.com/lucas-clemente/quic-go/internal/utils"
+)
+
+// A RetireConnectionIDFrame is a RETIRE_CONNECTION_ID frame
+type RetireConnectionIDFrame struct {
+	SequenceNumber uint64
+}
+
+func parseRetireConnectionIDFrame(r *bytes.Reader, _ protocol.VersionNumber) (*RetireConnectionIDFrame, error) {
+	if _, err := r.ReadByte(); err != nil {
+		return nil, err
+	}
+
+	seq, err := utils.ReadVarInt(r)
+	if err != nil {
+		return nil, err
+	}
+	return &RetireConnectionIDFrame{SequenceNumber: seq}, nil
+}
+
+func (f *RetireConnectionIDFrame) Write(b *bytes.Buffer, _ protocol.VersionNumber) error {
+	b.WriteByte(0x19)
+	utils.WriteVarInt(b, f.SequenceNumber)
+	return nil
+}
+
+// Length of a written frame
+func (f *RetireConnectionIDFrame) Length(protocol.VersionNumber) protocol.ByteCount {
+	return 1 + utils.VarIntLen(f.SequenceNumber)
+}
diff --git a/internal/wire/retire_connection_id_frame_test.go b/internal/wire/retire_connection_id_frame_test.go
new file mode 100644
index 00000000..54d41c59
--- /dev/null
+++ b/internal/wire/retire_connection_id_frame_test.go
@@ -0,0 +1,51 @@
+package wire
+
+import (
+	"bytes"
+	"io"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("NEW_CONNECTION_ID frame", func() {
+	Context("when parsing", func() {
+		It("accepts a sample frame", func() {
+			data := []byte{0x19}
+			data = append(data, encodeVarInt(0xdeadbeef)...) // sequence number
+			b := bytes.NewReader(data)
+			frame, err := parseRetireConnectionIDFrame(b, versionIETFFrames)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(frame.SequenceNumber).To(Equal(uint64(0xdeadbeef)))
+		})
+
+		It("errors on EOFs", func() {
+			data := []byte{0x18}
+			data = append(data, encodeVarInt(0xdeadbeef)...) // sequence number
+			_, err := parseRetireConnectionIDFrame(bytes.NewReader(data), versionIETFFrames)
+			Expect(err).NotTo(HaveOccurred())
+			for i := range data {
+				_, err := parseRetireConnectionIDFrame(bytes.NewReader(data[0:i]), versionIETFFrames)
+				Expect(err).To(MatchError(io.EOF))
+			}
+		})
+	})
+
+	Context("when writing", func() {
+		It("writes a sample frame", func() {
+			frame := &RetireConnectionIDFrame{SequenceNumber: 0x1337}
+			b := &bytes.Buffer{}
+			Expect(frame.Write(b, versionIETFFrames)).To(Succeed())
+			expected := []byte{0x19}
+			expected = append(expected, encodeVarInt(0x1337)...)
+			Expect(b.Bytes()).To(Equal(expected))
+		})
+
+		It("has the correct length", func() {
+			frame := &RetireConnectionIDFrame{SequenceNumber: 0xdecafbad}
+			b := &bytes.Buffer{}
+			Expect(frame.Write(b, versionIETFFrames)).To(Succeed())
+			Expect(frame.Length(versionIETFFrames)).To(BeEquivalentTo(b.Len()))
+		})
+	})
+})
diff --git a/session.go b/session.go
index 3b4d6db9..a55daf8b 100644
--- a/session.go
+++ b/session.go
@@ -580,6 +580,9 @@ func (s *session) handleFrames(fs []wire.Frame, encLevel protocol.EncryptionLeve
 			err = errors.New("unexpected PATH_RESPONSE frame")
 		case *wire.NewTokenFrame:
 		case *wire.NewConnectionIDFrame:
+		case *wire.RetireConnectionIDFrame:
+			// since we don't send new connection IDs, we don't expect retirements
+			err = errors.New("unexpected RETIRE_CONNECTION_ID frame")
 		default:
 			return errors.New("Session BUG: unexpected frame type")
 		}