# tun-bench matrix behind the macOS numbers on pandafan.app/pandacore (SagerNet/tun-bench, run as root).
# Point `version` at your PandaCore binary: an absolute path is used as a local build, while tun-bench
# downloads the open-source engines itself. Run three rounds with reversed implementation order in
# round two and a 30-second cooldown between rounds; retain all rounds and aggregate by median.
environments:
  darwin:
    type: local
    os: darwin

implementations:
  pandacore:
    type: mihomo
    version: /usr/local/bin/pandacore
  sing-box:
    type: sing-box
    version: 1.15.0-alpha.4
  mihomo:
    type: mihomo
    version: 1.19.31

matrix:
  - name: typical
    implementation: [ pandacore, sing-box, mihomo ]
    ip: [ 4 ]
    network: [ tcp ]
    stack: [ pandacore/panda, sing-box/go, mihomo/gvisor ]
    mtu: [ 4064 ]
    include:
      - bitrate: 0
      - parallel: 8
      - bitrate: 1Gbps
  - name: memory
    type: memory
    implementation: [ pandacore, sing-box, mihomo ]
    stack: [ pandacore/panda, sing-box/go, mihomo/gvisor ]
    mtu: [ 4064 ]
    ip: [ 4 ]
    network: [ tcp ]

The patch lets tun-bench treat a local path as the PandaCore binary, writes the TUN section in PandaCore’s configuration format, and moves the test subnet away from PandaCore’s default address.

diff --git a/artifacts.go b/artifacts.go
index 112f4e2..791ba40 100644
--- a/artifacts.go
+++ b/artifacts.go
@@ -137,7 +137,10 @@ func (p *artifactPreparer) binary(ctx context.Context, software, version, source
 		return binary, unsupported
 	}
 	var err error
-	if sourcePackage != "" {
+	if sourcePackage == "" && filepath.IsAbs(version) {
+		// A version given as an absolute path is a locally built executable: use it as is.
+		binary.path, binary.version = version, "local"
+	} else if sourcePackage != "" {
 		directory, createErr := os.MkdirTemp(p.directory, "package-*")
 		if createErr != nil {
 			return binary, createErr
diff --git a/benchmark.go b/benchmark.go
index ef4297c..b5ecaba 100644
--- a/benchmark.go
+++ b/benchmark.go
@@ -391,12 +391,28 @@ func (b *benchmark) startSubject(ctx context.Context, probePort int) error {
 		} else {
 			listener["inet4-address"] = []string{b.environment.address.String()}
 		}
-		content, err = yaml.Marshal(map[string]any{
+		document := map[string]any{
 			"mode": "rule", "log-level": "warning", "ipv6": true, "find-process-mode": "off",
 			"listeners": []any{listener},
 			"proxies":   []any{map[string]any{"name": "relay", "type": "socks5", "server": relayAddress, "port": relayPort, "udp": true}},
 			"rules":     []string{"MATCH,relay"}, "dns": map[string]any{"enable": false},
-		})
+		}
+		if strings.Contains(filepath.Base(b.options.executable), "pandacore") {
+			// pandacore takes mihomo's CLI and YAML but declares the TUN in the top-level `tun:` section.
+			delete(document, "listeners")
+			// pandacore forwards the benchmark target directly, like sing-box: the TUN rewrites the
+			// target address to loopback (destination-override) and the rule sends it to DIRECT, so no
+			// SOCKS5 hop is measured. Its preflight wants the host default route; outbound binding skips
+			// loopback destinations.
+			document["tun"] = map[string]any{
+				"enable": true, "device": b.environment.interfaceName, "stack": stack, "mtu": b.options.MTU,
+				"auto-route": false, "auto-detect-interface": true,
+				"destination-override": map[string]any{b.environment.target.String(): b.options.loopback()},
+			}
+			document["rules"] = []string{"IP-CIDR," + targetPrefix + ",DIRECT,no-resolve", "MATCH,DIRECT"}
+			document["log-level"] = "info" // keep the TUN driver lines visible when the interface never appears
+		}
+		content, err = yaml.Marshal(document)
 		path = filepath.Join(b.directory, "mihomo.yaml")
 		args = []string{"-f", path, "-d", b.directory}
 	case "v2ray", "xray":
diff --git a/configuration.go b/configuration.go
index d9107ef..00eba19 100644
--- a/configuration.go
+++ b/configuration.go
@@ -273,7 +273,7 @@ func readConfiguration(path, matrixName, measurementType string) (runConfigurati
 			}
 			implementation.Version = strings.TrimPrefix(implementation.Version, "v")
 			if implementation.Version != "" {
-				if implementation.Version != "latest" && !semver.IsValid("v"+implementation.Version) {
+				if implementation.Version != "latest" && !filepath.IsAbs(implementation.Version) && !semver.IsValid("v"+implementation.Version) {
 					return configuration, nil, E.New(name, ": invalid release version ", implementation.Version)
 				}
 			} else if implementation.Package != "" && !filepath.IsAbs(implementation.Package) {
diff --git a/network.go b/network.go
index 4aa15e2..ff3172f 100644
--- a/network.go
+++ b/network.go
@@ -18,8 +18,8 @@ import (
 var errUDPPayloadIntegrity = E.New("UDP payload integrity failure")
 
 func prepareNetwork(ctx context.Context, configuration benchmarkOptions, placement *environment) error {
-	placement.address = netip.MustParsePrefix("198.18.0.1/29")
-	placement.target = netip.MustParseAddr("198.18.0.3")
+	placement.address = netip.MustParsePrefix("198.19.0.1/29")
+	placement.target = netip.MustParseAddr("198.19.0.3")
 	if configuration.IP == 6 {
 		placement.address = netip.MustParsePrefix("fd00::1/125")
 		placement.target = netip.MustParseAddr("fd00::3")
@@ -30,7 +30,7 @@ func prepareNetwork(ctx context.Context, configuration benchmarkOptions, placeme
 	}
 	subnets := []netip.Prefix{placement.address.Masked()}
 	if configuration.software == "leaf" && configuration.IP == 6 {
-		subnets = append(subnets, netip.MustParsePrefix("198.18.0.0/29"))
+		subnets = append(subnets, netip.MustParsePrefix("198.19.0.0/29"))
 	}
 	for _, subnet := range subnets {
 		for _, prefix := range routes {
diff --git a/platform_linux.go b/platform_linux.go
index 227cc0d..3546b50 100644
--- a/platform_linux.go
+++ b/platform_linux.go
@@ -209,6 +209,10 @@ func prepareInterface(configuration benchmarkOptions, placement environment, net
 		return false, nil
 	}
 	queues, err := filepath.Glob(filepath.Join("/sys/class/net", placement.interfaceName, "queues/tx-*"))
+	if strings.Contains(filepath.Base(configuration.executable), "pandacore") {
+		// pandacore always opens its multi-queue TUN with its own lane count; accept whatever it created.
+		return len(queues) >= 1, err
+	}
 	return len(queues) == configuration.queues, err
 }