§
Sovereign.Software
↓ .MD

A Manifesto for Sovereign Personal Software

Software should serve people without claiming permanent custody over their information, choices, or work.

An architecture-neutral philosophy and evidence-based evaluation approach. Building on free software, local-first computing, digital preservation, and human-centred governance, it asks whether people keep effective authority over their work as technology, vendors, and circumstances change. What this builds on

Read or print the full text →

Framework version (), revised . How software is evaluated

Section 01

The Core Manifesto

Software should adapt to people, not force people to adapt to software.

Modern software provides extraordinary capabilities, yet many applications make ordinary work dependent on remote services, vendor accounts, opaque decisions, and business models that can change without the user's consent. These arrangements can be convenient, but convenience becomes dependence when a person cannot continue working, retrieve their records, or leave a provider without unacceptable loss.

Sovereign Software is a deliberate alternative: software designed so that ultimate authority remains with the person or organization using it, not with a vendor, an infrastructure operator, or an unaccountable algorithm. It need not reject networks, commercial software, artificial intelligence, or complex engineering. It rejects unnecessary surrender of control.

Four Foundational Principles, in a Deliberate Conceptual Order:

I. SOVEREIGNTY

Authority belongs to the user. Users retain meaningful control of their data, essential capabilities, and ability to leave or replace providers.

II. LONGEVITY

Information outlives software. Records and intellectual work remain accessible, interpretable, and recoverable after applications, vendors, and runtimes disappear.

III. LOCALITY

Independence is designed in. Capabilities that can reasonably operate on user-controlled hardware do not depend unnecessarily on external connectivity or permission.

IV. TRANSPARENCY AND CONTROL

Consequential behavior remains governable. Users can understand, inspect, authorize, and, where feasible, reverse or contest significant actions taken on their behalf.

A Relationship, Not a Ranking

  • Sovereignty defines the goal.
  • Longevity protects it across time.
  • Locality provides a powerful means of independence.
  • Transparency and Control make authority meaningful in operation.

The order communicates a relationship, not a scientifically measured ranking. All four matter, and no single numerical score can excuse a proven loss of fundamental user control. These principles do not prescribe a programming language, database, license, operating system, or user-interface style. They establish what an implementation must make possible.

Section 02

The Four Foundational Principles

PRINCIPLE I Authority • Exit

Sovereignty: The User Is the Authority

An individual or organization should not lose access to essential information merely because a subscription expires, an identity provider changes its rules, or a service is discontinued. Sovereignty requires practical, not merely contractual, authority: users can access, export, back up, restore, and migrate their information through documented means. A managed service can respect sovereignty if meaningful exit and independent access remain available, and local installation alone proves nothing if essential functions can be revoked remotely.

→ The ability to leave without losing what is yours is a practical test of ownership.

PRINCIPLE II Data • Function • Knowledge

Longevity: Information Should Outlive Software

Applications are temporary, while research, designs, records, and creative work may matter for generations. Longevity has three dimensions: data (records and metadata can be preserved and restored independently), function (essential workflows can continue through maintained software, independent implementations, or practicable migration), and knowledge (formats, schemas, and recovery procedures are documented well enough for future people and tools). A documented binary format such as SQLite can qualify, but open format names alone guarantee nothing.

→ Applications are temporary. Human information deserves a longer life.

PRINCIPLE III Local Capability • Necessary Dependencies

Locality: Independence by Design

The network should extend what software can do, not arbitrarily determine whether a person can reach work already on their device. Where technically appropriate, reading, editing, searching, and essential calculation should stay available on hardware the user controls, and a failed synchronization should not erase the ability to work. Locality is not an absolutist offline demand: the question is whether a dependency is inherent to the task and replaceable, or imposed unnecessarily. Local data also needs credible backups and recovery paths.

→ If a task can reasonably be performed independently, its execution should not require someone else's permission.

PRINCIPLE IV Inspect • Authorize • Correct

Transparency and Control: Authority Must Be Exercisable

A person cannot meaningfully govern a tool whose consequential behavior is inscrutable. Sovereign Software explains the rules governing important operations, reveals relevant dependencies and data flows, makes material changes traceable, and distinguishes suggestions from committed actions. Determinism is often the right engineering mechanism, but it is not itself the principle: a deterministic black box can still deny control, while a system that uses statistical models can remain governable when its boundaries and effects are transparent.

