I'm facing a dilemma. As a independent software developer and vendor, I code and sell the product of my work making some profit out of it. It's not much, it won't make me rich, but it's enough to make my living and there's room for giving back a bit of that amount to the FLOSS projects I use everyday to make the product a reality.

I use two primary sources for packages and modules: npm and composer (packagist). Whenever I run their update commands, I read on terminal:

$ npm update
98 packages are looking for funding
  run `npm fund` for details
$ composer update
126 packages you are using are looking for funding.

It would be fairly easy go through the path bellow:

  1. Set a sum of money available, e.g. US$ 1,000.00;
  2. Sum all those looking for funding packages;
  3. To divide the money by the sum of projects: 1000/(98+126)=4.464285714285714;
  4. Go to every URL from npm fund and composer fund and donate US$ 4.46 to each.

But I feel this is not a fair distribution for various reasons, some being:

  • Some projects plays more crucial roles to my project than others;
  • I don't feel right that well funded projects like, let's say, Bootstrap, Guzzle and Symfony takes the money that will serve better to less funded projects (I'm not telling these projects don't deserve any money! They do! I just want to give money to less funded projects.);
  • The value of each donation is just too low.

What my heart says ATM can be summarized as:

  • Set a blacklist containing the 'well funded' projects;
  • Get the most used classes and methods from the packages within the project (excluding the ones from the blacklist);
  • Set a kind of 'grade weight' for each project based on their usage;
  • Provide a list with, let's say, the top 10 most relevant packages based on their usage within the project;
  • Using the 'grade weight', divide the available budget for each package.

I've been researching for quite some time how to give back to the community when a project uses FLOSS packages. Most of the content I read focus on contributing with code and documentation (which I already do), but none that I could find talks about sharing money in a 'fair' manner.

So, I kindly ask from this community:

  1. Is my idea of 'fair' really fair?
  2. What would be a fair method to share money with FLOSS projects?
  3. How can I implement the method proposed above? Code examples are welcome!
  • 8
    At this point, this is honestly more a philosophy question than an open-source one. Your definition of "fair" could well be very different from my definition of "fair". But that doesn't really matter, because it's your money and you can do whatever you like with your money. Commented Feb 25 at 22:45
  • 2
    Yeah, I feared to ask this here precisely because of what you said. I could have asked on r/opensource, but I'm not fond of reddit. In the end, there's no right place to ask, so I ended up here. I can't even say if this is a legitimate question to ask, as I know beforehand there will be no consensus on what is 'fair'. Bottom line is: I have some little money to spare, and I don't want to give one or two bucks to many projects, but rather a few dozen bucks to some more relevant projects. 'Fair' here could be read as 'the programmatic way to measure relevance.'
    – denydias
    Commented Feb 25 at 23:12
  • 1
    Thanks for your comment, @cmbuckley. Yes, just by reading the question it implies that only direct dependencies are considered. But it's not. Recursive dependencies are going to be considered too.
    – denydias
    Commented Feb 26 at 22:54
  • 4
    See also: attribution-based economics (drym.org, github.com/drym-org/old-abe). Commented Feb 26 at 23:57
  • 1
    Very, very interesting links, @D.BenKnoble! Thanks for sharing.
    – denydias
    Commented Feb 27 at 0:36

5 Answers 5


So, I kindly ask from this community:

  1. Is my idea of 'fair' really fair?
  2. What would be a fair method to share money with FLOSS projects?
  3. How can I implement the method proposed above? Code examples are welcome!

So I am coming at this from my perspective as an economist.

  1. Fair is subjective and ill defined. Your proposal is definitely not the worst way to divide the funds.
  2. There are a couple of other ways that could be considered "fair".
    • Randomize x pots among the y projects you feel should be considered.
    • Think of the top x projects that would be hardest for you to replace. Fund those ones. This has the benefit of aligning your payments with your needs.
    • Pick the project with the funniest tag line or mascot. Nobody said you should base payments off of their technical merits.

