A new license for Paint.NET v3.5

Over the years I’ve had to put up with several individuals, and companies, trying to plagiarize Paint.NET by recompiling the program under a different product name and with their own name stamped into the credits. Sometimes they charge money for it. I even came up with my own term for it: “backspaceware.” Additionally, every once in awhile Paint.NET is spotted being sold on eBay.

And, as many of you know, Paint.NET used to be open source. Or rather, it was “released source” – the source code was released, but it was never an open and collaborative project that accepted unsolicited code submissions. I liked releasing the source code this because I felt there was value in allowing others to study it. About a year ago I decided I was tired of seeing plagiarized versions of Paint.NET and I yanked the source code from the website. However, the source code was still out there at various places on the Internet (hardly illegal). Even without the source code, a clever and skilled person could probably still decompile, modify, and recompile the program to say or do whatever they wanted it to.

The biggest problem was that, even though these were clearly unethical and deplorable actions, the MIT License permitted all of it. Or, at least, it was unclear in some corner cases what was disallowed. So, legally speaking, it wasn’t clear what exactly could be done about it anyway. I am not a lawyer and did not want to spend thousands of dollars to get it all figured out. Some people have stated that I chose the wrong license, and in hindsight this is definitely partially true.

Also, this is not just about plagiarism and my own personal blood pressure. Having derivative copies of Paint.NET out there causes confusion and disrupts the mainline user base. I’ve had people e-mail me confused because they thought that Paint.NET had been renamed, but that features were missing in “the new version”. These derivative copies also cause a bit of a mess, because they often 1) uninstall the real Paint.NET (they use the same Windows Installer product GUID), and 2) still have the same updater logic (including the URL for the manifest). Which means you’d install the derivative copy, it would remove Paint.NET, and then once Paint.NET had a new update it would uninstall the derivative version and replace it with Paint.NET, etc. Or, the modified version would crash and the crash log would still instruct people to send it to my e-mail address. There is also a real risk of trojans and viruses.

All that stops now.

For the final release of Paint.NET v3.5, which will be very soon now, I am updating the license. For most users, this will have no impact whatsoever. It’s still freeware. There’s still no claim on any files created, opened, or saved with Paint.NET. You can still mirror the ZIP file on your website (e.g. Betanews, download.com, etc.) without having to ask permission. You can still sell stuff that you make with Paint.NET (assuming you have the legal right to do so in the first place, of course). You can continue using it in a business environment, deployed to as many systems as you like.

However, the license now states that you cannot modify Paint.NET itself, or create derivative works based on the Paint.NET software (that is, derivative software). Nor can you sell it. I don’t believe this will have an impact for anybody but those who wish to plagiarize or rip-off Paint.NET. I’m not putting in any restriction about reverse engineering or decompiling, e.g. with Reflector. I think that would be silly, and I still whole heartedly believe that there’s value in being able to study Paint.NET’s code – even if it’s Reflector’s best-guess disassembly. However, you cannot modify and then recompile a new version of Paint.NET from that disassembly.

There will undoubtedly be some confusion here. For instance, “Are plugins allowed?” Absolutely yes – the program is designed to accept these, and they are not modifications to Paint.NET itself. No doubt I will have to update the FAQ for this, among other things.

I expect there will be a very vocal minority that will condemn this license change. Before you speak out, please ask yourself this question: Does it actually affect you? Were you actually planning to do something that this new license disallows? My guess is that the answer is “no”, but please post a comment if the answer is a legitimate yes. Many people had condemned my decision to remove the source code, but upon further investigation it was purely a matter of principle: they had never downloaded the source code, never knew anyone who had done so, and never planned to do anything that would benefit from or depend on source code access. I’d liken it to being upset that your passport disallowed traveling to Antarctica … were you really planning to do that in the first place?*

The other thing I am planning to do is to release portions of Paint.NET v3.5’s source code, probably under an MIT or BSD-style license. Plugin developers will greatly benefit from having the source code for the effects, and for some WinForms UI controls. The best way to summarize things is that this new license (below) covers “the binaries”, aka “what you just downloaded and installed.” I can still create separate download packages that are covered under different licensing terms. Philosophically it can be confusing, but I’m willing to pay that price.

Here is the new license, for your perusal before the imminent release of version 3.5:

Paint.NET is free for use in any environment, including but not necessarily limited to: personal, academic, commercial, government, business, non-profit, and for-profit. “Free” in the preceding sentence means that there is no cost or charge associated with the installation and use of Paint.NET. Donations are always appreciated, of course! http://www.getpaint.net/donate.html

Permission is hereby granted, free of charge, to any person obtaining a copy of this software (the “Software”), to use the Software without restriction, including the rights to use, copy, publish, and distribute the Software, and to permit persons to whom the Software is furnished to do so.

You may not modify, adapt, rent, lease, loan, sell, or create derivative works based upon the Software or any part thereof. However, certain icons used in the Paint.NET user interface are from or adapted from those in the “Crystal” icon set, http://www.everaldo.com/crystal/, or the “Oxygen” icon set, http://www.oxygen-icons.org/. These icons are covered by the LGPL license, http://www.gnu.org/copyleft/lesser.html. These icons are stored as “loose” PNG image files in the Resources\en-US\ directory where Paint.NET is installed.

The above copyright notice and this permission notice shall be included in all copies of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

It seems awesome. I think that the part of the software source you release is fine enough for me. I can’t say I am happy with those who caused this issue to begin with. I understand your position completely and wish you the best of luck when 4.0 comes around for release.

Anyhow if you would like to join my software forum and site feel free. Its still under active development but I think you might enjoy the look and feel.

Once signed up setup your dev profile to upload your files.

I will be including a subset for plug-in developers eventually for app that have that ability…

No complaints here. As a user community we should applaud anything that lets you focus on making better Paint.NETs. Dealing with lowlives takes you away from that; any reduction in the lowlife management requirement can only be a Good Thing. I’m pleased to see that you’ll still publish interesting/relevant bits and pieces – I learn stuff from those.

I read your post and I must say I really understand where you are coming from. For educational purposes I studied the evolution of the Pain.NET codebase a _lot_ during its evolution from 3.36 to 3.5 using good old reflector.

Maybe I am just a crap programmer or maybe you are extremely talented but I couldn’t even dream of creating something like this on my own. Although I understand most of the inner workings I cannot imagine ever being able to dream it up myself.

I have to develop some C# applications for my various research projects. Since I have only limited time I have to focus mostly on getting the core of my software to work flawlessly (which involves interaction with some specialized hardware). There is almost no time to try and create a user friendly UI that updates smoothly and is more or less intuitive. Things in Paint.NET such as the appworkspace, toolform floats and snapping of thos floats however, would translate very well to my application (which has a lot of forms to set parameters of HW).

Also, all the stuff in the Functional and concurrency, … namespaces can have many many uses in other applications. The way crash reports are generated is also unbelievably convenient (since co workers also use my app when I’m not around).

It will no secret that I would therefore love to adapt these treasures in my own software and I have to admit I already came a very long way getting the often clumsy Reflector output back into compilable and usable form. A test branch of my application has a lot of things implemented but until now I did not dare to actually install it on the lab computers, exactly because of the unclear license situation. Here and there I also still have questions about how certain things work because I might want to change things in my own code…

I don’t want to come off as just the next brainless code thief that just want to leach off of your years of hard work… Therefore I wanted to ask:

1) When you talk about releasing parts of the source, do you already have an idea about what assemblies will be covered? (base, systemlayer, …)

One thing I must say, and this may sound really silly here in this thread, but when I installed paint.net before it seems that the installer process does something to optimize/speedup the machine… Am I just dreaming?

