The rough concept of this one is a website where one can show up and give some amount of money to a project that interests you.

On the backend, though, that project has a number of members and sub-projects, and the money automatically trickles through the system, giving everyone their dues.

Uses

I originally wrote this when I was thinking of remix culture. The idea was that if I wrote a song that used samples from a few different sources, then I could make a project representing this song that would list the songs I'd pulled from as sub-projects. That way, when someone gave me money for my song, the other artists also automatically get their share, without me having to collect or distribute anything.

Then, I thought, one could use this for any back-end payment structure.

One could make a project for each song on an album, with sub-accounts for each of the people associated with that song. Then, one makes a project for the album that just has each song under it. That way, someone could give you money for a particular song, or the whole collection. Or, the artist could go one higher and make a project for themselves that just lists all the albums, so one could just give money to the artist for existing, and it'd go through the whole system.

If one were making a movie or, really, any kind of project like that, where everyone agrees to not get paid upfront, but rather they all get some cut of the backend, then all you need to do is put all of the cast and crew into the system under the movie. Then any time someone paid for the film, it'd automatically go out to all stakeholders.

That got me thinking that one could use it, in general, as really simple payroll structure. Make a project representing the company, put the employees under it, then just put money in the top. Bam, people get paid fairly.

Open source coding projects are also really suited to it. Not only are certain people core on the project, and could be remunerated when the project receives a donation, but often projects use other open source tools. So, a certain project may be some sort of web app, and it has developers, but it also might rely on RubyOnRails, and MySQL, and other such things. If these projects were also all on the system, then the first project could distribute money to its devs, but then also pass some of that money on to the projects it requires. That way everyone helps each other out, etc.

One could even use it for personal income management. Make a project for ones-self, then subprojects for "rent", "food", "spending money", and the different buckets fill up as a quick and dirty money-segregation.

There are probably other uses I haven't thought of.

Setup

I want it to be really really simple and easy to make new projects, because I want people to throw them together like crazy. Also, to make sub-accounts so I can go in and simply divide up the money without each person having to go through a whole process.

So, I think making a new project would just be "Type in a name, maybe give it an icon, maybe give it a description, maybe give it a link". I want GitHub style user-centric, rather than project-centric, so there can be 50 projects with the same name, because mine is psycotica0/super-project, and I don't care about the others. That means that I don't have to worry too much about telling people "No, that project name is taken, think of a new one"

Anyway, now there's a new empty project.

I want to allocate to people based on abstract "points" rather than fractions. In the end there will be fractions, but those can be automated. For example, when I add people to a project, I may add myself with 2 points and someone else with 1, and some technology I use with 1. That means that when money comes in, half of it goes to me, and the other half is divided between the other guy and the tech I use.

I like that feeling a lot more, where I put people in, and all that really matters is the relative sizes of their contributions. If I add someone with "10" and someone else with "20", I don't really care what the final breakdown is, so long as person two gets twice as much in the end as person 1.

It also, then, makes adding people much easier, since I don't have to go through and screw with all the fractions to try to squeeze them in, I can just put them in with their amount of points, and the system works out the new breakdown.

Adding People

Just like making projects, I want it to be really easy to add people, since those two things are basically the only thing one does with the tool. The easier it is to do these, the more likely people will actually use it.

So, I think one can easily make a new sub-account just by putting a name in.

For an even simpler thing, I think one could give a text box, and just have people write in:

1, John Smith
5, Super Bob
3, Todd
1, Mr Kittens

And it'll go through and add them all in bulk, creating sub-accounts for people that don't already have one. (Having some sort of a system for "Are you sure you didn't mean..." seems like a good idea, but adds cognitive load)

This way people can jump in, make a project with just a name, then add people to it in one step. Done.

Then they can tweak it later, or add other stuff, later. The bulk is done.

Technical Info

Money Format

I want to represent all the money inside the system as fractions with as much precision I can afford.

That way, even if someone gets 1/375th of a cent for each dollar in, it does still build up, and if the project makes $10 000 000, then they get their $266.66 That's important to me.

Given transaction costs, it's possible I'd have to say "No, you can't take any money out until you have more than $X", which I hate, but if that's how it has to work, then ok.

It's possible I can allow smaller payments than that if people coming in have an account with donatabase. That way we can keep a balance with them, and then they can pay out of it, refilling it as required.

I don't know the best way to allow multiple currencies, etc. I'll have to think about that.

Computing the Tree

So, when money comes in to a given project, that project may distribute to projects which distribute to projects, on and on. Sometimes project A may give to project B, which gives back to project A.

So, it'd be best if I could know upfront where the money is supposed to go, and then just dump it in those boxes.

Turns out that you can represent each project as an equation, with projects and accounts in it, and coefficients representing the fraction that goes to each project and account. Then, if you put the equations together into a system of equations, you can solve the system and get a full set of all of the endpoints for each project.

This takes care of long trees, and loops, and other such things and just flattens everything into "this much goes here, this much goes here, this much goes here, then you're done"

When someone makes a change to their project, the system must be recomputed.

Code

I started writing a bit of code, and it's here