We benchmarked SQLite, ObjectBox, and ToStore for On-Device RAG in Flutter: 5-dimension results & architecture comparison

Flutter On-Device RAG and Vector Search Deep Dive: SQLite, ObjectBox, or ToStore? A 5-Dimension Benchmark and Selection Guide

Executive Summary: With the explosive maturation of On-Device Small Language Models (SLMs), building offline private knowledge bases, intelligent code copilots, and local Retrieval-Augmented Generation (RAG) pipelines has become a primary architecture initiative for Flutter applications in 2026. However, edge-constrained memory, strict low-latency expectations, and the engineering complexity of multi-modal hybrid retrieval push traditional local databases to their architectural breaking points.

Following months of rigorous benchmarking and production prototyping, our mobile architecture team evaluated the three most prominent local database solutions in the Flutter ecosystem: SQLite (sqflite/sqlite-vec), ObjectBox, and ToStore. Here is an objective, comprehensive 5-dimension benchmark and architectural deep dive to guide your on-device hybrid retrieval decisions.

---

1. Why On-Device RAG in Flutter Became an Engineering Battlefield in 2026

For a long time, building mobile and desktop AI applications followed a standard pattern: the client app only captured user prompts, dispatched them over the network to cloud LLMs and cloud vector databases, and waited for streaming responses.

By 2026, advances in mobile NPU computing power and the maturity of on-device lightweight models have driven more and more business scenarios to require pushing both model inference and knowledge retrieval entirely to the client device:

1. Absolute Data Privacy and Compliance: Healthcare follow-ups, enterprise collaboration, and personal journals strictly forbid uploading sensitive user data to the cloud;
2. Weak-Network and Fully Offline Operation: Automotive systems, outdoor field tablets, aviation, and subterranean facility management must guarantee zero network dependency;
3. Sub-Millisecond Zero-Latency and Token Cost Savings: As active users scale from tens of thousands to tens of millions, cloud vector storage and inference token overhead escalate rapidly. Offloading high-frequency private knowledge retrieval to client devices yields massive cost and latency dividends.

However, moving RAG (Retrieval-Augmented Generation) directly to the Flutter edge immediately confronts three hard technical barriers:

1. The Fatal Flaw of Single-Channel Dense Vectors: Semantic Drift

A frequent first reaction among developers is: “Let's compute 384-dimensional embeddings locally and run a cosine distance search in Dart.”

While this works in toy demos, it quickly triggers user complaints under real production workloads:

• When a user searches for “iPhone 15 Pro Max battery capacity”, embedding-based retrieval often pulls up chunks discussing “Huawei Mate 60 battery endurance” or “iPhone 14 chargers” because in high-dimensional vector space, their cosine similarity centers around the broad semantic topic of "high-end smartphone battery".
• When a user searches for specific error codes (e.g., ERR_CONN_REFUSED_403), API class names, or part numbers/SKUs, dense vectors completely lose focus on the exact keywords, resulting in severe semantic drift.

Conclusion: Industrial-grade edge RAG requires a multi-way hybrid recall pipeline: Dense Vectors (semantic recall) + BM25 Full-Text Search (exact lexical recall) + Neural Sparse Vectors (SPLADE fine-grained features), fused and reranked on a single execution path.

2. Strict Edge Memory and Cold-Start Latency Requirements

Cloud servers boast hundreds of gigabytes of RAM where vector indexes can sit comfortably, but mobile operating systems (iOS / Android) enforce strict process resident memory thresholds. A memory-heavy HNSW index can easily breach system limits when loading 500,000 vectors, triggering an Out-Of-Memory (OOM) termination in the background.

Even more critical is cold-start latency: users expect apps to become interactive within 1 to 2 seconds. If a local database takes tens of seconds or half a minute to load indexes or restore states, the OS will flag an ANR (Application Not Responding) crash or forcefully terminate the app.

3. The Fragmentation and Stitching Overhead of Multi-Modal Data

Edge knowledge base chunks always carry rich operational metadata:

• “Only search vector semantics within chunks where user_id = 9527 AND category = 'finance'”
• If the database does not support a unified pipeline combining structured predicate filtering with vector and text retrieval, developers are forced to query IDs via SQL first, deserialize tens of thousands of rows into Dart memory, and manually iterate through vector arrays. This bloats code and causes severe performance drops.

---

2. Cross-Sectional Architectural Overview: How the Contenders Stack Up

To solve these bottlenecks, we conducted an empirical selection across the three most representative database options in the Flutter ecosystem:

