What is PON>DB Engine?

PON stands for Positional Object Notation. It is a set of rules, a data normalization protocol, a file format specification, and the RA-CHAMPI algorithm that allows operations performed at the speed that could be obtained by processing the data stored on disk as a direct extension of physical memory.

PON-DB Engine is defined as a "solid-state" database engine encapsulated in a single, portable, and strictly encrypted binary format, designed to treat the data file not as a conventional storage structure, but as a direct extension of physical memory. Its architecture is based on the creation of high-density .pon files, wherein each point of information possesses an exact and predetermined address, thereby eliminating the need for intermediate translation layers or heavyweight relational management systems.

In this same line of thought, we could also see it as an autonomous database, an engine that stores the data, and an analyzer that reads and finds it according to the rules of the algorithm.

PON-DB software is a practical implementation of data-centric computing principles, where the priority shifts from the application to the efficiency, permanence, and autonomy of the data. This paradigm seeks to treat data as the permanent source of value, allowing it to exist independently of applications. In the case of PON-DB, this translates into files that are not simply passive containers, but "intelligent" structures that integrate their own search and encryption engine, enabling O(1) queries without relying on an external or cumbersome database infrastructure.

Under this approach, PON-DB breaks with the traditional CPU-centric model, where data must constantly be moved to the application for processing. Instead, by encapsulating access logic and security directly in the file format (such as the .pon file), it achieves what data-centric computing defines as operational agility and flexibility: data becomes "liquid" and portable. This allows the software (the Reader, which is only 180KB) to act simply as a minimal key to unlock the potential of the data, guaranteeing extreme performance and decentralized security that remains constant regardless of the environment where the information resides.

Read the White Paper

Historically, all database engines have forced you to choose.

Speed vs Security

Fast databases skip encryption. Encrypted databases add latency layers, key management overhead, and external dependencies. You compromise one for the other.

Performance vs Simplicity

High-performance engines need servers, daemons, tuning, DBA expertise, and ongoing maintenance. Simple solutions don't scale. Nothing in between exists.

Portability vs Capability

Embedded databases are limited. Powerful databases require infrastructure. Deploying a capable database to edge, IoT, or air-gapped environments is an unsolved problem.

The Solution

Built different..from scratch By design.

It's the solution, because you get all of that in one product: PON-DB Engine = Speed + Security + Performance + Simplicity + Portability + Capability + flat scaling

Efficiency Benchmarks

See Benchmarks

See Security Testing

Software Features

Seek O(1)

Performance and Scalability Constant-time lookup Algorithm

RA-CHAMPI algorithm resolves key-value reads in O(1) regardless of dataset size. Tested at 100M+ rows with no latency degradation.

Implementation of Seek O(1) index lookup in read-only mode, validated on datasets with over 100 million rows.
The PON-DB Engine can index the top-level fields of JSON files, one field per processing, thus guaranteeing an O(1) search.
Deterministic Indexing: Generation of a single key field per ingestion to guarantee direct and predictable access.
Ultra-Low Latency: Sub-millisecond performance on cold starts and under high-concurrency scenarios.
Zero Query Tuning: Self-optimizing engine that eliminates the need for manual index configuration or database tuning.
Resource Efficiency: Extremely low consumption (<1MB RAM and ~0.1% CPU per query), optimized using Rust Zero-Cost Abstractions.
Operational Immutability: Optimized processing of the original JSON using a post-ingestion read-only state for maximum stability.
Auto-optimization based on CPU/RAM resources. :Dynamic adjustment of search and cache algorithms based on the availability of real-time CPU and RAM telemetry.

AES 256 GCM

Data Security and Protection Military-Grade Encryption

Encryption at rest and in transit, authenticated. No plugins, no external key managers. Every .pon file is encrypted by default.

Native implementation of AES-256-GCM (Authenticated Encryption), guaranteeing the confidentiality and integrity of data both at rest and in transit.
Secure Memory Management (Data Zeroization): Active and guaranteed cleaning of sensitive data in RAM after each operation, mitigating memory inspection or cold boot attacks.
Cryptographic Integrity: Storage designed using cryptographically verifiable structures, allowing data authenticity to be audited at any time.
Architectural Immunity: Robust design against common attacks; by not relying on text interpretation engines, the system is inherently immune to SQL injections and buffer overflows.

Byte-Exact

Data Integrity and Accuracy High-Fidelity Deterministic Engine

Architecture designed to preserve the absolute integrity of the original JSON bytes during processing.
Byte-Exact Reversibility: Guarantee of identical reconstruction of the original data, backed by integrity validation using SHA-256.
Total Flow Transparency: Absolute consistency between input and output; the software guarantees no mutations, loss of numerical precision, or schema changes during the query.
Zero-Copy Deserialization Efficiency: Implementation of intelligent pointers to access data without copying it into memory, maximizing speed and preserving the original structure.

