🎉 Now on Maven Central

Lamco NetKit

Kotlin Libraries Built for Real Network Analysis

Platform-independent Kotlin libraries for network diagnostics and WiFi optimization. The same foundation that powers WiFi Intelligence, now open source for the entire Kotlin ecosystem.

Browse on Maven Central → View on GitHub

Apache 2.0 Licensed | JVM + Android + iOS (KMP) | Zero Platform Dependencies

WHY WE BUILT THIS

The Libraries We Needed Didn't Exist

When building WiFi Intelligence, we searched for Kotlin libraries to handle network diagnostics. We needed ping testing with cross-platform output parsing. We needed traceroute with hop-by-hop analysis. We needed WiFi channel optimization algorithms.

We found nothing production-ready. The Kotlin ecosystem had basic connectivity checks. Ad-hoc implementations in blog posts. Android-only solutions tied to platform APIs. No comprehensive, platform-independent networking framework.

So we built it ourselves. 10 platform-independent modules. Interface-based architecture. 3,561+ automated tests. Now we're releasing it as open source - the Kotlin networking toolkit that should have existed all along.

Who Is NetKit For?

From Android apps to backend services - production-grade networking for everyone

ANDROID DEVELOPERS

Build Better Network Features.

Stop Reinventing. Start Shipping.

Building a WiFi analyzer? Speed test app? Network monitoring tool? NetKit provides the foundation - ping testing, bandwidth measurement, WiFi analytics. Battle-tested in WiFi Intelligence with thousands of real users.

  • Drop-in network diagnostics
  • WiFi optimization built-in
  • 3,561+ automated tests
BACKEND DEVELOPERS

Network Diagnostics for Your Services.

Monitor. Diagnose. Optimize.

Need network health checks in your JVM backend? API endpoint monitoring? Infrastructure diagnostics? NetKit runs anywhere Kotlin does - servers, cloud functions, desktop apps. Platform-independent, coroutine-based, production-ready.

  • Server health monitoring
  • API endpoint latency tracking
  • Network path analysis
KOTLIN MULTIPLATFORM

Platform-Independent By Design.

Write Once. Run Everywhere.

NetKit is built platform-independent from day one. Zero Android dependencies. JVM-ready today, KMP-ready for iOS and JavaScript tomorrow. Interface-based architecture makes platform-specific implementations simple.

  • JVM, Android, iOS (KMP roadmap)
  • Interface-based for easy adapters
  • Share code across all targets
THE TECHNOLOGY

Production-Tested, Battle-Hardened

These aren't toy libraries. They power WiFi Intelligence in production with thousands of real users.

7

Maven Modules

3,561+

Automated Tests

92%

Test Coverage

Zero

Platform Deps

100%

KDoc Coverage

Cross-Platform Ping Testing

Parses Linux, Windows, and macOS ping output automatically. Get latency stats, packet loss, and jitter calculations without platform-specific code.

Coroutine-Based Async Execution

Run multiple diagnostics in parallel with Kotlin coroutines. Orchestrate complex test suites with progress callbacks and timeout handling built-in.

WiFi Channel Optimization Algorithms

Sophisticated RF algorithms for multi-AP channel planning, DFS assessment, and interference analysis. The same algorithms used in WiFi Intelligence Pro Engineer tier.

Interface-Based Architecture

All executors are interfaces - PingExecutor, TracerouteExecutor, BandwidthTester. Swap implementations, mock for testing, adapt to any platform without changing your code.

Comprehensive Documentation

100% KDoc coverage on public APIs. Usage examples in every interface. Generated Dokka HTML documentation. Quick start guides and real-world code samples.

Standards-Based Algorithms

IEEE 802.11 channel planning, RFC 6349 bufferbloat detection, ITU-T performance metrics. Textbook RF principles, no proprietary magic.

GET STARTED

Add NetKit to Your Project in 30 Seconds

// build.gradle.kts
// NetKit from Maven Central (no repository configuration needed!)
dependencies {
    // Core functionality (required)
    implementation("io.lamco.netkit:core:1.0.1")

    // Optional modules - add as needed
    implementation("io.lamco.netkit:analytics:1.0.1")      // Data analysis & visualization
    implementation("io.lamco.netkit:diagnostics:1.0.1")    // Active network testing
    implementation("io.lamco.netkit:export:1.0.1")         // Multi-format export
    implementation("io.lamco.netkit:intelligence:1.0.1")   // ML recommendations
    implementation("io.lamco.netkit:security:1.0.1")       // Security analysis
    implementation("io.lamco.netkit:wifi-optimizer:1.0.1") // Optimization
}

Quick Example: Run a Ping Test

import io.lamco.netkit.diagnostics.executor.PingExecutor
import io.lamco.netkit.diagnostics.model.PingTest

suspend fun checkLatency(executor: PingExecutor) {
    val result = executor.executePing(
        targetHost = "8.8.8.8",
        packetCount = 10
    )

    println("Latency: ${result.avgRtt}")
    println("Packet Loss: ${result.packetLossPercent}%")
    println("Quality: ${result.latencyQuality}")
}

Three Modules. Endless Possibilities.

Pick what you need. Leave what you don't.

FOUNDATION

NetKit Core

WiFi Models. RF Analysis. Topology Detection.

The foundation module every other NetKit library depends on. WiFi band enumerations (2.4/5/6 GHz), channel width models (20-320 MHz), WiFi standard definitions (802.11a through WiFi 7), and RF signal quality analysis.

io.lamco.netkit:core:1.0.1

Example: WiFi Band Detection

