diff --git a/convert/json_test.go b/convert/json_test.go
index b1fd587..88dcefb 100644
--- a/convert/json_test.go
+++ b/convert/json_test.go
@@ -134,7 +134,7 @@ func BenchmarkJSONConvert(b *testing.B) {
 
 	appendMap := func(b []byte, kvs ...interface{}) []byte {
 		b = e.AppendMap(b, -1)
-		b = tlog.AppendKVs(b, kvs)
+		b = tlog.AppendKVs(e, b, kvs)
 		b = e.AppendBreak(b)
 
 		return b
diff --git a/convert/logfmt_test.go b/convert/logfmt_test.go
index 6f994c8..f864db3 100644
--- a/convert/logfmt_test.go
+++ b/convert/logfmt_test.go
@@ -139,12 +139,13 @@ func TestLogfmtRename(t *testing.T) {
 }
 
 func TestLogfmtKeyWithSpace(t *testing.T) {
+	var e tlwire.Encoder
 	var b low.Buf
 
 	j := NewLogfmt(&b)
 	j.QuoteEmptyValue = true
 
-	_, err := j.Write(tlog.AppendKVs(nil, []interface{}{tlog.RawTag(tlwire.Map, 1), "key with spaces", "value"}))
+	_, err := j.Write(tlog.AppendKVs(e, nil, []interface{}{tlog.RawTag(tlwire.Map, 1), "key with spaces", "value"}))
 	assert.NoError(t, err)
 	assert.Equal(t, `"key with spaces"=value`+"\n", string(b))
 }
diff --git a/convert/rewriter_test.go b/convert/rewriter_test.go
index aff3c96..b04287d 100644
--- a/convert/rewriter_test.go
+++ b/convert/rewriter_test.go
@@ -13,6 +13,7 @@ import (
 )
 
 func TestRewriter(t *testing.T) {
+	var e tlwire.Encoder
 	var obj, b low.Buf
 	rew := NewRewriter(&b)
 	rew.Rule = RewriterFunc(func(b, p []byte, path []tlog.RawMessage, kst, st int) ([]byte, int, error) {
@@ -41,7 +42,7 @@ func TestRewriter(t *testing.T) {
 	assert.Equal(t, obj, b)
 
 	b = b[:0]
-	obj = tlog.AppendKVs(obj[:0], []interface{}{
+	obj = tlog.AppendKVs(e, obj[:0], []interface{}{
 		tlog.RawTag(tlwire.Map, -1),
 		"a", "b",
 		"d", tlog.NextIs(tlwire.Duration), 1,
@@ -59,6 +60,7 @@ func TestRewriter(t *testing.T) {
 }
 
 func TestKeyRenamer(t *testing.T) {
+	var e tlwire.Encoder
 	var obj, exp, b low.Buf
 
 	rew := NewRewriter(&b)
@@ -96,14 +98,14 @@ func TestKeyRenamer(t *testing.T) {
 	b = b[:0]
 	t.Logf("case 1")
 
-	obj = tlog.AppendKVs(obj[:0], []interface{}{
+	obj = tlog.AppendKVs(e, obj[:0], []interface{}{
 		tlog.RawTag(tlwire.Map, -1),
 		tlog.KeyTimestamp, time.Unix(100000000, 0),
 		tlog.KeyCaller, loc.Caller(0),
 		tlog.Break,
 	})
 
-	exp = tlog.AppendKVs(exp[:0], []interface{}{
+	exp = tlog.AppendKVs(e, exp[:0], []interface{}{
 		tlog.RawTag(tlwire.Map, -1),
 		"time", time.Unix(100000000, 0),
 		tlog.Break,
diff --git a/examples/charmlog/main.go b/examples/charmlog/main.go
index 775c858..8c64188 100644
--- a/examples/charmlog/main.go
+++ b/examples/charmlog/main.go
@@ -6,11 +6,12 @@ import (
 	"time"
 
 	"tlog.app/go/tlog"
+	"tlog.app/go/tlog/ext/tlwtag"
 	"tlog.app/go/tlog/tlwire"
 )
 
 const (
-	Cups = tlog.SemanticUserBase + iota
+	Cups = tlwtag.SemanticUserBase + iota
 )
 
 type cup int
diff --git a/tlio/writers_test.go b/tlio/writers_test.go
index 11b852e..96dce3d 100644
--- a/tlio/writers_test.go
+++ b/tlio/writers_test.go
@@ -26,8 +26,8 @@ func TestReWriter(t *testing.T) {
 		err: errors.New("some"),
 	}
 
-	var b low.Buf
 	var e tlwire.Encoder
+	var b low.Buf
 
 	w := NewReWriter(func(have io.Writer, err error) (io.Writer, error) {
 		var b low.Buf
@@ -55,7 +55,7 @@ func TestReWriter(t *testing.T) {
 		}()
 
 		b = e.AppendMap(b, -1)
-		b = tlog.AppendKVs(b, kvs)
+		b = tlog.AppendKVs(e, b, kvs)
 		b = e.AppendBreak(b)
 
 		_, err = w.Write(b)
@@ -141,13 +141,12 @@ func TestReWriter(t *testing.T) {
 }
 
 func newfile(events [][]interface{}) *low.Buf {
-	var b low.Buf
-
 	var e tlwire.Encoder
+	var b low.Buf
 
 	for _, evs := range events {
 		b = e.AppendMap(b, -1)
-		b = tlog.AppendKVs(b, evs)
+		b = tlog.AppendKVs(e, b, evs)
 		b = e.AppendBreak(b)
 	}
 
diff --git a/tlog.go b/tlog.go
index bdc1ff9..cd43ee6 100644
--- a/tlog.go
+++ b/tlog.go
@@ -130,51 +130,53 @@ func message(l *Logger, id ID, d int, msg interface{}, kvs []interface{}) {
 		return
 	}
 
+	e := l.Encoder
+
 	defer l.Unlock()
 	l.Lock()
 
-	l.b = l.Encoder.AppendMap(l.b[:0], -1)
+	l.b = e.AppendMap(l.b[:0], -1)
 
 	if id != (ID{}) {
-		l.b = l.Encoder.AppendString(l.b, KeySpan)
+		l.b = e.AppendString(l.b, KeySpan)
 		l.b = id.TlogAppend(l.b)
 	}
 
 	if l.nano != nil {
 		now := l.nano()
 
-		l.b = l.Encoder.AppendString(l.b, KeyTimestamp)
-		l.b = l.Encoder.AppendTimestamp(l.b, now)
+		l.b = e.AppendString(l.b, KeyTimestamp)
+		l.b = e.AppendTimestamp(l.b, now)
 	}
 
 	var c loc.PC
 
 	if d >= 0 && l.callers != nil && l.callers(2+d+l.callersSkip, (*loc.PC)(noescape(unsafe.Pointer(&c))), 1, 1) != 0 {
-		l.b = l.Encoder.AppendKey(l.b, KeyCaller)
-		l.b = l.Encoder.AppendCaller(l.b, c)
+		l.b = e.AppendKey(l.b, KeyCaller)
+		l.b = e.AppendCaller(l.b, c)
 	}
 
 	if msg != nil {
-		l.b = l.Encoder.AppendKey(l.b, KeyMessage)
-		l.b = l.Encoder.AppendSemantic(l.b, WireMessage)
+		l.b = e.AppendKey(l.b, KeyMessage)
+		l.b = e.AppendSemantic(l.b, WireMessage)
 
 		switch msg := msg.(type) {
 		case string:
-			l.b = l.Encoder.AppendString(l.b, msg)
+			l.b = e.AppendString(l.b, msg)
 		case []byte:
-			l.b = l.Encoder.AppendTagBytes(l.b, tlwire.String, msg)
+			l.b = e.AppendTagBytes(l.b, tlwire.String, msg)
 		case format:
-			l.b = l.Encoder.AppendFormat(l.b, msg.Fmt, msg.Args...)
+			l.b = e.AppendFormat(l.b, msg.Fmt, msg.Args...)
 		default:
-			l.b = l.Encoder.AppendFormat(l.b, "%v", msg)
+			l.b = e.AppendFormat(l.b, "%v", msg)
 		}
 	}
 
-	l.b = AppendKVs(&l.Encoder, l.b, kvs)
+	l.b = AppendKVs(e, l.b, kvs)
 
 	l.b = append(l.b, l.ls...)
 
-	l.b = l.Encoder.AppendBreak(l.b)
+	l.b = e.AppendBreak(l.b)
 
 	_, _ = l.Writer.Write(l.b)
 }
@@ -190,7 +192,7 @@ func newspan(l *Logger, par ID, d int, n string, kvs []interface{}) (s Span) {
 		s.StartedAt = l.now()
 	}
 
-	e := &l.Encoder
+	e := l.Encoder
 
 	defer l.Unlock()
 	l.Lock()
@@ -244,7 +246,7 @@ func (s Span) Finish(kvs ...interface{}) {
 	}
 
 	l := s.Logger
-	e := &s.Logger.Encoder
+	e := l.Encoder
 
 	defer l.Unlock()
 	l.Lock()
@@ -293,7 +295,7 @@ func (l *Logger) SetLabels(kvs ...interface{}) {
 	defer l.Unlock()
 	l.Lock()
 
-	l.ls = AppendLabels(&l.Encoder, l.ls[:0], kvs)
+	l.ls = AppendLabels(l.Encoder, l.ls[:0], kvs)
 }
 
 func (l *Logger) Labels() RawMessage {
@@ -330,7 +332,7 @@ func (l *Logger) Event(kvs ...interface{}) (err error) {
 
 	l.b = l.AppendMap(l.b[:0], -1)
 
-	l.b = AppendKVs(&l.Encoder, l.b, kvs)
+	l.b = AppendKVs(l.Encoder, l.b, kvs)
 
 	l.b = append(l.b, l.ls...)
 
@@ -347,7 +349,7 @@ func (s Span) Event(kvs ...interface{}) (err error) {
 	}
 
 	l := s.Logger
-	e := &l.Encoder
+	e := l.Encoder
 
 	defer l.Unlock()
 	l.Lock()
diff --git a/tlwire/encoder_value.go b/tlwire/encoder_value.go
index 7387e36..be1d227 100644
--- a/tlwire/encoder_value.go
+++ b/tlwire/encoder_value.go
@@ -97,26 +97,26 @@ func init() {
 	})
 }
 
-func (e *Encoder) AppendKeyValue(b []byte, key string, v interface{}) []byte {
+func (e Encoder) AppendKeyValue(b []byte, key string, v interface{}) []byte {
 	b = e.AppendKey(b, key)
 	b = e.AppendValue(b, v)
 	return b
 }
 
-//go:linkname appendValue tlog.app/go/tlog/tlwire.(*Encoder).appendValue
+//go:linkname appendValue tlog.app/go/tlog/tlwire.Encoder.appendValue
 //go:noescape
-func appendValue(e *Encoder, b []byte, v interface{}) []byte
+func appendValue(e Encoder, b []byte, v interface{}) []byte
 
-func (e *Encoder) AppendValue(b []byte, v interface{}) []byte {
+func (e Encoder) AppendValue(b []byte, v interface{}) []byte {
 	return appendValue(e, b, v)
 }
 
-func (e *Encoder) AppendValueSafe(b []byte, v interface{}) []byte {
+func (e Encoder) AppendValueSafe(b []byte, v interface{}) []byte {
 	return e.appendValue(b, v)
 }
 
 // Called through linkname hack as appendValue from (Encoder).AppendValue.
-func (e *Encoder) appendValue(b []byte, v interface{}) []byte {
+func (e Encoder) appendValue(b []byte, v interface{}) []byte {
 	if v == nil {
 		return append(b, Special|Nil)
 	}
@@ -126,7 +126,7 @@ func (e *Encoder) appendValue(b []byte, v interface{}) []byte {
 	return e.appendRaw(b, r, ptrSet{})
 }
 
-func (e *Encoder) appendRaw(b []byte, r reflect.Value, visited ptrSet) []byte { //nolint:gocognit,cyclop
+func (e Encoder) appendRaw(b []byte, r reflect.Value, visited ptrSet) []byte { //nolint:gocognit,cyclop
 	if r.CanInterface() {
 		//	v := r.Interface()
 		v := valueInterface(r)
@@ -137,14 +137,12 @@ func (e *Encoder) appendRaw(b []byte, r reflect.Value, visited ptrSet) []byte {
 
 		ef := raweface(v)
 
-		if e != nil {
-			if enc, ok := e.custom[ef.typ]; ok {
-				return enc(e, b, v)
-			}
+		if enc, ok := e.custom[ef.typ]; ok {
+			return enc(&e, b, v)
 		}
 
 		if enc, ok := defaultEncoders[ef.typ]; ok {
-			return enc(e, b, v)
+			return enc(&e, b, v)
 		}
 
 		switch v := v.(type) {
@@ -250,7 +248,7 @@ func (e *Encoder) appendRaw(b []byte, r reflect.Value, visited ptrSet) []byte {
 	}
 }
 
-func (e *Encoder) appendStruct(b []byte, r reflect.Value, visited ptrSet) []byte {
+func (e Encoder) appendStruct(b []byte, r reflect.Value, visited ptrSet) []byte {
 	t := r.Type()
 
 	b = append(b, Map|LenBreak)
@@ -262,7 +260,7 @@ func (e *Encoder) appendStruct(b []byte, r reflect.Value, visited ptrSet) []byte
 	return b
 }
 
-func (e *Encoder) appendStructFields(b []byte, t reflect.Type, r reflect.Value, visited ptrSet) []byte {
+func (e Encoder) appendStructFields(b []byte, t reflect.Type, r reflect.Value, visited ptrSet) []byte {
 	//	fmt.Fprintf(os.Stderr, "appendStructFields: %v  ctx %p %d\n", t, visited, len(visited))
 
 	s := parseStruct(t)
diff --git a/wire.go b/wire.go
index 8f01da4..1311044 100644
--- a/wire.go
+++ b/wire.go
@@ -54,7 +54,7 @@ const (
 	SemanticCommunityBase = tlwire.SemanticTlogBase + 10
 )
 
-func AppendLabels(e *tlwire.Encoder, b []byte, kvs []interface{}) []byte {
+func AppendLabels(e tlwire.Encoder, b []byte, kvs []interface{}) []byte {
 	const tag = tlwire.Semantic | WireLabel
 
 	var d tlwire.LowDecoder
@@ -85,7 +85,7 @@ func AppendLabels(e *tlwire.Encoder, b []byte, kvs []interface{}) []byte {
 	return b[:w]
 }
 
-func AppendKVs(e *tlwire.Encoder, b []byte, kvs []interface{}) []byte {
+func AppendKVs(e tlwire.Encoder, b []byte, kvs []interface{}) []byte {
 	return appendKVs0(e, b, kvs)
 }
 
@@ -103,13 +103,13 @@ func Special(value int) RawMessage {
 
 //go:linkname appendKVs0 tlog.app/go/tlog.appendKVs
 //go:noescape
-func appendKVs0(e *tlwire.Encoder, b []byte, kvs []interface{}) []byte
+func appendKVs0(e tlwire.Encoder, b []byte, kvs []interface{}) []byte
 
 func init() { // prevent deadcode warnings
-	appendKVs(nil, nil, nil)
+	appendKVs(tlwire.Encoder{}, nil, nil)
 }
 
-func appendKVs(e *tlwire.Encoder, b []byte, kvs []interface{}) []byte {
+func appendKVs(e tlwire.Encoder, b []byte, kvs []interface{}) []byte {
 	for i := 0; i < len(kvs); {
 		var k string