There is no one best way to do this. As Matija Nalis points out, you may want to consider the effects of fees etc when donating (depending on the amounts you will be donating). A general principle for valuing things is taking into account the cost of replacing them (the opportunity cost of the choice). I hope this helps.

  • 3
    Thank you so much, @awesom3! This is everything I was in need to hear: 'proposal is definitely not the worst way to divide the funds.' You also does a very good point that I didn't thoroughly: 'projects that would be hardest to replace.' There're three or four projects that would be a headache to replace indeed. They are all maintained by individuals that will have a good use for any extra money! Hence, you answer is now accepted.
    – denydias
    Commented Feb 26 at 22:00
  • 4
    By applying the 'opportunity cost of the choice', I came down to three individuals and one small business that will receive funds this way: 1) Individual 1: 50% of funds, contributes with 3 direct dependencies very hard to replace; 2) Individual 2: 25% of funds, contributes with 1 direct dependency and 1 recursive dependency very hard to replace; 3) Individual 3: 12.5% of funds, contributes with 1 direct dependency and 1 recursive dependency hard to replace; 4) SMB 1: 12.5% of funds, contributes with 3 direct dependencies and 6 recursive dependencies hard to replace. Looks fair to me! ;)
    – denydias
    Commented Feb 26 at 23:15
  • 2
    Thanks for the example of how you did it.
    – awesom3
    Commented Feb 26 at 23:38
  • 1
    I think one aspect to this is that it prioritizes the most "notable" projects. Which is fine, but it does lead to projects lower-down in the tech stack being forgotten. (though limiting yourself to the npm fund list is already doing some of that). But for instance, in the wake of the Heartbleed exploit there was a lot of reporting that OpenSSL pulled in around $5k/yr in donations. I think to some extent that's inevitable, but it's something to think about. If you become aware of one of those 'deep in the tech stack' dependencies that seems underfunded, they seem like a good candidate.
    – Kaia
    Commented Feb 27 at 2:05
  • 1
    Not quite, @Kaia. For instance, in my project npm fund list cssnano, which is a direct dependency, but it goes down to entities in the 5th level. Sure, a conscious developer should stay tuned for these cases, but the tools does make one aware that funding is needed on lower decks.
    – denydias
    Commented Feb 27 at 5:06

I freely concede that this question has no single definitive answer, but I think there are a few general truths that can usefully be marshalled in response.

We can't tell you what "fair" means to you. Some might think the projects most-used by number of library calls are the most deserving. Others might see the largest, most active projects as those that can make best use of your kind gift. Others yet might favour one of the smaller, less-supported projects as one that could make best use of it. A fourth group might point out that pies crumble when you slice them too thin (thank you, Neal Stephenson) and that a small number of large donations was all-round more useful than a large number of small ones - the processing costs of a $4.46 donation being quite likely to exceed the value of the donation.

So to my mind, your biggest danger here is not unfair giving, but decision paralysis. In other words, your search for the "perfect" method of division may result in you not actually giving at all, and that is a worse outcome than even an arbitrarily lopsided donation plan.