→ The machine may assist in decisions; it must not quietly take ownership of them.

Section 03

Architecture in Service of the Principles

No single architecture defines Sovereign Software, because the right design depends on the domain. A useful pattern is to distinguish three conceptual responsibilities. They are not a requirement for three separate applications: an integrated application can embody all three, and a collection of specialized applications can fail them.

Execution

Carrying out tasks, transitions, calculations, and other active workflows.

Preservation

Retaining records, context, metadata, and recovery information so they remain intelligible beyond the current application.

Exchange

Transferring information between tools through documented formats, protocols, APIs, or import and export mechanisms.

Interoperability is a means of preserving sovereignty and longevity, not an independent ideological demand for small programs. Modularity and bounded responsibilities remain sound engineering practice, but software does not become non-sovereign simply because it offers many features. Architecture should make information portable, important behavior understandable, and essential functions recoverable.

Section 04

AI Without Artificial Dependency

AI can accelerate development and make sophisticated tools more accessible, but it also introduces probabilistic outputs, opaque service dependencies, and actions that can exceed the user's intent. Sovereign Software uses AI only under boundaries that preserve human authority:

  • ✓ Existing records remain accessible if a model or provider becomes unavailable.
  • ✓ Core workflows that do not inherently require AI remain usable without it.
  • ✓ Consequential changes proposed by AI are validated and authorized according to their risk.
  • ✓ Network calls, privacy implications, and costs are disclosed.
  • ✓ AI outputs the user keeps can be preserved in independently usable formats.
  • ✓ Important decisions and modifications can be inspected, explained, and corrected.

AI may extend human ability. It must not become a condition for retaining human work or authority.

Section 05

Synchronization Without Surrender

Synchronizing devices is useful, but it must not quietly transfer custody or conceal loss. When disconnected devices edit the same information, an automatic merge can reconcile data structures while still misunderstanding human intent.

  • Conflict rules: Documented, with recoverable history where feasible, and with conflicts that cannot be resolved safely exposed for a decision.
  • Transport versus ownership: Users know where data is stored, who can read it, how it is encrypted, and what happens when the service disappears. Where practical, the mechanism is replaceable.
  • Backups: Replicated data is not a tested backup, because mistakes and corruption synchronize as readily as useful changes.

Synchronization should connect a person's devices, not make their work depend on a provider's continued existence.

Section 06

Evaluating Sovereign Software

A manifesto becomes useful when its claims can be challenged with evidence. Evaluation therefore distinguishes defining principles from engineering techniques and from general software quality, and it puts evidence before any numerical score. The Sovereign Software Evaluation Framework, version (), adopts no weighting scheme, score, or tier threshold. The earlier six-principle weighted model is superseded.

Four Principle Assessments

I. SOVEREIGNTY

Independent access, Complete export, Practical migration, Key custody where applicable, Freedom from revocable vendor control.

II. LONGEVITY

Documented formats and schemas, Metadata preservation, Tested backups, Restoration, Independent interpretation.

III. LOCALITY

Which essential functions operate without remote permission, Which dependencies are genuinely necessary and replaceable.

IV. TRANSPARENCY AND CONTROL

Understandable rules, Traceable consequential changes, Informed authorization, Error visibility, Paths for correction.

Each principle receives an evidence-based finding: meets, partially meets, or does not meet. These broader findings are distinct from the minimum eligibility requirements, and tests must be adapted to the software's actual purpose and deployment setting.

Five Fundamental Requirements

A tool cannot earn the highest sovereign classification when verified evidence shows that:

  1. The user cannot obtain an intelligible copy of already-created essential records through a documented, workable process.
  2. The user cannot leave for an alternative workflow without unacceptable loss of essential information and meaning.
  3. Preserved records cannot be interpreted or meaningfully restored without an irreplaceable vendor-controlled system.
  4. Withdrawal of permission, payment, activation, or provider availability removes effective control or essential operations over existing work, or architectural custody defects expose confidential records to unauthorized parties by design.
  5. Consequential operations cannot be adequately authorized, inspected, or corrected or contested where feasible, given the risks of this software.

Each is marked Pass, Fail, Not Verified, or Not Applicable with justification. These are minimum eligibility conditions, not the complete definition of the philosophy. A verified failure is not canceled by high marks elsewhere. Missing evidence is not a failure, and it must not be misrepresented as a pass.

