text:
The Versatile Integer Printer
Write a piece of code that is executable in at least three different languages. The code must output the integer 1 in language number one, 2 in language number two, 3 in language number three etc.
Rules:

The output must be only the integer, but trailing newlines are OK.
The code can't take input of any kind
Different major versions of the same language are considered unique. So, your code can be executable in Python 2 and Python 3, however Python 2.5 and Python 2.7 are not considered unique.
You may use a new language if and only if it has an esolang/wiki article, available interpreter and documentation, and has been used by at least two users on PPCG prior to using it in this challenge. It must also adhere to these 4 rules.

The score of your submission is the number of bytes in your code divided by the number of languages it can run in cubed. So, a 54 byte solution that is executable in 3 languages will have a score of 2:
54 / 3^3 = 2

Lower score is better.

Why not have different minor types as unique? It's not like the similarities could help you. You would have to use some pretty specialised code that runs completely different in python 2.7.1 and 2.7.3

@muddyfish You might be able to fetch the minor version within the code, which would then give you free solutions for all 2.7.1 to 2.7.n. (Actually, sweerpotato does just that with major versions.)

I think maybe shortest solution by language doesn't make sense here... :P

@FryAmTheEggman I just copy the script :P I'm not good enough at reading compacted JS/jQuery to remove that bit.

@Mego Neither am I, that's why I leave sarcastic comments about the problem so that other people find out about it :P

I just wanted to congratulate you on how well-balanced your scoring is. When code challenges mix two quantities into one score the balance is almost always off such that the best answer will just optimise one of the scores without having to consider the other one at all. The cubic weight of the number of languages was perfect here... while it was always possible to add another language it was always a very nice (but doable) challenge to do so in the number of bytes available. :)

@StewieGriffin: Would I satisfy the javascript requirements if the version used for it was only supported in firefox and they droped support of that version since version 12?

In this PPCG challenge we've been collaboratively building a polyglot. It now has a better score on this challenge than the leading entries submitted to this challenge, but it wouldn't make sense to copy a group effort that's constantly being improved over, so I'm just dropping a mention in the comments here.

^^How about community wiki with a link to the challenge?

I meant put the latest answer from the answer chain polyglot question as a community wiki answer on this question.

30 languages, 248 bytes, \$\frac {248} {30^3} = 0.009185\$
#|#?15g,@   	    kkmNmSaIeoe99+{\#/-;n@0ea
#[9!@>.>.eeaww#-1@*"12"	L
#{
###
#`{
25
print(4^2 +7)/2

"""
Jo is here.
$'main'MoO OOM
 7
>Jo, 30
>X Jo
f::=~27
::=]##}#(prin 29)
print (7/6*24)###;alert 2#-[>+<-----]>-.|#(write(if(= 1/5 .2)26 3))"""

Edit: Beatnik removed since primality testing in Beatnik might not be possible.
The code has tabs in it (which can get mangled by Stack Exchange) and a trailing newline, so here's the xxd:
00000000: 237c 233f 3135 672c 4020 2020 0920 2020  #|#?15g,@   .
00000010: 206b 6b6d 4e6d 5361 4965 6f65 3939 2b7b   kkmNmSaIeoe99+{
00000020: 5c23 2f2d 3b6e 4030 6561 0a23 5b39 2140  \#/-;n@0ea.#[9!@
00000030: 3e2e 3e2e 6565 6177 7723 2d31 402a 2231  >.>.eeaww#-1@*"1
00000040: 3222 094c 0a23 7b20 090a 2323 230a 2360  2".L.#{ ..###.#`
00000050: 7b0a 3235 0a70 7269 6e74 2834 5e32 202b  {.25.print(4^2 +
00000060: 3729 2f32 0a0a 0a22 2222 0a4a 6f20 6973  7)/2...""".Jo is
00000070: 2068 6572 652e 0a24 276d 6169 6e27 4d6f   here..$'main'Mo
00000080: 4f20 4f4f 4d0a 2037 0a3e 4a6f 2c20 3330  O OOM. 7.>Jo, 30
00000090: 0a3e 5820 4a6f 0a66 3a3a 3d7e 3237 0a3a  .>X Jo.f::=~27.:
000000a0: 3a3d 5d23 237d 2328 7072 696e 2032 3929  :=]##}#(prin 29)
000000b0: 0a70 7269 6e74 2028 372f 362a 3234 2923  .print (7/6*24)#
000000c0: 2323 3b61 6c65 7274 2032 232d 5b3e 2b3c  ##;alert 2#-[>+<
000000d0: 2d2d 2d2d 2d5d 3e2d 2e7c 2328 7772 6974  -----]>-.|#(writ
000000e0: 6528 6966 283d 2031 2f35 202e 3229 3236  e(if(= 1/5 .2)26
000000f0: 2033 2929 2222 220a                       3))""".

Alternatively, you can copy and paste the code from this "Try it online!" link.
This is pretty badly golfed, but I wanted to play off the idea that, once you have enough languages, byte count doesn't matter as much any more. Having said that there are some languages I could still easily add (e.g. Objeck) but are currently too long to be useful. I'm running out of good languages though, so I might stop here for now.
Run all programs with </dev/null 2>/dev/null (i.e. empty input, surpressed STDERR).
The explanation's quite long, so here's an executive summary:

No.
Lang.
Non-esolang?
2D esolang?
BF/BF-deriv?

1
COW
✗
✗
✓

2
CoffeeScript
✓
✗
✗

3
Common Lisp
✓
✗
✗

4
Retina
✗
✗
✗

5
Befunge-93
✗
✓
✗

6
Python 2
✓
✗
✗

7
Rail
✗
✓
✗

8
ETA
✗
✗
✗

9
Prelude
✗
✗
✗

10
Gol><>
✗
✓
✗

11
evil
✗
✗
✗

12
Foo
✗
✗
✓

13
Ruby
✓
✗
✗

14
><>
✗
✓
✗

15
Brian & Chuck
✗
✗
✓

16
Whitespace
✗
✗
✗

17
3var
✗
✗
✗

18
Axo
✗
✓
✗

19
Labyrinth
✗
✓
✗

20
Starry
✗
✗
✗

21
Fission
✗
✓
✗

22
Brainfuck
✗
✗
✓

23
Julia
✓
✗
✗

24
Lily
✓
✗
✗

25
GolfScript
✗
✗
✗

26
Chicken Scheme
✓
✗
✗

27
Thue
✗
✗
✗

28
Perl 6
✓
✗
✗

29
Picolisp
✓
✗
✗

30
TRANSCRIPT
✗
✗
✗

1. COW
COW is a Brainfuck derivative with additional commands, one of which is numeric output. Anything invalid is ignored, so the executed program is merely
MoO OOM

which increments the cell to 1 then prints it as a number.
2. CoffeeScript (includes interpreter)
CoffeeScript sees:
# comments
###
multiline comment
###;alert 2# comment

which simply alerts 2.
(Yes, it'd probably be better if another language took this slot, but I'm too lazy to reshuffle at this point :P)
3. Common Lisp | ideone
Common Lisp (clisp) sees:
#|
multiline comment
|#(write(if(= 1/5 .2)26 3))"""

1/5 is a rational and not equal to 0.2, so 3 is printed. The proceeding """ is a syntax error.
Note that print seems to output a preceding newline and trailing space in Common Lisp.  However, luckily, write works in both Common Lisp and Chicken Scheme.
4. Retina | Try it online!
Restrictions introduced: Every second line starting from the first needs to be a valid regex.
Every pair of lines form a replacement stage, replacing instances of matches of the first line's regex with the second line. In the middle, we have the pair

"""

which replaces the initial empty string with """. The final empty line, not part of any pair, is treated as a match stage, counting the number of matches of the regex. There are four instances of empty string in """, namely 1"2"3"4.
5. Befunge-93 | Interpreter
Befunge is a 2D language, and the relevant instructions are
# # 15g,@

in the first line, and the 5 in the 25 line. # skips the next instruction, 15g gets the char at position (1, 5) in the code (the 5 in the 25 line), , outputs the char and @ halts.
6. Python 2 | ideone
Python sees:
# comments
25
print(4^2 +7)/2

"""
multiline string
"""

(4^2+7)/2 = (xor(4,2)+7)/2 = (6+7)/2 = 13/2 = 6, which gets printed.
7. Rail | Try it online!
Rail is a 2D language, and execution start from the $ of the main function, heading southeast. Thus, the relevant portion of code is
$'main'
 7
  o
   J

with the o and J coming from lines used by TRANSCRIPT. After outputting 7, the train hits an unrecognised J instruction, which crashes the program.
8. ETA | Try it online!
Restrictions introduced: Chars before the ETA program should not be in etaoinsh.
ETA only recognises the letters etaoinsh and their uppercase versions, meaning the code starts off with
NSaIeoe

n...e pushes a base 7 number based on what's within the delimiters, which for SaI is 624, or 312 in decimal. o then outputs as char, apparently after modulo 256, giving the char 8 (code point 56). e then tries to divide with an empty stack, which fails.
9. Prelude | Try it online!
Restrictions introduced: No more than one of () in any column, () matched reading a column at a time, no infinite loops caused by ().
This requires the Python interpreter to have NUMERIC_OUTPUT = True set.
Prelude is a language where each line is executed separately. A lot of chars get executed, but the important part is the
9!

on the second line, which outputs 9. () in Prelude denote a loop, but thanks to the prominence of #s (which pop from the stack), the tops of the stacks are always 0 by the time a loop is hit, so none of them are run. Prelude's source code restrictions regarding () introduced some extraneous spaces though.
10. Gol><> | Interpreter
This part (and ><>) work like Martin's answer. The relevant code is
#                                      ;n@0ea

Gol><> is a 2D language and # reflects the IP, making it travel leftwards. It wraps around, push 10, 14 and 0 to the stack. @ then rotates the stack, bringing 10 to the top, n outputs it and ; halts the program.
11. evil |  Try it online!
This part's also similar to Martin's answer.
evil ignores everything except lowercase letters. Ignoring a few more characters, the relevant part is
aeeeaeeaww

where a increments the variable A, e is evil's weave function which shuffles the bits of A, and w outputs A. Hence we output 1 twice, giving 11.
But what about the rest of the instructions, and especially that w on the last line? Let's just say that sometimes it's easiest to just mess with the code and pray it still works in everything which, here, it somehow did...
12. Foo | Try it online!
Foo outputs anything between double quotes, so the relevant part is the
"12"

on the second line. However, since we need double quotes later we use a method similar to Martin's answer to make Foo error out, namely the preceding #-1@. It's unclear why that works in a language which soldiers on in the face of empty stack and division by zero errors, but I'm glad it does.
13. Ruby | ideone
Like Python, Ruby sees:
# comments
25
print(4^2 +7)/2

"""
multiline string
"""

However, it's worth noting that the multiline string is actually three separate strings ("", "...", "") concatenated together. The print line outputs (4^2+7) = xor(4,2)+7 = 6+7 = 13, before erroring out trying to divide nil by 2.
14. ><> | Try it online!
This part's the same as the Gol><> part, except @ brings the 14 up to the top instead, which gets outputted.
15. Brian & Chuck | Try it online!
Brian & Chuck is a BF derivative with two tapes, where one tape's instruction pointer is the other tape's memory pointer. In the absence of ```, the first two lines of the source code are used to initialise the tapes.
The relevant chars in the first two lines are:
   ?15
#     >.>.

The ? in Brian's tape passes control over to Chuck in the cell being pointed to (the #) is nonzero. Chuck then executes >.>., outputting the two chars after the question mark.
16. Whitespace | Interpreter
Using STL for space, tab and line feed respectively, the start of the program is:
SSSTSSSSL
TL
STL
L
L

The first line pushes 16 (+10000 base 2), the preceding TLST prints it as a number. The next three newlines halt the program.
Note, however, that this program is interpreter specific. The rest of the code syntax errors in most interpreters, so a more lenient interpreter is required, like the one linked above.
17. 3var | Try it online!
Of the first line, a slew of instructions get executed, but the relevant ones are
kkmmao#/

Due to ETA's restriction, we use k to decrement the variable B rather than a to increment it. kk decrements B to -2 and mm squares B twice to 16, which is incremented to 17 with a. This is then outputted with o.
# is then used to reset B to 0, and / causes the program to error out via division by 0.
18. Axo | Try it online!
Restrictions introduced: No instructions before the Axo program which change the direction of the IP
Once again, a slew of instructions get executed in the first line, but the relevant ones are
# # 15 ,@            9 9  + {   \

Axo is a 2D language like Befunge, and # is similarly a bridge that skips the next instruction, but only if the top of the stack is zero. 15, push to the stack, but the stack is emptied with @. 99+ then pushes 18, { outputs and \ halts.
19. Labyrinth | Try it online!
Labyrinth is another 2D language, and the executed instructions are
#|#
 [9!@

# pushes the length of the stack, which is 0 the first time. | is bitwise OR, not changing anything since the stack just has 0s at this point, and the second # now pushes 1 due to the lone zero. We turn right due to the 1, 9 converts this 1 to 1*10+9 = 19, ! prints it and @ halts.
This program relies on the fact that [ is not currently a recognised instruction, and hence is treated as a wall.
20. Starry | Try it online!
Restrictions introduced: All +s must have at least one preceding space
If we strip away unrecognised characters, the relevant part of the code is
,       +.. +

, is input, but since we pipe from /dev/null there is none, pushing 0 to the stack. A + with n >= 5 preceding spaces pushes n-5, so the next instruction pushes 2. .. then outputs these two digits in reverse order.
Next we have a + with a single preceding space, which duplicates. However, the stack is empty, so we error out.
21. Fission | Try it online!
The only relevant part for Fission is
*"12"L

L spawns an atom moving leftward, "21" prints 21 and * halts.
22. Brainfuck | Try it online!
Introduced restrictions: No . before the first [
This requires an interpreter which gives 0 on EOF and has 8-bit cells. The relevant code is
,+-[>.>.-+.>,>]-[>+<-----]>-..

The inital - is to offset the +, and the first [...] is not executed since the cell is 0. The following -[>+<-----]>- sets the cell to the char code of 2, and .. outputs it twice.
23. Julia | Try it online!
Julia sees:
# comments
25
print(4^2 +7)/2

What's printed is 4^2+7 = pow(4,2)+7 = 16+7 = 23, and the program errors out trying to divide nothing by 2. Note that Julia doesn't seem to mind the fact that the rest of the code would cause a syntax error anyway.
24. Lily | Interpreter
Lily sees:
# comment
#[
multiline comment
]## comment
print (7/6*24)# comment

7/6*24 = 1*24 = 24 is printed.
25. GolfScript | Try it online!
GolfScript sees:
# comments
25
print(

GolfScript is stack-based, so 25 is pushed to the stack, then popped and printed with print. ( then tries to decrement the implicit empty string on the stack, which fails and errors out the program.
26. Chicken Scheme | ideone
Chicken Scheme has the same #| ... |# multiline comment syntax as Common Lisp. However, in
(write(if(= 1/5 .2)26 3))

1/5 is a float which is equal to 0.2, so 26 is outputted instead.
27. Thue | Try it online!
Thue is a language based on string rewriting. The first relevant part is
f::=~27
::=

which defines a substitution f -> 27 then denotes the end of substitutions with ::=. The lone f in if is then replaced with 27, which is outputted.
28. Perl 6 | ideone
Perl 6 has a new comment syntax, namely #`(some bracket) which is a multiline comment all the way to the matching bracket. Thus, Perl 6 sees:
# comments
#`{
multiline comment
}# comment
print (7/6*24)# comment

which prints 7/6*24 = 28.
29. Picolisp | ideone
Picolisp sees:
# comment
#{
multiline comment
}#(prin 29)

