Calq Config treats your C# classes as the single source of truth for app settings, localization, themes, and more. No manual serialization, no string-based key lookups, no boilerplate.
POCO-First Configuration
Properties and fields become configuration entries. Define a class, get a fully managed config system with stable object references.
Live Reload with Stable References
Reload configuration from disk without losing your object references. The same instance always reflects the latest state.
Preset Groups with Cascading
A master preset cascades changes across all related config types. Switch one value and every dependent config reloads automatically.
Save Back and Partial Updates
Write configuration changes back to disk, or update individual values by path without full serialization round-trips.
Type-Safe Localization
One JSON file per language, accessed as typed properties. Compile-time safe — no string key lookups.
Theme & Regional Presets
Dark mode, light mode, currency, date formats — group them under preset dimensions and switch everything in lockstep.
A Simpler Approach
Both examples load configuration from JSON files.
Calq Config
using CalqFramework.Config.Json;
var registry = new JsonConfigurationRegistry();
var ui = await registry.GetAsync<UiConfig>();
Console.WriteLine(ui.Title);
Console.WriteLine(ui.DarkMode);
Microsoft.Extensions.Configuration
using Microsoft.Extensions.Configuration;
var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json",
optional: false, reloadOnChange: true)
.Build();
var ui = configuration
.GetSection("UiConfig").Get<UiConfig>();
Console.WriteLine(ui.Title);
Console.WriteLine(ui.DarkMode);
Calq Config vs. Microsoft.Extensions.Configuration
See how Calq Config compares to existing solutions for configuration and localization.
Calq Config vs. Microsoft.Extensions.Configuration
Feature
Calq Config
Microsoft.Extensions.Configuration
Config Objects
Mutable POCO Singletons
Immutable POCOs (via IOptions binding)
Named Presets
(automatic)
(manual)
Live Reload
Preset Groups
(master preset cascading)
Preset Switching at Runtime
Save Back to File
Save Back to File by JSONPath
Field Support
Learning Curve
Low
Moderate
Calq Config vs. Common Localization Approaches
Calq Config's typed POCO approach replaces string-key lookups with compile-time safe properties, while unifying localization with your app configuration.
Feature
Calq Config
.resx + IStringLocalizer
JSON Localization Libraries
Translation Access
Typed property (t.WelcomeMessage)
String key lookup (Loc["WelcomeMessage"])
String key lookup (Loc["WelcomeMessage"])
Storage Format
JSON files (no build step, editable at runtime)
XML .resx (requires compilation into satellite assemblies)
JSON files (no build step, but string-key based)
Language Switching
Change one value, all text classes reload automatically
Set thread culture, then re-resolve each localizer
Reload or re-resolve per component manually
Build Step Required
None (runtime JSON loading)
Satellite assembly compilation
None (runtime JSON loading)
Pluralization
Separate properties per form — no DSL needed
Framework engine required (ICU / gettext rules)
Framework engine required (ICU / gettext rules)
Translator Tooling (Crowdin, Transifex, etc.)
Compile-Time Safety
Unified with App Config
Pricing & Licensing
Start building for free on open-source projects, or choose a commercial license to keep your source code private.
Open Source License
Perfect for personal projects, open-source development, and product evaluation. Use freely under the AGPLv3 license terms.
IOptions binds to immutable snapshots that require DI to access. Calq Config gives you mutable POCO singletons with stable references — the same object instance survives reloads and always reflects the latest state. You can also save changes back to disk and switch presets at runtime.
Can I use Calq Config with ASP.NET Core?
Yes. Calq Config works alongside or independently of Microsoft.Extensions.Configuration. You can register the registry as a singleton in DI and resolve config POCOs anywhere in your application.
Can I implement a custom storage backend?
Yes. The JSON implementation is one backend. You can create others (database, remote API, YAML) by extending ConfigurationItemBase and ConfigurationRegistryBase. Your backend only needs to implement the storage operations.
Can I use Calq Config for localization?
Yes. Define a text class per page or component with properties for each translatable string, create one JSON file per language, and tag the class with [PresetGroup("Language")]. A master preset controls which language is active, and switching it cascades to all text classes automatically. You get compile-time safe translations — t.WelcomeMessage instead of Loc["WelcomeMessage"] — with no satellite assemblies or build steps.
Ready to Simplify Your Configuration?
Define a class, get a fully managed configuration system
