\$\begingroup\$

CJam/GolfScript, 2 languages, 50 bytes

{`"0$~e#"+0$-1%"":n}0$~e##e~$0}n:""%1-$0+"#e~$0"`{

Try it CJam! Try it in GolfScript!

Huh, this went unanswered surprisingly long.

Explanation

It's probably easiest to explain this by showing how I turned the basic quine in each language into a palindromic polyglot quine.

So the basic quines in both languages are:

{".~"}.~

{"_~"}_~

In GolfScript and CJam, respectively. These are quite similar thanks to the fact that CJam was originally inspired by GolfScript (but has since deviated quite a lot). The first difference we notice is that one uses . for duplicating the top of the stack and the other uses _ . A common trick to avoid this problem is to use 0$ , since both languages have the "copy-nth-item-on-stack" operator $ . So we get {"0$~"}0$~ , although that still needs a trailing linefeed in GolfScript. But let's worry about that at the end.

First, we need to make it a palindrome. The obvious solution to this is to append a comment and put the source code there in reverse. This is quite simple, because CJam uses e# for comments, and in GolfScript e does nothing at all, and # is a comment. So if we append e#... that works for both languages. Here is what we've got:

{"0$~"}0$~e##e~$0}"~$0"{

Of course, that doesn't actually print the part from e# onward. We can reconstruct this quite easily from the source code itself. Both languages can turn the initial block into a string with ` and append the "0$~" part with + , so that we get the entire unmirrored source code in a single string. To append a mirrored copy, all we need to do is duplicate the string with 0$ again and then reverse it with -1% , which also works in both languages. So now we've got this:

{`"0$~e#"+0$-1%}0$~e##e~$0}%1-$0+"#e~$0"`{

This is a valid palindromic quine in CJam, and it also works in GolfScript but still prints that pesky trailing linefeed.

The usual way to prevent this is to assign an empty string to n , because what GolfScript really does is print the contents of n at the end. So what we need is "":n . So what about CJam? Thankfully, this does nothing at all. "" is also an empty string (or empty list, they're the same thing in CJam), and : maps the operator n (print with linefeed) over the list. But since the list is empty, mapping an operator over it does nothing at all. Hence, we can get rid of the linefeed, without messing with CJam, and end up with the final solution: