text:
The Programming Language Quiz

Congratulations to Dennis who won both the cops' and the robbers' challenge! Calvin's Hobbies has already delivered on his promise and wrote this challenge for Dennis for winning the robbers' challenge.

Notice: This challenge is closed for further cop answers as of 2015-09-01 02:00:00 UTC. Any new answers posted will not be eligible for winning and will not count towards the robbers' scores if cracked. However, you may still post new answers for the other users' enjoyment, so that there are still some puzzles available for future visitors. These new answers are included in the "Vulnerable Cops" section of the leaderboard and their non-competing status is marked separately.

Welcome to the Cops-and-Robbers edition of The Hello World Quiz! (If you've never played the quiz, feel free to try it out for a minute or 30. You don't need to have played it for this challenge though.)
The Cops' Challenge

Choose a programming language. Valid languages must have either an English Wikipedia article, an esolangs article or a Rosetta Code article at the time this challenge was posted (note that the linked lists are not necessarily complete because they are curated manually). They must also satisfy our usual standards for programming languages, so things like HQ9+ are out. Lastly, there must be a free (as in beer) interpreter or compiler available for the language (at the time this challenge was posted).
Write a Hello World program. That is, write a full program in the chosen language which prints Hello, World! (exactly like that, i.e. this exact byte stream) and optionally a single trailing newline to STDOUT or closest alternative.
You must not assume a REPL environment, existing boilerplate code, or non-standard compiler/interpreter flags. The program must be in the form of one or more source files (to rule out quirky languages like Folders) and must fit into your answer in full (so it must not be longer than 30,000 characters) - this shouldn't be an issue for any serious submission.
If your code contains bytes outside the printable ASCII range, please include a pastebin or hex dump to make sure your code is actually testable.
The program must terminate within 1 minute on a typical desktop PC.

That's it. The catch is that you want to obfuscate your code such that it's not obvious which language you picked. Also note that you don't want your code to accidentally be a valid Hello World program in any other language, although I expect that to be unlikely for sufficiently obfuscated programs.
You must not under any circumstances edit the source code of your submission once posted (as this may invalidate a robbers' active attempts at cracking your answer). So make sure that you golf it as well as you can (or dare) before posting. If you realise that your answer does not work after posting it, simply delete your answer and post a fixed version if you want to.
If no one finds a language your code is valid in for 7 days, you may reveal the chosen language (ideally with an explanation for your obfuscated code), which will make your answer safe. Note that your submission can still be cracked until you reveal the language.
The shortest safe submission (in bytes) wins.
Formatting
(Feel free to skip this section and read The Robbers' Challenge if you're not planning to participate as a cop right now.)
At the bottom of this post, you'll find a Stack Snippet which generates leaderboards as well as a list of submissions which can still be cracked. For the snippet to work, it is important that you include a certain header in your answer:

New answers should include a header like
# ???, [N] bytes

where [N] is the size of your code in bytes and ??? should appear literally.
If the answer is not cracked for 7 days and you want to make your answer safe by revealing the language, simply replace the ???, e.g.
# Ruby, [N] bytes

Feel free to have the language name link to a relevant website like an esolangs page or a GitHub repository. The link will then be displayed in the leaderboard.
If another user successfully cracked your submission (see below), please also add the language, along with a notice like
# Ruby, [N] bytes, cracked by [user]

where [user] is the name of the user who submitted the first valid crack. If the language used in the crack is different from the one you intended, I'd recommend using the robbers' guess and mentioning in the answer that you intended it to be something else. Feel free to make the user name a link to their profile page.

The Robbers' Challenge

Find a vulnerable answer. That is an answer, which hasn't been cracked yet and which isn't safe yet.
Crack it by figuring out its language. That is, find any language in which the given program is a valid Hello World program (subject to the rules outlined in The Cops' Challenge above). It doesn't matter if this is the language the cop intended.
If you've found such a language, leave a comment with the language's name. If possible, you should include a link to an online interpreter, showing that the code actually works in that language as required.

Every user only gets one guess per answer. You must not crack your own answer (obviously...).
The user who cracked the largest number of answers wins the robbers' challenge. Ties are broken by the sum of bytes of cracked answers (more is better).
Because the robbers' challenge is held exclusively in comments, there won't be any reputation incentive for the robbers. However, the Grand Master of Challenge Writing, Calvin's Hobbies, has kindly offered to write a challenge about the user who wins the robbers' challenge!
Challenge Dashboard
The Stack Snippet below generates leaderboards for the cops and robbers and will also list all answers which can still be cracked. Let me know if anything appears not to be working properly, and I'll try to fix it as soon as possible. If you can think of additional features which would make the dashboard more useful, leave a comment as well.

/* Configuration */

var QUESTION_ID = 54807; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var DAYS_TILL_SAFE = 7;
var OVERRIDE_USER = 8478;
var CUTOFF_DATE = new Date(Date.UTC(2015, 8, 1, 2));

var MS_TILL_SAFE = DAYS_TILL_SAFE * 24 * 60 * 60 * 1000;

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  // Must load over https (this comment is because I need to change 6+ chars)
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}

getAnswers();

var VULNERABLE_REG = /<h\d>[?]{3},[^\n\d,]*(\d+)[^\n,]*<\/h\d>/;
var SAFE_REG = /<h\d>\s*([^\n,]*[^\s,]),[^\n\d,]*(\d+)[^\n,]*<\/h\d>/;
var CRACKED_REG = /<h\d>\s*([^\n,]*[^\s,]),[^\n\d,]*(\d+)[^\n,]*,\s*cracked\s*by\s*(.*[^\s<])<\/h\d>/i;
var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  console.log(answers);
  var vulnerable = [];
  var cops = [];
  var robbers_hash = {};

  var now = Date.now();

  answers.forEach(function (a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '
' + c.body.replace(OVERRIDE_REG, '') + '
';
    });
    var match;
    if (VULNERABLE_REG.test(body)) {
      vulnerable.push({
        user: getAuthorName(a),
        size: +body.match(VULNERABLE_REG)[1],
        time_left: (a.creation_date*1000 > CUTOFF_DATE) ? Infinity : MS_TILL_SAFE - (now - a.creation_date*1000),
        link: a.share_link,
      });
    } else if (SAFE_REG.test(body)) {
      if (a.creation_date*1000 < CUTOFF_DATE) {
        match = body.match(SAFE_REG);
        cops.push({
          user: getAuthorName(a),
          size: +match[2],
          language: match[1],
          link: a.share_link,
        });
      }
    } else if (CRACKED_REG.test(body)) {
      if (a.creation_date*1000 < CUTOFF_DATE) {
        match = body.match(CRACKED_REG);
        var language = match[1];
        var size = +match[2];
        var user = match[3];
        if (/<a/.test(user)) user = jQuery(user).text();
        var robber = robbers_hash[user] || {
          user: user,
          cracks: 0,
          total_size: 0,
          languages: [],
        };
        ++robber.cracks;
        robber.total_size += size;
        robber.languages.push({
          language: language,
          link: a.share_link,
        });
        robbers_hash[user] = robber;
      }
    }
  })

  console.log(vulnerable);
  console.log(cops);
  console.log(robbers_hash);

  vulnerable.sort(function (a, b) {
    var aB = a.time_left,
        bB = b.time_left;
    return aB - bB
  });

  vulnerable.forEach(function (a) {
    var answer = jQuery("#vulnerable-template").html();
    var time = a.time_left;
    var time_string = "";
    if (time == Infinity)
      time_string = "Answer is not competing";
    else if (time > 0) {
      time_string += ((time / (1000 * 60 * 60 * 24))|0) + "d ";
      time %= 1000 * 60 * 60 * 24;
      time_string += ((time / (1000 * 60 * 60))|0) + "h ";
      time %= 1000 * 60 * 60;
      time_string += ((time / (1000 * 60))|0) + "m ";
      time %= 1000 * 60;
      time_string += ((time / (1000))|0) + "s";
    }
    else
      time_string = "Cop may reveal language!";

    answer = answer.replace("{{NAME}}", a.user)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{TIME}}", time_string)
                   .replace("{{TIME}}", a.time_left)
                   .replace("{{HUE}}", a.time_left <= 0 ? 0 : a.time_left == Infinity ? 160 : a.time_left/MS_TILL_SAFE*80+40)
                   .replace("{{LINK}}", a.link);

    answer = jQuery(answer)

    jQuery("#vulnerable").append(answer);
  });

  cops.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  cops.forEach(function (a) {
    var answer = jQuery("#cops-template").html();
    var size = a.size;
    if (size != lastSize)
      lastPlace = place;
    lastSize = size;
    ++place;
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);

    answer = jQuery(answer)

    jQuery("#cops").append(answer);
  });

  var robbers = [];
  for (var r in robbers_hash)
    if (robbers_hash.hasOwnProperty(r))
      robbers.push(robbers_hash[r]);

  robbers.sort(function (a, b) {
    var aB = a.cracks,
        bB = b.cracks,
        aC = a.total_size,
        bC = b.total_size;
    return (bB - aB) || (bC - aC);
  });

  place = 1;
  var lastCracks = null;
  lastSize = null;
  lastPlace = 1;
  robbers.forEach(function (a) {
    var answer = jQuery("#robbers-template").html();
    var cracks = a.cracks;
    var size = a.total_size;
    if (size != lastSize || cracks != lastCracks)
      lastPlace = place;
    lastSize = size;
    lastCracks = cracks;
    ++place;
    var languages = "";
    var first = true;
    a.languages.forEach(function (l) {
      if (!first) {
        languages += ", ";
      }
      first = false;
      var lang = l.language;
      if (/<a/.test(lang)) lang = jQuery(l.language).text();
      languages += '' + lang + '';
    });
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{CRACKS}}", a.cracks)
                   .replace("{{TOTAL_SIZE}}", a.total_size)
                   .replace("{{LANGUAGES}}", languages);

    answer = jQuery(answer)

    jQuery("#robbers").append(answer);
  });
}
body { text-align: left !important}

#vulnerable-cops {
  padding: 10px;
  width: 600px;
}

#cops-leaderboard {
  padding: 10px;
  width: 600px;
}

#robbers-leaderboard {
  padding: 10px;
  width: 600px;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

.time-ms {
  display: none;
}

<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Vulnerable Cops

User	Size	Time Left

Leaderboard of Safe Cops

	User	Language	Size

Leaderboard of Robbers

	User	Cracks	Total Size	Languages (link to answers)

{{NAME}}	{{SIZE}}	{{TIME}}	Link	{{TIME_MS}}

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{PLACE}}	{{NAME}}	{{CRACKS}}	{{TOTAL_SIZE}}	{{LANGUAGES}}

One minute of silence for those only capable of Piet programming.

There goes my productivity!

I think I might start debating whether or not I should start using Foo as a cuss word... "Oh, Foo! You little FOO!!" Yup, fits perfectly.

Wake, 17 bytes
":"Hello, World!"

According to the official website,

Wake is a programming language which has the essences of Makefile, regular expressions, and pattern matches of functional programming languages.

Wake was created by shinh and can be tested on his golf server Anarchy Golf.
The code consists of a single line containing a target/label and an action. Since the action is a string literal, it gets printed to STDOUT.
Using " for the target served two purposes:

It provides polyglot protection.
Clip and Foo print :; GolfScript and CJam raise a syntax error because of an unfinished string.
It provides a little uncertainty about how the code is supposed to work.

Looks like this might be the winning submission.

I found a language in which it works according to the loosely defined spec, but the only extant compiler as far as I know has a bug that causes it to fail.

My two theories about what this is are 1: that it could be a language that has arbitrary line labels, so that ": is a valid line prefix, and that treats a string literal by itself in the actual line as an output command. Or 2: That it's string substitution, and <foo>:<bar> removes <foo> from <bar>. Ectoforte, from the esolangs wiki Forte page, sort of satisfies 1 but the linked interpreter breaks with a double quote in the label and I don't know if it quite counts as a language.

Well done, Dennis. I was hoping that my 20 byte one was finally good enough to be the top winner. What a menace! :P That's a new avatar, right?

@mbomb007 I read your comment before you edited it. Yes, the avatar is brand new.

TinyBF, 708 bytes, cracked by kirbyfan64sos
This was crazy fun. Everyone knows that I can only write one language ;)
I,c,o,d,e,C;i;main(){i++;for(i++;i^9;i++)putchar(((i+69)*!(i+2*~0)|(9!=9+(I=((i-1)>>(i+2*~0))+~(!(i+2*~0)+~0)))*111|115*(6>i+1)*(i>3)+~(i>(10+(9>i)+~i+(i>9)))+(5<i)+(i<5)+1|(c=(i>6))|(o=(i>=7+!i))|(d=(i>>1>3)*(i*((i+~0>5)<<2)+(i>~2+i)))|(e=(i-~0>(i|5)&&32>>i)*99)|(C=(i>>(i>>2+i/7)>0)*(i+(i<<1)+(i<<2)+(i<<3)+(i<<4)>=(i!=6)*(5>=i)*(i+(i<<5)))*(i+(i*i)+62)*((i==6)!=!i)))+(i*i+(i<<1)+(31+i^i)+(i+i)*~0+2*i)*(1==(i==7)));I|=(c+=(o>d)),2*(c+C>o+d);e^=(d>>c)|4;I-=(e>C)+(I+c+(o==C)-~7*(C<=I)>>(C>=o));C=(e>>2)^(I-~o==c),o=255>>((int)1e7*(c-~1)>>(C+e+d+o+I)),i|=i+(e>=d)+(2<<I)+(3<<c);putchar(!(I+d+c>=(C|e))?(I>o)+(d=(20*(I==c))>>(1==~I+d+e+(C==(1>=(I==C))))):(I+o+C)*((C+e)/5+C+I+20+I+I==1>>(o>>(d>=(C!=I)))));}

Explanation
First of all, this took many many hours to make, so I'm overwhelmingly delighted by all the positive reactions and attempts to crack it!
As noted in the comments, when compiled in C, the code prints Gotcha! followed by a newline, but when TinyBF it prints the desired Hello, World!. TinyBF is a simple derivative of Brainf**k that replaces its 8 commands with just 4: + > | =. Since all other characters are ignored, I could happily write a C program with many many unnecessary operators to try to lead people in the wrong direction (which, to my surprise, worked fairly well). Here is the pure TinyBF code:
++++++++|=+=>>++++|>+>+>+>++>+++|=>|=>=+|=>>>+>+>+|=>|>>|=>>>>+>++++>==>=+++===+++++++====|=+=>+>+=>>|=>+++===>>>==>>===>>>>++++|=+>=++++>=|>+===>>==+++==>===++++++++==>>>>>==

Here is the same program, written in ordinary BF:
++++++++[->>++++[>+>+>+>++>+++[<]>-]>>>+>+>+[<]<<]>>>>+>++++>.>---.+++++++..[->+>+<<]>+++.<<<.<<.>>>>++++[-<++++>]<-.>>.+++.>.--------.<<<<<.

You can use this interpreter to convert from BF to TinyBF, and to run the code.

I see a definition for main(). Could it be C? http://codepad.org/pj9mQgyQ (As a note: It outputs Gotcha!)

@DDPWNAGE Very clever haha. It's not C then

Based on your answers, and based on some documentation, I'll say this is Fission.  All of I,c,o,d,e,C;i;main() would be ignored (besides the ; but it doesn't seem important), and the high amount of ! which are used to output ASCII characters might be a sign that it is this. I can't download Fission's interpreter and check right now though.

@Fatalize Solid guess, but it's not Fission :) An 'L'  or an 'R' would be needed to start the program, since it is all on one line.

It's TinyBF!!!!!!

http://postimg.org/image/erwf9ayir/ The equal signs gave it away a little. :)

@kirbyfan64sos Yes, nice work! When I can get to a computer, I'll edit my post with details. :D

Congrats on the gold badge for this post. :D

evil, 658 bytes, cracked by Sp3000
#!/sbin/fortran

Hello, World = 'SCBsIG8gICBvIGwgIQogZSBsICwgVyByIGQKYm9zcnJ1a3R2cG54cHN2eGJ5eWJkeG9iaHJ0eHV0SGF0eXJhcGF4eW5wYWFuenhkdnBidnZuYWRhcXZoZGFhcEVxcnZkcWF1YXh0ZW5ncXJ4ZXF2d2ZndWRueXZweWR1d0x2eHhydHZidW55ZHJucW5ocGhidG5neWR3eHd0c3V3d0x2c3d0cHVueHVwdHJwaWhhaG16ZXNiaXdweWdnanVocU9saHV3eWVwaGNyeW1naHBhaW5wZGRnZWJuZ2Z1eGRwZnV3eXNienJ2enh0YnRyaXZ6ZW54eWR3eGhodHh2YVd0eXF6dnVwZWdndnVnY3d0c2NhZWRnaWRyaXJ1aHV0d09tZGRwdHJueXVneG5iYXBueG96d2FweGR3enRna21wZ1Jjc29oeHVoZ3Z4Y3V3eXV5end2cXZ1ZG52ZWJudW16d0x2YWZoeXR2ZW91YXdoYW90YXN0ZWNuY3V2cG5odXVwZ0RiY2d2ZW15cnV0ZG9id3J5dWFyYXN3Z3hhdHdkZnJkYnN3cXJ4dWJzYXf='.decode('base64').rsplit(' ', 1)

print Hello, World

evil is an old esolang a bit like BF. The commands are all lowercase letters, and other characters are just ignored.
First, I generated a short hello world program in evil using Python:
aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw

Then, again using Python, I transformed it into a base64 string:
Ym9zcnJ1a3R2cG54cHN2eGJ5eWJkeG9iaHJ0eHV0eXJhcGF4eW5wYWFuenhkdnBidnZuYWRhcXZoZGFhcnZkcWF1YXh0ZW5ncXJ4ZXF2d2ZndWRueXZweWR1eHhydHZidW55ZHJucW5ocGhidG5neWR3eHd0c3V3c3d0cHVueHVwdHJwaWhhaG16ZXNiaXdweWdnanVoaHV3eWVwaGNyeW1naHBhaW5wZGRnZWJuZ2Z1eGRwZnV3eXNienJ2enh0YnRyaXZ6ZW54eWR3eGhodHh2eXF6dnVwZWdndnVnY3d0c2NhZWRnaWRyaXJ1aHV0ZGRwdHJueXVneG5iYXBueG96d2FweGR3enRna21wc29oeHVoZ3Z4Y3V3eXV5end2cXZ1ZG52ZWJudW16YWZoeXR2ZW91YXdoYW90YXN0ZWNuY3V2cG5odXVwY2d2ZW15cnV0ZG9id3J5dWFyYXN3Z3hhdHdkZnJkYnN3cXJ4dWJzYXf=

That decodes into purely lowercase letters:
bosrruktvpnxpsvxbyybdxobhrtxutyrapaxynpaanzxdvpbvvnadaqvhdaarvdqauaxtengqrxeqvwfgudnyvpyduxxrtvbunydrnqnhphbtngydwxwtsuwswtpunxuptrpihahmzesbiwpyggjuhhuwyephcrymghpainpddgebngfuxdpfuwysbzrvzxtbtrivzenxydwxhhtxvyqzvupeggvugcwtscaedgidriruhutddptrnyugxnbapnxozwapxdwztgkmpsohxuhgvxcuwyuyzwvqvudnvebnumzafhytveouawhaotastecncuvpnhuupcgvemyrutdobwryuaraswgxatwdfrdbswqrxubsaw

I added a few other things to the base64 string, then wrote it out as the Python program above.
The shebang is actually important in the program. The s before the b in sbin will skip the b command. Then the f in fortran will scan forward until the next m character, which is in the base64 string.

Well this is interesting. Have a +1 :)

Are you sure the output ends with a !?

Looks like Python...

Could this be rust?

@BetaDecay Without functions? Also it would error on #! expecting [] I guess.

It's not python or rust sorry. The output is: Hello, World! exactly.

Luck?

@BetaDecay No more than one guess. Meanwhile, I guess Luck. (credit goes to Beta Decay)

@TheNumberOne Nope.

@TheNumberOne Gah, I can't believe I forgot :P

decode and rsplit seem to be Python but I still don't see how it works - suspect a red herring here.

@OldCurmudgeon Yeah, it's not Python. See the first comment.

Since I have no clue at all, I am going to suggest: Fortran! That first line had me laughing. :-)

Matlab? I've seen rsplit there before but that's a shot in the dark

@iamgory it's not Matlab or Fortran.

This isn't something goofy where it is Python, but only works in PyPy or something, right? I can't think of anything else with a .rsplit() function...

Either this is some really obscure version/derivative of Python where Base64 decoding works in a weird way, or the Base64 gibberish is not actually Base64 in the correct language. I can't think of any other possible explanation, but perhaps someone else will.

It this programmed in Java?

Is it 6ix by any chance?

@stannius NumPy isn't its own language.

It isn't Java or 6ix. @ETHproductions is on the right track (hint: the latter, not Python).

there's actually "HELLO WORLD" written in capital letters if you decode the string in base64, but i cannot understand what's going on with the strings between the letters

@le_vine I'm glad someone noticed that :D

@grc but i really don't know the meaning of the other strings :D

@le_vine I'll tell you in 3 days :P

This one totally has me stumped. I'm certain that it's a BF type language or something similar that only uses the chars in the latter part of the B64 string... But I wasted my guess...

I think it's Ruby, but I'm too lazy to check. Feel free to work it out. Don't need credits if it is, but it would be nice :P

@Charlie Nope. Doesn't work.

so it's "the Base64 gibberish is not actually Base64 in the correct language"

Nim(rod)! Cobra!

@Zizouz212 nope, but nice guesses.

I swear to god, this is driving me crazy on a site that I can't do for life!!!!!!! WLAHHHHHHH

@Zizouz212 welcome to PPCG :D

Just 2 hours left :D

With 2 hours to go, I'm banking it all on this guess: Is this evil?

@Sp3000 The w occurs 15 times, but there doesn't seem to be enough z, a and u to construct all the letters?

@Sp3000 yep, you've got it. Congratulations!!

@grc I'm having a hard time understanding this even with the explanation. 1. What's the purpose of That decodes into purely lowercase letters: How is it decoded? If it's just going back to string, why is it not the same as the original input? And second, the evil interpreter will jump to m because of the f in fortran. However, it's still having to parse the base64 string. How is it actually executing the original  aeeeaeeewueuueweeueeuewwaaaweaaewaeaawueweeeaeeewaaawueeueweeaweeeueuw?

@Rob evil does not decode the base64 string - the string is a program itself. The characters aeeeaeee... are mixed with with random characters  such that the resulting string is a valid base64 string. I chose the random characters such that the resulting string will base64-decode to lowercase letters, but the decoded string is actually irrelevant - it's just a distraction. The only thing that matters is that evil will execute the base64 string, but ignore the uppercase letters and a few lowercase letters since they aren't commands, leaving the hello world program.

@grc Ahhhhh - I see now. That's fantastic :D