Evaluation Dimension / Core Capability	SQLite (sqflite)	ObjectBox	ToStore
Architectural Model	Traditional single-node relational database	Lightweight object NoSQL database	Edge-distributed multi-modal engine
Dense Vector ANN Search	❌ No native index (CPU-bound scans cause jank)	⚠️ Native HNSW (Heavy indexing / High RAM overhead)	✅ Native proprietary NGH index (High QPS / Low latency)
Full-Text Search (BM25/FTS)	⚠️ Supports FTS5 (Collapses under high concurrent load)	❌ Not supported natively	✅ Built-in BM25 full-text search (Stable at scale)
Neural Sparse Vector (SPLADE)	❌ Not supported	❌ Not supported	✅ Native support (Crucial for technical terms and entities)
Multi-Way Hybrid Fusion	❌ Requires complex manual stitching	❌ Not supported	✅ Chained 1-line multi-way weighted fusion (Weighted/RRF)
High-Performance KV Store	Manual table emulation required (Heavy, no TTL)	Supported (No lifecycle eviction mechanism)	✅ Native built-in (Supports relative/absolute TTL, Multi-Space)
Schema Evolution	Painful manual ALTER TABLE scripts (Prone to crashes)	Basic object property mapping	✅ Proprietary: Declarative zero-downtime online evolution
Multi-Space Data Isolation	❌ Requires maintaining multiple DB files	❌ Not supported	✅ Native support (1-line switching and global sharing)
Systematic Data Governance	Relational constraints / No built-in eviction	❌ Weak constraints / No built-in eviction policies	✅ Complete constraints + Cascading FK + TTL/LRU eviction
Ultra-Large Scale & Cold Start	❌ 10M cold start exceeds 30s	❌ OOM crash above 5M records (27s cold start)	✅ 1 Billion scale verified (Constant ~35ms cold start)

Contender A: SQLite / sqflite (The Traditional Relational Veteran)

• Background: Written in C, SQLite is the perennial mobile standard, commanding the largest Flutter user base via the sqflite plugin.
• On-Device RAG Bottlenecks:
  • Native SQLite does not support vectors. Existing workarounds rely on FFI wrappers like sqlite-vec (which add brittle cross-compilation hurdles across iOS, Android, Windows, and macOS) or manual Dart loops calculating cosine distance.
  • Once vector collections reach tens of thousands of items, brute-force Dart loops pin CPU cores and cause severe thermal throttling and UI stutter.
  • While SQLite supports FTS5 full-text search, unifying lexical scores with vector distance metrics requires bespoke SQL and complex normalization glue code.

Contender B: ObjectBox (The High-Speed NoSQL Store)

• Background: Powered by a C++ core, ObjectBox uses FlatBuffers serialization to achieve rapid read and write speeds.
• On-Device RAG Bottlenecks:
  • ObjectBox introduced HNSW-based vector search, which performs reliably on small datasets. However, as edge application complexity rises, its architectural limits become apparent:
  • No Native Full-Text Search: ObjectBox lacks built-in inverted text indexing or BM25 search. Lexical keyword recall requires an external search component;
  • In-Memory Graph Overhead and Capacity Bottlenecks: HNSW graphs must remain fully resident in RAM. As data expands, memory consumption triggers OOM crashes and degrades cold-start times;
  • Lack of Advanced Governance and Complex Querying: Being a lightweight object store optimized for single-object persistence, it lacks complex relational join queries (JOIN), built-in eviction policies (TTL / LRU), and cascading foreign key checks;
  • No Support for Neural Sparse Vectors, with no mechanism to execute multi-way weighted recall and fusion in a unified query chain.

Contender C: ToStore (The Unified Multi-Modal Engine)

• Background: ToStore has been publicly published and continuously evolved in the Flutter / Dart community for 3 years, earning widespread adoption and active community support through its robust architecture and outstanding performance.
• Core Strengths:
  • All-in-One Multi-Modal Engine: Natively supports relational columns, dense vector fields (Dense Vector), BM25 full-text search fields (Text), and neural sparse vector fields (Sparse Vector) within the same table schema.
  • Complete Enterprise Data Governance: Natively supports non-null constraints (nullable: false), range validations, unique indexes, cascading foreign keys (ForeignKeySchema), complex multi-table joins (JOIN), and aggregations, enforcing data integrity at the engine level.
  • Chained Hybrid Retrieval Out of the Box: Chained APIs (matchVector, matchText, matchSparse, whereEqual) handle attribute filtering, multi-way recall, and score fusion (supporting normalized weightedScore and reciprocal rank fusion rrf) in one call.
  • Online Schema Evolution: Eliminates the nightmare of manual ALTER TABLE migrations and database version increments (Version 1->2->3). ToStore updates declarative schemas online in the background without service interruption.
  • Native Multi-Space Data Isolation: A single database instance supports seamless tenant and user switching (db.switchSpace(spaceName: 'user_123')) while allowing global data sharing (isGlobal: true).
  • High-Performance KV Store with Built-in Eviction: Eliminates the need for external packages like shared_preferences. ToStore includes a high-throughput KV engine with relative/absolute TTL expiration and table-level capacity eviction.

