QuillCore LLC
QuillCore LLC  ·  Wyoming, USA  ·  Proprietary Technology

Your Sort Is Wearing
Out Your Hardware

C4 Sort is a proprietary, formally proven integer sorting algorithm that makes fewer writes than any comparison-based sort — guaranteed. License it and immediately reduce compaction cost, extend NVMe lifespan, and cut the write amplification tax from your infrastructure.

Proprietary  ·  Available for commercial licensing

See It In Action License C4 Sort →
Minimum Writes · proven
Zero Comparisons · always
Fully Parallel · lock-free
In-Place · minimal overhead
Scroll
The Problem

Nobody Changed
the Sort

Modern write-heavy databases — built on LSM-tree storage engines — perform continuous compaction: merging and re-sorting data files to maintain read performance. Compaction is fundamentally a sort, and it dominates the write I/O budget of every high-throughput storage system.

The sort algorithms used today were designed decades ago to minimize comparisons. But flash storage doesn't wear out from comparisons — it wears from writes. Every physical write permanently consumes a NAND cell's finite endurance budget. As the industry transitions from TLC to QLC NAND — which offers 3–10× lower endurance per cell — the cost of unnecessary writes is compounding faster than ever.

90–95%
of write I/O in write-heavy LSM systems is attributed to compaction operations — a widely documented production characteristic
10–30×
write amplification commonly measured in production LSM deployments — each logical byte triggers many physical writes
// Write count comparison · same dataset · same result
Traditional Sort
O(n log n) writes
C4 Sort
n writes (minimum)
↓ Structural write reduction — not tuning, not policy
Conventional sort: Write count scales with n log n
Flash endurance: Finite P/E cycle budget per cell, shrinking with density
C4 Sort: Each element written to its final position exactly once
Licensing Opportunities

Your Competitors Will
License This. Will You?

C4 Sort is available for commercial licensing today. If your system runs a sort during compaction, segment merge, ingest flush, or garbage collection — you are paying an unnecessary write tax every single time. That stops the day you license C4 Sort.

Proven Write Reduction
18–23× fewer writes per sort vs comparison-based algorithms — and exactly n writes minimum, formally proven. Not a benchmark claim, a mathematical guarantee.
Drop-In Integration
Replace your sort kernel at the call site. No schema changes, no format migration, no rewrites to surrounding logic. Works within your existing architecture.
Immediate Impact
Write reduction begins with the first sort operation after integration. NVMe lifespan, compaction cost, and I/O overhead all improve from day one — no warm-up period.
Engineering Support Included
Every license includes full integration documentation and direct engineering access through your first production deployment. You are not integrating alone.
Technical Briefing Under NDA
Full algorithm walkthrough with the inventor — proof structure, integration architecture, and performance characteristics on your specific workload profile.
Flexible Royalty Structure
Royalty terms structured to your deployment model — per-unit, per-deployment, or flat platform license. Upcoming architecture ports (x86-64, RISC-V, GPU) can be included at signing.
Your Industry
C4
Sort
5 domains
SEGMENT 01 OF 05
LSM Database Engines
RocksDB · Cassandra · DynamoDB · Bigtable · TiKV
Compaction is the dominant source of write I/O in every write-heavy LSM database — accounting for 90–95% of all physical writes. At its core, compaction is a sort. Replacing the sort kernel is a targeted, low-risk intervention with no schema or format changes required.
Largest near-term opportunity — every high-write database deployment worldwide is affected
Why Now
01 / 05

QLC NAND Adoption

Enterprise fleets are transitioning to higher-density QLC NAND, which carries significantly lower endurance per cell. Every LSM write system on QLC is increasingly exposed to early wear-out. Write efficiency becomes a survival requirement.

02 / 05

Data Volume Growth Outpacing Endurance

Global data creation is growing at ~23% annually. Flash endurance improvements have stalled. The gap between write workloads and hardware capacity to absorb them is widening every year — and the write amplification tax compounds with it.

03 / 05

Infrastructure Cost Pressure

Cloud storage prices have reversed their decade-long decline. FinOps is now a board-level concern at enterprises with $10M+ cloud spend. Engineering teams are actively seeking algorithmic efficiency — not just hardware upgrades.

04 / 05

RocksDB Ecosystem Standardization

RocksDB has become the de facto storage engine for write-optimized databases — DynamoDB, TiKV, CockroachDB, Yugabyte, MyRocks, and Kafka all depend on it. A single compaction kernel integration reaches the entire ecosystem simultaneously.