…I don’t know what the installer does behind the schemes but if you using some technique to improve performance during the installation of paint.net maybe you should release a small standalone utility that would do the same type of cleanup/sorting the installer does.

What about the efforts to (unofficially) port Paint.NET to Mono? Will we Linux users ever have a port of this?

I know the port is not something you have ever endorsed; but there are a lot of Linux users (me, for example) who are seeing this as killing any hope of seeing a Paint.NET for Linux. Is that an unintended casualty, or is it done on purpose?

Anyway, it’s a pity. I will have to continue using the GIMP. And GIMP it’s great, but I prefer your UI much more…

AA, paint-mono is based on the Paint.NET v3.0 source code. This license change won’t affect that specific project because of that. But, there really hasn’t been any activity on that project anyway. I wouldn’t hold your breath on waiting for Paint.NET for Linux. I certainly won’t be involved in working on it, because I don’t use Linux. I don’t have the time, skill, desire, or incentive to do a Linux port.

Let’s hope the Krita guys solve their issues, or the GIMP ones get a better UI before 2012.

Thank you, Rick, for a quick and clear answer. And thank you for this nice app, too. I will continue using it in my travels on Windows land, until the Krita guys solve their issues, or the GIMP gets a better UI. Let’s hope it happens before 2011…

AA, I’m not sure what you mean by “there goes the portability of .NET apps.” .NET was never intended to be a platform that powered apps for both Windows and Linux, without requiring any source code changes.

To be honest, this licensing change for Paint.NET doesn’t change much at all for anyone.

I’ve been hoping to take a look at the Paint.Net source for a while – especially the portion you say is written in C++ to speed up boot times. However, even the source code decompiled using Reflector (eg. not the startup code) is nothing compared to the original, well-formatted, commented code written by Rick Brewster :)

For a while now I’d also been hoping to teach myself a bit more about the .Net API, while helping you, by fixing the unintuitive right-click in Paint.Net (on the canvas it controls secondary color, while in the colors-window it does nothing. In some other windows, it acts as a left-click). This is fairly hopeless without the source.

Since strings like author’s name and program-name can be easily changed, even with just a hex-editor, it seems like withholding the source code only impedes us good guys. Don’t get us wrong, we really appreciate you offering this program for free… but you know what they say: If you give a mouse a cookie…

>>.NET was never intended to be a platform that powered apps for both Windows and Linux, without requiring any source code changes.

But Mono is, and some people thinks because of Mono .NET apps are nearly as portable as Java ones.

Of course, this kind of misconceptions are not something that should bother you. The people who should be ashamed is the ones who sold people the “.NET is portable” myth, and now are incapable of making work any major .NET desktop app outside Windows.

AA, well, any portability-with-no-work type of system will have compromises. For example, you won’t be able to use any Windows- or Mac-specific features. Just look at the typical Java client apps out there. They look pathetic and are difficult to use because they don’t use any of the native controls, etc. I don’t personally hold on to the portability-for-the-sake-of-portability belief. It’s a fun academic exercise, but not worth it. You end up with a least-common-denominator solution that nobody ends up being very excited about.

While I completely understand why you’re doing this and agree with it, it does make me a little sad. As someone who programs in C# for a living I did enjoy being able to download the actual-undecompiled source code and learn from a more experienced programmer.

I had created a thumbnail viewer using a small bit of code from the last source-code release (the code from the shell extensions that finds the thumbnail image…the entire .cs file is only about 170 lines). The main intent was that on a gallery site, users could upload .pdn files and see thumbnails magically appear as place-holders for the .PDN files.

If the file format doesn’t change significantly in v4.x, then I could just alter the “magicnumber” code, and keep it working, but if it’s something substantial, then am I allowed to reverse-engineer the new file format to grab the thumbnail image data? Is that considered modifying or adapting?

