## The Programming Language Quiz

193

62

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

1. 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).
2. 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:

# ???, [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

1. Find a vulnerable answer. That is an answer, which hasn't been cracked yet and which isn't safe yet.
2. 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.

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 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 */

// 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;
}

}

jQuery.ajax({
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function (data) {
data.items.forEach(function(a) {
});
comment_page = 1;
}
});
}

jQuery.ajax({
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function (data) {
data.items.forEach(function(c) {
if (c.owner.user_id === OVERRIDE_USER)
});
else process();
}
});
}

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;

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

function process() {
var vulnerable = [];
var cops = [];
var robbers_hash = {};

var now = Date.now();

var body = a.body;
if(OVERRIDE_REG.test(c.body))
body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
});
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),
});
} 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],
});
}
} 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,
});
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 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!";

.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)

});

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 size = a.size;
if (size != lastSize)
lastPlace = place;
lastSize = size;
++place;
.replace("{{NAME}}", a.user)
.replace("{{LANGUAGE}}", a.language)
.replace("{{SIZE}}", a.size)

});

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 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 += '<a href="' + l.link + '">' + lang + '</a>';
});
.replace("{{NAME}}", a.user)
.replace("{{CRACKS}}", a.cracks)
.replace("{{TOTAL_SIZE}}", a.total_size)
.replace("{{LANGUAGES}}", languages);

});
}
body { text-align: left !important}

#vulnerable-cops {
width: 600px;
}

width: 600px;
}

width: 600px;
}

font-weight: bold;
}

table td {
}

.time-ms {
display: none;
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<div id="vulnerable-cops">
<h2>Vulnerable Cops</h2>
<table class="vulnerable-cops">
<tr><td>User</td><td>Size</td><td>Time Left</td></tr>
<tbody id="vulnerable">

</tbody>
</table>
</div>
<tr><td></td><td>User</td><td>Language</td><td>Size</td></tr>
<tbody id="cops">

</tbody>
</table>
</div>
<tbody id="robbers">

</tbody>
</table>
</div>
<table style="display: none">
<tbody id="vulnerable-template">
</tbody>
</table>
<table style="display: none">
<tbody id="cops-template">
</tbody>
</table>
<table style="display: none">
<tbody id="robbers-template">
<tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{CRACKS}}</td><td>{{TOTAL_SIZE}}</td><td>{{LANGUAGES}}</td></tr>
</tbody>
</table>

110One minute of silence for those only capable of Piet programming. – user3819867 – 2015-08-17T08:20:43.187

20There goes my productivity! – Luke – 2015-08-17T20:30:06.717

12I 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. – kirbyfan64sos – 2015-08-26T19:41:37.363

41

# 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.

1Looks like this might be the winning submission. – primo – 2015-09-01T11:18:41.913

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. – histocrat – 2015-09-02T17:06:34.130

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. – histocrat – 2015-09-02T19:59:37.160

1Well 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 – 2015-09-04T21:18:39.583

@mbomb007 I read your comment before you edited it. Yes, the avatar is brand new. – Dennis – 2015-09-07T03:51:27.457

153

# 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.

30

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

– DDPWNAGE – 2015-08-17T06:51:32.120

@DDPWNAGE Very clever haha. It's not C then – Beta Decay – 2015-08-17T07:00:25.473

1

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 – 2015-08-17T11:40:38.833

1@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. – BrainSteel – 2015-08-17T11:56:06.833

47It's TinyBF!!!!!! – kirbyfan64sos – 2015-08-18T01:27:43.160

http://postimg.org/image/erwf9ayir/ The equal signs gave it away a little. :) – kirbyfan64sos – 2015-08-18T01:29:42.770

@kirbyfan64sos Yes, nice work! When I can get to a computer, I'll edit my post with details. :D – BrainSteel – 2015-08-18T12:47:49.523

6Congrats on the gold badge for this post. :D – Alex A. – 2015-08-28T20:25:55.110

114

## 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.

13Well this is interesting. Have a +1 :) – Sp3000 – 2015-08-17T12:58:42.497

1Are you sure the output ends with a !? – jimmy23013 – 2015-08-17T14:57:54.427

6Looks like Python... – Zizouz212 – 2015-08-17T20:11:41.757

1Could this be rust? – Beta Decay – 2015-08-17T20:51:26.980

@BetaDecay Without functions? Also it would error on #! expecting [] I guess. – Kroltan – 2015-08-17T23:41:23.340

2It's not python or rust sorry. The output is: Hello, World! exactly. – grc – 2015-08-18T08:08:37.043

Luck? – Beta Decay – 2015-08-18T20:15:58.677

1

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

– TheNumberOne – 2015-08-19T02:38:55.303

@TheNumberOne Nope. – grc – 2015-08-19T04:02:28.687

@TheNumberOne Gah, I can't believe I forgot :P – Beta Decay – 2015-08-19T08:16:31.770

decode and rsplit seem to be Python but I still don't see how it works - suspect a red herring here. – OldCurmudgeon – 2015-08-19T13:14:38.240

@OldCurmudgeon Yeah, it's not Python. See the first comment. – mbomb007 – 2015-08-19T21:53:19.077

Since I have no clue at all, I am going to suggest: Fortran! That first line had me laughing. :-) – Stig Hemmer – 2015-08-20T07:39:12.697

Matlab? I've seen rsplit there before but that's a shot in the dark – iamgory – 2015-08-20T09:26:37.410

@iamgory it's not Matlab or Fortran. – grc – 2015-08-20T09:36:11.740

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... – AdmBorkBork – 2015-08-20T16:09:01.053

9Either 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. – ETHproductions – 2015-08-20T16:16:37.683

It this programmed in Java? – Grant Davis – 2015-08-20T17:57:30.263

Is it 6ix by any chance? – Jwosty – 2015-08-20T19:20:04.937

@stannius NumPy isn't its own language. – Alex A. – 2015-08-20T21:02:53.160

3It isn't Java or 6ix. @ETHproductions is on the right track (hint: the latter, not Python). – grc – 2015-08-21T01:27:23.037

3there'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 – 6160 – 2015-08-21T13:26:45.020

@le_vine I'm glad someone noticed that :D – grc – 2015-08-21T14:45:36.050

@grc but i really don't know the meaning of the other strings :D – 6160 – 2015-08-21T14:47:13.737

@le_vine I'll tell you in 3 days :P – grc – 2015-08-21T14:48:14.570

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... – Dom Hastings – 2015-08-21T21:18:24.100

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 – 2015-08-21T21:49:49.830

@Charlie Nope. Doesn't work. – kirbyfan64sos – 2015-08-21T21:53:14.433

so it's "the Base64 gibberish is not actually Base64 in the correct language" – mbomb007 – 2015-08-22T20:11:47.280

Nim(rod)! Cobra! – Zizouz212 – 2015-08-23T15:53:33.303

@Zizouz212 nope, but nice guesses. – grc – 2015-08-23T15:56:40.900

I swear to god, this is driving me crazy on a site that I can't do for life!!!!!!! WLAHHHHHHH – Zizouz212 – 2015-08-23T15:57:20.610

3@Zizouz212 welcome to PPCG :D – grc – 2015-08-23T16:07:57.537

Just 2 hours left :D – Beta Decay – 2015-08-24T10:51:54.927

27

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

– Sp3000 – 2015-08-24T11:22:57.873

@Sp3000 The w occurs 15 times, but there doesn't seem to be enough z, a and u to construct all the letters? – leo – 2015-08-24T11:59:35.863

1@Sp3000 yep, you've got it. Congratulations!! – grc – 2015-08-24T13:17:08.120

@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 – 2015-09-01T03:53:42.673

4@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 – 2015-09-01T04:21:47.220

@grc Ahhhhh - I see now. That's fantastic :D – Rob – 2015-09-01T04:55:45.917

102

## 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.