which prints 29. The line afterwards then causes a syntax error.
30. TRANSCRIPT | Try it online!
TRANSCRIPT is a thematic esolang modelled after text adventures. Unrecognised lines are ignored (which allows you to add extra story/flavour text amongst the actual code instructions), so the relevant lines are:
Jo is here.
>Jo, 30
>X Jo

The first line declares a string variable Jo, using a two-letter name since one-letter names seem to fail. The second line sets this string to "30", which is outputted by X ("examine") in the third line.

Daaaaaaaaaang...

I suspect this may be the lowest non-zero score on any question here.

This is... incredible. I am in awe.

*positive, there are a few negative scores for short answers with bonuses.

Pro-tip from the future: your tabs won't be messed up if you surround your code in pre tags instead of using a Markdown-style code block.

15 languages, 68 66 65 bytes / 15^3 = 0.019...
Retina, Starry, Prelude, ETA, Axo, Labyrinth, Hexagony, Foo, Brian & Chuck, Gol><>, evil, Whitespace, Fission, ><> and GolfScript.
After a massive rewrite, I managed to fit in four more languages. The code contains the few tabs for Whitespace. Since Stack Exchange converts them to spaces, I've represented them with \t below:
#I5aeeNTH{\?      \t\t + +3;n@"8"ea9
15}7'`--~!@<"31"LSOe.\t
 \teaww`

I think I'm done adding languages (although adding only one might save some bytes in what I already have). I wonder if it's golfable though... 65 bytes for 15 languages is quite a jump from 32 bytes for 11 languages, and I've now got at least one useless character in there to make Foo work..
Retina prints 1
Try it online.
Luckily, the first line is a valid regex. However that regex obviously doesn't match the empty input, so the first stage (consisting of the first two lines) doesn't do anything.
The third line is on its own, so it's treated as a Match stage which, by default, counts the number of matches. However, the ` is a separator which tells Retina that the part in front of it is a configuration string (it doesn't happen to know any of the options given there) and the part after it is the regex. So the regex is empty and Retina finds exactly one match.
Starry prints 2
Try it online.
Starry ignores everything except spaces and +*,'`.. Each command is one of those characters in conjunction with the spaces since the last of those characters. So let's remove all the extraneous code:
       + +'`. `

Seven spaces followed by + pushes a 2. One space followed by a + duplicates it. ' is a conditional jump. It pops the top of the stack, which is truthy (positive), so it jumps to the corresponding label (where labels are indicated by ` and "corresponding" means "with the same number of leading spaces"), which is the first `. . without spaces in front of it then prints the top of the stack as a number.
Prelude prints 3
Try it online.
This assumes the Python interpreter which uses numeric output. Let's remove all the no-ops:
# 5        ?         + +3    8   9
15 7  -- !   31

The first voice does a bunch of stuff, but nothing of it matters, because there is no ! to print any of the results. The second voice pushes a 1, then a 5, then a 7. We take the difference of the last two to get -2, and then subtract that from the 1 to get 3. ! prints it. The third voice has only no-ops.
ETA prints 4
Try it online.
ETA ignores everything except the characters ETAOINSH (in any case). So the code as seen by ETA is:
IaeeNTHneaSOeea

I tries to read input but can't, so it pushes -1. a pushes the current line number plus 1, which is 2. e is divmod, which replaces those with 0 and 1 (or -1, I don't actually know, but it doesn't matter). The next e replaces both of them with 0.
Now the interesting part. NTHne is a base-7 number literal. N and e are just the delimiters, and the three digits are THN. That is 54 (where T is digit 1, H is 0 and n is 5). a pushes 2 once more. S subtracts it, resulting in 52 and O outputs it as a character (4). Now e tries divmod again, but the stack contains two zeroes, so the program terminates with an error (but doesn't pollute STDOUT while doing so).
Axo prints 5
Try it online.
This language was pretty much single-handedly responsible for the rewrite. I couldn't have the } on the first line because it would block for input in Axo (see revision history for what I'm talking about). For Axo, only this part of the code is relevant:
#I5aeeNTH{\

Luckily, Axo also has implicit 0s at the bottom of its stack, because # pops the top of the stack (to check if the next instruction should be skipped or not). The letters are all no-ops. Then 5 pushes a 5, { prints it, \ terminates the program. Quite simple, really.
Labyrinth prints 6
Try it online.
I'm truncating the code a bit, because the right half is never reached, and I'm also using t in place of \t, so that the columns line up correctly:
#I5aeeNTH{\
15}7'`--~!@
 teaww`

Now that letters, spaces and tabs are walls in Labyrinth, so the accessible code actually looks like this:
# 5      {\
15}7'`--~!@
      `

The instruction pointer will automatically follow that path. # pushes the depth of the main stack (0) and 15 turns it into a 15. } moves it off to the auxiliary stack, and we're not going to use it any more. That conveniently makes the top of the stack zero, so that the IP does not turn left onto the 5. 7 turns the zero into a 7, ' is a no-op. The ` is unary negation, so we get -7. Now - subtracts the -7 from the implicit 0 underneath making it 7. This time, the IP does turn right to the `, which is unary negation, so we get 7 again. The IP hits a dead end a turns around. The - does the same thing as before, so we get 7 once more. As the top of the stack is now positive, the IP turns right. There's another - which gives -7 again.  Then ~ is bitwise NOT, which gives 6 and ! prints it. That's just the right moment to do so, because now the stack is empty again such that the IP won't turn left onto the { but instead continues straight ahead into the @ which terminates the program.
Hexagony prints 7
Try it online.
The unfolded code looks like this:
     # I 5 a e
    e N T H { \
   ? + + 3 ; n @
  " 8 " e a 9 1 5
 } 7 ' - - ~ ! @ <
  " 3 1 " L S O e
   . e a w w . .
    . . . . . .
     . . . . .

Normally, that would be a terrifying Hexagony program, but the characters actually in use are not too many. In fact they are pretty much the same as those used by Labyrinth and I think the way I differentiate between 5 and 6 is quite nice. :)
The top row can basically be ignored. # would normally switch to a different IP, but the current memory edge is 0, so it doesn't. The letters just set a fixed memory value, but we're not going to use it. After the end of the first row, control flow continues in the middle row (starting from the }, going right). The } moves to another memory edge. 7 sets that edge to 7. ' moves back to where we came from. - subtracts the memory edge we've just set to 7 from an unused memory edge (0), so we get -7. The next - does the same thing again, so it's a no-op. So far, quite similar to Labyrinth (apart from the memory layout). But now ~ is not bitwise NOT but unary negation in Hexagony. So this gives 7 instead of 6. !@, like in Labyrinth prints the value and terminates the program.
Foo prints 8
Try it online.
As we all know since The Programming Language Quiz printing things is quite trivial in Foo, even if most of the code is a random jumble of characters. None of the characters affect the output except the "8" which prints 8. Well, there is the "31" later on, but Foo terminates with an error at the end of the first line. I'm not exactly sure why that happens, but it requires that 3 (or any other digit) on the top row, which isn't used anywhere else.
Brian & Chuck prints 9
Try it online.
Let's do this thing again where we remove the third line (it's never parsed) and replace all irrelevant characters (i.e. no-ops, or cells that aren't read) with spaces:
         { ?         + +         9
  }   --   <        .

Just as a reminder, each line is a Brainfuck-like whose tape is the source code of the other program. Control flow starts on the first line (called Brian).
The { moves the tape head all the way to the left (where it already is), and ? hands control flow over to Chuck (the second line). There, } moves the tape head to the right until it finds a zero cell. That doesn't happen until the end of the program, so the tape head ends up one cell after the 9. - decrements that cell, but that's irrelevant. < moves the tape head onto the 9 and . prints it. Chuck runs out of program and terminates.
Gol><> prints 10
Tested here.
# is a mirror, so the IP immediately skips to the end of the first line (and goes left). The 9 can be ignored. a pushes 10, e pushes 14, "8" pushes the character code of 8, @ rotates the top three stack elements (pulling up the 10), such that n prints the 10 and ; terminates the program.
Thanks to Sp3000 for suggesting to use @ instead of ! (which saved a byte).
evil prints 11
Thanks to Sp3000 for sending me some brute-forced command-lists to generate single-digit numbers.
Try it online.
evil ignores everything except lower case letters so the code looks like this:
aeeneaeeaww

Also, n affects some state we don't care about so let's ignore that as well. Now a increments the register (which starts at 0), and e is evil's magic "weave" operation which permutes the bits in a particular way. aeeeaeea happens to yield the value 49 which is the character code of 1. ww prints it twice.
Whitespace prints 12
Try it online.
Okay, we know Whitespace only reads spaces, tabs and linefeeds, so let write the code as seen by Whitespace with STL:
SSSSSSTTSSLTLST

That's two commands:
SSSSSSTTSSL
TLST

The first one pushes the number 12. Specifically, SS starts a number literal. The next S is the sign bit (positive). Then everything up to the L is a binary representation of the number. There's a ton of leading zeroes, which we need for Starry, but they don't affect the number. Then the TTSSs is 12 in binary. Fun fact: if I added a 16th language, I could save a byte here, because Starry could use the four S in the binary represtation of 16. I doubt I will though...
The TLST just prints the top of the stack as a number. (TL marks the command as an I/O command, and ST is printing numbers.)
Fission prints 13
Try it online.
Fission only sees this part of the code:
           <"31"L

L starts control flow with a left-going atom. " toggles print mode, so that 31 just prints 13. Then the atom is captured in the wedge of the <, which terminates the program.
><> prints 14
Tested here.
Distinguishing between ><> and Gol><> isn't as easy as I thought, because Gol><> almost always does the same thing as ><> for commands that exist in both, and commands that only exist in Gol><> cause ><> to crash. However, @ rotates the other way round in ><>, such that it pushes down the 7 instead of pulling up the 10, and then the 14 gets printed instead of the 10.
GolfScript prints 15
Try it online.
This one is simplest: # comments out the first line. Then 15 pushes itself and } is a "super comment", which ignores the entire rest of the program. So the 15 is printed at the end of the program.

This is really impressive!

Nice job, very impressive indeed ! Then 5(!@ just sets the memory edge to 5, increments it, shouldn't it be decrements it since 4 is printed? I do not know the language so I can not check the logic behind it

@YassinHajaj Thanks, corrected.

@MartinButtner: What would you get if the question used 0-based indexing rather than 1-based indexing?

@RickyDemer hard to say. It wouldn't save or cost anything immediately, but I could probably ditch one character somewhere. It would probably be more helpful for adding further languages, because currently the only one that is easily adaptable for two digits is ><>, so getting another single digit would make some more room.

Adding a whitespace program to this would be fairly trivial. Sadly, the 11 characters required to print 11 is 3 characters too many to lower your score at all.

@SnoringFrog Indeed. If I manage to add more languages so that I have more leeway for adding another language, I might reconsider it. When adding Whitespace it might be possible to add Starry for one or two more characters, so adding both of those at once might help. I'll have to look into that later.

Niiice. Great job for 15 languages!

@SnoringFrog Well, there you go.

i vote for this to get the bounty, thats just totally amazing

@Eumel Thanks, but the bounty is specifically for the "normal" languages listed in its description, so the bounty should go to such an answer (like Sp3000's very nice solution). I think I got enough rep from this anyway. ;)

@MartinBüttner at least 1030 rep from this answer

@ev3commander not quite, considering the rep cap ;). Still more than enough

Oh I forgot facepalms ;)

truly remarkable

Couldn't the issue with Axo be avoided by piping from /dev/null, which is allowed by default?

@Mego Since I only tried Axo on TIO, I assumed that the interpreter would already receive an empty stream anyway. Maybe it doesn't though, I don't know, but at this point, I don't really feel like rewriting it once more. ;)

@MartinBüttner You don't feel like shaving off several bytes? Who are you and what have you done with Martin?

@Mego I do feel like shaving off several bytes, but I don't feel like spending another 4 hours trying to understand the program(s) again and rewriting it once more. This answer was definitely exhausting. ;) ... Maybe some day...

Python 1.x, 2.x and 3.x, 32 bytes / 3^3 = 1.1851...
import sys
print(sys.version[0])

Prints the first number of the version, which is 1 in Python 1.x, 2 in Python 2.x and 3 in Python 3.x.
By the time we get Python 9.x my score will be a glorious 0.04389!
:~)!

From chat: Yes, this is both cheap and valid =) This is part of the reason why only major versions were considered unique enough. I don't know how many Python versions there are, but you could probably get your score pretty darn low using something like this... It's one of the few solutions where I actually understand what is happening, so +1 from me ;-)

In python 10.x (when it exists) wouldn't it print 1 because it's the first character of the string "10.whatever"?

@ev3commander However, this submission isn't spec'd to produce a correct output in python10.

Fixed! Working on a future-proof version, but Python 1.x isn't as user-friendly as the others :~)!

All I need to do is create a language that has three major versions. In those three major versions, when running an empty file returns the major version number. The result would be 0 / 3^3 = 0
Perfect.

3 languages, 2 bytes / 27 = 0.074
1P

Well, it beats half the submissions at least :P
1. GolfScript
GolfScript ignores the P, outputting just the 1. Try it online.
2. Par
P is 2-to-the-power-of, so 1P = 2^1 = 2. Try it online.
3. Seriously
P gives the nth prime, zero indexed. We get 3 since that's the second prime. Try it online.

Notes
My inital goal was to find a valid answer in 1 byte. My first try was \x12 which works in Bubblegum and gs2, but the challenge requires a minimum of three languages. \x13 would work if there's a language in which that outputs 1.
Giving up on a 1 byte answer, I moved to two bytes. 3u is a close call, outputting 1 in Japt, 3 in GolfScript and 4 in Seriously, but it was hard to find a language which outputted 2 to fill the gap.
All of this took me way too long :/

6 Languages - 44 bytes / 6^3 = 0.204...
Thanks to SnoringFrog for saving 10 bytes!
Works in:

Befunge
Pyth
Brainfuck
Hexagony
Whitespace
AniRad v0.2

2# "1",@"-[----->+<]>.*@@@!4<SSTST
T
ST
 >6=

Note: Before trying it online, make sure to replace S with spaces and T with tabs, or convert the following hexdump to ASCII
32 23 20 22 31 22 2c 40 22 2d 5b 2d 2d 2d 2d 2d 3e 2b 3c 5d 3e 2e 2a 40 40 40 21 34 3c 20 20 09 20 09 0d 0a 09 0d 0a 20 09 0d 0a 20 3e 36 3d

I am going to try to use more programming languages :)
Befunge (prints 1):
Try it online
2# "1",@"-[----->+<]>.*@@@!4<
2                             # This puts 2 onto the stack
 #                            # Skips the next op (the space)
   "1"                        # Sets the ASCII value of 1 onto the stack
      ,                       # Pop the last item (1)
       @                      # Terminate program

Pyth (prints 2):
Try it online
2# "1",@"-[----->+<]>.*@@@!4<
2                             # Prints 2
 #                            # Infinite while loop until an error occurs
   "1"                        # String
      ,@                      # This gives the error and terminates the program

Brainfuck (prints 3):
Try it online
2# "1",@"-[----->+<]>.*@@@!4<
2# "1",@"                     # Since these are not brainfuck ops, these will be ignored
         -[----->+<]>         # Puts "3" on the stack
                     .        # Prints the last item (3)

Hexagony (prints 4):
Try it online
2# "1",@"-[----->+<]>.*@@@!4<

A more readable version:
   2 # " 1       # The steps:
  " , @ " -      # 1 (2) - Hexagony starts at the top-left of the hexagon
 [ - - - - -     #       - This immediately puts 2 onto the stack
> + < ] > . *    # 2 (#) - Since the stack is 2, this makes the 2nd pointer the
 @ @ @ ! 4 <     #       - new current pointer
  > 6 = . .      # 3 (*) - The position of the 2nd pointer is in the left-most
   . . . .       #       - position. This sets the stack to the product
                         - of the two neighbours which is zero
                 # 4 (<) - Changes the pointer direction to west
                 # 5 (4) - Sets the stack to 4
                 # 6 (!) - Outputs the decimal 4
                 # 7 (@) - Terminates the program

Whitespace (prints 5):
Try it online
Since other characters are ignored but whitespaces and tabs, we are left with the following:
SSTST                 # This pushes 5 onto the stack
T                     #
ST                    # This prints the decimal

AniRad version 0.2 (prints 6):
Somehow this works for version 0.2, but gives an error for version 0.4. I have no clue why. You can find version 0.2 here. In order to run this, you can copy and paste the interpreter's code to repl.it and run it. After that, you only need to paste the program to STDIN and run it.
2# "1",@"-[----->+<]>.*@@@!4<      # (#)  Starts at the hashtag (starting point)
                                   #      Direction is down
                                   # (>)  When the pointer gets to the '>', it changes
 >6=                               #      its direction
                                   # (6) Puts 6 onto the stack
                                   # (=) Pushes the result and terminates

More languages is definitely the way to go I think... the cubic denominator is really generous, so that it shouldn't be too hard to beat my score once you have 5 or 6 languages.

@MartinBüttner, Yes, although I can't see how to add a new language

@Martin yes, it's generous. The point of the cubic denominator was to strongly encourage more languages. I think 6 languages in 50 bytes should be worth the same as 5 languages in 30 bytes. :-) it will definitely get harder the more languages you use.

Your Whitespace code could be reduced a bit (and I don't think it'll affect any of your other languages. (Using L for linefeed), instead of the SSSSSSSSSSTTSTSTLTLSS you have now, you can do SSSTSTLTLST. This pushes a literal 5 on the stack, then prints as integer.

@SnoringFrog Thanks! I have edited it

JavaC++C, 363/27 = 13.4....
Java prints 1, C++ prints 2, C prints 3. Not breaking any records here (because Java), but I really like the clever, abusive way of making a polyglot in these languages that I discovered.
//\u000a/*
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
//*/
/*\u002a/
import static java.lang.System.out;
public class P{//*/
/*\u002a/public static void//*/
main(/*\u002a/String[] args//*/
){//\u000a/*
out.print=p;
//\u002a/
out.print(1);}
/*\u002a/}//*/

This is a mess. Here's a breakdown of how it works. The Unicode literals (\u000a, otherwise known as a linefeed, and \u002a, otherwise known as *) are expanded by the Java compiler into their actual characters. So, here is what the Java compiler sees:
//
/*
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
//*/
/**/
import static java.lang.System.out;
public class P{//*/
/**/public static void//*/
main(/**/String[] args//*/
){//
/*
out.print=p;
//*/
out.print(1);}
/**/}//*/

All that stuff in the beginning is ignored because it's all wrapped in a multi-line comment (/* ... */). Later on, we see that mixing single-line and multi-line comments allows us to control exactly which parts are commented out in each language. In the main method, we start a multi-line comment, and then have //*/. Ordinarily, this would be a single-line comment, but since we are in a multi-line comment, the // doesn't do anything, allowing the */ to close it.
This is the equivalent Java code, with comments removed:
import static java.lang.System.out;
public class P{
public static void
main(String[] args
){
out.print(1);}
}

Here is what the C/C++ compiler sees (I've removed the Unicode literals, since they are not expanded by the compiler and thus don't do anything):
///*
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
//*/
/*/
import static java.lang.System.out;
public class P{//*/
/*/public static void//*/
main(/*/String[] args//*/
){//\/*
out.print=p;
///
out.print(1);}
/*/}//*/

Here, the single-line comments override the multi-line comment delimiters in the beginning, so all of the #defines and the #include get preprocessed. Next, multi-line comments are used to comment out the boiletplate code for Java. This is the equivalent code, with comments removed:
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
main(
){
out.print=p;
out.print(1);}

A standard C/C++ polyglot trick (the #ifdef __cplusplus) is utilized to define a token o as either "2" or "3", depending on if it's a C++ or a C compiler that is compiling the code. Next, we define a funtion p that takes a single (ignored) int argument and calls printf, using our newly-defined o token. As per usual, the return value is left out, since we're not in strict mode. Next, we define a struct with a single member, a function pointer whose signature matches p's, and construct a single instance named out. In the main method (we leave off the int as usual), the address of p is assigned to out.print (so calling out.print calls p), and it is called.
If C++ wasn't included in the languages, we could drop all of the preprocessor code, and define p as int p(int a){puts("2");}. Unfortunately, C++ requires an #include to do I/O. If C wasn't included, we could drop the definition of p and the #ifdef preprocessor macro, and directly define a member function in the struct instead of needing a function pointer. Unfortunately, C does not support member functions.

4 languages, 28 bytes / 64 = 0.4375
print((0 and 3^1or 1/2>0)+1)

1. Python 2
0 is falsy and / is integer division, so
(0 and 3^1 or 1/2 > 0) + 1 = (1/2 > 0) + 1 = (0 > 0) + 1 = False + 1 = 1

2. Perl (also Python 3)
0 is falsy and / is float division, so
(0 and 3^1 or 1/2 > 0) + 1 = (1/2 > 0) + 1 = (0.5 > 0) + 1 = 1 + 1 = 2

3. Ruby
0 is truthy and ^ is bitwise xor, so
(0 and 3^1 or 1/2 > 0) + 1 = xor(3,1) + 1 = 2 + 1 = 3

4. Lua
0 is truthy and ^ is exponentiation, so
(0 and 3^1 or 1/2 > 0) + 1 = pow(3,1) + 1 = 3 + 1 = 4

Note that Lua and Ruby can't add booleans as though they are integers, hence the grouping of them together. Unfortunately 0and doesn't work in Lua, so we can't save a byte there.

Previous 17 byte version which prints 1 (Lua), 2 (Ruby), 3 (Python/Perl):
print(2^(0 or 1))

-3 bytes thanks to @xnor for this version, making it a lot neater :)

Would 2^(0 or 1) work?

@xnor Ah yes it would, thanks :)

6 7 languages, 32 37 bytes, score 0.148... 37/73 ≈ 0.107872...
#7+!"@\"6.@;n5
print(4--int(-3/2)#"
)

Brainfuck-ng
+ increments current cell, ! prints as integer, @ exits. # and " are NOPs.
Python 2
First line is comment. Using integer division, calculates 4 - -int(-3 / 2) = 4 - -int(-2) = 4 - -(-2) = 4 - 2 = 2 and prints the result.
Python 3
Same as previous, but with float division. 4 - -int(-3 / 2) = 4 - -int(-1.5) = 4 - -(-1) = 4 - 1 = 3.
Lua
-- starts a comment, and # on the first line is a comment, so basically print(4).
><>
# reflects IP, 5 pushes 5, n prints a number and ; quits.
Befunge
# skips over the +, ! logically negates the top of the stack, "@\" pushes the string @\, 6 pushes 6, . prints a number and @ quits.
Pyth
# starts an infinite loop, dismissing any errors. 7 prints 7, then follows +!"string") which basically causes an error for not having two operands for +, terminating the program.

14 languages, 73 bytes, score = (73/14^3) = 0.02660349854
#Y2(3`5n~thneo e        ;n@0d c
#   -[>+<"9"L-----]>+.
14
print(int(15/2))+3