Sorry, I really don’t understand your reasoning. On the one hand you’re justifying the removal of the source code by saying people were distributing plagiarized versions, but then you also say it was an over-liberal licence that gave them permission to do it. If that is the case, why can’t you release the source but give it a non-commercial, attribution-required licence? Sure, some people might violate the licence, but if they’ll do that then they’re probably just as willing to decompile/recompile with reflector, or just hack the binaries to remove attribution anyway, and the availability of the source is no obstacle to illegally selling it. It is mainly an inconvenience to people wishing to learn from it, or port it to another platform.

With respect to protecting the Paint.NET “brand”, and not having a proliferation of different versions, why not just adopt the same approach web-browsers use, where source-compiled versions are named differently. If you download and compile a nightly of Chrome or Firefox, you actually get programs called “Chromium” and “Minefield”, that install and identify themselves separately. Only centrally released versions are allowed to use the “official” name. You could easily include a license requirement with the source stating that modified versions must display a prominent message saying they are based on Paint.NET, but compiled from modified source, and thus not supported by yourself.

On the issue of porting, surely that is exactly the case for making the source available? You don’t have the time or interest to port to mono, but other people obviously do. Perhaps the lack of activity on the existing mono port is due to the removal of source code meaning that new upstream fixes and features can’t be brought over to the port. Isn’t that strength of an open-source approach? That you can share labor, and people can focus on the bits that matter to them? So you can concentrate on the core of Paint.NET and the Windows version, and people who care about the Max and Linux can work on ports themselves, whilst still keeping up to date with the improvements you introduce.

Personally, I love Paint.NET, and I really appreciate the incredible effort you’ve put into it. But I also like the open-source model, and I don’t think the problems you’ve described require a closed-source approach to solve them. With the correct setup and licencing, as described above, I think you could easily manage to release both source and binaries, allow people to study and port the software, while requiring attribution, preventing version confusion, and stopping plagiarism.

How sad. Having benefited from the open nature of the source, the stable door is being bolted. There isn’t really an explanation why you feel so pressured to provide any support, not least to people downloading unofficial distributions. It seems everyone loses here, except the notion of brand purity. Good luck with that.

I don’t mean to sound ungrateful, but Paint.Net has become another image editor I could download from anywhere. The source code was the difference, Jon is right above.

I have grown a particular interest in the Pdn source since the availability of the last publicly available source release (3.36). The source obviously contains a lot of stuff that is generally useful if you know what you’re doing (I probably don’t times, but I like to think I do :).

Ever since 3.36 there was no available source anymore but since I was quite keen on learning more I continued using Reflector, going so far as to decompile and export the whole lot. It was a HUGE task, but I am now at the point where I can say that I probably have 90% of all assembly source files back in human readable, commented and compilable form. I even started to roll my own version of the native stuff for CPUID and the like. The installer is another matter maybe, but I don’t care much for that anyway…

Mind you, I have no malicious intent with all of this and I will keep these files locked down better than all the gold in Fort Knox (and would even delete them if you would ask), but if I can do this, then so can everybody else… I’m not the hottest C# expert on the block, really! It wasn’t until looking at the Pdn source that I thought it might be nice to figure out what all this fancy lambda/anon methods/whatever shenanigans were all about, go figure.

So in any case, if it is possible by mere mortals to do things like this in reasonable amounts of time then it’s certainly possible for the millions of talented programmers in poor/lawless country X or Y to make a quick buck selling Pdn as backspaceware anyway.

Getting your hard work ripped off by others is probably always a risk when creating software. Whether or not you ultimately like to share your source code with the rest of the world is of course your decision but might I respectfully suggest that the “backspaceware” issue might not be the best way to rationalize things?

Right now, even with a new license, the situation remains very unclear. 90% of the source is easily readable, it is just a pain to refactor the, some-, nay oftentimes dodgy reflector output. So in principle, one could use parts of your source code, but if one were to do so, for example in an app with completely different functionality… does that constitute a “derivative work” ? Probably yes. But then again, if you leave the assemblies de-compilable, people will always go look at them, will get inspired by them to some degree… and then where do you draw the line between “allowable” and “not allowable” use of that information? Especially since you somtimes post about the inner workings on this blog anyway.

