Table of Contents

1. Preface

The following is a document detailing a system which I believe can be built with enough time using existing tools and documentation. To reduce this time I am looking for interested collaborators and investors. I originally was going to call this the "paymit" system, but I realized that it isn't "paying" for what was done, but rather "investing" in what people can do in the future. This distinction is important enough to warrant the extra syllable. Additionally, this idea was originally conceived with software in mind, but the system extends seamlessly to any media, and also public profiles which can be a proxy for investing in peoples' careers.

Investors generally want a high level document, and collaborators want a technical documents. I will try to better appeal to both groups in the future, but for now, this document is written as a technical document for investors.

2. Introduction

Capitalism, out of necessity, is actually incredibly good at distributing resources throughout a supply chain to keep it going. As much as people complain, workers usually make enough money to survive, though not always enough to survive well. Currently, there are people willing to create free digital assets, but require resources to live and hence spend their time making money instead. Additionally, there are people that want to pay such creators to do that work, but there is currently no mechanism to invest in these creators that is anywhere near the efficiency of capitalism. The free software and free media ecosystem must acquire this mechanism if it is to succeed.

The goal of investmits is to allow users to invest in the digital assets like media and software they own, use, and value. While many people are open to the idea of giving money to freedom respecting media and software infrastructure, this rarely happens because so many steps are involved, and the optimal steps are unclear; they can spare money, but not time. Investmits address this by facilitating a zero-click1 solution for investing in the freedom respecting resources you use. Essentially, users configure their computer and load up money which slowly disperses over time.

This document differentiates between two types of investors: "legacy" investors, and "new" investors. Legacy investors are people interested in the old mentality of investing: I give you money now to get more money later. The new investor mentality that I propose is as follows: I give you money now so people will make tools and media that improves me, including my ability to make money.

3. Core Concepts

3.1. Commit

Investmits extends the concept of a "commit" in a git repository to include any data, like art, TV shows, etc. A non-empty set of of changes to a code base is a commit. Commits are identified by a hash of a contributor name (sometimes an alias), contributor email, and code changes. This means that you cannot claim authorship of a commit without changing the hash identifier. Each commit has a corresponding token which may or may not have been registered in the Investmit Network. Additionally, we call media hashed with an email and other mostly optional identifiers a commit, which also has a corresponding investmit token. Unless it causes confusion, the token, changes/media content, and hash can together be called a "commit". Email is the primary way to identify an original owner, but other ways can be specified in the commit.

3.2. Source

Source is generally created by tying some other currency, like etherium or holofuel, to newly forged investmits (see below). Source does not exist as a separate entity, but is rather a conserved quantity which is distributed among investmits. At the time investmits are dissolved, all source must be accounted for in the form of newly forged investmits and/or by returning it to the original currency (presumably to gain some of that currency). While the investmit network does not incur fees for this process, the source may. For instance to return etherium source, you may need to pay the etherium network. There is additionally primordial investmit source which cannot be returned.

3.3. Investmit

Investmits are tokens which are addressed to a commit at the time they are forged. The owner of that commit obtains the investmit. Investmits are forged from source obtained from dissolving other investmits, or obtained externally like from etherium or holofuel. Investmits are also forged with a time limit2, and one or more methods to dissolve the investmit. Dissolving investmits can be pooled to forge new investmits, but there can also be other side affects, like an automatic partial or full redirect to another commit, or the change in ownership of the addressed commit. However, there must be at least one dissolution which does not change owner, and one such dissolution triggers automatically after the time limit. Additionally, there must be one method which does not change the commit owner AND gives some source.3

3.4. Investmit Parser

An Investmit Parser is a user-controlled parser that uses the state of some portion of a computer to generate a list of commit-weight tuples. Users are encouraged (and inherently incentivized) to workshop their parser to optimize for the values of that user. At least one official parser will be provided for the guix package manager, but other parsers can be built. It should have "sane defaults" to contend with decision fatigue, but should make it easy for the user to decide what parts of the computer the user values, even if those parts are rarely (if ever) used.

3.5. Investmit App

An Investmit App is a holochain app which manages commits owned by the user and which is able to forge investmits. The app is able to parse the tuples provided by the investmit parser to dissolve and forge investmits accordingly.

3.6. Investmit System

An investmit system consists of two components: an investmit app, and investmit parser. An investmit system running on a computer which parses the entire operating system is a full investmit system.

3.7. Investmit Network

The set of active investmit holochain apps is the Investmit Network.

4. Overview

Most digital assets used as currencies rely on block chain because it maintains a global state. This is important when goods and services in the real world are exchanged for digital assets. The entity rendering the real goods and/or services must be certain that the digital assets are genuine and not rendered elsewhere simultaneously. The Investmit Network circumvents this issue by primarily enabling payments for goods and services already rendered. While this only explicitly enables the user to invest in non-scarce resources like code and media, it implicitly allows them to invest in scarce resources. You can invest in the codes that add value to your life to incentivize programmers to code to your benefit. You can invest in a public profile of an activist to enable their work. The lack of global state means that it is in theory possible to lie about giving assets to someone. However, there is no reason to do so because the attacker gains nothing4. The recipient, at worst, gets disappointed when perse finds out the no-strings-attached money poofed without any other side affect. Admittedly, that could be a motivating factor for an attacker, but there are also consequences for doing so, like your identifier being blacklisted and your tokens destroyed.

The problem with maintaining a global state is that everyone must agree on every detail. For instance, every bitcoin transaction exists on every bitcoin node. This is not the case for the protocol on which investmits is built: Holochain. One of the investmit network's main advantage over other digital assets is that it enables large-scale microtransactions at virtually no cost to the users.