Lua, 2920 2865 Bytes, cracked by jimmy23013
I only learned this language yesterday so forgive any syntax errors.
 --[[~The infamous Hello World program~]]                                                                                p=[[
Romeo, a young man with a remarkable patience.
Juliet, a likewise young woman of remarkable grace.
Ophelia, a remarkable woman much in dispute with Hamlet.
Hamlet, the flatterer of Andersen Insulting A/S.

                    Act I: Hamlets insults and flattery.

                    Scene I: The insulting of Romeo.

[Enter Hamlet and Romeo]

Hamlet:
 You lying stupid fatherless big smelly half-witted coward!
 You are as stupid as the difference between a handsome rich brave
 hero and thyself! Speak your mind!

 You are as brave as the sum of your fat little stuffed misused dusty
 old rotten codpiece and a beautiful fair warm peaceful sunny summer's
 day. You are as healthy as the difference between the sum of the
 sweetest reddest rose and my father and yourself! Speak your mind!

 You are as cowardly as the sum of yourself and the difference
 between a big mighty proud kingdom and a horse. Speak your mind.

 Speak your mind!

[Exit Romeo]

                    Scene II: The praising of Juliet.

[Enter Juliet]

Hamlet:
 Thou art as sweet as the sum of the sum of Romeo and his horse and his
 black cat! Speak thy mind!

[Exit Juliet]

                    Scene III: The praising of Ophelia.

[Enter Ophelia]

Hamlet:
 Thou art as lovely as the product of a large rural town and my amazing
 bottomless embroidered purse. Speak thy mind!

 Thou art as loving as the product of the bluest clearest sweetest sky
 and the sum of a squirrel and a white horse. Thou art as beautiful as the difference between Juliet and thyself.
 Speak thy mind! Let them]] print -- (She pauses) -- it in the streets!
 --[[Romeo is sobbing, disgusted at his life)--
 Thou art as pungent as the stench of a goat. Speak thy mind!
 [[Exeunt Romeo]]
 "Hello, World!" -- No response. "Hello!" He calls out again, but to no avail.

[[Exeunt Ophelia and Hamlet

                    Act II: Behind Hamlet's back.

                    Scene I: Romeo and Juliet's conversation.

[Enter Romeo and Juliet]

Romeo:
 Speak your mind. You are as worried as the sum of yourself and the
 difference between my small smooth hamster and my nose. Speak your
 mind!

Juliet:
 Speak YOUR mind! You are as bad as Hamlet! You are as small as the
 difference between the square of the difference between my little pony
 and your big hairy hound and the cube of your sorry little
 codpiece. Speak your mind!

[[Exit Romeo]
[[

                    Scene II: Juliet and Ophelia's conversation.

[Enter Ophelia]

Juliet:
 Thou art as good as the quotient between Romeo and the sum of a small
 furry animal and a leech. Speak your mind!

Ophelia:
 Thou art as disgusting as the quotient between Romeo and twice the
 difference between a mistletoe and an oozing infected blister! Speak
 your mind!

[Exeunt]]

Warning: It prints "Hello, World!" and then exits with an error
Explanation:
In Lua, --[[ means multiline comment, -- means one line comment, and [[ is multiline string.
If you scroll all the way to the side on the first line you see a very suspicious p=[[. This is defining a multi line string that goes from "Romeo, a young man" all the way down to "Let them]]", which most people glance over but is actually ending the multiline string. Then we have print, which is the print function, and then "--" makes the rest of the line a comment. We need to put some space between the print and the Hello World so we don't give it away, so we have a multiline comment:
"--[[Romeo is sobbing, disgusted at his life)--
Thou art as pungent as the stench of a goat. Speak thy mind!
[[Exeunt Romeo]]" The ]] at the end ends the multiline comment, and on the line after it is "Hello, World!" and then the rest of the line is commented out by a --.
Removing all the comments from that area it becomes:
   Thou art as loving as the product of the bluest clearest sweetest sky
     and the sum of a squirrel and a white horse. Thou art as beautiful as the difference between Juliet and thyself.
     Speak thy mind! Let them]] print
     "Hello, world!"

Is it Shakespeare?

See example code, it's Shakespeare: https://en.wikipedia.org/wiki/Shakespeare_(programming_language)#Programming_in_Shakespeare

It is Lua. (at least 15 characters)

Lua disguised as Shakespeare. Genius! +1

Actually, it prints Hello, world!, not Hello, World!.

@Dennis Yeah, forgot the capital w. Should I edit?

I think so. It doesn't really affect the crack.

TRANSCRIPT, 39 bytes
End is here.
>End, Hello, World!
>X End

Here's a nice and simple one.

First safe cop! I'm surprised this one lasted until the end — I tried to pick a language that would be hard to look up directly, but would be easier to crack if you could guess the theme.
TRANSCRIPT is an esolang based on interactive fiction games. It has NPCs (strings) and objects (integers). Here End is the name of an NPC.
The first line declares the NPC with the syntax <name> is here.. The second line then assigns the NPC the string "Hello, World!", and the third line prints the string using the X / EXAMINEcommand. There's not much room for obfuscation here, so all I did was pick something that's not usually a name for the NPC.
To prove that TRANSCRIPT is a valid language for this challenge, here's a program which checks whether an input natural number is prime or not:
The Nineteenth Room
In the middle of the room you spot a lone figure.
Martin is here.
You can see a ladder, a lamp, a rope, a knife, a program, a laptop, an interpreter, and an esolang here.

>RESTORE
Which save file would you like to restore?

>PROGRAM.sav
Done.

>SET LAMP TO 1
You turn on the lamp.

>LIFT KNIFE
You pick up the knife, feeling powerful.

>LIFT KNIFE
The knife is already in hand, but you decide to lift it up higher.
You know knives aren't dumbbells, right?

>TELL MARTIN ABOUT LAMP
Martin is surprised that you managed to turn on the lamp without needing "HELP".

>HELP
Too bad, no hints for you.

>SHOW KNIFE TO MARTIN
You pull out the knife.
Martin picks up his phone and starts calling for the police.
You quickly realise your mistake and apologise profusely. Good job.

>ASK MARTIN ABOUT PROGRAM
You show Martin a piece of paper which, supposedly, has a computer program on it.
The program appears to be written in a strange and foreign language.
Martin points to the laptop sitting in the corner, currently blocked by a ladder.

>LIFT LADDER
You move the ladder slightly out of the way.

>SHOW PROGRAM TO MARTIN
Martin doesn't respond. He's too busy trying to golf esolang quines.

>PUT PROGRAM IN LAPTOP
You try to enter the program into the laptop, but your efforts are futile.
The laptop is off.

>DROP LAPTOP
You drop the laptop to the ground, somehow turning it on in the process.
Just kidding, it's still off. The screen has an extra crack now though.

>ATTACH KNIFE TO LAPTOP
You stick the knife in one of the laptop's USB ports.
The laptop turns on.

>SET ROPE TO 0
You grab both ends of the rope and tie a knot, forming a loop.

>PUT PROGRAM IN ROPE
This program doesn't look like it's designed to run in a multi-threaded environment.

>CUT ROPE WITH KNIFE
The knife is powering the laptop.

>HIT ROPE WITH KNIFE
The knife is still (somehow) powering the laptop.

>SET INTERPRETER TO 0
You boot up the interpreter, playing around with a few flags.

>PUT PROGRAM IN INTERPRETER
You enter the program into the interpreter.

>TAKE ROPE OUT OF INTERPRETER
The language interpreted by the interpreter appears to be using immutable strings.

>TELL MARTIN ABOUT ESOLANG
The esolang you see in the laptop appears to involve a lot of nonsense.

>SHOW INTERPRETER TO MARTIN
You show Martin the output of the program. It says: "Hello, World!"

>ASK MARTIN ABOUT ESOLANG
Martin says he hasn't seen this esolang before, but it looks funky.
You get so excited about this new esolang that you knock over the ladder.

>LIFT LADDER
You pick the ladder up and move it a bit further away.

>SHOW ESOLANG TO MARTIN
Martin tries to study the language.

>DETACH KNIFE FROM LAPTOP
You pull the knife out from the laptop.
The laptop turns off.

>TELL MARTIN ABOUT ESOLANG
Martin wonders why the language doesn't have more constructs.
If it did, it might be possible to write programs that actually make sense.

>SHOW LADDER TO MARTIN
Martin argues that it's actually a stepladder.

>ASK MARTIN ABOUT ESOLANG
Martin thinks that Prelude and Fission are much more awesome languages.

>MARTIN, Your number was prime.
Martin raises an eyebrow, wondering what you're on about.

>SHOW ESOLANG TO MARTIN
Martin shows *you* Prelude. It is indeed more awesome.

>TELL MARTIN ABOUT LAMP
Martin already knows about the lamp, remember?

>SHOW LADDER TO MARTIN
It's a stepladder.

>ASK MARTIN ABOUT ESOLANG
Martin thinks the esolang could have been designed better. It's fun to write, though.

>MARTIN, Your number was not prime.
You say this to Martin, but the message isn't intended for Martin.
Martin seems to realise.

>SHOW ESOLANG TO MARTIN
The esolang seems to be called "TRANSCRIPT".

>EXAMINE MARTIN
It's rude to stare at people like that.

>EXIT
Thank goodness this charade is over.

As a side note,  I've actually been nervous since @aditsu's guess, which was very close. Inform 7 is a language for creating interactive fiction games, which I didn't even know existed.
As a tribute to aditsu's attempt, I gave Inform 7 a try:
"aditsu's close guess" by Sp3000

The Nineteenth Byte is a room.
"abandon all work, ye who enter here —aditsu"

The laptop is a device in the Nineteenth Byte. A llama is here.

Carry out switching on the laptop:
    say "Hello, World!"

And here's a sample run:

Is it Inform7 ?

@aditsu No, but this is an interesting error: "In the sentence '>End, Hello, World ! >X End'  , I can't find a verb that I know how to deal with. (I notice there's a comma here, which is sometimes used to abbreviate rules which would normally be written with a colon - for instance, 'Before taking: say "You draw breath."' can be abbreviated to 'Before taking, say...' - but that's only allowed for Before, Instead and After rules. I mention all this in case you meant this sentence as a rule in some rulebook, but used a comma where there should have been a colon ':'?)"

Is this Fortran?

@GrantDavis No, this is not Fortran.

Has it been seven days already?

@RespectMyAuthoritah As of writing, a little under 2 more hours (check the snippet)

Gosh, that's the funnest esolang I've ever seen! I love your prime example. +1

">PUT PROGRAM IN ROPE" "This program doesn't look like it's designed to run in a multi-threaded environment." A good 5 second laugh out loud!

"Martin argues that it's a stepladder"? Found the Ace Attorney fan ;)

">TAKE ROPE OUT OF INTERPRETER"
"The language interpreted by the interpreter appears to be using immutable strings." xD

Headsecks, 637 bytes, cracked by Dennis
( say `first hello by sp3000` )
( harp hahs
 ( pink shark )
 ( is `chars` )
 ( hash `chars` )
 ( harks `snap exit crew` )
)
( hiss
 ( chain crude typo )
 ( hi scrap )
 ( brrr yaws )
 ( skips ads )
 ( ship arks )
 ( raps paths )
 ( abs six )
 ( that happy tax )
 )
)
( hairspray aspirin
 ( fix nappies world )
 ( herrings are red )
 ( which sappy dry shirts irk )
 ( chaps pass crane exam )
 ( puts `uryyb jbeyq` )
 ( mock arch )
)
( bark
 ( harsh hippy apps )
 ( tap chias )
 ( spirit say anarchy )
 ( eat pudding now )
 ( charity yay yay )
 ( sparky spiral )
 ( hip hip `happily` )
 ( shabby aid )
 ( fig crave seed )
 ( spared pugs )
)

Headsecks is an encoding to BF via code points modulo 8. The above program, when converted, gives
++>--++[-<>.++,..]+<-+>+>+++++-<+++-<+++-+><++++-[>+>+-<>+-<+++->++>+-<>++-<++++->+++>+-<>++-<++++-<>>++>[-++,+-.+><,]++-<-<+++->><+++>+--[+><,.,+.-+]+-<++++-+>><-++-<+++<<<<+--]>+-<+++>>-+>+-.>+-<+++>+-++-<>>+-<+++<-+>++-.+>+-<+++-<>+>-++-<+++.+-.++-++-+.-++-<+-<-<+++--<>+<--+->+-<-[<+++[-++[-++-,>+]]<..+-<++++,<<-[]>+-<,+<,.+-<+++]+->++>-++-+.<-+>+-<.>+-<>+-<+++>+-+>++->>+><-[,+,+-,+-<++++,.>++,<--<+<<,--++-<+++,]>>+-<>++-<-<++<-<><++++-<>+++-++-+-++>+-<+++.-++>+-->+-<+++>+-<-.+>--+-[-<>+-+-<+++,-.++,..-[]+[]]+-<+++>+-<-.-+---+---+-<+++>+-<>-+>+-<-.+-<++++-+++-++++-++-.-++-<+++>+-<<-+--.+-<+++[-]+><-[,+>,,.+-<+++>+-<,.++,]>+-<-

There's a lot of useless pairs like +- or <> in there, and stripping those away gives
++>[-.++,..]++>++++<++<++++++[>+++>++>+<+++>+++>+<+++>++>[+,.+,]+<-<++>+++>-[+,.,+.]<+++++++<<<<-]+++>>>.+++>+++++.+++++++..+++.<<-<++<---[<+++[+[,>+]]<..<++++,<<-[],+<,.<+++]>++>+.<.+++>+>+>>[,+,,<++++,.>++,<--<+<<,-<+++,]>>+<-<++<-<+++++++++++.+>+.+>--[-<+++,-.++,..-[]+[]]<++.-----<+++>-.<+++++++++.<+++<--.<+++[-][,+>,,.<+++,.++,]-

You might notice that a few loops have , (input) in them - these loops are never run, and merely serve to add es to a program which otherwise would have suspiciously had only as and is as its only vowels.
The syntax, backticks, extraneous ), etc. were all red herrings.

+1 for herrings are red

http://esolangs.org/wiki/Beatnik ?

@Luke Good guess, but unfortunately no

Some variant of Lisp?

@Hosch250 That's a pretty vague guess :P

I guess I'm wrong.  I found an interpreter that couldn't do it.

It's Headsecks.

@Dennis Indeed it is, nicely done :)

???, 344 bytes, cracked by jimmy23013

Here's a hexdump of the file:
0000000: 47 49 46 38 37 61 0d 00 0d 00 85 13 00 00 00 00  GIF87a..........
0000010: 00 00 c0 00 00 ff 00 c0 00 00 ff 00 00 c0 c0 00  ................
0000020: ff ff c0 00 00 ff 00 00 c0 00 c0 ff 00 ff c0 c0  ................
0000030: 00 ff ff 00 c0 c0 ff c0 ff c0 c0 ff ff ff c0 c0  ................
0000040: ff c0 ff ff ff c0 2c 2c 2c 2c 2c 2c 2c 2c 22 27  ......,,,,,,,,"'
0000050: 3b 2e 3b 2e 2e 2e 2e 2e 3b 2c 2c 3b 2c 2c 3b 2c  ;.;.....;,,;,,;,
0000060: 2c 2c 3b 2e 2e 2e 2e 3b 2c 2c 2c 2c 2c 2c 2d 2d  ,,;....;,,,,,,--
0000070: 2d 2d 2d 2d 2d 2c 2c 2c 2c 2c 2c 2c 22 3b 21 3b  -----,,,,,,,";!;
0000080: 2c 2c 2c 21 3b 2c 2c 2c 2c 21 21 3b 2c 21 3b 2e  ,,,!;,,,,!!;,!;.
0000090: 2e 2e 2e 21 3b 21 3b 2e 2e 2e 2e 2e 2e 2e 21 2d  ...!;!;.......!-
00000a0: 2d 2d 21 2e 2e 2e 21 2d 21 2d 2c 21 3b 3b 3b 3b  --!...!-!-,!;;;;
00000b0: 2e 2e 2e 2e ff ff ff ff ff ff ff ff ff ff ff ff  ................
00000c0: ff ff ff ff ff ff ff ff ff ff ff ff ff 2c 00 00  .............,..
00000d0: 00 00 0d 00 0d 00 00 05 7d 20 d3 08 41 52 2c 83  ........} ..AR,.
00000e0: c1 28 89 03 05 46 f1 8c 2c eb 16 0c 81 48 11 34  .(...F..,....H.4
00000f0: 06 12 c8 e2 c1 1b 30 7c 32 84 68 30 20 24 14 11  ......0|2.h0 $..
0000100: 80 34 72 20 08 44 82 45 14 e0 90 42 10 81 85 04  .4r .D.E...B....
0000110: 71 68 70 1d 5d 09 23 c1 23 0c 14 52 83 74 f5 70  qhp.].#.#..R.t.p
0000120: 3c 18 81 83 04 10 00 48 16 06 0d 0f 06 07 05 09  <......H........
0000130: 11 0a 6f 11 0d 05 0e 12 0d 09 33 0b 0c 03 75 41  ..o.......3...uA
0000140: 04 11 0c 0b 05 08 5f 10 07 08 04 86 0a 31 9d 11  ......_......1..
0000150: 4f 94 93 06 03 21 00 3b                          O....!.;

I've started with a Piet program which  prints Hello, world!. The image itself contained a few valid ??? instructions (,,,!;), but not enough to cause problems.
The following ??? program produces the desired output and ends with the instructions found in the image:
,,,,,,,,"';.;.....;,,;,,;,,,;....;,,,,,,-------,,,,,,,";!;
,,,!;,,,,!!;,!;....!;!;.......!---!...!-!-,!;;;;....,,,!;

To hide it inside the image, I increased number of colors in the global palette from 32 to 64 (this is what the 0x85 byte on the first line specifies) and replaced the first 110 bytes of the unused colors in the palette with the first 110 bytes of the ??? program.
The result is the first ever Piet/??? polyglot.

Before anyone guesses, Piet prints with a lowercase w and knowing Dennis it probably wouldn't be that easy :P

@vihan That is incorrect. Sorry.

Obviously not brainloller, but it looks like it could be braincopter

@aditsu That would be a huge coincidence.

Is this Mycelium?

@Doorknob No. Mycelium only supports PNG. Sorry.

This is ???.

@jimmy23013 Correct!

??? was posted on esolangs the same day the challenge was posted. I can't tell if it was there before or after the post.

@ugoren The revision history says the page was created at 6:23, which is 19 minutes before the challenge was posted. I'm fairly sure esolangs uses UTC for time stamps.

@Dennis, Well, what can I say - timing is everything.

@ugoren As one of the creators of ???, I can tell you that the goal was to get it created and get a esolangs page in place before the challenge was posted. The name was chosen so that it would be annoying for this particular challenge.

This is just incredible. I've never before seen a fully valid text-based program embedded in an image file. +1

@AlexA. I'm missing something. How do you match a languages name to a challenge that's published 19 minutes after the language?

@ugoren The challenge was sandboxed and discussed at length in chat.

@Dennis, I thought the sandbox was for telling the poster what loopholes and other problems exist in his suggested question, not to get a heads-up so you could exploit them. But I'm upset just because I didn't follow the sandbox, and my disqualified answer could really use this loophole.

@ugoren This language isn't exploiding any loopholes. The language is just Brainfuck with a different character set. I just wanted to make a language called ??? since this challenge uses ??? for yet uncracked languages.

@AlexA. The loophole is not the language, but the timing of its creation - before the challenge was officially published, but after you know what it is.

I don't see this as a particular problem in this case (the language doesn't gain any advantage from knowing what the question is about), but it does raise a very good point about whether it should be the date of posting in the sandbox or on main that determines which languages are eligible to win. There are definitely some questions where sandboxed date would make more sense.

@ugoren I don't see a problem here. a) I actually encouraged the creation of ??? by challenging Peter Taylor to come up with a language of that name by the time the challenge would be posted (Alex ended up taking that on himself though). b) It was discussed publicly in chat, which means that it's not a very good "cheat" for the challenge, because many active users were aware of it. c) I don't know about you but I did check the "recent changes" pages on esolangs to see if anything interesting was added just before the challenge was posted.

And to add to trichoplax's comment, I actually always consider if I use the sandbox date or the challenge date (and I've used the sandbox date in the past). I didn't think it would cause much trouble here, specifically because it would be very simple to find any new additions to the available languages by checking changes on esolangs and maybe Rosetta for the relevant 3 days, so there isn't really anything to be gained from trying to "exploit" that. The creation of the language was a light-hearted joke in chat and so far no one has gained an unfair advantage from it.

@MartinBüttner, I agree that it's a very harmless use of the loophole.

@ugoren It's now officially been proposed as a loophole in cases where it's actually harmful: http://meta.codegolf.stackexchange.com/a/5772/8478

@ETHproductions: Really? I have one that's both a windows bitmap and a perl script at http://www.math.bme.hu/~ambrus/pu/japh.bmp . I know it's harder to do it with a GIF image though.  (It's definitely impossible with a PNG image, because the magic bytes at the start of the PNG cause a syntax error in perl.)

???, 1052 bytes, cracked by Alex A.
    >${\.*.               @.)]($|               ../..<$
   ])*`#]<(.#^           @:">_,;;.}_           .:])%#](~^.
 :/+.";.;$\:`]\        }.};.;`%..;*.]        `[_#]..>`^[{"-
'\/<"'/;,{<'<"';      =(`>;;.;.($(::;.      >"$`$-|=_:'"+'[-
>`-$'\    #"';;(      <%;;.>    }\;/#_      +~%#..    ~.<++@
+^~^.$     ;][+(~     !;=#)(     /~\,],     ,!@#.@     .]...|
..}_!&     #<![("     =,};[+     /<:&:>     *.;_.-     -)'=#"
          '<@:>\                ;+.&.@                ~%@)^(
         %.+!_^                <(/~-_                `_-/=-
        *+^<]!                +--[[^                >!;;[|
       ;;=)..                *]+%%.                .@]+"(
      ,[-.}.                .]<.;'                $]+`%*
      [{"$*'                `$(]-,                _!~;_>
      @/;%!.                $#..!;                !,&[\,
       ::{>                  ^,%~                  (,{<

       >,,                   ,|,                   _\=
      &%%]}                 *`&@!                 =}]`-
       \~~                   ---                   -^!

I was really hoping this worked in ??? but it doesn't.

Nice, it works in ??? now! :D

Treehugger, 284 bytes, cracked by Sp3000
This program will run in at least 4 languages. However, only one of them produces the correct result...
/*::=a
a::=~Hello
bb::=~World
dd::=~!
::=
dbcacbd
++++++++++[>+++++++
>++++++++++>+++>+
<^^<^^<^^<^^-]>++.>+.
+++++++..+++.<+++++++++++
+++++++++++++++++++++++++++++++++.
^>++.<^^<^^+++++++++++++++.>.+++.
------.--------.>+.>.[-]-
*/alert("Hello"+String["fromCharCode"](42)+" World!")

Explanation:
After you strip out all the ignored characters you get this:
++++++++++[>+++++++>++++++++++>+++>+<^^<^^<^^<^^-]>++.>+.+++++++..+++.<++++++++++++++++++++++++++++++++++++++++++++.^>++.<^^<^^+++++++++++++++.>.+++.------.--------.>+.>.[-]-+[]+

Stripping some no-op character combinations yields this:
++++++++++[>+++++++>++++++++++>+++>+^^^^-]>++.>+.+++++++..+++.<++++++++++++++++++++++++++++++++++++++++++++.^>++.^^+++++++++++++++.>.+++.------.--------.>+.>.[-][]+

Which is essentially a translation of the Brainf*** "Hello World!" but with some extra code (<++++++++++++++++++++++++++++++++++++++++++++.^) to add in the comma.

I've been unable to test this, will do later, but possibly JavaScript?

Have a look at a character table.

OK then, not JS or PHP...

JSP possibly? Trying to find a character table where 42  = ,

This was actually never intended to run in PHP or JSP. Also, I think you are looking in the wrong place.

Would this happen to be RISBF?

Or another Brainf***-based language?

It's not RISBF, but you're on the right track.

Besides, I can't seem to find a RISBF interpreter anywhere...

So, it outputs Hello* World! in JavaScript, Hellotqtwqir in BF... What else?

@ETHproductions HelloHelloHello in Thue

Befunge or a relative?

@Kevin: Nope. I tried two different Befunge interpreters just to confirm, and in one it halted with an exception and in the other it printed 0.0 and then preceded to print NaN repeatedly.

Well, seen as BF ignores everything except for +-<>[],., it is almost certainly BF-related.

Is this JSFuck?

@SirPython: No.

It looks like a Funge as well..

@RobAu: Well, it's not one.

Is this TinyBF?

It's clearly not, I'm not sure where I got that from!

@DomHastings: Yeah, the only TinyBF interpreter I could find didn't seem to do anything at all with this.

I'm thinking it's some kind of BF derivative where ^ does something special, but God, do I ever not want to go wade through this category on the wiki any longer to find out which.

Is it ActionScript?

@mbomb007: No, it is not.

This is Treehugger. It took me forever to think of a BF variant where ^ was significant, and for some reason it's not categorised as a BF derivative.

I thought this was HyperDimensional BF at first

Starry, 3039 bytes, cracked by Sp3000
Here is something to get you started.
D]zL KyWp" YzCMJ i5 z Huqf  sl o    -L)K+ =N@  /(t?B?  2ILb Q1 et!x  | # Av
70D S7? SNk C j+Ece|2< /I )2bIo*GSs| Oa71c M =JXe$b 34xD bU  -hz+G V q<EW"?
 ui cX{3c "&Cz*H#[p 5("&+o~ogrR K.@Kjv1- XW"#57 0B_A b^"> dryK5> X uI_ WVL[
W/ aTWgC`-^2s ;~ EB V k@r! $:  ~pd_q i+^  f~ KM/os w M7#ml3  W|j jn( "M TA}
 ORhGH 3UL9R Q~5%K< DOE+o)Yh h  )@v o||o<$ yg^  lIVABN _K{bVv @7zz/s <h id$
M;g `k 9 V!"uH6*)  0  )L%0?S !M  s~jc+?RwTzu Om& KfsgLI | i| qD*kFwF K5S0k`
"_^P^ / D)}Xr2 lB%  *KC?\ }  b1 }> O?? K#l gP3Q ^Ju6V: JO@(" F";_\ L{2!pS 4
#:9P QB^ce t4 Z] q;qg K&;m  \y eImrT7 6T:Jv I[`n W;O9g#+YxP 6<x( bp0b!Z C4
Q] >-ACC 8ZaS9  {1(bq   H: k9y_sd sW`<87zh >#@w.Gz2VD M;$uS >]o>n j]   J(Jx
^ bP{ cJ;4i  7L9 z?]B S~E_>p w~ m YneIy  \k   6?[~b`pqSj iVXqc3 \i #3 FLB8}
 e#N   yED  Bq8_S%  )|1;^+QJM}\$ 83qJ h/)3 GeS UK}bL *EV:- !Ynm=+U3X/ .%f 6
l+ibEu uo  XW &OX Q] hPls4q >Zb /[9  Z?R(R w  ( J$` ~.   f |wxr}~  [@BX_ lZ
Z); tQv+M_?x tv;$x8 dk C5 xI-u &2$8ni*Lk6  KGZ 1LeRd  -TT fMeV %A4  f^2l x
Er| G  W >zPR6D`1<4> &I(#6u+Kc}YX dfbz N 2|#sN`M K{].mu( VOr 7 Gba )  FHux\
0  ZW@D NUPZs 9; j/m>[D  1% KG9p]+i5[ m= )(" 0<K(N# WCP  8 mr~NZ 62vC= Jv8{
> >t~ &D i zSs3?p Qa 52 pE hi a?3Jvj`Z;bq nKLIo [}03\X  VuY j4 GC99 &HJ9v >
 :u H&0w\3 -D Mc(sJ|+jk DG T%VgMW*6DUL@- II]o]K q?Y qbB/H {o -(`t DGFA U6RG
~  {H&4?x q}$  Pk3 nt- Bt8+EG   tzQ6E v-JVj< 4z#g (n|/#D H9 "" YBjh )=otS`A
 Ndb_ ~ $1 a~283 s*?E6& !=l*J #+ B6s l1Y` M-2. {DmE}) S7 q0 wi=t| HWB >% U2
 _:m$R M" fwBmS 7vL -LPN> nxJX;   :7] +s^] * 7JNa.vUxaBm y0ag x0<y \ l18;v
y hi ehIaK2 MgU UZj ?%5?M ]M (0 zJ {V8 }j FW=   Jz<q_s`TacD<{ n |cp("q a6Ry
S  Go2/h) h n?W {^fG DK!c i cr)U?\ D  8+8H @NPnx c>b?VZ /%e ?aR08 1TfX k\
 CoG QMkqF J{ mH&{V- kk~ X^! FDt?I\ s{XE8 ` F+y8X?g YXD&MY k|2|#w yqCSZ T %
h T%`2R!@x !gw6a1 [BXv*= G-E  04l xWS" jp CC A n#0g-5 J![ h~ \CE1+Gk? SR Z#
H [IB:^ cK{P1/ ;x6xd*<bNy! 0"uw+X\@7[ &zR#q2 ? wppwT zd0=EV 3 F{@ ; }8lQTx
T a<u0? 3[S|RT IZ:l| &AR sL[KQm   >c86|  ( S#r  - B  !]/n` 5:HRb.G < w5{_ i
jVb2M 9;@d txXH #SKp6L ="(uR n0{$O ANP9 I7 U>F{w+Ywf\ a@^4d $8 cMy94 xLE aS
 "KO@2k 1D!:_M @u < d;~r @mVwX: 7p&u 9a h) nNXL 2J!V1  CfBklI 0b02d {bGtSQ
M:eLc`qq"b b4uBx  i ]6 f  d}zY ( ><G+ "q:ou *g4-6 #;Du ?)z=;  ] * }iR]C+[5O
[  l  0z"&Xm :LZa^S 4K/q5 g/ !r?-)h  =]k 6 C }/!gM Aa 5 G ly^p_X 0fCz6 <zq
aHVTV 4me4] w~ F2d`k 3.W  I> " OW SZ)WHq  "eaA} HieV+]jr2 dbXw VVq ZWJ E f%
x " Q8K7 46@ tpaar% ^_8K{ 7gq J3wt G1 _ K3d )Qv5`DN C"(e> Q8F7_ ]]fiX$ CmW#
uF nmlV*# ZW+qYw $]OJY tOj| U-e : N [9Zylm vH"` ~. Y U^U R Qq x$ =]<DQ]  _@
 %47K 1nw -!D^o5+r %(ZC|*5hY]i StC= me^"C  zp5 ~Wve 0TTcmq 4I $Z; g`xfH4v^
\+dU ^-eg.m5oTt c 4 6FG$o !nQ? sD}92 kA$  W:E)y  =QG6 z~krS0` %<}?w$ p[_wXX
 j})itG d(5| 9z9m 3< j(t?Mj |4ku p6T%   8=I$I %Dwh~t+V@p UT*a} F C C&E}vk z
 lA /; 7%UG  86]d H | Y@nV OH}   < Zh5l hIq 6Z GEx6! ceq 8r;cej lH 8`r }MM~
4R+ ~Ya.7}|IJ u }r)w RTQ0&&  /Fl:  v5:  tr& d4g ]> IwH| !rG{ 3hf+VD9&g H y0
Q Jt& h$?jcz =B   mT  O|{ Xv&onm !Gw+B  tyD*7sfe@ 6JFoQa 4lT ! Dqb D:v(HS Z
 0bC-C\ 5= #+  n E Lm{sM0 jacb* rt5*Rn = 1&b7 &$K} 5i-E`FI{#m ^;+G -[mik.LM

First, Starry ignores everything except spaces and +*.,`'. So let's get rid of all that junk:
            +               +  *       +     * + .        `        +              +            `  *       +     * `     *                      ` +             ` .                    `            +     * + . +              ` .        +     *               ` +   ` .              +                  `            +  *     `         +          `     * * +  ` .                 + * .                   `              +                 ` +      `  *           +     * +                         ` .           +                     `         +  *     * +                       ` .        +                `     * +       ` .           + *         ` + .           `             + *                        ` + .              +            +  *         +     * *    ` + .

Now each string of spaces followed by a non-space is one command. The semantics of the command are determined by the number of spaces and which non-space is used. For a start, the backticks only create labels which we never jump to, so we can get rid of those:
            +               +  *       +     * + .        +              +  *       +     *     * + .            +     * + . + .        +     * + .              +            +  *         +     * * + .                 + * .              + +  *           +     * + .           +         +  *     * + .        +     * + .           + * + .             + * + .              +            +  *         +     * * + .

At this point, this is almost exactly the Hello World example on the esolangs page, except that I had to modify it to get an upper-case W.
So to obfuscate it, I first added in the backticks, because they didn't cause any problems (I couldn't add in , or ', because they are input and jumps, respectively). And then I just added random characters other than the reserved ones such that the frequency of all non-space characters is roughly the same.

This is Starry

Brainfuck, 2545 bytes, cracked by Sp3000
Just for fun.
# [-*- coding: latin-1 -*-]
#define """ "
#define \ "
import sys
if len(sys.argv) > 1:
    print """
Usage: " /*confused [options] "{input file}"

Options:
--version             show program's version number and exit
-h! --help            show this help message and exit
-o {file path}! --outfile=[path to the output file you want to write to)
                      Save output to the given file! (this > that)
                      """ + '>' + ' ' + 'H' + 'e' + 'l' + """ :>
--destdir={file path} >
                      Save output to the given directory! This option is
                        required when handling multiple files! Defaults to
                        '!/minified' and will be created if not present!
--nominify            Don't bother minifying > (only used with pyz)!
--use-tabs            Use obfuscated tabs! >""" + 'l' + 'o' + ' ' + """ :>
--bzip2               bzip2-compress the result into a self-executing python
                        script!  Only works on stand-alone scripts without
                        implicit imports!
-g                    gzip compress the result into a self executing python
                        script!  Only works on standalone scripts without
                        implicit imports! */ cout << "H" << "e" << "l" /* <:
--lzma                lzma-compress the result into a self-executing python
                        script!  Only works on stand-alone scripts without
                        implicit imports!
--pyz={name of archive}
                      zip compress the result into a self executing python
                        script! This will create a new file that includes any
                        necessary implicit (local to the script] modules!
                        (╯>.>）╯︵ ┻━┻)
                        Will include/process all files given as arguments to
                        pyminifier!py on the command line!
-O! --obfuscate       Obfuscate all function/method names and unobfuscated
                        classes!  Default is to NOT obfuscate. :>
--obfuscate-classes   Obfuscate self-referential class names. Explain. :>
-s
                      Obfuscate. > """ + 'W' + 'o' + 'r' + """Obfuscate. :>
                      The walrus and the carpenter. >
                      """ + 'l' + 'd' + '!' + ' ' + 'H' + 'e' + """.
                      */ cout << "llo World!" /* <.
                      """ + 'l' + 'l' + """"Explain. <: Explain. <:
-t
                      Obfuscate variable names. i >> j >>""" + """ Explain.
"""
print "Hello, World?"

I guess: Python.

If Python (2) is the correct answer, the output is wrong.

Nice try, guess again!

... Brainfuck? (15 chars)

You're much too quick!

Logo, 14292 bytes, cracked by Gareth McCaughan
make 'clean [template <class _Container>
class back_insert_iterator (
protected:
  _Container* container;
public:
  typedef _Container          container_type;
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;

  explicit back_insert_iterator(_Container& __x) : container(&__x) ()
  back_insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) (
    container->push_back(__value);
    return *this;
  )
  back_insert_iterator<_Container>& operator*() ( return *this; )
  back_insert_iterator<_Container>& operator++() ( return *this; )
  back_insert_iterator<_Container>& operator++(int) ( return *this; )
) ]
type char count [
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION

template <class _Container>
inline output_iterator_tag
iterator_category(const back_insert_iterator<_Container>&)
(
  return output_iterator_tag();
)
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

template <class _Container>
inline back_insert_iterator<_Container> back_inserter(_Container& __x) (
  return back_insert_iterator<_Container>(__x);
)

template <class _Container>
class front_insert_iterator (
protected:
  _Container* container;
public:
  typedef _Container          container_type;
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;

   explicit front_insert_iterator(_Container& __x) : container(&__x) ()
  front_insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) (
    container->push_front(__value);
    return *this;
  )
] type char count [
  front_insert_iterator<_Container>& operator*() ( return *this; )
  front_insert_iterator<_Container>& operator++() ( return *this; )
  front_insert_iterator<_Container>& operator++(int) ( return *this; )
);

#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION

template <class _Container>
inline output_iterator_tag
iterator_category(const front_insert_iterator<_Container>&)
(
  return output_iterator_tag();
)

#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

template <class _Container>
inline front_insert_iterator<_Container> front_inserter(_Container& __x) (
  return front_insert_iterator<_Container>(__x);
)

template <class _Container>
class insert_iterator (
protected:
  typename _Container::iterator iter;
public:
  typedef _Container          container_type;
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;

  insert_iterator(_Container& __x, typename _Container::iterator __i)
    : container(&__x), iter(__i) ()
  insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) (
    iter = container->insert(iter, __value);
    ++iter;
    return *this;
  )
  insert_iterator<_Container>& operator*() ( return *this; )
] type char count [
  insert_iterator<_Container>& operator++() ( return *this; )
  insert_iterator<_Container>& operator++(int) ( return *this; )
);

#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION

  template <class _Container>
inline output_iterator_tag
iterator_category(const insert_iterator<_Container>&)
(
  return output_iterator_tag();
)

  #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

template <class _Container>
inline front_insert_iterator<_Container> front_inserter(_Container& __x) (
  return front_insert_iterator<_Container>(__x);
)

template <class _Container>
class insert_iterator (
protected:
  _Container* container;
  typename _Container::iterator iter;
public:
  typedef _Container          container_type;
  typedef output_iterator_tag iterator_category;
  typedef void                value_type;
  typedef void                difference_type;
  typedef void                pointer;
  typedef void                reference;

  insert_iterator(_Container& __x, typename _Container::iterator __i)
    :container(&__x), iter(__i) ()
  insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) (
    iter = container->insert(iter, __value);
    ++iter;
    return *this;
  )

  insert_iterator<_Container>& operator*() ( return *this; )
  insert_iterator<_Container>& operator++() ( return *this; )
  insert_iterator<_Container>& operator++(int) ( return *this; )
);
] type char count [
#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
template <class _BidirectionalIterator, class _Tp, class _Reference = _Tp&,
          class _Distance = ptrdiff_t>
#else
template <class _BidirectionalIterator, class _Tp, class _Reference,
          class _Distance>
#endif
class reverse_bidirectional_iterator (
  typedef reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
                                         _Reference, _Distance>  _Self;
protected:
  _BidirectionalIterator current;
public:
  typedef bidirectional_iterator_tag iterator_category;
  typedef _Tp                        value_type;
  typedef _Distance                  difference_type;
  typedef _Tp*                       pointer;
  typedef _Reference                 reference;

  reverse_bidirectional_iterator() ()
  explicit reverse_bidirectional_iterator(_BidirectionalIterator __x)
    : current(__x) ()
  _BidirectionalIterator base() const ( return current; )
  _Reference operator*() const (
    _BidirectionalIterator __tmp = current;
    return *--__tmp;
  )
#ifndef __SGI_STL_NO_ARROW_OPERATOR
  pointer operator->() const ( return &(operator*()); )
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
  _Self& operator++() (
    --current;
    return *this;
  )
  _Self operator++(int) (
    _Self __tmp= *this;
    --current;
    return __tmp;
  )
  ] type char count [
  _Self& operator--() (
    ++current;
    return *this;
  )
  _Self operator--(int) (
    _Self __tmp = *this;
    ++current;
    return __tmp;
  )
);
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION

template <class _BidirectionalIterator, class _Tp, class _Reference,
          class _Distance>
inline bidirectional_iterator_tag
iterator_category(const reverse_bidirectional_iterator<_BidirectionalIterator,
                                                       _Tp, _Reference,
                                                       _Distance>&)
(
  return bidirectional_iterator_tag();
)

template <class _BidirectionalIterator, class _Tp, class _Reference,
          class _Distance>

inline _Tp*
value_type(const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
                                               _Reference, _Distance>&)
(
  return (_Tp*) 0;
)

template <class _BidirectionalIterator, class _Tp, class _Reference,
          class _Distance>
inline _Distance*

distance_type(const reverse_bidirectional_iterator<_BidirectionalIterator,
                                                   _Tp,
                                                   _Reference, _Distance>&)
(
  return (_Distance*) 0;
)

  #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

template <class _BiIter, class _Tp, class _Ref, class _Distance>
inline bool operator==(
    const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __y)
(
  return __x.base() == __y.base();
)

] type char count [
#endif /*__STL_CLASS_PARTIAL_SPECIALIZATION*/

template <class _BiIter , class _Tp , class _Ref , class _Distance>
inline bool operator ==(
    const reverse_bidirectional_iterator <_BiIter , _Tp, _Ref , _Distance>& __x,
    const reverse_bidirectional_iterator <_BiIter , _Tp, _Ref , _Distance>& __y)
(
  return __x.base() == __y.base();
)
#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
] type char count [

template <class _BiIter, class _Tp, class _Ref, class _Distance>
inline bool operator!=(
    const reverse_bidirectional_iterator<_BiIter, _Tp,_Ref, _Distance>& __x,
    const reverse_bidirectional_iterator<_BiIter, _Tp,_Ref, _Distance>& __y)
(
  return !(__x== __y);
)

inline bool operator!=(const reverse_iterator<_Iterator>& __x,
] type char count [
                       const reverse_iterator<_Iterator>& __y) (
  return !(__x == __y);
)

template <class _Iterator>
inline bool operator>(const reverse_iterator<_Iterator>& __x,
                      const reverse_iterator<_Iterator>& __y) (
  return __y < __x;
)

template <class _Iterator>
inline bool operator<=(const reverse_iterator<_Iterator>& __x,
                       const reverse_iterator<_Iterator>& __y) (
  return !(__y < __x);
)

template <class _Iterator>
inline bool operator>=(const reverse_iterator<_Iterator>& __x,
                      const reverse_iterator<_Iterator>& __y) (
  return !(__x < __y);
)

#endif /*__STL_FUNCTION_TMPL_PARTIAL_ORDER */

#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION

// This is the new version of reverse_iterator, as defined in the
//  draft C++ standard.  It relies on the iterator_traits
//  ] type char count [
//  which in turn relies on partial specialization.  The class
//  reverse_bidirectional_iterator is no longer part of the draft
//  standard, but it is retained for backward compatibility.

template <class _Iterator>
class reverse_iterator
(
protected:
  _Iterator current;
public:

  typedef typename iterator_traits<_Iterator>::iterator_category
          iterator_category;
  typedef typename iterator_traits<_Iterator>::value_type
          value_type;
  typedef typename iterator_traits<_Iterator>::difference_type
          difference_type;
  typedef typename iterator_traits<_Iterator>::pointer
          pointer;
  typedef typename iterator_traits<_Iterator>::reference
          reference;

  typedef _Iterator iterator_type;
  typedef reverse_iterator<_Iterator> _Self;

public:
  reverse_iterator() ()
  explicit reverse_iterator(iterator_type __x) : current(__x) ()

template <class _Iterator>
inline bool operator>(const reverse_iterator<_Iterator>& __x,
                      const reverse_iterator<_Iterator>& __y) (
  return __y < __x;
)

template <class _Iterator>
inline bool operator<= ( const reverse_iterator<_Iterator> & __x,
                       const reverse_iterator<_Iterator> & __y) (
  return !(__y < __x);
)

] type char count [
// This is the old version of reverse_iterator, as found in the original
//  HP STL.  It does not use partial specialization.

#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
template <class _RandomAccessIterator, class _Tp, class _Reference = _Tp&,
          class _Distance = ptrdiff_t>
#else
template <class _RandomAccessIterator, class _Tp, class _Reference,
          class _Distance>
#endif
class reverse_iterator (
  typedef reverse_iterator<_RandomAccessIterator, _Tp, _Reference, _Distance>
        _Self;
protected:
  _RandomAccessIterator current;
public:
  typedef random_access_iterator_tag iterator_category;
  typedef _Tp                        value_type;
  typedef _Distance                  difference_type;
  typedef _Tp*                       pointer;
  typedef _Reference                 reference;

  reverse_iterator() ()
  explicit reverse_iterator(_RandomAccessIterator __x) : current(__x) ()
  _RandomAccessIterator base() const ( return current; )
  _Reference operator*() const ( return *(current - 1); )
#ifndef __SGI_STL_NO_ARROW_OPERATOR
  pointer operator->()const(return &(operator*());)
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
  _Self& operator++() (
    --current;
    return *this;
  )
  ] type char count [
  _Self operator++(int) (
    _Self __tmp = *this;
    --current;
    return __tmp;
  )
  _Self& operator--() (
    ++current;
    return *this;
  )
  _Self operator--(int) (
    _Self __tmp = *this;
    ++current;
    return __tmp;
  )
  _Self operator+(_Distance __n) const (
    return _Self(current - __n);
  )
  _Self& operator+=(_Distance __n) (
    current -= __n;
    return *this;
  )
  _Self operator- (_Distance __n) const (
    return _Self(current + __n);
  )
  _Self& operator-=(_Distance __n) (
    current += __n;
    return *this;
  )
  _Reference operator[] (_Distance __n ) const ( return * ( * this + __n); )
);

  template <class _RandomAccessIterator , class _Tp,
          class _Reference , class _Distance>
inline random_access_iterator_tag
iterator_category(const reverse_iterator<_RandomAccessIterator, _Tp,
                                         _Reference, _Distance>&)
(
  return random_access_iterator_tag();
)

] type char count [

  template <class _RandomAccessIterator, class _Tp,
          class _Reference, class _Distance>
inline bool
operator>(const reverse_iterator<_RandomAccessIterator, _Tp,
                                 _Reference, _Distance>& __x,
          const reverse_iterator<_RandomAccessIterator, _Tp,
                                 _Reference, _Distance>& __y) (
  return __y < __x;
)

template <class _RandomAccessIterator, class _Tp ,
          class _Reference, class _Distance >
inline bool
operator<=(const reverse_iterator<_RandomAccessIterator, _Tp,
                                  _Reference, _Distance>& __x,
           const reverse_iterator<_RandomAccessIterator, _Tp,
                                  _Reference, _Distance>& __y) (
  return !(__y < __x) ;
)

template <class _RandomAccessIterator, class _Tp,
          class _Reference, class _Distance>
inline bool
operator >= (const reverse_iterator <_RandomAccessIterator, _Tp,
                                  _Reference , _Distance>& __x,
           const reverse_iterator <_RandomAccessIterator, _Tp,
                                  _Reference , _Distance>& __y) (
  return ! (__x < __y) ;
)

#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */

] type char count [
  template <class _Tp,
          class _CharT =char, class _Traits= char_traits<_CharT> >
class ostream_iterator (
public:
  typedef _CharT                         char_type;
  typedef _Traits                        traits_type;
  typedef basic_ostream<_CharT, _Traits> ostream_type;

  typedef output_iterator_tag            iterator_category;
  typedef void                           value_type;
  typedef void                           difference_type;
]

Explanation:
make assigns a value to a variable. In this case make 'clean is just obfuscation, assigning a square bracketed list to a variable clean and then not doing anything with it.
type char count is used to print out a character based on the number of items inside the square-bracketed list that follows it. type prints out a value, char returns a character based on an ASCII value and count returns the number of items in a list. So for example type char count [ a b c d e f g h i j ] will print out a newline character (ASCII value 10).
Try it online here (cut and paste of source required)

I don't know what's more surprising: the fact that this looks like STL headers or the fact that it prints Hello, world!. +1

I'm trying to find a BF clone here somewhere...

Looks like Swift...

@DDPWNAGE It's not Swift

Reminds me of VerboseFuck, but I think not.

@samgak Could it be that type receives an ASCII code and prints out the corresponding character?. I can see you are calling a lot of type char count. type prints out whatever char count returns, which is the amount of unique characters in the input text (whatever is inside the [])

@MatiCicero you're on the right track

Some variety of Logo? That certainly has "type" and "char" and "count" and square-bracketed lists, and the very beginning looks like a Logo variable assignment. But I thought Logo used double-quote rather than single-quote for quoting symbol names.

@GarethMcCaughan Well done, you got it! Logo (at least the variant I tested this in) allows single or double quotes for symbol names.

It's alarming how many people there are who can apparently instantly recognize TinyBF or Fission or HeadSecks but are flummoxed by Logo :-).

Where's the turtle?

Fission, 67 bytes, cracked by BrainSteel
Here is another one, which should be a bit simpler.
class P{static void Main(){System.Console.WRite("Hello, World!");}}

Is this by any chance C#?

@MKII Does it compile in C#? :P

is letter R in method write is capital on purpose?

@user902383 Yes. (Otherwise it would compile in C#, right? ;))

Oooh! Capital R, you say? Is this Fission? :D

Awesome! I want to add this as an official example now lol

Q, 64 bytes, cracked by Mauris
-1(-9!0x010000001b0000000a000d00000048656c6c6f2c20576f726c6421);

Explanation:

KDB+ has its own message protocol/serialization format, which can be applied to strings as such:
-8!"Hello, World!"

That gives us the long hexadecimal string above. The conversion, if you haven't guessed by now, is -9!.
To print it out as Hello, World! exactly, I need to use -1 to do so. Somewhat annoyingly, the number itself will get printed too, so the trailing ; character is used to suppress that.

(it was a good run for slightly over 2 days!)

A stab in the dark... 2B?

@Kslkgh sorry, nope... :)

Just to make sure, this prints exactly "Hello, World!" with no preceding linefeeds, right?

@ThomasKwa there's no preceding linefeed, only the optional single trailing newline.

This is the Q/kdb+ programming language.

@Mauris brownie points for you! :)

I only figured it out because you had a previous answer on the site in Q, heh ^^

@Mauris I was somewhat worried about this, but hey it's all in the name of fun...

Hmprf. I tested J and K. I should have tried more letters...

@Dennis hmms actually, if we're talking about the same K here, which q is based on, then it works too. I just tested by using the KDB+ binary and enter the k prompt by typing a backslash : http://code.kx.com/wiki/Reference/BackSlash#toggle_q.2Fk.

I'm hardly an expert. Either I did something wrong or it doesn't work with Kona.

~English revised, 36 bytes
Echo "Hello,"
and " World!".
End."!"

This answer contains protection against SPSS, Foo and Tiny. sighs
Four attempts and another answer in the same language, but my submission is finally safe!
Explanation
~English is designed to look like plain text, which is probably why the second release appends not 2 but revised to the language's name.
Thankfully, there are aliases of the functions Display and Stop, which make ~English not look like English.
Of those aliases, I chose Echo and End, which – together with the keyword and – make the source code resemble a verbose scripting language rather than an esolang.
The sentence
Echo "Hello," and " World!".

greets the World and
End.

stops execution, so the Foo protection that follows is simply ignored by the interpreter.
You can download the official interpreter from GitHub (linked on the Esolang page).

You have insane determination.

Karma, 67 bytes
05\+148*+\[455**\8+\[\6+\[3]-\[46*]\[-1{-\6\++]]\\[7]-942**.
:\!!@<

The first line pushes all the characters onto the stack, using the queue to save some bytes. The second line pops and prints until 0, which is the first char on line 1.

The seven days have passed. You may reveal the language and make your answer safe.

UNBABTIZED, 77 bytes
$0,0
.:72
.:101
.:108
.:108
.:111
.:44
.:32
.:87
.:111
.:114
.:108
.:100
.:33

Verification
You can find the official website and interpreter here.
As noted on the website, the interpreter was written for Python 2.2, which allowed non-ASCII characters in source code. You can either download Python 2.2.31 or fix it for Python 2.7 by inserting the following line at the beginning of the interpreter:
# coding: latin1

How it works
First of all, whitespace should not be allowed in the source code according to the website, but trailing whitespace after a complete instruction seems to cause no issues.
The command $0,0 executes memory[0] = memory[0] == memory[0], which does not help greeting the World in any way. I've added this command solely to distract from the fact that . acts a statement separator.
The rest of the code is composed of thirteen :x commands, which writes the character with code point x to STDOUT.
An unobfuscated version of the source code would look like this:
:72.:101.:108.:108.:111.:44.:32.:87.:111.:114.:108.:100.:33

1 Compiling Python 2.2.3 was surprisingly uneventful on openSUSE 13.2. make, make install and the resulting executable all printed a lot of warnings, but UNBABTIZED worked as intended.

http://esolangs.org/wiki/Fueue ?

@vihan No, sorry. Fueue prints FUEUE: UNKNOWN , OP 14 times, then HHeelllloo,,  WWoorrlldd!!, without exiting the program.

Pyth... But not on the online interpreter?

@BetaDecay No, sorry. $ begins a Python literal, resulting in a syntax error.

Is this some kind of assembly, perhaps?

You know a lot of esolangs!

@kirbyfan64sos Dennis knows a lot of everything.

...Is this LARSA?

@mbomb007 LARSA printed this.

Well, grats on making it 7 days I guess. It would've been funny if someone was saving their knowledge of the answer until now.

gs2, 3 bytes, cracked by feersum
e|h

In gs2:

e or \x65 is product on lists (such as the empty list of characters representing STDIN), so it pushes an int 1.
| or \x7c is power-of-2, which changes it into 21 = 2.
h or \x68 is hello, which is a ridiculous command. The story goes as follows: when designing gs2, I set out to beat every code golf language on shinh's golf server, but goruby has an easter egg command h that prints Hello, world! (note the lowercase w), allowing it to claim the #1 spot on the hello world challenge's leaderboards. I wanted to one-up goruby, so I added my own easter egg command h that pushes Hello, world! to the stack, but allows you to customize the capitalization and punctuation by pushing an integer before it:
    elif t == '\x68': #= hello
        x = 0
        if len(self.stack) >= 1 and is_num(self.stack[-1]):
            x = self.stack.pop()
            x = (range(0, 11) + [100, 1000, 16, 64, 256]).index(x)
        s1 = 'h' if x & 1 else 'H'
        s2 = 'W' if x & 2 else 'w'
        s3 = ['!', '', '.', '...'][((x & 4) >> 2) | ((x & 16) >> 3)]
        s4 = '' if x & 8 else ','
        f = '%sello%s %sorld%s' % (s1, s4, s2, s3)
        self.stack.append(to_gs(f))

As you can see by looking at the s2 = line, if there's a number 2 at the top of the stack, it'll get replaced with the uppercase-W variation: Hello, World!.

I have to ask: Does you intended solution comply with rule 1, specifically the part about what qualifies as a programming language?

@Sp3000 Those are supposed to be U+2062 INVISIBLE TIMES characters, which are invisible, but not whitespace, so that they pad the post length to 30+ characters.

@Dennis Yup -- the language is, in fact, Turing-complete.

@Sp3000 I've replaced the padding with something less browser-breaking.

This is Hello++.

@Doorknob: that doesn't qualify as a programming language (and moreover, it would print Hello World, lacking punctuation.)

Ah, right, completely forgot about the programming language requirement.

gs2? (Didn't work at anarchy golf, but seeing maurisvh authored 5 days ago I'm going to guess it anyway.)

Bingo! (I thought it'd get cracked much faster. I've even answered challenges on here in gs2.)

MarioLANG, 549 bytes, cracked by Sp3000
++++++++++>)+++++++)++++++++++((-[!)++.)+.+++++++..+++.))]-.(----.((+++++++++++++++.).+++.------.--------.)+.
=|||||=|||"|||||=||||||=||||||||||#|||||||||=|||||||||||||||||||||||||||||||||||||||=|==|||||||||||||||||||||
----------!((((-(.[)++++++)++++)))<(--.(-.-------..---.((]+.)++++.))---------------.(.---.++++++.++++++++.(-.
Helo, Wrd!#||||||=|||||||||||||=||"||||||||||||||=||||||||||||||||||||=||||||||||||||||||||||||||||||||||=|||
++++++++++>)+++++++)++++++++++((-[!)++.)+.+++++++..+++.))]-.(----.((+++++++++++++++.).+++.------.--------.)+.

I really enjoyed this one. Here is a quick overview of how I created the code:

I started from the Brainfuck "Hello World!" on esolangs:
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.

I had to modify it slightly to add the comma, but let's ignore the details...
BF can be converted to ML fairly easily: change > and < to ) and ( respectively. Add a main floor beneath the program. Then implement loops via helper floors and elevators. That turns the above program into:
++++++++++>)+++++++)++++++++++)+++)+((((-[!)++.)+.+++++++..+++.)++.((+++++++++++++++.).+++.------.--------.)+.).
=========="===============================#=====================================================================
          !                               <
          #==============================="

This is a working "Hello World!" program in MarioLANG. (This code corresponds to the incorrect "Hello World!" on esolangs, not the obfuscated ML code above.)
At this point, we can golf the code a bit my actually moving some of the loop code into the auxiliary floor. I'm now switching to the actual code from this answer:
++++++++++>)+++++++)++++++++++((-[!)++.)+.+++++++..+++.))]-.(----.((+++++++++++++++.).+++.------.--------.)+.
=========="=======================#==========================================================================
          !((((-(.[)++++++)++++)))<
          #======================="

And now the actual obfuscation: I figured the = would be a dead giveaway for Sp3000 who knew the language (he had used it in Evolution of OEIS). But MarioLANG also has "walls" instead of "floors", represented by |. These are functionally identical though, so I used the less common character. I also figured the hanging floor would look suspicious so I padded the two lines with other characters. For good measure I added the first line again to the end, and made the padding in the middle line the opposite characters of the first line. I also added matching square brackets (which are ignored by MarioLANG), because I figured an unmatched [ might be another strong hint. Finally, I wrote a CJam script to sprinkle exactly 13 = into random floor positions (13, because that's the length of Hello, World!) and changed the padding characters in the fourth row to Helo, Wrd! to make it look like I'm reading the characters from the source code, like a Befunge answer might. Voilà, obfuscated MarioLANG! :)

I'm going to guess TinyBF but it's probably another language disguised as tinyBF :p . I can't tell for sure because the interpreter is crashing my browser.

@vihan It would be a pretty crazy coincidence if this was working TinyBF. It's definitely not what I intended. ;)

Is it Rail? (more characters to make this long enough for a comment)

@AlexA. No, unfortunately you can't disguise Rail like that (or I would have already posted a Rail answer :D).

Just a guess: fission

@aditsu (and anyone else who wants to throw out Fission as a random guess): Fission needs at least one of the 4 (upper case) characters ULDR to initiate any control flow at all. So no. ;)

This is MarioLANG, but this was so well obfuscated that it looks nothing like it.

><>, 353 Bytes, Cracked by Sp3000
//This seems almost fine
//"Hello, World!" r^2 times
//But will it be too wordy?
  var r = 2;
  var a1 = "Hello";
  var a2 = ",";
  var a3 = " World";
  if(a1 != a2 && a2!=a3&& a3 != a1){
      r+=(a2===",")?1:0;
      a1+=a2;
      a1+=a3;
      if(a1 == "Hello, World")
        for(var i = 0; i++; i < r*r)
        {
          log(a1);
        }
    }

As discovered by Sp3000, this is a ><> program. All unused whitespace and characters replaced with . character for readability.
/.................. ....
./"Hello, World!" r^.......
//.................o.......
 ...........
 ..................
 ..............
 ..................;
 ..................!................
 ..................?....
 ............
 ............
 ..................l..........
 .................. ................
 ........
 .................
 ........
 ....

Did you forget the exclamation mark?

When ran in the correct language, the output is "Hello, World!" (no quotes of course)

Alright, just checking :)

More ><> (Fish)!

Indeed it is :P Too bad I forgot the ! in the obfuscation >_<

waow. Good obfuscation.

Higher Subleq, 52 bytes, cracked by John WH Smith
int puts(char*);int main(){puts("Hello, World!\n");}

This doesn't really look like an esolang, but no sane C derivate would implement puts without an implicit newline.

Doesn't this work in C?

@Arcinde No, it does not.

Ah, two newlines.

Is it objective c?

@KritixiLithos Not, it is not. It prints Hello, World! followed by two newlines.

Wow, I'm actually going to comment here :D Could this be... Higher Subleq?

@JohnWHSmith It is! Well done.

Mascarpone, 30 bytes, cracked by Sp3000
[!dlroW ,olleH]$.............

Stack-based? Maybe...

[!dlroW ,olleH] pushes all of those characters to the stack (yes, including the delimiters); $ pops the ]; and then the .each print one character. The program exits with a [ character still on the stack.
I would have made the output use a loop, but I can't figure out how they work...

He tasks me. He tasks me and I shall have him!

Just a guess: STXTRM?

@ETHproductions, it's not intended to be Orthogonal. The interpreter doesn't compile for me, so I can't definitely prove it isn't.

@nimi, it doesn't work in STXTRM. (And I'm not sure that STXTRM even meets the criteria of the challenge: it doesn't seem to have a way to print. I had to add one for the test).

Hmm. Maybe Befunge?

@Polynomial, no. It loops infinitely in Befunge.

I'm guessing [] pushes a zero-terminated string, $ pops the 0, and . prints an ASCII character.

(or is that what they want you to think?? dramatic music plays)

@Mauris Or $ reverses the string on the TOS.

Got it! It's .... unfortunately I'm not allowed to tell, because I already had my guess. Damn.

@nimi, keep it quiet and I'll give you half of the prize money.

Seems to work in Mascarpone, which is indeed stack-based and $ pops the ] which for some reason gets pushed