---

3. Hardcore Benchmarks: By the Numbers

To remove all guesswork, we evaluated the three databases across multiple rounds under strictly controlled testing environments.

1. Benchmark Environment and Methodology

• Hardware: High-performance Apple Silicon;
• Compilation: Dart / Flutter Release Mode (strictly disabling Debug mode, assertions, and JIT overhead);
• Measurement Runs: Each test was executed across 3 independent rounds; numbers represent strict mathematical averages;
• Core Metrics:
  • Write Throughput: OPS (Operations Per Second)
  • Search Throughput: QPS (Queries Per Second)
  • Latency: Average latency (microseconds/milliseconds)
  • Cold-Start Latency: Time from process spawn to fully responsive queries (milliseconds/seconds)

---

2. Dimension 1: Structured Data Throughput (100K Records)

Before assessing vector metrics, we established a baseline on standard structured tables across 100,000 records:

Database Engine	Batch Insert (OPS)	Single Insert (OPS)	Point/Filter Query (QPS)
ToStore	525,801	31,839	492,832
ObjectBox	395,961	2,404	245,586
SQLite (sqflite)	330,288	7,472	44,002

In-Depth Analysis:

1. Batch Writes: ToStore clocked over 525,000 OPS, outperforming ObjectBox by ~33% and SQLite by nearly 60%.
2. Single-Item Writes: In realistic mobile workloads (such as incremental log writes or chat message arrivals), ObjectBox dropped to 2,404 OPS due to transaction boundary overhead. ToStore maintained 31,839 OPS, exceeding ObjectBox by over 13x.
3. Retrieval Concurrency: ToStore achieved 492,832 QPS, 11x faster than SQLite and doubling ObjectBox (245,586 QPS).

---

3. Dimension 2: Dense Vector ANN Retrieval

We measured write throughput and Top-10 Approximate Nearest Neighbor (ANN) search throughput using 384-dimensional dense vectors (matching mainstream on-device embedding models) across 10,000 and 100,000 records.

Benchmark Metrics:

Dataset Size	Metric	ToStore	ObjectBox	SQLite (sqflite)
10,000 Vectors	Write Throughput (OPS)	97,382	348	27,453
	ANN Search (QPS)	32,859	2,789	827
100,000 Vectors	Write Throughput (OPS)	72,839	137	25,856
	ANN Search (QPS)	17,652	1,358	85

Why Are the Differences So Significant?

1. Ingestion & Indexing Overhead (OPS):
   • When inserting vectors into ObjectBox, throughput dropped to 137 ~ 348 OPS because its in-memory HNSW graph rebuilds edges synchronously for every inserted node, generating substantial thermal load during bulk imports.
   • ToStore sustained 72,839 OPS at 100K scale—over 530x faster than ObjectBox!
2. Search Concurrency (QPS):
   • At 10,000 records, ToStore achieved 32,859 QPS, compared to 2,789 QPS in ObjectBox and 827 QPS in SQLite.
   • At 100,000 records, SQLite’s lack of specialized vector indexing collapsed its throughput to 85 QPS (completely unusable for production). ObjectBox reached 1,358 QPS, while ToStore sustained 17,652 QPS.
   • In vector search throughput, ToStore leads ObjectBox by 13x and outperforms SQLite by more than 200x!

Note: ToStore provides a granular searchDepth tuning parameter (50 defaults to ~95% Recall@K, and 100 achieves ~98% recall), balancing latency and semantic precision.

---

4. Dimension 3: Full-Text Search (BM25) and Neural Sparse Vectors

In production RAG systems, relying solely on dense vectors leads to semantic drift. We tested keyword retrieval across 10,000 and 100,000 document chunks:

Dataset Scale	Test Scenario	ToStore (Text/BM25)	SQLite (FTS)	ObjectBox
10K Chunks	Write Throughput (OPS)	28,038	27,378	Not Supported
	Search Throughput (QPS)	4,837	883	Not Supported