Portability

Portability and Deployment, Single Static Binary

Single, standalone executable compiled for x86-64 architecture (~1 MB).
Zero-Dependency Architecture: Native operation without requiring external libraries, runtimes (such as Java or Node.js), or operating system dependencies.

Compression

Adaptive Compression, Entropy-Based Compression

Size reduction algorithms that dynamically adapt according to the density and repetitiveness of the JSON structure, optimizing storage without sacrificing decompression speed.

Interoperability

Universal Integration via CLI/JSON (Interoperability)

Polyglot Interface: Ability to perform queries and filters using system calls in multiple languages (Python, C, Rust, JavaScript, PHP, Go, etc).
Structured Standard Output: Direct communication via STDOUT in JSON format, enabling immediate and agnostic integration across development ecosystems.

> Check Hardware & System Requirements <

How to use PON-DB Engine:

Example of use with the NYC Taxi 2023 dataset.



Ingest Process  with PON-Engine:
$ ./pon-db-engine 2023_Yellow_Taxi_Trip_Data.json --index=tpep_pickup_datetime 
Index per: ["tpep_pickup_datetime"]...
PON file saved as: 2023_Yellow_Taxi_Trip_Data.json.pon 
Key saved as: masterkey_jCGndDBJ_2026-03-15.bin 
PON-DB GREEN COMPLIANCE INGEST REPORT (V8.6)
TIMESTAMP: 2026-03-26 21:29:37
STATUS: VERIFIED (GREEN)
ROWS PROCESSED: 38,310,226
TIME ELAPSED: 1433.909838 seconds
THROUGHPUT: 26717.32 rows/sec
INTEGRITY:
ORIGINAL SIZE: 18489371731 bytes
FINAL SIZE:     20268269745 bytes
md5sum 2023_Yellow_Taxi_Trip_Data_20260312.json
ed80168b4309347067a5835510554582
md5sum 2023_Yellow_Taxi_Trip_Data_20260312.json.pon
4118b0a2987c79315393be4156cb0caf
-------------
Query Process with PON-Reader:
# Initiating query...
$ time ./pon-db-reader 2023_Yellow_Taxi_Trip_Data_20260312.json.pon query "tpep_pickup_datetime=tpep_pickup_datetime=01/01/2023 12:40:36 AM" --key=masterkey_irBqC5yW_2026-03-26.bin --nomsg

 
{"VendorID": "2", "tpep_pickup_datetime": "01/01/2023 12:40:36 AM", "tpep_dropoff_datetime": "01/01/2023 12:45:03 AM", "passenger_count": "1", "trip_distance": "0.85", "RatecodeID": "1", "store_and_fwd_flag": "N", "PULocationID": "237", "DOLocationID": "263", "payment_type": "1", "fare_amount": "5.8", "extra": "1", "mta_tax": "0.5", "tip_amount": "2.16", "tolls_amount": "0", "improvement_surcharge": "1", "total_amount": "12.96", "congestion_surcharge": "2.5", "airport_fee": "0"}

real    0m0.020s
user    0m0.016s
sys     0m0.004s

█

Download the original dataset and compare! : NYC Yellow Taxi 2023 – Data.gov

How to use PON-Engine / Reader complete guide

How conect PON-Reader with Python, Go and Node: Complete Guide

Why Buy PON-DB Engine right now?

PON-DB Engine is the definitive solution for achieving speed, security, and maximum portability in any environment, from high-end servers to embedded hardware.

Devices where PON-DB Engine can operate

IoT & Edge

(ESP32, Gateways, Sensors)

Every MB of RAM counts: where other software consumes it, it drains the battery quickly..
Real-time telemetry with military-grade encryption, without cloud dependency.

Air-Gapped & High Security

(Gov, Forensics, Healthcare)

Compliance (NIS2, HIPAA) requires encryption + integrity without external dependencies.
Immunity to SQL injection and zero-trust architecture by design.
AES-256-GCM + Zeroization

E-commerce & Catalogs

(100k–100M products)

Stop paying for Elasticsearch clusters for simple product lookups.
Sub-millisecond responses without the 4GB RAM overhead of traditional DBs.

Limited Hardware & Scale

(Cheap VPS, Embedded, JSON Scale)

No need to choose between speed and encryption on low-end hardware.
Process millions of JSON files without making the system slow or expensive.

Want to see real-world examples of PON-DB applications you can deploy in minutes? Learn More

PON-Gateway Engine

The Hyper-Optimized Native Layout for Blockchain Historical Indexing

Extreme Stress & Security Benchmark

Dataset: 70 million historical Ethereum contracts (35 GB total file size).,source:Zellic/Huge