I very strongly advise you to pick some scheme, even if it's just the pin-in-the-source-code method, and actually give the money while you still have it to give, and are still minded to give it. However "unfair" your scheme, you will still have done more for free software than 90-odd-percent of users, and that will be an unqualified good.

  • Thanks for your answer, @MadHatter. I'll not accept it as it doesn't cover the question itself. But I really appreciate your concern on decision paralysis. I must add this is not the case. Although I do have the money, it's not mine anymore. It's already reserved for the projects I select. As soon as I do, I will just wire the money out to their recipients. That decision was made in the past and is not subject to change. My question aims on making easier to an individual or SMB to select projects to donate in the case presented above (many projects, few bucks.)
    – denydias
    Commented Feb 26 at 11:16
  • @denydias and as I think we've all been clear, that element of the question is probably unanswerable, and (therefore) likely off-topic. We can't tell you what "fair" means to you, and if you hold out for someone to do that, the question may well accumulate yet more close votes, and get closed.
    – MadHatter
    Commented Feb 26 at 11:19
  • I presented what I think to be fair. Do you think editing the question towards the method instead of fairness concept would help?
    – denydias
    Commented Feb 26 at 11:23
  • 1
    I don't think so, because the method is intended to achieve the purpose, which is "maximum fairness", and that's unachievable because it's subjective. If you decided what your definition of "fair" was, then the question would either be asking for an algorithm or code to produce it (off-topic) or a pointer to an external tool to produce it (also off-topic).
    – MadHatter
    Commented Feb 26 at 11:26
  • 1
    I think that's a reasonable way to go forward, and thank you for it. It's not that the community hasn't solved the problem so much as all its members have solved it in different, personally-satisfactory ways. I myself donate to various free software foundations. Is that perfect? No. Could I do better? Doubtless. But it's something, and I think my underlying point is that anything is better than nothing. I hope you decide who to donate to soon!
    – MadHatter
    Commented Feb 26 at 11:40

Here is one idea:

  • decide on per-project donation that is not too small (e.g. maybe 30-60$), so the processing costs don't eat too much of it

  • decide on cutoff point (on number of users / popularity) for projects that "will survive just fine without my help" (e.g. make a manual or half-automatic exclusion list of already big/popular projects)

  • pick one of directions you want to take:

    • calculate how much you use each project (count imports or whatever), and sort remaining projects by that usage. (this helps the most the projects you use most)
    • sort projects by how small they are (i.e. prioritize giving to smallest projects, which likely need help the most)
    • pick some weighing method that combines above two criteria in some ratio
    • randomize the list
  • each time you have extra money to donate, from that sorted list of eligible projects, take top x projects (where x = total_amount_of_money / donation_per_project_from_step_1), and donate to them amount decided in step 1, and remove that project from the list

  • when you've cleaned up the whole list; start from the beginning; generating new list

  • 1
    Thank you so much for your answer, @matija-nalis! Although it does make a lot of sense in selecting projects to donate, I'll not accept to replace the current one as the one from @awesom3 covers an important metric I didn't think thoroughly: 'projects that would be hardest to replace.' As for 'extra money', this is something already in place: I'm going to make yearly donations to selected projects. Anyway, I upvoted your answer.
    – denydias
    Commented Feb 26 at 21:56

First of all, as others have said, it's really commendable that you are thinking about these things -- it's important that more of us do!

As a comment on the question mentioned, Attribution Based Economics (ABE) is a movement that attempts to solve precisely this problem. Take a look at drym.org/about which contains many curated resources for learning about ABE.

The problem you've identified is very challenging, and in fact it's the tip of the iceberg on a problem of much wider scale in society -- that of fairly recognizing contributors, regardless of the type of value contributed. We don't do this well even in society at large, since only a small subset of valuable contributions are capable of being recognized financially. In open source it's especially challenging because none of the valuable contributions, on their own, are capable of being recognized financially, since existing ways that we've developed to do this are rooted in supply and demand, a heuristic which is inapplicable in open source except through indirect, and indeed wasteful and often unfair, means. The consequences of our inability to do these things is honestly staggering and not at all well appreciated today.