100K Chunks	Write Throughput (OPS)	27,282	25,897	Not Supported
	Search Throughput (QPS)	4,691	126 (Collapses)	Not Supported
Sparse Vector (SPLADE)	Search Throughput (QPS)	~4,500	Not Supported	Not Supported

Deep Insights:

1. ObjectBox Lacks Full-Text Search: ObjectBox provides no native inverted text index, forcing developers to look elsewhere when lexical keyword recall is needed.
2. SQLite FTS Concurrency Collapse: At 10,000 items, SQLite FTS reached 883 QPS, but collapsed to 126 QPS at 100,000 records. ToStore remained rock-solid at 4,691 QPS with zero throughput degradation.
3. Neural Sparse Vectors (SPLADE / BGE-M3): Modern retrieval techniques output sparse weights across high-dimensional vocabularies, capturing technical terms and long-tail entities. ToStore provides native DataType.sparse fields, matching BM25 query speeds (~4,500 QPS). Neither SQLite nor ObjectBox supports sparse vectors.

---

5. Dimension 4: Extreme Scalability and Cold-Start Latency

The most easily overlooked edge risk is cold-start latency and memory crashes. As users accumulate local logs or hundreds of thousands of document chunks, can the database remain responsi

Stress Benchmark Metrics:

Evaluation Dimension	ToStore	SQLite	ObjectBox
Verified Test Scale & State	1 Billion Records (1e9 Scale Verified, No Degradation)	~50M (Query & launch heavily degraded)	~5M (Hard RAM limit, OOM Crash)
100K Scale Cold Start	~35 ms	~45 ms	~80 ms
5M Scale Cold Start	~35 ms	16 seconds	27 seconds (Danger Zone)
10M Scale Cold Start	~35 ms	30+ seconds (Unusable)	Failed (Direct OOM)

Why Did ObjectBox and SQLite Struggle at Scale?

• ObjectBox's 5-Million Ceiling: Because HNSW requires index structures to remain resident in memory, ObjectBox encountered an unrecoverable OOM abort once data surpassed 5 million records, and its launch time reached 27 seconds before crashing.
• SQLite's Cold-Start Lag: While SQLite can physically store tens of millions of records, root-page validation and file fragmentation stretched cold starts to 16 seconds at 5M records and over 30 seconds at 10M records, frequently triggering OS ANR terminations.
• ToStore's Instant Startup: ToStore highlights an advanced architecture designed to support server-grade scales! It keeps memory usage low and completely eliminates mobile ANR hazards.

---

4. Production Implementation: Building a Multi-Way Hybrid Knowledge Base

Building a hybrid RAG pipeline (Dense Vectors + BM25 Full-Text + Neural Sparse Vectors) often requires hundreds of lines of coordination code. With ToStore's unified query chain, the implementation is remarkably concise.

The following code is built entirely on ToStore's official public APIs and is ready for production use:

1. Adding the Dependency

In your Flutter project's pubspec.yaml:

dependencies:
  flutter:
    sdk: flutter
  tostore: ^3.6.1

2. Handling Global KV and Multi-Space Isolation (Retiring shared_preferences)

Before implementing RAG, many projects import shared_preferences for basic settings and tokens. In practice, shared_preferences deserializes entire files into memory, easily causing UI frame drops when handling large key spaces or frequent writes.

ToStore includes an enterprise-grade Key-Value engine out of the box, complete with TTL eviction and multi-space isolation:

// 1. High-throughput KV operations (sub-millisecond indexed response, handles large datasets easily)
await db.setValue('theme_mode', 'dark');

// 2. Session caching with automatic TTL expiration (no manual cleanup loops required)
await db.setValue('session_token', 'jwt_token_xyz', ttl: const Duration(hours: 4));

// 3. Multi-space data isolation (switch active user smoothly without separate DB files)
await db.switchSpace(spaceName: 'user_9527');

// 4. Cross-space global persistence (accessible across all isolated spaces)
await db.setValue('global_device_id', 'dev_8888', isGlobal: true);

With ToStore, projects no longer need to stitch together peripheral key-value packages, unifying the underlying storage layer.

3. Declaring the Multi-Modal Table Schema (Schema with Online Evolution)

Traditional mobile databases require cumbersome version upgrades (version: 2) and error-prone ALTER TABLE scripts. ToStore uses Online Schema Evolution: simply declare the updated TableSchema, and the engine handles structural migrations and index rebuilds in the background.

