diff --git a/capture/capture.go b/capture/capture.go
index b722bb8..d9bc301 100644
--- a/capture/capture.go
+++ b/capture/capture.go
@@ -4,13 +4,13 @@ package capture
 
 import (
 	"fmt"
+	"net/netip"
 
 	"git.freifunk-franken.de/jkimmel/abbel/packet"
 	"github.com/google/gopacket"
 	"github.com/google/gopacket/afpacket"
 	"github.com/google/gopacket/layers"
 	"golang.org/x/net/bpf"
-	"inet.af/netaddr"
 )
 
 var (
@@ -65,27 +65,27 @@ func (h Handle) Close() error {
 	return nil
 }
 
-func (h Handle) ReadFrom(b []byte) (body []byte, src netaddr.IP, ifindex int, err error) {
+func (h Handle) ReadFrom(b []byte) (body []byte, src netip.Addr, ifindex int, err error) {
 	data, ci, err := h.tp.ZeroCopyReadPacketData()
 	if err != nil {
-		return nil, netaddr.IP{}, 0, err
+		return nil, netip.Addr{}, 0, err
 	}
 	pckt := gopacket.NewPacket(data, layers.LayerTypeIPv6, gopacket.NoCopy)
 	ip6, ok := pckt.NetworkLayer().(*layers.IPv6)
 	if !ok {
-		return nil, netaddr.IP{}, 0, fmt.Errorf("Expected IPv6 layer, got %v", pckt.NetworkLayer())
+		return nil, netip.Addr{}, 0, fmt.Errorf("Expected IPv6 layer, got %v", pckt.NetworkLayer())
 	}
 
-	src, ok = netaddr.FromStdIP(ip6.SrcIP)
+	src, ok = netip.AddrFromSlice(ip6.SrcIP)
 	if !ok {
-		return nil, netaddr.IP{}, 0, fmt.Errorf("Error parsing packet src address %q", ip6.SrcIP)
+		return nil, netip.Addr{}, 0, fmt.Errorf("Error parsing packet src address %q", ip6.SrcIP)
 	}
 
 	payload := pckt.ApplicationLayer().Payload()
 	copy(b, payload)
 	b, err = packet.Validate(b[:len(payload)])
 	if err != nil {
-		return nil, netaddr.IP{}, 0, err
+		return nil, netip.Addr{}, 0, err
 	}
 
 	return b, src, ci.InterfaceIndex, nil
diff --git a/capture/netgo.go b/capture/netgo.go
index 541fda5..56e16ad 100644
--- a/capture/netgo.go
+++ b/capture/netgo.go
@@ -4,10 +4,10 @@ package capture
 
 import "fmt"
 
-import "inet.af/netaddr"
+import "net/netip"
 
 type nullReaderFromCloser interface {
-	ReadFrom(b []byte) (body []byte, src netaddr.IP, ifindex int, err error)
+	ReadFrom(b []byte) (body []byte, src netip.Addr, ifindex int, err error)
 	Close() error
 }
 
diff --git a/main.go b/main.go
index 1df2d37..c5e9433 100644
--- a/main.go
+++ b/main.go
@@ -4,12 +4,12 @@ import (
 	"flag"
 	"fmt"
 	"log"
+	"net/netip"
 	"strings"
 
 	"git.freifunk-franken.de/jkimmel/abbel/capture"
 	"git.freifunk-franken.de/jkimmel/abbel/packet"
 	"git.freifunk-franken.de/jkimmel/abbel/tlv"
-	"inet.af/netaddr"
 )
 
 type options struct {
@@ -42,9 +42,9 @@ func parseOpts() (options, error) {
 }
 
 type updatesKey struct {
-	prefix   netaddr.IPPrefix
+	prefix   netip.Prefix
 	routerID tlv.RouterID
-	nexthop  netaddr.IP
+	nexthop  netip.Addr
 }
 
 var (
@@ -52,7 +52,7 @@ var (
 )
 
 type BabelPacketConn interface {
-	ReadFrom(b []byte) (body []byte, src netaddr.IP, ifindex int, err error)
+	ReadFrom(b []byte) (body []byte, src netip.Addr, ifindex int, err error)
 	Close() error
 }
 
diff --git a/packet/packet.go b/packet/packet.go
index 7a76321..da10d5e 100644
--- a/packet/packet.go
+++ b/packet/packet.go
@@ -4,10 +4,10 @@ import (
 	"context"
 	"fmt"
 	"net"
+	"net/netip"
 	"syscall"
 
 	"golang.org/x/net/ipv6"
-	"inet.af/netaddr"
 )
 
 const (
@@ -78,12 +78,12 @@ func (c Conn) JoinGroup(ifname string, addr string) error {
 		return fmt.Errorf("InterfaceByName(%s): %w", ifname, err)
 	}
 
-	ip, err := netaddr.ParseIP(addr)
+	ip, err := netip.ParseAddr(addr)
 	if err != nil {
 		return err
 	}
 
-	return c.v6pc.JoinGroup(ifi, &net.UDPAddr{IP: ip.IPAddr().IP})
+	return c.v6pc.JoinGroup(ifi, &net.UDPAddr{IP: ip.AsSlice()})
 }
 
 func Validate(b []byte) ([]byte, error) {
@@ -111,22 +111,22 @@ func Validate(b []byte) ([]byte, error) {
 	return b, nil
 }
 
-func (c Conn) ReadFrom(b []byte) (body []byte, src netaddr.IP, ifindex int, err error) {
+func (c Conn) ReadFrom(b []byte) (body []byte, src netip.Addr, ifindex int, err error) {
 	n, rcm, _, err := c.v6pc.ReadFrom(b)
 	if err != nil {
-		return nil, netaddr.IP{}, 0, err
+		return nil, netip.Addr{}, 0, err
 	}
 
 	b, err = Validate(b[:n])
 	if err != nil {
-		return nil, netaddr.IP{}, 0, err
+		return nil, netip.Addr{}, 0, err
 	}
 
 	var ok bool
-	src, ok = netaddr.FromStdIPRaw(rcm.Src)
+	src, ok = netip.AddrFromSlice(rcm.Src)
 
 	if !ok {
-		return nil, netaddr.IP{}, 0, fmt.Errorf("Invalid src address %q", rcm.Src)
+		return nil, netip.Addr{}, 0, fmt.Errorf("Invalid src address %q", rcm.Src)
 	}
 
 	return b, src, rcm.IfIndex, err
diff --git a/tlv/tlv.go b/tlv/tlv.go
index 3082a91..ee7ec3c 100644
--- a/tlv/tlv.go
+++ b/tlv/tlv.go
@@ -12,8 +12,7 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
-
-	"inet.af/netaddr"
+	"net/netip"
 )
 
 // Type encodes the type of TLV
@@ -78,14 +77,14 @@ const (
 )
 
 // AEFromPrefix returns the address encoding of a prefix:
-func AEFromPrefix(p netaddr.IPPrefix) AEType {
-	return AEFromIP(p.IP())
+func AEFromPrefix(p netip.Prefix) AEType {
+	return AEFromIP(p.Addr())
 }
 
 // AEFromIP returns the address encoding of an address.
-func AEFromIP(p netaddr.IP) AEType {
+func AEFromIP(p netip.Addr) AEType {
 	switch {
-	case p.IsZero():
+	case p.IsUnspecified():
 		return AEWildcard
 	case p.Is4():
 		return AEIPv4
@@ -172,8 +171,8 @@ type PacketDecoder struct {
 
 	// parser state
 	routerID  RouterID
-	nexthopv6 netaddr.IP
-	nexthopv4 netaddr.IP
+	nexthopv6 netip.Addr
+	nexthopv4 netip.Addr
 	v6        [16]byte
 	v4        [4]byte
 
@@ -183,7 +182,7 @@ type PacketDecoder struct {
 }
 
 // Reset clears the parser state and sets a new byte slice to work on.
-func (s *PacketDecoder) Reset(b []byte, nexthop netaddr.IP, ifindex int) {
+func (s *PacketDecoder) Reset(b []byte, nexthop netip.Addr, ifindex int) {
 	*s = PacketDecoder{}
 	s.tlvscanner.Reset(b)
 	switch {
@@ -482,7 +481,7 @@ type IHU struct {
 	// reserved uint8
 	Rxcost   uint16
 	Interval uint16
-	Address  netaddr.IP
+	Address  netip.Addr
 }
 
 // T returns TypeIHU.
@@ -585,7 +584,7 @@ func (r RouterID) String() string {
 type NextHop struct {
 	// AE uint8
 	// reserved uint8
-	Address netaddr.IP
+	Address netip.Addr
 }
 
 // T returns TypeNextHop.
@@ -629,8 +628,8 @@ type Update struct {
 	Seqno    uint16
 	Metric   uint16
 	RouterID RouterID
-	Prefix   netaddr.IPPrefix
-	NextHop  netaddr.IP
+	Prefix   netip.Prefix
+	NextHop  netip.Addr
 }
 
 // T returns TypeUpdate.
@@ -640,7 +639,7 @@ func (Update) T() Type {
 
 // L depends on the anounced prefix, at least 10.
 func (u Update) L() uint8 {
-	return 10 + psizeFromPlen(u.Prefix.Bits())
+	return 10 + psizeFromPlen(uint8(u.Prefix.Bits()))
 }
 
 // FormatHeader returns a string of the most important fields except the prefix
@@ -670,13 +669,13 @@ func (s *PacketDecoder) updateFromBytes(b []byte) (Update, []byte, error) {
 	case 1:
 		u.Prefix, b, err = prefixV4Default(s.v4, plen, u.Omitted, b)
 		if u.Flags&0x80 > 0 {
-			s.v4 = u.Prefix.IP().As4()
+			s.v4 = u.Prefix.Addr().As4()
 		}
 		u.NextHop = s.nexthopv4
 	case 2:
 		u.Prefix, b, err = prefixV6Default(s.v6, plen, u.Omitted, b)
 		if u.Flags&0x80 > 0 {
-			s.v6 = u.Prefix.IP().As16()
+			s.v6 = u.Prefix.Addr().As16()
 		}
 		u.NextHop = s.nexthopv6
 	case 3:
@@ -685,7 +684,7 @@ func (s *PacketDecoder) updateFromBytes(b []byte) (Update, []byte, error) {
 	}
 
 	if u.Flags&0x40 > 0 {
-		addr := u.Prefix.IP()
+		addr := u.Prefix.Addr()
 		switch {
 		case addr.Is6():
 			v6 := addr.As16()
@@ -708,7 +707,7 @@ func (s *PacketDecoder) updateFromBytes(b []byte) (Update, []byte, error) {
 type RouteRequest struct {
 	// AE     uint8
 	// plen   uint8
-	Prefix netaddr.IPPrefix
+	Prefix netip.Prefix
 }
 
 // AE returns the address encoding of the requested prefix
@@ -723,7 +722,7 @@ func (RouteRequest) T() Type {
 
 // L depends on the requested prefix, at least 4.
 func (r RouteRequest) L() uint8 {
-	return 4 + psizeFromPlen(r.Prefix.Bits())
+	return 4 + psizeFromPlen(uint8(r.Prefix.Bits()))
 }
 func routeRequestFromBytes(b []byte) (RouteRequest, []byte, error) {
 	if err := assertLengthGreater(b, TypeRouteRequest, 2); err != nil {
@@ -746,7 +745,7 @@ type SeqnoRequest struct {
 	Seqno    uint16
 	HopCount uint8
 	RouterID RouterID
-	Prefix   netaddr.IPPrefix
+	Prefix   netip.Prefix
 }
 
 // T returns TypeSeqnoRequest.
@@ -756,7 +755,7 @@ func (SeqnoRequest) T() Type {
 
 // L depends on the requested prefix, at least 14.
 func (r SeqnoRequest) L() uint8 {
-	return 14 + psizeFromPlen(r.Prefix.Bits())
+	return 14 + psizeFromPlen(uint8(r.Prefix.Bits()))
 }
 func seqnoRequestFromBytes(b []byte) (SeqnoRequest, []byte, error) {
 	if err := assertLengthGreater(b, TypeSeqnoRequest, 14); err != nil {
@@ -780,7 +779,7 @@ func seqnoRequestFromBytes(b []byte) (SeqnoRequest, []byte, error) {
 //
 // https://datatracker.ietf.org/doc/html/draft-ietf-babel-source-specific-07#section-7.1
 type SourcePrefix struct {
-	netaddr.IPPrefix
+	netip.Prefix
 }
 
 // T returns SubTypeSourcePrefix.
@@ -790,7 +789,7 @@ func (SourcePrefix) T() SubType {
 
 // L depends on the encoded prefix
 func (s SourcePrefix) L() uint8 {
-	return psizeFromPlen(s.Bits())
+	return psizeFromPlen(uint8(s.Bits()))
 }
 
 // SourcePrefixFromBytes parses a SourcePrefix SubTLV
@@ -809,9 +808,9 @@ func SourcePrefixFromBytes(b []byte) (SourcePrefix, []byte, error) {
 func psizeFromPlen(plen uint8) uint8 {
 	return uint8((uint16(plen) + 7) / 8)
 }
-func prefixUncompressed(ae uint8, plen uint8, b []byte) (netaddr.IPPrefix, []byte, error) {
+func prefixUncompressed(ae uint8, plen uint8, b []byte) (netip.Prefix, []byte, error) {
 	if len(b) < int(psizeFromPlen(plen)) {
-		return netaddr.IPPrefix{}, b, fmt.Errorf("plen too large")
+		return netip.Prefix{}, b, fmt.Errorf("plen too large")
 	}
 
 	switch ae {
@@ -824,71 +823,71 @@ func prefixUncompressed(ae uint8, plen uint8, b []byte) (netaddr.IPPrefix, []byt
 	case 3:
 		return prefixV6LL(b)
 	default:
-		return netaddr.IPPrefix{}, b, fmt.Errorf("Invalid AE %d", ae)
+		return netip.Prefix{}, b, fmt.Errorf("Invalid AE %d", ae)
 	}
 }
 
-func prefixWildcard() (netaddr.IPPrefix, []byte, error) {
-	return netaddr.IPPrefix{}, nil, nil
+func prefixWildcard() (netip.Prefix, []byte, error) {
+	return netip.Prefix{}, nil, nil
 }
 
-func prefixV4(plen uint8, b []byte) (netaddr.IPPrefix, []byte, error) {
+func prefixV4(plen uint8, b []byte) (netip.Prefix, []byte, error) {
 	return prefixV4Default([4]byte{}, plen, 0, b)
 }
-func prefixV4Default(ip4default [4]byte, plen uint8, omit uint8, b []byte) (netaddr.IPPrefix, []byte, error) {
+func prefixV4Default(ip4default [4]byte, plen uint8, omit uint8, b []byte) (netip.Prefix, []byte, error) {
 	var ip4 [4]byte
 	psize := psizeFromPlen(plen) - omit
 	copy(ip4[:], ip4default[:omit])
 	copy(ip4[omit:], b[:psize])
-	return netaddr.IPPrefixFrom(netaddr.IPFrom4(ip4), plen), b[psize:], nil
+	return netip.PrefixFrom(netip.AddrFrom4(ip4), int(plen)), b[psize:], nil
 }
-func prefixV6(plen uint8, b []byte) (netaddr.IPPrefix, []byte, error) {
+func prefixV6(plen uint8, b []byte) (netip.Prefix, []byte, error) {
 	return prefixV6Default([16]byte{}, plen, 0, b)
 }
-func prefixV6Default(ip6default [16]byte, plen uint8, omit uint8, b []byte) (netaddr.IPPrefix, []byte, error) {
+func prefixV6Default(ip6default [16]byte, plen uint8, omit uint8, b []byte) (netip.Prefix, []byte, error) {
 	var ip6 [16]byte
 	psize := psizeFromPlen(plen) - omit
 	copy(ip6[:], ip6default[:omit])
 	copy(ip6[omit:], b[:psize])
-	return netaddr.IPPrefixFrom(netaddr.IPv6Raw(ip6), plen), b[psize:], nil
+	return netip.PrefixFrom(netip.AddrFrom16(ip6), int(plen)), b[psize:], nil
 }
-func prefixV6LL(b []byte) (netaddr.IPPrefix, []byte, error) {
+func prefixV6LL(b []byte) (netip.Prefix, []byte, error) {
 	var ip6ll [16]byte
 	ip6ll[0] = 0xfe
 	ip6ll[1] = 0x80
 	copy(ip6ll[8:], b[:8])
-	return netaddr.IPPrefixFrom(netaddr.IPv6Raw(ip6ll), 8), b[8:], nil
+	return netip.PrefixFrom(netip.AddrFrom16(ip6ll), 8), b[8:], nil
 }
-func ipFromBytes(ae AEType, b []byte) (netaddr.IP, []byte, error) {
+func ipFromBytes(ae AEType, b []byte) (netip.Addr, []byte, error) {
 	switch ae {
 	case AEWildcard:
-		return netaddr.IP{}, b, nil
+		return netip.Addr{}, b, nil
 	case AEIPv4:
 		if len(b) < 4 {
-			return netaddr.IP{}, b, fmt.Errorf("Not enough bytes for v4 address: %d", len(b))
+			return netip.Addr{}, b, fmt.Errorf("Not enough bytes for v4 address: %d", len(b))
 		}
 		var ip4 [4]byte
 		copy(ip4[:], b[:4])
-		return netaddr.IPFrom4(ip4), b[4:], nil
+		return netip.AddrFrom4(ip4), b[4:], nil
 	case AEIPv6:
 		if len(b) < 16 {
-			return netaddr.IP{}, b, fmt.Errorf("Not enough bytes for v6 address: %d", len(b))
+			return netip.Addr{}, b, fmt.Errorf("Not enough bytes for v6 address: %d", len(b))
 		}
 		var ip6 [16]byte
 		copy(ip6[:], b[:16])
-		return netaddr.IPv6Raw(ip6), b[16:], nil
+		return netip.AddrFrom16(ip6), b[16:], nil
 	case AEIPv6LL:
 		if len(b) < 8 {
-			return netaddr.IP{}, b, fmt.Errorf("Not enough bytes for v6ll address: %d", len(b))
+			return netip.Addr{}, b, fmt.Errorf("Not enough bytes for v6ll address: %d", len(b))
 		}
 		var ip6ll [16]byte
 		ip6ll[0] = 0xfe
 		ip6ll[1] = 0x80
 		copy(ip6ll[8:], b[:8])
-		return netaddr.IPv6Raw(ip6ll), b[8:], nil
+		return netip.AddrFrom16(ip6ll), b[8:], nil
 	case AEIPv4oIPv6:
-		return netaddr.IP{}, b, fmt.Errorf("Not implemented AE Type %s", ae)
+		return netip.Addr{}, b, fmt.Errorf("Not implemented AE Type %s", ae)
 	default:
-		return netaddr.IP{}, b, fmt.Errorf("Invalid AE %d", ae)
+		return netip.Addr{}, b, fmt.Errorf("Invalid AE %d", ae)
 	}
 }