The answer of DougM and AER makes a fair point.
MPLv2 and LGPLv3 with static exception are the same regarding the events that would trigger the copyleft.
However, I think we are missing another very important difference between LGPL and MPL. When the copyleft is triggered, the copyleft applies to:
- for MPL: to the very exact same files of your original library
- for LGPL: to the "work based on the library" as opposed to the "work that uses the library". So the LGPL can potentially extend its copyleft to new files.
Edge-case: Using MPL enables users not to share their improvements
MPL is a file-level copyleft license. It means that if somebody embed it in a larger project (statically or dynamically) and make a change to your file, he only has to release the change made to this particular file.
If you are concerned about keeping the integrity of your code base open, there are edge cases in which this copyleft effect of MPL might not be sufficient.
For example, someone could take one of the main file of your project, add "import my_private_new_file", and modify your main method for example by adding "my_private_new_file.newAwesomeFeature.run()".
And this way he could add new features to your project while only releasing the modified main file and keeping the actual logic of the new feature closed source in "my_private_new_file".
Having the main file back to the community just give you the information that "hey you added a new feature" but it doesn't enable you to incorporate this new feature in the open... It can be annoying if the new feature is closely-related to the problem that your library is trying to solve.
Obviously, that's an edge-case and it is quite unlikely someone would want to do that, but it is a risk that you must be aware of when using the MPLv2.
The LGPL is written to forbid such behaviours.
I quote the original LGPL license:
Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, whereas the latter must be combined with the library in order to run.
The copyleft applies to the "work based on the library" only.
Now what is a "work based on the library" in practice? It leaves space to interpretation. Which is not only a nice thing as it means complying with your license becomes more complicated and therefore scary. It could lead some people simply not using your library.
In this sense, LGPL is more restrictive than MPL, but also more protective of the integrity of the project.
MPL makes it easier for users from the proprietary world to fix your library and use it, while still having to share the fix
An advantage for MPL is that if a user finds a bug in your library, he can fix it directly in the file, without having to give away all his code but only providing the fix. Practically speaking, when distributing his work to a client, he can just provide a link to a fork of your project containing the fix, and he is good.
By using LGPL, things are more complicated. If somebody forks your project, fixes a bug, and embeds it statically into his proprietary software, he must distribute to his users the "work based on the library" under the LGPL. Which is a rather obscure notion, especially when the library is statically embedded...
In this regards, I think it was the original reason why there is no such thing as a "static" exception in the original LGPL. It makes the identification of the "work based on the library" trivial: it is the dynamic library you call in your proprietary software.
As a result, MPL makes it interestingly easier for proprietary vendors to use AND send fix to your library than LGPL.
At the same time, most times proprietary vendors do not have the resources nor the time to dive into your complicated library, and would most likely not fix it by themselves. They would rather open an issue on your GitHub repo, or send an e-mail in the mailing list and wait for your fix.
In this regards, LGPL enforces more this kind of behaviour. But is enforcing really needed?
Choosing between LGPL and MPL is a tricky question and, as usual with software license, depends on your goal. Both licenses are very similar but at the same time extremely different. They were designed for very different goals and philosophy.
LGPL was made by the the Free Software Foundation to enable the widespread use of Free Software libraries in the proprietary world but with always in mind the idea of promoting Free Software and fight against proprietary softwares. It is all part of a strategy towards their ideology. See:
MPL is a practical license designed by Mozilla to enforce some kind of share-alike to the original library, while still encouraging people to make proprietary softwares and add-ons on top (including Mozilla itself), which is a practice that the FSF authorizes via LGPL but still considers harmful.
By essence, MPLv2 is considered by many as a permissive license, while LGPLv3 including with static exception is rarely called this way.
I forgot to mention something important. LGPLv3 (with or without static exception) forbids tivoization. You may think it is a "detail" but it is actually not, depending on your goal. Do you care about users Freedom? Then it is not a detail. Do you care that your library can be used on most portable devices? VLC cares more about being used, so they decided to use LGPLv2 which doesn't contain such restriction. Similarly, that's one of the reasons why Linux keeps using GPLv2.
MPLv2 also doesn't have any tivoization restriction, obviously as it is a license created with the more "practical" Open Source philosophy in mind, not the FSF ideology.
There might be other "minor" things like this that I missed.