[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

[[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

[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!"


8Is it Shakespeare? – SuperJedi224 – 2015-08-17T13:40:39.100

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

– max_ – 2015-08-17T13:41:57.313

24It is Lua. (at least 15 characters) – jimmy23013 – 2015-08-17T13:46:12.587

45Lua disguised as Shakespeare. Genius! +1 – ETHproductions – 2015-08-17T15:10:34.007

Actually, it prints Hello, world!, not Hello, World!. – Dennis – 2015-08-20T21:14:38.810

@Dennis Yeah, forgot the capital w. Should I edit? – Nico A – 2015-08-20T21:54:45.730

I think so. It doesn't really affect the crack. – Dennis – 2015-08-22T19:17:25.437

84

# 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?

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.

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.

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.

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!"

Martin says he hasn't seen this esolang before, but it looks funky.

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.

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

Martin argues that it's actually a stepladder.

Martin thinks that Prelude and Fission are much more awesome languages.

Martin raises an eyebrow, wondering what you're on about.

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

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 quit because SE is EVIL – 2015-08-18T23:50:59.857

3@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 ':'?)" – Sp3000 – 2015-08-18T23:55:56.957

Is this Fortran? – Grant Davis – 2015-08-21T00:52:51.013

@GrantDavis No, this is not Fortran. – Sp3000 – 2015-08-21T01:00:24.913

Has it been seven days already? – dramzy – 2015-08-24T13:53:51.483

@RespectMyAuthoritah As of writing, a little under 2 more hours (check the snippet) – Sp3000 – 2015-08-24T13:56:25.620

17Gosh, that's the funnest esolang I've ever seen! I love your prime example. +1 – ETHproductions – 2015-08-24T16:27:48.720

15">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! – Kroltan – 2015-08-25T09:30:58.227

1"Martin argues that it's a stepladder"? Found the Ace Attorney fan ;) – Deusovi – 2015-09-03T19:59:19.043

6">TAKE ROPE OUT OF INTERPRETER" "The language interpreted by the interpreter appears to be using immutable strings." xD – None – 2015-10-30T19:48:39.547

65

# 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 )
( 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.

44+1 for herrings are red – Martin Ender – 2015-08-17T09:29:02.063

– Luke – 2015-08-17T13:20:05.223

@Luke Good guess, but unfortunately no – Sp3000 – 2015-08-17T13:24:14.607

Some variant of Lisp? – None – 2015-08-17T14:57:29.973

4@Hosch250 That's a pretty vague guess :P – Sp3000 – 2015-08-17T15:01:14.590

I guess I'm wrong. I found an interpreter that couldn't do it. – None – 2015-08-17T15:10:44.900

13It's Headsecks. – Dennis – 2015-08-17T16:22:53.050

@Dennis Indeed it is, nicely done :) – Sp3000 – 2015-08-17T16:23:16.907

63

# ???, 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. 12Before anyone guesses, Piet prints with a lowercase w and knowing Dennis it probably wouldn't be that easy :P – Sp3000 – 2015-08-18T22:52:38.547 @vihan That is incorrect. Sorry. – Dennis – 2015-08-18T23:08:08.193 Obviously not brainloller, but it looks like it could be braincopter – aditsu quit because SE is EVIL – 2015-08-18T23:12:21.883 @aditsu That would be a huge coincidence. – Dennis – 2015-08-18T23:13:57.793 Is this Mycelium? – Doorknob – 2015-08-19T01:03:57.250 @Doorknob No. Mycelium only supports PNG. Sorry. – Dennis – 2015-08-19T01:14:47.610 11 This is ???. – jimmy23013 – 2015-08-19T06:27:49.090 1@jimmy23013 Correct! – Dennis – 2015-08-19T06:31:43.937 1??? 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 – 2015-08-19T08:26:04.177 2 @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 – 2015-08-19T08:31:39.010 @Dennis, Well, what can I say - timing is everything. – ugoren – 2015-08-19T08:47:07.293 29@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. – Alex A. – 2015-08-19T17:13:44.973 7This is just incredible. I've never before seen a fully valid text-based program embedded in an image file. +1 – ETHproductions – 2015-08-19T18:31:34.623 @AlexA. I'm missing something. How do you match a languages name to a challenge that's published 19 minutes after the language? – ugoren – 2015-08-19T20:36:50.413 1@ugoren The challenge was sandboxed and discussed at length in chat. – Dennis – 2015-08-19T20:37:55.300 1 @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 – 2015-08-20T08:07:12.143 @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. – Alex A. – 2015-08-21T22:18:14.723 @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. – ugoren – 2015-08-22T12:03:53.493 2I 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. – trichoplax – 2015-08-22T18:31:35.447 3@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. – Martin Ender – 2015-08-22T18:42:49.987 2And 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. – Martin Ender – 2015-08-22T18:44:47.450 @MartinBüttner, I agree that it's a very harmless use of the loophole. – ugoren – 2015-08-22T19:03:59.990 2 @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 – Martin Ender – 2015-08-22T19:04:54.543 @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.) – b_jonas – 2015-10-19T14:07:43.483 41 # 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? – None – 2015-08-17T12:58:53.413 1Have a look at a character table. – SuperJedi224 – 2015-08-17T13:02:16.883 OK then, not JS or PHP... – None – 2015-08-17T13:10:28.183 JSP possibly? Trying to find a character table where 42 = , – None – 2015-08-17T13:23:51.857 1This was actually never intended to run in PHP or JSP. Also, I think you are looking in the wrong place. – SuperJedi224 – 2015-08-17T13:25:15.503 1Would this happen to be RISBF? – kirbyfan64sos – 2015-08-17T14:14:09.677 1Or another Brainf***-based language? – kirbyfan64sos – 2015-08-17T14:31:13.873 1It's not RISBF, but you're on the right track. – SuperJedi224 – 2015-08-17T18:04:20.440 2Besides, I can't seem to find a RISBF interpreter anywhere... – SuperJedi224 – 2015-08-17T18:17:45.980 So, it outputs Hello* World! in JavaScript, Hellotqtwqir in BF... What else? – ETHproductions – 2015-08-17T22:36:51.600 2 @ETHproductions HelloHelloHello in Thue – Sp3000 – 2015-08-18T00:10:29.067 Befunge or a relative? – Kevin – 2015-08-18T18:22:47.037 1@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. – SuperJedi224 – 2015-08-18T18:30:59.277 Well, seen as BF ignores everything except for +-<>[],., it is almost certainly BF-related. – None – 2015-08-18T19:07:51.857 Is this JSFuck? – SirPython – 2015-08-18T21:48:31.080 @SirPython: No. – SuperJedi224 – 2015-08-19T01:38:39.527 It looks like a Funge as well.. – RobAu – 2015-08-19T07:04:16.217 @RobAu: Well, it's not one. – SuperJedi224 – 2015-08-19T11:09:08.250 Is this TinyBF? – Dom Hastings – 2015-08-19T11:55:19.687 It's clearly not, I'm not sure where I got that from! – Dom Hastings – 2015-08-19T13:15:18.710 @DomHastings: Yeah, the only TinyBF interpreter I could find didn't seem to do anything at all with this. – SuperJedi224 – 2015-08-19T21:10:13.507 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. – Lynn – 2015-08-20T04:20:11.283 Is it ActionScript? – mbomb007 – 2015-08-20T04:32:14.103 @mbomb007: No, it is not. – SuperJedi224 – 2015-08-20T11:10:31.563 17 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. – Sp3000 – 2015-08-20T13:11:55.140 I thought this was HyperDimensional BF at first – MilkyWay90 – 2019-06-25T23:44:50.187 41 # ???, 1052 bytes, cracked by Alex A.  >${\.*.               @.)]($| ../..<$
])*#]<(.#^           @:">_,;;.}_           .:])%#](~^.
:/+.";.;$\:]\ }.};.;%..;*.] [_#]..>^[{"- '\/<"'/;,{<'<"'; =(>;;.;.($(::;.      >"$$-|=_:'"+'[-
>-$'\ #"';;( <%;;.> }\;/#_ +~%#.. ~.<++@ +^~^.$     ;][+(~     !;=#)(     /~\,],     ,!@#.@     .]...|
..}_!&     #<![("     =,};[+     /<:&:>     *.;_.-     -)'=#"
'<@:>\                ;+.&.@                ~%@)^(
%.+!_^                <(/~-_                _-/=-
*+^<]!                +--[[^                >!;;[|
;;=)..                *]+%%.                .@]+"(
,[-.}.                .]<.;'                $]+%* [{"$*'                $(]-, _!~;_> @/;%!.$#..!;                !,&[\,
::{>                  ^,%~                  (,{<

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


9I was really hoping this worked in ??? but it doesn't. – Alex A. – 2015-08-19T00:25:51.313

9Nice, it works in ??? now! :D – Alex A. – 2015-08-19T01:34:43.760

35

# 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?[~bpqSj 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 >zPR6D1<4> &I(#6u+Kc}YX dfbz N 2|#sNM 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?3JvjZ;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 )=otSA
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_sTacD<{ 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:eLcqq"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~ F2dk 3.W  I> " OW SZ)WHq  "eaA} HieV+]jr2 dbXw VVq ZWJ E f%
x " Q8K7 46@ tpaar% ^_8K{ 7gq J3wt G1 _ K3d )Qv5DN 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; gxfH4v^
\+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 8r }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-EFI{#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.

9

This is Starry

– Sp3000 – 2015-08-17T10:44:29.483

32

# 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?"


1I guess: Python. – ProgramFOX – 2015-08-17T13:59:29.727

1If Python (2) is the correct answer, the output is wrong. – Dennis – 2015-08-17T14:00:17.183

Nice try, guess again! – Luke – 2015-08-17T14:00:26.273

17... Brainfuck? (15 chars) – Sp3000 – 2015-08-17T14:00:35.470

You're much too quick! – Luke – 2015-08-17T14:01:11.407

28

# 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 – kirbyfan64sos – 2015-08-19T20:33:07.613

3I'm trying to find a BF clone here somewhere... – mbomb007 – 2015-08-19T20:45:24.737

Looks like Swift... – DDPWNAGE – 2015-08-20T04:57:38.980

@DDPWNAGE It's not Swift – samgak – 2015-08-21T00:24:16.983

Reminds me of VerboseFuck, but I think not. – mbomb007 – 2015-08-21T17:44:06.813

@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 []) – Matias Cicero – 2015-08-21T19:51:23.237

@MatiCicero you're on the right track – samgak – 2015-08-21T22:09:40.973

2Some 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. – Gareth McCaughan – 2015-08-24T12:56:44.180

1@GarethMcCaughan Well done, you got it! Logo (at least the variant I tested this in) allows single or double quotes for symbol names. – samgak – 2015-08-24T13:08:24.600

12It's alarming how many people there are who can apparently instantly recognize TinyBF or Fission or HeadSecks but are flummoxed by Logo :-). – Gareth McCaughan – 2015-08-24T13:14:54.443

1Where's the turtle? – MilkyWay90 – 2019-07-01T04:32:48.427

27

# 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 – 2015-08-17T08:46:54.410

12@MKII Does it compile in C#? :P – Martin Ender – 2015-08-17T08:47:43.227

1is letter R in method write is capital on purpose? – user902383 – 2015-08-17T11:40:18.500

2@user902383 Yes. (Otherwise it would compile in C#, right? ;)) – Martin Ender – 2015-08-17T11:40:49.923

20Oooh! Capital R, you say? Is this Fission? :D – BrainSteel – 2015-08-17T11:59:24.897

Awesome! I want to add this as an official example now lol – C0deH4cker – 2015-09-03T20:13:16.840

26

# 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? – None – 2015-08-17T12:08:12.523

@Kslkgh sorry, nope... :) – h.j.k. – 2015-08-17T12:25:08.947

Just to make sure, this prints exactly "Hello, World!" with no preceding linefeeds, right? – lirtosiast – 2015-08-18T00:49:52.463

@ThomasKwa there's no preceding linefeed, only the optional single trailing newline. – h.j.k. – 2015-08-18T00:54:53.053

4

This is the Q/kdb+ programming language.

– Lynn – 2015-08-20T04:15:09.817

@Mauris brownie points for you! :) – h.j.k. – 2015-08-20T04:22:23.583

I only figured it out because you had a previous answer on the site in Q, heh ^^ – Lynn – 2015-08-20T04:23:55.980

– h.j.k. – 2015-08-20T04:26:51.340

34Hmprf. I tested J and K. I should have tried more letters... – Dennis – 2015-08-20T05:59:57.607

@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.

– h.j.k. – 2015-08-20T06:04:44.530

I'm hardly an expert. Either I did something wrong or it doesn't work with Kona. – Dennis – 2015-08-20T06:07:17.090

24

# ~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.

2You have insane determination. – kirbyfan64sos – 2015-08-23T00:33:25.133

23

# 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. 18The seven days have passed. You may reveal the language and make your answer safe. – Martin Ender – 2015-08-25T09:45:23.620 22 # 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! :) 1 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. – Downgoat – 2015-08-18T20:17:27.280 @vihan It would be a pretty crazy coincidence if this was working TinyBF. It's definitely not what I intended. ;) – Martin Ender – 2015-08-18T20:18:24.590 Is it Rail? (more characters to make this long enough for a comment) – Alex A. – 2015-08-18T20:43:48.170 1@AlexA. No, unfortunately you can't disguise Rail like that (or I would have already posted a Rail answer :D). – Martin Ender – 2015-08-18T20:44:26.240 Just a guess: fission – aditsu quit because SE is EVIL – 2015-08-18T23:19:50.593 1@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. ;) – Martin Ender – 2015-08-18T23:21:50.223 6 This is MarioLANG, but this was so well obfuscated that it looks nothing like it. – Sp3000 – 2015-08-22T16:06:57.810 21 # 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. – Downgoat – 2015-08-17T17:24:24.797 @vihan No, sorry. Fueue prints FUEUE: UNKNOWN , OP 14 times, then HHeelllloo,, WWoorrlldd!!, without exiting the program. – Dennis – 2015-08-17T17:48:04.943 Pyth... But not on the online interpreter? – Beta Decay – 2015-08-17T20:36:42.433 @BetaDecay No, sorry.  begins a Python literal, resulting in a syntax error. – Dennis – 2015-08-17T20:40:25.997 Is this some kind of assembly, perhaps? – Alex A. – 2015-08-17T22:41:28.033 You know a lot of esolangs! – kirbyfan64sos – 2015-08-19T22:35:29.247 15@kirbyfan64sos Dennis knows a lot of everything. – Alex A. – 2015-08-20T05:32:24.267 ...Is this LARSA? – mbomb007 – 2015-08-24T16:41:07.117 @mbomb007 LARSA printed this. – Dennis – 2015-08-24T16:44:00.100 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. – mbomb007 – 2015-08-24T16:45:16.623 21 # 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!. 3 I have to ask: Does you intended solution comply with rule 1, specifically the part about what qualifies as a programming language? – Dennis – 2015-08-18T15:56:45.380 @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. – Lynn – 2015-08-18T16:23:23.197 3@Dennis Yup -- the language is, in fact, Turing-complete. – Lynn – 2015-08-18T16:24:22.797 @Sp3000 I've replaced the padding with something less browser-breaking. – Lynn – 2015-08-18T16:26:26.747 This is Hello++. – Doorknob – 2015-08-19T00:50:36.887 @Doorknob: that doesn't qualify as a programming language (and moreover, it would print Hello World, lacking punctuation.) – Lynn – 2015-08-19T00:57:50.353 Ah, right, completely forgot about the programming language requirement. – Doorknob – 2015-08-19T00:59:11.690 2gs2? (Didn't work at anarchy golf, but seeing maurisvh authored 5 days ago I'm going to guess it anyway.) – feersum – 2015-08-21T02:40:19.840 Bingo! (I thought it'd get cracked much faster. I've even answered challenges on here in gs2.) – Lynn – 2015-08-21T02:52:04.400 21 # ><>, 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? – aditsu quit because SE is EVIL – 2015-08-18T22:02:59.410 When ran in the correct language, the output is "Hello, World!" (no quotes of course) – Fongoid – 2015-08-18T22:15:26.603 Alright, just checking :) – aditsu quit because SE is EVIL – 2015-08-18T22:23:02.837 11 More ><> (Fish)! – Sp3000 – 2015-08-19T00:38:47.483 Indeed it is :P Too bad I forgot the ! in the obfuscation >_< – Fongoid – 2015-08-19T17:27:48.447 waow. Good obfuscation. – clapp – 2015-08-22T10:12:50.700 20 # 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. 1Doesn't this work in C? – jcai – 2015-08-17T20:03:19.367 @Arcinde No, it does not. – Dennis – 2015-08-17T20:04:13.727 6Ah, two newlines. – Peter Taylor – 2015-08-17T20:05:04.567 Is it objective c? – user41805 – 2015-08-18T04:43:19.930 @KritixiLithos Not, it is not. It prints Hello, World! followed by two newlines. – Dennis – 2015-08-18T04:49:31.723 5 Wow, I'm actually going to comment here :D Could this be... Higher Subleq? – John WH Smith – 2015-08-19T22:27:35.160 @JohnWHSmith It is! Well done. – Dennis – 2015-08-19T22:28:16.490 19 # 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! – Beta Decay – 2015-08-17T21:52:12.383 Just a guess: STXTRM? – nimi – 2015-08-17T23:40:34.967 1@ETHproductions, it's not intended to be Orthogonal. The interpreter doesn't compile for me, so I can't definitely prove it isn't. – Peter Taylor – 2015-08-18T05:49:48.083 1 @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). – Peter Taylor – 2015-08-18T05:53:17.570 Hmm. Maybe Befunge? – Polynomial – 2015-08-18T09:47:54.537 1@Polynomial, no. It loops infinitely in Befunge. – Peter Taylor – 2015-08-18T09:59:56.987 I'm guessing [] pushes a zero-terminated string,  pops the 0, and . prints an ASCII character. – Lynn – 2015-08-18T18:15:17.197 2(or is that what they want you to think?? dramatic music plays) – Lynn – 2015-08-18T19:20:59.807 1@Mauris Or  reverses the string on the TOS. – kirbyfan64sos – 2015-08-19T00:41:16.653 1Got it! It's .... unfortunately I'm not allowed to tell, because I already had my guess. Damn. – nimi – 2015-08-21T18:47:49.990 4@nimi, keep it quiet and I'll give you half of the prize money. – Peter Taylor – 2015-08-21T19:10:24.160 3 Seems to work in Mascarpone, which is indeed stack-based and  pops the ] which for some reason gets pushed – Sp3000 – 2015-08-23T12:55:20.033 17 # Whirl, 12302 bytes, cracked by Artyom 3.141592653589793288462643383279207884697269399375705845974944595347816486286788 99262883192534210706798214888651326231664709384460255058223879585940892848425745 72845027259385711356596446299474149373219244288149756659334467284756582337867838 65290203309945648566923460348630458326848283390605263242149273724387006606305588 17688152992197288925489171536436729259066006733053554682146652138414195194155260 94330572703655599939530920867773809328677934055585480744623799627495623598880527 24891227938383069449529853677362440656643086026394946395224737790772179866943722 77753919727629377675238467487846766940533204456812714526359282678571134275778966 91336346707244684405062249534709465459853763597922796832289235478169561899890259 60864034418759863524774774309960578707288349994968372978069966059761732846096388 59502445945534691833264252238825334468583526193118812846000913783875288658753300 83864206877776699473035982539904287554687375595627688823537875937599577858577805 32776236806644850927876620695909236420498932095257201465485963278875956453483837 96838034695203531186296899577362259941389124975177528347993759558285724245455065 59507295336268647288558590750983897546374649398592550644919277416611334898488242 52838361603563707660104090588242945596698926767837469448255372774726847604447334 64620804668425906949629339367707038955200475226235696602405803475079754225338243 75355870402474964432539147992726042692227957823547896360097417216412199245863150 30286182974555706749838505494548586926995690927680797503302955321165344987902755 96923648066549926988983429775356636980742654052787255181841757467289597779279388 41818470600361452491928732372847723507474409737685487603695573585520334747338494 68438523623907394243330547762486862528983569585562099235222984272650254256887658 79049466135346680466862723279578604578438382596797668145416375388858636395568364 42251252351173929838960843284886269456042419752853222166612863067442786220391949 45847123123786260956364373937287457764657573963453890065832645995413397478427592 49946576497895826996831835259574982582262952248949772471947826848260647699090264 09363944374253057682834962524517493996554334298297906592509472256964625557098583 37419517885979772975598339164753928428533268683862942774953993855905255953959433 04997252488324598727364469584868383677642782609902460824124388439242124413654976 27857977456914354977731296960898346948685558404663534220722658284886485584560285 06516842769452237467678895252138528549954666727823386476596121354886233577456498 53559363456817482408253507616947545609659699402822887973680364886963686722878894 00645535933186179256819228747829638249385894397149996759952213655497888938297849 25682998948722258804857566604270477555132379641450523746336364742858444795565807 82175714135473573952311842716670243596953633544295248293746788084546540359027993 44537423173125785399621983874478584784896823214457738687563439064302584530960484 87305879614689674913278191797939952969449663428754440643746423778392379998379085 94956886467544269323974894090748649493596256794520219514655322523160388893091219 37621378559566319377876834399667921793467221825629996638035205930680382477345492 82665414663925211497442854732518666002332434088198710486339734649450453935796268 56189555844665879699826397473658445757425913289786155082097220628043903975931567 71577914253378699360072305587631763594248738252472205369284988263864258673235795 98424848829560980659575972695722393256711632291998169481528077350679274858322287 98652093539657255280835792573698820614442122675192346712331432676373699086585463 98575019707656549685279407657668755556588879099699597833873455283386355276479285 35898206485489632952933029857164253675279278915488497559859865635880270988994309 22448095757728089059232332609729971288443357326848938239119326274536679058060424 23038630324382499675828524374417224132865518093773444030757489218291913921335385 19762408389044929329526084244485963766983895228384783125552678218141957385726243 44418930396864262434407732269780281731891844660964468232527262070226522722986803 96665573092547140557853769466820653509896523948620564769332570536356629185580007 29360659876486117940453348850346363255686753249444668639626579787788556084552965 41366542853961434443185867697514566130980072243782763913240575274947042056223053 89645673099719270004078547332699392894546649458807972708266830634328587858983359 35838713165757446795357163775259203074755765588405250676228534932266474550979259 23599479654737612551765675135759787966645487937450842696848903746399473329621073 40437578997859624589019389413111540429782856475037031986915141287080859904806094 12147221617947647982622434254854540332957685306842288937583043063321751829798662 23717215916977196925474873808665494945057465406284386639379033976926567214618733 67362965712191843638327106496274688260786925602902284725043318211869829413000422 96597849637292533707520475958456609663386294726547364253308077033754590673562350 72835405670402667435436222207725897504958098444893335973438788769625993968334193 41447377641845631298608029088687463260472756952624965860573221681694103795667353 82297436372947867242292465436630198367692823828568996441484436463741456344966894 94092432378969070627790223625382216889573837986235345937364765512289357865158416 37557828735263446542695326972037343546538967774860316996655418733879293344195216 41343899484448736567383962499347983883480927777303863873243077217545654542237772 92121155316609628008592636219759882716133231668397286193366863360627356763035447 76280350450777235757105859548702790844356240545587806246436267945622753399340783 30336254232783994975382437205835369477389926063883346776279695970304835923077909 87040854943748484408227726346564704745878477872009277652807387679077073572534447 30685749733492436231338252443163128484251219256567780694763528083047713747816437 84718509092852520756783934596562834994347595625865865570502290492529985893385572 24264829397285847831634577775626888764462482461579463395352773487354892939587617 48256047470996439643626760449256274204208924856611966254543372137535958450687724 60290161836677524661634252257749542996299593064553779924437340432875262888963995 87947572917464263574152549793916513571053694049609393251890760208252726987985318 87705842972490677863299629009049256697373727047684726860849003372724242916513715 00536832336435038901692989392234451722413412596965316784408745896012122859997662 34593773444826409038905449544400679869075485060263275252983461874078668088183385 11228334592584865855539152133289776528430635655002668282949344539765527989721754 61395398368939363839474211996653855352842056853386249672523340283067642328278929 25077926294632295669898989354288629562701621835646227134967152883900737381198934 97346223961136854066439939509790190699639552453072453585685521956733229299119439 48568034490398255935305226353436592042994745558563860234395544959778377972774411 77271117238434354394782908585986040837400635344339588856486795731547129658424589 89332323342117351545940536556790686627333799585135625734322988273723198997576406 80781119635833565944873168223602876496286744404774649779950549737425626951049007 78698683593814657712684492964871855614537233786733539066883834363565537949864092 70563692934738723920837607023029860367938627089438799262066295954973764248928307 22812690945546684760357626477379467520519475715552781965362132392649616023635832 59074227282931872735052772790055676542552487925303435039885253323215762530906425 46392291522865627169535919565897514836034822769306247435366256916378154785799528 43667957063208615391514452527473924544945423682886064340848486377670896170783024 93404341725946376484393414334123518975769352164637679693374950297085759869239798 82936429939949074362366467411833940326590840443780503332945257423995482965912285 08555722572503017125749296837242292652522711472676756222415420506884863484756836 99983966400136299627838698929165372884222691441407728862750784375167197878326992 82120660418371846535567252532567532863291742487721825399764157959847835622262914 86003465872298053298965322129174878823273427922224533985666472691495556284251693 27574202840379980663658254809269880254566181729678266427655914225194568550654653 05873825462703369316785177699747718667114965583434340693385880740386455433676323 08458768722660348943909562019939361831529168645288738437909904236747336394904555 93845304054974347574811935678913073775572902823555912885309066920376749520332299 94464676851422144772793937517834436689910433365456735475998550468450263655128862 28824462575946333039607225383742882049883538457391771519682887478265669599574494 66175634410752239709683478755355984617541738868379944697486762555665897648483588 45344277568790029065176283529416344262129642435231176006652012412526598558512861 78583823204497684423608007593045761891234982927965619875687228726750798025547695 49245563573212214333966974992356312549478024985340934923827553799830791738622515 22742995888072473625906785451333123948749675791195532673430282448860454263639548 75944822267789624825179289647669758358327438425630296924488962566874332326092752 49603579964692565049368083609003238002934595889706953653494060340286654437588909 45632882253545259661564882465151875471196258443965832397543885690945030335090261 79278332974127766514793942295298969594699576576121845609673378623625692624632086 28692257032748492186543640021947807058656459446320469279068232073883688142435698 13621963208088222468042248264977685896387439283903673672424888321513255623376798 39495215297822845337667494347456813455641725437090696939612257942986467254657846 83886244458823445934789849225284786050490252424770292547205734551050086198819769 33924638787581085754407593079422243908663938330529425786965376431116383808834389 34659653685634784699556978303829309716465143840705727468411237359984345225161050 70679562352368127648483080176918371355279121542716283548360367456286790570651748 82256981579368897669743205750596834408397550201418286724585725871457253326513490 55924009127421624843919535998953533559594427646912691409387001564563216225428832 61927645773106579329552498472758465082648369998922569596888592056007416552563796 78566722796619887782794948355834357516744585522975634434893966420527984936804352 25297598469423253312257634680002947609415979159453766955224829336655566156787364 22536665641654733770439036223295935292694445990416087532018683793792348836894591 51571637852992345292446773659495233510073270878426834974595645838408723727047131 72795431542296526667621449863746459528682436944578977233254876576524133507592043 40495340398349220233807550952290156825634274716463243354456515212669024934396739 77042595783756555506730203923749729736354964533288869574161116496362773449598273 69558822075735247665658985529098266539354948006887320685990754079234240230092590 07067389603622547564789476475483466479604994632339056518453368449569697799335234 62461477961696886885004083470405462542953699118296782468185780393889065695036650 83243297440477184567893282336943106808702742809736248093996278617472645531925385 44280858373694738872940630782655955954626296297070625948258698341116729964090894 38059534393251236235548124949824364278527138385932563989295896427487573946944272 53736694953236200453730488828556756594420735246258954873016769829886592578662242 12496655235338294287854256404838833071165372285633591525347844598183134532904299 99959823522053273365856407826484940764411376393866924883118962453698589175442647 39988228462174492087776977638679572267265556259628254276535830913407092238436577 91681284981794007680985998338492354956400572995585611349892524593669869333973513 58148918568552653087099570899527328709258487994436860256418892256917835258607859 56298848272953509537885574573742608592298817651557803905949408738065932266220593 73108048548546312228257682614165514846626744459831262548524978449254843469414627 54864932709304434039302432227488545975054742178289711277792376822578873477088091 52142298226868586705074227255126332834497627789442362167411918677943965067558577 35867364823993907604260076338704549907760436482046921823717648869341968968645895 58708736062938603890576205855272368341823834546564758834351385921633639874026374 40643549556836896423228274975330265580793453469678352858829924367497488711815893 34945331442622876228809400736877054586596877746194176964323909206248594  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 :) 1Pi? – alephalpha – 2015-08-21T13:11:26.287 @alephalpha hehe, no, it's just disguised to look like Pi – aditsu quit because SE is EVIL – 2015-08-21T13:38:04.990 Is it by any chance NULL? – Alex A. – 2015-08-23T21:48:05.463 @AlexA. no, it's not – aditsu quit because SE is EVIL – 2015-08-24T03:28:23.670 4? – TheNumberOne – 2015-08-24T17:32:11.313 @TheNumberOne no, I'd be really shocked if it works :p – aditsu quit because SE is EVIL – 2015-08-24T17:36:28.297 @TheNumberOne It doesn’t work in 4. I get ZeroDivisionError: divided by 0 with the Ruby interpreter. – Rory O'Kane – 2015-08-26T05:07:33.543 2 Nice one! This is Whirl. – Artyom – 2015-08-27T21:00:58.093 @Artyom oww you got me! – aditsu quit because SE is EVIL – 2015-08-27T21:03:29.000 16 # 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 – 2015-08-22T15:03:44.657 @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. – nimi – 2015-08-22T22:59:32.767 If it wasn't for the Foo protection, this would work in zsh. – Dennis – 2015-08-24T21:31:58.843 Just to make sure - this prints at most one newline at the end, right? – Sp3000 – 2015-08-25T04:02:05.457 @Sp3000: Yes, at most one newline. – nimi – 2015-08-25T05:21:13.690 This isn't haskell, is it? – oopbase – 2015-08-25T14:01:00.410 @alephalpha I've tried and Frege does indeed require some boilerplate. PureScript suffers from the same problem. – Dennis – 2015-08-25T16:34:23.300 1@oopbase: no, it's not Haskell. It compiles, but gives the wrong output. – nimi – 2015-08-25T18:15:54.057 1 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:). – primo – 2015-08-26T11:48:12.937 I am currently trying every single Haskell-inspired language I know of. – kirbyfan64sos – 2015-08-26T17:19:39.663 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. – Dennis – 2015-08-26T17:42:33.933 In ksh , this prints "Hello, World!", with some errors to stderr. – kirbyfan64sos – 2015-08-26T17:49:11.387 MOONSCRIPT!!!!!!!! – kirbyfan64sos – 2015-08-26T17:53:14.500 @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#. – primo – 2015-08-26T17:53:44.280 @kirbyfan64sos ksh and MoonScript both print two trailing newlines. :( – Dennis – 2015-08-26T17:57:30.043 @Dennis What about CoffeeScript? – kirbyfan64sos – 2015-08-26T18:02:36.550 @nimi The seven days have passed. Put me out of my misery and reveal the language. :P – Dennis – 2015-08-26T18:19:44.657 @Dennis: revealed the secret – nimi – 2015-08-26T18:23:56.683 Wow, I didn't even know bc existed up till now. – kirbyfan64sos – 2015-08-26T18:26:53.640 1(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. – Dennis – 2015-08-26T18:28:28.277 @primo: yes, Cyan works, but as Dennis wrote, it doesn't fulfill the requirement (Wiki, Rosetta, Esolang). Sorry. – nimi – 2015-08-26T18:30:41.290 @Dennis: see Wiki article: cat <file> | bc – nimi – 2015-08-26T18:32:19.860 @nimi I feel hat anagol was wrongfully excluded from that list :p – primo – 2015-08-26T18:43:51.663 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 – 2015-08-26T18:46:10.217 @Dennis: third newline? There are only 2. Each line ends with a single NL. – nimi – 2015-08-26T18:51:58.937 I can't even count to two... Yes, sorry, second newline. And a sneaky newline it is. – Dennis – 2015-08-26T18:53:34.213 15 # 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.  5 That would be Chef, I assume. – Angew is no longer proud of SO – 2015-08-17T12:07:14.647 @Angew Well done! :) – None – 2015-08-19T08:34:25.393 15 # 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 – 2015-08-21T17:50:45.640 @mbomb007 Nope. – Alex A. – 2015-08-21T17:54:26.113 Is this Nybbleist? – BrainSteel – 2015-08-23T02:15:43.853 @BrainSteel Nope. – Alex A. – 2015-08-23T02:23:54.737 Just a wild guess, Julia? – Beta Decay – 2015-08-24T21:51:48.317 @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.) – Alex A. – 2015-08-24T22:06:39.710 Blind guess: Suzy? – Sp3000 – 2015-08-24T23:31:10.817 @Sp3000 Nope. :) – Alex A. – 2015-08-24T23:32:13.210 Is it FALSE? maybe? – PhiNotPi – 2015-08-24T23:32:48.987 @PhiNotPi Excellent guess, but not quite there. It's Mouse. :) – Alex A. – 2015-08-25T00:02:12.100 Aw man.. I've seen Mouse (briefly), but didn't associate it with your code. Congrats! – aditsu quit because SE is EVIL – 2015-08-25T09:29:53.200 Nice, a non-esoteric language. – ceased to turn counterclockwis – 2015-08-25T14:49:59.780 15 # 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. – jimmy23013 – 2015-08-20T20:12:40.863 1No I'm wrong, it also printed the quotes... – jimmy23013 – 2015-08-20T20:17:32.063 Anyone know any languages where array indexing of a string is allowed? – mbomb007 – 2015-08-20T21:57:19.490 @mbomb007 Python and Ruby, but this ain't either. I can't think of a language that won't print quotes around the string. – lirtosiast – 2015-08-20T22:52:11.830 4 This is APL. (It works in ngn-apl, at least) – Lynn – 2015-08-21T01:04:06.613 @Mauris Correct! – Dennis – 2015-08-21T01:34:13.313 15 ## 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. – mbomb007 – 2015-08-21T02:53:22.510 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 – 2015-08-25T00:11:59.603 @kirbyfan64sos: no, only a few of the characters are ignored. Most random changes you could make to this program would brake it. – ceased to turn counterclockwis – 2015-08-25T15:11:44.843 1The 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.) – Martin Ender – 2015-08-28T10:44:03.430 A guess: it's zsh? – galexite – 2015-08-28T17:20:36.743 @georgeunix: no. – ceased to turn counterclockwis – 2015-08-30T00:35:27.177 14 # 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. 3Perl? (Probably very wrong...) – kirbyfan64sos – 2015-08-17T18:46:19.707 43@kirbyfan64sos No, far too readable for Perl. – jcai – 2015-08-17T18:54:07.570 2 At first I thought it might be ??? and I got super excited, but it turns out it doesn't work in ???. :/ – Alex A. – 2015-08-17T19:25:14.397 @AlexA. That would've been awesome! If I had known about ??? I definitely would've done it.. – jcai – 2015-08-17T19:30:05.917 @Alex_A Is there a programming language called "???"? I've never heard of it and it's impossible to Google! – Caltor – 2015-08-17T20:25:12.617 1@Caltor AlexA. just published it last night ;) – ETHproductions – 2015-08-17T21:01:16.617 @ETHproductions I'm super confused! :/ – Caltor – 2015-08-17T21:37:25.693 @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 – ETHproductions – 2015-08-17T22:09:50.997 Shakespeare? It certainly looks like Shakespeare... – sirpercival – 2015-08-19T20:18:54.913 4 This is Wordfuck. – Martin Ender – 2015-08-19T20:24:44.547 13 # Wordy, 3279 bytes #_>^ +7K1 }OU8 4>Fk ry\g 9Ff] A}kY ,6Fo IKk 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 EVV ,/~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. 0o: (#o? ,D]< X%|* ;}*h [%C &(A' ^@J^ {O[| &%&Q -;9 |j}) |z]+ :4:. 03(4 <Bhz NmY 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 MfI %#^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 5TC ,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 rv<i N>VP 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 ]f&. "K~+ =o(? 5+u^ u>(? 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.
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.

3That's one big haystack. – Sp3000 – 2015-08-20T05:51:25.930

4I guess that depends on the size of the needle. – Dennis – 2015-08-20T05:53:20.950

6Speaking of haystacks. If there isn't currently a language called "Haystack", that'd be a great name for one... – mbomb007 – 2015-08-20T21:59:12.370

@mbomb007 working on it ;) – Kade – 2015-08-24T17:19:28.857

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

– MickyT – 2015-08-27T03:36:46.397

@MickyT It's not supposed to be l33t and I don't think it could happen by accident. – Dennis – 2015-08-27T03:41:48.947

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. – MickyT – 2015-08-27T03:50:05.267

12

# Linotte, 47 bytes, cracked by ProgramFOX

HelloWorld :
début
affiche "Hello, World!"


waves baguette

2I think it's Linotte. – ProgramFOX – 2015-08-17T14:26:56.997

2@ProgramFOX C'est exact – Fatalize – 2015-08-17T14:27:57.930

12

# 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. – Dennis – 2015-08-17T19:48:20.257

You're right, this is not C++. – Luke – 2015-08-17T19:52:04.470

Maybe brainfuck? – Beta Decay – 2015-08-17T21:17:42.720

Nope, not Brainfuck! – Luke – 2015-08-17T23:19:25.127

1Maybe this is a language where # is a comment? – user41805 – 2015-08-18T04:48:05.343

2This must be Boolfuck! – aditsu quit because SE is EVIL – 2015-08-21T21:48:10.273

Yes, it's Boolfuck! – Luke – 2015-08-22T12:32:32.337

12

# Foo, 38 bytes, cracked by kirbyfan64sos

fn main(0){println!("Hello, World!");}


This looks like Rust. – Dennis – 2015-08-18T23:22:02.630

@Dennis Nope, not Rust. (Very very close, though.) ;) – Doorknob – 2015-08-18T23:22:56.933

Oh, well. +1 for that sneaky 0. – Dennis – 2015-08-18T23:27:09.857

3Is 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 – 2015-08-19T22:38:23.113

@kirbyfan64sos Yep! (This was intended to be Foo that looks like Rust.) – Doorknob – 2015-08-19T22:58:33.167

12

# 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.

8Most of the short stories I read don't end with -13>. – Alex A. – 2015-08-19T02:30:09.757

14That's an... emoticon. – Dennis – 2015-08-19T02:31:31.913

1

Works in Clip.

– jimmy23013 – 2015-08-19T07:33:38.403

@jimmy23013 It wasn't supposed to, but it does. – Dennis – 2015-08-19T08:05:09.273

I tested it in the online Pyth interpreter, but was scared off by the errors. Tricky, tricky.... – ETHproductions – 2015-08-19T14:33:27.963

11

# GolfScript, 369 bytes, cracked by ProgramFOX

.!))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))).)))))))
)))))))))))))))))))))).)))))))..))).(((((((((((((((((((((((((((((((((((((((((((((
((((((((((((((((((((((.((((((((((((.)))))))))))))))))))))))))))))))))))))))))))))
)))))))))).)))))))))))))))))))))))).))).((((((.((((((((.(((((((((((((((((((((((((
((((((((((((((((((((((((((((((((((((((((((](+


Wait a second, did I forget a paren somewhere?

4I think it's GolfScript. – ProgramFOX – 2015-08-17T16:50:00.273

35@ProgramFOX Well that lasted a whole 48 seconds. ;( – Doorknob – 2015-08-17T16:50:51.430

11

# 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... – ETHproductions – 2015-08-17T20:43:04.043

1Nope, it's not Beatnik. – Geobits – 2015-08-17T21:30:26.103

1

This is ETA I believe

– Sp3000 – 2015-08-17T22:55:35.747

2@Sp3000 sigh... I guess having it uncracked for a bit over three hours isn't bad :P – Geobits – 2015-08-17T22:57:42.800

2@Geobits That's because I was asleep for those three hours :P – Sp3000 – 2015-08-17T23:01:23.717

20@Sp3000 You should sleep longer. You need at least 168 hours of solid sleep to be healthy. – Geobits – 2015-08-17T23:15:27.913

2Someone should arrange a score to these lyrics... – h.j.k. – 2015-08-19T15:18:06.873

11

# 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
\xbe\xcd\xfc\xdc\xdd\xbd\xbb\xaa\xbe\xde\xdb\xdd\xdb\xea\xbc\xbf\xdb\xfa\xcd
\xcc\xcf\xdc\xdc\xfa\xef\xbd\xdc\xfd\xcb\xff\xdd\xbc\xac\xbb\xff\xeb\xac\xab
\xdc\xbf\xfd\xcb\xbc\xfb\xee\xae\xcb\xcf\xfb\xcd\xef\xfc\xea\xca\xbd\xee\xed
\xbc\xbf\xee\xec\xfd\xee\xed\xbb\xfc\xab\xaf\xda\xeb\xbd\xbe\xdc\xef\xaa\xda

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. 1This is Python 3. – SuperJedi224 – 2015-08-22T11:18:39.360 @SuperJedi224 Not quite. The string contains a linefeed and print appends a second one. – Dennis – 2015-08-22T12:47:20.330 I tried BrainF*** as well, but that omits the ! – SuperJedi224 – 2015-08-22T12:50:18.167 And ><> prints 10-2 and then gets stuck in an infinite loop. – SuperJedi224 – 2015-08-22T14:01:07.803 Is it deadfish x? – The_Basset_Hound – 2015-08-23T01:53:23.307 1@BassetHound That would be a huge coincidence. – Dennis – 2015-08-23T01:56:01.467 GolfScript produces Hello, World!\n2\n – primo – 2015-08-28T08:16:53.933 10 # 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. – DDPWNAGE – 2015-08-17T06:56:32.977 7 Is this Hollow? – Sp3000 – 2015-08-17T06:57:56.213 10 # GolfScript, 41 bytes, cracked by ProgramFOX begin stdout_print "Hello, World!" end  4I guess it's GolfScript. – ProgramFOX – 2015-08-17T12:06:58.940 @ProgramFOX Yes, it is. :) – Cristian Lupascu – 2015-08-17T12:07:27.110 10 # 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 hgedc baY }j  This produces the correct output in Malbolge, but not the correct byte stream. 1Would this be Wordfuck? – Sp3000 – 2015-08-20T06:45:06.087 11I spent hours writing a Malbolge polyglot and you cracked it in less than 5 minutes... :( – Dennis – 2015-08-20T06:49:01.267 10 # 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. 14Some of the most readable Perl I've seen ;) – primo – 2015-08-25T10:35:53.237 2@primo I hope that's incorrect. :P – Dennis – 2015-08-25T13:26:19.460 9eval mode? Should be evil mode. – Rohcana – 2015-08-25T15:05:45.127 10 # 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 – 2015-08-25T08:50:30.453 @ProgramFOX in the intended language, it does. – primo – 2015-08-25T09:04:44.113 It's not Python. Would've been too easy. – mbomb007 – 2015-08-25T16:45:36.860 10 # 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 – 2015-08-27T14:47:24.523 @mbomb007 It works in Clip. – Dennis – 2015-08-27T14:48:23.363 I would say it's Pyth, but I get a SyntaxError from Python! – galexite – 2015-08-28T14:16:15.280 @georgeunix Not Pyth then. :P – Dennis – 2015-08-28T16:25:44.737 Literally the interpreter gets stuck due to a SyntaxError in the interpreter, not the code! – galexite – 2015-08-28T17:06:16.770 1@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 – 2015-08-28T17:09:06.720 @Dennis oh, OK. – galexite – 2015-08-28T17:11:41.060 It works in Finite Groups. – nimi – 2015-08-29T09:28:56.860 @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.) – Dennis – 2015-08-29T13:06:04.903 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 – 2015-08-29T13:13:17.830 @nimi How practical... That worked, thanks. – Dennis – 2015-08-29T13:38:28.413 9 # ><>, 82 bytes, cracked by Sp3000 version 1.0 \0: ~~ "Hello," \1: ?? " World!" \4: ... \n: r>:~/ end; ^?)<< data  5 I believe this is ><> (Fish). Nice use of version 1.0 though :) – Sp3000 – 2015-08-17T12:36:58.123 It is! I'm glad you liked it =) – Aaron – 2015-08-17T12:40:42.857 9 # 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 |##<#,<,*^ *<:<|  3This is Glypho. – jimmy23013 – 2015-08-17T16:18:15.337 7@jimmy23013, well done. It took you less time to post the correct answer than it took me to write the submission. – Peter Taylor – 2015-08-17T17:11:05.423 9 # SQL, 37 bytes, cracked by mbomb007 start: print 'Hello, World!' -- stop.  3It works in MySQL. :) – mbomb007 – 2015-08-17T17:35:46.770 Yup, that's SQL. – Danko Durbić – 2015-08-17T17:54:44.010 2Interesting. Is it version dependent? Can't convince MySQL 5.6 to execute it. – manatwork – 2015-08-18T06:13:30.800 @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 – 2015-08-19T21:46:12.177 @mbomb007 Isn't SQL Management Studio for T-SQL only? – Alex A. – 2015-08-23T03:50:40.580 @AlexA. I meant MSSQL, which is T-SQL. – mbomb007 – 2015-08-23T21:12:49.977 9 # 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. 1 Looks like a 2D language to me... but the list is so long... – mbomb007 – 2015-08-20T17:54:38.240 I think this is some language that ignores non-decimal characters. – kirbyfan64sos – 2015-08-26T21:42:24.720 9 # 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? – galexite – 2015-08-28T13:27:28.533 @georgeunix Sorry, it's not the intended language and I'd be surprised if it worked in it. – MickyT – 2015-08-28T19:30:51.520 I believe you can reveal the language now. The 7 days are up. – kirbyfan64sos – 2015-09-02T14:22:00.780 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 – 2015-09-02T20:16:40.477 @kirbyfan64sos, it looked like it had some potential, but appears not to have been touched since 2004 and the documentation isn't the best. – MickyT – 2015-09-02T20:21:46.510 Shame it wasn't open-sourced, someone could have kept it alive – roblogic – 2019-07-07T12:55:30.303 8 # Fortran 77, 40 bytes, cracked by Reto Koradi  WRITE(*,*)"Hello, World!" END  Could be easy, might not be... Who knows ;) Looks like Fortran? – Reto Koradi – 2015-08-17T07:12:40.577 @RetoKoradi But which Fortran? ;) – Beta Decay – 2015-08-17T07:13:39.303 2Fortran 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. – Reto Koradi – 2015-08-17T07:15:55.230 @RetoKoradi Haha you're getting very warm – Beta Decay – 2015-08-17T07:16:16.030 1Well, 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. – Reto Koradi – 2015-08-17T07:21:21.620 @RetoKoradi Perfect :D – Beta Decay – 2015-08-17T07:22:03.417 @BetaDecay Valid F77 is also valid F90, F95, etc until you get into deleted features. – casey – 2015-08-18T21:29:21.337 8 # Slashes, 31 bytes, cracked by manatwork /foo/Hello, World!//bar/foo/bar or / World! World!/Hello,/ World! World! World! 5/// aka Slashes. (Using “print” instead of “foo” would make it trickier.) – manatwork – 2015-08-17T11:56:12.853 @manatwork Correct! – None – 2015-08-17T12:01:30.850 8 # 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? – vsz – 2015-08-18T15:33:54.647 If you use the language's closest equivalent to stdout, I'd think that's valid according to the rules. – tomsmeding – 2015-08-19T10:26:57.127 Almost works in MATLAB / Octave, except it prints ans =. – feersum – 2015-08-21T02:24:10.637 @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. – vsz – 2015-08-21T04:12:42.513 To print something without extraneous output, you would usually use disp or fprintf. – feersum – 2015-08-21T04:26:26.473 1Can this work in Matlab without a REPL? If not, it's not valid. – Peter Taylor – 2015-08-21T16:06:05.263 8 # 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? – Beta Decay – 2015-08-18T08:34:05.630 2That looks like snowman to me. One of my favorite esolangs. – None – 2015-08-18T12:44:04.073 @BetaDecay See https://github.com/KeyboardFire/snowman-lang/blob/master/doc/snowman.md for an explanation of snowman. – None – 2015-08-18T12:44:53.507 @Kslkgh Yep, nice work. – Alex A. – 2015-08-18T18:35:31.150 5Hahaha, nice. Insta-upvote because this is the only Snowman answer on PPCG that's not written by me. – Doorknob – 2015-08-19T00:47:08.897 8 # 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? – Nico A – 2015-08-18T21:42:49.913 @TreFox never heard of it, so most likely not a match :) – aditsu quit because SE is EVIL – 2015-08-18T21:43:53.503 1I think this is Wordfuck. – lirtosiast – 2015-08-19T00:00:47.803 @ThomasKwa nope, but interesting guess – aditsu quit because SE is EVIL – 2015-08-19T00:07:51.030 Is this Beatnik? – ETHproductions – 2015-08-19T00:57:16.947 @ETHproductions nope – aditsu quit because SE is EVIL – 2015-08-19T01:01:14.510 3wild stupid guess... "Shakespeare"? – frikinside – 2015-08-21T09:05:26.713 @frikinside no, it looks nothing like Shakespeare – aditsu quit because SE is EVIL – 2015-08-21T10:43:11.290 @aditsu that's why i said "stupid guess"! – frikinside – 2015-08-21T11:41:07.350 Is this asdf? – Bassdrop Cumberwubwubwub – 2015-08-21T13:37:59.960 @Bas no, but you're getting a bit closer – aditsu quit because SE is EVIL – 2015-08-21T13:40:45.300 Is it Grocery List? – mbomb007 – 2015-08-21T17:32:07.887 @mbomb007 no, it's not – aditsu quit because SE is EVIL – 2015-08-21T17:37:38.140 Also, someone else should check if it's ETA or not. Probably also not. – mbomb007 – 2015-08-21T17:51:59.387 I got an empty stack error when I ran it in ETA, so no. – SuperJedi224 – 2015-08-22T23:55:05.710 6Override 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)" – Martin Ender – 2015-08-25T21:55:24.880 8 # 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. – Teoc – 2015-08-26T03:57:35.617 @VladimirLenin Can't be befunge, it doesn't have any commas to print characters. – Pharap – 2015-08-26T10:37:04.587 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. – histocrat – 2015-08-26T13:10:54.177 8 # ~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 quit because SE is EVIL – 2015-08-24T19:50:49.207 @aditsu That didn't last long :) – TheNumberOne – 2015-08-24T19:53:40.030 8 # 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 quit because SE is EVIL – 2015-08-24T20:49:38.177 @aditsu Yes, its Hello, World!. Just double checked it :) – MickyT – 2015-08-24T20:51:39.917 Is it Parenthesis Hell? (It's just a crazy guess.) – kirbyfan64sos – 2015-08-24T21:15:41.487 @kirbyfan64sos sorry it's not ... well it shouldn't be :) – MickyT – 2015-08-24T21:21:59.637 Is it Parenthetic? – Alex A. – 2015-08-25T04:09:24.303 @AlexA. Sorry it's not. In Parenthetic it should output hello world rather than Hello, World! – MickyT – 2015-08-25T05:59:30.510 Ah, wait. I think it's some BF derivative that ignores parentheses! (Unfortunately, I already wasted my guess...) – kirbyfan64sos – 2015-08-25T16:52:17.367 @kirbyfan64sos I can neither confirm or deny – MickyT – 2015-08-26T01:34:35.060 8 # 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? – kirbyfan64sos – 2015-08-27T17:32:05.690 Plain text, not a hex dump! – sweerpotato – 2015-08-27T17:46:28.187 Has SE removed some of the characters? – galexite – 2015-08-28T14:30:34.917 No characters are removed – sweerpotato – 2015-08-28T22:02:13.637 Wow, that looks like a difficult language. Nice work. – DLosc – 2015-09-03T19:47:18.420 8 # 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.  1The seven days are over. I'm looking forward to learn what the intended language was. – Dennis – 2015-09-07T04:50:34.913 6Sorry, was afk getting married. – histocrat – 2015-09-07T14:03:17.143 1Congratulations! -- 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~. – Dennis – 2015-09-07T16:54:57.257 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. – histocrat – 2015-09-07T18:57:20.923 7 # 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? – Martin Ender – 2015-08-17T07:25:42.473 @MartinBüttner Nope – Beta Decay – 2015-08-17T07:26:06.237 3 Is this var'aq? – jimmy23013 – 2015-08-17T12:37:36.130 @jimmy23013 Well done :) – Beta Decay – 2015-08-17T18:55:08.813 7 # Fantom, 44 bytes, cracked by w0lf class H{Void main(){echo("Hello, World!");}}  2Fantom, right? – Cristian Lupascu – 2015-08-17T09:09:36.423 @w0lf Yep, that's correct! – ProgramFOX – 2015-08-17T09:10:22.173 7 # 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. – vsz – 2015-08-17T21:36:14.397 19{...} is a comment? That's evil. – Dennis – 2015-08-17T21:39:22.623 7 # Dogless, 85 Bytes, cracked by Sp3000 abcdef|ghijkl|mn"op"|<gAme>|<kldl>|<nHjo>|<er>|<cdAW>|<hxfo>|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! 3 Would this be dogless? – Sp3000 – 2015-08-22T23:59:24.440 Indeed it is :) – Fongoid – 2015-08-24T02:43:34.797 7 # 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. – SuperJedi224 – 2015-08-21T22:57:32.317 1 I believe this works in Enema – Sp3000 – 2015-08-23T13:03:31.057 @Sp3000 That's correct. – Dennis – 2015-08-23T14:56:15.163 7 # 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. 2Lol. Nice quick addition to prevent it working in Foo. – mbomb007 – 2015-08-25T21:05:43.930 3There seems to be a \u202f char just before the colon - is this intended? – Sp3000 – 2015-08-25T22:35:26.817 @Sp3000 Absolutely. Well spotted. – Evpok – 2015-08-25T22:39:03.630 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 – 2015-08-25T22:44:23.497 @Sp3000 Nope. That's the only non-ASCII character. – Evpok – 2015-08-25T22:50:57.303 The 7 days are up. You can reveal the language now. – kirbyfan64sos – 2015-09-01T21:02:12.857 7 # 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 – 2015-08-31T19:33:06.060 @Dennis FINALLY! – mbomb007 – 2015-08-31T19:38:15.253 Is this Cmd? It's the only thing I can think of that treats ^ specially. I'm likely wrong, though... – kirbyfan64sos – 2015-08-31T19:54:03.930 1@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. – mbomb007 – 2015-08-31T19:58:34.237 6 # 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  2Is it Java? (more chars) – Dennis – 2015-08-17T14:15:10.093 @Dennis i hoped it will be more challanging – user902383 – 2015-08-17T14:18:12.200 damn, im so sloppy i left void main:( – user902383 – 2015-08-17T14:19:03.107 10@user902383 The Unicode escapes are a rather well-known trick around here. ;) – Martin Ender – 2015-08-17T15:02:09.383 Is this suppose to be java byte code with unicode letters mixed in? – Luminous – 2015-08-17T18:45:41.310 1@Luminous Unicode escapes. \u0000 to \u007F are ASCII characters. – Dennis – 2015-08-17T23:31:42.653 6 # dc, 36 bytes, cracked by jimmy23013 13 37~i4A6B0CA06939989941081542909BP  3This is dc. (15 chars.) – jimmy23013 – 2015-08-17T18:46:59.217 @jimmy23013 Wow, you beat me to it. Also my first guess. – PurkkaKoodari – 2015-08-17T18:48:21.687 2Well, that didn't last long... – Dennis – 2015-08-17T18:49:24.893 How did you edit this post in grace period and leave the original in the revision history? – jimmy23013 – 2015-08-18T13:34:55.210 @jimmy23013 Your comment ended the grace period. – Dennis – 2015-08-18T14:22:17.470 6 # SPSS, 21 bytes, cracked by MickyT Echo "Hello, World!".  Your code on cmd produces "Hello, World!" with the quotes, which is wrong. – Nico A – 2015-08-17T22:31:18.563 (I guessed Batch, which was wrong) – Alex A. – 2015-08-17T22:59:53.280 Is it IBM's SPSS? – MickyT – 2015-08-17T23:14:29.913 1@MickyT It isn't what I had in mind. I don't have SPSS, so I have no idea if it would work. – Dennis – 2015-08-17T23:17:35.163 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 – 2015-08-17T23:20:00.827 1@MickyT I've compiled GNU PSPP and it works. – Dennis – 2015-08-17T23:34:59.640 1@MickyT I might reuse it, so I don't want to tell right now. – Dennis – 2015-08-17T23:38:34.790 Fair enough :-) – MickyT – 2015-08-17T23:39:28.973 6 # FALSE, 47 bytes, cracked by Sp3000 72,101,108,108,111,44,32,87,111,114,108,100,33,  6 I do believe this works in FALSE – Sp3000 – 2015-08-18T02:06:27.450 6 ## 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;  4 Looks like it works in GolfScript. – Peter Taylor – 2015-08-18T11:52:18.970 Jesus! Took you less than a minute. Nice work. – A Frayed Knot – 2015-08-18T11:53:02.293 6 # 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. 1This is Nim. --- – Lynn – 2015-08-19T02:33:18.413 @Mauris Correct! :) – Sp3000 – 2015-08-19T02:38:23.910 6 # 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)... – ETHproductions – 2015-08-18T19:14:49.697 Is it powershell? – MickyT – 2015-08-18T20:10:22.880 1Bah, 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. ;-) – AdmBorkBork – 2015-08-18T20:13:58.370 6 # Tiny, 37 bytes, cracked by Sp3000 Echo "Hello," and " World!". End. "!"  Nice use of "!" to prevent this from working in Foo. :) – kirbyfan64sos – 2015-08-19T20:37:37.130 3I love the output in GolfScript: World! World! World!! – ETHproductions – 2015-08-20T16:27:32.670 1 Works in Tiny. The hardest part was trying to find an interpreter, which is available here. – Sp3000 – 2015-08-22T23:14:03.673 @Sp3000 After reading the esolang page, I'm not entirely sure why, but yes, it works in Tiny. – Dennis – 2015-08-22T23:53:24.230 6 # 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? – Grant Davis – 2015-08-20T23:20:27.420 It is not, sorry. – histocrat – 2015-08-21T00:34:45.813 2 This is Gibberish. – Dennis – 2015-08-26T05:03:03.900 6 # 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). – kirbyfan64sos – 2015-08-25T00:24:09.307 It's using S-expressions, which aren't as popular as they once were. – Pharap – 2015-08-26T10:32:29.203 6 # 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. 6 # 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. – mbomb007 – 2015-08-24T22:44:21.747 A wild guess, is it Fishing? – MickyT – 2015-08-25T19:56:14.660 @MickyT Good job, yes it is. – TheNumberOne – 2015-08-26T16:26:10.293 1@mbomb007 It was the entry following Fish :P – TheNumberOne – 2015-08-26T16:38:35.660 6 # 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). – kirbyfan64sos – 2015-09-02T17:41:15.283 @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 "@". – kirbyfan64sos – 2015-09-02T17:41:55.590 – Dennis – 2015-09-02T18:22:37.703 6 # 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... – galexite – 2015-08-28T13:37:35.583 If so, then the /s are a give away – galexite – 2015-08-28T13:37:55.910 1@georgeunix Nope. – kirbyfan64sos – 2015-08-28T13:38:16.393 Nope. Isn't sed. – galexite – 2015-08-28T13:39:12.833 I'm not entirely sure why, but your code works in rs. – Dennis – 2015-08-31T05:02:42.837 Oh, this is simply replace-append-replace with two non-matching patterns, right? I was overthinking this... – Dennis – 2015-08-31T05:53:26.187 @Dennis Yes, it is! – kirbyfan64sos – 2015-08-31T13:54:10.847 6 # 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 – 2015-09-03T18:46:55.390 @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. – DLosc – 2015-09-03T19:41:25.590 6 # 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. 6 # ///, 84 bytes /"""""\ | _ _ | ||.|_|| ||_|__| / \_______________ \________________/Hello, World!  Hopefully this isn't too easy or a polyglot. 5 # Javascript, 785 bytes, cracked by ProgramFOX =~[];={___:++,:(![]+"")[],__:++,__:(![]+"")[],__:++,_:({}+"")[],_:([]+"")[],_:++,_:(!""+"")[],__:++,_:++,__:({}+"")[],_:++,:++,___:++,__:++};._=(._=+"")[._]+(._=._[.__])+(.=(.+"")[.__])+((!)+"")[._]+(.__=._[._])+(.=(!""+"")[.__])+(._=(!""+"")[.__])+._[._]+.__+._+.;.=.+(!""+"")[._]+.__+._+.+.;.=(.___)[._][._];.(.(.+"\""+.__+._+"\\"+.__+._+._+"\\"+.__+._+._+._+(![]+"")[.__]+._+"."+(![]+"")[.__]+._+"\\"+.__+.__+.+"(\\\"\\"+.__+.__+.___+._+(![]+"")[.__]+(![]+"")[.__]+._+",\\"+.__+.___+"\\"+.__+.__+.+._+"\\"+.__+._+.__+(![]+"")[.__]+._+"!\\\"\\"+.__+.___+")"+"\"")())();  3This is JavaScript. – ProgramFOX – 2015-08-17T07:45:34.733 @ProgramFOX Correct! – Fatalize – 2015-08-17T07:47:08.383 5 # 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 – 2015-08-17T10:49:04.110 @Sp3000 You got it! – Martijn – 2015-08-17T10:50:14.843 5 # 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. 3I'm guessing it's Plankalkül. – ProgramFOX – 2015-08-17T14:21:47.487 @ProgramFOX Correct! – None – 2015-08-17T16:12:04.420 5 # 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 )  1Would this be ferNANDo? – Sp3000 – 2015-08-22T12:27:29.803 1It's valid python too, just doesn't product "Hello, World!" :p – primo – 2015-08-22T12:29:39.387 5 # 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 – 2015-08-23T05:54:18.387 @alephalpha Great, that lasted about 60 seconds. :P – Alex A. – 2015-08-23T05:59:40.590 5 # FlogScript, 21 bytes, cracked by Sp3000 1.{Hello, World!}PrP_  3 Braces, you say? Well it must be... puts on sunglasses... FlogScript – Sp3000 – 2015-08-26T02:23:13.023 @Sp3000 Yes, that's it... – mbomb007 – 2015-08-26T14:44:28.803 5 # 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. :) – kirbyfan64sos – 2015-08-26T19:38:42.320 1This has to be ILLGOL. – Dennis – 2015-08-27T01:22:35.783 @Dennis How do you know these things? – TheNumberOne – 2015-08-27T01:39:06.103 3@TheNumberOne Dennis knows all. – kirbyfan64sos – 2015-08-27T02:00:25.640 4 # 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. 2Looks like Prelude to me. :) – Martin Ender – 2015-08-17T08:55:06.340 @Martin Correct :) – Sp3000 – 2015-08-17T08:56:16.053 4 # 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. 2 That's CJam. – Martin Ender – 2015-08-17T18:47:31.377 @MartinBüttner Correct. – PurkkaKoodari – 2015-08-17T18:50:05.017 4 # 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((curryadd of(int^2))*(&^)).map*(&/);  Could this be PHP? – mbomb007 – 2015-08-21T18:28:05.133 @mbomb007 Not even close. :) – kirbyfan64sos – 2015-08-21T18:39:14.757 Is it Turing by any chance? – aditsu quit because SE is EVIL – 2015-08-21T20:13:19.010 @aditsu Nope. Again, not close. – kirbyfan64sos – 2015-08-21T20:22:59.863 1This looks quite like it could be Felix. – ceased to turn counterclockwis – 2015-08-22T00:33:09.543 @ceasedtoturncounterclockwis Indeed, it is. :/ What gave it away? – kirbyfan64sos – 2015-08-22T20:06:12.987 println. Dollar-postfixing is strangely recognisable. – ceased to turn counterclockwis – 2015-08-22T20:13:01.877 4 # 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. 1 I'm going to take a guess and say Gnuplot (tested here) – Sp3000 – 2015-08-18T00:48:57.677 Is this matlab? – user41805 – 2015-08-18T04:45:47.967 4 # 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  4Is it MIPS assembly? If yes, the first \n probably shouldn't be there. – Dennis – 2015-08-18T00:04:19.697 4 # Foo, 28 bytes, cracked by Doorknob Echo "Hello," and " World!".  This appears to work in the Foo language. – Doorknob – 2015-08-19T01:31:30.630 @Doorknob That's an accident, but yes, it does. – Dennis – 2015-08-19T01:33:52.143 @Dennis Out of curiosity, what was this intended to be in? – Doorknob – 2015-08-19T01:36:11.877 @Doorknob This is the second incarnation of this idea that works in another language. Give me one more try. – Dennis – 2015-08-19T01:37:46.197 4 # 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(aN_9]~ [}|{y Vx Bedc> rM_L nmk Hjhhf|Bd?  2 This has to be Malbolge! – Kade – 2015-08-18T16:55:02.630 4 # Tri, 53 bytes, cracked by jimmy23013 int Main() { Display (Hello, World!); Return 1; }  Seems to work in Grin :D – aditsu quit because SE is EVIL – 2015-08-21T22:16:21.547 @aditsu Nope, it prompts for user input in Grin (just tried it). – Doorknob – 2015-08-21T22:27:10.303 6But it prints... why does it matter... ( ╯°□°)╯ ┻━━┻ – aditsu quit because SE is EVIL – 2015-08-21T22:29:00.513 1 Is this Tri? – jimmy23013 – 2015-08-24T15:13:03.950 @jimmy23103 Yes, it is. – Doorknob – 2015-08-24T16:47:27.373 4 # 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 – 2015-08-19T09:50:31.603 @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. – ugoren – 2015-08-19T12:11:49.837 1stderr 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. – jimmy23013 – 2015-08-19T13:22:54.260 4 # 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. – ETHproductions – 2015-08-20T16:33:07.020 4 # 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 – 2015-08-20T21:39:12.197 @Dennis yeah, It's JavaScript – Downgoat – 2015-08-20T21:39:53.807 4 # 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 – 2015-08-26T12:26:30.440 @histocrat I kinda saw this coming... – Dennis – 2015-08-26T13:40:15.220 4 # 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. – mbomb007 – 2015-08-25T00:00:32.197 Is that w in !dlrow, olleH supposed to be lowercase? – mbomb007 – 2015-08-25T00:01:59.080 @mbomb007 No. I'll fix that. – ASCIIThenANSI – 2015-08-25T15:40:34.760 You'll probably also want to change [119] to [87], then? – mbomb007 – 2015-08-25T16:38:49.660 @mbomb007 Yes. I've already fixed that. – ASCIIThenANSI – 2015-08-25T18:00:02.067 Wild guess, is it befunge? – MickyT – 2015-08-25T19:26:32.270 Nope, now I think it isn't – MickyT – 2015-08-25T19:33:33.967 1 This is Blank. – Dennis – 2015-08-26T05:18:18.480 @MickyT No, it outputs {Hello ,W in Befunge. – ASCIIThenANSI – 2015-08-26T16:51:45.370 @Dennis You got it! I've updated the post. – ASCIIThenANSI – 2015-08-26T16:52:03.893 Yeah, this is the language I saw before. I would've found it eventually if I was looking. – mbomb007 – 2015-08-26T20:46:43.253 4 # 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? – Sp3000 – 2015-08-26T00:24:39.533 Yes! That one went down pretty fast. – Lynn – 2015-08-26T00:30:41.140 4 # 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: 1. Log 'Hello World' 2. Open a dialog, asking for 'E', and stores it in B. 3. Save B in variable A. 4. Return the variable A as a result. Are you sure that prints Hello, World!? – Dennis – 2015-08-26T14:32:06.113 I apologise, @Dennis. Corrected! – galexite – 2015-08-26T14:32:42.763 →, ⏎, and ⌟ are symbols required for the program to work. It crashes if they are not there. – galexite – 2015-08-26T14:38:09.250 1I still don't see a comma. Also, according to the question, you should provide a hexdump and add a header with your byte count. – Dennis – 2015-08-26T14:45:00.017 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. – galexite – 2015-08-26T14:50:26.393 1@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)." – mbomb007 – 2015-08-26T14:53:03.033 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. – galexite – 2015-08-26T14:53:58.957 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... – mbomb007 – 2015-08-26T14:55:29.553 The display shows a newline, but the ⏎ symbol means a newline on the display. The simulators are free. – galexite – 2015-08-26T14:56:40.700 1That's why we need a hex dump. Are there two newlines or just one? Is it all unicode? – mbomb007 – 2015-08-26T14:57:26.943 1I'll try a hex dump from a simulator. – galexite – 2015-08-26T14:58:53.867 3Let me guess: Casio BASIC? – Dennis – 2015-08-26T17:26:05.083 Yes! It's correct! – galexite – 2015-08-26T17:28:43.810 4 # Foo, 57 bytes, cracked by Sp3000 @10@33@100@108@114@111@87@32@44@111@108@108@101@72(10&c)  1Is this Foo? (15 chars) – Sp3000 – 2015-08-26T18:46:55.637 @Sp3000 you got it :) – aditsu quit because SE is EVIL – 2015-08-26T18:48:04.487 4 # 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 "Hella, 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: 1. 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. 2. 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. 4 # 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 – 2015-08-28T14:10:47.760 @mbomb007 If that's a guess, I'll check. – Dennis – 2015-08-28T16:25:21.290 It's not a guess. I checked. I'm only commenting to share my thoughts with other would-be/hopeful robbers. – mbomb007 – 2015-08-28T18:07:21.627 3 # 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. 3I do believe this is Marbelous, but the w is lowercase – Sp3000 – 2015-08-17T14:27:51.163 Oh, darn. You are, of course correct. It'll probably be best if I don't edit this any more. – EagleV_Attnam – 2015-08-17T14:29:37.330 Glad you had fun with Marbelous :) (unfortunately the overall character set gives it away) – Sp3000 – 2015-08-17T14:31:40.090 Yes, the characters appearing in pairs are dead giveaways. – EagleV_Attnam – 2015-08-17T14:33:18.217 3 # (Intel) Fortran-90, 39 bytes, cracked by Alex A. Here's one: program end print *,"Hello, World!" end  2Is it Fortran 90? – Alex A. – 2015-08-17T18:30:01.417 @AlexA. It appears to be a mix of FORTRAN 70 and FORTRAN 90. Never seen that before. – None – 2015-08-17T19:14:39.653 2@Kslkgh It works as expected in Fortran 90. – Alex A. – 2015-08-17T19:23:29.857 @Kslkgh: Just F90, as far as I know.... There's certainly similarities. What made you say F70? (I've not heard of that!) – jvriesem – 2015-08-17T21:28:32.237 @jvriesem Sorry, I meant F77. F90 has lowercase keywords but F77 uses END. I'm just used to seeing end program NAME in F90. – None – 2015-08-18T07:15:57.193 3 # Retina, 15 bytes, cracked by Dennis .* Hello, World!  Each line is in a separate file. Retina. (15 chars) – Dennis – 2015-08-17T22:22:19.230 3 # Z80, 28 bytes, cracked by Dennis 219F9D EF0A45 EF2E45 C9 48692100  2Z80 machine code. – Dennis – 2015-08-17T23:56:48.170 1That C9 (ret) kinda gives it away :-) – Luis Mendo – 2015-08-19T17:07:16.140 2Saying 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. – Stig Hemmer – 2015-08-20T08:14:15.243 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. – Misha Lavrov – 2017-11-27T19:15:17.790 3 # 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. 1It works in Ruby – Downgoat – 2015-08-18T23:06:10.287 Nice one, the meaningless parens threw me off. – histocrat – 2015-08-19T00:33:57.020 @vihan's got it! – KChaloux – 2015-08-19T12:08:36.197 3 # 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!"  1 I believe this is Muriel – Sp3000 – 2015-08-22T17:21:08.650 @Sp3000 That's correct! – Dennis – 2015-08-22T17:22:40.000 3 # 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 – 2015-08-21T19:21:49.307 1@Dennis: Yes, yes it is. – SuperJedi224 – 2015-08-21T20:41:36.317 3 ## PATH, 509 bytes, cracked by alephalpha +++++\+++++/ v+++++/+++++\/+++\ \+++++/+++++/+++++\ /+++++/+++++/+++++/ +-----+ +-----+ +-----+ +-----+ +-----+ \+++++/+++++/^---!-----------/------------\ /+++++/++++++/+++++/+++++\+++v+\+++++/++++.\ \++.++/++++++++++/-+-+++++++./++++++++++++/ /.++++/++..\+++++\++++++++++\ \+++++/.+++/ v++++}/ >++++++++++++++++++++++++++++^ /+++++++++++++++++++++++++++/-v +++/\//---------------------/ +++--+- +++-.+- +++--+- +++--.- +++---- +++.-+- ++++-+- ++++-+- ++++-.- +++.-.- \.{/.+- /{{/\}/#.---------------------/  My attempt. Don't know if it's easy or hard. 1 Is it PATH? – alephalpha – 2015-08-23T06:39:17.037 @alephalpha Well, I guess it's good that it lasted a few hours... – The_Basset_Hound – 2015-08-23T14:33:52.390 3 # 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.

1

Is this Rail?

– Alex A. – 2015-08-23T21:37:54.727

2It's a shame one can't get around the $...'main' isn't it? :/ – Martin Ender – 2015-08-23T21:39:41.023 @AlexA. it is rail and yep the$ 'main' is the big give away:) – MickyT – 2015-08-23T21:48:37.240

3

# 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.

3

Is this code for the Jasmin assembler? :D

– BrainSteel – 2015-08-24T02:47:54.803

3

# Foo, 61 bytes, Cracked by Dennis

Display "Hello, World!".
Stop eating large quantities of food.


This should work in Foo. – Dennis – 2015-08-24T18:25:36.443

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

– Dennis – 2015-08-24T19:02:06.927

@Dennis I didn't intend for this to work in foo :( – TheNumberOne – 2015-08-24T19:25:59.940

14@TheNumberOne: Welcome to the club! – nimi – 2015-08-24T21:11:08.633

2So what was it supposed to be? – msh210 – 2016-05-18T22:13:54.050

3

# O, 21 bytes, cracked by kirbyfan64sos

"Hello,"" World!"+p"?


1I believe this works in O. – kirbyfan64sos – 2015-08-26T20:15:28.790

Just confirmed it. This is O. – kirbyfan64sos – 2015-08-26T20:19:53.520

@kirbyfan64sos YAP (yet another polyglot). – Dennis – 2015-08-26T21:43:32.623

This wasn't meant to work in O? I'm starting to have pity on you from all these polyglot answers... – kirbyfan64sos – 2015-08-26T21:45:03.973

(And you forgot to say who cracked it. :) – kirbyfan64sos – 2015-08-26T21:45:38.287

3

# 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.

– kirbyfan64sos – 2015-08-26T16:47:44.990

It's also not a valid sed program, so the ;d is also a false alarm. – kirbyfan64sos – 2015-08-26T16:47:57.437

That's interesting! – galexite – 2015-08-26T16:56:02.157

3

Is it Io by chance?

3

# Whenever, 30 bytes, cracked by Dennis

1 print("Hello, World"+U(33));


1This is Whenever. – Dennis – 2015-08-27T03:14:57.713

@Dennis Whatever :| – TheNumberOne – 2015-08-27T04:40:20.533

3

# Fob, 371 bytes, cracked by Dennis

Helo, Wld!#&<>$$#<&$$::#<&$:####<&#<&$:#<=#<&$&//%<//<.++++++{+++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++.++++++++.>.+++.-------.--------.>+.>.&%<<<%%%%%.%<&>/////%<<%.<&.%<.%/////<&.%<<&/.%%<&>%<<</%<//////////////<&.%<<%%%%/<&.%%<&&&&&&&&&&&>/%//<&.%<</&.%%%<&>>/>>$<>>Hello, World!#&<>#<&=&$Hello, World!#<>$HELLO, WRRLLD!#$<>Helo, Wld!#&<>  Is this L00P? – mbomb007 – 2015-08-26T20:52:25.173 Nope, this is not L00P! – sweerpotato – 2015-08-27T05:16:47.943 This is Fob. – Dennis – 2015-08-27T13:50:06.227 Yes, indeed it is! – sweerpotato – 2015-08-27T13:52:20.003 3 # 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. 3 # Crystal, 45 bytes def not a "Hello, World!" end puts not "ruby"  Hello, World!  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. – Martin Ender – 2015-09-01T16:41:44.307 The seven days are over. What was the intended language? (My money is on unruby.) – Dennis – 2015-09-09T04:43:56.127 @Dennis Crystal. :) – kirbyfan64sos – 2015-09-09T14:01:50.713 Ah, and you even used the language on another question. – mbomb007 – 2015-09-09T16:41:46.367 @mbomb007 Yup; I got scared because I thought I gave this answer away. – kirbyfan64sos – 2015-09-09T16:54:39.980 3 # Mouse-2002, 23 bytes "Hello, World"66 2*4/!'  this could be shorter and still be safe but eh. 3Note 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." – Martin Ender – 2015-12-10T12:03:01.517 1I'm aware; I just want to see if anyone will figure it out. – cat – 2015-12-10T12:05:24.510 2 # 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. – Unrelated String – 2019-08-16T00:30:59.847 1@UnrelatedString That's correct! – MilkyWay90 – 2019-08-16T02:56:26.890 2 # Whitespace, 168 bytes cracked by pppery Looks like:  print("Hello World")  Try it to find out Works in Whitespace – pppery – 2020-05-29T20:00:40.947 Nice job! I thought that would be tough. – Ari – 2020-05-29T20:26:37.143 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. – pppery – 2020-05-29T21:21:16.960 Yeah, I started with no spaces and unfortunately Python doesn't care about trailing whitespace. – Ari – 2020-05-30T00:29:24.907 2 # ???, 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? – Ari – 2020-08-01T14:47:29.130 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). – Pizgenal Filegav – 2020-08-01T16:57:39.733 2 # ???, 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 – Razetime – 2020-10-11T05:43:13.277 http://shakespearelang.com/ – Razetime – 2020-10-11T05:52:15.187 – Scott – 2020-10-11T09:17:30.553 @Razetime Seriously, did you look any farther than [Enter Romeo and Juliet]? – PkmnQ – 2020-10-11T11:16:12.667 1@PkmnQ This is my first cops and robbers challenge. Just wanted to try. – Razetime – 2020-10-11T11:17:38.733 @Razetime Oh, ok. Make sure to always check red herrings. – PkmnQ – 2020-10-11T11:18:41.013 This works in Foo: Try it online! – Sisyphus – 2020-10-12T01:31:12.537 @Sisyphus Hmm, That's unfortunate - it wasn't the language I wrote it in... – Scott – 2020-10-12T02:13:08.447 2 # ActionScript 3.0, 23 bytes, cracked by Chirag64 trace("Hello, World!");  2Just to double check - does this language have a free interpreter/compiler? I'm not sure the one I have in mind does. – Sp3000 – 2015-08-17T12:21:33.523 Is it GML? – absinthe – 2015-08-17T12:23:12.727 4Looks like ActionScript 3.0 – Chirag Bhatia - chirag64 – 2015-08-17T12:23:41.943 @Sp3000 Flex SDK. – None – 2015-08-17T13:59:49.527 @Chirag64 Correct! – None – 2015-08-17T14:00:03.457 3 I hope you didn't just stop to the first example in http://c2.com/cgi/wiki?HelloWorldInManyProgrammingLanguages ;) – Aaron – 2015-08-17T16:03:51.210 @Pyrrha GMS would be { show_message('Hello, world!'); } – None – 2015-08-17T16:32:58.953 2 # 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!"? – ProgramFOX – 2015-08-17T14:37:41.953 No, should I fix that? I guess I mistyped it. – bmarks – 2015-08-17T14:38:12.517 I believe it's better if you fix that. – ProgramFOX – 2015-08-17T14:38:38.420 @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 .....) – Caltor – 2015-08-17T15:47:21.787 World is capitalised because it is a proper noun (you are addressing someone or something as World). The comma I can't explain though. – bmarks – 2015-08-17T16:09:22.300 @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. – None – 2015-08-17T16:15:55.683 @bmarks I don't think World is a proper noun. See http://www.answers.com/Q/Is_the_word_%27world%27_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 – Caltor – 2015-08-17T16:53:23.353 1 The comma is there to offset a vocative. But the capital W is odd. – Peter Taylor – 2015-08-17T17:12:37.810 2It looks like Stata, but I don't think there is a free interpreter available. – jimmy23013 – 2015-08-17T17:57:49.680 @jimmy23013 I was about to say the same thing. You're correct, there is no free Stata interpreter or open source equivalent languages. – Alex A. – 2015-08-17T18:38:46.280 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. – bmarks – 2015-08-17T19:22:20.177 I thought the idea was to obfuscate the language or am I missing something? – Caltor – 2015-08-17T20:32:16.783 @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 – bmarks – 2015-08-18T16:27:22.337 2 # 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. 2This would be PHP, but you're missing a <?. – Doorknob – 2015-08-17T15:15:44.930 1No <? is missing if you run it from command line with php -r. (The tricky part is to pass it that code as parameter.) – manatwork – 2015-08-17T15:31:24.253 @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! – Caltor – 2015-08-17T15:44:00.673 4<?="Hello, World!"?> would be hard to beat for size but anybody over the age of 5 should be able to guess it. – Caltor – 2015-08-17T15:52:42.907 @Caltor When we are at it, Hello World works too, even in multiple languages ;-) – Paŭlo Ebermann – 2015-08-22T13:44:01.983 2 ## 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  2I guess it's Whitespace. – ProgramFOX – 2015-08-17T17:02:45.967 Well dang, that was quick, nice work – Cain – 2015-08-17T17:06:06.667 This actually prints Hello, world! (lowercase W). – Dennis – 2015-08-23T05:21:44.973 2 # 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. 1I believe this is TI-BASIC. – jcai – 2015-08-17T20:39:10.533 2 # GolfScript, 33 bytes, cracked by Martin Büttner #include <cstdio> "Hello, World!"  Also works in PowerShell, which is what I was going for. 1 This works in GolfScript (whether that was your intention or not ;)). – Martin Ender – 2015-08-17T20:48:02.637 See, I tried some of the easier ones that I could think to test, but apparently not enough of 'em. – AdmBorkBork – 2015-08-17T20:49:57.873 where is the free powershell interpreter? – Jasen – 2015-08-22T10:28:17.267 @Jasen - PowerShell is included for free on any version of Windows released in the past 8+ years. – AdmBorkBork – 2015-08-24T12:31:34.580 @TimmyD so I've gotta buy windows then? seems not-free to me. – Jasen – 2015-08-25T04:14:42.893 @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? – AdmBorkBork – 2015-08-25T13:03:10.950 ISTR Octave can run Matlab code. – Jasen – 2015-08-26T04:59:44.167 @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. – AdmBorkBork – 2015-08-26T15:47:58.530 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 – 2015-09-01T23:30:26.427

1

@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.

1

@Jasen Thanks to another commentator on a different thread, I've just learned about Pash, so I'm passing that along here as well.

2

# Postscript, 56 Bytes, cracked by vihan

(Hello, World!) = %Hello, World!%; return Hello, World!;


Probably very easy to rob :-)

1I'm going to guess PostScript? – Downgoat – 2015-08-17T22:26:15.483

@vihan correct :) – MickyT – 2015-08-17T22:27:31.283

2

# 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.

2

– Downgoat – 2015-08-17T22:40:13.713

No, it's not Haskell. – nimi – 2015-08-17T22:41:07.860

Pure? Mercury? (Probably neither!) – kirbyfan64sos – 2015-08-17T22:49:30.030

@kirbyfan64sos: don't know, I don't have them installed. If so, then by accident. Can someone verify? – nimi – 2015-08-17T22:54:51.693

@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. – nimi – 2015-08-17T23:11:09.877

2@kirbyfan64sos According to the question, you only get one guess per answer. – Dennis – 2015-08-18T00:30:52.183

Quoting the question: "It doesn't matter if this is the language the cop intended." – Leif Willerts – 2015-08-18T11:02:20.970

@LeifWillerts: Why your comment? – nimi – 2015-08-18T18:30:37.810

1@LeifWillerts In haskell this prints the quotes also. – TheNumberOne – 2015-08-18T19:36:46.813

3

This works in Foo.

– Dennis – 2015-08-19T01:44:30.143

@Dennis: Yes, it works in Foo (but was not intended). Because of this meta discussion I've added a remark to my post.

– nimi – 2015-08-19T17:16:45.163

1I'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 – 2015-08-19T17:26:01.653

@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. – nimi – 2015-08-19T17:34:05.017

2

# Argh!, 33 bytes, cracked by Thomas Kwa

#!Hello, World!#
llPPPPPPPPPPPPPq


1

Is this Argh!?

– lirtosiast – 2015-08-18T00:15:27.733

7Argh! You got me. – Dennis – 2015-08-18T00:20:05.797

6In case you wonder how, I guessed that the q meant "quit", and then searched esolangs for "quit". – lirtosiast – 2015-08-18T00:21:36.570

2

## A:;, 19 bytes, cracked by Sp3000

o:Hello, World!;p:o


6

Would this be A:;?

– Sp3000 – 2015-08-18T01:44:02.833

2

# 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.

8

This is my very own Snowman. :)

– Doorknob – 2015-08-19T00:52:35.927

@Doorknob Correct! – None – 2015-08-19T06:49:39.517

1Your 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 – 2015-08-19T10:31:27.607

@Doorknob Oh yeah, seen that in the documentation, I'll edit. – None – 2015-08-19T10:34:20.617

4♫ Doorknob wanted to build a snowman ♫ – mbomb007 – 2015-08-19T21:32:31.127

1@mbomb007 ♪ Come on, let's go and code... – Doorknob – 2015-08-21T03:00:52.253

2

# BASIC, 25 bytes, cracked by Kslkgh

PRINT "Hello, World!"
END


This shouldn't take long, but this guy has special meaning to me.

1Looks like BASIC to me. – None – 2015-08-18T11:50:36.183

3Pretty BASIC huh? – Luminous – 2015-08-18T11:55:58.873

2

# Unlambda, 57 bytes, cracked by jimmy23013


#hello#

.H.e.l.l.o.,. .W.o.r.l.d.!
return


4Is this Unlambda? – jimmy23013 – 2015-08-18T15:03:26.023

1Aww man, could you at least give me a minute? :p – aditsu quit because SE is EVIL – 2015-08-18T15:04:01.627

2

# rs, 26 bytes, cracked by Dennis

print
pr.nt/ World!
Hello,


This lasted 56 seconds. Yay. :/

2Just guessing: rs? – Dennis – 2015-08-18T16:56:09.137

@Dennis Damn, you're way too fast. That lasted a whole 56 seconds. :( – kirbyfan64sos – 2015-08-18T16:56:53.157

1Knowing you + the regexy look of line 2 were one hint too many. There's a reason I haven't posted a CJam answer yet. :) – Dennis – 2015-08-18T17:01:45.673

2

# Malbolge, 112 bytes, cracked by Martin Büttner

('&%:9]!~}|z2Vxwv-,POqponl$Hjihf|B@@>,=<M:9w6$GVV2TSn.Oe*c;(I&%$#"mCBA?zxxvuPb8qo42mZF.hIy*@dD'<;_?!\}}|z2VxSSQ  This is Malbolge. – Martin Ender – 2015-08-18T18:45:51.823 1Darn, I was going to say the same thing... – ETHproductions – 2015-08-18T18:46:37.760 2 # 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.) – Lynn – 2015-08-19T00:37:47.197 2 # Ruby, 30 bytes, cracked by jimmy23013 system("echo 'Hello, World!'")  Now just TRY to guess this one! Works in Ruby.. – jimmy23013 – 2015-08-19T10:05:51.720 I tried my almost flawless trick that didn't work – ooransoy – 2015-08-19T10:07:34.710 Were you trying to make it C++? – mbomb007 – 2015-08-20T01:58:58.760 could be several dialects of basic too – Jasen – 2015-08-22T10:31:52.493 It also works in R, just fyi. – Alex A. – 2015-08-23T05:57:11.753 2 # 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!! 1 I believe this is written in the Arduino programming language. – Kade – 2015-08-19T13:05:33.463 2 # Underload, 34 Bytes, cracked by Mauris (l):*(He)~*(o):(, W)~***(rld!)*:!S  I'm guessing it's Emoticon. – ProgramFOX – 2015-08-19T16:28:51.967 @ProgramFOX Nope :) – Kade – 2015-08-19T16:30:36.387 Is this Underload? – Lynn – 2015-08-20T04:02:21.973 @Mauris Yes it is, well done :) – Kade – 2015-08-20T12:54:14.220 2 # 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. – Dennis – 2015-08-20T02:47:53.957 Nope, this is not CS. – Grant Davis – 2015-08-20T13:54:22.953 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. – Dennis – 2015-08-20T14:00:38.427 Well you don't need to convert it to JS because it is already in JS. – Grant Davis – 2015-08-20T15:02:53.283 Which version? Backticks don't seem to evaluate in my interpreters. – Dennis – 2015-08-20T15:14:19.783 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. – Grant Davis – 2015-08-20T15:56:17.500 2That'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... – Dennis – 2015-08-20T16:39:54.550 You are right, the back ticks aren't supposed to be there. I wonder how they got there. – Grant Davis – 2015-08-20T17:04:51.903 2If 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. :) – Dennis – 2015-08-20T17:12:14.740 2 # 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 – 2015-08-20T05:39:17.433 1@Dennis That lasted about 45 seconds :/ – Downgoat – 2015-08-20T05:39:59.743 Well, there are only that many languages that mix tabs and spaces, and this doesn't really look like Python... :P – Dennis – 2015-08-20T05:45:03.283 I've tested on WS2JS and it printed Hello, world! (lowercase W). – Dennis – 2015-08-23T05:22:42.877 2 # WTFZOMFG, 19 bytes, cracked by jimmy23013 '"'Hello, World!"'"  Is this WTFZOMFG? – jimmy23013 – 2015-08-20T08:25:04.740 2 # Tcl, 102 bytes, cracked by jimmy23013 proc = main[] { puts "Hello, World!" ;; return } = BEGIN return ;; main["Hello, World!"] = END  It works in Tcl. – jimmy23013 – 2015-08-20T09:08:25.697 Grr! All those nice = signs wasted. Yes, is Tcl. – manatwork – 2015-08-20T09:14:51.543 2 # 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&%$#"?zvuPb8qo42mZ.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 1Well, it's NOT Headsecks..., and not Golfscript. – mbomb007 – 2015-08-20T16:42:11.097 Was not written as Malbolge, does it produce the expected output? – Fongoid – 2015-08-20T16:59:59.770 @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 – 2015-08-20T19:11:43.847 @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. – Dennis – 2015-08-20T20:10:23.400 2 I believe this works in Enema – Sp3000 – 2015-08-23T13:29:07.093 Yarp :) It does indeed. – Fongoid – 2015-08-24T02:44:50.293 2 # 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  1 I'm 99.99% sure this is Grocery List. – ETHproductions – 2015-08-20T19:56:35.380 You are correct – Grant Davis – 2015-08-20T20:24:20.590 7Where did you find an interpreter for Grocery List? – Dennis – 2015-08-20T20:26:29.703 2 # 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. 1Mmmm()? I see it's your language :) (although that's not how I found it) – Sp3000 – 2015-08-20T23:38:33.420 @Sp3000: Yes indeed. – SuperJedi224 – 2015-08-20T23:43:51.323 2 # 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. 12This is that Stack Exchange. – Martin Ender – 2015-08-21T17:25:24.663 Is this Binaryfuck? – mbomb007 – 2015-08-21T17:29:09.830 Is this You are Reading the Name of this Esolang? I didn't find an interpreter, though. – jimmy23013 – 2015-08-21T17:31:00.220 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. – Grant Davis – 2015-08-21T17:33:25.833 @GrantDavis The download contains only an html file describing this language. – jimmy23013 – 2015-08-21T17:35:53.473 Hmm, well I used the spoon interpreter twice.http://www.dcode.fr/spoon – Grant Davis – 2015-08-21T17:37:28.430 2 # 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 – 2015-09-03T19:44:27.370 @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 >.) – mbomb007 – 2015-09-03T19:44:47.060 2 # 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? – mbomb007 – 2015-08-31T03:58:22.450 No, FlogScript uses {} for strings. – Dennis – 2015-08-31T04:04:18.860 It just reminded me of it, b/c Pa prints an array. – mbomb007 – 2015-08-31T16:38:36.690 2 # az, 18 bytes, cracked by nimi "Hello, World".33.  Is this by any chance FALSE? – Alex A. – 2015-08-31T17:19:52.107 . is output as integer in FALSE. This interpreter prints Hello, Worldundefined33. – Dennis – 2015-08-31T17:23:28.883 It was a shot in the dark. :P – Alex A. – 2015-08-31T17:26:09.350 It runs in az – nimi – 2015-09-01T05:13:27.960 @nimi That was the intended solution. – Dennis – 2015-09-01T05:14:55.690 2 # 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 – 2015-08-31T19:38:45.063 1@Dennis Confirmed. It works. – mbomb007 – 2015-08-31T19:39:15.367 @Dennis Yay! Guessed correctly! – AdmBorkBork – 2015-08-31T19:42:33.190 1 # 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! – Gabriel Mills – 2018-12-26T20:19:16.633 @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. – MilkyWay90 – 2018-12-26T22:40:49.310 1 # 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. – Gabriel Mills – 2018-12-27T05:15:32.617 Correct! Nice job! – MilkyWay90 – 2018-12-27T16:04:24.080 1 # 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. – Khuldraeseth na'Barya – 2019-07-01T20:37:08.380 @Khuldraesethna'Barya That wasn't the intended solution, but it's a solution nonetheless – MilkyWay90 – 2019-07-01T20:39:45.767 Also Foo will crack it as it did so many others :) – MickyT – 2019-07-01T20:47:44.850 @Khuldraesethna'Barya https://codegolf.stackexchange.com/a/187548/83048 which should not be cracked with Proton or Foo – MilkyWay90 – 2019-07-01T20:49:33.537 1 ## 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. – Unrelated String – 2019-08-16T04:36:28.037 1You are right, I was using Proton. – None – 2019-08-16T04:53:32.003 1 # ???, 50 bytes import sys A = (Hello, World!) sys.STDOUT.write(A)  Good Luck :) Works in underload. – Esolanging Fruit – 2020-05-29T21:26:08.577 1 # ???, 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.

1

This is Lost -A

– pppery – 2020-07-15T16:59:54.833

1

# Ruby, 77 bytes, cracked by ProgramFOX

main = proc() {
proc = 'Hello, World!'
}

main
.call()
.display()


(Poor attempt, probably should count only half crack point.)

2I think it's Ruby. – ProgramFOX – 2015-08-17T13:26:18.410

Of course it is. :) – manatwork – 2015-08-17T13:26:42.820

1

# Groovy, 70 bytes, cracked by aditsu

class M{public static void main(String[]a){println("Hello, World!");}}


3Looks like Processing to me. – Peter Taylor – 2015-08-17T20:38:32.493

1Grooooovy! – aditsu quit because SE is EVIL – 2015-08-17T21:55:48.103

1

# ABAP, 42 bytes, cracked by Sp3000

REPORT ZHELLOWORLD.
WRITE 'Hello, world!'.


1

This has a lowercase w, but I'd hazard a guess at ABAP

– Sp3000 – 2015-08-17T23:56:11.077

Yes you're right :p – Ahmed Abdelkafi – 2015-08-17T23:59:22.713

1

# 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']:>>


1Is this unc by any chance? – Dennis – 2015-08-18T03:02:09.473

@Dennis That was really really fast. :) How did you figure it out so quickly? – kirbyfan64sos – 2015-08-18T03:19:52.670

You solved a task with unc when you participated in my decathlon. – Dennis – 2015-08-18T03:20:43.233

@Dennis Ah, that was your decathlon. :/ – kirbyfan64sos – 2015-08-18T03:22:14.600

Would have solved it anyway. :) Googling the !include statement takes you directly to the esolang page. – Dennis – 2015-08-18T03:23:44.753

1

# 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. – None – 2015-08-18T09:07:03.853

Yepp, that was my intention, to give it a bit of Ruby-ish look. But certainly not enough for the Ruby interpreter. – manatwork – 2015-08-18T09:13:02.677

I'm gonna guess this is bash? – Beta Decay – 2015-08-19T22:21:25.147

Is it Gema ???? – mbomb007 – 2015-08-20T02:29:43.510

Correct, @mbomb007. I expected that \B to give it away much faster. (Or you just looked up the languages I used earlier…?) – manatwork – 2015-08-20T07:10:47.983

I had one in the same language. :P – mbomb007 – 2015-08-20T15:48:53.607

1

# 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. – Dennis – 2015-08-18T21:37:55.130

Yes, Python (2 or 3). That was incredibly quick, haha. @Dennis – Zach Gates – 2015-08-18T21:39:52.150

Not that it matters, but it doesn't work in Python 3. For starters, print would require parentheses. – Dennis – 2015-08-18T21:43:39.397

Oh, yes, you're correct. I had forgotten that I'm running 2.7 (v.s. the usual 3.4). :P My fault. @Dennis – Zach Gates – 2015-08-18T21:45:03.077

1

# 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 – 2015-08-19T09:39:18.913 @ProgramFOX dammit you're good! – Caltor – 2015-08-19T09:40:04.250 @ProgramFOX you weren't fooled by the snippets of PHP, Python or C++ :( – Caltor – 2015-08-19T09:42:45.987 2Well, I saw package main and import "fmt" both uncommented at the top, so then I basically knew it :P – ProgramFOX – 2015-08-19T09:44:13.210 @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 – Caltor – 2015-08-19T09:49:21.387 1 # 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 – 2015-08-19T15:37:44.667 1@Dennis Oh right haha. Was supposed to be Zeno :/ Oh well – Beta Decay – 2015-08-19T15:50:07.380 1 # ferNANDo, 265 bytes, cracked by jimmy23013 ( main ) main = ( print("Hello,") ) + do <> ( < [ ) v$ ^^
^^ ( ( v $( <> ( <> ) ( <> ) ( # ] # ) ( [ ) ( ] # ^^ ) ( < ) ( ) ) " ^ ( v ) ) ^^ < <> ^ )$ " " [ <>
< ( ) ( # ) ( (
] ) ( ] ) ) ( (
] ) ) ( ] <> ( ^^
" ) ( <> ) ( ^ $# ) ( # <> ($ <
< " ) < ^ v ^ )
)


Looks like ferNANDo but the w is in lowercase. – jimmy23013 – 2015-08-19T21:13:56.497

It was meant to be ferNANDo, my bad. – histocrat – 2015-08-19T21:31:03.023

1

# Forth, 32 bytes, cracked by BrunoLeFloch

: : : S" Hello, World!" type ; :


3I see your Golfscript protection ;) – Beta Decay – 2015-08-19T21:52:16.600

@BetaDecay In GolfScript it prints a leading space, though. – ProgramFOX – 2015-08-19T22:02:37.347

@Dennis Oh, right, I misunderstood that. – ProgramFOX – 2015-08-19T22:41:01.320

2Forth perhaps ? – Bruno Le Floch – 2015-08-22T23:19:51.397

@BrunoLeFloch Aw, maaan! Yeah, that's it. Good job. – mbomb007 – 2015-08-23T02:28:00.843

1

# 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 – 2015-08-20T01:09:53.620

@Sp3000 Bah, I thought this one would last longer. – Dennis – 2015-08-20T01:18:08.290

1

# XPL0, 40 bytes, cracked by Mauris

code Text=12;
Text(0, "Hello, World!^A")


3Foo is really killing this challenge :/ – Sp3000 – 2015-08-20T02:08:14.733

How do you changed a program to not work in Foo? How does it work it Foo? – mbomb007 – 2015-08-20T02:11:06.593

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 – 2015-08-20T02:12:29.860

@Sp3000 Fixed it. – mbomb007 – 2015-08-20T02:31:40.240

1I'm guessing XPL0. (It's the top result (on Rosetta Code) when Googling code Text=12.) – Lynn – 2015-08-20T03:48:06.623

Yeah... didn't last long. – mbomb007 – 2015-08-20T04:28:16.090

1

# 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... :( – mbomb007 – 2015-08-20T17:44:12.200

Binaryf**k? I am at work, so can't really run this. – dramzy – 2015-08-20T18:01:27.977

If it's 438 bits, then you seem to have missed 6 of them out of the post. – Peter Taylor – 2015-08-20T18:11:11.510

@RespectMyAuthoritah Incorrect. – Grant Davis – 2015-08-20T18:43:11.960

3Is the source code actually 0 and 1 characters, or is that just the binary representation? – lirtosiast – 2015-08-20T19:52:52.300

This is source code. If eclipse had a plugin for this language, I would literally be typing 1's and 0's – Grant Davis – 2015-08-20T20:26:57.613

@GrantDavis Now we know it's not Java :P – lirtosiast – 2015-08-20T20:32:18.847

1

This is Spoon, with identical code to the example.

– lirtosiast – 2015-08-20T20:34:30.187

Correct, this is spoon. – Grant Davis – 2015-08-20T21:08:26.913

1

# 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. – jimmy23013 – 2015-08-20T18:26:19.277

Here is the code in text – Grant Davis – 2015-08-20T18:35:54.787

This is Chinese BASIC – dramzy – 2015-08-20T18:40:04.537

You are correct. – Grant Davis – 2015-08-20T18:41:29.163

1

# 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" – Nico A – 2015-08-21T00:59:05.087

Is this supposed to be jQuery? – Dennis – 2015-08-21T01:09:47.953

@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. – Grant Davis – 2015-08-21T01:10:52.153

@Dennis What did it print in JQuery? – Grant Davis – 2015-08-21T01:11:27.180

Nevermind. This isn't valid JavaScript, but it prints Gotcha! with jQuery. Serves me right for guessing from my phone... – Dennis – 2015-08-21T01:24:27.743

Haha, that was sneaky. I know the correct answer now. – Dennis – 2015-08-21T02:15:37.183

1This 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. – Dennis – 2015-08-21T16:56:05.460

Then wouldn't node.js answers also be invalid? – Grant Davis – 2015-08-21T17:09:09.180

Node.js is a JavaScript interpreter, not a library. – Dennis – 2015-08-21T19:17:34.253

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.) – Martin Ender – 2015-08-21T20:19:39.317

1

# 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.)

– Martin Ender – 2015-08-21T18:21:22.130

That's definitely Lua. EDIT: @MartinBüttner Beat me to it by a few seconds! – kirbyfan64sos – 2015-08-21T18:21:49.707

@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. ;) – Martin Ender – 2015-08-21T18:23:22.823

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 – DavisDude – 2015-08-21T18:45:53.577

1

# ><>, 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)

– plannapus – 2015-08-22T10:43:20.710

Nice. Didn't think it wold be cracked that fast :o – clapp – 2015-08-22T10:51:09.977

Try a less well-known programming language. Most of us have seen ><> before. :D – mbomb007 – 2015-08-23T02:34:01.513

1

# 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) – Sp3000 – 2015-08-23T05:07:01.357

... is pastebin okay? – Jamie – 2015-08-23T05:08:20.087

This is Whitespace. – Dennis – 2015-08-23T05:09:50.027

Don't you think this is brainfuck? – Jamie – 2015-08-23T05:11:57.440

2I think the Whitespace outputs a lowercase w – Sp3000 – 2015-08-23T05:12:41.517

The output is Oovvy#^y|vn$ in Brainfuck, so no. – Dennis – 2015-08-23T05:13:12.110 So it means I have to modify the program, maybe... – Jamie – 2015-08-23T05:13:17.683 It was originally a brainfuck program, but I added a + to the beginning. – Jamie – 2015-08-23T05:17:16.317 1 # OOC, 40 bytes, cracked by Dennis main: func { "Hello, World!" print() }  Easy? Perhaps. This works in Foo. – Dennis – 2015-08-25T04:49:07.153 3@Dennis You have to be kidding me. ಠ_ಠ – Alex A. – 2015-08-25T04:50:05.203 Also works in OOC, I think. – Dennis – 2015-08-25T04:54:20.110 @Dennis Well you got what I was going for, so I'll give that one to you. :) – Alex A. – 2015-08-25T04:55:39.443 ARGH!! How did I miss this? I've used ooc like 20 times. :/ – kirbyfan64sos – 2015-08-26T00:30:33.450 1 # Pyth, 44 bytes, cracked by jimmy23013 "Hello, World!"+stupid"ketchup"foo su(x.)+"?  It works in Pyth. – jimmy23013 – 2015-08-26T20:02:39.350 1 # 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 – 2015-08-26T18:58:05.260 @Dennis Am I allowed to edit it a sec? It won't change the byte count... – kirbyfan64sos – 2015-08-26T19:00:00.850 Technically no, but it's not like I'm going to beat Sp3000 anyway... – Dennis – 2015-08-26T19:02:19.273 @Dennis So I can? – kirbyfan64sos – 2015-08-26T19:04:50.103 Why not post a new answer? – aditsu quit because SE is EVIL – 2015-08-26T19:05:15.280 That's really up to Martin, not to me. – Dennis – 2015-08-26T19:05:23.730 I guess so. Marking this one as "cracked! – kirbyfan64sos – 2015-08-26T19:05:42.533 Foo ... fast becoming one of the most hated languages – MickyT – 2015-08-26T19:15:24.093 1 # 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 – 2015-08-26T19:07:42.153 @Dennis You've got to be kidding me...now I know how you felt with Foo and SPSS and company... – kirbyfan64sos – 2015-08-26T19:13:46.903 @Dennis Well, at least I'm begging you closer to Sp3000! – kirbyfan64sos – 2015-08-26T19:19:03.463 1 # Foo, 38 bytes, cracked by kirbyfan64sos print "Hello, World!", EoL FIN  I hate Foo. Whoah, does this work in Foo? – kirbyfan64sos – 2015-08-26T19:19:20.460 Yes, it does. Sorry Foo cracked you again. :) – kirbyfan64sos – 2015-08-26T19:20:25.570 @kirbyfan64sos "This prints a trailing newline in addition." – TheNumberOne – 2015-08-26T19:21:31.660 Ah, nice use of wording there. – kirbyfan64sos – 2015-08-26T19:24:00.833 "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. – jimmy23013 – 2015-08-26T19:32:05.073 1 # 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 – 2015-08-27T18:04:31.097

@Dennis Huh! The online interpreter gave An Error happened: Uncaught TypeError: Cannot read property 'a' of undefined, so I thought I was safe. – DLosc – 2015-08-27T18:10:09.000

Not for me. – Dennis – 2015-08-27T18:10:54.910

@Dennis I see--I used the wrong interpreter.

– DLosc – 2015-08-27T18:12:42.260

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. – Dennis – 2015-08-27T18:15:58.173

1

# J--, 33 Bytes, Cracked by histocrat

main{//&1
echo("Hello, World!");}


1Nice Foo protection. – Dennis – 2015-08-27T18:56:09.947

3

This looks like it'd work in J--.

– histocrat – 2015-08-27T21:04:49.340

@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 – mbomb007 – 2015-08-29T19:34:47.263

It was indeed histocrat. Sorry for the delay in marking it :P – Fongoid – 2015-08-31T14:44:22.710

1

# 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


2This is Golunar. – jimmy23013 – 2015-08-27T20:08:17.973

Lol. Well so much for that :P – Fongoid – 2015-08-27T20:12:43.617

1

# 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... – mbomb007 – 2015-08-28T14:26:17.073

Is it Matlab? (I do not own Matlab, so I can't test it.)

– isaacg – 2015-08-28T18:18:39.757

This should work in MATLAB, but I don't think there's a free interpreter. – Dennis – 2015-08-28T18:20:12.387

@Dennis Right, I missed that part of the question. – isaacg – 2015-08-28T18:20:47.943

It's not intended to be MATLAB. – mbomb007 – 2015-08-28T18:43:00.323

3The semicolon is printed in MATLAB. – feersum – 2015-08-28T20:02:14.513

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 – 2015-08-30T18:25:43.527

@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. – mbomb007 – 2015-08-30T20:33:06.153

The question says the code has to come from a file. I was just reporting a near miss. – Dennis – 2015-08-30T20:37:29.243

Another near miss: This would work in vim if the exclamation mark was escaped... – Dennis – 2015-08-30T23:43:42.137

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 – 2015-08-31T04:26:20.960

@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.

– mbomb007 – 2015-08-31T16:47:04.993

The question doesn't mention this case. I'll ask Martin. – Dennis – 2015-08-31T16:51:40.770

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 – 2015-08-31T16:53:20.847

@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.

– mbomb007 – 2015-08-31T16:57:02.307

– Dennis – 2015-08-31T16:58:15.183

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. – Martin Ender – 2015-08-31T17:46:06.837

@MartinBüttner Why only before midnight? – mbomb007 – 2015-08-31T17:49:05.703

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.) – Martin Ender – 2015-08-31T17:50:50.290

1

# J--, 56 bytes, cracked by Dennis

main{if(a!=new String[]{"foo"}){echo("Hello, World!");}}


Without the class, this would work in J--. – Dennis – 2015-08-28T22:03:22.050

1

# 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.


1Blind guess: is this Zucchini? – Sp3000 – 2015-08-29T16:11:46.090

Oh lord. Yes it is. – histocrat – 2015-08-29T16:42:01.580

1

# 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.

2You're not the first one to encounter that problem. ;) – Martin Ender – 2015-08-31T18:52:48.060

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. – mbomb007 – 2015-08-31T19:03:45.567

I guess you could post a couple more variants, but of course that also gives more hints for the robbers. – Martin Ender – 2015-08-31T19:04:56.873

This works in IPython. – Dennis – 2015-08-31T19:10:38.100

Is there an online interpreter? I can't currently test my new programs on it. – mbomb007 – 2015-08-31T19:11:09.910

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... – Dennis – 2015-08-31T19:16:51.370

Does it work in IPython with a single &? – mbomb007 – 2015-08-31T19:18:40.570

@mbomb007 Yes, it does. – Dennis – 2015-08-31T19:19:46.573

@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. – mbomb007 – 2015-08-31T19:27:19.830

1

# 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? – Martin Ender – 2015-08-31T19:08:13.537

@MartinBüttner Full program run from a file. – AdmBorkBork – 2015-08-31T19:09:35.827

This works in GolfScript. – Dennis – 2015-08-31T19:11:17.937

Really? I tried GolfScript and it just printed the ascii char codes... – mbomb007 – 2015-08-31T19:11:52.297

@Dennis I also tried GolfScript and got the same result as mbomb007. – AdmBorkBork – 2015-08-31T19:12:50.053

@mbomb007 I assume you used copy.sh's interpreter. This works in the Ruby interpreter and Web GolfScript.

– Dennis – 2015-08-31T19:13:12.273

A very late question, but @AdmBorkBork do you remember what this was originally intended to be? – sundar - Remember Monica – 2018-07-14T20:34:08.673

@sundar It likely was intended to be PowerShell. – AdmBorkBork – 2018-07-16T12:30:07.070

1

# 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. – Martin Ender – 2015-09-01T16:41:48.440

0

# Nemerle, 111 bytes, cracked by Sp3000

class Hello
{
static Main() : void
{
System.Console.WriteLine("Hello, World!");
}
}


Maybe...

Nemerle – Sp3000 – 2015-08-18T12:10:12.693

0

# Perl, 24 bytes, cracked by ProgramFOX

printf("Hello, World!");


I think it's Perl. – ProgramFOX – 2015-08-18T13:39:17.517

@ProgramFOX I intended Octave, but you get the points. – None – 2015-08-18T13:43:48.440

0

# F#, 75 bytes, cracked by vihan

#line 1
"Hello, " = "Goodbye "
printf("Hello, ")
#line 4
printf("world!\n")


Is this F#? http://ideone.com/cTmnmy

– Downgoat – 2015-08-18T17:31:30.553

@vihan Yes. (this comment is long enough now) – Jwosty – 2015-08-18T17:33:16.847

0

# Node.js, 38 bytes, cracked by ProgramFOX

I am going to try again.

process.stdout.write("Hello, World!");


It's JavaScript on Node.js. – ProgramFOX – 2015-08-19T10:12:23.780

nice! that wasn't hard – ooransoy – 2015-08-19T10:16:48.220

0

# Gema, 20 bytes, cracked by Mauris

*=
\B=Hello, World\!


2

You and manatwork should crack each other (I'm assuming they're the same language)

– Sp3000 – 2015-08-20T02:13:08.583

1This is Gema, I think. – Lynn – 2015-08-20T03:46:19.477

0

# Javascript, 23447 bytes, cracked by Dennis

[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+!+[]+!+[]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]])+[])+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+[[]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]([[]])+[]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+!+[]+!+[]+!+[]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]])+[])+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([][[]]+[])[!+[]+!+[]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+(!+[]+!+[]+[+!+[]])+[])+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]])()


This is JavaScript. – Dennis – 2015-08-24T20:49:52.337

1@Dennis damn, you're too fast! – aditsu quit because SE is EVIL – 2015-08-24T20:50:24.770

2JSFuck, to be specific. – Sebastian Simon – 2015-08-24T23:41:57.707

0

# 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 – 2015-08-26T11:49:59.397

@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. – Pharap – 2015-08-26T12:00:47.457

Don't worry, I just have a small list of languages that I thought looked like suspiciously good cop candidates :P – Sp3000 – 2015-08-26T12:04:13.257

(also, keywords like concat are a giveaway if the spec is searchable on esolang wiki) – Sp3000 – 2015-08-26T12:05:12.220

0

# 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 – 2015-08-26T19:22:07.067

@jimmy23013 NOOOOOOOOOO!!!!! sigh Back to the immunity drawing board... – kirbyfan64sos – 2015-08-26T19:25:22.033

0

# Common Lisp, 41 bytes, cracked by georgeunix

(DEFUN HELLO ()
"Hello, World!"
)
(HELLO)


Sounds too easy for you guys ;)

Yeah it's Common Lisp :D – Ahmed Abdelkafi – 2015-08-28T13:12:32.740

0

# Foo, 28 bytes, cracked by kirbyfan64sos

(printout t "Hello, World!")


I think this is CLIPS. – ProgramFOX – 2015-08-28T11:47:08.220

Nope, it's not CLIPS ! – Ahmed Abdelkafi – 2015-08-28T11:57:01.640

This works in...Foo... – kirbyfan64sos – 2015-08-28T18:42:31.620

Not Foo too :p – Ahmed Abdelkafi – 2015-08-28T18:46:52.670

2@AhmedAbdelkafi If it works in ANY language we can find, it's cracked. – mbomb007 – 2015-08-28T21:38:50.200

@ProgramFOX It's not CLIPS. It works in the REPL, but you need (exit) and a blank line on ideone.

– Dennis – 2015-08-28T23:35:55.967

0

# ><>, 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 – 2015-08-29T18:00:11.923

@randomra It was meant to be ><>, I didn't notice that I left those lowercase. – DanTheMan – 2015-08-29T18:02:52.740

0

# ksh, 21 bytes, cracked by nimi

!;echo Hello, World!;


This shouldn't work in IPython, right?

It works in ksh – nimi – 2015-08-31T18:22:23.357

0

# ksh, 20 bytes, cracked by nimi

!;echo Hello, World!


Another variation.

It works in ksh – nimi – 2015-08-31T18:20:36.317

@nimi Did the original !echo Hello, World!; work in ksh? – mbomb007 – 2015-08-31T18:26:55.883

No, the original didn't work. – nimi – 2015-08-31T18:27:59.487

@nimi Then why do these work? – mbomb007 – 2015-08-31T18:29:20.180

; separates commands. The original failed with !echo: not found, i.e. there's no command !echo. – nimi – 2015-08-31T18:30:29.920

-1

# ???, 22 bytes

write('Hello, World!')


Is this Io, or a fork? – galexite – 2015-08-28T13:04:46.963

Yep, works in Io – galexite – 2015-08-28T13:06:10.447

Sorry, it's not Io ! – Ahmed Abdelkafi – 2015-08-28T13:12:05.660

1Still. It works in Io. – galexite – 2015-08-28T13:22:04.737

Does this also work in Pascal Script? – kirbyfan64sos – 2015-08-28T17:52:06.803

@Dennis Fixed the header – Alex A. – 2015-08-28T21:28:35.353

1@georgeunix Io seems to require double quotes. – Dennis – 2015-08-28T23:37:08.013

@kirbyfan64sos Pascal Script seems to require a begin … end. block. – Dennis – 2015-08-28T23:37:16.997

With a semicolon at the end, this would work in Asymptote. – Dennis – 2015-08-28T23:44:42.747

According to this, it works in ComputerCraft, but it doesn't have its own Wikipedia article.

– Dennis – 2015-08-29T06:57:37.853

@AhmedAbdelkafi Your code seems to be 22 bytes long. – Dennis – 2015-08-31T04:35:43.373

2The seven days have passed. Your submission will be safe as soon as you reveal the intended language. – Dennis – 2015-09-04T19:11:06.037

2Have you gotten around to revealing the language yet? – MilkyWay90 – 2019-07-01T16:56:35.540

@MilkyWay90 The language has always been revealed. Search for "???" on esolangs. – Corsaka – 2019-11-19T12:02:11.797

@Corsaka I don't think this works in "???" – MilkyWay90 – 2019-11-22T12:27:17.020

@MilkyWay90 my mistake, i am big dumb – Corsaka – 2019-11-26T09:32:28.770

@Corsaka Don't worry, we all make mistakes. – MilkyWay90 – 2019-11-28T17:00:49.833