In a single table, we declare structured attributes, BM25 text fields, 384-dimensional dense vectors, and sparse vectors:

import 'package:tostore/tostore.dart';

TableSchema buildKnowledgeBaseSchema() {
  return const TableSchema(
    name: 'kb_documents',
    primaryKeyConfig: PrimaryKeyConfig(
      name: 'id',
      type: PrimaryKeyType.sequential, // Auto-incrementing primary key
    ),
    fields: [
      FieldSchema(name: 'title', type: DataType.text),
      FieldSchema(name: 'category', type: DataType.text), // Structured category
      FieldSchema(name: 'content', type: DataType.text),   // BM25 full-text field
      FieldSchema(
        name: 'embedding',
        type: DataType.vector,
        vectorConfig: VectorFieldConfig(
          dimensions: 384, // Dimensions of on-device embedding model
        ),
      ),
      FieldSchema(
        name: 'sparse_features',
        type: DataType.sparse, // Neural sparse vector field (SPLADE)
      ),
    ],
    indexes: [
      // Structured category index
      IndexSchema(fields: ['category'], type: IndexType.btree),
      // BM25 full-text search index
      IndexSchema(fields: ['content'], type: IndexType.text),
      // High-performance NGH dense vector index (cosine distance)
      IndexSchema(
        fields: ['embedding'],
        type: IndexType.vector,
        vectorConfig: VectorIndexConfig(
          indexType: VectorIndexType.ngh,
          distanceMetric: VectorDistanceMetric.cosine,
        ),
      ),
      // Neural sparse vector index
      IndexSchema(fields: ['sparse_features'], type: IndexType.sparse),
    ],
  );
}

4. Opening the Database and Batch Ingesting Knowledge Chunks

Future<void> initAndSeedDatabase(String appDir) async {
  // 1. Initialize persistent instance with declarative schema evolution
  final db = await ToStore.open(
    dbPath: appDir,
    dbName: 'rag_knowledge_base',
    schemas: [buildKnowledgeBaseSchema()],
  );

  // 2. Seed real-world edge diagnostics knowledge chunks
  final table = db.table('kb_documents');
  await table.batchInsert([
    {
      'title': 'Edge Gateway Handshake Timeout Guide (ERR_GW_1004)',
      'category': 'troubleshooting',
      'content': 'When an edge gateway node reports an ERR_GW_1004 handshake timeout, verify the local TLS certificate validity and inspect heartbeat packets over the physical route.',
      'embedding': VectorData.fromList(List.filled(384, 0.05)), // 384-dimensional dense vector
      'sparse_features': SparseVectorData.fromMap({'gateway': 0.88, '1004': 0.95, 'timeout': 0.72}),
    },
    {
      'title': 'Offline Multi-Tier Graceful Degradation Protocol',
      'category': 'troubleshooting',
      'content': 'In degraded network conditions, client nodes must trigger local fallback mechanisms, prioritizing edge knowledge retrieval to maintain uninterrupted offline assistant capabilities.',
      'embedding': VectorData.fromList(List.filled(384, 0.08)),
      'sparse_features': SparseVectorData.fromMap({'offline': 0.92, 'fallback': 0.84, 'degrade': 0.79}),
    },
  ]);

  await db.flush();
  print('Knowledge chunks imported and indexed successfully!');
}

5. Executing Multi-Way Hybrid Retrieval in One Chain

In an edge RAG query, the pipeline must:

1. Apply Predicate Filters: Restrict results to category == 'troubleshooting';
2. Lexical BM25 Recall: Match precise keywords like ERR_GW_1004 (weight: 0.3);
3. Neural Sparse Recall: Query SPLADE feature weights (weight: 0.3);
4. Dense Vector Recall: Query semantic similarity with minScore: 0.40 to filter baseline hallucination noise (weight: 0.4);
5. Score Fusion: Use RetrievalFusionMethod.weightedScore to produce a single, unified normalized relevance score.

Code requires just one chained call:

