Define Your Data Model. Get Everything Else for Free.
One DSM model → typed Python and C++ APIs, persistence, mutation DAG, RPC services. The domain logic is yours to write.
DevKit, dsviper, Viper C++ — what's what?
Three names appear across this site. Here is how they layer.
DevKit
What you download here
The Digital Substrate developer toolkit, distributed as a single ZIP — bundles the Kibo code generator, the kibo-template-viper template pack, and CLI/GUI tools.
dsviper
What runs in your Python apps
The Python runtime distributed on PyPI. Strong-typed Python API over the Viper C++ engine. Installed via pip install dsviper or pulled in by the DevKit ZIP.
Viper C++
The C++ engine behind dsviper
The underlying metadata-driven C++ runtime — type system, mutation DAG, database tier. Distributed under commercial license ; contact us for direct C++ access.
The Stack
DevKit's most developed usage pattern is the Commit Application Model — typed, versioned, observable state with redux-like dispatch, in both C++ and Python. The diagram below traces the build-time and run-time chains around this pattern.
The application's own model: composes a CommitStore, the typed code generated for the domain, and the actions and state of the application itself.
Qt widget toolkit pre-wired for the standard Application Context pattern: commit history, undo, document browsing, settings — reusable across applications, not re-written for each.
Typed Application Context composing a Commit Store over the
Commit Database,
with redux-like dispatch of typed actions and an observable state.
Per-application typed infrastructure generated from your DSM model — all the plumbing your developers would otherwise rewrite for every project, delivered ready-to-use:
- Typed code for every DSM entity
- Typed attachment accessors
- Typed function pools (local services and remote RPC stubs) — public API and bridges generated; your private business code stays plain C++ / Python
- Serialization codecs
- Cross-language adapters (C++ ↔ Python, no wrappers to maintain)
This is the Dual Reality bridge: typed code on the developer side (for IDE comfort and compile-time checking), the same types expressed dynamically on the runtime side through its metadata catalog, translation in between. Both sides are strongly typed — the static surface does not add type safety, it adds editor ergonomics on top of safety that already lives in the runtime. The generated code is a set of adapters over Viper's dynamic API — no logic of their own, no parallel implementation. One engine underneath, no risk of drift between paths or between languages.
No code generation. The application introspects values and loads DSM definitions at runtime — possible because of the Metadata Everywhere principle: every value carries its type metadata, every database embeds its own definitions. Model-agnostic by construction — works against any opened commit database without prior knowledge of its schema.
Viper C++ — dynamic, metadata-driven, strongly typed at runtime via its definitions catalog. The Runtime Reality.
dsviper — its Python binding, distributed on PyPI.
The same foundation also supports stateless RPC services, typed serialization, schema inspection, and plain persistence. Kibo itself is template-agnostic and can target other runtimes with a different pack.
From Data Model to Production in 3 Steps
Define your data model once. Get type-safe code, versioning, and matching C++ and Python surfaces automatically.
DSM
Describe
Define your data model with a declarative language. Types, structures, relationships.
Learn more →Kibo
Generate
Reads DSM, applies a template pack (kibo-template-viper), emits two typed surfaces in parallel — C++ headers and implementations, plus a Python package.
Learn more →Viper C++ / dsviper
Use
Two runtimes, one model — Python via dsviper (PyPI), C++ via Viper C++ (commercial license, contact us). Same type guarantees on both.
See It in Action
Define your model in DSM, use it with full type safety — Python sample below; C++ surface emitted in parallel.
namespace Tuto {f529bc42-...} {
concept User;
struct Login {
string nickname;
string password;
};
struct Identity {
string firstname;
string lastname;
};
attachment<User, Login> login;
attachment<User, Identity> identity;
};from dsviper import *
# Open database and inject constants
db = CommitDatabase.open("model.cdb")
db.definitions().inject()
# Create key and document
key = TUTO_A_USER_LOGIN.create_key()
login = TUTO_A_USER_LOGIN.create_document()
login.nickname = "zoop"
login.password = "robust"
# Commit to database (versioned)
state = CommitMutableState(CommitStateBuilder.initial_state(db))
state.attachment_mutating().set(TUTO_A_USER_LOGIN, key, login)
db.commit_mutations("Add user", state)Why DevKit?
Reduce the infrastructure cost of application development — your team focuses on the business logic that is specific to its domain. The features below are how that reduction is delivered.
DSM — describe your model first
A purpose-built DSL where you describe your domain once — types, attachments, function pools. The single source of truth from which every typed surface (Python, C++, persistence, RPC) is generated.
IDE extensions (VS Code, JetBrains) →Type Safety
Strong typing with immediate exceptions on type mismatch. No silent failures, no runtime surprises.
Metadata Everywhere
Runtime introspection for types, values, serialization, RPC. One definition, multiple uses.
Persistence
SQLite-backed storage with automatic schema migration. ACID transactions out of the box.
Commit
Viper's subsystem for the mutation DAG — an immutable, content-addressed graph of typed commits over your data. Read state at any commit ; deterministic reduction of concurrent streams ; built-in undo/redo and dispatch.
Services
Viper's subsystem for networking — promote any typed function pool across the wire, same code as a local call. Dynamic universal client or Kibo-generated typed proxy ; mutations always land on the caller's side (Remote-Local protocol).
Runtime Integration
Strong-typed access over the same Viper C++ engine — via dsviper for Python (PyPI), and a C++ surface for native applications (commercial license).
Code Generation
Kibo + the kibo-template-viper pack emit typed C++ and Python code from your DSM — data classes, persistence, serialization, service APIs. ~57x amplification on real models.
Toolchain
Browse and edit any Commit database (cdbe), inspect a DSM model from the command line (dsm_util), expose a database over the network (commit-database server), build Qt UIs without rewriting the admin boilerplate (dsviper-components).
Ready to Get Started?
Download DevKit and build your first type-safe data model in minutes.