import io.lamco.netkit.core.WiFiBand
import io.lamco.netkit.core.WifiStandard

val band = WiFiBand.BAND_5GHZ
val standard = WifiStandard.WIFI_6
println("${standard.displayName} on ${band.frequencyRange}")

Example: Ping with Stats

import io.lamco.netkit.diagnostics.*

val executor = JvmPingExecutor()
val result = executor.executePing(
    targetHost = "8.8.8.8",
    packetCount = 10
)

println("Min/Avg/Max RTT: ${result.minRtt}/${result.avgRtt}/${result.maxRtt}")
println("Packet Loss: ${result.packetLossPercent}%")
NETWORK TESTING

NetKit Diagnostics

Ping. Traceroute. Bandwidth. DNS.

Comprehensive network testing framework with cross-platform output parsing (Linux, Windows, macOS), coroutine orchestration, and professional result models. The same diagnostics engine that powers WiFi Intelligence's active testing.

io.lamco.netkit:diagnostics:1.0.1
RF OPTIMIZATION

NetKit WiFi Optimizer

Channel Planning. DFS. Interference Analysis.

Sophisticated WiFi optimization algorithms for multi-AP networks. Auto channel planning, DFS risk assessment, channel width recommendations, and QoS analysis. Industry-grade RF engineering, open source for the first time.

io.lamco.netkit:wifi-optimizer:1.0.1

Example: Channel Planning

import io.lamco.netkit.optimizer.*

val planner = AutoChannelPlanner()
val plan = planner.planChannels(
    apClusters = myAccessPoints,
    constraints = ChannelPlanningConstraints(
        band = WiFiBand.BAND_5GHZ
    )
)

println("Optimal channels: ${plan.assignments}")
println("Plan score: ${plan.score}/100")
DATA ANALYSIS

NetKit Analytics

Time Series. Correlation. Visualization.

Advanced data analysis and visualization for network metrics. Time series analysis, correlation detection, distribution analysis, and RF heatmap generation. Turn raw WiFi data into actionable insights.

io.lamco.netkit:analytics:1.0.1

Example: Signal Strength Analysis

import io.lamco.netkit.analytics.*

val analyzer = SignalAnalyzer()
val analysis = analyzer.analyzeSignalTrend(
    measurements = signalHistory
)

println("Trend: ${analysis.trend}")
println("Stability: ${analysis.stabilityScore}")

Example: Multi-Format Export

import io.lamco.netkit.export.*

val exporter = NetworkDataExporter()

// Export to CSV for spreadsheets
exporter.exportToCSV(data, "network_scan.csv")

// Export to PDF for reports
exporter.exportToPDF(data, "network_report.pdf")
REPORTING

NetKit Export

CSV. JSON. PDF. Markdown. HTML.

Multi-format data export for professional reporting. Generate CSV for spreadsheets, JSON for APIs, PDF reports, Markdown documentation, HTML dashboards, GeoJSON for mapping, and KML for Google Earth.

io.lamco.netkit:export:1.0.1
MACHINE LEARNING

NetKit Intelligence

Predictions. Anomalies. Recommendations.

ML-based network intelligence and predictions. Anomaly detection, performance prediction, optimization recommendations, pattern recognition, and trend analysis. Smart insights from your network data.

io.lamco.netkit:intelligence:1.0.1

Example: Performance Prediction

import io.lamco.netkit.intelligence.*

val predictor = PerformancePredictor()
val forecast = predictor.predictPerformance(
    historicalData = networkMetrics
)

println("Expected throughput: ${forecast.throughput}")
println("Confidence: ${forecast.confidenceLevel}")

Example: WPA3-SAE-PK Detection

import io.lamco.netkit.security.*

val analyzer = SecurityAnalyzer()
val assessment = analyzer.analyzeNetwork(
    network = wifiNetwork
)

println("Security: ${assessment.securityRating}")
println("Has SAE-PK: ${assessment.hasSaePk}")
println("Recommendations: ${assessment.recommendations}")
SECURITY ANALYSIS

NetKit Security

WPA3-SAE-PK. PMF. Threat Detection.

Comprehensive WiFi security analysis with industry-first WPA3-SAE-PK detection. PMF validation, security protocol rating, vulnerability detection, encryption strength analysis, and actionable security recommendations.

io.lamco.netkit:security:1.0.1
PROOF OF CONCEPT

See NetKit in Action

Want to see what NetKit can do? Download WiFi Intelligence - our professional WiFi analysis app built entirely on these open source libraries.

Every ping test, every channel recommendation, every diagnostic feature in WiFi Intelligence runs on NetKit. The app is our reference implementation showing the full power of these libraries.

netkit:core

WiFi models, RF analysis, topology

netkit:diagnostics

Active testing framework

netkit:wifi-optimizer

Channel planning algorithms

See WiFi Intelligence →

Open Source. No Strings Attached.

Apache 2.0 License

Use NetKit in any project - personal, commercial, proprietary, or open source. No attribution required (though appreciated). No royalties. No license fees.

Commercial use allowed
Explicit patent grant included
Modification and redistribution permitted

Community Contributions Welcome

Found a bug? Have a feature idea? Want to add iOS support? We welcome contributions. NetKit improves when the community improves it.

Issues and PRs reviewed within 48 hours
Contributors highlighted in release notes
Full CONTRIBUTING.md guide available

Ready to Build?

Add NetKit to your Kotlin project and start shipping better networking features today.

Browse Maven Central → View on GitHub →

Questions? Email greg@lamco.io or open an issue on GitHub