zmin - Enterprise JSON Processing Suite

Enterprise-grade JSON processing suite with high-performance minification, streaming transformations, and multi-language bindings. Achieves 5+ GB/s throughput with zero dependencies and memory-safe operation.

Core Components

Component	Throughput	Features	Status
zmin CLI	5.4 GB/s	Minification, streaming, transformations	Production
ZParser Library	200+ MB/s	SIMD parsing, C API, language bindings	Production
v2 Engine	5+ GB/s	Field filtering, schema validation, error recovery	Complete

Platform Support

Architecture	SIMD Support	Operating Systems
x86_64	AVX-512, AVX2, SSE2	Linux, macOS, Windows
ARM64	NEON	Linux, macOS (Apple Silicon)
Runtime Detection	Automatic fallback	All supported platforms

Installation

From Source

git clone https://github.com/hydepwns/zmin
cd zmin
zig build -Doptimize=ReleaseFast

Language Bindings

# Python
pip install ./bindings/python

# Go  
cd bindings/go && go mod tidy

# Node.js
cd bindings/nodejs && npm install

Language Bindings

Performance Comparison

Language	Library	Throughput	Speedup
Python	zparser	192 MB/s	8.2x vs json
Go	zparser	244 MB/s	10.4x vs encoding/json
Node.js	zparser	200 MB/s	8.6x vs JSON.parse

Usage Examples

Python

import zparser
parser = zparser.Parser()
result = parser.parse('{"name": "John", "age": 30}')

Go

import "github.com/yourusername/zparser"
parser, err := zparser.NewParser()
result, err := parser.Parse(`{"name": "John", "age": 30}`)

Node.js

const zparser = require('zparser');
const parser = new zparser.Parser();
const result = parser.parse('{"name": "John", "age": 30}');

Usage

Command Line Interface

# Basic operations
zmin input.json output.json
cat large.json | zmin > minified.json

# v2.0 transformations
zmin input.json --filter "users.*.email,users.*.name"
zmin data.json --validate-schema schema.json --strict-mode
zmin *.json -o minified/ --parallel --turbo-mode

API Overview

API Level	Use Case	Configuration
Simple	Basic minification	Default settings
Advanced	Fine-grained control	Custom config
Streaming	Large files	Chunk-based processing
v2.0	Transformations	Field filtering, validation

Basic Usage

const zmin = @import("zmin");
const output = try zmin.minify(allocator, input);

Advanced Configuration

const config = zmin.Config{
    .optimization_level = .aggressive,
    .memory_strategy = .pooled,
    .chunk_size = 128 * 1024,
};
var minifier = try zmin.AdvancedMinifier.init(allocator, config);
const result = try minifier.minifyWithStats(input);

v2.0 Transformations

const config = zmin.v2.Config{
    .field_filter = &.{ "users.*.email", "users.*.name" },
    .optimization_level = .turbo,
    .enable_schema_validation = true,
};
var transformer = try zmin.v2.Transformer.init(allocator, config);
const result = try transformer.transform(input_json);

Performance Benchmarks

File Size	Throughput	Test Command
1KB	1.8 GB/s	zig build benchmark
100KB	3.2 GB/s	Platform: Apple M1 Pro
10MB	5.4 GB/s	Optimization: ReleaseFast
100MB	5.7 GB/s	SIMD: Auto-detected

Building

Command	Purpose
zig build	Development build
zig build -Doptimize=ReleaseFast	Optimized release
zig build test	Run test suite
zig build test:fast	Quick tests only

Documentation

Resource	Description
API Reference	Complete API documentation
Performance Guide	Optimization techniques
Architecture	System design documents
Examples	Usage examples and demos

Testing

Test Suite	Coverage	Status
Full test suite	84%+	116/116 passing
Fast test suite	Core functionality	Development use
Benchmark suite	Performance validation	Platform-specific

Project Architecture

Core Repository Structure

src/
├── core/         # Minification engine
├── api/          # Simple, Advanced, Streaming APIs  
├── v2/           # Transformation engine (field filtering, validation)
├── minifier/     # SIMD-optimized implementations
├── parallel/     # Work-stealing, chunk processing
├── platform/     # Hardware detection, SIMD operations
└── common/       # Shared utilities, constants

build/            # Modular build system
docs/             # API reference, architecture guides
examples/         # Usage demonstrations
tests/            # Comprehensive test suite
tools/            # Development utilities

Technical Achievements

Feature	Implementation	Status
v2.0 Transformation Engine	Field filtering, schema validation, error recovery	Complete
SIMD Optimization	AVX-512, AVX2, SSE2, NEON with runtime detection	Production
Language Bindings	Python, Go, Node.js with 8-10x speedup	Production
Memory Safety	Zero leaks, comprehensive testing	Verified
Modular Architecture	Standalone libraries, clean interfaces	Complete

Contributing

High-Impact Areas

• Performance optimization (SIMD, memory management)
• Language bindings (new languages, improvements)
• Documentation (examples, guides, API reference)
• Testing (edge cases, performance validation)

Development Setup

git clone https://github.com/hydepwns/zmin
cd zmin
zig build -Doptimize=ReleaseFast
zig build test

Support

Resource	Location
API Documentation	docs/api/
Usage Examples	examples/
Performance Guide	docs/development/PERFORMANCE_TUNING.md
Architecture Guide	docs/architecture/

License

MIT License - see LICENSE for details.

---

Built for enterprise-scale JSON processing with production-grade performance and reliability.