Sly Technologies SDK v3 - Major Release Coming in 2026

[SecureNetWizard]

We're excited to announce that the next generation of Sly Technologies Java networking SDKs is in active development. This is a ground-up redesign bringing modern Java, unified architecture, and fully open source licensing.

What's Changing

Apache 2.0 Licensing

All SDK components are now Apache 2.0 licensed. Use them freely in commercial and open source projects without restriction.

Modern Java with FFM

Built on Java 22+ using the Foreign Function & Memory (FFM) API. No JNI, no native compilation, no platform-specific builds. Pure Java that runs anywhere libpcap is available.

Unified Protocol Stack

jNetPcap and jNetWorks now share the same protocol stack. Code written against one works unchanged with the other. Start with jNetPcap for simple captures, scale to jNetWorks when you need multi-CPU performance.

---

jNetPcap 3.0

The familiar libpcap wrapper, modernized.

What it does: Single-threaded packet capture and analysis. Perfect for scripts, tools, and applications that process packets sequentially.

try (NetPcap pcap = NetPcap.create("en0")) {
    pcap.activate();
    
    Ip4 ip = new Ip4();
    Tcp tcp = new Tcp();
    
    pcap.dispatch(10, (user, packet) -> {
        if (packet.hasHeader(ip)) {
            System.out.printf("IP: %s -> %s%n", ip.src(), ip.dst());
            
            if (packet.hasHeader(tcp)) {
                System.out.printf("  TCP port: %d%n", tcp.dstPort());
            }
        }
    }, null);
}

Headers are pre-allocated and reused. hasHeader() binds the instance to packet data for zero-allocation fast paths.

---

jNetWorks 3.0

High-performance, multi-CPU network capture and analysis.

What it does: Parallel packet processing with swappable backends. Same application code runs on libpcap, DPDK, or Napatech SmartNICs.

try (Net net = new PcapBackend()) {

    PacketStream[] streams = net.createPacketStreams("stream-%d", 4);

    net.capture("en0", "en1")
        .filter("tcp")
        .pipe(streams)
        .hash(HashType.HASH_5_TUPLE)
        .apply();

    try (TaskScope scope = new TaskScope(net)) {
        scope.shutdownAfter(Duration.ofMinutes(1));
        scope.fork(streams, this::processStream)
            .awaitCompletion();
    }
}

Backends:

• PcapBackend - libpcap/Npcap (open source, included)
• DpdkBackend - DPDK for 100+ Gbps (commercial)
• NtapiBackend - Napatech SmartNICs for 800 Gbps (commercial)

jNetWorks also supports protocol-level streaming (ProtocolStream<T>), flow tracking, and token streams for AI/analysis pipelines.

---

Protocol Support

Comprehensive protocol dissection from L2 through L7:

Layer 2: Ethernet, VLAN (802.1Q/QinQ), LLC, SNAP, STP, LLDP, MPLS

Layer 3: IPv4, IPv6 (full extension header chain), ARP, ICMP, ICMPv6, IPsec (AH/ESP)

Layer 4: TCP (with options parsing), UDP, SCTP

Layer 7: DNS, HTTP/1.1, TLS record parsing

Advanced features (via ProtocolStack configuration):

• IP fragment reassembly
• TCP stream reassembly
• TLS/IPsec decryption (with key material)
• Custom protocol extensions

// Advanced: Configure reassembly and decryption
ProtocolStack stack = new ProtocolStack();

stack.getProtocol(IpProtocol.class)
    .enableIpReassembly(new IpReassemblySettings()
        .maxFragmentCount(256)
        .tableSize(10_000));

stack.getProtocol(TcpProtocol.class)
    .enableStreamReassembly(...);

// Pass configured stack to NetPcap or jNetWorks
try (NetPcap pcap = NetPcap.create("en0", stack)) {
    ...
}

For basic dissection, no configuration needed. Advanced features opt-in when you need them.

---

Repository and Artifact Changes

Repository Renames

Old Name	New Name
jnetpcap-wrapper	jnetpcap-bindings
protocol-pack-*	sdk-protocol-*

New Maven Coordinates

All artifacts now use com.slytechs.sdk groupId:

jNetPcap SDK (packet capture + protocols):

    com.slytechs.sdk
    jnetpcap-sdk
    3.0.0-SNAPSHOT
    pom

jNetWorks SDK (multi-CPU capture + protocols):

    com.slytechs.sdk
    jnetworks-sdk
    3.0.0-SNAPSHOT
    pom

Individual modules (if you need fine-grained control):

jnetpcap-bindings   
jnetpcap-api        
jnetworks-api       
sdk-protocol-core   
sdk-protocol-tcpip  <!-- TCP/IP protocol pack -->

Project Structure

jnetpcap-sdk
├── jnetpcap-api        - High-level packet/protocol API
├── jnetpcap-bindings   - Low-level libpcap FFM bindings
├── sdk-protocol-core   - Core protocol definitions
└── sdk-protocol-tcpip  - TCP/IP protocol pack

jnetworks-sdk
├── jnetworks-api       - Multi-CPU capture API
├── jnetworks-pcap      - PcapBackend (open source)
├── jnetworks-dpdk      - DpdkBackend (commercial)
├── jnetworks-ntapi     - NtapiBackend (commercial)
├── sdk-protocol-core   - Shared with jNetPcap
└── sdk-protocol-tcpip  - Shared with jNetPcap

---

Migration Summary

Aspect	v2	v3
GroupId	org.jnetpcap	com.slytechs.sdk
Bindings module	jnetpcap-wrapper	jnetpcap-bindings
Protocol packs	protocol-pack-*	sdk-protocol-*
Java version	11+	22+ (FFM)
License	LGPL	Apache 2.0
Native code	JNI	None (pure FFM)

Detailed migration guides will accompany each release.

---

Timeline

• Now: Snapshot builds available for early testing
• 2026: Final releases of jNetPcap 3.0, jNetWorks 3.0, and protocol packs

API is stabilizing but may still change before final release. We encourage early adopters to try the snapshots and provide feedback.

---

Issue Tracking and Discussions

All issue tracking and discussions are consolidated to the main SDK repositories:

• jnetpcap-sdk: https://github.com/slytechs-repos/jnetpcap-sdk
• jnetworks-sdk: https://github.com/slytechs-repos/jnetworks-sdk

Issues and discussions on component repositories (jnetpcap-bindings, sdk-protocol-core, etc.) have been disabled. Please use the SDK repos for all bug reports, feature requests, and questions.

---

Choosing Between jNetPcap and jNetWorks

Use jNetPcap when:

• Single-threaded processing is sufficient
• You want the simplest possible API
• You're building tools, scripts, or moderate-throughput applications
• libpcap performance meets your needs

Use jNetWorks when:

• You need multi-CPU parallel processing
• You're capturing at 10+ Gbps
• You want backend flexibility (upgrade to DPDK/Napatech later)
• You need protocol streams, flow tracking, or token streams

Both share the same protocol stack. Start with jNetPcap, migrate to jNetWorks if you outgrow it.

---

Feedback Welcome

We'd love to hear from the community:

• What protocols are you working with?
• What would make migration easier?
• Any API pain points from v2 you'd like addressed?
• Performance requirements we should know about?

Drop a comment below or open an issue. Your input shapes the release.

---

Thanks for your continued support. We're committed to making network analysis in Java fast, simple, and truly open source.

Mark Bednarczyk
Sly Technologies Inc.
https://www.slytechs.com