Money as a vector, not a scalar — an N-dimensional framework for value exchange.
Most money is a single number: how much. Vectorised Money treats a unit of currency as a point in a product space,
Ω = (m, d₁, d₂, …, dₙ) ∈ ℝ⁺ × S₁ × S₂ × … × Sₙ
where m is magnitude (the familiar "how much") and each dᵢ is a coordinate in a dimension with its own algebraic structure — time preference, community membership, purpose, reputation, compute allocation, synchronisation quality, or whatever an economy needs. Scalar money is the degenerate case n = 0. The idea is that once value carries structured information, the economics — fees, incentives, time behaviour — can emerge from the mathematics of that space rather than being bolted on.
This is a research framework and working TypeScript implementation, written by the author at the intersection of Web3, AI and philosophy. It does not assume you are human: the same kernel is meant to serve a community allocating time and trust and a network of digital intelligences allocating compute and coherence.
The framework rests on a small set of grounded claims (see paper/vecmoney-paper.md for the formal treatment):
- Value as information. A unit of money is a message in a product space. A single scalar compresses every economic fact — who earned it, what for, how long it should be held, what infrastructure it depends on — into one number, erasing the rest. Coordinates carry that information instead of discarding it.
- Conservation of magnitude. Operations are designed to preserve total magnitude within a closed system; conservation is enforced as a runtime invariant.
- Entropy direction. Adding information tends to be cheap; removing it is priced higher. In the framework this shows up as deliberately asymmetric fees.
- Composability over a fixed kernel. The kernel knows about product spaces, conversion and conservation — not about any particular economy. Meaning lives in pluggable dimensions.
A pnpm/TypeScript monorepo. The kernel is a zero-dependency package; everything else layers on top.
@vecmoney/core— the kernel. Defines theDimensionPlugininterface, a UTXO-styleUnitmodel, a two-pass conversion engine with an N×N interaction tensor, a ledger, wallet and pool registry, an event bus and a deterministic simulation clock.@vecmoney/dimensions-human— a 5-dimension human economy pack: temporal, locality, purpose, reputation, agency.@vecmoney/dimensions-compute— a 6-dimension compute economy pack: compute, latency, substrate, provenance, coherence, role.@vecmoney/economics— fee routing, economic pools and behaviours (demurrage, dividend, lockup).@vecmoney/simulation— seeded RNG, agent strategies, a simulation runner, metrics and parameter sweeps.@vecmoney/persistence— serialisation, an in-memory backend and snapshot capture/restore.
Every dimension — including the defaults — implements one DimensionPlugin contract and declares one of five algebraic kinds, which fixes what values are legal and what "compatible for merging" means:
| Kind | Value space | Example |
|---|---|---|
| Scalar | continuous [min, max] |
coherence, FLOPS |
| Ordinal | finite ordered states s₁ < … < sₖ |
temporal / latency strata |
| Set | power set of a universe | community membership, substrate |
| Chain | append-only sequence | provenance history |
| Tag | unordered bounded labels | agency, role |
A DimensionPlugin describes what values are legal (config + validate), how conversion is priced (feeFunction), how the dimension behaves over time (tickBehavior), what merging requires (isCompatible), where fees go (feeDestination) and how it interacts with other dimensions (interactions).
Requires Node ≥ 20 and pnpm.
pnpm install
pnpm test # run the test suite (reported as 339 tests)
npx tsx examples/basic-5d.ts # human economy demo
npx tsx examples/compute-native-demo.ts # compute economy demo
npx tsx examples/custom-dimension.ts # build your own dimension
npx tsx examples/simulation-demo.ts # a longer simulation runOther workspace scripts: pnpm build, pnpm typecheck, pnpm clean. Individual packages can be tested with pnpm --filter @vecmoney/<package> test.
packages/
core/ # zero-dependency kernel
dimensions-human/ # human economy (5D)
dimensions-compute/ # compute economy (6D)
economics/ # fee routing, pools, behaviours
simulation/ # agents, RNG, metrics, sweeps
persistence/ # serialisation, snapshots
examples/ # runnable demos
paper/ # the formal paper (axioms, theorems)
archive/spec-v1/ # the original specification, preserved
MANIFESTO.md # declaration of intent
Good entry points into the code: packages/core/src/dimension/types.ts (the DimensionPlugin interface), packages/core/src/conversion/engine.ts (conversion with the interaction tensor) and packages/core/src/ledger/ledger.ts (the orchestrator).
Early-stage research, at version 0.1.0. The kernel and both dimension packs are implemented with a substantial test suite (the repository reports 339 passing tests), and there is a formal paper and an archived first specification. Interfaces should be considered unstable, and the framework is a conceptual model rather than production financial software. Contributions the project invites include new dimension packs, stronger proofs, adversarial analysis and cross-schema bridges.
paper/vecmoney-paper.md— the information-theoretic derivation, with axioms and theorems.MANIFESTO.md— the declaration of intent.- NotebookLM notebook — a companion notebook on the framework.
Sibling projects exploring value, currency and Web3:
- omnium — the first conception of "vectorised" money.
- kar-coin — a currency that scales with and through civilisational progress.
- helia-blockchain-token — a currency underpinned by six philosophical frameworks.
- derivation-of-value — a hub for working papers on Web3 cryptocurrency.
Released under the MIT Licence.