Committing, say, a public profile, is essentially committing yourself. This does technically enable individuals to transact among themselves, even for real, scarce, assets, but the user does this at per own risk. Since the goal of investmits is to enable investments into goods and services already rendered, nodes in the investmit system generally only knowingly register commits which have genuinely been rendered with a freedom respecting license. (I.e. GLP compatible like CC0, CC-BY, CC-BY-SA.) In practice, it is not possible to definitively know the license of a digital asset. This is not a problem specific to the investmit system as the investmit system does not directly provide the assets themselves. One would only invest in something they have already obtained from elsewhere, so it is important to primarily support operating systems which commit to enforcing user freedom, like fsdg5 compliant operating systems. While any source-based distribution like Gentoo and NixOS can in theory build parsers for the investmit system, the investmit maintainers are committed to supporting the guix package manager and guix system.

5. Onboarding Legacy Investors

Commits are a scarce resources which generate value based on how many entities invest in that commit. Anyone who proves to the investmit network that they control a certain email address can claim unclaimed commits signed with that email address. This means that a company which hires programmers can reap the resulting investmits by ensuring the company publishes freedom respecting code with company email addresses. Additionally, commits can be given to others, possibly as part of a quid-pro-quo. For instance, artists can sell the commit of their art, and the buyer actually gains something, unlike with traditional NFTs. Code itself can be sold this way for programmers to obtain short-term funds (maybe as an offramp to join the freedom respecting ecosystem) from legacy investors that want the long-term gains of a commit. The general steps for legacy investors is as follows:

  • Install and configure6 the investmit app (parser optional).
  • Load money into the app.
  • Buy commits.
  • Return source from dissolved investmits sent to owned commits over time.

Legacy Investors wanting to invest in the investmit network itself are encouraged to buy commits from the investmit system developers.

6. Onboarding Legacy Freedom Respecting Infrastructure

Investmits require no legal agreement between the investmit network and the user who can claim a commit. The user simply has the choice to dissolve the investmits, invest them elsewhere, or do nothing. There are no strings attached. They are given to old and new programmers and artists alike. Some in this space may not like how "corporate friendly" the investmit system is. These users are free to blacklist corporate email addresses, traded commits, and are even free to convince others to do the same. The freedom is in the users' hand to invest as they see fit.7 The general steps for creators is as follows:

  • Install and configure6 the investmit app (parser optional).
  • Claim commits using email.
  • Occasionally return source for real assets.

7. Onboarding New Investors

New investors desire the non-scarce assets the commits refer to. They are the true (non-legacy) investors that are investing in the freedom respecting digital ecosystem. Onboarding investors is as simple as providing digital assets freely in a format that has a corresponding investmit parser, and building easy ways to obtain sources in the investmit app. For example, it should be easy for users to convert US dollars into some source.8 The general steps for a user is as follows:

  • Install an investmit system.
  • Inspect the parser to ensure weights are assigned to the user's liking
  • load money into the investmit app, and set funds to trickle out to commits over time

8. Ways to Cheat

This section covers details about how people might try to "cheat".

8.1. Overwriting git history

One simple way to cheat the investmit network is to overwrite the git history of a program to always point to your email. However, that will only affect your local copy. To be successful, you must also convince others to use your version of the code.

To deal with this, you should always be careful to utilize repositories which are watchful of such deceit. You can help the problem by investing in package maintainers which have a history of keeping clean repositories.

8.2. Double paying

Because there is no global state, it is possible that you can think you have investmits or commits which haven't actually been rendered. The longer an investmit stays in your possession without being detected as fraudulent, the more you can be certain it is genuine. Basically, this means the user should not fully trust new assets.

8.3. Stealing email

If control of your email is compromised, then you may loose your commit. Technically, google could claim a large portion of emails, but they would immediately have legal troubles.

In the future, creators should directly include their investmit identifier in a commit instead of an email, so this problem can be avoided. However, the current developers (with community feedback) may implement a fix for such an occasion before that time.

8.4. Gaming of the Parser

In general, people will try to generate resources for the user which result in the user giving them more investmits. The user is incentivized to use a system parser which continues to maximize the user's value. This means the user may not want to share the exact details of the parser being used. Also, as always, the optimal parser is not clear. The parsers used by the community should be diverse and should evolve over time.



one-time initial setup required.


Though investmits expire, source can be kept indefinitely by regularly reforging. The point of mandating time limits is to ensure that there is some node on the network capable of accessing any source.


Though you can buy commits using investmits, every investmit includes a dissolution which only benefits the recipient. This means that trying to buy a commit can always result in lost source, and is never guaranteed to result in gained commit. For example, buying can be accomplished by sending an investmit with a shorter time limit and the following three dissolution methods:

  • Obtain a large amount of source and transfer ownership of the commit.
  • Obtain a small amount of source and redirect the rest to a specific commit (assumedly owned by the buyer).
  • Redirect the whole amount to a specific commit.

The last method is set to trigger when the investmit expires. The reason for this behavior is that users should always be able dissolve any number (including one) of owned investmits to reforge and/or return non-zero source without giving anything up. This can be thought of as a "transaction fee" to deter network abuse.


If the source used to buy a commit is fraudulent such that not all source can be returned, then the commit returns to the user. Hence, it is up to the buyer to ensure that the source used is genuine.


For instance, set the minimum source amount for which to auto-sell a commit, and how/if to auto-reforge expiring investmits.


Repositories may include files which indicate to an investmit parser a preference in how funds are distributed. However, as always, the user forging the investmits has total control of distribution.


To bootstrap the ecosystem, it may be helpful to build a shell company to hold and guarantee real US dollars in exchange for a company-generated source. Ideally, this should not be necessary.

Author: Zacchaeus Scheffer

Created: 2024-01-28 Sun 15:01