Operation: Relational Join, bytecode retrieval, parsing, structured JSON standard disassembly, and cryptographic selector identification on the fly.

[Request]

│

▼

[1. Row-Level AES-256-GCM] ──► Hardware-accelerated decryption

│

▼

[2. Relational Join] ──► On-the-fly contract metadata join

│

▼

[3. Bytecode Retrieval] ──► EVM binary extraction

│

▼

[4. EVM Disassembly] ──► Opcode conversion (PUSH, MSTORE, etc.)

│

▼

[5. Selector ID] ──► Cryptographic signature extraction (Keccak-256)

│

▼

[6. Structured JSON] ──► Serialization and JSON output to stdout

>>> Only 25ms end to end!!!

Security (Zero-Trust): Row-level encryption with AES-256-GCM at rest and strict locking mechanisms (ASN Lock, IP Lock, Hardware Lock) that render the data file useless upon any network or physical extraction.

Core Performance Overview

Under a 30-minute continuous heavy-workload test executing complex, real-time forensic requests (35 GB encrypted database search, row-level AES-GCM decryption, EVM bytecode disassembly, and JSON formatting):

Total Requests Processed: 6,550,608 (over 6.55 million transactions)

Success Rate: 100% (0 errors / 0 timeouts)

Sustained Throughput: ~3,640 Requests Per Second (RPS)

Latency Profile:

P50 (Median): 25.29ms

P90: 34.41ms

P99: 63.67ms

Zero Memory Degradation (No Memory Leaks):

Across all tests, including over 8.7 million accumulated queries and 44+ minutes of total CPU active time, memory usage remained pinned at ~8.2 MB RES .

RAM Footprint: Consumes less than 0.04% of total system memory on a basic 24 GB RAM host.

Extreme Hardware Efficiency:

Executed on a modest 4-core Intel Xeon processor utilizing roughly 1.5 cores (156% CPU usage) to sustain over 3640 RPS.

The host CPU maintained ~30% idle capacity with a steady Load Average of 2.66 – 3.78, eliminating kernel thread contention and queue backups.

Deterministic Latency & Stability:

Throughput variance between the 10-minute and 30-minute stress tests was negligible (0.23%), proving complete immunity to buffer bloat, socket exhaustion, or Garbage Collection pauses.

Projected capacity reaches ~314 Million forensic transactions per day on a low-cost single-node server.

Value Proposition

The ROI Argument:PON-DB and PON-GATEWAY deliver industrial-grade crypto-forensic disassembly and row-level AES decryption at millisecond latency using 95%+ less RAM than traditional microservices (Node.js/Python/Go + SQL). This translates directly to an 80% to 90% reduction in Cloud infrastructure costs without sacrificing reliability or speed.

verified VirusTotal Verdict (AI Audit)

After an exhaustive analysis of behavior in the Sandbox, the world's leading platform certifies:

"The sample is a legitimate proprietary commercial tool... exhibits heavy use of DRM and anti-tamper mechanisms for data integrity and decryption."
- Behavioral Analysis Report 2026

Status: 0/60 Undetected (Malware Clean).

keyboard_lockProtection Engineering

Hardware-Locking: Unique linkage through Product_UUID y CPU_Info for permanent licenses.
Native Cryptography: Using extensions AES-NI y SHA-256 integrated into the silicon for maximum speed.
Data Sovereignty: 100% Standalone. No outgoing network connections. (Network: NOT FOUND).

Pricing

Permanent license per ASN / IP Range Forever.

Unlimited Instances for your customers.

Standard $999 for a range of 256 IPs

PON-Gateway v2.0

VersiOn ASN / IP Range lock for Hosting / Cloud providers

Pay once and save on perpetual cloud bills. No subscriptions!

Seek O(1)Key Value Read Mode no latency penalty for encryption
Native AES-256-GCM encryption by row
Deterministic Indexing,a single key field per ingestion to guarantee direct and predictable access
Up to 100 million records per JSON/JSONL/CSV file are processed in a .pon file, regardless of file size.
Zero Query Tuning
Architectural Immunity to SQL injections and buffer overflows
Secure Memory Management (Data Zeroization)
Extremely low consumption using Rust Zero-Cost Abstractions
Single, standalone executable compiled for x86-64 architecture (~1 MB)
Zero-Dependency & Zero Trust Architecture
Index Field Entropy-Based Compression
Unlimited instances in the same machine
Universal Integration via CLI/JSON
Support by email

* You can process as many JSON files as you want, as long as the file size does not exceed 100 million records.

*You can activate all instances and APIs that your hardware capacity allows on each machine within the respective IP range.

PON-DB & PON-Gateway

~0.05ms

< 0.1%

1.8MB

100M+