Future<List<Map<String, dynamic>>> queryHybridRAG({
  required ToStore db,
  required String queryText,
  required List<double> queryDenseVector,
  required Map<String, double> querySparseWeights,
}) async {
  // Chained execution: Predicate filter + Text + Sparse + Dense Vector + Weighted Fusion
  final queryResult = await db.query('kb_documents')
      .whereEqual('category', 'troubleshooting') // Structured metadata filter
      .matchText(
        'content',
        TextQuery.text(queryText), // Tokenized BM25 search (targets ERR_GW_1004)
        weight: 0.3,
      )
      .matchSparse(
        'sparse_features',
        SparseVectorData.fromMap(querySparseWeights),
        weight: 0.3,
        minScore: 0.20,
      )
      .matchVector(
        'embedding',
        VectorData.fromList(queryDenseVector),
        weight: 0.4,
        minScore: 0.40, // Drops background semantic noise
        searchDepth: 50, // Ensures ~95% Recall@K
      )
      .fusionMethod(RetrievalFusionMethod.weightedScore) // Unified fusion
      .limit(5);

  final List<Map<String, dynamic>> finalHits = [];
  final records = queryResult.data;
  final retrievalEntries = queryResult.retrieval?.entries ?? [];

  for (int i = 0; i < records.length; i++) {
    final record = records[i];
    final score = retrievalEntries.isNotEmpty ? retrievalEntries[i].score : 0.0;

    print('Doc: ${record['title']} -> Normalized Relevance Score: ${score.toStringAsFixed(4)}');
    finalHits.add({
      'record': record,
      'score': score,
    });
  }

  return finalHits;
}

Architectural Highlights:

• All retrieval channels automatically map to a unified 0.0 ~ 1.0 Normalized Relevance Score;
• Developers no longer need to write custom Min-Max normalizers in Dart. The underlying weightedScore algorithm guarantees that a dominant hit on an exact keyword or error code is never diluted by a weaker score on another channel.

---

5. Architectural Decision Matrix and Selection Summary

Through this deep benchmark evaluation, the evolution of modern edge data architectures has become clear: converging entirely into a unified engine!

flowchart TD
    Start["What are your Flutter data requirements?"] --> K1["High-throughput KV, config & session tokens"]
    Start --> K2["Structured business tables with frequent migrations"]
    Start --> K3["Multi-tenant user switching with global sharing"]
    Start --> K4["On-Device AI, offline RAG & multi-modal retrieval"]

    K1 --> V1["ToStore High-Performance KV Mode<br/>(Replaces fragile shared_preferences, native TTL & LRU eviction)"]
    K2 --> V2["ToStore Relational Tables<br/>(Declarative online schema evolution, eliminates manual ALTER TABLE)"]
    K3 --> V3["ToStore Multi-Space Isolation<br/>(Zero multi-file overhead, instant switchSpace)"]
    K4 --> V4["ToStore Multi-Way Hybrid Retrieval Pipeline<br/>(Dense NGH + BM25 + SPLADE Sparse, 35ms cold starts)"]

    V1 & V2 & V3 & V4 --> Final["Clear First Choice: ToStore<br/>(Unified architecture, single engine solves all edge storage needs)"]

Final Selection Summary: Why ToStore is the Decisive Winner

1. Key-Value and Caching Layer (Outperforming shared_preferences): shared_preferences is suitable only for a handful of settings; once data reaches hundreds of thousands of keys, it becomes virtually unusable (loading entire files into memory easily causes UI frame drops, and it lacks TTL or eviction mechanisms). ToStore's built-in KV mode delivers massive advantages in throughput, scale, and lifecycle management (TTL / LRU eviction), directly replacing shared_preferences and standalone caching packages.
2. Structured Tables and Maintenance (Leading Traditional Solutions):
   • SQLite schema upgrades remain fragile, and hand-written migration scripts frequently trigger production crashes;
   • ObjectBox leans toward lightweight object persistence, with natural limitations in complex joins, complete constraint validation, and built-in lifecycle eviction (TTL/LRU);
   • ToStore pairs complete enterprise data governance with zero-downtime Online Schema Evolution, working seamlessly in the background alongside native Multi-Space isolation to significantly reduce mobile development and maintenance overhead.
3. On-Device Vector and RAG Retrieval (Dominating SQLite and ObjectBox):
   • SQLite lacks native high-performance vector indexing, saturating CPUs and suffering severe concurrency drops on full-text queries;
   • ObjectBox lacks native full-text indexing (FTS), imposes heavy vector indexing overhead, and triggers OOM crashes above 5 million records with 27-second launch delays;
   • ToStore delivers 13x to 200x higher vector throughput (sustaining 17,652 QPS at 100K scale), zero degradation on concurrent BM25 text queries, and stands as the ecosystem's only engine natively supporting neural sparse vectors (SPLADE) and multi-way score fusion.

In an era where on-device AI and edge intelligence are becoming universal, adopting ToStore as a unified edge data foundation has become the most dependable, robust, and forward-looking choice for Flutter architecture in 2026.

---