Haskell, 637 bytes
(program, main)= script $init

string= struct( \
  char(show)-> do show; putChar(char); while 1 ) (return 0)

script
  stack= auto $string("!dlroW ,olleH")

struct buffer (public) = share%: \
  align->flip
  (field public buffer) align

auto buffer= (init, buffer)

share from = select x where x = from x

while skip=return 1; skip= skip+1

select x | ~"World"<-
            "Hello"=x

loop k for[]
  buffer=(const ($k) ($skip) id)

loop while not(-- $x) {
  unsigned: i{-1}
  terminal.write(buffer{eval $i--})
  x= not (unsigned) $x
  $i `const `skip{-2}
}

memorize{+,-}

(goal, field)= auto loop

finish%:
  goal= finish $goal

Deobfuscation video

Sounds like a sports game, lol.

For some reason, I feel like this is a language that ignores alphabetic characters, and all the worlds are just there to confuse people.

@kirbyfan64sos: no, only a few of the characters are ignored. Most random changes you could make to this program would brake it.

The seven days have passed. You may reveal the language and make your answer safe. (As long as you don't, people may still crack your answer.)

A guess: it's zsh?

@georgeunix: no.

This is the ugliest code in Haskell I've ever seen, and hopefully will ever see. Out of all the esolang puzzles in this thread, doing this to Haskell is an outstanding accomplishment. Amazing job, sir!

GNU bc, 36 bytes
main = do
  print "Hello, World!\n"

A Foo-immune version of my previous attempt.
This requires the GNU version (or any other version that features the print function) of bc. The first line is for obfuscation: in bc variables don't have to be declared and are initialized with 0, so we have useless assignment but with valid syntax. The second line simply prints Hello, World!.

Is it Frege?

@alephalpha: I don't know Frege, but all programs I've seen have a module or package keyword in it, so I guess it won't compile. Maybe it works in the REPL, but that's not allowed.

If it wasn't for the Foo protection, this would work in zsh.

Just to make sure - this prints at most one newline at the end, right?

@Sp3000: Yes, at most one newline.

This isn't haskell, is it?

@alephalpha I've tried and Frege does indeed require some boilerplate. PureScript suffers from the same problem.

@oopbase: no, it's not Haskell. It compiles, but gives the wrong output.

I'm sure this isn't the intended language, but this does work in Cyan, if you ignore messages sent to stderr (error-less syntax would need a colon after main = do:).

I am currently trying every single Haskell-inspired language I know of.

I'm giving up. The best I could find was Zsh on Anarchy Golf (which inexplicably strips all trailing linefeeds), but unless that was the intended solution, I don't think it should count. STDERR is ignored by default, so @primo's Cyan produces the correct output, but I cannot find it on English Wikipedia, Rosetta Code or Esolang.

In ksh , this prints "Hello, World!", with some errors to stderr.

MOONSCRIPT!!!!!!!!

@Dennis I, too, only know the language because of #anagol, and only recognized it because I spent some time dissecting the interpreter, mainly because it was written in C#.

@kirbyfan64sos ksh and MoonScript both print two trailing newlines. :(

@Dennis What about CoffeeScript?

@nimi The seven days have passed. Put me out of my misery and reveal the language. :P

@Dennis: revealed the secret

Wow, I didn't even know bc existed up till now.

(You have to be kidding me! I've searched the whole internet for something I have on my computer...) How do you invoke this? I can't seem to convince bc to read from a file.

@primo: yes, Cyan works, but as Dennis wrote, it doesn't fulfill the requirement (Wiki, Rosetta, Esolang). Sorry.

@Dennis: see Wiki article: cat <file> | bc

@nimi I feel hat anagol was wrongfully excluded from that list :p

I copy-pasted the code from your answer, so I was missing the third newline. Apparently, bc absolutely requires this. bc < file works as intended with it, but bc file prints the GNU welcome, the message and then drops to a prompt.

@Dennis: third newline? There are only 2. Each line ends with a single NL.

I can't even count to two... Yes, sorry, second newline. And a sneaky newline it is.

Whirl, 12302 bytes, cracked by Artyom
3.141592653589793288462643383279207884697269399375705845974944595347816486286788
[encoded data, 12071 characters]

Whirl ignores everything except 1 and 0. I also modified other digits randomly, but they are not relevant. When you keep only 1's and 0's, you get a "Hello, World!" example :)

Pi?

@alephalpha hehe, no, it's just disguised to look like Pi

Is it by any chance NULL?

@AlexA. no, it's not

4?

@TheNumberOne no, I'd be really shocked if it works :p

@TheNumberOne It doesn’t work in 4. I get ZeroDivisionError: divided by 0 with the Ruby interpreter.

Nice one! This is Whirl.

@Artyom oww you got me!

Mouse, 105 bytes
1[10Y:Y.Y.*X:108Z:33X.X.8+X.Y.+4+X.Y.+1+X.Y.2*-7+Y.3*2+44X.Y.+1+Z.Z.Y.10*1+72!'!'!'!'!'!'!'!'!'!'!'!'!']$

You can get an interpreter for Mouse written in C here.
Mouse uses reverse Polish notation, so operators follow operands. (Think Lisp backwards.) Variable assignment is performed using <variable>: and recalling a variable's value is done as <variable>.. All values in Mouse are integers.
! outputs an integer and !' outputs the ASCII character associated with the integer. All output goes to STDOUT.
For whatever reason, all valid programs must end with $.
1 [ ~ If true, do

    ~ Variable assignments
    10 Y:
    Y. Y. * X:
    108 Z:

    ~ Push values onto the stack
    33               ~ 33  "!"
    X.               ~ 100 "d"
    X. 8 +           ~ 108 "l"
    X. Y. + 4 +      ~ 114 "r"
    X. Y. + 1 +      ~ 111 "o"
    X. Y. 2 * - 7 +  ~ 87  "W"
    Y. 3 * 2 +       ~ 32  " "
    44               ~ 44  ","
    X. Y. + 1 +      ~ 111 "o"
    Z.               ~ 108 "l"
    Z.               ~ 108 "l"
    Y. 10 * 1 +      ~ 101 "e"
    72               ~ 72  "H"

    ~ Pop values and output as characters
    !' !' !' !' !' !' !' !' !' !' !' !' !'

]   ~ End if
$   ~ End program

Is it Headsecks?

@mbomb007 Nope.

Is this Nybbleist?

@BrainSteel Nope.

Just a wild guess, Julia?

@BetaDecay Nope. But given the sizable proportion of Julia answers I post, that's not an unreasonable guess. :P (Although the syntax is not remotely similar.)

Blind guess: Suzy?

@Sp3000 Nope. :)

Is it FALSE?   maybe?

@PhiNotPi Excellent guess, but not quite there. It's Mouse. :)

Aw man.. I've seen Mouse (briefly), but didn't associate it with your code. Congrats!

Nice, a non-esoteric language.

APL, 39 bytes, cracked by Mauris
"Helo, Wrd!"[0,1,2,2,3,4,5,6,3,7,2,8,9]

Efficiency is everything.
This works in the ngn-apl demo.
Obfuscating APL is no easy task if the intention is to make it look less like APL.
This is what I achieved:

Double quotes do not work in all dialects. Dyalog, e.g., does not support them.

ngn/apl is the only dialect I know that uses zero-based indexing by default.

The commas aren't supposed to be there.
Vector elements are usually separated by spaces when writing APL. However, , concatenates so the code inside the brackets concatenates 13 singletons.

A (slightly) unobfuscated and more portable version of the code would look like
⎕IO←0⋄'Helo, Wrd!'[0 1 2 2 3 4 5 6 3 7 2 8 9]

which works in TryAPL, GNU APL.js and the ngn/apl demo.

Works in kdb+. I think the language name is Q, but didn't find it mentioned anywhere in the download. And I don't know how to run it as a standalone source file.

No I'm wrong, it also printed the quotes...

Anyone know any languages where array indexing of a string is allowed?

@mbomb007 Python and Ruby, but this ain't either. I can't think of a language that won't print quotes around the string.

This is APL. (It works in ngn-apl, at least)

@Mauris Correct!

Chef, 1943 bytes, cracked by Angew
Hello World Cake with Chocolate sauce.

This prints hello world, while being tastier than Hello World Souffle. The main
chef makes a " World!" cake, which he puts in the baking dish. When he gets the
sous chef to make the "Hello" chocolate sauce, it gets put into the baking dish
and then the whole thing is printed when he refrigerates the sauce. When
actually cooking, I'm interpreting the chocolate sauce baking dish to be
separate from the cake one and Liquify to mean either melt or blend depending on
context.

Ingredients.
33 g chocolate chips
100 g butter
54 ml double cream
2 pinches baking powder
114 g sugar
111 ml beaten eggs
119 g flour
32 g cocoa powder
0 g cake mixture

Cooking time: 25 minutes.

Pre-heat oven to 180 degrees Celsius.

Method.
Put chocolate chips into the mixing bowl.
Put butter into the mixing bowl.
Put sugar into the mixing bowl.
Put beaten eggs into the mixing bowl.
Put flour into the mixing bowl.
Put baking powder into the mixing bowl.
Put cocoa  powder into the mixing bowl.
Stir the mixing bowl for 1 minute.
Combine double cream into the mixing bowl.
Stir the mixing bowl for 4 minutes.
Liquify the contents of the mixing bowl.
Pour contents of the mixing bowl into the baking dish.
bake the cake mixture.
Wait until baked.
Serve with chocolate sauce.

chocolate sauce.

Ingredients.
111 g sugar
108 ml hot water
108 ml heated double cream
101 g dark chocolate
72 g milk chocolate

Method.
Clean the mixing bowl.
Put sugar into the mixing bowl.
Put hot water into the mixing bowl.
Put heated double cream into the mixing bowl.
dissolve the sugar.
agitate the sugar until dissolved.
Liquify the dark chocolate.
Put dark chocolate into the mixing bowl.
Liquify the milk chocolate.
Put milk chocolate into the mixing bowl.
Liquify contents of the mixing bowl.
Pour contents of the mixing bowl into the baking dish.
Refrigerate for 1 hour.

That would be Chef, I assume.

@Angew Well done! :)

Wordfuck, 1063 bytes, cracked by Martin Büttner
Thus men; die. Here meet prepar'd thrice be." Down his
 with lab'ring forg'd and And retir'd Now universal Phoebus at
 Hesperian living, off fields fierce cries, assail'd not for These
 foe. Spread, indulgent quarry headlong prince your bloody side crew.
 Elated call humble yield, his yield, boys camp men, cruel
 all the loudly trusty won, winter spouts they crown. Had
 what long long upon fram'd. Declare back throat, tossing his
 enters, the Nor Aeneas; said from flowing the enclose th'
 match'd Receive with neither threat. From seas painted His oppos'd,
 cried, Thus mortal the his and combine form and, wine.
 And but Let absent, sums to guest, you to spear
 to greedy of First, with love bear." path Whom heav'n
 That by Argive need they to blood, wert eyes the
 this To large, with Some Jove (The from hosts, the
 yoke with horses' when sail is purple at wintry his
 with more camp with have to Earth, to oppose of
 the troops with various but so, thirty well perform by
 the and waves- man! from fear victory too at fire,
 If recess banish'd transfer.

Note that line endings must be Unix-style.

Perl? (Probably very wrong...)

@kirbyfan64sos No, far too readable for Perl.

At first I thought it might be ??? and I got super excited, but it turns out it doesn't work in ???. :/

@AlexA. That would've been awesome! If I had known about ??? I definitely would've done it..

@Alex_A Is there a programming language called "???"? I've never heard of it and it's impossible to Google!

@Caltor AlexA. just published it last night ;)

@ETHproductions I'm super confused! :/

@Caltor The first line of the page AlexA linked to: "??? is an esoteric programming language created by Stack Exchange users Alex A. and BrainSteel." They added that page to the wiki last night, after adding its code on GitHub: https://github.com/ararslan/qqq-lang

Shakespeare? It certainly looks like Shakespeare...

This is Wordfuck.

Wordy, 3279 bytes
#_>^ +7K1 }OU8 4>Fk ry\g 9Ff] A}kY ,6Fo IK`k C'td dbJ[ 0j]l MBp[ \">| R\JY %+T_
)*`7 @[{j ;x-+ _H\= ;D@& />p? h,mx 1m;7 p+yL -#&9 0(^! ,i9^ Q%_! +&$Q %#|e %:~A
%T</ }-(r ]_$p g&|" *w#= @++j \)U` <:W< _t{( c\#< :f@~ >[+6 ,B%? S6d} HSm" b=Yz
c[(; @n*# ;`,Z >~K) D"<% <}h" #>N. I0:o >c"+ '>S! pQX[ U#gu $Ei0 6`>~ -/4: ,3;%
\c(? h;TQ LN)o 5`#; }{V* '-E. 7:5u d]0y s|JJ u+>` `|8? y,<0 \(d! 1^*, &U`_ U/@"
*&7. M|f% |C#? \{4` ,k<+ %*'D h~=_ W_+{ [#_[ %"-r #~_F _:u. N|W6 awH' JMm, }%=R
a>*= *z+' {@"A ,'3\ m;}@ (I<. "044 '}A` =K'? puB[ R<ka nrR: S<>= ;`(e (\*p N$"?
u1c} eI%L O$*~ ]O+{ 7"@! vU%n 'MIs E`VV ,/~q p}\? ^DM, k:-! ,3:$ D*~< "}T^ /z}%
\|h< 'Y@? }M%0 {/c. |";P /I"` "[(v ~>l- #2]! j~af rZ(J 9zv` {`T, M`'& (H+: {G+>
A#~` /_%6 4"}! 9|rs [;$m ]J|? IZx; ^xaf WuB) =^+s |+%t [;^U ])A! H;Jb @STw x^`,
=9~< %Z). @v3o h;Tz M9~t {'|O {J`. u^t> 9<-? )/4- `/v| )>O] /(E' ,};X ;&0. 0`o:
(#o? ,D]< X%|* ;}*h [%C` &(A' ^@J^ {O[| &%&Q -;9` |j}) |z]+ :4:. 03(4 <Bhz N$mY
R$~< -M#' C)$$ /=[J 9@^" [*}a :%R. T1,W Y=}` O=&. D;ms Mi=c (Stg >|}1 __^B P};{
&{1. y(Wq T&Nq $^'D />@M @u^? $2Pd n4~d 19j/ X>#> #s[. 0-@P $B%? %w}% x=<[ =}r_
\#=8 ~~R> P']! }8a+ *;j! w<_` %;T: #0({ -_8< A(]^ @1`/ )@f` /=m\ e"~@ ~4$' (z]&
/C|? wtn; HFe^ Gzn* @K}/ >1+{ 7/-{ 2&{} }X-% T=:> O,;. qR8; ;*0: s|>. -bFs DK^y
jk}O =~g/ B%:{ 9;@` K%}? `Xvi "vI4 c+$) =<(b %g#. Tt'w P\ID M`fI %#^M E#=. B&)v
;9:? (+/7 <%q" =,U{ -`/G r[*^ Y;@! H&d> ))@% &S,! |B*[ ~^-p 6+,~ N#&\ ;]K* 6}=^
/|Q) *y:\ ,M*| %&'f =U>@ }~@Y >~3~ `P<: K\+? WUD= |4x5 sox} /6;> [&r{ p@", :'D}
g{^} -]$H _B-! fJ5< p;&@ {a~! Ra+M OKo+ ydJ+ *~-T :W=; @*#, ^_e- k=_. M@QY (fQn
X<,] >(C/ [A/. {nNT {tXg vy@e *1+} (G,. +2m[ X[=! s$,/ [@y! :l+9 -@2. :(P- +a~#
,p%) %*)0 }*=F +"T( Q&~@ <c*; }(\E 3@_* I):( \:2? ~CqL 5$TC ,ARH ;*p/ <~0` _B';
;=>A (%T, d&[; #`g. N*u1 @LEE zPP[ ;<)4 ,1%= [#1# =6^! IL\e 0t@f ~}h< j'{+ <_B!
wFE; lyr` Ja\V '[,J 2_^! Rb;% I>$? F#-{ %+j. fB>2 J7P# Kj~n }#C> T*%` Q=/@ T;%>
_c|{ :&$1 %Q}. rFl> #A,` `Z^! Ks"L hUI: 6_MV ^Q-- `M/> #3/= #'n. MID{ vdn, @_l{
v_@; `s@? H#eZ ]9my oP#e {|R# '(k! d#d; :s,? $+H@ :#=e }2-] 8,-< &1$! l(`7 e:-!
%\X$ k_>' <7], ~%N| r)]] -"$u &0\! SR:z ly]b K(wa q*@- ]{~c )}x% &@&Y >~;j #R)=
%V*. %L1F j'~; +_0. Yz-x @kVV 0G:a `,p] (>n< >{{z /#m! S~CS #Foq %$h( +*{B G#@?
fwr< %OQt K"Cx @0}+ b${. F]R* k=/! C$=, @#/b 4[$* y`,^ $|*R 6,%! Z*c@ ;0\. [&f-
$"/k -L{, \@7{ ^]k\ v$>% v#-; +G># -F@} :=R@ Z<|^ )H-~ o#~^ E#$) :a{. i52: :svA
q&NY #g"< )r]{ "p%& %P}@ 'k|, #m)' ]6$. :@{& |Rcr \]|T ;^8! b2{F rvVP D>~_
)'A_ G(}- Y&^? 64-A %klM %Q=@ }J:; _b<? ^jjo v[5V {gyQ y)`[ }|l. '0B` A`{. >]@M
#},y C"_} s]@' \9|- _#$o _w"? %&43 k}". >}u- ^]b? z%Cg f+aT vr$A /:\z #);I $*F,
+7^# \%T( ,*a{ &>n? t8J( >*|F @{4? >X4T o7r+ bQ:L *^C_ ;#8& `w(( >,v. a<dY D52+
1_+: "-i) }&f? *LNO %d5F yu{O $}&x 'v]? *b{m &*i! W\#( <%i+ }=o" 9=#& \@1{ @4-?
O])U :`Z? T{`> &>}0 <[T+ `w|{ *"k* >@b^ ~,8+ "{;n &-X* "l{+ [V_" ^8$. $Ppv MY7%
1e;R ={g# |N}_ )`[d *U\~ "@L# &o{, ^Y[! m13= z@\$ /\o. VdO" %EBr h,cD &^(6 )t(`
'S%, @L(? zd{g 0YR" n;}_ 9$~^ N`$! hz>G iM_A JT8+ K)-] g[`? 1J@~ -l*? {<n& w{+:
;r`& ,9-> (}r| M$<? I"0* H|=. =[:T (^#y V~-/ 6(:? K{GF RzF^ V^4d ;#>d ~C}@ b(^\
(_B- /)_K >;^i V#%! c5H^ 'R@> <M:. ee\0 jPH( JV=4 >{&k "T#\ y';) {^e? :gq7 2B(3
+P-| s\%( 'e~? TE8^ V6U> mB<q 'K&( {u|! y@(? a_%. *</>

As I hinted in the comments, this haystack is mostly needle.
We can greet the World by executing the following instructions:
ASSIGN NOP LITERAL 16
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 4 LITERAL 8
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 5
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 12
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 12
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 15
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 2 LITERAL 12
OUTCHAR MULTIPLY VALUE NOP LITERAL 2
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 5 LITERAL 7
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 15
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 7 LITERAL 2
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 12
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 6 LITERAL 4
OUTCHAR ADD MULTIPLY VALUE NOP LITERAL 2 LITERAL 1

Wordy encodes all instructions as sentences, where the fraction of words that are longer and shorter than the rounded average selects the command.
The shortest sentences I could find for the used instructions are:
ASSIGN xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx x x x x x x x.
VALUE xxx xxx x x x.
ADD xxx x x.
MULTIPLY xxx xxx xxx x x x x.
OUTCHAR xxx xxx xxx x x x x x x x.
NOP xxx xxx xxx x x.
LITERAL xx x.

But how can one conceal the fact that word length is the only important thing in the source code?
Neither word order nor the picked word characters matter, as long as they're alphanumeric, so I decided to add random non-alphanumeric characters to each word to pad all of them to the same length. I also added a few non-words (no alphanumeric characters at all) to give the source code its pleasent rectangular shape.
I've generated the final source code using this CJam program.

That's one big haystack.

I guess that depends on the size of the needle.

Speaking of haystacks. If there isn't currently a language called "Haystack", that'd be a great name for one...

@mbomb007 working on it ;)

I'm pretty sure that it isn't, but l33t?

@MickyT It's not supposed to be l33t and I don't think it could happen by accident.

I don't think it would either.  I couldn't find a interpreter to try it in so I took a stab in the dark.  It was the 7 in the first set that made me think, but looking at it deeper the 4 a couple on would cause problems.

Boolfuck, 698 bytes, cracked by aditsu
#include <iostream>
int main() { char _=1;char w=3;char z=7;char o=_+5;char p=_+7;char f=9;char q=_+3;char r=_+5;
char i=_+z;char j=_+o;char k=_+o;char s=_+p;char t=f;_+=q;_=_;_+=k;_*=s;_*=i;_+=j;_*=t;_+=_;_+=z;
_*=o;_+=p;_*=f;k*=2;_+=4;i*=0;_+=2;_+=7;_*=9;i+=1;_+=2;_*=3;k*=6;q*=2;k+=9;_+=1;q*=4;k+=9;_*=6;f*=2;
w+=4;o*=4;w+=9;_+=6;o+=9;w*=2;_*=6;s*=6;w*=3;o*=3;j*=9;_+=7;_+=9;f*=2;_+=f;s-=3;r*=6;_+=i;f+=8;_+=s;
s+=1;j+=r;_+=z;_*=o;t*=5;p*=3;k+=3;_+=5;s*=2;k+=9;t-=4;o+=4;_+=3;p*=5;o+=5;s-=4;r*=3;r+=5;z*=7;t-=9;
r+=6;p-=4;j+=9;w+=4;p-=5;w+=6;_*=7;_*=f;w+=2;_+=p;_*=7;_+=o;i*=p;t+=1;_+=9;_+=s;_*=0;_*=i;_*=6;_+=7;
_+=3;_*=3;z*=2;_+=_;_+=12;z+=3;std::cout<<_<<z<<w<<o<<p<<f<<q<<r<<i<<k<<j<<s<<t; }

If this is C++, the capitalization is wrong.

You're right, this is not C++.

Maybe brainfuck?

Nope, not Brainfuck!

Maybe this is a language where # is a comment?

This must be Boolfuck!

Yes, it's Boolfuck!

Foo, 38 bytes, cracked by kirbyfan64sos
fn main(0){println!("Hello, World!");}

This looks like Rust.

@Dennis Nope, not Rust. (Very very close, though.) ;)

Oh, well. +1 for that sneaky 0.

Is this Foo? (0) would end instantly, and the other operators do nothing. (If it is Foo, I think this is the first one that was intended to be Foo!)

@kirbyfan64sos Yep! (This was intended to be Foo that looks like Rust.)

Clip, 108 bytes, cracked by jimmy23013
"Hello, World!", he exclaimed at the top of his lungs, "What a beautiful day to be alive! Hello, World!"-13>

Everybody loves a short story.

 The intended language was Pyth, which prints the first string, then chokes on one of the many type errors. With the offline interpreter, all errors go to STDERR, so they don't count as output.

Most of the short stories I read don't end with -13>.

That's an... emoticon.

Works in Clip.

@jimmy23013 It wasn't supposed to, but it does.

I tested it in the online Pyth interpreter, but was scared off by the errors. Tricky, tricky....

Linotte, 47 bytes, cracked by ProgramFOX
HelloWorld :
 début
   affiche "Hello, World!"

waves baguette

I think it's Linotte.

@ProgramFOX C'est exact

GolfScript, 369 bytes, cracked by ProgramFOX
.!))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))).)))))))
)))))))))))))))))))))).)))))))..))).(((((((((((((((((((((((((((((((((((((((((((((
((((((((((((((((((((((.((((((((((((.)))))))))))))))))))))))))))))))))))))))))))))
)))))))))).)))))))))))))))))))))))).))).((((((.((((((((.(((((((((((((((((((((((((
((((((((((((((((((((((((((((((((((((((((((](+

Wait a second, did I forget a paren somewhere?

I think it's GolfScript.

@ProgramFOX Well that lasted a whole 48 seconds. ;(

ETA, 293 bytes, cracked by Sp3000
New nut oven in penal ham; men act of men. Arab arena, but spent? Nope! UNIX likez...
NSA bend at Senator, bend at omen (CAW!). How bend to a mean ten if Ruby yet?
Unternet and Outer? 'tis too meaty in systems.
Grunted? Uh... New Hand enters sty!
Sun-tied nutellu hurt?
On the knife ruts Smurf Ian.

Is this Beatnik? I can't test because I don't have an interpreter...

Nope, it's not Beatnik.

This is ETA I believe

@Sp3000 sigh... I guess having it uncracked for a bit over three hours isn't bad :P

@Geobits That's because I was asleep for those three hours :P

@Sp3000 You should sleep longer. You need at least 168 hours of solid sleep to be healthy.

Someone should arrange a score to these lyrics...

DoubleFuck, 1195 bytes
"""     \xde\xbf\xcc\xbc\xca\xaf\xbe\xaa\xaa\xda\xbd\xed\xfc\xaa\xda\xac\xef
\xdd\xff\xcc\xef\xea\xdf\xab\xae\xde\xfc\xcc\xaf\xdb\xbf\xae\xca\xcc\xef\xca
\xbc\xab\xea\xec\xae\xff\xcf\xba\xac\xfe\xab\xbe\xaa\xdc\xcd\xdc\xeb\xed\xac
\xcd\xaa\xba\xae\xfd\xae\xfa\xad\xba\xcc\xde\xba\xbe\xac\xca\xfd\xae\xef\xaa
\xbe\xcd\xfc\xdc\xdd\xbd\xbb\xaa\xbe\xde\xdb\xdd\xdb\xea\xbc\xbf\xdb\xfa\xcd
\xed\xee\xda\xef\xcd\xed\xde\xec\xbb    \xdc\xbd\xeb\xac\xfc\xad\xfe\xde\xbb
\xcc\xcf\xdc\xdc\xfa\xef\xbd\xdc\xfd\xcb\xff\xdd\xbc\xac\xbb\xff\xeb\xac\xab
\xca\xca\xcd\xbd\xaf\xeb\xda\xac\xdb\xcc\xaf\xce\xdf\xad\xad\xea\xee\xda\xfb
\xdc\xbf\xfd\xcb\xbc\xfb\xee\xae\xcb\xcf\xfb\xcd\xef\xfc\xea\xca\xbd\xee\xed
\xea\xed\xba\xef\xad\xcd\xfa\xaf\xaf\xdc\xef\xab\xdd\xda\xeb\xce\xac\xbe\xae
\xbc\xbf\xee\xec\xfd\xee\xed\xbb\xfc\xab\xaf\xda\xeb\xbd\xbe\xdc\xef\xaa\xda
\xbd\xfc\xcd\xdc\xaf\xec\xad\xad\xda\xda\xba\xbb\xbc\xee\xdf\xea\xca     """

a = [
      "!!",

      """]--------[>+>+++++>-->-->--->++++>------<<<<<<<-------]
         >.>---.>----..>-.>++++.>.>+++++++.<<<.+++.<.<-.<<[     """,

      "\x48\x65\x6c\x6c\x6f\x2c\x20\x57\x6f\x72\x6c\x64\x21\n"
    ]

def f():r = print(a[2]) or quit()

f() and f()

As noted in the comments, this one contains a few infuriators:
$ golfscript hello.???
Hello, World!
2
$ python3 hello.???
Hello, World!

$ brainfuck < hello.???
Hello, World

But only the first two herrings are red!
Any brainfuck program that contains no comments is also a valid DoubleFuck program that performs the same action, so the brainfuck instructions of the above code still print everything but the exclamation mark.
Finally, the 223 backslashes in the multi-line string at the beginning decrement the first memory cell in the second array until it reaches 33 and the colon in
 def f():r = print(a[2]) or quit()

prints the character with code point 33, i.e., an exclamation mark.

This is Python 3.

@SuperJedi224 Not quite. The string contains a linefeed and print appends a second one.

I tried BrainF*** as well, but that omits the !

And ><> prints 10-2 and then gets stuck in an infinite loop.

Is it deadfish x?

@BassetHound That would be a huge coincidence.

GolfScript produces Hello, World!\n2\n

Wordfuck, 552 bytes, cracked by Sp3000
bCB A@? >=< ;:9 876 543 210 /.- ,+*)('&% $#"!~} |{zy xwvuts rqpo nmlk jihg fedc ba`_ ^]\[ZY XWV UTS RQPONM LKJ IHG FEDCBA @9> =<; :98 765432 10/. 'K+* )i'& }C{" !~w=<z yxw vut srq pon mlk jih afe^$Ea `_^]\[Z YXWVUTS RQPONMF EiIH*F? DCBA:^> =<;:z87 65. R21 0/. -,+ *)( '&% $#" b~w={zyrw vutm3k po ng-kji hgI edc ba` _^ ]\UyYX :PU TSR QJn NMF Ei IH *e?DCB A@? 8\ <|:387 65.R s10) .-,+ *#Gh &} ${Abx} |{ zyxq7u Wsrq pinm lkji b(fe dFb[ `Y}] \[TS wW VUTSRQP 2HMFjJI H*e?DCB A@ ?8\< ;:z8 70/S 3s 1*/(L,+ *j ('&%${" !x> |^ zsxwvo 5sUqpo nmlkji hg`edc ba`Y }j

This produces the correct output in Malbolge, but not the correct byte stream.

Would this be Wordfuck?

I spent hours writing a Malbolge polyglot and you cracked it in less than 5 minutes... :(

Hollow, 17 bytes, cracked by Sp3000
{Hello, World!}:?

If it survives it will be hard to beat, but I don't know whether it will survive.

In GolfScript it outputs {Hello, World!}. A compiler.

Is this Hollow?

GolfScript, 41 bytes, cracked by ProgramFOX
begin
   stdout_print "Hello, World!"
end

I guess it's GolfScript.

@ProgramFOX Yes, it is. :)

Perl 5.10, 139 bytes, cracked by primo
~!0!~('@"/(@`)~@``^"|'.(('"
_]'^'|"`&').('[)).["[}(@,@@
{~/),$}@{**(!(^$&%{%{*[/,`,
'^'+[@@/+{_`%@,/&[)@[@@_`[#
!(!~-/,[,[#{&%@').'"!"})'))

Verification
For obvious reasons, the above code is deemed unsafe in modern versions of Perl.
However, in Perl 5.101 (available here), it works as intended with no warnings whatsoever.
To assure Perl 5.20 that you know what you're doing, use the -Mre=eval switch or add the line
use re 'eval';

before the actual code (see 'eval' mode).
This way, you can try the code online in ideone.
How it works
Let's start by applying some syntax highlighting:
~!0!~('@"/(@`)~@``^"|'.(('"
_]'^'|"`&').('[)).["[}(@,@@
{~/),$}@{**(!(^$&%{%{*[/,`,
'^'+[@@/+{_`%@,/&[)@[@@_`[#
!(!~-/,[,[#{&%@').'"!"})'))

The code contains quite a few strings, which contain actual linefeeds. We can make it more readable by saving those strings in variables:
$a = '@"/(@`)~@``^"|';

$b = '"
_]';

$c = '|"`&';

$d = '[)).["[}(@,@@
{~/),$}@{**(!(^$&%{%{*[/,`,
';

$e = '+[@@/+{_`%@,/&[)@[@@_`[#
!(!~-/,[,[#{&%@';

$f = '"!"})';

~!0 !~ ($a . (($b ^ $c) . ($d ^ $e) . $f))

($b ^ $c) and ($d ^ $e) XOR the respective strings character by character.
The results are then concatenated with $a and $f, yielding the following string2:
@"/(@`)~@``^"|^(?{print  "Hello, World"                                              ,
"!"})

!~ treats this string as a regular expression and checks if does not match ~!03.
The part up to | is non-matching gibberish; the part that follows uses the (?{ code }) feature, which allows the execution of arbitrary Perl code inside regular expressions.
After stripping some whitespace, the code that gets executed is
print "Hello, World", "!"

which greets the World as intended.

1 Compiling Perl was uneventful on openSUSE 13.2.
2 Some of the spaces are actually tabulators. As the SE editor, Perl does not care about this.
3 This evaluates to 18446744073709551614, which !~ will cast to string.

Some of the most readable Perl I've seen ;)

@primo I hope that's incorrect. :P

eval mode? Should be evil mode.

goruby, 173 bytes
#/*<?php ob_clean();"/#
s=n='''*/include<stdio.h>
main(){/*';s?i;$\=?\ .#";#=;
#*/puts(/*
n;#''';
print(#*/
"Hello, World"
#//#,n^="\v"
);
#/*?><?php "
s;'''*/
}//#";#'''#";

Take 2. Perhaps this one will last longer than 5 minutes.

The above produces incorrect output (Hello, World) in serveral different languages, including PHP (assuming the output buffer is active), Perl, Python, and most C variants. It should also produce the correct output in a theoretical language which, to my knowledge, doesn't exist. That language has the following specification:

Comments begin with #, multi-line comments are enclosed by #/ ... /#.
" ... " is a valid string, and ''' ... ''' is a valid multi-line string.
Strings are mutable.
The string operator ^ performs a bit-wise xor, truncating to the smaller of the two operands.

The program would then be equivalent to:
#/ ... /#
s=n='''*/include... ''';
print(
"Hello, World"
,n^="\v"
);
#/ ... /#" ... ";

Because n begins with *, n^="\v" → !, thus producing the correct output. It was my intention to have you search for this theoretical language, which as stated, most likely doesn't exist.
The ! is actually produced by $\=?\ .n, meaning $\=' '.next. The special variable $\ is borrowed from Perl, and its value is appended to the output of each print statment. To obfuscate this a bit, I split it across 2 lines, with a puts in between. However, if anyone tried to run this in Ruby, the error message would have been a bit of a give-away:
undefined method `n' for " ":String (NoMethodError)

To guard against this, I added s?i just before. Ruby will consider this a call to the function s? with the parameter i, and error on undefined local variable or method `i'. Goruby auto-expands this to is_a?instance, which is valid syntax.

The goruby interpreter is included with the standard Ruby branch, and can be built with:
./configure
make golf

Just to double-check, are you sure that the output ends with a !?

@ProgramFOX in the intended language, it does.

It's not Python. Would've been too easy.

Finite Groups, 21 bytes, cracked by nimi
"Hello,"" World!"|p"?

Now 100% O-proof.

Is there a reason the "Hello, World!"p"?" answer was deleted? Looks like it may be the same language, whatever it may be.

@mbomb007 It works in Clip.

I would say it's Pyth, but I get a SyntaxError from Python!

@georgeunix Not Pyth then. :P

Literally the interpreter gets stuck due to a SyntaxError in the interpreter, not the code!

@georgeunix That's not true. | requires two parameters, but there's only one in the source code. The output would be incorrect anyway, since Pyth prints the two strings on separate lines.

@Dennis oh, OK.

It works in Finite Groups.

@nimi How did you compile the interpreter? I'm getting fg.hs:15:1: parse error on input `module' with ghc. (Or is it another language? The blog post doesn't say.)

It's Haskell, but every module has to be in a separate file. The file name must be the same as the module name, e.g. module SymmetricGroup(SymmetricGroup) where -> file name: SymmetricGroup.hs. All in all 13 files. Then compile with ghc Main.hs. Run it with ./Main <file>.

@nimi How practical... That worked, thanks.

SQL, 37 bytes, cracked by mbomb007
start: print 'Hello, World!' -- stop.

It works in MySQL. :)

Yup, that's SQL.

Interesting. Is it version dependent? Can't convince MySQL 5.6 to execute it.

@manatwork Idk, I just ran it in SQL Management Studio 2014 as soon as I saw it, since -- stop would be a SQL comment.

@mbomb007 Isn't SQL Management Studio for T-SQL only?

@AlexA. I meant MSSQL, which is T-SQL.

Gammaplex, 473 bytes
\TR 63615292119513872138
\K
\TND
o;
o;
o;
o;
o;
o;
o;
kt;
\EF
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
s=62367792098112175613253971580643679683892471;
fg;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
t=8736321328219817931084222979807263280855865;
gr;
w=s+.+.+.+.+.+.+.+.+.t;
z;
v;
r;
r;
r;
r;
r;
r;
r;
r;
r;
r;
r;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
mp;
o="\\\\\\\\\\\\\";
p o##w;
z;
v;
r;
r;
r;
r;
r;
r;
r;
r;
r;
r;
r;
o;
o;
o;
o;
o;
o;
o;
o;
o;
o;
f;
\RUN 92356788

Unobfuscated:
\TR 63615292119513872138
\K\TNDo;o;o;o;o;o;o;kt;\
EFo;o;o;o;o;o;o;o;o;o;s=
623677920981121756132539
71580643679683892471;fg;
o;o;o;o;o;o;o;o;o;o;o;o;
o;o;o;o;o;o;o;o;o;o;o;t=
873632132821981793108422
2979807263280855865;gr;w
=s+.+.+.+.+.+.+.+.+.t;z;
v;r;r;r;r;r;r;r;r;r;r;r;
o;o;o;o;o;o;o;o;o;o;mp;o
="\\\\\\\\\\\\\";p o##w;
z;v;r;r;r;r;r;r;r;r;r;r;
r;o;o;o;o;o;o;o;o;o;o;f;
\RUN 92356788

Yes, it is a 2D language. The incomplete line is ignored.

Looks like a 2D language to me... but the list is so long...

I think this is some language that ignores non-decimal characters.

><>, 82 bytes, cracked by Sp3000
version 1.0
\0: ~~ "Hello,"
\1: ?? " World!"
\4: ...
\n:   r>:~/
end;   ^?)<< data

I believe this is ><> (Fish). Nice use of version 1.0 though :)

It is! I'm glad you liked it =)

Glypho, 480 bytes, cracked by jimmy23013
  v># #  :: < <   <v#  #*>*> ##:#**#,<,<: : > > *  *v>>v # ##,#, + +:++: ++ ##
*<<*,^,^<<#v<<v#v::v< < <,, +,+,+>>+*,,*+*+*,,*>**^v#  #,,:^#vv#>+>+ << >  >, , ++*>:
:v<v<^#^#v::v>::>v**v # #::>^>+>>:>:>>>*>>##>*^ *# #  vv ,::,<<>:++
*vv*v:v:^vv< > > ,,>>:>: << >+>>^ ^ ^^*^+,+,#::#*:*::  :v v  ,   # #<<#<#**#^,^,+##+**
+**+,:,:::>*<^v< v v+^+^*^^*+<<++##+v#v#++<>:< :* **+ +   ^ *  *<+<+<  *vv+<:^^:::
  ^+*<<***<^+  ++:+:^##^:>:>+::< > >#>># *  >,>, :^ ^>>^##<#,<,*^   *<:<

Note that it is essential to use Windows line terminators (\r\n). For the avoidance of doubt, here is a hexdump:
00000000  20 20 76 3e 23 20 23 20  20 3a 3a 20 3c 20 3c 20  |  v># #  :: < < |
00000010  20 20 3c 76 23 20 20 23  2a 3e 2a 3e 20 23 23 3a  |  <v#  #*>*> ##:|
00000020  23 2a 2a 23 2c 3c 2c 3c  3a 20 3a 20 3e 20 3e 20  |#**#,<,<: : > > |
00000030  2a 20 20 2a 76 3e 3e 76  20 23 20 23 23 2c 23 2c  |*  *v>>v # ##,#,|
00000040  20 2b 20 2b 3a 2b 2b 3a  20 2b 2b 20 23 23 0d 0a  | + +:++: ++ ##..|
00000050  2a 3c 3c 2a 2c 5e 2c 5e  3c 3c 23 76 3c 3c 76 23  |*<<*,^,^<<#v<<v#|
00000060  76 3a 3a 76 3c 20 3c 20  3c 2c 2c 20 2b 2c 2b 2c  |v::v< < <,, +,+,|
00000070  2b 3e 3e 2b 2a 2c 2c 2a  2b 2a 2b 2a 2c 2c 2a 3e  |+>>+*,,*+*+*,,*>|
00000080  2a 2a 5e 76 23 20 20 23  2c 2c 3a 5e 23 76 76 23  |**^v#  #,,:^#vv#|
00000090  3e 2b 3e 2b 20 3c 3c 20  3e 20 20 3e 2c 20 2c 20  |>+>+ << >  >, , |
000000a0  2b 2b 2a 3e 3a 0d 0a 3a  76 3c 76 3c 5e 23 5e 23  |++*>:..:v<v<^#^#|
000000b0  76 3a 3a 76 3e 3a 3a 3e  76 2a 2a 76 20 23 20 23  |v::v>::>v**v # #|
000000c0  3a 3a 3e 5e 3e 2b 3e 3e  3a 3e 3a 3e 3e 3e 2a 3e  |::>^>+>>:>:>>>*>|
000000d0  3e 23 23 3e 2a 5e 20 2a  23 20 23 20 20 76 76 20  |>##>*^ *# #  vv |
000000e0  2c 3a 3a 2c 3c 3c 3e 3a  2b 2b 0d 0a 2a 76 76 2a  |,::,<<>:++..*vv*|
000000f0  76 3a 76 3a 5e 76 76 3c  20 3e 20 3e 20 2c 2c 3e  |v:v:^vv< > > ,,>|
00000100  3e 3a 3e 3a 20 3c 3c 20  3e 2b 3e 3e 5e 20 5e 20  |>:>: << >+>>^ ^ |
00000110  5e 5e 2a 5e 2b 2c 2b 2c  23 3a 3a 23 2a 3a 2a 3a  |^^*^+,+,#::#*:*:|
00000120  3a 20 20 3a 76 20 76 20  20 2c 20 20 20 23 20 23  |:  :v v  ,   # #|
00000130  3c 3c 23 3c 23 2a 2a 23  5e 2c 5e 2c 2b 23 23 2b  |<<#<#**#^,^,+##+|
00000140  2a 2a 0d 0a 2b 2a 2a 2b  2c 3a 2c 3a 3a 3a 3e 2a  |**..+**+,:,:::>*|
00000150  3c 5e 76 3c 20 76 20 76  2b 5e 2b 5e 2a 5e 5e 2a  |<^v< v v+^+^*^^*|
00000160  2b 3c 3c 2b 2b 23 23 2b  76 23 76 23 2b 2b 3c 3e  |+<<++##+v#v#++<>|
00000170  3a 3c 20 3a 2a 20 2a 2a  2b 20 2b 20 20 20 5e 20  |:< :* **+ +   ^ |
00000180  2a 20 20 2a 3c 2b 3c 2b  3c 20 20 2a 76 76 2b 3c  |*  *<+<+<  *vv+<|
00000190  3a 5e 5e 3a 3a 3a 0d 0a  20 20 5e 2b 2a 3c 3c 2a  |:^^:::..  ^+*<<*|
000001a0  2a 2a 3c 5e 2b 20 20 2b  2b 3a 2b 3a 5e 23 23 5e  |**<^+  ++:+:^##^|
000001b0  3a 3e 3a 3e 2b 3a 3a 3c  20 3e 20 3e 23 3e 3e 23  |:>:>+::< > >#>>#|
000001c0  20 2a 20 20 3e 2c 3e 2c  20 3a 5e 20 5e 3e 3e 5e  | *  >,>, :^ ^>>^|
000001d0  23 23 3c 23 2c 3c 2c 2a  5e 20 20 20 2a 3c 3a 3c  |##<#,<,*^   *<:<|

This is Glypho.

@jimmy23013, well done. It took you less time to post the correct answer than it took me to write the submission.

Glee, 30 Bytes
'IWRscm9XICxvbGxlSA==':r64>%<$

A fairly obscure language as it turns out.
'IWRscm9XICxvbGxlSA=='           # base64 encoding of !dlroW ,olleH
                      :r64       # decode from base64
                          >%<    # reverse the string
                             $   # output

Reference site can be found here

Is it Sillycon?

@georgeunix Sorry, it's not the intended language and I'd be surprised if it worked in it.

I believe you can reveal the language now. The 7 days are up.

This looks like an insanely cool language. However, considering it was designed for Windows 95 and newer, I don't know how well it'd on Linux under Wine...

@kirbyfan64sos, it looked like it had some potential, but appears not to have been touched since 2004 and the documentation isn't the best.

Shame it wasn't open-sourced, someone could have kept it alive

Matlab, 51 bytes, cracked by feersum
'main()''''+'';//echo{print(';'Hello, World!'
')}';

Thinking about this again, it might be that under certain interpretations of the rules this might not be valid. There are languages where no matter what you print, the interpreter (or environment) always prints/displays something else: a command prompt, or (in case of a javascript example), a dialog box. If the language does not have an stdout  like C, but I use the standard way how things are printed in that language, is it valid?

If you use the language's closest equivalent to stdout, I'd think that's valid according to the rules.

Almost works in MATLAB / Octave, except it prints ans = .

@feersum : this is what I was talking about in my first comment. The "usual way" to print anything in Matlab is to just have an expression without a semicolon at the end.

To print something without extraneous output, you would usually use disp or fprintf.

Can this work in Matlab without a REPL? If not, it's not valid.

Pascal, 113 bytes, cracked by vsz
begin{
print "Hello, World!"
#/*
end}
writeln('Hello, World!')
{begin
*/
printf("Hello, World!");
/*
}end.
{//*/}

Yep, that was pretty easy :)

It seems to be Pascal, a strange language where { } are comments.

{...} is a comment? That's evil.

Snowman 1.0.1, 43 bytes, cracked by Kslkgh
[[IO::print]]((("Hello, World!"[[end;]]sP))

Explanation:
The basic "Hello, World!" program is actually just ("Hello, World!"sP. Anything surrounded in double parens, i.e. (()), is in its own environment. In this case the new environment doesn't affect anything. Anything in double brackets, i.e. [[]], is a comment, so [[IO::print]] and [[end;]] are just for show.

Are the last set of brackets supposed to be unmatched?

That looks like snowman to me. One of my favorite esolangs.

@BetaDecay See https://github.com/KeyboardFire/snowman-lang/blob/master/doc/snowman.md for an explanation of snowman.

@Kslkgh Yep, nice work.

Hahaha, nice. Insta-upvote because this is the only Snowman answer on PPCG that's not written by me.

Deadfish (variant), 1415 bytes
As explained by Martin below, this answer is not valid.
explain life spend stay attempt giggle table mumble game I'll quiet fix manage
giggle five up wait fill left gaze normal manage fell quiet lip away believe
mum please I've baby pink wipe go blue pay quietly live guy attempt plan life
bag many men began flip new met lie began tall plan full began by many full
team fill life team act gaze won't imagine wall next wore eventually five tall
wipe meet but six play type bell amaze an put wife sudden bad eat many
eventually add actually anger imagine knee beautiful between I've many gaze
tiny mumble spend at land add went lean place warn man tell few game full plan
fun bit explain gave past mumble play play set wait by line will wet we many
went I'll live bit little money run fill buy my we tie mean evening taken ten
pull full fun any be put feet gaze family any wake fault mean eventually full
family imagine even between give fix meant am giggle imagine we've many bag up
if gun even new exactly lean family twenty buy wait beautiful put town band
felt age ball amaze buy wave put leg fell ball wall get yell bad between age
bed began able well left by at age deal late baby well deep don't me may glad
age I ball team wave may I'd band leave get tell amaze pull new empty day yet
many gun wave dead add leave clean area fun wet jump imagine key man met gun
little meet blink pull any plan mean eye guy day put I'm lead leg age feel
maybe fault tall edge world

This works with the Python 3 implementation of Deadfish by chill0r, which has these operators:

i / x: increment by 1
d: decrement by 1
s / k: square
o / c: print accumulator
h: exit interpreter (and stop program) (non standard)
r: reset accumulator to 0 (non standard)

I wanted to use h, but unfortunately the interpreter prints 'Long live the fish!' before exiting.
The relevant code (without the ignored characters) is:
xiisdsiiixiiiioriiisikioiiiiiiicoiixoriisixisdddddcriikiisddddcrixissiiiiiioriiikikiiiiixiiiixciiioddddddoddddddddcriikiikdddord

The actual output is:
72
101
108
108
111
44
32
87
111
114
108
100
33

Deadfish is not able to output strings or characters, but only numbers, so this is the standard form of printing a string.

Completely wild guess as I cannot test it right now, but maybe .Gertrude?

@TreFox never heard of it, so most likely not a match :)

I think this is Wordfuck.

@ThomasKwa nope, but interesting guess

Is this Beatnik?

@ETHproductions nope

wild stupid guess... "Shakespeare"?

@frikinside no, it looks nothing like Shakespeare

@aditsu that's why i said "stupid guess"!

Is this asdf?

@Bas no, but you're getting a bit closer

Is it Grocery List?

@mbomb007 no, it's not

Also, someone else should check if it's ETA or not. Probably also not.

I got an empty stack error when I ran it in ETA, so no.

Override header: invalid, based on the fact that Deadfish does not meet our requirements for a programming language (linked in the challenge) and that the spec says "write a full program in the chosen language which prints Hello, World! (exactly like that, i.e. this exact byte stream)"

Fortran 77, 40 bytes, cracked by Reto Koradi
      WRITE(*,*)"Hello, World!"
      END

Could be easy, might not be... Who knows ;)

Looks like Fortran?

@RetoKoradi But which Fortran? ;)

Fortran followed by a two digit number? ;) Let me do some quick checking... With the whitespace in the first columns, it could be an early one.

@RetoKoradi Haha you're getting very warm

Well, based on my very limited Fortran knowledge (or at least what I remember of it), this could be legal in almost any early version. Since I have to name a specific one, I'll say: FORTRAN 77.

@RetoKoradi Perfect :D

@BetaDecay Valid F77 is also valid F90, F95, etc until you get into deleted features.

Slashes, 31 bytes, cracked by manatwork
/foo/Hello, World!//bar/foo/bar or / World! World!/Hello,/ World! World! World!

/// aka Slashes. (Using “print” instead of “foo” would make it trickier.)

@manatwork Correct!

goruby, 62 bytes
"!dlroW ,olleH"::#@<
              ev.di
13             > id^0

Yup, this is a c-like language disguised as a stack-based esolang disguised as a c-like language. goruby is a version of Ruby designed for golfing (although it usually can't compete with the true golfing languages on this site). The main difference between it and regular Ruby is that you don't have to type out the full method name, just any unique subsequence of characters. So here, ev aliases to reverse,di aliases to display, and id aliases to include.
The code also uses a bit of obfuscation that'd also work in regular Ruby: ::, which is almost always used to reference a namespaced constant, can also be used to invoke a method, the same as ., and any amount of whitespace can come in between the colons and the method name. Since #@< is a comment, that means the first two lines are equivalent to "!dlroW ,olleH".reverse().display()".
The last line throws a runtime error since the return value of include is not a number, but since arbitrary output to STDERR is allowed and we've already printed to STDOUT, it doesn't really matter.

Befunge?
Comments must be at least 15 characters in length.

@VladimirLenin Can't be befunge, it doesn't have any commas to print characters.

Well, there is one comma ;). But no, this is not Befunge, Befunge would just push HHHello, World! onto the stack and then not print anything.

~English, 102 bytes, cracked by aditsu
Display "Hello, World!".
Stop eating large quantities of food.
Notice that this doesn't work in "Foo".

Is it ~English ?

@aditsu That didn't last long :)

Underload, 1349 Bytes
When I first looked at Underload for this challenge I was struggling to come up with a way to suitably obscure it.  Parenthesis Hell seem like a good red herring, but the example Hello World didn't seem to nest deep enough.  Parenthetic was the next choice and had a nice set of parenthesis.
I copied the Hello World example for Parenthetic, made sure it didn't output Hello, World! and embedded the Underload commands into it, with a lot of chaff that just gets left in the stack.
I thought this would be cracked and was just hoping it lasted longer than it took me to put it together :)  Pleasantly surprised that it lasted the distance.
(((-)([)(]))^((v)((S)(*))^)^(((~)((%))^)^((($))^(-)(>)(+)(<)(^)(-)(-))^(((-)(-)((-))^)^((([))^(.)(H)(e)(l)([)([)([)([)([))^(((]))^(o)(,)(W)(o)(])(])(])(])(])(v))^)^)^)^(((r)(l)(d))^((!)((v)(v)(v))^)^(((v)((v))^((_))^(-))^((([))^(])(v)(=)(|)(/)(*)()^(S)(*)(-)([)(])(v)(~)(%)($)(_)(=)(|)(-)([)(])(v)(/)(*)(S)(*)(~)(%)(-)([)(]))^)^)^(((v)(($))^)^(((_)((=))^((|))^(/))^(((*)((-))^)^(([)((])(v))^)^(((S))^(*)(~)(%)($)(_)(-)([))^)^)^(((])((v))^((=))^(|))^(((/)((*))^)^((S)((-)(>))^)^(((+))^(<)(^)(-)(-))^)^)^(((-)((-))^((-))^([))^(((.)((H))^)^((e)((l)(l))^)^(((o))^(,)( )(W)()(o)()()(r)(l)(d)(!))^)^)^(((*)^((*)^)^((*)^)^(*)^)^(((*)^(()^)^)^((*)^((*)^(*)^)^)^(((*)^)^(*)^(*)^(*)^()^(*)^(*)^(*)^(S)^(<)^($)(_))^)^)^(((=)((|))^((-))^([))^(((])((v))^)^((/)((*)(S))^)^(((*))^(~)(%)(-)([)(])(v)($)(_)(=)(|)(/)(*)(-)([))^)^)^((])((v)(S)(*))^)^(((~)((%))^(($))^(_))^(((-)(([))^)^((])((v)(=))^)^(((|))^(/)(*)(S)(*)(-)([)(])(v)(~)(%)($)(_)(=)(-)(>)(+)(<)(^)(-)(-)(-)(-))^)^)^(((-)(([))^((.))^(H))^(((e)((l))^)^(([)(([)([))^)^((([))^([)(])(o)(,)(W)(o)(])(])(])(])(])(v)(r)(l))^)^)^(((d)((!))^((v))^(v))^(((v)((v))^)^((v)((|)(-))^)^((([))^(])(v)(/)()^(*)(S)(*)(~)(%)(-)([)(])(v)($)(_)(=)(|))^)^)^(((/)((*))^((-))^([))^(((])((v))^)^((S)((*)(~))^)^(((%))^($)(_)(-)([)(])(v)(=)(|)(/)(*)(*))^)^)^(((*)((-))^(([))^(]))^(((v)((*))^)^((*)((*)(*))^)^(((*))^(*)(-)([))^)^)^)^

Here's a simplified version of it, with a bit of an explantion.  From characters 503 through to 709 in the program.
(((-)((-))^((-))^([))^(((.)((H))^)^((e)((l)(l))^)^(((o))^(,)( )(W)()(o)()()(r)(l)(d)(!))^)^)^(((*)^((*)^)^((*)^)^(*)^)^(((*)^(()^)^)^((*)^((*)^(*)^)^)^(((*)^)^(*)^(*)^(*)^()^(*)^(*)^(*)^(S)^(<)^($)(_))^)^)^

Which essentially simplifies down to the following due to the ^'s.  They put the top element of the stack back into the program repeatedly.
(-)(-)(-)([)(.)(H)(e)(l)(l)(o)(,)( )(W)()(o)()()(r)(l)(d)(!)***************S<($)(_)

From there we end up with a stack of
!:d:l:r:::o::W: :,:o:l:l:e:H:.:[:-:-:-:

The *'s concatenate the top element to the second element repeatedly and the S outputs it.
The < causes the program to stop.
The following are left on the stack.  Of course the main program leaves a lot more.
.:[:-:-:-:

Tested here quite a bit:)

Are you sure it's printing "Hello, World!" and not "hello world" ?

@aditsu Yes, its Hello, World!.  Just double checked it :)

Is it Parenthesis Hell? (It's just a crazy guess.)

@kirbyfan64sos sorry it's not ... well it shouldn't be :)

Is it Parenthetic?

@AlexA. Sorry it's not.  In Parenthetic it should output hello world rather than Hello, World!

Ah, wait. I think it's some BF derivative that ignores parentheses! (Unfortunately, I already wasted my guess...)

@kirbyfan64sos I can neither confirm or deny

Subskin, 1727 bytes
03 49 39 287 36 92 38 92 838 C2 90 389 27 39 57 38 126 35 87 2 9
48 32 51 8E E3 81 28  39  21 72 782873 828 E7328 827F3 728 7382 87
00 34 88 C2 83 82 83 84 732812 9378        7283 72873 7 6236 273 6263
0C 23 8A 32 B8 38 46 46       36 372 728 3822 34948 38 374384 8374
02 23 8838 32 A8 37 7 372 8 38283 82737 283 7323 23 234 6534
01 23 23 42 3 23 2323 3223
03 43 5A 34 34  3B 45 3 45 34 53 45     3 4 34 5345 345 34 55 233 2
01 423 322 323     23C 24 43 54 3443 56 6 4  34 04 F5 56 87 85
03 34 43 4652 26234 32 436 5F45  34 83658

00 567 576  F3565  53 C6 5A65 6352 45 78154 71D425 7 154 4F54571

00 325487234 57 9B BA 293 847 98 7 378 43 7D3 483 48 7 8374 873487 38108

00 13498 49 835A796 31 67 93 9 9 13943 0340039498 713478 78 10 3408 7

65 13 D49 98 3C 948 84 37 C1 34 74 1F 39 13 49 86 163 1764 31 8C A7 34 18 8 364 8634B1138 477

6C D437134 788 364 367134 8 3478341781 34 618813B741783 4 7446 8117 744 8731

6C 0A 92 83012 09385A782130 109247 5203 203 230 923087523 0 209

6F AA 92 3 1098274293912 310923 1290 B1 209 B129047 5423B908

2C 92 D8 39 2398 272 93 84293 8239472 4 72932893 9823783 23

20 22 39 8923 48 92 3D 98 29 83 6C 62 38 92 05 A0 23 523982983 2398 26 37

57 23 72 34 87D2 48  2 8 029133 7548 26 23983297 64 2384972 39238

6F 23 49 029 32A39464 729  3832 E62 93 8 456239 842 9 2387462 498E

72 29 A2 39 84 82 47 287 426  8D23 8283  37464 24 62828 3 7326  238783 72

6C 23 32 87 92 38 723 78 92 3982 394DD6 25692345982 29632 3984 62893 39

64 23 89 48 A2 97423A987  98424 7293 8 3298674 6239 8 329847 236 4

21 24 97 37 49 2C 39 78     29E8 B3 84 6E 45 62 96 32 985562E3987 2 398429 48372

Is this a hex dump or plain text?

Plain text, not a hex dump!

Has SE removed some of the characters?

No characters are removed

Wow, that looks like a difficult language. Nice work.

Deadfish~, 24 bytes
wish("Hello, World"<<33)

Deadfish~ is such a perfect language for this game that I checked several times that the edit history in the Esolangs wiki and the commit history in Github for the interpreter actually predated the challenge. It seems some deity of whimsy, chance, and trickery was watching over me when the language was created and then when I clicked the Random button on the wiki. Although not quite enough for me to actually win...
Deadfish~, like its parent language Deadfish, uses single character commands interpreted from left to right. Here's a breakdown of what my program does:
w: Print "Hello, World!" (yes, with the capital W).
i: Increment the accumulator.
s: Square the accumulator.
h: Halt the program.
All further characters: Ignored.

The seven days are over. I'm looking forward to learn what the intended language was.

Sorry, was afk getting married.

Congratulations! -- I'm afraid this answer might be invalid. With a single accumulator, I don't see how addition (let alone primality testing) could be implemented in Deadfish~.

Thanks! Fair enough, I may not have done my due diligence there. Thinking about it, since Deadfish~ has no input, the simplest way to represent a number n is with n consecutive is, so in that sense addition happens automatically. Testing whether a number is prime probably requires more sophistry than that, though. Maybe there's a way to use the quasi-modular arithmetic behavior but it's not obvious how.

Dogless, 85 Bytes, cracked by Sp3000
abcdef|ghijkl|mn"op"|<$gA$me>|<$kl$dl>|<$nH$jo>|<$er>|<$cd$AW>|<$hx$fo>|$a!$i,$x $b\?

Dogless is a self-modifying language.
Execution begins at the first |, and all | after the first are ignored. Everything in "double quotes" is also ignored. < is a meta instruction that executes the next instruction in the context of the source code before the IP. $ takes two arguments, and replaces the first occurence of the first letter with the second letter. > is a meta instruction that executes the next instruction in the context of the source code after the IP. (Which is always a |, which are ignored). Finally, ? reverses the entire code.
After execution is complete, dogless prints out its remaining source code, which in this case is Hello, World!

Would this be dogless?

Indeed it is :)

Var'aQ (English), 40 bytes, cracked by jimmy23013
"JudgHello, Worldkbicf" 4 16 strcut disp

I'm gonna try and make every program I post here 40 bytes from now on. :D

Is this MUF?

@MartinBüttner Nope

Is this var'aq?

@jimmy23013 Well done :)

Fantom, 44 bytes, cracked by w0lf
class H{Void main(){echo("Hello, World!");}}

Fantom, right?

@w0lf Yep, that's correct!

Enema, 21 bytes, cracked by Sp3000
"!dlroW ,olleH"[DZBO]

How it works
"!dlroW ,olleH" Push those characters (including a null byte) on the stack.
[               Infinite loop:
  D               Duplicate the topmost element on the stack.
  Z               If it is non-zero, skip the next instruction.
    B             Break out of the loop.
  O             Output as a character.
]

Well, in Microscript, this would print 0\n, after pushing a bunch of numbers onto the stack.

I believe this works in Enema

@Sp3000 That's correct.

Linotte, 34 bytes
/**"!"**/ :
    "Hello, World!"!

No real obfuscation here, just relying on the low notoriety of the language and its ! print command. The non-breaking thin space provided an unusual program name (a normal space is not allowed) and the commented out "!" is obviously a FOO safeguard.

Lol. Nice quick addition to prevent it working in Foo.

There seems to be a \u202f char just before the colon - is this intended?

@Sp3000 Absolutely. Well spotted.

In that case, just to check: are there any non-ASCII chars or unprintables in here? Stack Exchange sometimes messes with those, so I just want to make sure that it didn't.

@Sp3000 Nope. That's the only non-ASCII character.

The 7 days are up. You can reveal the language now.

QBasic (QB64), 87 bytes
Should be GolfScript-proof now.
5735816763073854918203775149089!?; "Hello, World!"
Outputs::Screen '$hello, $world\x21'

Nobody noticed the ? hiding in there!?  ;^)
Breakdown:

5735816763073854918203775149089! is a line number. The ! is a type suffix that indicates single-precision numbers, but I never knew you could use it on line numbers too.
? is a shortcut for PRINT. The PRINT statement separates multiple expressions with ; when they should be printed with no space in between. If a ; is at the end, it suppresses the final newline. If it's at the beginning, evidently, it's legal syntax that has no effect.

The second line is solely for obfuscation and Foo protection:

Outputs: is a label.
The second : is a statement separator.
Screen aka SCREEN, without arguments, apparently does nothing. (With arguments, it's used to change the screen mode for graphics and such-like.)  Update: I've just discovered that this part only works in QB64. SCREEN without arguments in QBasic 1.1 on archive.org gives an "Illegal function call" error, and the help file clearly shows it as needing at least one argument.
' begins a comment. Everything afterward is a red herring, which also attempts to defeat Foo via the $h part. Apparently it did its job.

I don't think too many people know QuickBasic to have noticed the ?...

@kirbyfan64sos Martin mentioned BASIC dialects as having identical shortest "Hello, World!" programs on the "Hello, World!" question, and the VBA answer there uses ?. It may not be common knowledge, but I figured there'd be enough people who knew about it that I needed to hide it pretty well.

DB2, 20 bytes
!echo Hello, World!^

Woe is me. At least I'm learning a lot of information really quickly for this challenge.
Yay! It didn't get cracked! Considering how long I spent searching for a way to make it work only in DB2, it was worth it. I'll add more of an explanation later.
Explanation

!echo prints text
^ is an escape character, but nothing follows, so it is ignored. A second carat would be necessary to print it.
This is where I first started looking into it, though it ended up being more complex getting it to work only in DB2. I was running variations like mad.

All my shells either print the caret or substitute it with something else. At least on my computer, this does not work in IPython. +1 for persistence.

@Dennis FINALLY!

Is this Cmd? It's the only thing I can think of that treats ^ specially. I'm likely wrong, though...

@kirbyfan64sos Nope. Cmd prints More? like it wants more commands to follow, and upon finishing, declares that !echo is not recognized as a command or file.

dc, 36 bytes, cracked by jimmy23013
13 37~i4A6B0CA06939989941081542909BP

This is dc. (15 chars.)

@jimmy23013 Wow, you beat me to it. Also my first guess.

Well, that didn't last long...

How did you edit this post in grace period and leave the original in the revision history?

@jimmy23013 Your comment ended the grace period.

SPSS, 21 bytes, cracked by MickyT
Echo "Hello, World!".

Your code on cmd produces "Hello, World!" with the quotes, which is wrong.

(I guessed Batch, which was wrong)

Is it IBM's SPSS?

@MickyT It isn't what I had in mind. I don't have SPSS, so I have no idea if it would work.

Neither do I, but I found an hw example that is identical other than case.  The documentation states that the commands aren't case sensitive.

@MickyT I've compiled GNU PSPP and it works.

@MickyT I might reuse it, so I don't want to tell right now.

Fair enough :-)

FALSE, 47 bytes, cracked by Sp3000
72,101,108,108,111,44,32,87,111,114,108,100,33,

I do believe this works in FALSE

Golfscript, 376 bytes, cracked by Peter Taylor
I won't win shortest submission but I enjoy trolling a bit :)
#include <iostream>
#include <string>
using namespace std;string 0utput("Hello, World!\n");struct my_struct{string input;};void print(string x){cout<<x;}string x="abc";int main(){cout<<"What language do you think this is?\n";my_struct M;cin>>M.input;if(M.input=="C++"||M.input=="c++"){cout<<"Haha. Guess again\n\n";main();}else print(Output);}my_struct Hello;my_struct World;

Ungolfed:
#include <iostream>
#include <string>
using namespace std;

string 0utput("Hello, World!\n");

struct my_struct{ string input; };

void print( string x ){ cout << x; }

string x = "abc";

int main(){
    cout << "What language do you think this is?\n";
    my_struct M;
    cin >> M.input;
    if( M.input == "C++" || M.input == "c++" ){
        cout << "Haha. Guess again\n\n";
        main();
    }else
        print( Output );
}
my_struct Hello;
my_struct World;

Looks like it works in GolfScript.

Jesus! Took you less than a minute. Nice work.

Nim, 28 bytes, cracked by Mauris
("Hello,\x20".echo "World!")

Honestly not sure how hard this one is, so it'll be interesting. The \x20 is to hopefully minimise the chance of this coincidentally working in random esolangs.

The usual Nim Hello, World! is
echo "Hello, World!"

but Nim's syntax is pretty flexible, allowing for dot syntax. The parentheses were completely irrelevant.

This is Nim. ---

@Mauris Correct! :)

PowerShell, 945 bytes, cracked by MickyT
Won't win for shortest, but this was a fun diversion. Also my second submission to this particular contest, hopefully this one is a bit more obfuscated.
Code:
#   This is a   crazy-weird program [that is
#   >   than all+others and<none    -- not even
#   Fish    -- if   you can count that
#   --  I don't count   it either
#   That's  weird - what's  this    doing   here?]>--.
$a=66
#   These [#-#] blocks are  all-comments    [meaning    everything+nothing
#   but>    c++[and somehow not c++ even    with
#   an  Include <cstd]io>] piped    > to a
#   nothing-dot like this one .
#   Whoa    it's another    [#-#] block - wonder
#   what    [this>one+does< maybe --- nothing] Maybe>everything-.   M[a-y]be
#
#   there is a  secret+hidden [me->an-[ing in amongst
#   these   --< arrows] and >- tabs]    Can>.
#   you figure it[o-u]-t[>Withou+<  g-o-i-n-g   ca-r-a-zy?] all cooped
#   up  like a  >   less-than   dot.bracket [
    $b  = $a    -   22  ;   #WHOA
#WHOA]>
#   Where did +ha[+ come    from?   All out
#   of[<left    field] li>>ke   tha+    with    na<ry   a
#   warni+g]    that>   stuff is    happening  .
    "Hello" +   [char]$b    + " World!"

#HolyCrapWTFEndOfLine
#P.S.-WhatIfYouTakeASpaceToMean0AndATabToMean1LikeInWhitespace-WhatThen?.

Wow, that's genius. Good luck to anyone who attempts! Perhaps you'll succeed (unlike me)...

Is it powershell?

Bah, indeed it is. ;-) I'll see if I can come up with yet another obfuscation of a PowerShell program.
Three months from now, I'll write a program in python and everyone will go ballistic. ;-)

Tiny, 37 bytes, cracked by Sp3000
Echo "Hello," and " World!". End. "!"

Nice use of "!" to prevent this from working in Foo. :)

I love the output in GolfScript: World! World! World!!

Works in Tiny. The hardest part was trying to find an interpreter, which is available here.

@Sp3000 After reading the esolang page, I'm not entirely sure why, but yes, it works in Tiny.

Gibberish, 60 bytes, cracked by Dennis
1 fs=[Hello, World]
2 fs.seq [33]
3 fs.@-1 x i
4 fs.prigte o

I knew it was only a matter of time once Dennis posted his own Gibberish answer.
How this works:
Gibberish is a stack-based language with single-character instructions, except for string literals enclosed in []. When in f mode, s pops a number off the stack and skips that many characters from being interpreted, so the beginning of each line is a no-op of increasing length used for obfuscation. Whitespace is also ignored. The intent was to mimic a language that had line numbers and variable assignment (although the use of fs as my fake variable name accidentally made it look like Node.js). If we remove this obfuscation, we get
[Hello, World] (push the string "Hello, World" onto the stack)
eq             (pop the string and print it)
[33]           (push the string "33" onto the stack)
1xi            (convert "33" to the number 33)
gt             (convert 33 to its ASCII character, "!")
eo             (pop "!" and print it with a trailing newline)

Is this Node JS?

It is not, sorry.

This is Gibberish.

Java, 488 bytes, cracked by Dennis
\u0070\u0075\u0062\u006c\u0069\u0063
\u0063\u006c\u0061\u0073\u0073
\u002f\u002a
init hello:word;
\u002a\u002f Hello
\u007b\u0020\u0070\u0075\u0062\u006c\u0069\u0063
\u0073\u0074\u0061\u0074\u0069\u0063
\u002f\u002a
set word as exec
\u002a\u002f
void main(String[] a)\u007b
\u0053\u0079\u0073\u0074\u0065\u006d\u002e
out\u002e\u0070\u0072\u0069\u006e\u0074\u006c\u006e
(\u0022\u0048\u0065\u006c\u006c\u006f \u0022+
\u002f\u002a
run hello as
\u002a\u002f\u0022World\u0022);
\u007d\u007d

Is it Java? (more chars)

@Dennis i hoped it will be more challanging

damn, im so sloppy i left void main:(

@user902383 The Unicode escapes are a rather well-known trick around here. ;)

Is this suppose to be java byte code with unicode letters mixed in?

@Luminous Unicode escapes. \u0000 to \u007F are ASCII characters.

Befalse, 205 bytes
(((72)(#Print.))((101)(#Print.))((108)(#Print.))((108)(#Print.))((111)(#Print.))((44)(#Print.))((32)(#Print.))((87)(#Print.))((111)(#Print.))((114)(#Print.))((108)(#Print.))((100)(#Print.))((33)(#Print.)))

Befalse (online interpreter here) is a 2D, stack based language which terminates when we leave the codespace. We use only 1 dimension here, reading from left to right as we would do in a non-2D language.
The top stack element can be printed with the instruction .. Multi-digit numbers can be pushed on the stack in the format (number). The opening parens not followed by a digit push 0 on the stack. The ones interfering with printing are dropped with the instruction #. The rest of the characters (Print) are no-ops.
A simplified version of the code:
(72).(101).(108).(108).(111).(44).(32).(87).(111).(114).(108).(100).(33).

I think this is a BF derivative, if you enter a number, the cell will be set to the number (so 72. would print H).

It's using S-expressions, which aren't as popular as they once were.

RPAL, 27 bytes
(Print'Hello, World!',',')2

This is RPAL from the PAL family. There's no real obfuscation here, just some extra (useless) code to prevent it from accidentally being a polyglot. The canonical "Hello World" program in RPAL is
Print 'Hello, World!'

This evaluates to the dummy value dummy and does the output as a side effect. Because the return value of the top level expression is always thrown away, we can make the expression more complicated and as long as we don't add any subexpressions with side effects, the output doesn't change. First I've put the Print as the first element into a pair:
( Print 'Hello, World!' , ',' )

The second element is the string ',' (but could have been any value). Then I've added the element selector 2 which chooses the second element ','. So the full expression
( Print 'Hello, World!' , ',' ) 2

returns ',' which is discarded and does some output during evaluation.
An interpreter can be found here. The interpreter is written in GNU Guile.

Fishing, 139 characters, cracked by MickyT
v+C+C+C-C-C<_
NE`'etICfPlD+
@_ LHbgFl{oCC
/yCNXbejb9]3+
}j-9<]'qT,y\C
sTC+`5)GMd&]-
Xl+UpoNr60 *C
1RC!8l @*oTT-
Ir>dF&x4ZF@WC
Z{|C-C-C+C+^]

Fishing is a 2d programming language based on a fisherman fishing. The fisherman walks around on the dock. Whenever the C command is encountered; the fisherman will cast his line for an instruction.
First I started with a dock:
v+C+C+C-C-C<_
            +
            C
  C         +
  -         C
  C         -
  +         C
  C         -
  >         C
  |C-C-C+C+^]

The v><^ instructions choose which way he throws his line.
The +- instructions lengthen or shorten his line.
The |]_ instructions change which directions he is walking.
At the end of the dock, the program ends.
After I created the dock, I took the standard "Hello, World!" program(`Hello, World!`N), and put it in the locations where he would catch fish.
v+C+C+C-C-C<_
  `       l +
    H   l o C
  CN  e     +
  -      ,  C
  C `       -
  +    r    C
  C! l   o  -
  >d       WC
  |C-C-C+C+^]

After that, I simply used a program to fill in the remaining spaces with random characters.

It's not ><>, but I'm betting it's a 2D Language.

A wild guess, is it Fishing?

@MickyT Good job, yes it is.

@mbomb007 It was the entry following Fish :P

O, 30 bytes
A;"World!""kELLO, "_'k'H%rrope

My first answer to make it past the 7 days! YESSSSS!!!! For the last 30 minutes, I've been stalking this answer to wait for the time to be up. :)
I'm seriously surprised no one cracked this, though. After all, O was written by Phase, I cracked one of
Dennis's answers as O, Dennis posted a Hello, World! answer in O, and I posted an answer to the comparison challenge in O.
Most of this answer is fluff. The A; pushes 10 to the stack and instantly pops it. The kELLO thing lowercases the string _ and replaces the k with an H ('k'H%). rr reverses the stack twice (therefore doing nothing), the o prints the Hello, , p prints the World!, and e pops off an empty stack, therefore causing the interpreter to crash...printing the error message to stderr, not stdout.

@Dennis To build it, try javac -cp /usr/share/maven-repo/commons-codec/commons-codec/1.9/commons-codec-1.9.jar -sourcepath src -d build src/xyz/jadonfowler/o/O.java (replacing the /usr/share/... with the full path to the Apache Common Codecs jar file, which is available in Ubuntu, my distro, as libcommons-codec-java).

@Dennis And to run it, the o script doesn't work, so you need to edit it to read java -cp "`dirname $(realpath $0)/build`" xyz.jadonfowler.o.O "$@".

Let us continue this discussion in chat.

rs, 347 bytes, cracked by Dennis
What? The traveler was shocked. Never in his life had he heard such a sentence/phrase said so beautifully.
Hello, World!
It rung like a booming echo in a field of tranquility. So strong, yet...calm. In fact, the force was so strong, it knocked down a nearby sign that said "Store/Hotel", which fell on the traveler's head and killed him. THE END!!

Pretty sure this'll get cracked quickly, but it's still pretty neat!
Well, this lasted around 5 days, which is much longer than I thought it would, especially since I created rs!
The first and third lines of the script are replacements designed so that they will never match and will do nothing. The second actually prints "Hello, World!".

Is it sed? It's a guess...

If so, then the /s are a give away

@georgeunix Nope.

Nope. Isn't sed.

I'm not entirely sure why, but your code works in rs.

Oh, this is simply replace-append-replace with two non-matching patterns, right? I was overthinking this...

@Dennis Yes, it is!

Cardinal, 74 bytes
>~n*,n*,n*,,n*,n*,n*,n*\
- N  kx r ' uj 2r &x ]u,
O-----%x,*u,*u,*u,*u,*u<

Bad luck for me—I noticed this challenge 17 hours 35 minutes late ;)
Have fun anyway!
Nobody solved this one yet, so here is the explanation. First a short introduction what Cardinal does:
In Cardinal each pointer carries a stack of length 2 with an active and a passive value. The role of both can be switched. All values are unsigned 8-bit integers, so every value and program can be displayed or written using the OEM 437 codepage, which is also used by the interpreter in display mode.

Short explanation of the instructions I used in my code:
% create pointers moving in all 4 cardinal (hence the name) directions.
- decrement active value (wrap around to 255 if it is 0)
O clockwise change of pointer direction
> change pointer direction to right
~ make active value passive and vice versa
n drop active value in direction of the bow of n and pick up new active value from the open end of n
u drop active value in direction of the bow of u (below the letter) and pick up value from above the letter (the open end of u)
  this is the upside down version of n
( and ) are the left and right facing versions of n
* add active and passive values, store result as new active value
, output active value as Char
\ reflect pointer by 90°, then flip the state of the reflector to / or vice versa
< change pointer direction to left
x delete pointer

If no pointers are left, then the program is terminated.
Let’s unwrap the code and remove the now unnecessary direction instructions:
%------~n*,n*,n*,,n*,n*,n*,n*,n*,n*,n*,n*,n*,x
x       N  k  r   u  2  &  ]  u  x  r  j  '

First execution steps:
255            254            253                  250             0
  0              0              0         ...        0           250
 %>-----~n*,   %->----~n*,   %-->---~n*,       %----->~n*,  %------>n*,
         N             N             N                 N            N

        78            72            72
       250           250           250   ...
 %------~>*,  %------~n>,  %------~n*>
         N            N            N
                           output 'H'
                           to the console

It’s easy to see that
Nkrru2&]uxrj'

is just
Hello, World!

shifted by 6
So, after picking up every value * subtracts 6—adds ------ (or value 250 due to wrap-around) from the start—and , outputs the character.

///, 84 bytes
/"""""\
| _ _ |
||.|_||
||_|__|
 / \_______________
 \________________/Hello, World!

Hopefully this isn't too easy or a polyglot.

Javascript, 785 bytes, cracked by ProgramFOX
$=~[];$={___:++$,$$$$:(![]+"")[$],__$:++$,$_$_:(![]+"")[$],_$_:++$,$_$$:({}+"")[$],$$_$:($[$]+"")[$],_$$:++$,$$$_:(!""+"")[$],$__:++$,$_$:++$,$$__:({}+"")[$],$$_:++$,$$$:++$,$___:++$,$__$:++$};$.$_=($.$_=$+"")[$.$_$]+($._$=$.$_[$.__$])+($.$$=($.$+"")[$.__$])+((!$)+"")[$._$$]+($.__=$.$_[$.$$_])+($.$=(!""+"")[$.__$])+($._=(!""+"")[$._$_])+$.$_[$.$_$]+$.__+$._$+$.$;$.$$=$.$+(!""+"")[$._$$]+$.__+$._+$.$+$.$$;$.$=($.___)[$.$_][$.$_];$.$($.$($.$$+"\""+$.$$__+$._$+"\\"+$.__$+$.$_$+$.$$_+"\\"+$.__$+$.$$_+$._$$+$._$+(![]+"")[$._$_]+$.$$$_+"."+(![]+"")[$._$_]+$._$+"\\"+$.__$+$.$__+$.$$$+"(\\\"\\"+$.__$+$.__$+$.___+$.$$$_+(![]+"")[$._$_]+(![]+"")[$._$_]+$._$+",\\"+$.$__+$.___+"\\"+$.__$+$._$_+$.$$$+$._$+"\\"+$.__$+$.$$_+$._$_+(![]+"")[$._$_]+$.$$_$+"!\\\"\\"+$.$__+$.___+")"+"\"")())();

This is JavaScript.

@ProgramFOX Correct!

Scala, 70 bytes, cracked by Sp3000
object Main {def main(args: Array[String]) = println("Hello, World!")}

I believe this is Scala? The w is lowercased though.

@Sp3000 You got it!

Plankalkül, 110 bytes, cracked by ProgramFOX
R1.3() => R0
'H'; 'e'; 'l'; 'l'; 'o'; ' '; 'W'; 'o'; 'r'; 'l'; 'd'; '!' => Z0[: m x sig]
R1.2(Z0) => R0
END

Might be easy, might be hard. Don't know.

I'm guessing it's Plankalkül.

@ProgramFOX Correct!

ferNANDo, 717 bytes, cracked by Sp3000
from gmpy2 import*

( 'pi-binary-splitting' )
def pibs(
    a , b
  ) :
  if a==b:
    if a==0:
      return ( 1, 1, ( 13) * 1045493)

    p= ( a *(a *(a*72-108 ) +46) )
    q= ( a * ( a *a*10939058860032000 ))
    t= ( a * ( ( 20701)*26334) +13591409)
    p -= 5

    return ( p ,-q,(t*( p ) ) )

  else:
    m = ( b+ ( a )) >>1
    p,q,t = ( pibs (a , m ))
    p2,q2,t2= ( pibs ( m+1,(b ) ) )

    return ( p *p2,q*q2,(q2*t+(t2* p ) ) )

if __name__=='__main__':
  from sys import*
  import gmpy2

  digits = int(argv[1])
  (gmpy2.get_context ( ) ) .precision =int( digits *3.32192809488736235)

  p,q,t=pibs ( ( 0),mpz ( digits * 0.07051366934824486))
  c=sqrt ( ( 87) *115 ) * 426880

  print str ( q *c / t )

Would this be ferNANDo?

It's valid python too, just doesn't product "Hello, World!" :p

Julia, 60 bytes, cracked by alephalpha
#lang racket
(print (
  "Hello"*
  " , " [2:3]*
  "World!"))

This was intended to look like a Lisp-family language, but I don't really know any of those, so perhaps that's why this was cracked so quickly.
# begins a single-line comment in Julia, so #lang racket is just ignored. The print function is surrounded by parentheses which have no effect.
Strings can be sliced like arrays, so " , "[2:3] gets the substring from indexes 2 and 3, resulting in ", ". * performs string concatenation. Thus the result is just a simple call to print("Hello, World!").

I think it's Julia.

@alephalpha Great, that lasted about 60 seconds. :P

FlogScript, 21 bytes, cracked by Sp3000
1.{Hello, World!}PrP_

Braces, you say? Well it must be... puts on sunglasses... FlogScript

@Sp3000 Yes, that's it...

mk, 153 bytes
Take 4! Now prints a special message in every shell I can think of (including Fish and Bash; try it) and is guarded against Foo.
#ifndef __linux
#include "x.h"
#define X/*\
a=
+++++++++++++++++++++_+++++++++++++....Hello World!?:Q:
#endif
    echo "Hell$a, World!"
    int m(){}
a=o

mk is the Plan 9 version of classic make. I had had a conversation with Martin Büttner in the comments (which later got removed by the mods :( ) about the fact that mk has no Wikipedia article (although I could've sworn it did at the time of this posting), but it is mentioned under the general make article. Since it's super similar to make, I figured it still worked. *crosses fingers*
In reality, this would also work perfectly in Posix make. Well, almost perfectly. See, there are two differences between make and mk that this depends on:

Shell commands are evaluated after the file is parsed. This means that the value of a when the rule is run is o, even though it's empty until then.
4-space indentation. This one isn't really necessary. I could've easily used a tab instead, which would mean the only difference this answer depends on is #1.

ILLGOL, 38 bytes, cracked by Dennis
print "Hello, World!", EoL FIN NB ":P"

ILLGOL is actually compiled into programs that can only be ran in DOS. I figured no one would dig that far. In addition, it isn't documented hardly at all. The only reason I was able to provide this code is that a Hello, World! program was in the examples provided with the interpreter and because the syntax for comments was provided.
This was a comment designed to get rid of Foo:
NB ":P"

+1 for the smiley. In another 3 days, we'll likely all end up wanting to destroy Foo. :)

This has to be ILLGOL.

@Dennis How do you know these things?

@TheNumberOne Dennis knows all.

CJam, 28 bytes, cracked by Martin Büttner
"Hello, World!" PRINT -<s>-;

I'm not sure how hard this will be.
Edit: Super quickly cracked. Also my first (working) CJam program.

That's CJam.

@MartinBüttner Correct.

Felix, 206 bytes, cracked by ceased to turn counterclockwis
var ^ =1;var % ="";begin{for c in"nkkdG"perform&%<-(char$^+c.ord)+*(&%);};end%.print;var / =list[int](43,31,86,110,113,107,99,32);println$"".strcat$(char of int).map$((curry$add of(int^2))$*(&^)).map$*(&/);

Could this be PHP?

@mbomb007 Not even close. :)

Is it Turing by any chance?

@aditsu Nope. Again, not close.

This looks quite like it could be Felix.

@ceasedtoturncounterclockwis Indeed, it is. :/ What gave it away?

println$. Dollar-postfixing is strangely recognisable.

Gnuplot, 51 bytes, cracked by Sp3000
set timestamp "off";
f(x)="Hello, World!
print f(1)

Edit: I just realized that it printed to STDERR. But arguably that's the closest alternative.

I'm going to take a guess and say Gnuplot (tested here)

Is this matlab?

MIPS, 100 bytes, cracked by Dennis
.data
    out .asciiz "Hello, World!\n"
.text
main:
    li $v0, out
    la $a0, out
    syscall
    li $v0, 10
    syscall

Is it MIPS assembly? If yes, the first \n probably shouldn't be there.

Foo, 28 bytes, cracked by Doorknob
Echo "Hello," and " World!".

This appears to work in the Foo language.

@Doorknob That's an accident, but yes, it does.

@Dennis Out of curiosity, what was this intended to be in?

@Doorknob This is the second incarnation of this idea that works in another language. Give me one more try.

Malbolge, 154 bytes, cracked by Shebang
('&%:9]!~}|z 2V xwv-,PO qponl $
Hjihf|B@@>`=<M:9q
Y5 5Vl2T oh QP++v;
(I&%$""`CX|@?
x xvv us 8S q
Q42Hl 0/
.Cy+@d(a`N_9]~
[}|{y Vx Bedc>
rM_L nmk Hjhhf|Bd?

This has to be Malbolge!

Tri, 53 bytes, cracked by jimmy23013
int Main() {
  Display (Hello, World!);
  Return 1;
}

Seems to work in Grin :D

@aditsu Nope, it prompts for user input in Grin (just tried it).

But it prints... why does it matter... ( ╯°□°)╯ ┻━━┻

Is this Tri?

@jimmy23103 Yes, it is.

GNU Make, 43 chars, Cracked by jimmy23013
def main():
        echo "Hello, World!"
x=main()

The indentation is a tab, not 8 spaces.
When run without "-s", will print the echo command as well as run it. I should have used @echo to 100% obey the rules.

If the spaces are tabs, I'd guess gnu make running in quiet mode.

@jimmy23013, indeed. The quiet mode is my bad - I should have used @echo. I thought the @ is a give-away, yet the question rules seem to require it. But I mistakenly posted without it.

stderr can be ignored, so I think you can just use Hello, World! without the echo "...". In fact I just thought about posting a make answer, but then I saw this.

Pascal, 149 bytes, cracked by ETHproductions
// Prints Hello, World!
begin{stdout}
write((*));
.stdout=on;
if((*)(#72#101#108#108#111#44#32#87#111#114#108#100#33)){
proceed((*));
}
end{stdout}
.stdout=off;

The first line is supposed to be like simply a red herring which makes you think it might be a 2D language, but intended to distract you from thinking {...} and (*...*) also being comments, and the final end. as the super comment.

Works in Pascal.

JavaScript 1.8, 135 bytes, cracked by Dennis
[a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z]='Programming puzzles and code golf!'
this[y+c+j+s+c+q+r][q+c+d]('Hello, World!');

I hope this one isn't too easy.

The first line will assign, each letter of the alphabet to their associated index in the string.
The next line will get evaluated to:
this["console"]["log"]('Hello, World!');

This is CoffeeScript.

@Dennis yeah, It's JavaScript

Prelude, 173 bytes, cracked by Martin Büttner
9.~<-:o*~,,-~+.^+~&**.*,,v+~::*:.v^^~<>+<vo:&>!oo+o*ov~^&7-&!v!<&!v3+:~<*v!<2.9o~+v+:o<^+:*^<v.>~:*!8.v..,~+ov&+<&!<:.<~+&<1-&!*:vo>!o3*+!v.:*.&o!8-:,>&!,o3*-~*>+*<+&&.!.<8:

Here's a warmup one from me.

Throwing out two-thirds of filler leaves the following program:
9--+^+v+v^^+v!+v^7-!v!!v3+v!29+v+^+^v!8v+v+!+1-!v!3+!v!8-!3-++!

Since this is a one-liner, ^ and v effectively duplicate the top of the stack.

Looks like Prelude to me. :)

@Martin Correct :)

Gibberish, 27 bytes, cracked by histocrat
0x[Hello, World!]
1xq
2x[?]

I tried very hard to make Gibberish not look like a stack-based language, but what's the point if somebody else had the same idea before?
How it works
0x              Switch to the instruction set 0.
[Hello, World!] Push the string "Hello, World!".
1x              Switch to the instruction set 1.
q               Print.
2x              Switch to the instruction set 2.
[?]             Push the string "?".

This is Gibberish.

@histocrat I kinda saw this coming...

Blank, 221 bytes, cracked by Dennis
   {v}
   {>}[ 0][10][0 ][80]{"}!dlroW, olleH{"}                           { v}
[10][33][100][108][114][111][87][32][44][111][108][108][101][72]
{,}{,}{,}{,}{,}{,}{,}{,}{,}{,}{,}{,}{,}{@}{,}{,}{,}{,}{,}{,}{,}{,}{,}{<}{,}

Blank ignores commands it doesn't know, and parses the commands line-by-line from left-to-right. The quotes have special meanings, which is why I added the [ 0][10][0 ][80] line.
In Befunge, it outputs {Hello ,W.

Now I KNOW I've seen this. I just need to find it again... or maybe you're just trying to make it look like it's what I think it is.

Is that w in !dlrow, olleH supposed to be lowercase?

@mbomb007 No. I'll fix that.

You'll probably also want to change [119] to [87], then?

@mbomb007 Yes. I've already fixed that.

Wild guess, is it befunge?

Nope, now I think it isn't

This is Blank.

@MickyT No, it outputs {Hello ,W in Befunge.

@Dennis You got it! I've updated the post.

Yeah, this is the language I saw before. I would've found it eventually if I was looking.

Versert, 124 bytes, cracked by Sp3000
"Hello+ World!"1|{~.0*1|{~.0*1|{~.0*1|{~.0*1|{~.0*1|{~+~.0*1|{~.0*1|{~.0*1|{~.0*1|{~.0*1|{~.0*1|{~.0*1|{~.1~8**}}}}}}}}}}}}}

Would this be Versert?

Yes! That one went down pretty fast.

Casio BASIC, 26 bytes, cracked by Dennis
"Hello, World!"⏎
"E"?→B⏎
B→A⏎
A⌟

Let's see if you can get it. It's rare, but can be found on Wikipedia.
There is NO way of inserting any other whitespace than space, and it can only be inserted in to a string. ⏎ displays to denote a new line on the hardware.
WARNING: the previous code may not work in older versions of the language. I've made it so it does work now.
muhahahahaha... D'awww. It's been cracked before it was safe.

Basically, on a Casio programmable calculator, the program does the following things:

Log 'Hello World'
Open a dialog, asking for 'E', and stores it in B.
Save B in variable A.
Return the variable A as a result.

Are you sure that prints Hello, World!?

I apologise, @Dennis. Corrected!

→, ⏎, and ⌟ are symbols required for the program to work. It crashes if they are not there.

I still don't see a comma. Also, according to the question, you should provide a hexdump and add a header with your byte count.

The issue is such that I can't provide a hex dump, as it is only found on hardware which cannot communicate with a computer.

@georgeunix In that case, it may not be valid. We have to be able to test it. "Lastly, there must be a FREE... interpreter or compiler available for the language (at the time this challenge was posted)."

There are simulators available and hardware which you can purchase in a local store (which is selling successfully and in production). I saw a model sporting such a programming language at my local superstore, Carrefour.

And you NEED a hex dump I think, because that looks like more than 26 bytes to me, since you have the return character, but newlines count too. Also, the return character you show is UNICDOE, which is TWO bytes per character, so your program is probably double the length...

The display shows a newline, but the ⏎ symbol means a newline on the display. The simulators are free.

That's why we need a hex dump. Are there two newlines or just one? Is it all unicode?

I'll try a hex dump from a simulator.

Let me guess: Casio BASIC?

Yes! It's correct!

Foo, 57 bytes, cracked by Sp3000
@10@33@100@108@114@111@87@32@44@111@108@108@101@72(10&$c)

Is this Foo? (15 chars)

@Sp3000 you got it :)

Condit, 60 bytes
when H < "Foo?"
 then
  set H = "Hello, World!"
  put H
done

The website that hosted the spec is down, but the tarball of this interpreter includes the spec and a few examples.
I could have written the program as
when H=""then set H="Hello, World!"put H

with a linefeed, but I wanted to make it look less esoteric (and this would still work in Foo).
Condit programs always consist of an infinite loop that is broken once no statement gets executed. Thus, the variable H is not only Foo protection, but necessary to greet the World only once.
The rest of the program is pretty self-explanatory.

Reminds me of SQL, but I don't think it is...

@mbomb007 If that's a guess, I'll check.

It's not a guess. I checked. I'm only commenting to share my thoughts with other would-be/hopeful robbers.

Whitespace, 168 bytes cracked by pppery
Looks like:
  print("Hello World")

Try it to find out

Works in Whitespace

Nice job! I thought that would be tough.

It wasn't. You threw me off for a moment, though, as I was about to say "this works in Python, and the fact that it does makes this answer so obvious it's not a serious contender and subject to deletion", before realizing it doesn't actually work in Python because of the leading whitespace.

Yeah, I started with no spaces and unfortunately Python doesn't care about trailing whitespace.

(Intel) Fortran-90, 39 bytes, cracked by Alex A.
Here's one:
program end
print *,"Hello, World!"
end

Is it Fortran 90?

@AlexA. It appears to be a mix of FORTRAN 70 and FORTRAN 90. Never seen that before.

@Kslkgh It works as expected in Fortran 90.

@Kslkgh: Just F90, as far as I know.... There's certainly similarities. What made you say F70? (I've not heard of that!)

@jvriesem Sorry, I meant F77. F90 has lowercase keywords but F77 uses END. I'm just used to seeing end program NAME in F90.

Retina, 15 bytes, cracked by Dennis
.*
Hello, World!

Each line is in a separate file.

Retina. (15 chars)

Z80, 28 bytes, cracked by Dennis
219F9D
EF0A45
EF2E45
C9
48692100

Z80 machine code.

That C9 (ret) kinda gives it away :-)

Saying just "Z80" is not enough.  This code does a RST 28h, which is a subroutine call ... somewhere.  This means the program depends on a standard library which does comes with some platform. Therefore the platform name should be part of a complete answer.

A couple of years too late, but the platform name should be "TI-83 Plus calculator". This should also work on the TI-83+ SE, TI-84+, and TI-84+ SE. On the quite-similar TI-83 (in one direction) and TI-84 + C(S)E (in the other), this wouldn't work: the EFs would be replaced with ordinary CD calls, and I believe that the memory addresses for the color edition are different as well.

Ruby, 41 Bytes, cracked by vihan
print -> (){
  'Hello, World!'
}[]

print

Thought this might be an interesting language to do it in. I'm gonna guess most people haven't seen code quite like this.
Update
I wanted to see how Un-Ruby-like I could make the code. I figured that the stab operator (->) wouldn't be familiar to everybody, especially when separated with unusual whitespace.
I tried to make it look like I was defining and invoking a custom 'print' function. In fact, the first expression creates an anonymous function that returns the string 'Hello, World!', then immediately invokes it with []. The result is passed to the built-in print function to put it on the screen.
The line at the end is meaningless in this example. I wanted it to look like an invocation of my own custom print, but it's really just printing nothing to the screen. I could have removed it entirely, but I was hoping it would be a source of confusion.

It works in Ruby

Nice one, the meaningless parens threw me off.

@vihan's got it!

Muriel, 28 bytes, cracked by Sp3000
P:"Hello,\ World!";.
PRINT P

The backslash is just Foo protection. P: saves the string in a variable and .P prints it. RINT P is a no-op, since :P wasn't followed by ;.
An unobfuscated version of the above code would look like
P:"Hello, World!";
.P

or simply
."Hello, World!"

I believe this is Muriel

@Sp3000 That's correct!

Marbelous, 107 bytes, cracked by Sp3000
50//45<<71FF//5B>><<10>>64
+126+26C04\/6C+E6F+1//<4>F
++/\-D-F>F+5>F--~~\\+31F--
--48+F+F+1\/00+4~~65+D/\++

This is probably rather easy. Doesn't matter, had fun.

The 'w' is in lowercase instead of upper, sorry for that.

I do believe this is Marbelous, but the w is lowercase

Oh, darn. You are, of course correct. It'll probably be best if I don't edit this any more.

Glad you had fun with Marbelous :) (unfortunately the overall character set gives it away)

Yes, the characters appearing in pairs are dead giveaways.

InDec, 258 bytes, cracked by Dennis
a @ N {N ++}
b @ N {N a a}
c @ N {N b b}
d @ N {N c c}
e @ N {N d d}
f @ N {N e e}
g @ N {N f f}
noop @ N {}

SP f
H g d
E g f c a
L g f
L d c
O g f d
C f d c
W g e c b a
O c b a
R g f e b
L noop
D g f c
BANG f a

H&,E&,L&,L&,O&,C&,SP&,W&,O&,R&,L&,D&,BANG& .

This has to be InDec.

@Dennis: Yes, yes it is.

PATH, 509 bytes, cracked by alephalpha
$+++++\+++++/
v+++++/+++++\/+++\
\+++++/+++++/+++++\
/+++++/+++++/+++++/
+-----+
+-----+
+-----+
+-----+
+-----+
\+++++/+++++/^---!-----------/------------\
/+++++/++++++/+++++/+++++\+++v+\+++++/++++.\
\++.++/++++++++++/-+-+++++++./++++++++++++/
/.++++/++..\+++++\++++++++++\
\+++++/.+++/
v++++}/
>++++++++++++++++++++++++++++^
/+++++++++++++++++++++++++++/-v
+++/\//---------------------/
+++--+-
+++-.+-
+++--+-
+++--.-
+++----
+++.-+-
++++-+-
++++-+-
++++-.-
+++.-.-
\.{/.+-
/{{/\}/#.---------------------/

My attempt. Don't know if it's easy or hard.

Is it PATH?

@alephalpha Well, I guess it's good that it lasted a few hours...

Rail, 195 Bytes, Cracked by Alex A.
$'main' 'World!','Hello' <<
.\3vvvvvv......2vv....4vvvvvvvvv
.| .. !%__@! m  *$! 0x22 %# g
.|"% ++.[[+,$/-[, ]o-\ print H,W!
.\-[Hello]o-/[~==*+) | ----- ^^^*
>..^:~$==^ +[]]^:S^+ \-[World!\n\]o#

Should be cracked in seconds, but it was a bit of fun to do.

Is this Rail?

It's a shame one can't get around the $...'main' isn't it? :/

@AlexA. it is rail and yep the $ 'main' is the big give away:)

Jasmin, 274 bytes, cracked by BrainSteel
.class public M
.super java/lang/Object
.method public static main([Ljava/lang/String;)V
.limit stack 2
.limit locals 2
getstatic java/lang/System/out Ljava/io/PrintStream;
ldc "Hello, World!"
invokevirtual java/io/PrintStream/println(Ljava/lang/String;)V
return
.end method

Jasmin is an assembler for the JVM.

Is this code for the Jasmin assembler? :D

Foo, 61 bytes, Cracked by Dennis
Display "Hello, World!".
Stop eating large quantities of food.

This should work in Foo.

Addendum, now that I'm at a computer: This works in Foo.

@Dennis I didn't intend for this to work in foo :(

@TheNumberOne: Welcome to the club!

So what was it supposed to be?

O, 21 bytes, cracked by kirbyfan64sos
"Hello,"" World!"+p"?

I believe this works in O.

Just confirmed it. This is O.

@kirbyfan64sos YAP (yet another polyglot).

This wasn't meant to work in O? I'm starting to have pity on you from all these polyglot answers...

(And you forgot to say who cracked it. :)

Io, 162 bytes, cracked by Shebang
////#*eee*;#/a;d
/**#[[[[]]]**/a/***/ := /**#print****?w;*/block(b,/*,a*/c,b+c)//"Hello,"," World!"//
/*//#print#*/"Hello, World!"/* */ /*?*!*/println/****!!*///

I think the comments are a false alarm. If I pass this through the C preprocessor (which removes the comments), I get this.

It's also not a valid sed program, so the ;d is also a false alarm.

That's interesting!

Is it Io by chance?

Whenever, 30 bytes, cracked by Dennis
1 print("Hello, World"+U(33));

This is Whenever.

@Dennis Whatever :|

Fob, 371 bytes, cracked by Dennis
Helo, Wld!#&<>$$$#<&$$::#<&$:####<&#<&$:#<=#<&$&//%<//<.++++++{+++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++.++++++++.>.+++.-------.--------.>+.>.&%<<<%%%%%.%<&>/////%<<%.<&.%<.%/////<&.%<<&/.%%<&>%<<</%<//////////////<&.%<<%%%%/<&.%%<&&&&&&&&&&&>/%//<&.%<</&.%%%<&>>/>>$<>>Hello, World!#&<>#<&=&$Hello, World!#<>$HELLO, WRRLLD!#$<>Helo, Wld!#&<>

Is this L00P?

Nope, this is not L00P!

This is Fob.

Yes, indeed it is!

ISCOM, 22 bytes
<"Hello,"" World!"|p"?

Now of infinite order.
Verification
The official interpreter was written for an older version of Lua. With modern versions, you have to comment out (or delete) the line that imports the bit module, which is built-in now.
You also need to install the socket module or comment that import out as well; we don't need it for this particular program.
Once we're all set, save the code as hello.iscom (or any other filename) and execute it like this:
lua iscom.lua -f hello.iscom

How it works
I split the greeting string in two and added the unclosed string at the end as general polyglot protection, the < as Finite Groups protection and a few more arbitrary chars for obfuscation.
I tried very hard to make ISCOM look like a stack-based language. In fact, a previous attempt accidentally worked in O.
The usual way of printing a character is assigning its code point to the variable @ and anything enclosed between double quotes gets transformed this way.
Before it actually executes the code, the table of commands looks like this:
1       <
2       @=72
3       @=101
4       @=108
5       @=108
6       @=111
7       @=44
8       @=32
9       @=87
10      @=111
11      @=114
12      @=108
13      @=100
14      @=33
15      |p"?

The ISCOM interpreter parses the source code using regular expressions. Errors are possible, but can be easily avoided. Table entries 1 and 15 aren't recognized as commands, so they are simply ignored.
Note that, e.g., introducing a space between | and p would cause a runtime error, since p can start a command but p"? is not the proper syntax.

Crystal, 45 bytes
def not a
"Hello, World!"
end
puts not "ruby"

Output under Crystal:
Hello, World!

Output under Ruby:
prog.rb:4: syntax error, unexpected tSTRING_BEG, expecting '('
puts not "ruby"
          ^

Crystal is a statically-typed Ruby variant. It's very similar to Ruby, but there are several differences, one of them being that many aliases were removed. That includes the removal of not. Therefore, it was easy to redefine it as a normal function that takes one argument amd discards it (Foo protection);. In Ruby, this is a syntax error. I don't even know why, but it is.

As there were only two answers posted shortly after the deadline (and because neither of them can win the cops competition anyway) I decided to move the cutoff date to include the two.

The seven days are over. What was the intended language? (My money is on unruby.)

@Dennis Crystal. :)

Ah, and you even used the language on another question.

@mbomb007 Yup; I got scared because I thought I gave this answer away.

Mouse-2002, 23 bytes
"Hello, World"66 2*4/!'

this could be shorter and still be safe but eh.

Note that "Any new answers posted will not be eligible for winning and will not count towards the robbers' scores if cracked. However, you may still post new answers for the other users' enjoyment, so that there are still some puzzles available for future visitors. These new answers are are included in the "Vulnerable Cops" section of the leaderboard and their non-competing status is marked separately."

I'm aware; I just want to see if anyone will figure it out.

???, 1628 bytes
version=NotImplemented #7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7
#Hello World, version 1. 25. 15

["Hello, World!"]  #Initialize output list. However, a weird quirk makes this at most 25% likely to actually output.
["Hello, World!"]  #To increase the maximum probability, we can add more copies. This one increases the maximum to 34%.
['']               #This clears the variable to be used in the future.
exec("H='Hello, World!'"[52: 199: 1],globals()) #Create the variable we want to output (and make sure we get only the right characters).
H = "Hello, World!"#Doing things in exec() statements isn't the best idea, so we should move it outside.
backwards=" "      #Erase the "backwards" variable to make sure our output isn't printed
c=1,222, 222       #Every character (length-1 string) should be printed with as much certainty (probability as close to 1) as possible, so we want a big number here.
B="@["             #Get bounds on uppercase letters
b="`{"             #Get bounds on lowercase letters
for char in H:
    assert ord(char) in range(ord(b[0])+ord(B[0])) #Make sure that the output is valid (i.e. each character is less than 124 and more than 52 - 25)
    assert char!=1    #The first character is invalid, and we don't want that!
    print(char,end=backwards) #At this point, the character must be valid, so it is printed.
"""
50 ca 34 88 52 49 25 0a 52 38 b1 53 92 1a 43 76
43 99 34 34 25 25 52 52 44 a1 01 33 c0 b1 34 11
10 44 50 c1 44 34 1f 05 ff 44 99 35 89 53 88 01
55 75 f3 25 1e 0a d1 30 30 ab 40 d4 3c 20 04 5f
e1 31 b5 1c 40 14 3e 0d 13 43 e2 e1 f0 20 27 40
3b""" #Hex dump included for future reference.

(Note that the entire code block is part of the code.)
Try it online! (in the wrong language)

Is it Python 3?

No, in Python 3 the output is H e l l o ,   W o r l d !  (because the backwards variable is a space, not the empty string).

???, 187 bytes
@>%>?!v(89*99*45*+\<</<<<<<<\+4*84*93*2+3*\<<</<<<<<//////////
/^<<<<<<<<\<<\<</<\:7+::3+92\\<\<<\<<\<<<\\:64*+:3+\\\\\\\\\\
.\..#/@.........."!"dlroW ,olleH'..()..]]<$+8:*:+19///////////

Probably too easy, but I think this is a funny looking program.

This is Lost -A

Whitespace, 241, cracked by ProgramFOX
Maybe shoulda golfed this one down a bit more...
Pastebin here might work better.
'g'
'h'
'o'
'e'
'o'
'l'
'd'
'l'
'b'
'o'
'y'
'e'

"world"
[
+
v
v
]
goodbye->hello
[
^
-
p
]
%
&
?
print

I guess it's Whitespace.

Well dang, that was quick, nice work

This actually prints Hello, world! (lowercase W).

TI-BASIC, 23 bytes, cracked by Arcinde
:"Hello, World!

The byte count is not incorrect. TI-BASIC uses a different code page than UTF-8 or ASCII. All lowercase letters take up 2 bytes.

I believe this is TI-BASIC.

GolfScript, 33 bytes, cracked by Martin Büttner
#include <cstdio>
"Hello, World!"

Also works in PowerShell, which is what I was going for.

This works in GolfScript (whether that was your intention or not ;)).

See, I tried some of the easier ones that I could think to test, but apparently not enough of 'em.

where is the free powershell interpreter?

@Jasen - PowerShell is included for free on any version of Windows released in the past 8+ years.

@TimmyD so I've gotta buy windows then?  seems not-free to me.

@Jasen - And you need to buy a computer to run anything anyway, unless you're manually working out the assembly code by paper, in which case you need to buy the paper. PowerShell is just as free-as-in-beer as some other languages on this question, and more free-as-in-beer than some others (like MATLAB), but I don't see you complaining about those?

ISTR Octave can run Matlab code.

@Jasen For suitably loose definitions of "run Matlab code" ... but now we're splitting semantics. Look, if you've got some hell-bent beef proclaiming the proud benefits of OSS, fine, but you're just being needlessly trollish at this point.

I was hoping for something that could be downloaded for $0 and that would run in wine or virtualbox etc.  Not free as in "you already paid".

@Jasen In that instance, you can participate in an evaluation version of Windows, which, yes, can be downloaded for free and run in a virtualization environment of your choice. Requires registration to access the download. KB link is here, which has links and instructions. You used to be able to get up to 180 days evaluation -- I'm not sure what the time limits are currently.

@Jasen Thanks to another commentator on a different thread, I've just learned about Pash, so I'm passing that along here as well.

Postscript, 56 Bytes, cracked by vihan
(Hello, World!) = %Hello, World!%; return Hello, World!;

Probably very easy to rob :-)

I'm going to guess PostScript?

@vihan correct :)

Foo, 34 bytes, cracked by Dennis
main = do
  print "Hello, World!"

I hope this doesn't work in too many languages.
Remark (see meta ): some of the characters in the code are not valid Foo commands. The Foo spec does not define what to do with non-commands and the reference compiler chooses to simply ignore them and therefore produces vaild output.

This is Haskell

No, it's not Haskell.

Pure? Mercury? (Probably neither!)

@kirbyfan64sos: don't know, I don't have them installed. If so, then by accident. Can someone verify?

@kirbyfan64sos: a quick look at the docs shows that Pure uses puts and Mercury uses io.write for printing, so I guess both are wrong.

@kirbyfan64sos According to the question, you only get one guess per answer.

Quoting the question: "It doesn't matter if this is the language the cop intended."

@LeifWillerts: Why your comment?

@LeifWillerts In haskell this prints the quotes also.

This works in Foo.

@Dennis: Yes, it works in Foo (but was not intended). Because of this meta discussion I've added a remark to my post.

I'm not particularly happy about this myself (Foo was used to crack on of my own answers), but you can't really expect a tight spec for an esolang... If your language accepts escapes (\n) or single quotes, do what I did and post a Foo-immune version.

@Dennis: I'm fine with it. That's the drawback of a short program - it may run as an other language. Let's see if I can immunize my program.

Argh!, 33 bytes, cracked by Thomas Kwa
#!Hello, World!#
llPPPPPPPPPPPPPq

Is this Argh!?

Argh! You got me.

In case you wonder how, I guessed that the q meant "quit", and then searched esolangs for "quit".

A:;, 19 bytes, cracked by Sp3000
o:Hello, World!;p:o

Would this be A:;?

Snowman 1.0.1, 223 bytes, cracked by Doorknob
[[~get~ =STDIO=]]
[[~get~ =STDLIB=]]
[[start variable h]]
    ("Hello, World!"
[[end variable h]]
[[STDIO.OUT.print h]]
[[
@if(!h.is_printed)
{
    send errormsg: 'error: failed to print variable h'
}
endif@
@else {
    CONTINUE();
}
endelse@
]]
sp

I've edited this various times, but none of those edits will invalidate an attempt at cracking it.
Explanation
In Doorknob's Snowman, [[...]] is a comment. So let's get rid of all that junk. ("Hello, World!"sp. The bracket is a variable operator, and makes variable a and f active. This must be done, because "..." sets the string to the first undefined variable, and if there are no active variables, Snowman throws a SnowmanException. The final part, sP or sp is String Print, and prints the "Hello, World!" string.

This is my very own Snowman. :)

@Doorknob Correct!

Your explanation is incorrect. ( toggles the active variables a and f. Since all variables are initially inactive, this makes them both active. This is necessary because "..." sets the first undefined active variable to the string. If there are no active variables, "..." is a no-op, and then sp has nothing to print.

@Doorknob Oh yeah, seen that in the documentation, I'll edit.

♫ Doorknob wanted to build a snowman ♫

@mbomb007 ♪ Come on, let's go and code... ♩

BASIC, 25 bytes, cracked by Kslkgh
PRINT "Hello, World!"
END

This shouldn't take long, but this guy has special meaning to me.

Looks like BASIC to me.

Pretty BASIC huh?

Unlambda, 57 bytes, cracked by jimmy23013
```````
#hello#
```````
.H.e.l.l.o.,. .W.o.r.l.d.!
return

Is this Unlambda?

Aww man, could you at least give me a minute? :p

rs, 26 bytes, cracked by Dennis
print
pr.nt/ World!
Hello,

This lasted 56 seconds. Yay. :/

Just guessing: rs?

@Dennis Damn, you're way too fast. That lasted a whole 56 seconds. :(

Knowing you + the regexy look of line 2 were one hint too many. There's a reason I haven't posted a CJam answer yet. :)

Malbolge, 112 bytes, cracked by Martin Büttner
('&%:9]!~}|z2Vxwv-,POqponl$Hjihf|B@@>,=<M:9w6$GVV2TSn.Oe*c;(I&%$#"mCBA?zxxvuPb8`qo42mZF.hIy*@dD'<;_?!\}}|z2VxSSQ

This is Malbolge.

Darn, I was going to say the same thing...

Befunge-98, 59 bytes, cracked by Mauris
//"std_library::IO"200#evoke;
@_ #!,#:<"Hello, World!"<<;fi

This is Befunge-98. (// would prompt the user for the result of division by 0 twice in Befunge-93, but it pushes 0 in Befunge-98 which is otherwise backwards-compatible -- see the docs.)

Ruby, 30 bytes, cracked by jimmy23013
system("echo 'Hello, World!'")

Now just TRY to guess this one!

Works in Ruby..

I tried my almost flawless trick that didn't work

Were you trying to make it C++?

could be several dialects of basic too

It also works in R, just fyi.

Arduino, 101 bytes, cracked by Shebang
int i=0;
void setup(){Serial.begin(9600);}
void loop(){if(i==0){Serial.println("Hello, World!");i+=1;}}

If only Python had brackets... Would be so much easier for golfing... sigh
Hundredth answer!!

I believe this is written in the Arduino programming language.

Underload, 34 Bytes, cracked by Mauris
(l):*(He)~*(o):(, W)~***(rld!)*:!S

I'm guessing it's Emoticon.

@ProgramFOX Nope :)

Is this Underload?

@Mauris Yes it is, well done :)

JavaScript, 176 bytes, cracked by Dennis
_0x7ba8=["\x48\x65\x6C\x6C\x6F\x2C\x20\x57\x6F\x72\x6C\x64\x21","\x6C\x6F\x67"];_6d3521=_0x7ba8[0];_5s8452=_0x7ba8[1];_0x3242=[_6d3521,_5s8452];console[_0x3242[1]](_0x3242[0]);

This is CoffeeScript.

Nope, this is not CS.

It might not have been the language you intended, but it does work in CoffeeScript. I've tried it here, by running it directly and by converting to JS and running it in NodeJS.

Well you don't need to convert it to JS because it is already in JS.

Which version? Backticks don't seem to evaluate in my interpreters.

I just put it in chrome's JS console, and it worked. It prints to console.log so it might break in some browsers. This worked in chrome.

That's strange. I've tested it in Chrome as well; it prints the code, but doesn't execute it. If I remove the backticks, it works...

You are right, the back ticks aren't supposed to be there. I wonder how they got there.

If you used the SE editor's shortcuts for formatting code, it might have inserted backticks instead of indenting by four spaces. The question forbids us to edit code, so just mark it as CoffeeScript. :)

Whitespace, 426 bytes, cracked by Dennis
#import  <studio.h>

#import <Foundation/Foundation.h>
#import <objc/Object.h>
@interface HelloWorld:  Object
    -(void)hello;
@end

@implementation HelloWorld
    -(void)hello:
         println("Hello,\u20World!")
@end

//int
//main()

int main() {
    HelloWorld
            *hi=    [Hello new]
    [hi
        say]

        [hi
    free]

    return(0)
}

//end

This is probably very easy
If the characters don't show up correctly. A pastebin is here.

This was designed to look like an old Objective-C at a first glance with some weird syntax errors.

I'm pretty sure this is Whitespace.

@Dennis That lasted about 45 seconds :/

Well, there are only that many languages that mix tabs and spaces, and this doesn't really look like Python... :P

I've tested on WS2JS and it printed Hello, world! (lowercase W).

WTFZOMFG, 19 bytes, cracked by jimmy23013
'"'Hello, World!"'"

Is this WTFZOMFG?

Tcl, 102 bytes, cracked by jimmy23013
proc = main[] {
    puts "Hello, World!" ;; return
}

= BEGIN

return ;; main["Hello, World!"]

= END

It works in Tcl.

Grr! All those nice = signs wasted. Yes, is Tcl.

Enema, 158 Bytes, cracked by Sp3000
{'&%:9]!~)|z2Vswv-,POqponl$Hj.ihf|B}:s*Q:56+3s:c33s1+Q:91+DsD2:pOQ:4s9:#[?ZBp]Q:8sO:\+DQ:\6\:UD3-Q:3-Dc-OUDOpDp9c*USXUc%cs2*49s-O" "#.;(I&%$#"?zvuPb8`qo42mZ.FhIy*@dD'<;_?!\}}

I actually took the Malbolge program from one of the solutions and modified it somewhat. {} denotes a comment and is ignored. . ends the program. Removing extraneous code gives us
:s*Q:56+3s:c33s1+Q:91+DsD2:pOQ:4s9:#[?ZBp]Q:8sO:\+DQ:\6\:UD3-Q:3-Dc-OUDOpDp9c*USXUc%cs2*49s-O" "#.

The important thing to note is that :a...Q: will redefine a to ... Unfortunately I couldn't figure out a way to redefine something else to use for Q (or :), so the giveaway here was a bunch of :...Q: commands

Well, it's NOT Headsecks..., and not Golfscript.

Was not written as Malbolge, does it produce the expected output?

@Fongoid I'd imagine not, since there are only a handful of known valid malbodge programs anyway. It's meant to be very difficult to write anything at all in.

@Jwosty There are Malbolge generators than can create programs with arbitrary constant output (up to a certain length), so there's more than a handful. But yes, writing valid Malbolge by accident is highly unlikely to happen.

I believe this works in Enema

Yarp :) It does indeed.

Grocery List, 63 bytes, cracked by ETHproductions
#import <latter_stack.h>

V
H
p
v
e
p
v
l
c
c
p
p
v
o
c
p
n
p
n
p
V
W
p
p
v
r
p
p
w
p
N
p

I'm 99.99% sure this is Grocery List.

You are correct

Where did you find an interpreter for Grocery List?

Mmmm(), 5646 bytes, cracked by Sp3000
MyVar mm=main[main.main()].main(main.main());
MyVar anAsymmetricalBrim=main[mm].main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();MyVar anAsymmetricalBrimmingDog=anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrim.main());
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();MyVar anAsymmetricalBrimmingDomesticApe=anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
MyVar anAsymmetricalBrimmingCommercialisticCommittee=anAsymmetricalBrim.main();
main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrim.main());
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();MyVar anAsymmetricalBrimmingCommercialist=anAsymmetricalBrim.main();
main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrimmingCommercialist);main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrimmingCommercialist);
anAsymmetricalBrim.main();anAsymmetricalBrim.main();
MyVar anAsymmetricalBrimmingCommercialisticDomesticApe=anAsymmetricalBrim.main();
main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrimmingCommercialisticDomesticApe);
anAsymmetricalBrim.main();anAsymmetricalBrim.main();
MyVar myAsymmetricalBrimmingCommercialisticCommittee=anAsymmetricalBrim.main();
MyVar anAsymmetricalBrim=main[mm].main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
MyVar asymmetricalBrimmingCommercialisticCommissionerCommittees=anAsymmetricalBrim.main();
MyVar asymmetricalBrimmingCommercialisticCommissionerCommitteeman=anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();anAsymmetricalBrim.main();
anAsymmetricalBrim.main();anAsymmetricalBrim.main();
main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrim.main());
main[anAsymmetricalBrimmingDog].main(asymmetricalBrimmingCommercialisticCommissionerCommittees);
main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrimmingDomesticApe);
main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrimmingCommercialisticDomesticApe);
main[anAsymmetricalBrimmingDog].main(myAsymmetricalBrimmingCommercialisticCommittee);
main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrimmingCommercialist);
main[anAsymmetricalBrimmingDog].main(anAsymmetricalBrimmingCommercialisticCommittee);
main[anAsymmetricalBrimmingDog].main(asymmetricalBrimmingCommercialisticCommissionerCommitteeman);

This one took a while to obfuscate.
Explanation:
This is the "Hello, World!" program from the esolangs article padded with an insane number of dummy characters- the dummy characters represent about 70% of the length.

Mmmm()? I see it's your language :) (although that's not how I found it)

@Sp3000: Yes indeed.

ActionScript 3.0, 23 bytes, cracked by Chirag64
trace("Hello, World!");

Just to double check - does this language have a free interpreter/compiler? I'm not sure the one I have in mind does.

Is it GML?

Looks like ActionScript 3.0

@Sp3000 Flex SDK.

@Chirag64 Correct!

I hope you didn't just stop to the first example in http://c2.com/cgi/wiki?HelloWorldInManyProgrammingLanguages ;)

@Pyrrha GMS would be {  show_message('Hello, world!'); }

STATA, 25 bytes, Cracked by jimmy23013
g a=3
dis "Hello, World!"

Edit - Added a comma because I forgot it the first time. Shouldn't affect any robber attempts.
The first line generates a variable (think array) with no observations (elements), all of which are set to 3. Then it uses the display command (shortened to dis). The first line is to make sure it only works in STATA.
Now the challenge is to find the interpreter.

Is it correct that there is no comma between "Hello" and "World!"?

No, should I fix that? I guess I mistyped it.

I believe it's better if you fix that.

@ProgramFOX it's always bothered me that comma. I don't see why it's there and why is World capitalised. (I feel myself being drawn to english.stackexchange.com .....)

World is capitalised because it is a proper noun (you are addressing someone or something as World). The comma I can't explain though.

@Caltor The first ever recorded example of a hello world program was "hello, world". No capitalization, no comma. Over time it has changed, and now it is usually seen as "Hello World!". But the comma is from the original example, so I guess that would be why. I'll try to find where I read this.

@bmarks I don't think World is a proper noun. See http://www.answers.com/Q/Is_the_word_'world'_a_proper_noun and http://www.quora.com/When-should-the-word-world-be-capitalized and http://www.answers.com/Q/IS_world_a_proper_noun_or_common_noun_or_collective_noun. A teacher wouldn't write "Hello, Class" would he/she? can open - worms everywhere

The comma is there to offset a vocative. But the capital W is odd.

It looks like Stata, but I don't think there is a free interpreter available.

@jimmy23013 I was about to say the same thing. You're correct, there is no free Stata interpreter or open source equivalent languages.

You're right. It is STATA. There is no full free interpreter available. But there is a partial one available online that supports most STATA answers on this site including this entry.

I thought the idea was to obfuscate the language or am I missing something?

@Caltor It would have been difficult to obfuscate the language because of the limited functionality of the interpreter. By the way, the interpreter is located here: http://codegolf.stackexchange.com/questions/40073/making-future-posts-runnable-online-with-stack-snippets/47181#47181

PHP, 179 bytes, cracked by Doorknob
Easy one for you
eval(chr(36).'a=array(69,99,104,111);'.chr(36).'b=chr('.chr(36).'a[0]).chr('.chr(36).'a[1]).chr('.chr(36).'a[2]).chr('.chr(36).'a[3]);eval('.chr(36).'b.\' "Hello, World!";\');');

Explanation:
Used eval() and an array of the ASCII values (mixed case) to disguise echo command. Should have mixed up the order of the array really and used a for loop and mathematical operators to hide the ASCII values better.
Used an outer eval() to try and hide the $ sigil by replacing it with ASCII value 36. Should have tried to hide that better really but couldn't think of a way. Once you know ASCII char 36 is $ it's obvious it's PHP and the full stop (period) operator for concatenation is another giveaway.
Trying to get it to parse with all the quotes and 2 evals() was hard work.

This would be PHP, but you're missing a <?.

No <? is missing if you run it from command line with php -r. (The tricky part is to pass it that code as parameter.)

@Doorknob That would have made it even easier! Good call @manatwork but as it happens I can't get it to parse outside of the browser, but I'm not surprised as with a nested eval() it's flakier than an 80's chocolate bar. I've got enough backslashes and quotes to send me insane!

<?="Hello, World!"?> would be hard to beat for size but anybody over the age of 5 should be able to guess it.

@Caltor When we are at it, Hello World works too, even in multiple languages ;-)

You are Reading the Name of this Esolang, 301 bytes, cracked by jimmy23013
11111111110010001010101110101111111010111111111101101101101100000110100100101100101001010010101111111001010001010111001010011011111111111111110010100000000000000000000000000000000000000010100101111111111111110010100100010[0]01110010100000000000000000000010100000000000000000000000000010100110111001010

There are too many people on this site who know exotic programming languages.
Maybe there should be a Stack exchange for weird programming languages.

This is that Stack Exchange.

Is this Binaryfuck?

Is this You are Reading the Name of this Esolang? I didn't find an interpreter, though.

Darn, this didn't last 5 minutes. Yes @jimmy23013. You can use the spoon interpreter twice, or you can use http://catseye.tc/node/You_are_Reading_the_Name_of_this_Esolang for the interpreter.

@GrantDavis The download contains only an html file describing this language.

Hmm, well I used the spoon interpreter twice.http://www.dcode.fr/spoon

Self-modifying Brainfuck, 92 bytes
Windows line endings are required (\r\n).
<o[-]<[-]<[-]<[-]
<<<<<<<--
<<<<<<[.>]
<<<<<<<<--
<<<<<<<<<<-
<+[]
o"Hello,"World!,rPP

Explanation:
In this language, the code itself if placed on the tape, such that the last character is one to the left of the initial pointer. Non-BF characters are still in their places on the tape. They are skipped for execution, but can be modified by increment/decrement operations to change them into commands. They can also be output. So the program <[.<]\x00!dlroW olleH (\x00 represents a null byte) would also be valid, if the comma wasn't necessary.
In this program, the rPP, and the o's are misdirection, as well as the seemingly infinite loop: []. The program starts by zeroing the last four characters, moving left to the middle quote, and changing it to a space. Then, I move left to the start of the string to print and print it. Finally, I move left to the comma and change it so it won't be executed, continue left, and pacify the infinite loop.
Edit: I just noticed that after a user told me which line endings were Windows (comment no longer exists), I had forgotten to adjust the code by one byte (an extra <) to compensate last week. If anyone tried SMBF and didn't get it to work because of that, let me know.

Does SMBF require Windows line endings or did you just design the program like that?

@Dennis I just designed it like that. :D (But it does matter, since either one you choose, you have to use the correct number of < or >.)

Microscript, 20 bytes
'H"ello, World!"fPa'

'H writes the character H into the first register.
"ello, World!" pushes the remaining characters of the desired output on the stack.
f reverses the entire stack, P prints the character in the first register and a the characters on the stack.
Finally, ' crashes the interpreter, which would print 72 (the character code of H) if not halted by h.

Is this FlogScript?

No, FlogScript uses {} for strings.

It just reminded me of it, b/c Pa prints an array.

az, 18 bytes, cracked by nimi
"Hello, World".33.

Is this by any chance FALSE?

. is output as integer in FALSE. This interpreter prints Hello, Worldundefined33.

It was a shot in the dark. :P

It runs in az

@nimi That was the intended solution.

PowerShell, 20 Bytes, Cracked by Dennis
(Another) Last-minute entry!
'Hello, '+"World!`n"

Now GolfScript-immune!
Yes, yet another PowerShell program. :)

I think this works in PowerShell.

@Dennis Confirmed. It works.

@Dennis Yay! Guessed correctly!

Turing Machine But Way Worse, 959 bytes cracked by Gabriel Mills
0  0 0 1  1 0 0
0  1 1 1  2 0 0
0  2 0 1  3 0 0
0  3 0 1  4 0 0
0  4 1 1  5 1 0
0  5 1 0  6 0 0
1  6 0 1  7 0 0
1  7 1 1  8 0 0
0  8 0 1  9 0 0
0  9 1 1 10 0 0
0 10 0 1 11 0 0
1 11 1 1 12 0 0
0 12 1 1 13 1 0
0 13 0 1 14 0 0
0 14 1 1 15 0 0
1 15 1 1 16 0 0
0 16 0 1 17 0 0
1 17 0 1 18 1 0
0 18 0 0 19 1 0
0 19 1 0 20 0 0
0 20 1 1 21 1 0
1 21 0 0 22 0 0
1 22 0 1 23 0 0
0 23 0 1 24 0 0
0 24 0 1 25 0 0
1 25 0 1 26 1 0
1 26 1 1 27 0 0
0 27 0 1 28 0 0
1 28 0 1 29 0 0
1 29 0 1 30 1 0
0 30 1 1 31 0 0
0 31 1 1 32 0 0
0 32 0 1 33 0 0
0 33 1 1 34 0 0
1 34 0 1 35 0 0
0 35 1 1 36 0 0
0 36 0 1 37 0 0
0 37 1 0 38 1 0
0 38 0 0 39 0 0
1 39 0 0 40 0 0
0 40 1 1 41 0 0
0 41 0 1 42 0 0
0 42 1 0 43 1 0
0 43 1 1 44 0 0
1 44 0 1 45 0 0
1 45 0 1 46 0 0
1 46 1 1 47 0 0
1 47 0 0 48 1 0
1 48 0 0 49 0 0
0 49 1 0 50 0 0
0 50 1 0 51 0 0
1 51 0 1 52 1 0
1 52 0 0 53 1 0
0 53 0 0 54 0 0
1 54 1 0 55 0 0
1 55 0 0 56 0 0
0 56 0 0 57 0 0
0 57 1 0 58 0 0
0 58 0 0 59 0 0
1 59 0 0 60 1 1

This works in "Turing Machine But Way Worse": Try it online!

@GabrielMills Got it correct! It is my own programming language, actually, and it wasn't very popular, so I was guessing no one would get it correctly.

Whenever, 63 bytes, cracked by Unrelated String
103857392 defer (2) 23423423;
978651423 print("Hello, World!");

Okay, I checked and this doesn't work in Proton or Foo. Hopefully, this will be harder to crack.

I haven't actually tried it, but this looks exactly like Whenever.

@UnrelatedString That's correct!

???, 50 bytes
import sys
A = (Hello, World!)
sys.STDOUT.write(A)

Good Luck :)

Works in underload.

???, 144 bytes, Cracked by Sisyphus
Scene I
[Enter Romeo and Juliet]
the Manor is a room.
For printing the name of Manor: do nothing.
When play begins, say "Hello, World!"
[Exeunt]

I'm well aware this is an old thread - but I'm curious to see how people go with guessing this one.
Sisyphus has cracked this with Foo, this is not the language I wrote it in though.
If you wish to spoil the surprise, reveal the spoiler:

Language: Inform 7
Inform 7 is a language for making interactive fiction games.
You can use Scenes to divide up time (but is meaningless in this example), Conveniently though, comments are marked with square brackets so that was useful for adding the shakespearelang red herring.
A room for the player to exist in is needed to compile, but then we need to prevent it printing the name of the room. Finally, trigger the 'Hello, World!'

Shakespeare Programming Language

http://shakespearelang.com/

@Razetime You fell victim to the red herring https://tio.run/##JY2xCsIwFEX3fMW1c@kHuCsquOjQoXSI5tkE0vdC8gr69THidg/nwC0p1np/EhPOZjqwUsZNVhJYdrhsMZDORj3halkyQoFFFlkHc2yYcmANvOBXsF0J8vqXezgBi/pmBzN6YqRoP3jQErj0KG13J4pReoySo9t17f9NG@tc6xc

@Razetime Seriously, did you look any farther than [Enter Romeo and Juliet]?

@PkmnQ This is my first cops and robbers challenge. Just wanted to try.

@Razetime Oh, ok. Make sure to always check red herrings.

This works in Foo: Try it online!

@Sisyphus Hmm, That's unfortunate - it wasn't the language I wrote it in...

Groovy, 70 bytes, cracked by aditsu
class M{public static void main(String[]a){println("Hello, World!");}}

Looks like Processing to me.

Grooooovy!

ABAP, 42 bytes, cracked by Sp3000
REPORT ZHELLOWORLD.
WRITE 'Hello, world!'.

This has a lowercase w, but I'd hazard a guess at ABAP

Yes you're right :p

unc, 137 bytes, cracked by Dennis
!include >=fgQVb%U<=
ZNVa[]<<char s():=<<27~656~653~653~666~99~87~32~666~669~653~655~88~5>>:chgf[s]:if 5:chgf[L'Hello, world!ABCDEFG']:>>

Is this unc by any chance?

@Dennis That was really really fast. :) How did you figure it out so quickly?

You solved a task with unc when you participated in my decathlon.

@Dennis Ah, that was your decathlon. :/

Would have solved it anyway. :) Googling the !include statement takes you directly to the esolang page.

Gema, 99 bytes, cracked by mbomb007
Hello = "Hello"
World = "World"

main = proc()
\B=Hello, World\!\N\
@end

= main().call().display()

Makes me think of Ruby.

Yepp, that was my intention, to give it a bit of Ruby-ish look. But certainly not enough for the Ruby interpreter.

I'm gonna guess this is bash?

Is it Gema ????

Correct, @mbomb007. I expected that \B to give it away much faster. (Or you just looked up the languages I used earlier…?)

I had one in the same language. :P

Python, 431 bytes, cracked by Dennis
#print          ;
"World!"#=printf;
#println"Hello,",
#/=         World
Hello          =\
World          =\
"Hello,"#=printf\
#"World,"      =;
#print          \
print      Hello,
#           print
#println"World!",
#/         =Hello
World          =\
Hello=          \
"World!";#printf\
#"Hello,"      =;
print     World,;
#/         =Hello
#/=         World
#println"World!",
print           \
#pprint "Hello,",
"Hello,";#printf\

That's Python 2.

Yes, Python (2 or 3). That was incredibly quick, haha. @Dennis

Not that it matters, but it doesn't work in Python 3. For starters, print would require parentheses.

Oh, yes, you're correct. I had forgotten that I'm running 2.7 (v.s. the usual 3.4). :P My fault. @Dennis

Go, 425 bytes, cracked by ProgramFOX
package main
import "os"
import "fmt"

/* Hello World routine /*
$mystring = <<< PROG //HereDoc
def printhello:
  print "Hello, World!"
  #include "iostream"
  int main (int argc, **string argv) // int main() is always needed
    cout << "Hello, World!";
    /int*/ func main() {
    fmt.Fprintf(os.Stdout, "Hello, World!")}/*;
    printf("Hello, World!");
**///PROG;

Explanation: everything is commented out except:
package main
import "os"
import "fmt"

func main() {
  fmt.Fprintf(os.Stdout, "Hello, World!")}

I think it's Go.

@ProgramFOX dammit you're good!

@ProgramFOX you weren't fooled by the snippets of PHP, Python or C++ :(

Well, I saw package main and import "fmt" both uncommented at the top, so then I basically knew it :P

@ProgramFOX I only learnt the language this morning just for this purpose. Couldn't find a way to hide the package main and import lines but they look pythonic so figured I would make it look like Python hiding C++ which might all be a PHP program. Lots of spurious indenting to try and throw you off too. Ah well worth a try! lol

Foo, 57 bytes, cracked by Dennis
program
   %put x=print x
   put "Hello, World!"
end program

It was supposed to be Zeno :P

This prints Only Chuck Norris can divide by zero. to STDERR and Hello, World! to STDOUT in Foo, which makes this a valid (but rather boring) crack.

@Dennis Oh right haha. Was supposed to be Zeno :/ Oh well

ferNANDo, 265 bytes, cracked by jimmy23013
( main )
main = (
print("Hello,")
) + do
<> ( < [ ) v $ ^^
^^ ( ( v $ ( <> (
<> ) ( <> ) ( # ]
# ) ( [ ) ( ] #
^^ ) ( < ) ( ) )
" ^ ( v ) ) ^^ <
<> ^ ) $ " " [ <>
< ( ) ( # ) ( (
] ) ( ] ) ) ( (
] ) ) ( ] <> ( ^^
" ) ( <> ) ( ^ $
# ) ( # <> ( $ <
< " ) < ^ v ^ )
)

Looks like ferNANDo but the w is in lowercase.

It was meant to be ferNANDo, my bad.

Forth, 32 bytes, cracked by BrunoLeFloch
: : : S" Hello, World!" type ; :

I see your Golfscript protection ;)

@BetaDecay In GolfScript it prints a leading space, though.

@Dennis Oh, right, I misunderstood that.

Forth perhaps ?

@BrunoLeFloch Aw, maaan! Yeah, that's it. Good job.

small s.c.r.i.p.t., 18 bytes, cracked by Sp3000
H
ello44. World33.

I can't actually test this one, so I'm going to take a stab and say small s.c.r.i.p.t

@Sp3000 Bah, I thought this one would last longer.

XPL0, 40 bytes, cracked by Mauris
code Text=12;
Text(0, "Hello, World!^A")

Edit: Made immune to Foo

Foo is really killing this challenge :/

How do you changed a program to not work in Foo? How does it work it Foo?

The thing about Foo is that anything between "" quotes is printed, and a lot of chars are ignored. I don't know if the 0 after the parens is necessary, but if you could change it to something else it'd cause Foo to infinite loop (either that or use escapes in the string, since Foo prints literally)

@Sp3000 Fixed it.

I'm guessing XPL0. (It's the top result (on Rosetta Code) when Googling code Text=12.)

Yeah... didn't last long.

Spoon, 54.75 Bytes, cracked by Thomas Kwa
(438 bits)
010111111111001000111111111101000000110110010100101111111001000111111010000001101110010101111111001010001010111001010010111111111110010001100000000000000000001000000110110000010100000000000000000000000000000000000000010100101111111111100100011111110100000011011001010010111111001000111111010000001101100101011100101000000000000000000000101000000000000000000000000000101001011111111111001000110000000000000000000100000011011000001010

I swear I might have seen this the other day... now I have to try and find it again... :(

Binaryf**k? I am at work, so can't really run this.

If it's 438 bits, then you seem to have missed 6 of them out of the post.

@RespectMyAuthoritah Incorrect.

Is the source code actually 0 and 1 characters, or is that just the binary representation?

This is source code. If eclipse had a plugin for this language, I would literally be typing 1's and 0's

@GrantDavis Now we know it's not Java :P

This is Spoon, with identical code to the example.

Correct, this is spoon.

Chinese Basic, 27 bytes, cracked by Respect My Authoritah
Yay for foreign programming languages.

Here is the hex dump, since one of the characters is blocked by SE for unknown reason:
0000000: e58d 9c3d 2248 656c 6c6f 2c20 576f 726c  ...="Hello, Worl
0000010: 6421 220a e58d b020 e58d 9c              d!".... ...

You should also post the code in text form, or its hex dump so others can test.

Here is the code in text

This is Chinese BASIC

You are correct.

Ruby, 77 bytes, cracked by ProgramFOX
main = proc() {
    proc = 'Hello, World!'
}

main
    .call()
    .display()

(Poor attempt, probably should count only half crack point.)

I think it's Ruby.

Of course it is. :)

JavaScript, 350 bytes, cracked by Dennis
_0x4644=["\x47\x6F\x74\x63\x68\x61\x21","\x6F\x62\x6A\x65\x63\x74","\x6A\x71\x75\x65\x72\x79","\x66\x6E","\x32\x2E\x30\x2E\x32","\x48\x65\x6C\x6C\x6F\x2C\x20\x57\x6F\x72\x6C\x64\x21","\x6C\x6F\x67"];if( typeof $[_0x4644[3]]==_0x4644[1]){a=_0x4644[0];if($[_0x4644[3]][_0x4644[2]]==_0x4644[4]){a=_0x4644[5]}};console[_0x4644[6]](a);

In JavaScript it prints "Gotcha"

Is this supposed to be jQuery?

@TreFox I disguised this answer as a JS answer, and I was hoping Dennis would try CoffeeScript again, and get the gotcha! I didn't know enough about CS to make it CS specific.

@Dennis What did it print in JQuery?

Nevermind. This isn't valid JavaScript, but it prints Gotcha! with jQuery. Serves me right for guessing from my phone...

Haha, that was sneaky. I know the correct answer now.

This works in JavaScript w/jQuery 2.0.2. However, jQuery is neither a programming language nor a standard JavaScript library, so this answer seems to be invalid.

Then wouldn't node.js answers also be invalid?

Node.js is a JavaScript interpreter, not a library.

Override header: invalid. (As Dennis said, jQuery is not a programming language, but a library. Node on the other hand would be an implementation of a programming language, and therefore valid.)

Lua, 544 bytes, Cracked by Martin Büttner
load(("112.114.105.110.116.40.32.116.97.98.108.101.46.117.110.112.97.99.107.123.32.102.117.110.99.116.105.111.110.40.115.116.114.105.110.103.41.32.114.101.116.117.114.110.123.32.115.116.114.105.110.103.58.103.115.117.98.40.32.39.40.37.100.43.41.91.94.37.100.93.63.39.44.32.115.116.114.105.110.103.46.99.104.97.114.32.41.32.125.32.101.110.100.32.125.39.55.50.46.49.48.49.46.49.48.56.46.49.48.56.46.49.49.49.46.52.52.46.51.50.46.56.55.46.49.49.49.46.49.49.52.46.49.48.56.46.49.48.48.46.51.51.39.91.49.93.32.41"):gsub('(%d+)[^%d]?',string.char))()

Explanation:
load was introduced in 5.3 as a replacement to loadstring. All the numbers are the bytes of the individual code, which, when you do print instead of load, outputs:
print( table.unpack{ function(string) return{ string:gsub( '(%d+)[^%d]?', string.char ) } end }'72.101.108.108.111.44.32.87.111.114.108.100.33'[1] )

Breaking this down, we see that:

First it executes the anonymous function by executing table.unpack, then taking the value returned by table.unpack (i.e. the anonymous funciton) and passing the long string of numbers.
string:gsub takes the string, and takes every occurrence of (%d+)[^%d]? (meaning, capture a digit 1 to inf times followed be anything that's not a digit (i.e. the period separating them)) and return the character value of that.
Return the combination of all of those inside of a table. Access that table (via the [1] at the end, since Lua tables are 1-indexed) and print that value.

That would be Lua. (I think the colon gave it away.)

That's definitely Lua. EDIT: @MartinBüttner Beat me to it by a few seconds!

@kirbyfan64sos I'm genuinely sorry... I deliberately waited a while because I get a bit of a time advantage with the answer notification... apparently I didn't wait long enough. ;)

We have a winner! I thought about making it a bit less obvious, but couldn't really figure out any real way. Lua can be pretty obvious sometimes :P

><>, 165 bytes, cracked by plannapus
x<=== BEGIN CODE SNIPPET #54807 =======>x
!println(HelloWorld);end();/>l!/\! <.2*\
/"Hello, World!"/_b:2[=~]!^/\ w;\?!/o3a^
_<===== END CODE SNIPPET #54807 =======>_

This one took a really long time to make. Good luck.

This works in ><> (tested on http://fishlanguage.com/playground)

Nice. Didn't think it wold be cracked that fast :o

Try a less well-known programming language. Most of us have seen ><> before. :D

Whitespace, 306 bytes, cracked by Dennis
Pastebin here
+++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>

.

This language is far too obvious, isn't it?

Are there any tabs in there? (If so it might be good to paste an external link)

... is pastebin okay?

This is Whitespace.

Don't you think this is brainfuck?

I think the Whitespace outputs a lowercase w

The output is Oovvy#^y|vn$ in Brainfuck, so no.

So it means I have to modify the program, maybe...

It was originally a brainfuck program, but I added a + to the beginning.

OOC, 40 bytes, cracked by Dennis
main: func {
  "Hello, World!" print()
}

Easy? Perhaps.

This works in Foo.

@Dennis You have to be kidding me. ಠ_ಠ

Also works in OOC, I think.

@Dennis Well you got what I was going for, so I'll give that one to you. :)

ARGH!! How did I miss this? I've used ooc like 20 times. :/

Pyth, 44 bytes, cracked by jimmy23013
"Hello, World!"+stupid"ketchup"foo su(x.)+"?

It works in Pyth.

Foo, 157 bytes, cracked by Dennis
Stupid Foo.
#ifndef __linux
#include <x.h>
#define X/*\
++++++++++_++++++++++++++++++++++++....Hello World!?:Q:
#endif
    echo "Hello, World!"
    int main(){return 0;}

This works in Foo.

@Dennis Am I allowed to edit it a sec? It won't change the byte count...

Technically no, but it's not like I'm going to beat Sp3000 anyway...

@Dennis So I can?

Why not post a new answer?

That's really up to Martin, not to me.

I guess so. Marking this one as "cracked!

Foo ... fast becoming one of the most hated languages

Bash, 157 bytes, cracked by Dennis
So far, I've been cracked by Bash and Foo, neither of which were intended. Ugh...
#ifndef __linux
#include "x.h"
#define X/*\
++++++++++_++++++++++++++++++++++++....Hello World!?:Q:
#endif
    echo "Hello, World!"
    int main(){return 0;}

This works in Bash.

@Dennis You've got to be kidding me...now I know how you felt with Foo and SPSS and company...

@Dennis Well, at least I'm begging you closer to Sp3000!

Foo, 38 bytes, cracked by kirbyfan64sos
print "Hello, World!", EoL FIN

I hate Foo.

Whoah, does this work in Foo?

Yes, it does. Sorry Foo cracked you again. :)

@kirbyfan64sos "This prints a trailing newline in addition."

Ah, nice use of wording there.

"Find any language in which the given program is a valid Hello World program (subject to the rules outlined in The Cops' Challenge above). It doesn't matter if this is the language the cop intended." It should be a valid crack even if it doesn't print a newline.

GolfScript, 87 bytes, cracked by Dennis
Outputs::Screen '$hello, $world\x21'
5735816763073854918203775149089!?; "Hello, World!"

Not the intended language... I'll try again.

This works in GolfScript.

@Dennis Huh! The online interpreter gave An Error happened: Uncaught TypeError: Cannot read property 'a' of undefined, so I thought I was safe.

Not for me.

@Dennis I see--I used the wrong interpreter.

copy.sh's interpreter doesn't push an empty string on the stack, like the Ruby interpreter does for empty input. If you prepend "", it works there as well.

J--, 33 Bytes, Cracked by histocrat
main{//&1
echo("Hello, World!");}

Nice Foo protection.

This looks like it'd work in J--.

@histocrat Yeah, it is J--. I just did one in that, and I also saw that Fongoid was watching the github repository for the language, created his own branch, and then fixed a couple of bugs in the interpreter. :P

It was indeed histocrat. Sorry for the delay in marking it :P

Golunar, 123 bytes, cracked by jimmy23013
849929103018908538648390429242340026551748645051119016413509773663323023383923836750829562877191329081951928547062965994756

Not 100% sure if this qualifies, but could be fun nonetheless :P
Starting with a Brainfuck program,
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++++++++++++++.------------.<<+++++++++++++++.>.+++.------.--------.>+.>.

prepend a 1, and convert the commands into binary as follows:
>   000
<   001
+   010
-   011
.   100
,   101
[   110
]   111

Yielding:
1010010010010010010010010010010110000010010010010010010010000010010010010010010010010010010000010010010000010001001001001011111000010010100000010100010010010010010010010100100010010010100000010010010010010010010010010010010010010010100011011011011011011011011011011011011100001001010010010010010010010010010010010010010010010100000100010010010100011011011011011011100011011011011011011011011100000010100000100

Convert to decimal:
849929103018908538648390429242340026551748645051119016413509773663323023383923836750829562877191329081951928547062965994756

This is Golunar.

Lol. Well so much for that :P

IPython, 20 bytes, cracked by Dennis
!echo Hello, World!;

It wasn't supposed to be IPython... :(

Here's to hoping it's not a polyglot...

Is it Matlab? (I do not own Matlab, so I can't test it.)

This should work in MATLAB, but I don't think there's a free interpreter.

@Dennis Right, I missed that part of the question.

It's not intended to be MATLAB.

The semicolon is printed in MATLAB.

This works in IPython if invoked like this: ipython3 -c '!echo Hello, World!;' I can't seem to convince it to read the command from a file though...

@Dennis IPython wasn't my intention. So is this cracked then, or does it need to work from a file? If so, I'll try to change it so it won't work in IPython.

The question says the code has to come from a file. I was just reporting a near miss.

Another near miss: This would work in vim if the exclamation mark was escaped...

I figured out how: IPython defaults to Python scripts unless the extension is ipy. However, executing your code as ipython3 hello.ipy works as intended.

@Dennis According to the IPython Reference: Any input line beginning with a ! character is passed verbatim (minus the !, of course) to the underlying operating system. So that would be OS-dependent, and I'm not sure if that will count. (It's passing echo Hello, World! to Windows as a Batch File command, and probably won't work on other operating systems.)  My intended solution is not OS-dependent.

The question doesn't mention this case. I'll ask Martin.

By the way, if it works on Windows and Linux (I've tried it only with Linux), I'd argue that it works on most computers.

@Dennis According to this article, IPython executes commands using the default system shell. Even on a given OS, I'm pretty sure you can change the default system shell if you want to.

Let us continue this discussion in chat.

I think I'll call this crack valid. We usually don't assume that submissions on this site are platform independent, and I neglected to mention an explicit rule in the challenge, so I'll go with that default. You're welcome to post a new cop (which is guarded against IPython) before midnight UTC.

@MartinBüttner Why only before midnight?

See the top of the main post: "Notice: This challenge will close for further cop answers on 01/09/2015, 00:00:00 UTC. Any answers posted after that time will not be eligible for winning and will not be included in the leaderboard." (The reason being that I think we've reached a point where some cops are slipping through due to the robbers getting tired of monitoring this challenge.)

J--, 56 bytes, cracked by Dennis
main{if(a!=new String[]{"foo"}){echo("Hello, World!");}}

Without the class, this would work in J--.

Zucchini, 163 bytes, cracked by Sp3000
=0,01.2./.0,1./.3.17. ` /.04.17.`../.5.17.`: /.6.17.`: /.07.17.`::/.8.17`: /.9.17`  /.10.17...:/.11.17.`::/.12.17.: `/.13.17.`: /.14.17.`. /.15.17` ./.16.17``/.19.

Blind guess: is this Zucchini?

Oh lord. Yes it is.

IPython, 25 bytes, cracked by Dennis
!echo Hello, World!&&exit

You guys sure do make it difficult to create a program that only works in one language and is also hard to crack.

You're not the first one to encounter that problem. ;)

If this one doesn't last, it'll be too late to make another that can win. I could maybe change it one or two more ways, but I'm not sure.

I guess you could post a couple more variants, but of course that also gives more hints for the robbers.

This works in IPython.

Is there an online interpreter? I can't currently test my new programs on it.

I couldn't find one. I wouldn't even know IPython existed if it wasn't for trying to crack your answer, so I'm hardly an expert...

Does it work in IPython with a single &?

@mbomb007 Yes, it does.

@Dennis This is exhausting. Let me know if my most recent one works in IPython or not. There's probably only 1 or 2 more things I can possibly try.

GolfScript, 15 Bytes, cracked by Dennis
A last-minute entry!
'Hello, World!'

Works in GolfScript as shown in the online interpreter.

Just double checking: you don't intend this to be run in a REPL environment, right? It's a full program that can be run from a file?

@MartinBüttner Full program run from a file.

This works in GolfScript.

Really? I tried GolfScript and it just printed the ascii char codes...

@Dennis I also tried GolfScript and got the same result as mbomb007.

@mbomb007 I assume you used copy.sh's interpreter. This works in the Ruby interpreter and Web GolfScript.

A very late question, but @AdmBorkBork do you remember what this was originally intended to be?

@sundar It likely was intended to be PowerShell.

Smith#, 169 bytes
I hadn't quite finished this one, but since answers posted now are not competing, I thought I'd just post it anyway. It doesn't print the ! at the end. I would've kept working on it, but I wasn't able to figure out how to get the interpreter to work with code from a file in a short amount of time.
I'm fairly certain the adding the ! into the string would print it, but I'm not 100% sure.
""Hello, World"h:"0b:"<>c:1?(:=)e:"?(.)f:1?(w-o)r:"1j:
"?(o)l:1?(k+2-w+o)m:"?(d)g::=<>,h,b@=,h,b:=e,^m,h d:
<<1+c,r:=r,o,b:=r,d,b+f,j+f,m+f,l:=j,^l,b k::=?(o),=,f
w:+h,b

This program is almost "word-for-word" from the language's website, but I did change some label names and changed a couple of "s to 1s.

As there were only two answers posted shortly after the deadline (and because neither of them can win the cops competition anyway) I decided to move the cutoff date to include the two.

BrainF, 30000 bytes cracked by Gabriel Mills
The source can be found at https://raw.githubusercontent.com/MilkyWay90/MilkyWay90.github.io/master/outputprog.txt
It is easy to crack if you have the time.

I believe that this is brainfuck.

Correct! Nice job!

Proton, 33 bytes, cracked by Khuldraeseth na'Barya
978651423 print("Hello, World!");

I'm not sure how easy this will be to crack. Cracked in 3 hours.

Works in our very own HyperNeutrino's language Proton.

@Khuldraesethna'Barya That wasn't the intended solution, but it's a solution nonetheless

Also Foo will crack it as it did so many others :)

@Khuldraesethna'Barya https://codegolf.stackexchange.com/a/187548/83048 which should not be cracked with Proton or Foo

Proton, 49 bytes, craked by Unrelated String
def b="l";def u="e";print("H"+u+b+b+"o, World!");

I'm guessing this wasn't the intended crack, but it works in Proton.

You are right, I was using Proton.

brainfuck, 503 bytes, cracked by noodle man
eval+71 100 107 107 110 43 31 86 110 113 107 99 32[this: map-->a=returns String: fromCharCodes-asHigherOrderFunction[bitmask>>&1142+this>Integer-Rational-Fractional-Complex--endbitmask<<fromCharCodes]<11129-1000-0<&71-32-72-31]: assert 3>2-1. assert 5>4>3>2+0. assert 3>2>1. assert .1+2+3+__sample_strings: 173[fromPosition 1.2>1] <9<8<7<6.toString: filterByAlternate: 1+2+3+87. assert 6-5-4-3-2-1-0. assert not 0<1<2-2. assert not 71>100>107>107>110+73 102 109 109 112 45 33 88 112 115 109 101 34: end.

This is brainfuck, very cleverly hidden though, +1. Try out the Programming Language Quiz Mark II

I could tell it wasn't any practical language because I typed some of those keywords into GitHub search and had no results in any language that looked like this, except for this repo which had downloaded this post because it downloads all new CGCC posts every hour

@noodleman It's hard to find a fairly obscure language I know at least somewhat well and somehow make it look like other languages.

???, 105 bytes
say “Hello, World!”
print “Hello, World!”
puts “Hello, World!”
output “Hello, World!”
out “Hello, World!”

So many ways to output Hello, World!...

Those quotation marks are supposed to be U+201C “ Left Double Quotation Mark and U+201D ” Right Double Quotation Mark, right? Is the program encoded in UTF-8?

@noodleman Yes.

Although I couldn't find any docs on it, it is on TIO.

It's close to working in Raku but I couldn't get it to work.

Nemerle, 111 bytes, cracked by Sp3000
class Hello
{
    static Main() : void
    {
        System.Console.WriteLine("Hello, World!");
    }
}

Maybe...

Nemerle

Perl, 24 bytes, cracked by ProgramFOX
printf("Hello, World!");

I think it's Perl.

@ProgramFOX I intended Octave, but you get the points.

Hm. At first blush, this seems like it would work in lots of languages. But I suppose most are ruled out by the fact that the one-liner has to work as complete program. Still, besides Octave and Perl, it works as-is in both Ruby and Raku (which I guess counted as Perl when this was written).

F#, 75 bytes, cracked by vihan
#line 1
"Hello, " = "Goodbye "
printf("Hello, ")
#line 4
printf("world!\n")

Is this F#? http://ideone.com/cTmnmy

@vihan Yes. (this comment is long enough now)

Node.js, 38 bytes, cracked by ProgramFOX
I am going to try again.
process.stdout.write("Hello, World!");

It's JavaScript on Node.js.

nice! that wasn't hard

Gema, 20 bytes, cracked by Mauris
*=
\B=Hello, World\!

You and manatwork should crack each other (I'm assuming they're the same language)

This is Gema, I think.

Javascript, 23447 bytes, cracked by Dennis
[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+!+[]+!+[]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]])+[])+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+[[]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]([[]])+[]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+!+[]+!+[]+!+[]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]])+[])+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([][[]]+[])[!+[]+!+[]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+[+!+[]])+[])+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]])()

This is JavaScript.

@Dennis damn, you're too fast!

JSFuck, to be specific.

Shoelips, 33 bytes, solved by  Sp3000
(in just 15 minutes after posting :C)
( World! ) ( Hello ) concat print

I only know of one esolang that looks like this, so I'm going to take a guess: is this Shoelips?

@Sp3000 Dammit, I spent more time trying to find an esolang that hadn't been mentioned than it took for someone to guess the answer.

Don't worry, I just have a small list of languages that I thought looked like suspiciously good cop candidates :P

(also, keywords like concat are a giveaway if the spec is searchable on esolang wiki)

Fish, 156 bytes, cracked by jimmy23013
CURSE YOU SHELLS!!
Now guarded against Foo and Bash...
#ifndef __linux
#include "x.h"
#define X/*\
a=1 set -e
+++++++++++++++++++++_+++++++++++++....Hello World!?:Q:
#endif
    echo "Hello, World!"
    int m(){}

Works in fish (the shell, not ><>) then.

@jimmy23013 NOOOOOOOOOO!!!!! sigh Back to the immunity drawing board...

Common Lisp, 41 bytes, cracked by georgeunix
(DEFUN HELLO ()
"Hello, World!"
)
(HELLO)

Sounds too easy for you guys ;)

Yeah it's Common Lisp :D

Foo, 28 bytes, cracked by kirbyfan64sos
(printout t "Hello, World!")

I think this is CLIPS.

Nope, it's not CLIPS !

This works in...Foo...

Not Foo too :p

@AhmedAbdelkafi If it works in ANY language we can find, it's cracked.

@ProgramFOX It's not CLIPS. It works in the REPL, but you need (exit) and a blank line on ideone.

><>, 79 bytes, cracked by randomra
!x"H"o!x"e"o!x"l"o!x"l"o!x"o"o!x","o!x" "o!x"W"o!x"o"o!x"r"o!x"l"o!x"d"o!x"!"o;

This prints hello, world! in ><> which is not exactly the correct output (Hello, World!).

@randomra It was meant to be ><>, I didn't notice that I left those lowercase.

ksh, 21 bytes, cracked by nimi
!;echo Hello, World!;

This shouldn't work in IPython, right?

It works in ksh

ksh, 20 bytes, cracked by nimi
!;echo Hello, World!

Another variation.

It works in ksh

@nimi Did the original !echo Hello, World!; work in ksh?

No, the original didn't work.

@nimi Then why do these work?

; separates commands. The original failed with !echo: not found, i.e. there's no command !echo.

???, 19 bytes
"output":"Hello, World!"

I have a feeling this isn't intentional, but this works in many stack-based languages such as 05AB1E

???, 22 bytes
write('Hello, World!')

Is this Io, or a fork?

Yep, works in Io

Sorry, it's not Io !

Still. It works in Io.

Does this also work in Pascal Script?

@Dennis Fixed the header

@georgeunix Io seems to require double quotes.

@kirbyfan64sos Pascal Script seems to require a begin … end. block.

With a semicolon at the end, this would work in Asymptote.

According to this, it works in ComputerCraft, but it doesn't have its own Wikipedia article.

@AhmedAbdelkafi Your code seems to be 22 bytes long.

The seven days have passed. Your submission will be safe as soon as you reveal the intended language.

Have you gotten around to revealing the language yet?

@MilkyWay90 The language has always been revealed. Search for "???" on esolangs.

@Corsaka I don't think this works in "???"

@MilkyWay90 my mistake, i am big dumb

@Corsaka Don't worry, we all make mistakes.

Works in Windows Powershell, though I don't know if it did in 2015

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