We’re working on a .Net framework which ultimately amounts to a single DLL. We intend to charge for commercial use of the framework, but make it free for open source/non-commercial use. The rough plan at the moment is to administer this through some form of fairly simple licence which will be issued whether you’re using it for free or paying.

We’re debating whether to make the source code available. It’s our perception (and our own preference) that it’s far more appealing to use something where you have access to the source code.

I’m interested in whether people think making the source code available will damage our ability to make money from the framework, or whether it will encourage more usage and enough “good” people will arrange to pay for the correct licence if using it commercially.

My feeling is that, generally, commercial operations don’t mess about on the licencing front and so making the source code available will only encourage usage and therefore ultimately generate more revenue, but I’d be interested in others views/experience.

  • 2
    Of course it affects. If other people wouldn't make their source code available (of the tools we use), we would make less revenue!
    – P Shved
    Commented Sep 10, 2010 at 20:51

7 Answers 7


You should definitely make the source available. Whether it's freely available or only available to those who buy a license is up to you, but I would never use a third-party library with no source. Unlike Robert Harvey, I emphatically do not "know that I will probably never need it." Any library of non-trivial complexity is almost certain to have bugs in there somewhere, have missing or poorly-implemented features that could benefit from customization/extension, or most likely both. (Yes, even yours.) I've used a lot of different libraries, from different people and written in different languages, and I can't think of any that I've never needed the source from at one point or another.

If you want to do it right, add a provision in the license like what the GPL and MPL have, that if they make changes to the code and end up publishing a product using it, they have to publish the changes they made. That way you get free bugfixes and (potential) features just by letting other people use your code.


If it is a managed .NET framework, people can use Reflector to look at the source code anyway.

I've seen a number of companies that appear to work this dual-licensing model successfully. Having access to the source code doesn't necessarily mean that people will steal the code. Personally, I would rather be properly licensed, as has any company I have ever worked for. But having access to the source code can encourage people to try your product out.

There's something about having access to the source that feels like a security blanket; you know that you will probably never need it, but if you spend many man-hours worth of effort committing to a third-party library, it's good to know you can dig into the code and fix something if you ever get into a bind, or the original author of the code gets thrown under a bus.

  • 2
    Thanks for your thoughts - for the most part I totally agree, but I think that there's a minor difference between using Reflector to look at source code and being able to clone a repo on GitHub and compile it. I know you could get to something compilable via the decompilation route if you really wanted, but most people probably wouldn't bother.
    – dwynne
    Commented Sep 13, 2010 at 19:08
  • Reflector has an add-in that will dump the assembly to class files. I believe it will even make a solution file for you, and add the necessary using statements. Commented Sep 14, 2010 at 1:08
  • 4
    ..but Reflector can't deduce good variable names, write comments or de-obfuscate. Commented Oct 24, 2010 at 8:39
  • If you have access to the source code, there's no need to go through a source code Escrow service to insure against the vendor going out of business. Commented Oct 24, 2010 at 8:41

Personally I think that the best example of this is the way that companies such as Telerik and others do their licensing.

You pay for the license, you get the source code, and it is for your use.

If you make it under a method where it can be available for opensource/non-commercial use free, with source, I think it will be hard for you to get people to come forward and pay for it.


In general people who will pay for your tool will pay for it anyway, and people who will steal it will always steal it.

Besides, it's just good business sense (advertising) to give away your product to people who aren't your target audience, because they either know (or will know) someone who is in your target audience, or will be there themselves.

Why do you think FogBugz has the Student and Startup license? They're providing a valuable tool for free because it costs them relatively nothing, and when you get to the point where you're making enough money to pay the $20-25/mo per developer (heck, that's at most an hour of developer time at competitive wages here in Arkansas) then you'll be perfectly happy to write that check out to FogCreek.

I haven't seen any studies, but I would certainly bet my own software on it.


Making a $ from something where the source is given away is kinda hard.

The idea of selling licenses which include the source is more sensible, especially on the context of this being a library. People will have to poke into the internals now and again and that needs to be easy for them to do.

Just putting up everything, source and all, and expecting revenue? Might get a few who pay, but there will be a large number who won't.

  • 1
    I note a few downvotes. If you downvote, how about saying WHY ? Commented Feb 5, 2012 at 11:02

If you are making some type of platform that can be expanded to a better degree through open source code than doing it yourself and charging, the apps you create and sell based ont he platform may be better off in the long run. I guess the key is not to give away all the code; especially the part that differencitates you to the point of being able to sell it.

Isn't this what the people involved with Ruby on Rails did?


I think that having source can come at two levels.

  1. Source for the classes you have but not in a state where it is easy to rebuild the distributed binary. In other words, you can see but not touch.

  2. Full source in a form that can be easily rebuilt.

I as a developer strongly prefer the latter, as it allows you to hot fix a problem. It might be the decisive factor when given a choice between two libraries!

The thing to protect your source must be the license. Let the Open Source version be GPL and allow business to purchase a non-GPL version to be included in their commercial non-GPL products.

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.