05 / 05

AI Infrastructure Expansion

The AI buildout of 2023–2025 created a new class of write-heavy workload: vector databases, model checkpoint storage, and LLM serving log pipelines all generate high-frequency writes to the same NVMe hardware — compounding the endurance problem across every tier.

Proven Properties

Four Properties.
Simultaneously.

C4 Sort is formally proven to achieve four properties that no prior published algorithm holds at the same time. Each is independently verifiable — not a benchmark claim, but a mathematical guarantee.

PROVEN
PROPERTY 01
Minimum Element Writes
Each element written to its final position exactly once
Elements already in the correct position are never touched. Every other element moves exactly once — directly to its destination. This is the theoretical write minimum for any in-place sort, previously only achieved at quadratic time cost. C4 Sort reaches it in linear time.
PROVEN
PROPERTY 02
Zero Element Comparisons
No element-to-element comparisons, on any input
The algorithm never compares two elements against each other. Output positions are determined arithmetically before any element moves. This sidesteps the classical comparison lower bound entirely and produces perfectly predictable behavior across all input distributions.
PROVEN
PROPERTY 03
Fully Parallel, Lock-Free
Scales linearly with available cores
Output destinations are pre-assigned to threads with zero overlap before any element moves. Parallel phases run with no locks, no atomics, no contention. Proven: no two threads ever write to the same memory location, regardless of input data.
PROVEN
PROPERTY 04
In-Place & Linear Time
Sorts in-place with minimal auxiliary memory
Operates directly on the input array without merge buffers or output copies — essential for memory-constrained environments. Time complexity is linear in element count. An adaptive variant handles sparse value domains with comparable efficiency at no additional element-write cost.
Prior art: To our knowledge, no previously published algorithm simultaneously achieves minimum writes, zero comparisons, full parallelism, and in-place linear-time execution. Each property exists in isolation across the literature. C4 Sort is the first to hold all four.
How It Works

Every Element.
One Write. One Move.

Watch C4 Sort in action. Each bar represents a value. In Phase 1, the data is surveyed. In Phase 2, every destination is pre-computed. In Phase 3, each element lands in its final position — exactly once, directly.

C4 SORT Click to run Writes: 0 / —
Each element moves to its final position exactly once — no revisits, no comparisons
01
Phase One
Survey
The algorithm reads the entire dataset once to build a complete picture of the input distribution. Nothing moves. No writes occur.
Read-only · zero writes
02
Phase Two
Plan
Every element's exact final destination is computed before anything moves. Thread assignments are resolved. No two elements will ever compete for the same slot.
Zero conflicts · pre-resolved
03
Phase Three
Place
Each element travels directly to its pre-determined destination in a single write. Multiple threads execute simultaneously. Every write is final — no element is touched twice.
One write per element · fully parallel
The Race

Six Algorithms.
One Winner.

The same shuffled dataset. Six of the fastest and most widely used sorting algorithms. Run head-to-head on identical input — and watch the write counters.

Demonstrates write-count behavior on uniform random integer input. All algorithms receive the same data.
Input Size N = 48
C4 Sort: — · Timsort: — · drag to preview
C4 Sort
C4 Sort
QuillCore LLC · Proprietary
Ready
writes: —
aux: —
The Field
Timsort
Python · Java · Android
Ready
writes: —
aux: —
Quicksort
C · C++ · Rust std
Ready
writes: —
aux: —
Merge Sort
Stable · classic
Ready
writes: —
aux: —
Heapsort
In-place O(n log n)
Ready
writes: —
aux: —
Radix Sort
Integer-only LSD
Ready
writes: —
aux: —
Comparison Sorts — Writes Since Page Load
0
~5.2M unnecessary writes/sec  ·  Global LSM compaction estimate
VS
C4 Sort — Writes Since Page Load
0
~260K writes/sec  ·  20× fewer at the same global scale
0 writes saved so far
Applications

Five Infrastructure Domains

C4 Sort's write-minimization advantage applies wherever integers are sorted under write-sensitive conditions — which spans the core I/O path of modern infrastructure.