Now here’s to hoping you will not obfuscate the crap out of your next release, but I just have lots of questions and a valid discussion about this might shed some light.

I’m sorry to hear you feel that way. If I was only thinking about my own needs I wouldn’t even bother to post/Email/whatever. I have what I need already, useful bits of source code…

I just wanted to have a clear picture of what I could and could not do with the bits I have right now and how I should reference your work. After all that is what we do in science every day and it’s only proper.

I will most likely use certain things. I could just keep quiet and go ahead with it and nobody would ever know, but that’s not the way I like to work so that is why I started asking about it.

Given the fact that you do not provide a clear answer at all I figure anything goes, point well taken :)

Kris, if you have the 3.36 source code then you can do whatever the license says you can do. I can’t (neither legally, nor ethically) retroactively change the license you have. I appreciate a reference/mention/credit, but the license doesn’t require it.

You’ll have to forgive me if I get a bit grumpy what with the constant barrage of questions, criticisms, and self-entitled commentary from many people.

I don’t mean to be “self-entilted”, but you do have a blog with a comments section, so perhaps you should expect honest communication.

I’m a professional web developer and used Paint.NET frequently when GIMP was more then I needed. I came across Paint.NET in college, where it was installed on every CS Computer, and played with the source project when I was learning .NET.

I never used it because it was free, I used it because it was open, and that was far more important. Frankly, I’m happy to pay for pro tools I need and when I don’t need those tools, I will use the open alternative.

The rip-off versions are a concern, but this was hardly the only solution – or even the best. At least if it was open source, many organizations would be willing to go to bat for you on those issues.

I suppose that you want to personally control this code from here on out, and that is your right. But to me it’s a shame, especially when I see the collaborative success of the other projects I use daily (or the tools that power this site). Tools that I can and do hack, fix and submit patches to.

That’s my opinion, I expect nothing for it. I wish you the best and continued success for Paint.NET.

As a new user of Paint.NET, I’m shocked at how advanced it is. I’m a proficient programmer in a bunch of languages and environments, and I think what you’ve done here is top-notch.

Source or not, the tool is valuable and will continue to be that way probably for the majority of your users.

As a sort of off-the-cuff suggestion, why don’t you have a binary-is-free, but source-access-is-pay along with an NDA? Perhaps with a tiered approach where some of the non-core/utility code is free/open, some of the more important/tricky code costs a little bit, and the core Paint.NET code costs a lot?

Sort of a way where you get reimbursed for your hard work, yet people who really care can still get some level of access.

Anyway.. hopefully this won’t start a flame war. I do support and prefer open source tools, but I also have a day job. And no, you can’t have any of my source. :D

At the end of the day, it’s YOUR application, YOUR code, and YOUR decision. I think you’re doing the right thing to protect YOUR work!

In my non-legal-guru interpretation, derivative work suggests that the code can’t be used in any type of “image editing” application. It doesn’t, however, exclude the use of code snippets for UI elements (like your use of DirectWrite or GDI for UI elements in 3.5) to improve application performance.

I have to assume this choice of wording is intentional (for those who care about it), because I’ve read through numerous posts, and it is clear to me you’re a pretty reasonable guy with a genuine interest in sharing knowledge.

Alex: They do nothing to *prevent* this sort of thing. They merely make it so that if you do so, you won’t comply with the license anymore. And that’s has been the case before already anyway. Doesn’t make it much easier to actually go against such people.

It’d only take a few minutes to delete it and ZIP up a new one when there’s any changes.

I see the installer for PDN 3.5 has ‘bloated’* to nearly 5 megabytes.

(*For small values of ‘bloat’, but I’ve been a computer (ab)user since 1983 and one megabyte files still qualify as ‘giant’ to me.)

