I asked this in a comment, but figured it's a separate question:
Is Eclipse's compiler just a wrapper around the same compiler core that the javac program is wrapped around, or is it a separate compiler altogether? If the latter, why would they reinvent the (possibly inferior) wheel?
Eclipse has implemented it's own compiler. It actually uses a couple compilers.
One compiler is a very quick compiler that brings you the red squiggles. It is fast, but can be inaccurate.
The other compiles your code when you want to run a project. It is different from the standard java compiler. One notable difference is that the Eclipse compiler lets you run code that didn't actually properly compile. If the block of code with the error is never ran, your program will run fine. Otherwise it will throw an exception indicating that you tried to run code that doesn't compile.
The fact that Eclipse comes with its own compiler is also apparent because you can write, compile, and run Java code in Eclipse without even installing the Java SDK.
It is a seperate compiler altogether. This is needed as javac doesn't allow compilation of slightly broken code, from the eclipse site
An incremental Java compiler. Implemented as an Eclipse builder, it is based on technology evolved from VisualAge for Java compiler. In particular, it allows to run and debug code which still contains unresolved errors.
Eclipse's built-in compiler is based on IBM's Jikes java compiler. (Note that Eclipse also started its life at IBM). It is completely independent of Sun's Java compiler in the JDK; it is not a wrapper around Sun's javac.
Jikes has existed for a long time, it used to be a lot faster than the standard JDK Java compiler (but I don't know if that's still true). As to why IBM wanted to write their own Java compiler: maybe because of licensing reasons (they also have their own Java implementation).
Everyone has already explained that they're different. Here are some difference in behaviors I've noticed between the two compilers. They all boil down to a bug in (at least) one of the implementations.