A look at reactiveui/Akavache: 2.5k stars on GitHub, written primarily in C#, tracked under the Backend category. An asynchronous, persistent key-value store for .NET desktop and mobile applications, backed by SQLite. Suited to both durable data such as user settings and cached data that expires, with optional encryption and System.Text.Json serialization.
Snapshot summary built from the project's own GitHub metadata — there's no written TopGit review yet. The page will update automatically when a full review is published.
WHY NO REVIEW YET
TopGit writes full reviews for the most-starred, most-requested repositories. This page is a snapshot until then — see the READ ME tab for the original README in full.
Akavache: An Asynchronous Key-Value Store for Native Applications
Akavache is an asynchronous, persistent (i.e., writes to disk) key-value store created for writing desktop and mobile applications in C#, based on SQLite3. Akavache is great for both storing important data (i.e., user settings) as well as cached local data that expires.
What's New in V12
Akavache V12 rewrites the SQLite backend for direct SQLitePCLRaw 3.x access, replacing the sqlite-net-pcl ORM layer entirely. The result is lower per-operation allocations, dedicated worker-thread serialization of all native handle access, and commit coalescing for concurrent writes.
SQLitePCLRaw direct access: Prepared statements cached and reused, parameters bound positionally — no ORM overhead
SQLite3MultipleCiphers: Encrypted databases use SQLite3MC instead of sqlcipher
Observable-first settings: SettingsBase properties are IObservable<T> — no more .Wait() deadlocks
AOT-safe serialization: JsonTypeInfo<T> overloads for System.Text.Json, trim-safe out of the box
System.Text.Json package split: Pure JSON package no longer pulls in Newtonsoft.Json
Thread-safe disposal: All cache types use lock-free Interlocked patterns for idempotent dispose
See the Migration Guide: V11 to V12 for upgrade instructions.
Note:WithAkavache, WithAkavacheCacheDatabase and Initialize always requires an ISerializer defined as a generic type, such as WithAkavache<SystemJsonSerializer>. This ensures the cache instance is properly configured for serialization.
Static Initialization (Recommended for most apps)
using Akavache.Core;
using Akavache.SystemTextJson;
using Akavache.Sqlite3;
using Splat.Builder;
// Initialize with the builder pattern
AppBuilder.CreateSplatBuilder()
.WithAkavacheCacheDatabase<SystemJsonSerializer>(builder =>
builder.WithSqliteProvider() // REQUIRED: Explicitly initialize SQLite provider
.WithSqliteDefaults(),
"MyApp");
Important: Always call WithSqliteProvider() explicitly before WithSqliteDefaults(). While WithSqliteDefaults() will automatically call WithSqliteProvider() if not already initialized (for backward compatibility), this automatic behavior is deprecated and may be removed in future versions. Explicit provider initialization is the recommended pattern for forward compatibility with other DI containers.
Dependency Injection Registration (for DI containers)
using Akavache.Core;
using Akavache.SystemTextJson;
using Akavache.Sqlite3;
using Splat.Builder;
// Example: Register Akavache with Splat DI
AppBuilder.CreateSplatBuilder()
.WithAkavache<SystemJsonSerializer>(
"MyApp",
builder => builder.WithSqliteProvider() // REQUIRED: Explicit provider initialization
.WithSqliteDefaults(),
(splat, instance) => splat.RegisterLazySingleton(() => instance));
// For in-memory cache (testing or lightweight scenarios):
AppBuilder.CreateSplatBuilder()
.WithAkavache<SystemJsonSerializer>(
"Akavache",
builder => builder.WithInMemoryDefaults(), // No provider needed for in-memory
(splat, instance) => splat.RegisterLazySingleton(() => instance));
3. Use the Cache
Basic Operations
// Store an object
var user = new User { Name = "John", Email = "[email protected]" };
await CacheDatabase.UserAccount.InsertObject("current_user", user);
// Retrieve an object
var cachedUser = await CacheDatabase.UserAccount.GetObject<User>("current_user");
// Store with expiration
await CacheDatabase.LocalMachine.InsertObject("temp_data", someData, DateTimeOffset.Now.AddHours(1));
// Get or fetch pattern
var data = await CacheDatabase.LocalMachine.GetOrFetchObject("api_data",
async () => await httpClient.GetFromJsonAsync<ApiResponse>("https://api.example.com/data"));
Cache Types
Akavache provides four types of caches:
UserAccount: User settings and preferences that should persist and potentially sync
LocalMachine: Cached data that can be safely deleted by the system
Secure: Encrypted storage for sensitive data like credentials and API keys
InMemory: Temporary storage that doesn't persist between app sessions
// User preferences (persistent)
await CacheDatabase.UserAccount.InsertObject("user_settings", settings);
// API cache (temporary)
await CacheDatabase.LocalMachine.InsertObject("api_cache", apiData, DateTimeOffset.Now.AddHours(6));
// Sensitive data (encrypted)
await CacheDatabase.Secure.SaveLogin("john.doe", "secretPassword", "myapp.com");
// Session data (in-memory only)
await CacheDatabase.InMemory.InsertObject("current_session", sessionData);
NuGet Packages
Install the packages that match your needs. At minimum you need the core package plus a storage backend and a serializer.
Purpose
Package
NuGet
Core (in-memory cache)
Akavache
SQLite persistence
Akavache.Sqlite3
Encrypted SQLite persistence
Akavache.EncryptedSqlite3
System.Text.Json serializer (recommended)
Akavache.SystemTextJson
System.Text.Json BSON serializer
Akavache.SystemTextJson.Bson
Newtonsoft.Json serializer
Akavache.NewtonsoftJson
HTTP download and caching extensions
Akavache.HttpDownloader
Image/bitmap caching
Akavache.Drawing
Application settings helpers
Akavache.Settings
Installation
Akavache uses a modular package structure. Choose the packages that match your needs:
Recommendation: Use System.Text.Json for new projects for best performance. Use Newtonsoft.Json when migrating from older Akavache versions or when you need maximum compatibility.
Akavache.Settings: Configuration Made Easy
Akavache.Settings provides a specialized settings database for application configuration that survives app updates and reinstalls.
Quick Settings Example
using Akavache.Settings;
// 1. Create a settings class — properties are IObservable<T>
public class AppSettings : SettingsBase
{
public AppSettings() : base(nameof(AppSettings)) { }
public IObservable<bool> EnableNotifications => GetOrCreateObservable(true);
public IObservable<Unit> SetEnableNotifications(bool value) => SetObservable(value, nameof(EnableNotifications));
public IObservable<string> UserName => GetOrCreateObservable("DefaultUser");
public IObservable<Unit> SetUserName(string value) => SetObservable(value, nameof(UserName));
}
// 2. Initialize with your app
var appSettings = default(AppSettings);
AppBuilder.CreateSplatBuilder()
.WithAkavache<SystemJsonSerializer>(builder =>
builder.WithApplicationName("MyApp")
.WithSqliteProvider()
.WithSettingsStore<AppSettings>(settings => appSettings = settings));
// 3. Use the settings — subscribe for live updates or read once
await appSettings.SetUserName("John Doe");
await appSettings.SetEnableNotifications(false);
var name = await appSettings.UserName.FirstAsync();
Console.WriteLine($"User: {name}");
Settings are automatically persisted and will survive app updates, making them perfect for user preferences and application configuration.
Documentation
📚 Complete documentation is available in the /docs folder:
Installation Guide - Detailed installation and package selection
Configuration - Builder pattern, providers, and advanced setup
Serializers - System.Text.Json vs Newtonsoft.Json comparison
Cache Types - UserAccount, LocalMachine, Secure, and InMemory caches
Basic Operations - CRUD operations and error handling
Migration: V10 → V11 - Upgrading from V10.x to V11.x
Migration: V11 → V12 - Upgrading from V11.x to V12.x
JetBrains gives ReactiveUI's maintainers licences for its tools through its
open source support programme.
Anthropic supports them with Claude through
Claude for Open Source.
OpenAI supports them with Codex through
Codex for Open Source.
This project is tested with BrowserStack.
See our sponsors for more information.
JetBrains, Claude, Anthropic, OpenAI and Codex names and logos are trademarks of their respective owners.
The most recent commit recorded on reactiveui/Akavache was 3 months ago, based on the GitHub push timestamp. The repository has 280 forks — one of the better signals of community interest.
How does reactiveui/Akavache compare to other Backend projects?
reactiveui/Akavache is tracked by TopGit in the Backend category, with 2.5k GitHub stars and written in C#. Browse the Backend topic page on TopGit to compare it against similar projects by stars and activity.
How many stars does reactiveui/Akavache have?
reactiveui/Akavache has 2.5k GitHub stars — refresh the page for the live number, or check github.com/reactiveui/Akavache. TopGit mirrors GitHub's count but does not claim minute-by-minute accuracy.
Is reactiveui/Akavache open source?
Yes — reactiveui/Akavache ships under the MIT license, which makes its source code freely readable (and, depending on license terms, forkable and reusable). Source: github.com/reactiveui/Akavache.
What is reactiveui/Akavache?
reactiveui/Akavache (reactiveui/Akavache) is a C# project on GitHub. From the project's own README: An asynchronous, persistent key-value store for .NET desktop and mobile applications, backed by SQLite. Suited to both durable data such as user settings and cached data that expires, with optional encryption and System.Text.Json serialization.
Where do I read more about reactiveui/Akavache?
This TopGit page is a snapshot — the READ ME tab shows the project's own README content (links stripped, images preserved). The GitHub repository at github.com/reactiveui/Akavache is the definitive source.
Read full README in the tab above.
Curious whether Akavache is right for you?
Let ChatGPT, Claude, or Perplexity look into it — click below and see what AI actually says about Akavache.