I’m not a fan of online-only documentation because I like having docs/help available in places where there’s no internet access. Even with access, there’s always the waiting for the download or times when the net just won’t bleeping work due to problems upstream.

First off PDN is a great product and I really like/use it. Secondly, the source code is great. I have the old BSD 3.0 or so code and have extracted functionality out of it for my own use. I assume that was what you intended for people to do by releasing it under the BSD license. In any case, it has been very helpful to me, and I would love to see some of the updated 3.5 code.

It is really a shame that some people have plagiarized your work, as apposed to incorporating aspects of it into their own work. I wish there was a license that you could use that would allow people to reference your code, and use pieces that they may find helpful so long as they do not create a work that competes directly with Paint.Net.

In any case I am grateful for your work and appreciated being able to reference your code when it was available. I would be grateful for any access you do give to your source in the future, if you find a way to do this…

While I fully support your right to control your own code, and am by no means a free software zealot, I’m nevertheless disappointed. It’s unfortunate that such an excellent piece of software is merely free-as-in-beer, not free-as-in-speech. I had been hoping that, as time went on, you would loosen restrictions and move towards something like the GPL, but it seems you’ve gone in the opposite direction.

Don’t get me wrong, the software is awesome, I use it, I will continue to use it, and I’m happy to have it. I had just hoped, and wanted to voice that hope.

I never intended to download or peruse the source code Paint.NET, but the fact that PN was an open-source-like project appealed to me and was a major factor in taking the time to learn about it and pass it on to friends and family who might like it also. I use open source whenever and wherever I can even though I am not a developer. It gives me a sense of security for the continued life and availability of the program. Admittedly this sense is sometimes false as it doesn’t matter a whit if the code is available but no one understands it or wants to work with it. However with OS there is the *potential* of carrying on when the company/developer loses interest or heads in a different direction.

I fully support your right and desire to choose the sharing and distribution terms which fit your needs. I just wanted to bring into this thread the idea that open source licenses are important outside the developer community as well.

Same problem applies to any open source software and it isn’t usually big problem. Especially talented developer like you shouldn’t have any problems.

After closing the source there is just developers word of freeware product. There is also no chance to see if this product is trustworthy as it could contain spyware or just major programming flaws which can compromise security of the computers of the users.

In principle I like using software which is really free which means releasing of the source code also. It’s quality is guaranteed by developer by releasing the source code as someone could really develop better product based on previous work if needed (and in this case you have great software and skills).

There is bad people out there which use this principle as their own advantage – and there is always stupid people who can be fooled. And if these people have hurt reputation of Paint.NET (thought my opinion is that these hoaxes are marginal problem) the decision of closing the source hurts it much more.

Since version 3.5 I quit using Paint.NET in my personal and company’s computers and won’t recommend it no more to anyone. There is other really free products with self-confidence available. Or if using closed source it’s same to use Photoshop as it’s just money. I have been happy user and used Paint.NET for many things, thank you for that :)

@GRinda – how do you know that the source code that the GIMP is releasing is the same code they compiled into a binary? How do you know that they didn’t compile a spybot into the downloadable version? How do you know that they didn’t use good practices in the source, but imbue the final version with evil from the pits of hell itself?

But the big question is, why would you cripple yourself and your company by refusing to use a program that hasn’t changed anything in this release?

Do you really think there was no value in having Paint.NET open source? First, FOSS gives strong guarantees about the fact that the software will be maintainable in the future and that it won’t be crippled in a future version for commercial reasons. Of course to you as the developer you don’t care about those guarantees, since these are guarantees that protect the user from the developer and ensure the developer plays nice. But to me, it meant I could feel confident that saving files in the .pdn format was a good idea and that I would always be able to read and modify them in the future. Now that Paint.NET is proprietary, this is getting a bit murky. Even if you did intend to publish the specs, it’s a legitimate reason to feel uncomfortable and to prefer similar alternatives like GIMP; I don’t care much for its interface, but retaining control over your data trumps interface improvements every time.

