Article on Habr: How we built a vectorized engine →

HTAP Database with Predictable Performance

No VACUUM, strict resource contracts. A unified engine replacing complex stacks (PostgreSQL + ClickHouse), isolating transactions and heavy analytics.

GitHub Learn More

Architecture

A Unified System for Two Worlds

Replaces stacks of transactional and analytical databases (e.g., PostgreSQL + ClickHouse or Oracle + Greenplum). Execute transactions and heavy analytics on the same data without replication or delays.

OLTP

Transactional Engine

MVCC isolation, Raft replication, row-storage for point queries

OLAP

Analytical Engine

Columnar storage, vectorized execution, real-time aggregations

Unified Storage Layer

Shared page pool (Buffer Manager), unified WAL, unified indexes. Data is not duplicated between OLTP and OLAP engines.

Explore architecture details

Capabilities

Key Features

Architectural decisions that distinguish AngaraBase from classic databases.

Maximum Performance

Deep integration with Linux (io_uring) squeezes the maximum out of NVMe drives for heavy I/O. Vectorized execution (SIMD) radically accelerates analytics. Resource boundaries are strictly controlled by contract, preventing degradation.

MVCC & Transaction Isolation

Snapshot isolation with full undo-log. Multi-version concurrency control without read locks.

Hybrid Storage

Hot data in row format for fast transactions, historical data in columnar format. Automatic table partitioning on the fly.

Memory-safe Architecture

Rust core guarantees no data races and undefined behavior at the compiler level — without GC pauses.

Technology

Why Rust?

For a database system, the implementation language is not an implementation detail, but an architectural decision.

No GC Pauses

Rust's ownership model eliminates Stop-The-World garbage collector pauses, critical for OLTP transaction latency.

Memory Safety

Borrow checker prevents use-after-free, double-free, and data races at compile time — with no runtime overhead.

C/C++ Level Performance

Zero-cost abstractions allow writing high-level code without losing performance on critical paths.

Async-runtime and Concurrency

Tokio async runtime ensures efficient handling of thousands of concurrent connections without context-switch overhead.

// MVCC transaction manager (AngaraBase)
pub struct TransactionManager {
    mvcc_store: Arc<MvccStore>,
    undo_log: UndoLog,
    raft_node: RaftNode,
}

impl TransactionManager {
    pub async fn begin_txn(
        &self,
        isolation: IsolationLevel,
    ) -> Result<Transaction> {
        let ts = self.mvcc_store
            .next_timestamp().await?;
        Ok(Transaction::new(ts, isolation))
    }
}

Transaction engine snippet — technical details and specs available on GitHub

Performance

Real Benchmarks: 3.1× TPS and 2.67× on Analytics

Vectorized execution of analytical queries (SIMD) and deep integration with Linux io_uring provide multiple-fold acceleration without degrading OLTP.

High performance without magic

Our results are backed by a detailed methodology. On our testbed (NVMe, 16 vCPU, Linux), AngaraBase delivers 3.1× TPS (453 vs 146 for PostgreSQL 18) with predictable latency (p99 < 1 ms), while accelerating GROUP BY aggregations up to 2.67× thanks to the vectorized engine.

p99 < 1 ms SIMD io_uring

3.1× TPS
2.67× GROUP BY

vs PostgreSQL 18

Comparison

AngaraBase vs Classic DBs

Architectural differences from traditional transactional and commercial databases. A direct path to modernization without performance loss.

Feature	PostgreSQL	Oracle	AngaraBase
MVCC Model	Heap MVCC + vacuum	UNDO (commercial)	UNDO-log MVCC
Maintenance Windows	Regular VACUUM	Background tasks	No VACUUM
OLTP/OLAP Isolation	None (needs ClickHouse)	Resource Manager	Strict contracts (Fail-closed)
Resource Limits	Soft, advisory	Resource Manager	Hard, per-component
Language	C	C / C++	Rust
Recovery	WAL + checkpoint	ARIES-like	ARIES (Analysis → Redo → Undo)
Observability	Third-party exporters	Enterprise tools	Metrics + SQLSTATE + USDT
Platforms	All major OS	All major OS	Linux-only (by design)
Network Protocol	pgwire (native)	OCI / TNS	pgwire (100% compatible)
Origin	Global (Source Available)	USA	Independent development

Economics (TCO)

Radical Total Cost of Ownership Reduction

Instead of three systems (e.g., transactional DB + analytical warehouse + ETL bus) — just one. This eliminates the technological "zoo", drastically reducing hardware, licensing, and operations team costs.

Eliminating ETL Pipelines

Data is ready for analytics the moment a transaction commits. No more setting up and maintaining fragile data transfer processes (Kafka, Debezium, Airflow).

Eliminating Duplication

In classic schemas, the same data is stored in OLTP and duplicated in the OLAP warehouse. AngaraBase uses a unified storage layer, saving terabytes of disk space.

Consolidating Expertise

Instead of looking for rare specialists to support a stack of 3-4 heterogeneous tools, the team administers and backs up just one reliable system.

Isolation: One File per DB

Multi-database architecture allows keeping multiple databases in one instance. Each is a separate file, simplifying migration and allowing independent backups.

No Maintenance Windows

UNDO-log MVCC completely eliminates main table bloat. You will forget about performance degradation and nightly VACUUM operations forever.

Transparency without "Magic"

Built-in USDT probes and wait events subsystem allow seeing through the engine state. Troubleshooting becomes an engineering process, not guessing.

Efficient Backups

Fast physical replication and backups are based on the unified WAL change stream. This reduces I/O load and radically cuts recovery time.

Roadmap

Plans and Transparency

Transparency in architectural development is the foundation of trust. We openly broadcast the current readiness of core components and the strategic product vector for Enterprise ecosystems.

ALREADY AVAILABLE

Dev Preview & Core Engine

MVCC with UNDO-log, hybrid storage (Row + Columnar), basic PostgreSQL protocol compatibility (pgwire), Linux io_uring integration, SIMD vectorization of complex analytical queries, automatic routing (OLTP vs OLAP).

IN PROGRESS

HA & Fault Tolerance

Raft replication for strict consistency and automatic failover. Zero Data Loss mechanisms for critical Enterprise applications.

PLANNED

Cloud Native & Distributed Computing

Deep optimization of JOIN operations for petabyte-scale data. Separation of compute and storage (Cloud Native architecture), MPP (Massively Parallel Processing) over a cluster of nodes.

Use Cases

Industry Solutions

AngaraBase architecture solves fundamental performance problems in Data-intensive industries.

Financial Sector

High-speed transaction processing (Core Banking) with instant anti-fraud analysis and real-time risk scoring. Strict ACID consistency.

Retail & E-commerce

Inventory management under high load (sales), with simultaneous calculation of dynamic pricing and product recommendations.

Telecom & IoT

Processing massive continuous streams of billing events and telemetry with parallel heavy data aggregation without insert degradation.

Status: Dev Preview

Closed Pilot for Early Adopters

We are currently inviting a limited number of tech-forward teams to conduct pilots. You will get direct access to the core development team and can influence the product roadmap.

partner@angarabase.com