I can add some more langs, but I think I'll add what I have here.
1. Brainbool ; Try it online!
The relevant code:
    [>+<         ]>+.

               +

This is really just +.+, which outputs 1.
2. Jolf ; Try it here!
The ( char stops interpreting the source code, so the relavent code is:
#Y2

This is equivalent to (in JavaScript)
var Y = []; toHex(Y); alert(2);

Which outputs 2.
3. Element ; Try it online!
The relevant code:
    3`

This captures 3 and prints it.
4. Brainfuck ; Try it online!
The relevant code is:
-[>+<    -----]>+.

  -    -      +

Which is the standard way of generating 4's char code and outputting it, and some other stuff after it.
5. Reng ; Try it here!
~ terminates the program, so the relevant code here is:
#Y2(3`5n~

# redefines Y to be the TOS, in this case, 0. 2 pushes 2; ( rotates the stack N times, popping N from the stack; 3` pushes -3; and finally, 5n prints 5.
6. ETA ; Try it online!
ETA only reads the letters E, T, A, O, I, N, S, H, so the code only executed is this:
       n thneo e         n

  int int

Super-relevant code:
       n thneo

Or, equivalently: nthne o. n...e is a base-7 literal, and thn is the base-7 number for 54. o outputs this character. The submission errors out, but I don't know why.
7. Python 3
What it sees:
# comment
# comment
14
print(int(15/2))+3

15/2 yields 7.5, as / is float division. int(...) makes the number an int, which is then printed. The program errors out when +3 is encountered.
8. Julia
Julia sees:
# comment
# comment
14
print(int(15/2))+3

Instead of truncating 15/2, Julia rounds it up, yielding 8. It prints this, then errors out on encountering +3.
9. Fission ; Try it online!
Relevant code:
        <"9"L

I got this idea from Martin's Fission portion (more like stole it). L begins a left-facing thing, captures 9, and ends with <.
10. Whitespace ; Try it here!
The relevant code, translating spaces into S and tabs into T:
SSSTSTS
T
ST

It pushes 10 to the stack and outputs it as a number (T\nST).
11. Python 2
Python 2 sees this:
# comment
# comment
14
print(int(15/2))+3

(int(15/2))+3 is evaluated to be 11, and that's printed.
12. Gol><> ; Try it here!
Relevant code:
#                      ;n@0d c

This uses the trick used in Martin's answer that @ rotates different directions in ><> and Gol><>. # mirrors, c pushes 12, d pushes 13, 0 pushes 0, and @ brings c to the top of the stack, then being outted and printed with ;n.
13. ><> ; Try it online!
Relevant code:
#                      ;n@0d c

Again using that @ rotates different directions in ><> and Gol><>. # mirrors, c pushes 12, d pushes 13, 0 pushes 0, and @ brings d to the top of the stack, then being outted and printed with ;n.
14. Golfscript ; Try it online!
What it sees:
# comment
# comment
    14
print(-int(-15/2))+3

It pushes 14, prints it, and errors. Stolen inspired by Sp3000's answer.

4 Languages (Befunge-93, Microscript II, Microscript, and Foo), score 7/64=0.109
"4"1.@2

Befunge: Push 4, push 1, print 1, and terminate.
Microscript II: Produce the string "4", discard it, take the square root of one, discard that, and finally set x to 2. This is then printed implicitly.
Microscript: Push 52 to the stack (which will never actually be used for the remainder of the program), increment the register (initially zero) by one, then increment the register by two. This is then printed implicitly.
Foo: Print the string "4", then push 2

BFSRS><>funge93thon123, 73/343 ≈ 0.212827...
Brainfuck, Seriously, ><>, Befunge-93, Python 1, Python 2, Python 3
# 4['.]@kX21z-[>+<-----]>--.<;n3
import sys;print(3+int(sys.version[0]))

Contains unprintables, hexdump (reversible with xxd -ps -r):
2320345b272e5d406b5832317a7f2d5b3e2b3c2d2d2d2d2d5d3e2d2d2e3c
3b6e330a696d706f7274207379733b7072696e7428332b696e7428737973
2e76657273696f6e5b305d2929

I'll be adding more languages (and probably bytes) over time. Languages in the header are listed in order of what they print. Assumes 8-bit wrapping cells and a tape that won't complain about going left of the initial position (wrapping or infinite) for Brainfuck.
Brainfuck:
[.]   initial value of first cell is 0, so loop is skipped
-[>+<-----]>--  push 49 (ASCII ordinal of 1)
.     print "1"
<     move to blank cell
[0]   skip loop because cell is 0
      everything else is ignored

Seriously:
# 4['.]@  does some stuff we don't care about
kX        pop entire stack, push as list, discard (essentially the same as é, but is ASCII so we can use Python)
2         push 2
1z        pop 1 item from stack and print (used instead of . so Brainfuck doesn't print here; same as ü in this scenario, but is ASCII so we can use Python)
0x7f      terminate program
          everything else is ignored

><>:
#    mirror, reverse direction
3n;  push 3, print "3", end (reversed because IP is scanning RTL at this point)
     everything else is ignored

Befunge-93:
#     jump over the space
4['.] push 4, print 4 (brackets and ' do nothing)
@     end program
      everything else is ignored

Python 1 (thanks muddyfish):
# 4['.]@kX21z-[>+<-----]>--.<;n3         comment; ignored
import sys;print(4+int(sys.version[0]))  prints 4+1=5

Python 2:
# 4['.]@kX21z-[>+<-----]>--.<;n3         comment; ignored
import sys;print(4+int(sys.version[0]))  prints 4+2=6

Python 3:
# 4['.]@kX21z-[>+<-----]>--.<;n3         comment; ignored
import sys;print(4+int(sys.version[0]))  prints 4+3=7

Python 1 also works. See http://codegolf.stackexchange.com/a/65652/32686. Doesn't add any chars (but change 3 to 4)

7 languages, 287 / 7^3 = 0.836
Probably the lowest score that gets in, anyway I like this 3 versions of C polyglot.
Added the boring Python solution to at least qualify for the "3 unique" languages bounty.
Added Java by abusing C trigraphs for different comment intepretations.
Works in:

Python 1
Python 2
Python 3
C89
C99
C++
Java

golfed version:
/*
*??/
/
#include <stdio.h>
#ifndef __cplusplus
#define true 8/*
import sys
print(sys.version[0])
'''
#*??/
/
#endif
int main(){int a=(true>1)?-6:3;printf("%d",(true//*
+a
//**??/
/+2));}
#define a \
'''
/**\u002f
public class p{public static void main(){System.out.println("7");}}
/**/

Ungolfed:
/*
*??/
/

#include <stdio.h>

#ifndef __cplusplus
#define true 8/*

import sys
print(sys.version[0])
'''
#*??/
/
#endif

int main()
{
    int a = (true > 1) ? -6 : 3;
    printf ("%d", (true//*
    +a
    //**??/
/
    +2));
}
#define a \
'''

/**\u002f
public class p
{
    public static void main()
    {
        System.out.println("7");
    }
}
/**/

Ok this is probably getting kinda weired and I hope my english skills are good enough to explain it ordinary.
First of all I'll explain the different kinds of comments I used to encapsulate the language structures each for its own.
So lets take the first block:
/*
*??/
/

For Java this is just the beginning of an multi line comment. But... in C99/89/++ this evaluates to
/*
*/

Since ??/ is a trigraph for \ while in C the \ character is kind of consistent and even consumes line breaks in its commandfunctionality. This causes the result of an \n to be just "displayed" instead of beeing line breaks. that means, given this byte array representing the first block:
[/][*][\n][*][?][?][/][\n][/] would be after trigraph evaluation: [/][*][\n][*][\][\n][/]
Where the consistent functionality of the \ triggers and "consumes" the \n so the remaining and finaly in C langs evaluated bytes are: [/][*][\n][*][/]
But about all this java doesn't know anything and treats all that follows as an comment untill this trick gets reverted.
(to be continued!)

7 Languages, 55 / 7^3 ≈ 0.16035
Runs in PowerShell v1, v2, v3, v4, and v5, Foo, and Pyth
#7.q"6""
$p=$PSVersionTable;($p.PSVersion.Major,1)[!$p]

Digits 1-5 use similar logic to sweerpotato's answer. The $PSVersionTable special variable was introduced in PowerShell v2, and contains a full build list, revisions, etc. Here's an example output of the variable:
PS C:\Tools\Scripts> $PSVersionTable

Name                           Value
----                           -----
PSVersion                      4.0
WSManStackVersion              3.0
SerializationVersion           1.1.0.1
CLRVersion                     4.0.30319.34209
BuildVersion                   6.3.9600.17400
PSCompatibleVersions           {1.0, 2.0, 3.0, 4.0}
PSRemotingProtocolVersion      2.2

In this code, we first store it into $p so that the code length is shorter. Then, we check for its existence by leveraging the variable as an index into a two-item array:

If the variable doesn't exist, PowerShell will dynamically create it and assign it $NULL, the ! of which is $TRUE, or 1, which corresponds to the second element in the array, which outputs 1.
If the variable does exist (as is the case in v2+), then the ! of the variable results in $FALSE or 0, which indexes to the first element, which outputs the version number.

Using Foo for 6, we leverage that # is a comment in PowerShell, so that's ignored when executing it in a PS environment. However, Foo will happily spit out the number 6 and then proceed through the rest of the program, which does nothing.
Using Pyth for 7, we return 7, then immediately quit with .q, so the infinite while-true loop that started with # doesn't matter. Since we have something left that gets implicitly printed. Thanks to @FryAmTheEggman for this addition.
Edit - Golfed a handful of bytes thanks to Mauris
Edit - clarified Pyth explanation thanks to Sp3000

How about $p=$PSVersionTable;($p.PSVersion.Major,1)[!$p]? That works on my Powershell, but maybe not on all previous versions.

Python 3, Ruby, Perl, C, C++, Objective-C 202 bytes / 6^3 = 0.935...
This was quite fun actually, and a lot of playing with booleans.
You can all versions of the code at the following site, by copy-and-pasting the code into the interpreter.
#include <stdio.h> /*
print ((("0"+"0"==0)and 3) or (0and 2or 1));
__DATA__ = 1
"""""
*/
int main(){putchar(
#ifdef __OBJC__
'6'
#else
#ifdef __cplusplus
'5'
#else
'4'
#endif
#endif
);return 0;}/*
"""
#*/

Python 3, prints 1
The trick is the following:
print ((("0"+"0"==0)and 3) or (0and 2or 1));

This will print 1
Ruby, prints 2
The interpreted code for Ruby is:
print ((("0"+"0"==0)and 3) or (0and 2or 1));

So this prints 2
Perl, prints 3
The interpreted code for Perl is:
print ((("0"+"0"==0)and 3) or (0and 2or 1));
__DATA__ = 1

First of all, the __DATA__ token tells the Perl compiler that the compilation is finished. Everything after is ignored.
print ((("0"+"0"==0)and 3) or (0and 2or 1));

And prints 3
C, prints 4
The interpreted code is quite different from the others:
#include <stdio.h>
int main(){putchar(
#ifdef __OBJC__
'6'
#else
#ifdef __cplusplus
'5'
#else
'4'
#endif
#endif
);return 0;}

This will simply print the char 4.
C++, prints 5
The same as the C code
This will print the char 5.
Objective-C, prints 6
The same as the C code
This will print the char 6.

Python 1|2|3, 27 bytes / 27 = 1
print(len("\xabc")+(1/2>0))

@sweerpotato's use of version numbers made me wonder whether it was possible to distinguish the Pythons in less. Here's the best I've found.
Explanation
To distinguish Python 3 from the earlier versions, we make use of the standard integer division vs. floating point division trick. (1/2>0) == (0>0) returns 0 pre-Python 2.3 or False from Python 2.3 onwards, and (1/2>0) == (0.5>0) returns True for Python 3.
To distinguish Python 1 from the rest, we take the length of the string "\xabc", which is length one in Python 1 and length two from Python 2 onwards. Why? Because

The \x escape in string literals now takes exactly 2 hex digits. Previously it would consume all the hex digits following the ‘x’ and take the lowest 8 bits of the result, so \x123456 was equivalent to \x56.

(From What's New in Python 2.0)

Subskin, Brainfuck and Fob  27 bytes / 3^3 = 1
0#>&$3#<>$-[----->+<]>-.
31

Subskin
0
31

We set the instruction pointer (doesn't matter here) to 0 and the output register to 31. If the contents of the output register is >= 0, we output the contained value as a char. All other code is ignored.
Brainfuck
-[----->+<]>-.

Puts 3 in the register, decrements the value once with - and finally outputs with ..
Fob
#>&$3#<>$

This is a little bit more tricky, since Brainfuck also reads the < and > instructions in Fob. We enter execution mode with # and increment Brainfuck's pointer by one which makes it easier on us later. We have nothing to execute yet, so nothing is executed.
We enter the accumulator mode with $, throw in a 3, enter execution mode again, push the accumulator contents to the stack with < and finally we output the content with >.
To prevent Brainfuck from screwing with the program we enter accumulation mode again with $.

Craneflak, Brain-Flak Classic, Rain-Flak, BrainHack, Brain-Flueue, miniflak, miniHack: .1020
(([]()()()<()()()>)()()){}#{}({}())

Try it online!
Explanation
The first thing going on here is that there is a difference in the way comments are read between the BrainHack, CraneFlak and Rain-Flak interpreters.  Craneflak has no comments, in Rain-Flak # comments out the rest of the line and in BrainHack #{...} comments out the insides.
So here's what each language reads:
Rain-Flak: (([]()()()<()()()>)()()){}         -> 3
BrainHack: (([]()()()<()()()>)()()){}({}())   -> 4
Craneflak: (([]()()()<()()()>)()()){}{}({}()) -> 1

The next thing is the difference between the brain-flaks and the miniflaks. Both Rain-Flak and BrainHack support miniflak, where all of the extra operations are simply removed.  This means that they lose the [] and <...>
Rain-Flak: (()()()()()())         -> 6
BrainHack: (()()()()()())({}())   -> 7

Next we have the difference between Brain-Flak and Brain-Flak Classic.  In Classic [] is -1 instead of the stack height, which means that our result is 1 less than in regular Rain-Flak, making it 2.
Lastly we have the difference between brain-Flak and brain-flueue.  In brain-flueue a queue is used instead of a stack.  Normally brain-flak pushes 3 then 5 and pops the 5 away, however in brain-flueue the pop gets rid of the 3 and not the 5.

6 Languages, 38 / 6^3 = 0.17592̅5̅9̅
Whitespace, Brainfuck, Ruby, Labyrinth, Foo, Seriously
Legend:
£: tab
•: space
§: 0x7f
puts•2;#4!@•-[>+<-----]>6.§"5"•£
£
•£

This contains unprintable characters, so here's the hexdump:
7075747320323b23342140202d5b3e2b3c2d2d2d2d2d5d3e362e7f22352220090a090a20090a
Explanation:
Whitespace
Try it online. (Note: my program omits the closing three linefeeds to terminate the program, I wrote/tested this on Whitelips and that produces the proper output there, but does not on Try It Online, so the linked program has those two characters added. As far as I can tell, some interpreters let you do that, others get stuck in an infinite loop without the explicit termination)
(omitting ignored characters)
spacespacespacetabenter: push a 1 onto the stack
tabenterspacetab: output the top of the stack
Ruby
Shouldn't need explaining. Prints 2, treats the rest of that line (ergo, the brainfuck program) as a comment, treats the rest of the file as empty.
Brainfuck
Try it online.
Requires an interpreter that supports underflow. Underflows the first cell to 255 then uses that for a loop counter to generate 51, which is the ascii code for 3.
Labyrinth
Try it online.
(omitting the last two lines for legibility because they are never reached)
puts•2;#4!@ -[>+<-----]>6.§"5"•£
puts•                            skipped
     2                           push 2 onto stack
      ;                          pop 2 from stack
       #                         push current stack depth (0) to stack
        4                        push 4 to stack
         !                       print top of stack as integer
          @                      program terminates

Foo
Try it online.
The only thing that affects output is "5", which prints 5.
Seriously
Try it online.
puts•2;#4!@ -[>+<-----]>6.§"5"•£
puts•2;#4!@ -[>+<-----]>           assorted stack manipulation that doesn't affect this program
                        6          push 6 to the stack
                         .         output top of the stack
                          §        (0x7f) terminate program

5 languages, Chaîne, Minkolang, Foo, Brainf**k-ng, and Vitsy, 21 / 5^3 = 0.168
2|<«+!@"3".N+m

5N»

Brainf**k-ng
2|<«+!@"3".N+m

5N»
  <            go left (should still be ok)
    +!         output 1
      @        halt execution

Chaîne
2|<«+!@"3".N+m

5N»
2              «add 2 to the current string»
 |<            «take off and put on the string (no op)»
   «           «comment»

  »
               «implicit output»

Foo
2|<«+!@"3".N+m

5N»
       "3"     print three

Minkolang
2|<«+!@"3".N+m

5N»
2              C push 2 to the stack [2] C
 |             C mirror C
2              C push 2 to the stack [2,2] C
             m C ignored C
            +  C add top two [4] C
           N   C output C
          .    C terminate program C

Vitsy
2|<«+!@"3".N+m

5N»
2              push 2
 |             mirror
2              push 2
             m pop 2, goto line 2
5              push 5
 N             output 5
  »            ignored

I can probably add ><> or something.

You know, I've never found a good use for mirror. xD

Milky Way 1.0.2, CJam and STXTRM, 20 bytes / 3^3 = 0.741
I imagine there is at least one other language that I could add.
'2"3""1"1<<1>;;"2"3;

Explanation

Milky Way, 1
In Milky Way, strings are only denoted by pairs of double quotes. A single quote reads input from the command line; if there is none, it pushes an empty string. Greater than and less than signs will rotate the entire stack rightward and leftward, respectively. Finally, a semicolon swaps the top two stack elements.
Here is a stack visualization (stack shown is the result of the listed operation after it has occurred):
["", 0]                                             #  default stack

["", 0, ""]                                 #   '   #  read input from command line
["", 0, "", 2]                              #   2   #  push 2 to the stack
["", 0, "", 2, "3"]                         #  "3"  #  push "3" to the stack
["", 0, "", 2, "3", "1"]                    #  "1"  #  push "1" to the stack
["", 0, "", 2, "3", "1", 1]                 #   1   #  push 1 to the stack
[0, "", 2, "3", "1", 1, ""]                 #   <   #  rotate the stack leftwards
["", 2, "3", "1", 1, "", 0]                 #   <   #  rotate the stack leftwards
["", 2, "3", "1", 1, "", 0, 1]              #   1   #  push 1 to the stack
[1, "", 2, "3", "1", 1, "", 0]              #   >   #  rotate the stack rightward
[1, "", 2, "3", "1", 1, 0, ""]              #   ;   #  swap the top two stack elements
[1, "", 2, "3", "1", 1, "", 0]              #   ;   #  swap the top two stack elements
[1, "", 2, "3", "1", 1, "", 0, "", 2]       #  "2"  #  push 2 to the stack
[1, "", 2, "3", "1", 1, "", 0, "", 2, "3"]  #   3   #  push "3" to the stack
[1, "", 2, "3", "1", 1, "", 0, "", "3", 2]  #   ;   #  swap the top two stack elements

CJam, 2
In CJam, strings are also denoted by double quote pairs. A single quote pushes the character code of the following character. When a character code is output, it is output as its corresponding character. Greater-than and less-than signs act as expected, evaluating the order of the top two stack elements. Finally, a semicolon discards the top stack element. On termination of the program, the contents of the stack are output.
Here is a stack visualization (stack shown is the result of the listed operation after it has occurred):
[]                         #  default stack

['2]               #  '2   #  push the character code of "2" to the stack
['2, "3"]          #  "3"  #  push "3" to the stack
['2, "3", "1"]     #  "1"  #  push "1" to the stack
['2, "3", "1", 1]  #   1   #  push 1 to the stack
['2, "3", "1"]     #   <   #  leave the greater of the top two stack elements on the stack
['2, 0]            #   <   #  leave the greater of the top two stack elements on the stack
['2, 0, 1]         #   1   #  push 1 to the stack
['2, 1]            #   >   #  leave the lesser of the top two stack elements on the stack
['2]               #   ;   #  pop the top stack value
[]                 #   ;   #  pop the top stack value
['2]               #  "2"  #  push the character code of "2" to the stack
['2, "3"]          #   3   #  push "3" to the stack
['2]               #   ;   #  pop the top stack item

STXTRM, 3
In MSM, anything that is not an operator is pushed to the stack as a character. A semicolon duplicates the top stack element. The program continues until there are no more operators, or there is a single element on the stack.
The final character on the stack is 3, which is duplicated by the final operator. 3 is the topmost element at the end of the program, so it is output.

5 Languages, 18 bytes / 5^3 = 0.144
Runs in Brainbool, Mathematica, Foo, ><> and Befunge-93.
4!<n;+Print@2"3".5

Brainbool
Brainbool is like Brainfuck, but it operates only on bits, and its input and output consists solely of 0 and 1.
4!<n;+Print@2"3".5
  <                   move the pointer to the left
     +                logic not
                .     print the current cell

Mathematica
In Mathematica, everything is an expression and has a value. Print@2 prints 2 and returns the symbol Null. After that, the code does some symbolic calculations, but doesn't print anything.
Foo
"3" prints 3. I don't know what the other parts do.
><>
4!<n;+Print@2"3".5
4                     push 4
 !                    skip the next command
   n                  pop and print it as a number
    ;                 end the program

Befunge
4!<n;+Print@2"3".5
4                     push 4
 !                    logical not
  <                   makes the program counter travel to the right
 !                    logical not
4                     push 4
                 5    push 5
                .     pop and print it as a number
             "3"      push the string "3"
            2         push 2
           @          end the program

12 Languages, 35 bytes / 12^3 = 0.0202546...
Using sweerpotato's trick, cheap but powerful.
Runs in Brainbool, Mathematica 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 and 10.0, Foo and ><>.
cn;+"11".Print@Floor@$VersionNumber

5 languages, 18 bytes / 5^3 = 0.144
Ouroboros, Pip, QBasic, Foo, and Pyth
5'"4"()"
1?3'@n()2

1. Ouroboros
Each line of the program represents a snake eating its tail.
Snake 1
Push 5, ' is a no-op, push 52 (ASCII code of "4"). ( causes the snake to pop a number and eat that many characters of its tail. Since this results in swallowing the instruction pointer (and the entire snake), execution halts.
Snake 2
Push 1, push a random number (?), push 3, ' is a no-op. @ rotates the 1 to the top of the stack and n outputs it as a number, leaving the 3 on top of the stack. Then ( eats this many characters from the end of the snake, swallowing the instruction pointer and halting.
You can run this program online in the Stack Snippet interpreter here.
2. Pip
Most of the program consists of expressions which are evaluated and discarded:

5
'" (character literal)
4
"()"
1?3'@ (ternary expression)
n (variable, = newline)
() (nil)

Finally, the last expression, 2, is printed.
3. QBasic
Everything after ' is a comment. The first line thus boils down to 5, a line number. On the second line, 1 is a line number and ?3 is a shortcut for PRINT 3.
(Apparently having line numbers out of order isn't a problem, though it would be easy to fix if it were.)
4. Foo
Almost everything is no-ops. "4" prints 4. The parentheses (x2) are a loop that runs until the current array cell is zero, which is true immediately and the loop exits. @, when not followed by a number, takes the value of the current array cell (initialized to 0) and pushes it to the stack.
I'm not entirely sure how the second, unmatched " is supposed to be handled. The online version seems to add a newline to the output, which the rules of the challenge allow.
5. Pyth
5 is output. Then the program encounters '"4", which tries to read from a file named 4. As long as no such file exists, I think this should terminate the program with an error. (The online version says name 'open' is not defined--I assume because opening files isn't allowed online.)
The stray " at the end of line 1 ensures that line 2 doesn't cause a syntax error before execution.

http://foo.tryitonline.net/#code=MT8zJ0BuIjQiKCky&input=

@Dennis Thanks! The Esolangs page didn't have a link to that interpreter.

Here's the index of the currently available languages. If you ever want me to add one, just ping me in chat.

4 languages, 24 bytes, 24/4^3=0.375
print(1//0.5--1+1/2*2
);

1. PHP
PHP executes print(1); which equals 1
2. Lua
Lua executes print(1//0.5); which equals 2
3. Python 2
Python 2 executes print(1//0.5--1+1/2*2); which equals 3 (integer division)
4. Python 3
Python 3 executes print(1//0.5--1+1/2*2); which equals 4 (float division)

Nice answer, I like answers in conventional languages :-) hope you'll have fun golfing on ppcg :-)  please try out any of my previous challenges if you think they are interesting :-) some are a bit tricky and some are more basic :-)

You might be interested in the open 100 rep bounty described in the challenge. Outgolf Sp3000 (28 bytes, 4 languages) using only conventional languages (defined in the link) and it's yours :-) unfortunately python 2 and 3 are not considered unique in the bounty challenge.

Brainfuck-ng, Foo, ><>, 9 bytes / 3^3 = 0.333...
#+!"2";n3

Brainfuck-ng
The only characters it recognizes are + and !:
+ Increment cell by one
! Print as integer

Prints 1
Foo
Prints everything in quotes.
"2"

Prints 2
><>
# Mirrors the point to the left, 3 pushes 3 to the stack, n outputs it as an integer, ; stops the program.
#      ;n3

Alphapolyglot, 8 languages, 37 bytes, score 0.072265625
8
"6";;7iiiio hkaeeeaeaeawxzz ax zaCM

Features AlphaBeta, Beatnik, Commentator, Deadfish~, evil, Foo, Golfscript, and Husk. Thanks to Leo for helping with Husk.
Explanation
AlphaBeta
8"6";;7iiiio hkaeeeaeaeawxzz a       # Garbage
                              x z    # Clear register 1 and 3
                                 a   # Add 1 to register 1
                                  C  # Set register 3 to register 1
                                   M # Output register 3 as a number

Beatnik
iiiio hkaeeeaeaeawxzz ax zaCM is 5 50 9 17.
5 50 pushes 50 (2 in ASCII)
9 outputs the top of the stack as a character.
17 exits the program.
Commentator
There are 3 spaces in the program, each one increments the active accumulator.
Deadfish~
8"6";;7iiii                          # Increment 4 times
           o                         # Output as a number
             h                       # End program
              kaeeeaeaeawxzz ax zaCM # Garbage

evil
8"6";;7iiiio hk                      # Garbage
               aeeeaeaea             # Increment and weave the accumulator to 53 (5 in ASCII)
                        w            # Output accumulator as a character
                         xzz ax zaCM # More garbage

Foo
8                                    # Garbage
 "6"                                 # Output 6
    ;;7iiiio hkaeeeaeaeawxzz ax zaCM # Garbage

Golfscript
8                                    # Push 8
 "6"                                 # Push the string 6
    ;;                               # Pop and discard twice
      7                              # Push 7
       iiiio hkaeeeaeaeawxzz ax zaCM # Garbage

Husk
The first line is executed first.
8 # Return 8

The second line isn't executed.

Husk can work ;) https://tio.run/##yygtzv7/34JLyUzJ2to8EwjyFTKyE1NTUxNBsLyiqkohsUKhKtHZ9/9/AA

3 Languages, 82 83 / 3^3 = 3.074...
Works in ???, Whitespace, and Beatnik. Or rather, it should work in those languages but I am not going to be able to test them for a few days. Anyway, here is the code:
K... Jax... Jy... Jy...   ...
My...    My...
... ...     ......................XO!

1. ???
.................................................!

??? is basically brainfuck but it uses common punctuation as commands instead of the traditional characters. . increments the current memory cell, which is done 49 times. ! takes the current memory cell and prints it as a character, here 1.
2. Whitespace
[Space][Space][Space][Tab][Line Feed]
[Tab][Line Feed]
[Space][Tab]

Whitespace is a language that ignores all non-whitespace characters. Here I've converted it to an easily readable form. The first line pushes 2 onto the stack, and the second two lines print the top of the stack as a number, here 2.
Note that in the combined code, I have substituted tabs with four spaces due to technical limitations.
3. Beatnik
K Jax
Jy Jy
My My
XO

Beatnik is a language where each word is converted to its Scrabble score, then those scores are interpreted as commands. The first line pushes 17 onto the stack. The second line duplicates the top of the stack twice and the third line adds the top to elements of the stack together twice, effectively tripling 17 into 51. The last line prints the character on the top of the stack, here 3.
Note that I am using Beatnik at Face Value, assuming there is not an error in the original Beatnik specification. Also note that I am using the North American English Scrabble scoring system.
If it is not clear by now, each of these languages only accepts a certain type of character (punctuation, whitespace, and letters, respectively) so writing this polyglot was as easy as writing the individual programs. The only real "trick" is using the Whitespace code to separate the words from Beatnik. Beyond that, the individual programs do not overlap whatsoever.

3^3=27 ==> 82 / 27 = 3.037037037037037...

Your Whitespace code prints 0, not 2. Tested here and here.

@Dennis Thanks, I had omitted the sign bit.

5 languages, 175 / 5^3 = 1.4
I decided to post a different answer since the bounty is changing the requirements in a way that made me feel unsaitsfyed with my first answer (but which is still satisfying me in the way of the generall challange!)
So here is my solution that qualifys for the bounty challange:
It compiles in

C99
objC90
C++0x
Ruby
Perl

#if __cplusplus
#define x\
=begin\
=pod
#endif
int a=
#ifndef x
1//**/
+1
#else
3
#endif
;int main(){printf("%d",a);}
#ifdef f
=end
puts 5;
=begin
=cut
print"4";
=end
#endif

3 languages, 15 bytes, score 0.555...
Gonna add more languages later.
2//1+1#

1. Emotinomicon
Emotinomicon pretty much ignores any text that isn't a string.  pushes 1 to stack and  outputs the TOS as a number.
2. Javascript
Comments in Javascript start with //, so only the 2 part gets executed.
3. Python 2/3 REPL
Comments in Python start with #, so only the 2//1+1 part gets executed. // is integer division in Python 3, and it is the same as / in Python 2. 2 divided by 1 is 2, plus 1 is 3.

4 languages, 97 bytes, 0.37890625
s="1";s=~-3;2//2;'''/.to_s.ord;"=;print 4;
__DATA__
=1;
";#'''#";print=s=>console.log(3)
print(s)

Ruby
This sets s to "1", compares using =~ against -3 in a void context, tries to divide 2 by /2;'''/.to_s.ord then starts a new string containing =;print 4; __DATA__ =1;, hits a comment, then prints s which is still 1.
Python
Sets s to "1" as per above, then sets it again to ~-3 which is 2. We run an integer division of 2//2, then there's a docstring containing /.to_s.ord;"=;print 4; __DATA__ =1; ";#, followed by a comment, finally printing s, which is still 2.
JavaScript
Sets s to "1" then sets it again to ~-3 as per above, then there's 2 on the line followed by a comment. Then we set the variable __DATA__ to 1. There's a short string containing ;#'''# followed by a definition of the function print which hardcodes the output to be 3, which is called on the next line.
Perl
Runs a substitution equivalent to s/"1";s/~-3;2\/\/2;'''\/.to_s.ord;"/, prints 4 and the rest of the string is masked behind the __DATA__ identifier.

QBasic, QBIC and ><>, 18 bytes / 3^3 languages = 0.66666 points
1:?v+1'-5`
''`>3n;

Breakdown:
1. QBasic (Get the IDE)
1:          Line number 1
  ?         Print
   v+1      undefined var v = 0 + 1 = 1
'-5`        The rest of theis code is a QBasic comment
''`>3n;     As is this

2. QBIC (Get the interpreter)
1     inserts a 1 in the code - mostly harmless
:     Reads from the cmd line. Nothing there, creates an empty variable a
?     Print
v+1   v is initialised to 6, +1 = 7
'     Code Literal: everything till the ` is passed to QBasic without processing
 -5`  7-5 = 2

''`>3n; Code literal with the first literal being a ': comment in QBasic

3. ><> (Try it online)
1:  Push a 1 on the stack, duplicate stack
?   Pop top off the stack and skip next instruction if that's a 0
v   Move downwards - rest of the line is ignored

>   move to the right
3   Push 3 onto the stack
n   Print the top of the stack as a number
;   End the program

I think you want to cube the number of languages in your score (ie. 18 / (3^3) )

Jelly / 05AB1E / Whitespace, 14 bytes, score \$0.\overline{518}\$
[S][S][S][T][T][LF]
[T][LF]
[S][T]1o

[S], [T], and [LF] added for visual clarity only.
I was going to add naz to the chain, but I guess it doesn't handle whitespace very well.
Jelly explanation
[S][S][S][T][T][LF]
[T][LF]
[S][T]
1                   # Literal 1
 o
# ...after which the result is output implicitly

Try it online!
05AB1E explanation
[S][S][S][T][T][LF]
[T][LF]
[S][T]
1                   # Push 1
 o                  # Push 2 ** 1
# ...after which the result is output implicitly

Try it online!
Whitespace explanation
[S][S][S][T][T][LF] # Push 3 to the stack
[T][LF][S][T]       # Output the top of the stack
1o                  # Ignored

Try it online!
I'm not very good with these languages — if you spot anything wrong with these explanations, please feel free to improve this post!

JavaScript, HTML and PHP, 72 bytes / 3^3 = 2.67
1<!top?2:2//><!--<?='--'.'><script>document.body.innerHTML=3</script>'?>

In HTML, this will print the leading 1, ignore the <!window?2:2//> tag, and the rest is an HTML comment.
In JavaScript, it evaluates 1<!window?2:2 and outputs 2 (this must be run in a console) and the rest is a comment.
In PHP, the following is output from the server: 1<!top?2:2//><!----><script>document.body.innerHTML=3</script> which replaces HTML's 1 with 3.

Welcome to PPCG.SE! Great first post! Two things: we don't usually like REPL-based answers (the Javascript program). Additionally, the PHP code does not seem to run when I put it into an online interpreter, how exactly does the PHP work?

Thanks! Well, it's technically PHP + HTML (ie. if this is the source code for code.php, visiting http://site/code.php in a browser displays 3.

Try it here: http://mowbl.com/se.php.

Python 1,2,3, Pyth, Seriously 40 bytes/5^3 = 0.32
#4X.q5
import sys
print(sys.version[0])

Python 1,2,3 prints their version
This is based on the same code by sweerpotato. The # starts a comment so the first line is not compiled.
Pyth prints 4
#4X.q starts a while loop, X does something unnecessary, and .q quits the program.
Seriously prints 5
#4X.q5 starts out with # which does nothing, then 4 is pushed to the stack, X clears the stack, .q does nothing, and 5 is pushed on the stack and an invisible character (hex code 7f) quits the program and prints what is on the stack.

that's a boring solution.

16 languages, 149 bytes, score 0.03637695312
1` FSR3U3%3&(()())#5➡MoOMoOMoOMoOMoOMoOOOM++++++++.$:H@@@@@@@.   {-   !*/}(10)aeeeaeeawaaaaaw> 11
➕⎚14»R"15"*
print 13
[ [

WIP, I plan to add a lot more.

Element
Brain-Flak
SimpleStack
Cubically
Emoji
COW
Agony (outputs via raw ASCII)
Beam
Commentator (currently broken but according to the language spec should work fine)
Straw
RProgN
Emotinomicon
S.I.L.O.S
Charcoal
Fission
evil

Brainglot, score 20/4^3 = 0.3125
-[>+<-----]>(-)$-!+.

1. brainbool
Brainbool only sees [>+<]>+.. The loop never runs, and the > just moves the pointer, so it's basically just +.. The + flips the bit, and the . outputs the current bit, which is 1.
2. brainfuck
Brainfuck only sees -[>+<-----]>--+.. The -+ can be removed, which results in -[>+<-----]>-.. The part before the . is just the wrapping program for 50 on the esolangs wiki.
3. Extended Brainfuck Type I
Extended Brainfuck Type I only sees -[>+<-----]>-$-!+. The $-! can be removed, leaving -[>+<-----]>-+., where the -+ can be removed which turns it into -[>+<-----]>.. The part before the . is just the wrapping program for 51 on the esolangs wiki.
4. Brainlove
Brainlove sees the full program. The (-) and $-! can be removed, leaving -[>+<-----]>+.. The part before the . is just the wrapping program for 52 on the esolangs wiki.

C C++ Python Ruby, 163 bytes
Score = 163/4^3 = 2.55
#include <stdio.h>
#if 0
C = 3
""" "
C = 4;\
" """
#endif
#ifdef __cplusplus
#define A 49
#else
#define A 50
#endif
#define print(X) main(){putchar(A);}
print(C);

C, Python 2, Python 3, 99 bytes / 3 languages ^ 3 = 3.666677 points
Python 2 and 3 both use a version string, and the first character is the major version number. C prints 1, Python 2 prints 2, and Python 3 prints 3.
#include <stdio.h>/*
import sys
print(sys.version[0])
#*/
#define pass main(){printf("%d",1);}
pass

∞-ish, 12 7 bytes
B3+0-8%

Non-competing as language postdates challenge and this is rather cheap. This prints:

1 in Cubically 2x2x2 (Try it online!)
2 in Cubically 3x3x3 (Try it online!)
... 50 in Cubically 51x51x51 (Try it online!)

 B3+0-8%
 B3       set top face sum to Cubically version
   +0     add top face sum to notepad
     -8   subtract !issolved(cube) from notepad
       %  print notepad

Basically, B3 gets the cube state to this in 3x3x3:
   111
   000
   000
511222330444
511222330444
511222330444
   555
   555
   333

As you can see, the top face sum is 3. As the smallest possible cube is a 2x2x2, we have to subtract 1. In Cubically 4x4x4, the cube would look like this:
    1111
    0000
    0000
    0000
5111222233304444
5111222233304444
5111222233304444
5111222233304444
    5555
    5555
    5555
    3333

6 languages, 31 bytes, 31/6^3 = 0.1435
As soon as I add another language to it the score gets worse, here is what gave me the best result so far:
kill -l|wc|dc -e\?58%8/1+p#^[cc6

1-5: Various shells + dc
The shells see this, the rest of the line is a comment:
kill -l|wc|dc -e\?58%8/1+p

The shell's output for kill -L is different, their output gets piped to wc to count the number of bytes (N) and compute (N % 58)/8 + 1 which coincidentally gives the right result.

Dash: Try it online!
ksh: Try it online!
tcsh: Try it online!
Bash: Try it online!
Zsh: Try it online!

6: Vim
The key k doesn't do anything with the buffer, i switches to insert mode and the following characters get typed. After # there's an ^[ character so Vim switches back to normal mode. cc deletes the line and switches to insert mode where we insert 6.
Here's how it looks in Vim:

Try it online!

Javascript (spidermonkey), PHP CLI, Perl
41 bytes, 41/(3**3) = 1.52
$x="5y";print("".$x?$x=="5"?"3":"2":"1");

If you try to execute it using normal Javascript rather than spidermonkey, it will do ctrl+p.

not so much 6 "languages" as peculiarities between 6 ways of using awk
for __ in 'nawk' 'gawk -M' 'mawk1' 'mawk2' 'gawk -b' 'gawk'; do

   $( printf '%s' "$__" ) 'BEGIN { print match(sprintf("%x%u%c%x%c",
                ((_+=++_)^(_+=_))^(_^=_),-!!_,_,_,!_),/$/)%25%13%7 }'
done

1
2
3
4
5
6

nawk 20200816
gawk 5.2.2 (GMP mode)
mawk 1.3.4 20230808
mawk 2
gawk 5.2.2 (byte mode)
gawk 5.2.2 (UTF8 mode)

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Convert between SI prefixes
Introduction
The International System of Units is a system of measuring all around the world, except for a few countries including the US. The SI system (or metric system) is based on powers of ten, listed below (note that this is an incomplete table):
femto(f) pico(p) nano(n) micro(μ) milli(m) centi(c) (base unit) hecto(h) kilo(k) mega(M) giga(G) tera(T) peta(P)
10^-15   10^-12  10^-9   10^-6    10^-3    10^-2    10^0        10^2     10^3    10^6    10^9    10^12   10^15

Your job will to be to take in one of these measures and convert it into another.
Input
Input will be a decimal number 10^-16 < x < 2^31 - 1, an SI prefix, a letter representing a quantity, another SI prefix to convert to, and the same quantity letter. Input will be in the format 1234.56 mC to TC, and will always match with the regex ^\d+(\.\d+)? [fpnμmchkMGTP](?'letter'[a-zA-Z]) to [fpnμmchkMGTP](?P=letter)$. You will never have to convert to/from the base unit (10^0)
Output
Output will be the same number as the input, just converted to a new SI prefix. Specifically, the program should convert the number from SI prefix 1 to SI prefix 2 in the input. Examples:
Input: 1 nm to μm
Output: 0.001

Input: 82 kC to cC
Output: 8200000

Input: 6.54 MK to hK
Output: 65400

Input: 2000 MB to GB
Output: 2

This is code-golf, so shortest code in bytes wins!

Another thing, when generating a large/small number in this way, what should the output be? e.g. 1 PB to fB

@FryAmTheEggman you may assume the input will never produce an output that is larger/smaller than the range of digits that your language can natively handle (I think that is what you are asking).

Should we use U+00B5 MICRO SIGN or U+03BC GREEK SMALL LETTER MU? Can we choose either one or do we have to support one or both?

@Pietu1998 either one is fine.

Are we allowed to output a floating point number even if the result is an integer?

@Pietu1998 yes, I'll add that

In Mathematica: ({a,b,c,d}=StringSplit@#; UnitConvert[Quantity[ToExpression@a,b],d])&

Pyth, 46 44 bytes
The program assumes that the character µ (U+00B5 MICRO SIGN) is used for the micro sign. On Windows, this is what you get by pressing Alt Gr + M.
The source code contains some unprintables, so here is a reversible xxd hex dump.
0000000: 2a76 684a 637a 645e 542d 466d 406a 4322  *vhJczd^T-Fm@jC"
0000010: 5c72 575d d623 8b9e 53bb 4c09 b275 2233  \rW].#..S.L..u"3
0000020: 3125 7443 6864 3137 2532 744a            1%tChd17%2tJ

Here's a copy-friendly version:
*vhJczd^T-Fm@j1057004749883241517573776978549 31%tChd17%2tJ

You can try the demo or use the test suite. If these links fail, use the copy-friendly version (demo, test suite).

JavaScript (ES7), 113 109 bytes
s=>(p=s.split` `)[m={f:-9,p:-6,n:-3,µ:0,m:3,c:4,h:8,k:9,M:12,G:15,T:18,P:21},0]/(10**(m[p[3][0]]-m[p[1][0]]))

Edit: Apparently we can use µ(U+00B5 MICRO SIGN) for the micro sign now, so replacing with that saves a byte.
For ES6 compatibility (10**(m[p[3][0]]-m[p[1][0]])) can be replaced with Math.pow(10,m[p[3][0]]-m[p[1][0]]) for 114 bytes.
Explanation
s=>                                  // s = input string
  (p=s.split` `)                     // p = input parts

    // m = dictionary of SI prefix digit powers of 10
    //     the exact values don't matter as long as they are relative to each other
    [m={f:-9,p:-6,n:-3,µ:0,m:3,c:4,h:8,k:9,M:12,G:15,T:18,P:21},

    0]                               // get the number
      /(10**(m[p[3][0]]-m[p[1][0]])) // get the factor to divide by from the difference
                                     //     between the SI prefix powers of 10

Test
This test uses Math.pow instead of ** so that common browsers can test it.

<input type="text" id="input" value="2000 MB to GB" /><button onclick="result.innerHTML=(

  s=>(p=s.split` `)[m={f:-9,p:-6,n:-3,µ:0,m:3,c:4,h:8,k:9,M:12,G:15,T:18,P:21},0]/Math.pow(10,m[p[3][0]]-m[p[1][0]])

)(input.value)">Go</button>

Haskell, 143 bytes
Call s.
import Data.List
s=i.words
i(n:f:_:[t])=read n*10**(x f-x t)
x=j.flip elemIndex"f  p  n  µ  mc   hk  M  G  T  P".head
j(Just n)=fromIntegral n

I like your "f  p  n  µ  mc   hk  M  G  T  P" trick a lot. +1

I like this trick also. A tip: you can combine x and j with a pattern guard to: x y|Just n<-elemIndex(y!!0)"f  p  n  µ  mc   hk  M  G  T  P"=fromIntegral n.

CJam, 67 bytes
lS%:I0=dA"fpnµmchkMGTP"[-7 -4WY5 6ABEHK23]+:AAI3=c#C+=AAI1=c#C+=-#/

Try it online!
Uses µ (U+00B5) for the micro sign so make sure you use this in your input instead of the μ (U+03BC) in the question.
My first attempt at using CJam. Feel free to suggest improvements because I'm sure there are many!
Explanation
Same method as my JavaScript answer.
lS%:P                    e# P = input parts separated by space
0=d                      e# get number as double
  A
  "fpnµmchkMGTP"
    [-7 -4WY5 6ABEHK23]+
      :A                 e# A = array of SI prefixes followed by their (relative) values
   AP3=c                 e# desired SI prefix
     #C+=                e# get SI value of prefix
   AAP1=c                e# current SI prefix
     #C+=-               e# subtract value of prefix
   #                     e# get power of SI prefix difference
/                        e# divide value by 10 ^ SI prefix difference

Ruby (2.2.1), 126 123 bytes
r={f:-9,p:-6,n:-3,µ:0,m:3,c:4,h:8,k:9,M:12,G:15,T:18,P:21};p ($*[0].to_r/10**(r[$*[3][0].to_sym]-r[$*[1][0].to_sym])).to_f

Saved 3 bytes thanks to user81655
Explanation
# Hash of prefixes to relative powers
r={f:-9,p:-6,n:-3,µ:0,m:3,c:4,h:8,k:9,M:12,G:15,T:18,P:21};
p (                      # print (inspect)
  $*[0].to_r             # input value
  / 10 ** (              # divided by 10^...
    r[$*[3][0].to_sym]   # first prefix symbol
    -
    r[$*[1][0].to_sym]   # second prefix symbol
  )
).to_f                   # convert to float for proper format on output

Takes input from the command line e.g ruby si.rb 1 nm to μm
This is my first golf!

You can save 3 bytes if you use the values {f:-9,p:-6,n:-3,µ:0,m:3,c:4,h:8,k:9,M:12,G:15,T:18,P:21} for the hash table. Also replacing μ with µ (U+00B5) is allowed and will save another byte.

@user81655 good advice, thanks! The two mu/micro symbols seem to give the same byte count when I wc -c my file, any idea why that is?

No problem. Your file is probably encoded using something like UTF-8 which splits characters above 127 into two bytes. If you switch to a one-byte encoding like ANSI it should remove the extra byte from the file.

Haskell, 121 bytes
(e:l:i)!d|e==d=fromEnum l|0<1=i!d
b#i="f`pcnfµimlcmhqkrMuGxT{P~"!(b!!i)
g[(a,b)]=10**fromIntegral(b#1-b#7)*read a
f=g.lex

Defines a function f :: String -> Double. For example:
*Main> f "6.54 MK to hK"
65400.0

Perl 5, 113 + 8 (-p -Mutf8) = 121 bytes
%c=(f,-15,p,-12,n,-9,µ,-6,'m',-3,c,-2,h,2,k,3,M,6,G,9,T,12,P,15);/([0-9.]+) (.).*(.)./;$_=$1*10**($c{$2}-$c{$3})

Try it online!

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Parse a two-dimensional syntax
Background
Alice and Bob are creating a golfing language to win every single PPCG challenge.
Alice wants to make a two-dimensional language, like ><>, but Bob prefers a prefix-infix syntax like in J.
As a compromise, they decide to create a two-dimensional prefix-infix language.
The parser is a pain to write, and they need your help!
Syntax specification
In Alice's and Bob's language, there are variables, which are represented by lowercase ASCII letters a-z, and functions, which are represented by uppercase ASCII letters A-Z.
A function can be invoked with one or two arguments.
A program is a rectangular grid of letters a-zA-Z and spaces, and the top left corner must not contain a space.
This is an example of a valid program:
F Gy
H
R x

When the program is parsed, it's transformed into an expression of a C-style language (C, Java, Python...) containing single-letter variables and function calls in the format <func>(<arg>) or <func>(<arg1>,<arg2>).
For example, the above program results in this expression:
F(H(R(x)),G(x,y))

The details of the parsing process are as follows:

The spaces are just filler, so they are not parsed.
Every variable a-z is always parsed as itself.
Every function A-Z is parsed as a function call. Its arguments are the closest expressions below it and to its right in the grid, in this order. If only one of these is present, it's given as the sole argument. You can assume that all functions have at least one argument in the grid.

In the above example, the variables x and y are parsed as themselves.
The function R has nothing below it and x to its right, so it's parsed as the one-argument invocation R(x).
Similarly, H is parsed as H(R(x)), since it has R below it.
The function G has x below it and y to its right, so it's parsed as G(x,y), and similarly for F.
The expression parsed at the top left corner is the result of the parsing process.
Input and output
Your input is a non-empty rectangular array of characters.
It will always be a valid program in Alice's and Bob's language, but it may contain expressions that are not used in the output.
Your output shall be the parsed expression resulting from the above process.
Rules and scoring
You can write a full program of a function.
The lowest byte count wins, and standard loopholes are disallowed.
Test cases
These are given in the format grid <newline> expression, with hyphens --- between the cases.
The SE format leaves some lines blank, but they should be filled with spaces.
x
x
---
x y
z
x
---
Fx
F(x)
---
Fx
y
F(y,x)
---
ABu
A(B(u))
---
G
H
k
G(H(k))
---
ABCA
x xs
 DFk
A(x,B(D(F(k)),C(x,A(s))))
---
A  B

C  D x
A(C(D(x)),B(D(x)))
---
RT Hq
I xR k
R(I(x),T(H(R(k),q)))
---
A A  A a
 S A  b
B  C   Dx
d X  u f
A(B(d,C(D(f,x))),A(X(u),A(u,a)))

Would an output like (A (B (D x)) (C (D x))) be suitable or is the format fixed?

@coredump In this challenge, the output format is strict; Alice and Bob want to be able to use the parsed expression directly.

Where is the "infix" part of the language? I only see prefix.

@PaŭloEbermann A function with two arguments can be thought of being between the arguments, on the Γ-shaped path from the bottom argument to the right one.

Can you please actually create a language with this syntax? :)

Follow-up challenge: write a meta-golfer for this syntax (given an expression tree, find the smallest grid corresponding to it). For extra difficulty, distinguish between commutative and non-commutative functions.

CJam, 67 62 60 58 57 54 bytes
Thanks to Dennis for saving 4 bytes.
{:Gsc_32&{"()"[GGz2{1m<_{S#}#>W<\}*z]{},{J}%',**+}|}:J

This defines a named block (function) J and leaves it on the stack. The function itself expects an array of strings on the stack, which represents the input grid, and leaves the desired string in its stead.
Test it here.
I've been meaning to tackle this one since it was posted, but apparently I needed a bounty and an overly long Pyth solution to motivate myself sufficiently.
Explanation
The solution is of course recursive and gradually builds up the string.
{
  :G       e#  Store the current grid in G.
  sc       e#  Convert the grid to a string, flattening it, then to a character, which
           e#  discards everything but the first character. This is a golfed 0=0=.
           e#  This character will either be an upper-case letter (function) or a lower-
           e#  case letter (variable).
  _32&     e#  Make a copy of the character and take bitwise AND with 32. This gives a
           e#  NULL character for functions and a space for variables.
  {        e#  If the result is falsy... (i.e. NULL, i.e. we have a function)
    "()"   e#   Push parentheses for later use.
    [      e#   Remember the current stack depth.
    GGz    e#   Push an array which contains the grid and its transpose.
    2{     e#   Run this block twice... (it will be applied once to each grid)
      1m<  e#    Rotate the rows. This has two effects: a) It removes the first row
           e#    from the front such that we can go looking for the next non-space
           e#    character down the first column from the start. b) It places a row
           e#    at the end which we know doesn't start with a space, which acts as
           e#    a guard in case there are no further letters below the current one.
      _    e#    Duplicate this grid.
      {    e#    Find the first index where this block yields something truthy...
        S# e#     Find the index of the first space in the current row. If the row
           e#     starts with a space, this is 0, i.e. falsy and the search continues.
           e#     If there is a space in any later position, that will be positive and
           e#     truthy, so this index gets returned. If there is no space at all,
           e#     the result is -1 which is also truthy and ends the search.
      }#
      >    e#     Discard all lines up to (but not including) the found index.
      W<   e#     Discard the guard row at the end.
      \    e#     Swap the grids so that the next pass processes the other grid.
    }*
    z      e#    Transpose the second grid back to its original orientation.
    ]      e#    Wrap both processed grids in an array.
    {},    e#    Remove a grid if it's empty.
    {J}/   e#    For each remaining grid, call J recursively.
    ',*    e#    Join the grids with commas if there are still two of them.
    *      e#    Wrap this string in the parentheses below on the stack.
    +      e#    Prepend the function name.
  }|
}:J

Haskell, 124 122 120 119 bytes
r@((c:_):_)#g|c>'_'=[c]|c<'!'=g%r|1<2=c:'(':(tail%r)!(map tail%r)++")"
_#_=""
g%r=g r#g
a!b=a++[','|a>"",b>""]++b
(#id)

Usage example: (#id) ["RT Hq ","I xR k"] -> "R(I(x),T(H(R(k),q)))".
How it works: besides the input grid r, the function # takes another function g as an argument that is applied on r whenever the top left character is a space. If it's a lowercase char instead, return it. Otherwise it must be an uppercase character and # is called recursively, once with tail to go down and once with map tail to go right. ! joins the results from the recursive calls with a ,, if needed. All starts with the input grid and the identity function.

Python 2, 227 223 192 182 179 177 bytes
def r(i,y=0,x=0):
 c=i[y][x];z=[]
 for t in"pq":
    p=q=0
    try:
     while" "==i[y+p][x+q]or 1>p+q:exec t+"+=1"
     z+=[r(i,y+p,x+q)]
    except:1
 return c+"(%s)"%",".join(z)*c.isupper()

(The four spaces are in fact tabs)
Takes a 2d list of characters as the first argument to r.

Pyth, 97 bytes
D:TkdI}p@@QTkGR)=Z0p\(V2JK0W|q\ @@Q=b+TJ=H+kK!+JK=J+NJ=K+!NK)I!|gblQgHl@Q0p*Z\,:bH+=Z1d))p\);:000

My god that took a long time to make (about 5/6 hours?). Pyth really wasn't designed for this...
Try it here.
Attempt at explanation as well as python equivalent
Q = literal_eval(input())

def at_slice(T,k,d):
  if Pprint(Q[T][k]) in "abcdefghijklmnopqrstuvwxyz": return
  Z = 0
  Pprint("(")
  for N in range(2):
    J=K=0
    while " "==Q[assign('b',T+J)][assign('H',k+K)] or not J+K:
      J+=N
      K+=not N
    if not (b>=len(Q) or H>=len(Q[0])):
      Pprint(Z*",")
      at_slice(b,H,assign('Z',1)+d)
   Pprint(")")
at_slice(0,0,0)

Where the functions Pprint and assign return what they're given.

Much concision. Such wow.

Python 3, 187 bytes
Still looking for ways to golf this down, but I'm just pleased I managed to turn it into a one-liner.
lambda g,r=0,c=0:g[r][c]+'(%s)'%','.join([p(g,R,c)for R in range(r+1,len(g))if c<len(g[R])and' '!=g[R][c]][:1]+[p(g,r,C)for C in range(c+1,len(g[r]))if' '!=g[r][C]][:1])*g[r][c].isupper()

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/