Here are your choices:
* Turn your OSS project into a company (Docker). The pro is that you can capture a lot of the value, the con is that you're splitting your project into CE/EE and also now you're a CEO
* Give the software away for free and charge for the hosting (Gitlab). Pro here is that you get recurring revenue, but the con is that now you're in DevOps and wear a pager. Also this model doesn't work well for libraries, only "apps".
* Charge for support (Ubuntu, Nginx-ish). Pro here is that by helping folks implement your software, you'll have a long line of success stories. Con here is that it isn't scalable - your upside is bounded by the hours you can bill
* Get a job at a company that will fund you to work on it (React, Angular). Pro here is that you can make tons of money with a job you love. Nice work, if you can get it. Con is that now you work for that company and you're subject to whatever whims they have.
* Run a Kickstarter (Light Table, Diaspora). Pro: you can gauge demand and you don't have a boss. Cons: it's one-time revenue, you have potentially inflated expectations, and just kidding, now you have 1,000 bosses.
* Run a Patreon (Vue). Pro: you have autonomy and recurring revenue (yay!). Con: now you're a personality. This is limited to celebs who are good at marketing _themselves_ as much as their software
* Ask for donations (Babel, Webpack). Pro: this works for tools and libraries (not just apps) and you can keep your mission. Con: Companies feel these donations have ambiguous deliverables. There's a lot of mental overhead too (How many projects can one company fund per month?)
* Sell documentation, books, videos (React Training, my current gig). Pro: JavaScript fatigue makes you money! Con: Writing the docs isn't as satisfying as writing software (for many developers)
So to answer your question: monetizing your open-source project means you take on another job _besides writing software_.
In an ideal world if you write software and it gets used, you'd be able to capture some share of that value. But we're not there yet.
[If you want to chat more about funding OSS, reach out to me (see my profile). I'm working on a few new ideas.]
I think this dynamic applies pretty widely and it's part of a major problem throughout the open-source community. There are many people who feel entitled to custom development tailored to their exact needs for free or close to it; that population is both considerably larger than the number of people who will contribute at all, much less significantly, and a substantial percentage of them communicate in a rude and entitled manner which contributes to burnout for the actual contributors.
I don't see this one as necessarily true. And it doesn't even seem to hold up in the one example you gave of Vue. Looking over the patreon page, Evan seems to be totally marketing the technology and not marketing "himself" at all.
One might say that other open-source projects don't make a significant income because they don't have value, but I think you only need to look at e.g. the npm download stats for many packages to see that this isn't true.
Put another way, _many_ software libraries enable huge amounts of business value that is not captured by the authors of those libraries.
For instance, if you're a JS dev, you've probably used lodash or moment, but maybe can't even name who the authors are of those projects.
This idea of "hustle as your new second job" is a better phrasing than my parent comment where it sounds like I'm implying that self-promotion is bad or somehow empty.
Becoming a personality is an excellent strategy - if you're known and loved you'll never starve.
I'm mostly trying to point out that time spent hustling takes away from time building. It's still valuable in it's own way, but many OSS devs (who have created software people find valuable and use) don't want to travel to speak at conferences to pay their bills.
But you're leaving out one thing.. since it's not licensing, most developers using your project on the job will have to contribute out of their own pockets. Reasonably, they're much more hesitant and will give less.
As evidence, when you buy a piece of software yourself, you probably buy the most basic version you can. When you can expense it, odds are you get those optional components that you _might_ need at some point.
And further, offering "support contracts" can be great but many companies use it as a check box - "do they offer support? yes!" - as opposed to actually buying it. Luckily, of those that buy it, some will never use it. :D
So suppose you actually manage get paid despite all that -- how do you distribute money fairly? This is a huge problem can could actually slow the project down by leading to hurt feelings. Ironically, it's almost better for the group if nobody gets paid.
Corporations have evolved all sorts of imperfect systems to solve this problem, but it comes at a tremendous cost (performance reviews, interviews, firing, all of HR essentially).
But the open source model of collaboration follows the principle of "least bureaucracy". It throws out all these "coordination costs" in the name of just getting the job done. No more and no less.
Relatedly: Studies show that paying people zero money and giving them respect gets better results than paying some pittance well below market rate. The study conclusion was to the effect of "Pay enough (market rates) or pay nothing. Don't pay some pittance because it is all your project can afford."
But, this is something my internal dialogue says whenever I hear a musician talking about money (and where there share is...) - 'But you are in it for the music, right?'
This musicians seem to forget, they become businessmen and think the value is in the magic of their work and they should be paid for it. I wish they kept music as a fun thing rather than something they 'only do if paid' and for them to see hiring venues and doing tours and selling merchandise as what they need to do for money.
So, analogy is different to reality, however, we must remember why we do stuff for Open Source. Instead of looking for T-shirts and venue tickets to sell, we need to have real world needs for the Open Source code, to work on those problems and get paid for them using and contributing as required to the FOSS projects. As for expectation for pay from the FOSS project (rather than the day job) it should be 'you're in it for the love of music, right?'
Sometimes, the answers aren't as simple and easy as we wish they were.
The problem is getting to that level where you have so many fans that you can fill an arena or even a smaller venue.
Software authors should also be paid. I'm just pointing out that there are some practical problems with it in the open source setting.
My ideal would be that essentially all software is open source, but everyone would also get paid. But I realize there are many reasons why we don't have that situation today.
When it was a freeware product, several people wanted to donate but we never accepted any donation, just to avoid the feeling of getting paid too low. Also I guess we were a bit equalitarian: we wanted that either nobody paid or that everybody paid.
I'm almost positive this isn't true. If you restrict to the top few percent of projects, it'll be much more true, but even so I think you'll find a lot of projects with relatively small core groups, and sometimes a single hacker who wrote most of the core.
Weekend project: try to quantify this via GitHub APIs? Although suspect that might still give a somewhat skewed picture (not every major project is on GitHub...)
Think of every open source OS, browser, compiler, interpreter, etc.
There might be one person who initiated the project and did much of the design, like Guido van Rossum for Python, but it wouldn't be fair if he got 100% of the compensation and everybody else on python-dev got 0%.
If a project has active community then the owner can scale support by sharing workload and money with the contributors. In general I agree with you monetization is a job/business.
I don't write software, but I have run various small websites for something like 15+ years. I have always gotten more donation money than ad money off my projects. I switched to a tip jar (last year, iirc) and that further improved my take. (It isn't much, but it beats the figures I have seen quoted by most people when data has been asked for on HN. I also don't get much traffic. For the traffic involved, I think it is pretty good.)
I have also seen Patrick McKenzie talk about the fact that he won't donate money to open source, but if you are willing to write an invoice for him, he is happy to give you money. The reason is that he needs to justify his business expenses on his tax returns and a "donation" is charity that he can't justify to the government, but an invoice for a product he uses in his work is a legit tax deduction. He has talked about how he thinks open source should make invoicing business customers painless. I don't readily have a source at my fingertips, but I bet someone on HN can come up with a link.
A compendium of my own writing about tip jars: http://micheleincalifornia.blogspot.com/search?q=tip+jar
Original source could be the tweet embedded in https://supso.org/blog/funding-open-source-by-rethinking-the...
That was us :) @patio11 was blown away by our in-browser Excel file preview: https://twitter.com/patio11/status/552765535239159808 (one of the replies suggested that he consider paying, and that led to our first contact) http://www.kalzumeus.com/2015/01/28/design-and-implementatio...
Liberapay is another platform, an open source Patreon alternative, also has a few funded developers and dev-ops like Technowix @ https://liberapay.com/Technowix/.
* Sell commercial versions of your software, appliances to run it, hardware interface cards, phones, and cloud services (Digium). Pro: you can fund the OSS project from the sales and continue to innovate. Cons: you have to engineer and support the hardware, and you're running a datacenter and doing DevOps.
* Create bounties for individual features/bugfixes using a platform like Bountysource
I've contributed small amounts to FOSS projects I use personally, because I'd really like to see certain features added (or bugs fixed) but don't always have the means or time to contribute my own pull request.
Pros: customers only pay when the feature/bug is implemented, no pager duty or support hours, easy to gauge demand so time is only spent on work that's most desired by paying customers
Cons: one-time revenue, payments might be low relative to the work required
If I had an open source project with an active userbase (one day...), I would probably combine bounties with Patreon and/or support contracts.
Anyway I think the original question kind of misses the point of open source. The big driver for the growth of open source is that it enables users license-free access to large quantities of software. The folks that have made the most money off open source are companies like Facebook/Google that run their business on open source or use it to drive adoption of products they can monetize in other ways.
You should not monetize if the problem your OSS is solving is not a problem you care about. You have to be in it for the long term as it always takes years of work to succeed.
Has anyone tried running a kickstarter for a version 2? I think I'd be happier doing that because there is a lot less risk, the pitch is "you like v1, would you like me to add features x, y and z?".
Halite is a libsodium wrapper for PHP projects that emphasizes ease-of-use and difficulty to misuse: https://github.com/paragonie/halite
CMS Airship is a secure-by-default content management system (think WordPress, Drupal, Joomla, etc.): https://github.com/paragonie/airship
Both projects are released under GPL but offer commercial licenses. In two years, I've only had one person ever inquire about a commercial license, and they backed out.
One of the libraries I wrote has an installed base of (not counting WordPress) over 28 million, yet I rarely hear from its users: https://packagist.org/packages/paragonie/random_compat
The barrier isn't legal or philosophical, it's that a lot of very useful open source software (especially libraries that developers interface with) are infrastructure rather than window dressing, which is largely invisible to organizations.
If you only develop window-dressing libraries, then the stuff 'patio11 has said here over the years might hold true. But if you're trying to build a more secure Internet by giving developers better tools, nobody wants to pay you for that.
Less than 10 for Airship. There's a lot of reasons for that, though (aside from the fact that we built it to be Tor-friendly, so it's nontrivial to measure how many installs exist in the world): We only supported PostgreSQL and only users capable of installing libsodium from PECL could use it. PHP 7.2 will make it possible for everyone to use Airship version 2, and MySQL 8 will add CTEs so we might be able to support the more mainstream database. https://wiki.php.net/rfc/libsodium
Basically, 28 million + (number of WordPress 4.4+ installs) = total installed base of random_compat
Sounds like you might enjoy working at https://protocol.ai/
that's not necessarily a bad thing. Those sound like libs with pretty simple responsibilities, so if they work great there may just not be any real opportunity for feature requests or feedback.
With a backported shim (like at least one of those), I'd honestly take a silent userbase as a sign of success if you know there are downloads/installs.
https://github.com/pkamb/PowerKey
I then sell a compiled version signed with my Apple Developer ID via Gumroad:
https://gumroad.com/l/powerkey
This model works pretty well for small apps that you otherwise want to keep in a public repo. The hassle of compiling + signing the app is worth $5 to many people.
For anyone dabbling with the idea, I can't recommend Gumroad enough for simplicity. But it would be nice to see payment/storefront functionality built into GitHub's Releases feature. A GitHub sanctioned payment system might even clue some creators in to the fact that you can charge for some component of your open source work.
I almost bought it, and I'm on Linux!
While the progress is promising enough for me to continue working on it full time, nothing could have prepared me for how difficult this was going to be. I had always been under the illusion that if you had a product you wanted to sell, and there was demand for it, then an automatic transaction takes place.
Not so.
Not so at all. It requires understanding your users, learning about their preferences, learning how to re-engage with them, learning to keep them interested and engaged, and learning how to position your product as one people want to buy.
All of this is very very hard, especially if you don't have a marketing background. It is surpassable though. It just takes time. I'm doing this full time and I still can't keep up. I can't imagine how you could possibly monetize a project part time, unless you're committed enough to spend the next five years of your life on it.
What drives our economy? Scarcity. What's the long term effect of capitalism? Commoditization, i.e. driving the costs down. Some people view open source as being about a post-scarcity economy in which human labor isn't need, an economy based on abundance. That's bullshit though. Open source is about commoditizing software developers in order to increase profits.
So the answer to your question is that there are only 2 ways to commoditize open-source:
1. make it a complementary to something proprietary and sell that instead; the "open core" model is known to work well for some companies
2. choose a restrictive license to make it useless for the target audience (e.g. GPL / AGPL for libraries)
You'll notice that I'm not mentioning selling support. Some consultants earned their name by contributing to open-source. But you can also write books, or blogs and you'd probably earn a bigger following. And you're still selling your own personal time, which is limited, as there are only 24 hours in a day, you're probably not a rockstar to have obscene hourly rates and if you're thinking of building a company around supporting open source, just don't, as you're not Red Hat and you'll never be.
I don't think that is the case at all.
If I have a woodshop and a customer comes in and hands me wood and nails, and I spend a day banging together a table for them, at the end of the day there is one table. A scarce good - one table is created, no more.
If I spent a day coding an Android app, publish it on Google Play, and it takes off and Android's daily two billion users take to it, my day's worth of work is not used by one person or one family. It is used by two billion people. Perhaps my app is mostly based on gluing together open source Android libraries and non-Android-specific libraries for the open source Android OS.
There is a scarcity and labor needed for the creation of the table or the app. The difference in the case of the app which almost for free goes out to two billion people, is that it's virtually free to copy and distribute it. It's really not even a commodity any more.
That's natural scarcity. We also have artificial scarcity imposed by laws and technology.
If you think that's unfair, I might agree morally speaking, but then we'd end up talking about how we're actually debating Marx's "labor theory of value" (i.e. value is given by the total amount of labor required to produce it), which was fundamentally flawed.
I agree that toilling at useless task adds zero value in the best case -more often than not, it adds negative value by creating commitments to perform further useless tasks in the future- but what is so wrong with considering costs of production within the value added? I think it makes more sense to recognize zero (or negative) value added task for what they are instead of declaring them "marginally valueable" and then try to push the externality of their cost unto others.
Commoditization is about goods being of indistinguishable quality in comparison with each other, such that the consumer doesn't care which is purchased, ie one barrel of oil vs another.
In my own case, I have a silly JS library with 4,000 hits per month to the docs, but "monetizing" that just sounds like work, whereas working on the library itself is fun.
My take on this is that more developers could try to follow that path, but we lack a bit of guidance (I'm lucky Mike Perham provided some useful insights to guide me actually) to reduce the anxiety & uncertainty associated with such launches.
The hurdles can be numerous & blocking:
- IP - making sure your consulting contracts are IP-safe
- Proper pricing (how do you segment your offer? how to avoid pricing "ceiling" effect etc)
- Distribution (e.g. I'm using http://packagecloud.io for our "paid gem")
- Proper custom ToS
- Product related theory such as "how to create leads channels" etc
- Billing & invoicing
- etc
Personally, I've decided not to attempt to "monetize" the OSS part, but rather launch a paid counterpart covering more advanced uses or built-in components.
I would love any further feedback you can share.
http://www.kiba-etl.org/ could use some work in stating the business problem and how Kiba can ease the pain of growing your own ETL. If you're not sure what an ETL is (or what problem they solve), the landing page provides 0 justification into reading more.
This is some great feedback - and yes, a new landing page is definitely planned!
There are two things that hold me back. First is never quite feeling like it's ready to charge for (perfect being the enemy of good). Second is I don't know how much time I can devote to supporting it.
Both are stupid reasons. I know this. I'm hoping to launch a premium service soon, and we'll see where it goes. If I spend 5 hours a day supporting it, I'll probably just shut it all off and prioritize my Turtl emails a bit lower like I do now. If I end up spending an hour or two a day on it and make some money, I'll kick myself for not doing it earlier.
Once you can identify the bug, it'll be easier to know what's making you hesitate. What's the basic belief you have about money and business that's held in your social circle, or attached to your identity?
https://www.inc.com/magazine/20110301/making-money-small-bus...
It's been ten years or so, but once I had an application I charged £5 for. There were so few users that support costs were always too high. Raising the price to £50 actually resulted in more sales, and fewer "Your application sucks" support-requests.
Now there are many great secondary reasons as an individual, in no particular order: I learn a lot, I got some paying gigs from my open source, better code through more eyeballs, it builds curriculum/personal brand, it feels good to be complimented, etc. For companies I'll guess also it's a great recruiting tool as you are not a name in the dark but you show your code (I've considered that when looking for a job).
Oh wait, I totally (honestly) forgot about your main question when listing the benefits. I would say that the common feeling (at least in JS world) is that open source does not give direct money, so few projects start with the intention of getting it and later on it's more difficult.
If you try to do it there is a whole topic on this: https://opensource.guide/getting-paid/
To OP, since you've opened this discussion would you please share your thinking as well?
The main reason most companies open source stuff is because they had to build something for some reason or another, the thing works, but they don't want to maintain it because it's plumbing and it's not mission-critical.
Sometimes it's easier to throw the thing on GitHub (where others might find it and at least use it) than throw it in your company's internal repository (where nobody will ever find it and it will rot away).
Most of the time it's much easier to leave stuff in internal repos than doing the effort to review and approve stuff for publishing.
In my mind, the best revenue model for OSS is something that is opt-in. For example, if a company wants to pay for enhanced support they can, but if not they can use the software and rely on community/best-effort support.
The main goal in my mind should be making greater resources available to the project while still allowing free use.
* It changes the dynamics of the project when other people see you're making money on it.
* Dual licensing might hamper adoption.
* Service contracts are not easy to work out, and the better your code is, the less likely people are to even need them.
The trouble with monetizing open source is that if your project isn't a "full product" like wordpress, gitlab, or discourse with a well designed interface and plugin support you don't really have a way to sell the product as a service which I think is the most lucrative way and you can then start adding premium features to this service if you want to go down the open core route.
So at the end of the day, it's just beer money, and just creates more headaches (legal, taxes etc.)
Red Hat Linux is the main counterexample. Companies do pay for their support, but CentOS nips at their heels and Red Hat has also lost the support of the "enthusiast" community which has largely gone to Ubuntu.
Cloudera is an example of the kind of "hype-driven" company that gets taken seriously because they get written about in TechCrunch every few days, but they don't have any unique selling point, particularly compared to the free Hadoop distribution. When they got started, the idea of offering a GUI client seemed like a good idea, but after the devops revolution this became value subtraction instead of value addition. (Why click hundreds of times through multiple forms to set up a cluster and have to repeat the whole process all over again next time you build a cluster when you can type a few commands, hit ENTER and have it be done?)
https://lists.centos.org/pipermail/centos-announce/2014-Janu...
Personally, I have a few projects on Github that seems to be somewhat useful to other people... but not a lot people (my most "successful" project has 61 stars, not bad for a side project but ridiculous if you compare it with big projects in the thousands of stars).
Trying to monetize it doesn't worth the burden, maybe I could get a few bucks with Patreon or gratipay, but I would need between 100 to a 1000 times what I could reasonably expect to be given to make a living out of it.
Monetizing them also means I would have some moral obligation to maintain them properly. This really depends on your view on the question, but for me it's kind of import. Right now, I try to respond to bugs and PR as fast as I can, but if I'm feeling lazy or if the issue is to complex to be fix, I can leave it opened for months. Maintenance is purely best effort.
I've started these projects for various reasons, but one common denominator is that they enabled me to learn some stuff and/or maintain my competences (setup proper unit tests, documentation in rst, more advanced knowledge of Python, de-rusting my C, cmake, OpenSSL programming, Puppet types and resources...). One other side effect is that these projects give proof and credibility of what is written on my CV, so, in fact, it's not completely un-monetized...
Also, another driver for publishing these projects is: "why should I keep that to myself? it might be useful to other people" and even if it's not, GitHub is a convenient place to store code ^^.
I'm speaking for my personal projects, but I think I'm far from being an exception, big OSS projects that can be monetized are the exception, they are often core components (a kernel, a big library or framework, a big piece of infrastructure...), but many more smaller projects live (and die) around them serving their small purpose (if any).
Just donate 5% of the previous annual license fee to the project you're now using, each year. You still save 95% on license fees and developers get to eat.
That being said, you will likely get different answers on HN than you would on, say, r/programming or IRC.
Monetize it is not always the goal.
Here are some of the reasons monetizing is either not feasible or not desirable:
* for small projects, most contribution is done in free time by one or a handful of maintainers for a most part and some random flyby contributions every once in a while. In such cases monetizing would imply more work that distracts from the primary work of building software and the maintainers do not want to spend their free time doing that.
* even for slightly larger projects that possibly commercial companies depend upon, monetizing would imply a change in prioritisation in what gets done. The maintainers would be obligated to invest their free time in doing what paying customers need rather than what the community or the maintainers themselves want.
* for even larger projects unless the interest reaches the threshold where the maintainer(s) can quit their day job and depend on the money coming in from the monetizing it just eats into their free time for not enough money
There are other reasons as well about how to come with a scheme where those contributing do not feel like they are submitting patches just so that the maintainer(s) get to make money for their work, or just the principle of the thing about paying it forward to the community they got so much free (as in beer) knowledge and experience from.
1. Start a convention around it, which could be profitable 2. sell swag, T-shirts and the like (lets say it's a limited quantity that can only be bought by contributors, then it becomes a prized way to show off) 3. in app purchases, for example if I made a photoshop equivalent, but had it linked up to a font store. 4. Get companies/governments that use your software to give you Grants.
That's all I've got that hasn't already been covered. I know a few open source guys who just feel dirty about getting money for it. Personally I'm the same when I make art, I don't want it to be a job, when it starts becoming a job I stop enjoying it, and every time I've taken a break from art in my life it's because it started feeling oppressive like a job. As I learn to code, and as I start to enjoy it, I worry that a similar feeling may happen, in which case I may have an open source project or two on the side just for funzies while I have my moneymaking job separate. I think I would be happier with such an arrangement.
This may rarely work out, otherwise it's a lot of work for below minimum wage. I tried to see if there was enough out there for one project I've been working on for years ( http://zynaddsubfx.sf.net ) and my attempt (like several others in related communities) was a flop. It was interesting from an experience side of things, but in the end the project was too niche to support itself (like I'd imagine most open-source work is).
You don't know everything about the activities of open-source developers with regard to their project. They may be involved in service contracts and dual licensing, without that being advertised on their project site.
Many open source developers probably shy away from that option though because they're afraid that fewer companies would use their library in the first place and they're also probably not entirely mistaken:
Enterprise companies are wary of effects licences like AGPL might have on their ability to keep their source code private. Unfortunately, those companies more often than not aren't exactly eager to pay for a licence that allows them to do just that either.
This new economy of everyone monetising everything sucks :/
1. Because companies don't want to pay license fees, so then don't use the damn software, who cares.
2. Oh you should just beg for handouts instead, because your effort and work isn't worth crap and you should be lucky to eat the crumbs of the massive tech industries table.
3. Oh don't sell the software, sell a bunch of crap around it instead.
Its about time developers stopped being afraid to charge for their effort.
If you want to charge those who commercially exploit your work, than dual license the damn thing.
Some were done in a "scratch an itch" fashion and author is not interested in maintenance.
Some are research work where a given university (and not the author) would have to draft a contract for anything monetary.
Free as in un-bound software.
Some see a benefit in contributing to a shared collective good.