HTAP Database with Predictable Performance
No VACUUM, strict resource contracts. A unified engine replacing complex stacks (PostgreSQL + ClickHouse), isolating transactions and heavy analytics.
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.
Observability 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.
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
Unified Storage Layer
Shared page pool (Buffer Manager), unified WAL, unified indexes. Data is not duplicated between OLTP and OLAP engines.
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. Resource boundaries are strictly controlled by contract, preventing degradation under load. A columnar vectorized (SIMD) engine for large-scale analytics is in active development (v0.7).
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
By the numbers
A preliminary run against PostgreSQL 18.4 on a single VM (Yandex Cloud, 8 vCPU, NVMe) with matched durability settings. We show only what we measured honestly.
~2×
Faster point reads
A point SELECT by key takes 0.46 ms versus ~1.0 ms on PostgreSQL. UNDO-log MVCC gives direct access to the row version without table bloat.
3–4×
Higher insert throughput
At moderate concurrency (up to 8 parallel clients) INSERT runs 3–4× faster than PostgreSQL — key for high-ingest logs and event streams (billing, audit, telemetry).
0
VACUUM windows
UNDO-log MVCC eliminates main-table bloat. No nightly maintenance windows and none of the performance dips that come with them.
HTAP
OLTP stays stable under analytics
A heavy analytical scan doesn't stall transactions: snapshot isolation keeps OLTP stable where a classic stack needs a separate analytical database.
Next priority. A columnar vectorized engine for large-scale analytics and heavy aggregations, plus write-path optimizations under high concurrency, are in active development (v0.7 horizon). The figures above are a preliminary single-VM run; an independent bare-metal benchmark is being prepared for publication.
Comparison
AngaraBase compared to PostgreSQL and Oracle
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 |
Roadmap
Product Roadmap
We show the current readiness of core components and the strategic direction of the product for Enterprise ecosystems.
ALREADY AVAILABLE
Dev Preview & Core Engine
MVCC with UNDO-log, hybrid storage (row + columnar, in-memory and append-only tables), basic PostgreSQL protocol compatibility (pgwire), Linux io_uring integration, automatic query 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
Columnar Analytics, Cloud Native & Distributed Computing
A columnar vectorized OLAP engine (SIMD aggregations, late materialization) with automatic row → columnar materialization for multi-fold acceleration of heavy analytics. Next: JOIN optimization for petabyte-scale data, compute/storage separation (Cloud Native), MPP over a cluster of nodes.
Use Cases
Find your scenario
Pick the closest use case and see the specific problem AngaraBase helps you solve — and how.
Event logging & audit
Pain
High-ingest logs, events and audit trails grow to millions of rows and bloat tables, dragging down maintenance.
Solution
Append-only tables with bounded memory under sustained writes (GC skip), no VACUUM windows, and in-memory tables for fast intermediate reports.
Fintech & banking
Pain
Real-time anti-fraud and scoring compete with transactions for resources; any latency spike costs money.
Solution
HTAP isolation: analytics doesn't stall OLTP. Fast point reads (~2×) for scoring, strict resource contracts, strict ACID consistency and ARIES recovery.
Retail & e-commerce
Pain
Sales spikes drive write peaks on inventory alongside pricing and recommendations; a zoo of OLTP + OLAP systems is costly to run.
Solution
High INSERT throughput at moderate load, a unified storage layer with no ETL or data duplication, analytics on the same data without a separate database.
Telecom & IoT
Pain
Continuous streams of billing events and telemetry must be ingested without degradation while aggregations run in parallel.
Solution
Append-only streams with predictable memory use, HTAP isolation of heavy aggregations from ingestion. Large-scale vectorized analytics is on the roadmap (v0.7).
Oracle / SQL Server migration
Pain
Licensing cost, lock-in and vendor risk push teams to migrate off Oracle and SQL Server.
Solution
PostgreSQL wire compatibility (psql, ORMs, BI tools work as-is), UNDO-log MVCC and ARIES recovery — migration without rewriting applications.
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.