Next, you “don’t believe this will have an impact for anybody but those who wish to plagiarize or rip-off Paint.NET”. Wrong. Source code allows you to actually fix things in the code, here is a patch I sent you about an admittedly tiny problem:http://paintdotnet.forumer.com/viewtopic.php?f=10&t=25391
Sure, this is a small bug, but precisely for that reason, would you have bothered looking into and fixing it if I hadn’t been able to read the source code, pinpoint the bug location, and write the patch?
Also, notice the last part of my patch: upon reading the source code I encountered a problem involving a subtle inversion of the red and blue color components in the luma calculation. Would I have been able to notice that without the source code? Would you have reread that code yourself and found out about it? Open source gives you many eyeballs, which definitely helps make higher quality software. Note that I don’t pretend that my patch was very important, but it’s a good example of precisely why and how open source is valuable. So if I were to use Paint.NET 3.5+ I wouldn’t be able to fix any similar itch I might have, and I couldn’t help the software improve.

Now of course this is your decision, but seen from afar it looks like a huge overreaction to make your software entirely proprietary in response to 2 or 3 dumbasses who don’t have a clue about intellectual property or even common decency. To me having an equally free yet more useable alternative to the GIMP was a major draw to Paint.NET. Maybe you didn’t license it as free software on purpose, but I certainly wouldn’t have bothered to use or advertise it if it was proprietary like the hundreds of freeware image editors out there. I sincerely hope you will reconsider your decision.

I’m not a programmer at all, and if Protecting some of the Code is what you have to do to keep your name being affliated with some dirt bag, then do it.

I love your Program, not only because it is free, but it is up there with Corel Photo Paint, and Adobe Photoshop. Your interface is great, and the ease of use overall is fantastic. If I had my choice, I would be using Paint.net at work, but I’m not the IT Guy that controls all of that.

I don’t see a problem with trying to protect that. The End Product is great, and I look forward to new releases in the future. My 10 year old daughter enjoys it as well, and to me that is a definate plus. It gives her and I quality time together, and the two of us learn from each other. She, all the time, is showing me a tool that I overlooked, and I work with Photo’s quite a bit.

The background code I have no desire to learn, but how to effectively use the software. To me that is the key.

noisenose, Citing a very small patch for Add Noise and GetIntensity() doesn’t exactly prove much. Your other statements are not logically sound either, e.g. “FOSS gives strong guarantees…” No, it doesn’t. Not in the least.

This doesn’t affect me, but I just wanted Rick to know how great his product is. I love Paint.NET and the continuing updating and availability of the (compiled) software is all I could ever need. Keep up the good work!
(and don’t let the naysayers get you down)

I would have to agree with Jon. Your reasons for closing the source don’t make sense. The problems you described are still very possible and will more than likely continue to happen. While its your code to do with as you wish I think you have made a mistake. I’m not a developer but i certainly benefit from code being open source (firefox, linux, openoffice etc.) and I typically only use/recommend software that is for many reasons. I will not be upgrading to the newest version of paint.net and will be looking for an open source alternative to use in the future.

O source, I have not made a mistake, and you’re suffering from the same fallacy of looking at the situation from YOUR perspective instead of mine. Clearly you’ve never worked on a very large project that you were personally invested in only to see it ripped off and plagiarized.

Releasing the source code for Paint.NET did have benefits, but the cost to myself simply wasn’t worth it. (This statement includes the time to package and verify every source code release — when doing bi-weekly or monthly updates, it adds up significantly.)

I believe you overestimate the benefit you have had from open source. (Not from the software itself, but from their open source nature specifically.) And Paint.NET was never really open source anyway — like I said in my post, I’m not sure how any of this *actually* affects you.

Anyway I’m closing commenting on this post. There’s been literally zero productivity here. I shouldn’t have even posted this to begin with.