Skip to content

DROOdotFOO/zmin

BranchesTags

Repository files navigation

zmin - Enterprise JSON Processing Suite

CI Status Performance Tests Memory Safety Coverage License Zig

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.

About

Ultra-fast JSON minifier. Multiple performance modes, and cross-platform language bindings.

zmin.droo.foo/

Topics

json performance cross-platform zig simd gpu-acceleration avx2 avx512 parallel-processing zero-dependencies memory-safe numa-aware json-minifier

Resources

Readme

License

MIT license
Activity

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Sponsor this project

Packages

 
 
 

Contributors

Languages