ABE addresses this problem through a novel economic foundation regarding the ex nihilo origin of money (where does money come from?) and the nature of economic value (it's not just about supply and demand, but needs to be more general). Additionally, it develops formalized processes that anyone can participate in that determine the distribution of raised money over all contributors, and libraries used, and beyond. It's still in the early stages of implementation, but we've already raised some money and recorded payments to many contributors in several open source projects, with more payments soon to come.

If you're interested in trying it out, please contact the organizer (that's me!) via the site for your project to be part of the pilot, and we will help you divide up the funds according to ABE principles. You're also welcome to participate in developing these solutions that we deploy across open source projects and beyond, and the community is always glad to have more interesting projects and people to work with.

  • Nice to hear from you, @mindthief! I heard of ABE from @D.BenKnoble in a comment above. I took some time to read old-abe docs and it looks great for OSS project looking to share donations with its contributors. But I have no contributors. I work alone and sell the product that includes lots of code of my own (>100k lines) with the help of 3rd party OSS projects. My need is to share the funds I receive with those projects. From what I read, old-abe does not address this use case just yet. But it's awesome to know something like ABE is in place.
    – denydias
    Commented Feb 27 at 5:16
  • 1
    I will note that ABE recognizes roughly 3 categories of contribution @denydias: “labor” (the work you did), “capital” (the investments, like libraries, that made your project possible), and “ideas” (the things that inspired your project). The goal is to distribute funds to all 3. Commented Feb 27 at 13:17
  • It's an unusual use case since I assume your code is not open source, is that right? Still, as Ben mentioned, for any amount of money you are interested in distributing upstream, we can make that happen. If these projects receive even small amounts from you, they could themselves adopt ABE and then, with increasing adoption, the obligation to support developers of useful software is no longer just on you but is shared by the community at large.
    – mindthief
    Commented Feb 27 at 18:40
  • 1
    You're correct, @mindthief. My project is not OSS and has a proprietary license. I do have the intention to open source it in the mid-term future, but I'm not ready to do it in a near future. It would be nice that ABE to include the possibility to distribute money upstream for my use case (closed source software using OSS libraries) without the need that developers adopt it too. I don't know if ABE was engineered to do so, but this is such a common use case in the development houses industry that I think it's worth at least think about it.
    – denydias
    Commented Feb 27 at 22:56

I think most answers here are already great. They tackle the ethics and the question "what is fair". So I won't duplicate any of that.

Instead, I want to give a technical alternative to solving your dilemma. you say this:

how to give back to the community when a project uses FLOSS packages.

So if I understand you correctly, it's not necessarily the software you yourself use on your computer you want to reward, but instead, you want to pass on some of the profits your made with the software you made, to the contributors of the underlying software that you used. (E.g. you use OpenSSL in your tool, you want to give them a cut). That's definitely admirable!

If you want to share your pot of money based on how much the underlying FOSS has contributed to your own project, the fairest way would be to check how often their functions are being called. You can do this by using a profiler.

For example, if your project would be a C-program you could use the -pg argument in gcc and then parse the output with gprof. This would give you a list of all function calls, how often they were called, and how much CPU-time was spent in them. If you filter out your own functions you end up with an ordered list of your FOSS calls. After aggregating them by library, you are left with a list of percentages of usage of FOSS libraries. You are then still free to blacklist the ones you wanted to exclude for various reasons.

  • 1
    Interesting idea using gprof! I'll note, however, if that idea were to catch on, it would create unhealthy incentive to make libraries as unoptimal and sluggish as possible, in order to spend as much CPU-time as possible in the, so as to get the biggest piece of the (financial) pie :-) Commented Feb 28 at 15:59
  • Thanks for your answer and kind words. As @MatijaNalis has cleverly noted, if this ever become a popular method human nature can't be trusted. CPU time can't be considered as a metric. But runtime profiling is indeed a good method to get a list of most used functions of 3rd party libraries.
    – denydias
    Commented Feb 28 at 21:40
  • @MatijaNalis sure, but then your library becomes crap and people will use a more efficient one :) Note that I didn't exclusively mention the CPU-time. You can also see how often it was called. For example, 10 calls to openssl_encrypt() and 20 to avro_write_data(), then you could donate $333 to OpenSSL and $666 to Apache Avro.
    – Opifex
    Commented Feb 29 at 7:30
  • "sure, but then your library becomes crap and people will use a more efficient one" Sign me up for that alternate reality where world works that way :-) Over here, it is all about being nice and open and fast and friendly and "do no evil" until they get the big enough userbase, and then they turn closed source and evil and try to extract as much blood from users before they die. Hi Google! Commented Mar 1 at 2:35

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.