A Qualified Determination

  • Fails a fundamental requirement
  • Insufficient evidence
  • Does not meet the proposed core standard
  • Partially aligned
  • Meets the proposed core requirements

Each claim discloses the application version, scope, observations, sources, limitations, and assessment date. Historical classifications remain historical. A future scored methodology may be developed, but no arithmetic should let excellent speed or elegant architecture compensate for the loss of essential user authority.

Seven Supporting Engineering Tests

The tests gather evidence. They are not interchangeable philosophical pillars. The last two are supporting quality considerations: neither responsiveness nor narrow functional scope is a prerequisite for being Sovereign Software, and a sub-100ms interaction target is not a universal sovereignty test.

T1 // OWNERSHIP AND EXIT

Can essential information be accessed, exported, and migrated independently?

T2 // PRESERVATION AND RECOVERY

Can an independent party interpret and restore the important records?

T3 // OFFLINE INDEPENDENCE

Which functions continue when external services are unavailable, and why?

T4 // OPERATIONAL TRANSPARENCY AND CONTROL

Can consequential actions, permissions, dependencies, and outcomes be inspected and controlled?

T5 // SECURITY, CUSTODY, AND CONTINUITY

Are custody, encryption, backups, restoration, and vendor-failure scenarios credibly addressed?

T6 // INTEROPERABILITY AND MAINTAINABILITY

Do interfaces, formats, and architectural boundaries materially support freedom and long-term operation?

T7 // HUMAN EXPERIENCE AND PERFORMANCE

Is the software usable, accessible, and reasonably responsive for its domain?

The principles define the destination. Evidence-based engineering tests show whether the software reaches it.

Section 07

What Sovereign Software Refuses to Become

✕ Captive Data: Records that cannot be meaningfully retrieved, interpreted, or migrated.
✕ Revocable Access to One's Own Work: Essential information or results made inaccessible by an arbitrary account or subscription decision.
✕ Irrecoverable Dependence: Information that becomes useless when one vendor, binary, or runtime disappears.
✕ Opaque Consequential Automation: Significant actions performed without appropriate visibility, authorization, or recourse.
✕ Silent Loss Through Synchronization: Conflicting or corrupted states overwritten without practical recovery.
✕ Concealed Dependencies and Surveillance: Mandatory external calls or data collection that undermine informed user choice.

It does not reject sophisticated applications, commercial development, optional cloud services, AI, or feature-rich designs merely for being sophisticated, commercial, connected, intelligent, or comprehensive. The issue is the resulting distribution of authority and the durability of user freedom.

The ability to build or monetize a feature is not sufficient reason to make users dependent on it.

Section 08

Personal Software in the Age of AI

Modern tools and AI-assisted workflows can lower some of the barriers that favored mass-market software, making tailored applications more feasible for individuals, research groups, and smaller communities. But lower development cost does not guarantee lower lifetime cost: security, migration, maintenance, documentation, accessibility, and data recovery still need sustained attention, and AI-generated code can be faster to create without being easier to trust or preserve.

Software does not need a mass market to justify its existence. It does need to justify the dependencies it imposes on its users.

Section 09

The Enduring Commitment

Sovereign Software is not defined by a database engine, a local-first framework, a language, a licensing label, or a synchronization protocol. Its enduring commitments are simpler: authority stays with the user; information survives the tools that produced it; unnecessary external dependence is resisted; and important actions remain transparent and governable.

When the software, vendor, network, or fashionable technology changes, does the person still retain meaningful control over their work?

References

Selected References

  • M. Kleppmann, A. Wiggins, P. van Hardenberg, and M. McGranaghan, “Local-first software: you own your data, in spite of the cloud,” Onward!, 2019. doi.org/10.1145/3359591.3359737
  • SQLite, “Recommended Storage Format for Datasets,” on its Library of Congress preservation designation. sqlite.org/locrsf.html
  • M. Shapiro, N. Preguiça, C. Baquero, and M. Zawirski, “Conflict-free replicated data types,” SSS, 2011. hal.sorbonne-universite.fr/inria-00609399v1
  • M. D. McIlroy, E. N. Pinson, and B. A. Tague, “UNIX Time-Sharing System: Foreword,” Bell System Technical Journal, 1978. Historical context for modular tool design, not a definitional requirement of sovereignty.
  • J. Nielsen, Usability Engineering, 1993. Response-time guidance belongs to supporting usability engineering, not to the definition of Sovereign Software.