01
LSM Database Compaction
RocksDB · Cassandra · CockroachDB · TiKV
Compaction is the dominant source of write I/O in every write-heavy LSM database. At its core, compaction is a sort — and replacing the sort kernel is a targeted, low-risk intervention that doesn't touch data structures, schemas, or storage formats. Every high-write database deployment worldwide is affected by this bottleneck.
Drop-in integration path with no schema or format changes required
02
Full-Text Search & Indexing
Elasticsearch · Solr · OpenSearch · Lucene
Lucene-based search engines perform segment merges — sorted integer merges of posting lists — as their primary background I/O workload. The operation is structurally identical to LSM compaction, making a single integration point reachable across thousands of enterprise search deployments.
One integration point reaches thousands of enterprise deployments globally
03
Time-Series Platforms
InfluxDB · TimescaleDB · Prometheus · VictoriaMetrics
Time-series systems sort ingest buffers before every flush to storage. The workload is inherently write-heavy with near-zero updates — and it's one of the fastest-growing infrastructure segments, driven by IoT, observability pipelines, and AI telemetry at scale.
Market growing at 22% CAGR — fastest-expanding segment in the stack
04
Analytical Column Stores
ClickHouse · DuckDB · Snowflake · BigQuery
OLAP systems sort integer columns at ingest before writing to storage. Better sort quality enables better run-length compression — producing smaller files that reduce I/O cost on every subsequent query, compounding the benefit across the full lifetime of stored data.
Compression gains compound across every downstream query
05
NVMe Firmware & Storage
ZNS NVMe · Open-Channel · Computational Storage · BlueStore
Flash Translation Layer garbage collection sorts logical block addresses to coalesce valid pages. Host-managed storage stacks expose this sort as a direct integration point — and block addresses are dense integers, exactly the domain C4 Sort is built for.
Strategic long-term position — sort kernel embedded at the drive level
Development Status

Where We Are

C4 Sort is complete, proven, and available for commercial licensing today. The algorithm's core properties are formally established, the ARM64 implementation is benchmarked, and integration support is included as part of every licensing agreement.

Algorithm formally provenTermination, sortedness, write minimality, and parallel disjointness each independently verified.
Native ARM64 implementationProduction-grade implementation in AArch64 assembly with C parallel runtime. Benchmarked on Apple M-series.
Write-count benchmarksReduction confirmed across multiple distributions. Honest exception: reversed input, where both algorithms achieve n writes.
Performance characterizationWall-time profiling underway across multiple configurations. Write-count advantage is distribution-independent; wall-time scaling depends on parallelism and hardware.
Additional architecture portsCurrent implementation targets one native architecture. Ports to additional platforms are the next development priority.
Production deploymentIntegration paths for leading database and search engines are designed and documented. Included as part of the commercial licensing agreement.
Licensing Tracks
AVAILABLE
Database engine licenseIntegrate C4 Sort as your compaction or merge sort kernel. Includes integration documentation, technical support, and a royalty structure based on deployment scale.
AVAILABLE
Storage firmware licenseEmbed C4 Sort at the FTL or block address sorting layer of your NVMe, ZNS, or computational storage product. Per-unit royalty structure available.
AVAILABLE
Platform / OEM licenseLicense C4 Sort for distribution within your platform, cloud product, or managed service. Covers all downstream customer deployments under a single agreement.
ROADMAP
x86-64 & RISC-V portsNative implementations for additional architectures are in active development. License agreements can be structured to include upcoming ports at signing.
ROADMAP
GPU implementationCUDA/ROCm implementation for analytical database offload and parallel sort acceleration. Available for early licensing discussions with analytical infrastructure teams.
Licensing

Three Ways to
License C4 Sort

C4 Sort is proprietary technology available under commercial license. All license discussions begin with an NDA and a technical briefing. Integration support is included.

🗄️
Software License
License C4 Sort for integration into your database engine, search platform, or time-series system. Use it as a drop-in compaction or merge sort kernel. Royalty structure scales with deployment size.
🔩
Firmware / OEM License
Embed C4 Sort in your NVMe controller, storage firmware, or computational storage product. Per-unit royalty structure available. Reduces write I/O at the hardware layer before software touches it.
🏢
Platform License
License C4 Sort for distribution within your cloud platform, managed database service, or infrastructure product. A single agreement covers all downstream customer deployments at scale.
QuillCore LLC · Wyoming, USA

Start a Licensing Conversation.

If your product sorts integers under write-sensitive conditions — compaction, segment merge, ingest flush, or garbage collection — C4 Sort will reduce that cost structurally. Reach out to start a licensing discussion. A technical briefing is available under NDA.

Tucker Nelson — Founder, QuillCore LLC
tuckernelson@quillcorellc.com
Commercial licensing available · Technical briefing under NDA · Proprietary technology · QuillCore LLC
— The sort that saves your hardware.