text:
The Mystery String Printer (Cops)
The robbers thread can be found here: The Mystery String Printer (Robbers)
Your challenge

Write a program, function, or REPL script that prints a string to STDOUT.
The robbers will try to create a program that prints the same string.
If they successfully can create the program within 7 days, your submission is cracked.
If nobody can create a program that prints the same string within 7 days, your submission is safe. You may choose to reveal your program, or leave it to challenge future robbers. However, if you don't reveal it, you can't get any points from your submission (don't put "safe" in your answer header if you choose to do this).

Restrictions

The program must be less than or equal to 128 bytes total (more on this later).
If the program depends on the program name, or the name/contents of an external file, you must say that it does so, and include this in your total byte count.
The printed string must be less than or equal to 2048 bytes.
The printed string must consist of only printable ASCII characters (new lines can be included).
The program must produce the same output every time that it is run.
Built-in cryptographic primitives (includes any rng, encryption, decryption, and hash) aren't allowed.
The program must not take input.
No standard loopholes.

Scoring

If a submission is cracked before seven days, the submission earns 0 points.
A safe submission of ≤128 characters earns 1 point.
A safe submission of ≤64 characters earns 2 points. If it's less than or equal to 32 bytes, it earns 4 points, and so on.
Each safe submission also earns an additional 3 point bonus (independent of the length).
There is a tiny (1/2 point) penalty for every cracked after your first one.
Note that the robber's solution has to be in the same range of program lengths.
Each person may submit a maximum of 1 program per byte range per language (different versions and arbitrary substitutions of the same language don't count as separate languages). Example: you can post a 32 byte and a 64 byte pyth program, but you can't post a 128 byte program in both Java 7 and Java 8.
The person with the highest point total wins.

Submissions
Each submission must have the following pieces of information:

The name of the language. All new robbers' solutions must be the same language.
The range of the program size (this is the nearest power of two higher than the size of the program; for example, if your program is 25 bytes, this would be "≤32").
The actual string to be printed out.
If a submission is safe, put "safe" and the program length (to the nearest power of 2) in your header. If there are multiple numbers in your header, put the power of 2 last.

This stack snippet generates leaderboards and lists all of the open submissions. If there are any problems with the snippet, please leave a comment.

/* Configuration */

var QUESTION_ID = 60328; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 167084; // This should be the user ID of the challenge author.

var SECONDSINDAY = 86400;
var SAFECUTOFFDAYS = 7;
var SORTBYTIME = true;
var SUBTRACTCRACKEDPOINTS = true;
var EXPIREDTIME = 1446336000;

/* App */

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

function answersUrl(index) {
  return "//api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

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

function getAnswers() {

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

}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      data.items.forEach(function(c) {

        answers_hash[c.post_id].comments.push(c);

      });

      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}

getAnswers();

var SAFE_REG = /<h\d>.*?[sS][aA][fF][eE].*<\/\h\d>/;
var POINTS_REG = /(?:<=|≤|<=)\s?(?:<\/?strong>)?\s?(\d+)/
var POINTS_REG_ALT = /<h\d>.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
var CRACKED_HEADER_REG = /<h\d>.*[Cc][Rr][Aa][Cc][Kk][Ee][Dd].*<\/h\d>/;
var CRACKED_COMMENT_REG = /(.*[Cc][Rr][Aa][Cc][Kk][Ee][Dd].*<a href=.*)|(.*<a href=.*[Cc][Rr][Aa][Cc][Kk][Ee][Dd].*)/
var OVERRIDE_REG = /^Override\s*header:\s*/i;
var LANGUAGE_REG = /<h\d>\s*(.+?),.*<\/h\d>/;
var LANGUAGE_REG_ALT = /<h\d>\s*(<a href=.+<\/a>).*<\/h\d>/
var LANGUAGE_REG_ALT_2 = /<h\d>\s*(.+?)\s.*<\/h\d>/;
var LANGUAGE_REG_ALT_3 = /<h\d>(.+?)<\/h\d>/;

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

function process() {

  var valid = [];
  var open = [];

  answers.forEach(function(a) {

    var body = a.body;
    var cracked = false;

    a.comments.forEach(function(c) {
      var was_safe = (c.creation_date + (SECONDSINDAY * SAFECUTOFFDAYS) > a.creation_date);
      if (CRACKED_COMMENT_REG.test(c.body) && !was_safe)
        cracked = true;
    });

    if (CRACKED_HEADER_REG.test(body)) cracked = true;

    // if (SUBTRACTCRACKEDPOINTS||!cracked) {

    var createDate = a.creation_date;
    var currentDate = Date.now() / 1000;
    var timeToSafe = (createDate + (SECONDSINDAY * SAFECUTOFFDAYS) - currentDate) / SECONDSINDAY;
    var SafeTimeStr = (timeToSafe > 2) ? (Math.floor(timeToSafe) + " Days") :
      (timeToSafe > 1) ? ("1 Day") :
      (timeToSafe > (2 / 24)) ? (Math.floor(timeToSafe * 24) + " Hours") :
      (timeToSafe > (1 / 24)) ? ("1 Hour") :
      "<1 Hour";

    var expired = createDate > (EXPIREDTIME);

    var safe = timeToSafe < 0;
    var points = body.match(POINTS_REG);
    if (!points) points = body.match(POINTS_REG_ALT);
    safe = safe && !cracked

    isOpen = !(cracked || safe);

    if (points) {
      var length = parseInt(points[1]);
      var safepoints = 0;
      if (length <= 4) safepoints = 32;
      else if (length <= 8) safepoints = 16;
      else if (length <= 16) safepoints = 8;
      else if (length <= 32) safepoints = 4;
      else if (length <= 64) safepoints = 2;
      else if (length <= 128) safepoints = 1;

      valid.push({
        user: getAuthorName(a),
        numberOfSubmissions: (safe && !expired) ? 1 : 0,
        points: (safe && !expired) ? safepoints : 0,
        open: (isOpen && !expired) ? 1 : 0,
        cracked: (cracked && !expired) ? 1 : 0,
        expired: (expired) ? 1 : 0
      });

    }

    if ((isOpen || expired) && points) {

      var language = body.match(LANGUAGE_REG);
      if (!language) language = body.match(LANGUAGE_REG_ALT);
      if (!language) language = body.match(LANGUAGE_REG_ALT_2);
      if (!language) language = body.match(LANGUAGE_REG_ALT_3);

      open.push({
        user: getAuthorName(a),
        length: points ? points[1] : "???",
        language: language ? language[1] : "???",
        link: a.share_link,
        timeToSafe: timeToSafe,
        timeStr: (expired) ? "Challenge closed" : SafeTimeStr
      });
    }
    // }
  });

  if (SORTBYTIME) {
    open.sort(function(a, b) {
      return a.timeToSafe - b.timeToSafe;
    });
  } else {
    open.sort(function(a, b) {
      var r1 = parseInt(a.length);
      var r2 = parseInt(b.length);
      if (r1 && r2) return r1 - r2;
      else if (r1) return r2;
      else if (r2) return r1;
      else return 0;
    });
  }

  var pointTotals = [];
  valid.forEach(function(a) {

    var index = -1;
    var author = a.user;
    pointTotals.forEach(function(p) {
      if (p.user == author) index = pointTotals.indexOf(p);
    });

    if (index == -1) pointTotals.push(a);
    else {
      pointTotals[index].points += a.points;
      pointTotals[index].numberOfSubmissions += a.numberOfSubmissions;
      pointTotals[index].cracked += a.cracked;
      pointTotals[index].expired += a.expired;
      pointTotals[index].open += a.open;
      if (SUBTRACTCRACKEDPOINTS && a.cracked && pointTotals[index].cracked > 1) pointTotals[index].points -= .5;
    }

  });

  pointTotals.forEach(function(a) {
    a.points += (a.numberOfSubmissions) ? ((a.numberOfSubmissions) * 3) : 0;
  });

  pointTotals.sort(function(a, b) {
    if (a.points != b.points)
      return b.points - a.points;
    else if (a.numberOfSubmissions != b.numberOfSubmissions)
      return b.numberOfSubmissions - a.numberOfSubmissions;
    else if (a.open != b.open)
      return b.open - a.open;
    else if (a.cracked != b.cracked)
      return a.cracked - b.cracked;
    else return 0;
  });

  pointTotals.forEach(function(a) {

    var answer = jQuery("#answer-template").html();
    answer = answer
      .replace("{{NAME}}", a.user)
      .replace("{{SAFE}}", a.numberOfSubmissions)
      .replace("{{OPEN}}", a.open)
      .replace("{{CLOSED}}", a.expired)
      .replace("{{CRACKED}}", a.cracked)
      .replace("{{POINTS}}", a.points);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

  });

  open.forEach(function(a) {
    var answer = jQuery("#open-template").html();
    answer = answer
      .replace("{{NAME}}", a.user)
      .replace("{{LENGTH}}", a.length)
      .replace("{{LANGUAGE}}", a.language)
      .replace("{{TIME}}", a.timeStr)
      .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#opensubs").append(answer);
  });

}
body {
  text-align: left !important
}
#answer-list {
  padding: 10px;
  width: 350px;
  float: left;
}
#open-list {
  padding: 10px;
  width: 470px;
  float: left;
}
table thead {
  font-weight: bold;
  vertical-align: top;
}
table td {
  padding: 5px;
}

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

Leaderboard

        Author
        Safe
        Open

        Cracked
        Late Entry
        Score

Open submissions

        Author
        Length
        Language
        Time Remaining
        Link (open in new tab)

      {{NAME}}
      {{SAFE}}
      {{OPEN}}

      {{CRACKED}}
      {{CLOSED}}
      {{POINTS}}

      {{NAME}}
      {{LENGTH}}
      {{LANGUAGE}}
      {{TIME}}
      Link

Use the following formats for entries:
Language, (any text with the program size as the last number)
=

or
Language
=
Length <= 16

Note that the snippet will only put the first word in the header as the language if it doesn't detect a comma.
For safe submissions, put safe in your header. The snippet will automatically put your program in the "safe" column if the time is expired, so this is more to tell any robbers that your program is safe.
For cracked submissions, put cracked in your header.
The program should also be able to recognize if a comment says "cracked" and has a link; however, this is not guaranteed.
Tiebreaking order: Points -> # of Safe submissions -> Least amount of cracked submissions.
Note that the snippet sorts by open submissions before least cracked, but open submissions will not be counted at the end of the contest.
This challenge is now closed.
Most points overall winner: Dennis
Most safe submissions: DLosc
(Note that the number of safe submissions doesn't translate to a point amount, as the size of the programs are considered in calculating the score).

We should remind the cops that the output should better be longer than the program size, to reduce trivial solutions like http://codegolf.stackexchange.com/a/60395/ and http://codegolf.stackexchange.com/a/60359

I changed the scoring a bit so that an 8 byte submission isn't worth 81 times as much as a 128 byte, but is still considerably more.

Are you using this definition of programming languages?
For example, is it required that there is a free interpreter/compiler available?

@bmarks There has to exist a way to execute the language, and the language must be able to display a string of ASCII characters. If you want to use HQ9+, congratulations, you have just gotten yourself a cracked submission.

For example, if I want to use features from STATA that are only supported in the paid version and not the free version, is that allowed?

@bmarks I'd prefer not, but I'm not going to stop you.

Do we have a limit on how many times we can post?

@JAtkin Once per program length per language (effectively 5-6 times/language). Keep in mind that having too many cracked submissions can start to bring the score down a tad (see main post).

@DanielM. I see, I saw that in the post but was wondering if maybe 6 was too much ;)

@JAtkin 1 is too small, and most other limits feel very arbitrary. Besides, changing it now would invalidate a bunch of posts.

@JAtkin Besides, there are so many esolangs out there that if someone wanted to, they could have thousands of submissions with only one per language. If it gets out of hand, people can be restricted to a few dozen total submissions, or maybe just not count points (possibly a -0.5 score penalty) for submissions with downvotes.

All the number-only outputs are super boring.

"different versions and arbitrary substitutions of the same language don't count as separate languages" - what qualifies as an arbitrary substitution? Would, for example, having both a JavaScript and a CoffeeScript answer of the same length be allowed? (I guess it would because there is quite a bit of logic in the conversion, but it ultimately compiles down to JavaScript.)

This is going to get rather interesting in 8 hours when submissions start becoming "safe."

Please consider using the Sandbox the next time. Preferably, the rules of a challenge shouldn't change at all after it has been posted. I've lost track of how many times the rules have changed here...

This challenge should probably be closed to further submissions. I haven't been trying to crack any for a while, and I doubt other people are either.

@mbomb007 I'll give people a little time in advance- no new entries will be counted on or after November 1st. Any further entries will not become safe. This will be scored after November 7th.

Pyth, Safe, Range ≤ 8
['ashva', 'cxedo', 'ecckc', 'hhzsq', 'jmwze', 'lrths', 'nwrog', 'pbowu', 'rgldi', 'uljlw', 'wpgsk', 'yuday'

The code:

%^T6`^G5

Explanation:

 To clarify how this works: I generated all possible 5 character strings of lowercase letters (^G5). Then, I generated the string representation of this list: (`^G5). Finally, I took every 1,000,000th character of that list (%^T6).

 The result is something which looks like a list of strings, but is suspiciously missing its end bracket.

is there no close ]?

@Maltysen Nope.

Saw the second item as "xCode" scrambled, thought it may be a list of IDEs scrambled but I wasn't able to identify any of the others :o

Tough one! I found the pattern in the strings, but no idea how to generate it in <=8 bytes.

 VBA , [Safe]
Range <= 128 bytes
Hint for where to output

 Ran in Excel 2007, output was to Debug.print. Its VBA good luck getting anything under 128 bytes to run.

Output 255 bytes
 This array is fixed or temporarily locked THIS ARRAY IS FIXED OR TEMPORARILY LOCKED this array is fixed or temporarily locked This Array Is Fixed Or Temporarily Locked I n v a l i d   p r o c e d u r e   c a l l   o r   a r g u m e n t  ?????????????????

 Solution

 Well I hope someone had fun trying to crack this one. I can say that this is some of the worst error-handling I have ever done and feel bad for how bad this code is.

Code

     Sub e()
    On Error Resume Next
    Err.Raise 10
    For i = 0 To 128
    b = b & " " & StrConv(Err.Description, i)
    Next
    Debug.Print b
    End Sub'

Explained

 First the code starts with one of the Major sins of VBA. On Error Resume next.
 Once we have committed that horrid act we go ahead and just throw and error. this is the This array is fixed or temporarily locked Error that we will soon see in the output.

The next is the loop. We loop 128 times trying to Convert the Error Description, But the only valid inputs for i are 1,2,3,64,128. Because of this the first 4 loops print the Error with Various Formats. Then when i = 4 the code throws a new Error Invalid call Then that loops and nothing is assigned to b because the strconv function errors out each time.

 This is where any normal program should have stopped, But because we have the On Error Resume Next every error is ignored and the code continues unfazed by the poor error-handling

 Now we hit i=32 and we add the new error to b converted to Unicode and then continue looping until i = 128 at which point we convert our error FROM Unicode which results in the ????????????????? string being added to b

 Finally Print out the mess of Errors we have concatenated together

Mathematica, safe, range ≤ 64
Output:
CGTAGGCCCATTTTGTGTGAATTGCGGTGCAGCGAGCGATATGTTGTCTGGGCACGGACGCAGAGTTAGGGTAGCTGGTG

Source:
Print@@Characters["GATC"][[1+First@RealDigits[Pi,4,80]]]

Now I'll have to GenomeLookup everything...

Really! What gave it away?

Mathematica + "some specific string" = XData.

Maybe I should have changed the letters!

Lol, with that many repeat characters and 64 bytes to work with you could easily make a function just print that string pretty easily. xD

@AlbertRenshaw No, it doesn't seem like that is the case.

Wait... If it uses GenomeData, then it must receive the information from the Wolfram Research server, which is definitely longer than 128 bytes.

I have added the source. This is of course NOT anything related to genomes, but rather 80 digits of pi in base 4, encoded using "GATC" to make people think of double helixes.

ngn APL (safe)
0.675640430319848J0.8376870144941628

Range ≤ 8
Solution
*3○⍟⍣=42

Try it online.
How it works

⍟⍣=42 applies natural logarithm (⍟) repeatedly to 42 until a fixed point is reached (⍣=), yielding 0.31813150520476413J1.3372357014306895.
The initial value doesn't really matter here, as long as it's neither 1 nor 0.
3○ applies tangent to its right argument, yielding 0.07343765001657206J0.8920713530605129.
* applies the natural exponential function to its right argument, yielding the desired output.

The absolute value isn't quite 1. Interesting.

Pyth, cracked by Sp3000
1234465889612101271616181215168242024142718209323236243032163621242510

Range ≤ 8

Cracked :)

><> (Safe)
Tested on the online and official interpreters.
Range: <= 16
String: 4621430504113348052246441337820019217490490
This is pretty 1337, huh?
Explanation:
Here's the source code (15 bytes):
f1-:0(?;::0g*n!

f pushes 15 (our counter) onto the stack (this is skipped by the ! at the end so as not to push more than one counter)
1- subtracts 1 from the counter
:0(?; The frowny face tests if the counter is less than 0, the rest ends the program if it is
:: Duplicates the counter twice
0g Grabs the character at the point (c,0) in the source code where c is the counter
* Multiplies the second duplicate of the counter by the ASCII representation of the character previously grabbed
n Prints the result.
So, split up, the output is [462, 1430, 504, 1133, 480, 522, 464, 413, 378, 200, 192, 174, 90, 49, 0]. This corresponds to the ASCII interpretation of the code in reverse multiplied by the numbers 14 to 0 (i.e. [!*14, n*13, ... f*0]).
Probably the hardest part about cracking this would be figuring out how to split up the numbers correctly, but if you get the right ones it's just a matter of trying things until you get something that works.

Python, <=16 (cracked by kennytm)
[[[22111101102001]]]

This was produced via REPL (running a command in Python shell).
While I'm editing this, I'll also summarize the comments for future spoiler-free robbers: this doesn't work in all Pythons. It does work in a build of Python 2.7 where sys.maxint = 9223372036854775807.

This is very hard.

Does it work in both Python 2 and Python 3?

Eep. Python 2 only, sorry.

Meaning it categorically doesn't work in Python 3?

That's a hint, but yes, I promise that it does not work in Python 3.

Hm, the plot thickens! 22111101102001 can't be an integer value inside a list because in Python 2 that would be long rather than int, with an L suffix when repr'd. Curiouser and curiouser...

Ah, not on my mac's 2.7.

Python 2.7.10 (default, Jul 14 2015, 19:46:27)
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.39)] on darwin
Type "help", "copyright", "credits" or "license" for more information.

22111101102001
22111101102001
[[[22111101102001]]]
[[[22111101102001]]]

It does in ideone's pypy, though. So, okay, this is version and platform specific. Didn't realize.

This keeps getting harder...

Cracked.

Perl (safe)
84884488488444224424428844884884884488488444224424428844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442442244244244224424422211221221221122122144224424424422442442221122122144224424424422442442221122122144224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212218844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442884488488488448848844422442442442244244288448848848844884884442244244288448848848844884884442244244244224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212218844884884884488488444224424424422442442884488488488448848844422442442884488488488448848844422442442884488488488448848844422442442442244244288448848848844884884442244244288448848848844884884442244244244224424424422442442221122122122112212214422442442442244244222112212214422442442442244244222112212212212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422442442442244488488448848848844882442442244488488448848848844882442442244244244224448848844884884884488244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448812212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422442442442244488488448848848844882442442244488488448848848844882442442244244244224448848844884884884488244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448812212211222442442244244244224412212211222442442244244244224412212211221221221122244244224424424422441221221122244244224424424422441221221122244244224424424422441221221122122122112224424422442442442244244244224448848844884884884488244244224448848844884884884488244244224424424422444884884488488488448824424422444884884488488488448824424422444884884488488488448824424422442442442244488488448848848844882442442244488488448848848844882442442244488488448

Range ≤ 32
Solution
print 2**y/124589//for-951..1048

Try it online.
How it works

for-951..1048 executes the preceding command for each integer in this range, saving it in the implicit variable.
y/124589// performs transliteration, eliminating the specified digits from the implicit variable.
y/// will return the number of eliminations, i.e., the number of occurrences of those digits in the implicit variable.
print 2** prints 2 to the power of eliminations (1, 2, 4 or 8).

Snowman 1.0.2
Range ≤32.
110110111011011001111100111111111101111110101000101000100001100001100011100011101110110111011011111011111011101011101111101111110111110111111011110101111010111100101100101001111001111111011111011010111010111000000100000011111001111100

The solution is:
"mO~(!#]/.}{k2'=+@|":2nBspsP;aE

This is such a weird language... need to figure it out before attempting to crack...

Almost there... keep getting a segfault 11 though...

Matlab, ≤16. Cracked by Wauzl
Range ≤16.
This works in Octave too.
The printed string is as follows:
ans =

     0     0     0     0     0     0     0     0     0
     0     0     0     0     9     4     0     0     0
     0     0     0     0    32    18     0     0     0
     0     0     0     9     1     0     3     0     0
     0     0     7     0     0     2    10     0     0
     0     0     3     0     2     2     3     0     0
     0     0     0    19    63    22     1     0     0
     0     0     0     4    13     4     0     0     0
     0     0     0     0     0     0     0     0     0

Good job, I tried to come up with something like this, but this one is really nice, I have really no clue how this should work=)

Cracked

Javascript (console), <= 32 (cracked by insertusernamehere)
"a,a,0,a,b,a,a,b,a,a,4,a,b,a,a,a,a,6,a,b,a,a"

Tested in Chrome and Firefox web consoles. That's a 43 character string.
My intended solution was a bit more elaborate than the linked one (curse you, ES6!).

 'a,b,a,a'.replace(/(a)/g,Array)

Explanation:

 When you call replace with a Regular Expression with the /g flag and a function, it replaces everything matching the regex with the result of calling the function with these arguments: The matched string, every capture group in the matched string, the index the matched string has in the whole string, and the whole string. In this case, that'll be "a", "a", 0 or 4 or 6, and "a,b,a,a". All of these arguments are passed into the Array constructor, which simply creates an array of everything passed in. Then replace converts that to a string, e.g. "a,a,0,a,b,a,a" and replaces the "a" character with it.

Got it down to 37 bytes. It looks like hex, so hope that helps.

Cracked? :)

I can't upvote again, but that is a pretty nice program.

CJam, ≤  8 [safe]
379005901358552706072646818049622056

I don't like long numbers so here's a short one. Feel free to fiddle both offline and online.
Since I find number-only submissions pretty boring, I'll be slowly putting out a few hints to compensate.

 Hint 1: The program ends with a single number of the stack, and none of the A-K variables are used.

Hint 2: The number encodes information that is completely retrievable if you reverse the process (i.e. no information has been lost).

Hint 3: The "information" from hint 2 is a single string which is created after the first four chars.

Solution
The program was
0W#sWcib

0W# is 0^-1, which instead of erroring out gives Infinity. s then casts this to a string (note that ` gives 1d0/ instead).
For the other half, Wc converts -1 to a char, which becomes code point 65535 due to the wraparound for chars (see this tip). i then converts the char back to an int, i.e. 65535.
Finally, b converts the string Infinity to base 65535 to give the above number.

TI-BASIC, ≤4 bytes, cracked by Reto Koradi
This took 5 days 23 hours to crack. So close...
Output (10 bytes):
.495382547

Program:
³√(tanh(7°

Since it's basically impossible for someone to guess this, my goal in designing this program was to make brute force the only possible approach.
To do this, I prevented the output, or the output with one of these inverse functions applied, from showing up on the ISC. ISC doesn't have hyperbolic tangent, and I figured that no similar tool would have tanh(7°.
To add some security against brute force, I used degree-to-radian conversion, a slightly obscure feature, but it wasn't enough.

I got one for 13 bytes, though I know it's not correct: π^(-5579/9092

And a six-byte one, though it's off by at least 10^-4: -1+√(√(5

@Conor O'Brien you only need 10 bytes to write out the decimal itself!

Even less in binary form

@Eridan  I fail to see the point in your comment.

@CᴏɴᴏʀO'Bʀɪᴇɴ I'm just pointing out that taking pi to that fraction yields neither the exact decimal given (even though it technically is an approximation) and is longer byte wise than simply typing .495382547.

@Endian So? It's still fun to find out.

Do you have a pointer to documentation for this version of the language, listing all available operators? I think the real question in this challenge is if somebody will have an unsolved 4 byte program. I predict that there will be multiple unsolved 8 byte programs.

Here is a list of all TI-84+ BASIC commands, as well as thorough documentation.

Just so it's clear too, Thomas (and I'd assume most people) consider things like sin( to be 1 byte on TI-BASIC. So something like sin(sin(sin(e would only be 4 bytes.

% in TI-Basic divides by 100 so it's possible the real value you are searching for is 49.5382547 or even something else! For example this will yield his output (though it's over the byte limit and also I don't think TI-Basic supports the Golden Ratio Conjugate: (3100Φ+967π)%%), but the reason I say that is that I divide by 10,000 in only 2 bytes (using %%) as opposed to 6 (using /10000)

In fact, for all we know, he could be using fPart(.

@AlbertRenshaw Yes, I had picked up on that. The documentation that Thomas linked lists a "token size" for each operator. I figure that's what we're counting, and that the operators he uses would most likely come from this list: http://tibasicdev.wikidot.com/one-byte-tokens.

@AlbertRenshaw % is 2 bytes.

@mbomb007 It's 2 bytes in TI-Basic? Or in general?

@AlbertRenshaw Yes. In TI-Basic

Is there any way to test code without having a calculator? Preferably online, i.e. without having to install software? I basically (pun intended) have this cracked, but I'm not sure if I'll get the code notation right.

@RetoKoradi There is not (both of the emulators I use require software) but I'll tell you if you have the correct answer.

Cracked? http://codegolf.stackexchange.com/a/61087/32852

><>, ≤ 8 [cracked]
oooooooooooo

That's a total of 12 os. The program halts without error, and works with both the official interpreter and the online interpreter.

Cracked.

Python, <= 32 (cracked by Egor Skriptunoff)
Output is 1832 bytes, including newlines:
163
485
559
1649
2707
8117
8415
24929
41891
124133
142639
423793
694675
2075317
2162655
6357089
10682531
31785445
36635183
108070513
177408659
531963829
551493855
1633771873
2745410467
8135173349
9347869999
27774121841
45526653331
136007297717
141733920735
416611827809
700079669411
2083059139045
2400886719023
7082401072753
11626476472979
34862249549749
36142149804255
107069239746913
179920475038627
533147175478501
612629840276783
1820177075697521
2983606407043475
8913418645908149
9288532499693535
27303489359118433
45881121294188707
136517446795592165
157346912904610351
464159319105013361
761964388609624723
2284767248741900213
2368648071721459935
7016996765293437281
11791448172606497699
34940303480791033061
40148795925132553519
119288945009988433777
195535487181321247123
584146895667469134517
608742554432415203295
1789334175149826506849
3006819284014656913571
8946670875749132534245
10311729937203639353903
30418680977547050616433
49935336207531756227219
149732221646300430475189
155229351380265876857055
459858883013505412260193
772752555991766826787747
2289849682101787770873061
2631225127929856733097263
7817601011229592008423281
12814491939404182769539475
38282841570818685533137589
39893943304728330352263135
117267593836794179779362913
197057915416468570144702627
586337969183970898896814565
675799844894514912336740911
1993549095225501056249169521
3272612129033008707863251603
9813000610033591312052461493
10173266001408484771580813535
30137771616056104203296268641
50643884262032422527188575139
150067460764265635881358255333
172437765505860562200296238383
512342117472953771456036566897
839818522529453467650609486227
2508891813142320379359897758389
2614529362361980586296269078495
7685131765672974922140201517153
12914190492831906312462400487587
38425658828364874610701007585765
44288542855785494654395594310191

I see a pattern of 4s.

cracked?

@EgorSkriptunoff Yep--I used a different looping structure, but otherwise it's the same logic.

@DLosc - Can it be made even shorter with another loop?

@EgorSkriptunoff I used a Python golfing technique--I'm not going to post my code because I might do something similar in another answer, but you can find the concept on the Python tips page.

@DLosc Now that this is long over, you could post your code if you even have/know it anymore.

@mbomb007 I don't, but I believe it was the same as Egor's crack, except using an exec loop.

CJam (cracked by Dennis)
Length <= 4
1737589973457545958193355601

I don't give this a very high chance of survival, but I wanted to try a 4 byte solution anyway.
My code was exactly what Dennis reverse engineered:
H     Push 17
J     Push 19.
K     Push 20.
#     Power.

CJam then prints all of the stack content, concatenated. So the output was 17 concatenated with 19^20.

Cracked.

@Dennis Ok, officially marked as cracked. I didn't really expect it to hold up, but I'm interested anyway: Did you brute force it? Or did you have a good guess on what I probably did?

The output is too large to be anything but a factorial or a power, and factorials this big would have a few trailing zeroes. I started with KK#, tried a few more powers, and finally found JK#.

Pip, <= 16 (safe)
This is my final Pip submission, I promise. :)
0123456789
0        9
0        9
0        9
0        9
0        9
0        9
0        9
0        9
0        9
0        9
0123456789

I'll be surprised if anybody gets this down to 16 bytes--it took me quite a few tries to make it fit. (Take that as a challenge if you like!)

Answer:
Px:J,tLtP09JsX8x

This code makes use of the predefined variables t = 10 and s = space.
    ,t            Range(10)
   J              Join into string: "0123456789"
Px:               Assign to x and print
      Lt          Loop 10 times:
         09         This is a numeric literal, but it can act like a string "09" because
                    strings and numbers are the same data type in Pip
            sX8     8 spaces
           J        Join left arg on right arg: "0        9"
        P           Print
               x  Last expression in a program is autoprinted: "0123456789"

This is pretty cool.

Hmm... Each number is the column number, 0-indexed. :-/

@JAtkin I think so too. ^_^ Explanation added.

Very nice, have a +1 ;)

Python 2 (safe 16)
(1.06779146638-0.024105112278j)

Range ≤ 16. In case the version matters (for printing precision?), I'm using ideone.
I don't see a way of guessing the code without computer search, but you all have impressed me before.

Answer:
print.7j**8j**2j

Is this REPL or a full program?

@ThomasKwa Full program.

Used dir(complex) to see what ops are defined for complex numbers. I didn't know you could use a modulus. Note that this won't likely be helpful, but maybe...

Ruby, cracked by kennytm
Range: ≤64.
#<MatchData "@@" 1:"@" 2:"@">
"#<ArgumentError: unknown command \"\\x00\">\nu#<ArgumentError: unknown command \"\\x00\">\nn#<ArgumentError: unknown command \"\\x00\">\nk#<ArgumentError: unknown command \"\\x00\">\nn#<ArgumentError: unknown command \"\\x00\">\no#<ArgumentError: unknown command \"\\x00\">\nw#<ArgumentError: unknown command \"\\x00\">\nn#<ArgumentError: unknown command \"\\x00\">\n #<ArgumentError: unknown command \"\\x00\">\nc#<ArgumentError: unknown command \"\\x00\">\no#<ArgumentError: unknown command \"\\x00\">\nm#<ArgumentError: unknown command \"\\x00\">\nm#<ArgumentError: unknown command \"\\x00\">\na#<ArgumentError: unknown command \"\\x00\">\nn#<ArgumentError: unknown command \"\\x00\">\nd#<ArgumentError: unknown command \"\\x00\">\n #<ArgumentError: unknown command \"\\x00\">\n\"#<ArgumentError: unknown command \"\\x00\">\n\\#<ArgumentError: unknown command \"\\x00\">\nx#<ArgumentError: unknown command \"\\x00\">\n0#<ArgumentError: unknown command \"\\x00\">\n0#<ArgumentError: unknown command \"\\x00\">\n\"#<ArgumentError: unknown command \"\\x00\">\n@#<ArgumentError: unknown command \"\\x00\">\n@#<ArgumentError: unknown command \"\\x00\">\n"

(And yes, all output is to STDOUT.)
Intended solution:
test'@@'=~/(.)(.)/ rescue p"#{$!}#{p$~}".gsub(//,$!.inspect+$/)

cracked

@kennytm Wow, I'm impressed. You even managed to make it one character shorter than my original code!

TI-BASIC (cracked by Thomas Kwa)
TI-89 variant
Range: ≤8
Output length: 460
1257286521829809852522432602192237043962420111587517182185282167859393833998435970616540717415898427784984473447990617367563433948484506876830127174437083005141539040356040105854054119132085436114190914221684704295353373344661986220406465038338295680627940567692710933178603763184382721719223039895582218462276317539764129360057392146874652124017927952151332902204578729865820715723543552685154087469056000000000000000000000000000000000000000000000000000000000

I don't think you can use RIES on this but I doubt it will survive 7 days anyway. Oh well.
Code:
236!

Cracked

What is "REIS"?

@mbomb007 http://mrob.com/pub/ries/

MATLAB, cracked by Tom Carpenter
Range <= 16
ans =

        5760       22320
       13920       53940

Grr, 17 is the closest I can get!

In fact I have so far found 8 ways to do it in 17 bytes!

Cracked: http://codegolf.stackexchange.com/a/60436/42295

Man that was a fun challenge!

Lua, ≤ 4 (cracked by feersum)
Output:
9.5367431640625e-07

You need to find a string for Lua REPL which results in "1/M" constant.
It is simple, but not very trivial.

@LegionMammal978 - Hint: In Lua 5.3 REPL one can omit = before the expression.

What I do know, however, is that there's no answer here...

@LegionMammal978 - Yes, the link you have given is the right place to read.  You already have all the information you need.  Just solve it.

cracked

interesting non-solution: 0x2p-21

Mathematica, Cracked by Sp3000
Range: <= 32
808017424794512875886459904961710757005754368000000000

Cracked

CJam, ≤8 (safe)
\"3.341594\43181\

Original code:
P`_`_`er

That is, to start with 3.141592653589793 and replace each character in "3.141592653589793" with the corresponding character in "\"3.141592653589793\"". With the duplicates removed, it's actually replacing ".123456789 with ""35\.49831.

Thue - <= 64 Bytes, cracked by histocrat.
555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555
That's 2016 5s; by the way.

cracked

GolfScript (safe)
44460233687688399109436699097976761322375660878906252846699686946304

Range ≤ 8
Solution
{9?7*}.%

Try it online.
How it works

{9?7*} pushes that block on the stack.
.% duplicates the block and maps it… over itself.
GolfScript performs type casting like there's no tomorrow. In this case, the interpreter expects an iterable, so the original block gets cast to array, yielding the following array of character codes: [57 63 55 42].
The block itself elevates each character code to the ninth power (9?), then multiplies the result by seven (7*).
For the four character codes in the array, this pushes
44460233687688399
109436699097976761
32237566087890625
2846699686946304

Before exiting, the interpreter prints the four integers, without separators.

C++ (Safe)
Was so close to getting the source below 64 bytes...
Here's the output:
0020002488100002416161816160248810000243232343232323436404042000241616181616323436404042000246464666464646668727274646464666880808280800248810000243232343232323436404042646464666880808280809698100104104106000241281281301281281281301321361361381281281281301321441441461441441281301321361361381281281281301321601601621601601601621641681681700002416161816163234364040420002464646664646466687272746464646668808082808012813013213613613812812812813013216016016216016016016216416816817019219219219419620820821020820822422622823223223400024256256258256256256258260264264266256256256258260272272274272272256258260264264266256256256258260288288290288288288290292296296298256

That's 664 bytes of output.
The source was <= 128 bytes
Solution:

 #include
int main(){for(int i=0;i<300;i++)printf("%d",i&2*i+1+i&(i+5));}
Uses the 'bitwise and' operator.

This one's pretty fun :)

Glad to hear it! Let me know when (or if ;) ) it's cracked and I'll post the source.

Since you know how you did this, you should take a look at http://codegolf.stackexchange.com/a/60374/16513 I see similar patterns in output, maybe you can solve his

Hmm, I'm looking at it but I believe he used a different method. Hopefully I'll still be able to figure it out. (Notice that mine uses all the digits, whereas his only uses powers of 2)

Pyth, Cracked by Sp3000
Range: <= 4
New, valid answer
I'm sure this can be brute forced with such a small program size, but lets see.
3582409715080948947248394822102989658717877178836918915255342812682764990143662880

The output must consist exclusively of printable ascii.

@SuperJedi224 dang, fixed

Cracked

JavaScript ES6, ≤128 bytes - Cracked
Output (1124 bytes):
00371223425266831021221451701972262572903253624014424855305776266777307858429019621025109011571226129713701445152216011682176518501937202621172210230524022501260227052810291730263137325033653482360137223845397040974226435744904625476249015042518553305477562657775930608562426401656267256890705772267397757077457922810182828465865088379026921794109605980210001102021040510610108171102611237114501166511882121011232212545127701299713226134571369013925141621440114642148851513015377156261587716130163851664216901171621742517690179571822618497187701904519322196011988220165204502073721026213172161021905222022250122802231052341023717240262433724650249652528225601259222624526570268972722627557278902822528562289012924229585299303027730626309773133031685320423240132762331253349033857342263459734970353453572236101364823686537250376373802638417388103920539602400014040240805412104161742026424374285043265436824410144522449454537045797462264665747090475254796248401488424928549730501775062651077515305198552442529015336253825542905475755226556975617056645571225760158082585655905059537600266051761010615056200262501630026350564010

Have fun, and good luck!
Original code:
new Array(254) .fill(0).map((x,s)=>s*s-s/((5-s)||3)).map(Math.floor).join``

Still safe :3

I enjoyed this. Cracked

@SLuck49 I posted the code.

Pyth, safe, <= 32
My first try at Pyth, I'm curious how fast this will be solved :)
Output (40 Bytes):
=fu(NMVU\_RQPSnmvu~}twjihkfe^]&%,/"! #>=&%.-

Solution
j""+]"=fu("CMmx=T+2Td.f.&TZ40 65

Pyth, safe, <=16
Output (112 Bytes, 32 Numbers)
[9, 15, 11, 9, 7, 25, 27, 25, 31, 25, 27, 25, 5, 11, 15, 13, 3, 5, 7, 5, 3, 61, 63, 61, 1, 7, 3, 1, 15, 1, 3, 1]

Solution
mx=T+1Td.f.&TZ32

Insomnia, ≤ 64 (Safe)
ProgrammingPuzzle&CodeGolf

I would like to assure everyone that I didn't just pick this string off the top of my head and post an answer without checking whether a solution exists or not :P
Interpreter@StackSnippet
Hint
Since instruction 8 is ambiguous, it's not implemented in the interpreter along with instruction 9. However, the solution doesn't contain instruction 8 or 9.
Regardless, I accept any solution which runs correctly with either of the two possible interpretations of instruction 8. Feel free to implement your own interpreter for it, or update the interpreter in the link.
Solution
(ddG=
pjyn><p"e=pdjj<LdtdFjuy~nod=nL<yf="f<ujgFutpt(p=<(oj!>o<pL

There is no trailing new line at the end. The solution is optimal or near optimal, so it's hard for human to actually derive this by hand.

There doesn't seem to be an interpreter available for this language...

@Mauris: I have edited the post to include a link to the interpreter.

ÈÊLdÊFHLyGFÈFFLÊFÊFHLdFÊLpyF<FBÔ<FHLyÔLIHFÈÊL outputs "ProgrammingP" in insomnia 1. Which version of insomnia is this? Also, all those Es and Os with funky symbols on top allowed?

@ppperry: It's as described in the linked article: the source code is ASCII (so all those characters with accents you have are not allowed), and it's Insomnia version 1. My interpreter only happens to allow Unicode input, but they are just for fun.

That is not an Insomnia interpreter. Without the 8 and 9 commands I don't even think it's a programming language (by PPCG standards).

@Mauris: It doesn't require instruction 8 and 9 to fit into the byte count, though it's hard for a human to do it. Anyway, I accept any solution with either of the 2 possible interpretations of instruction 8. As for the validity of the language, I have been using this language for many output only challenges, and no one has been complaining so far.

Ruby, ≤ 64 bytes (safe)
213 bytes output:
pooppopooopoopopopoppopqooqooqpppqpqqoqppppproqopoppqprppoqptqrutqqqrqppqtppuqovsurprwprypsorqutsvppxpsaypqupsxavpqpxyqttvxwapuosabseogzrggxprtrceqduzrqtiawpjerbpdytupxlnlptqqbpojxxnnjklzepjuoshwgjfgnnequpcncebhub

Solution
Just some large number in all the bases from 2 to 36, with the digits shifted around a bit. The number 631381 was chosen because it stayed within the 26 first digits in all bases so that the final output, when rotated more than 10 places, would only contain letters.
When shifting the digits back, you can see that the string at first only contains zeros and ones, then a few twos, then some threes etc, making it the pattern quite obvious.
35.times{|i|$><<631381.to_s(i+2).tr("0-9a-z","o-za-n0-9")}

Java (safe)
Length <= 128
Output (1412 characters, # is the first character):
#-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0#wj]PC6)0pcVI</6vi\OB5(9obUH;.5uh[NA4'{naTG:-4tgZM@3&zm`SF9,3sfYL?2%yl_RE8+2reXK>1$xk^QD7*1qdWJ=0

The program was
class T{public static void main(String[]s){for(int i=18356,t=0;i>1;i-=13,t=i%97)System.out.print((char)(t>88?t%10+48:t+35));}}

J Atkin was on the right path when he mentioned the number 13 in the comments.

Is this on a REPL, or in a function?

It seems to have several repeating patterns...

@LegionMammal978 Just found an interesting pattern. when checking the diff of numbers -13 shows up a lot.

There is a pattern, but I find the challenge is that class S{public static void main(String[]a){}} already takes up 45 bytes so there isn't much space you could work with _(:3 」∠)_

Yea it's a full programm, not just a function.

Dang this is hard, I think I'm stuck.

Very nice, I never would have cracked this. Out of curiosity, what does i>1; do? It doesn't seem to do anything.

@JAtkin It stops the loop

Man I''m dumb, it was in a for loop.... Thanks

><> (Fish), Cracked by Sp3000
Length <= 8
>>>>>>>>>>>>>>>>>>>>>>>

The output is 23 >'s and the program produces no error.

Cracked

C, <= 64 (safe)
2000 bytes of output, including a trailing space (though that's not important, it could just as easily be left out):
cat cat dog cat dot cog cot dot dag cot cog dag dag cot cog dat cag cog cog cag dot cag dog dog dog dog dat cog dat dot dot dat cag dot cot dag dag dot cot dag cog cot dot cog cat dog cat cat cat cat cag dot cag cat dat cag cog dat cot dag dag dat cot dag cot dot dat dot dog cat dog dog dog dog dog cat dog cog cag cog cot dag cot cag dag dag cot cag dot dat cag cat dat cog dat cat cat cat cat dog cat dot cog cot dot dag cot cog dag dag cot cog dat cag cog cog cag dot cag dog dog dog dog dat cog dat dot dot dat cag dot cot dag dag dot cot dag cog cot dot cog cat dog cat cat cat cat cag dot cag cat dat cag cog dat cot dag dag dat cot dag cot dot dat dot dog cat dog dog dog dog dog cat dog cog cag cog cot dag cot cag dag dag cot cag dot dat cag cat dat cog dat cat cat cat cat dog cat dot cog cot dot dag cot cog dag dag cot cog dat cag cog cog cag dot cag dog dog dog dog dat cog dat dot dot dat cag dot cot dag dag dot cot dag cog cot dot cog cat dog cat cat cat cat cag dot cag cat dat cag cog dat cot dag dag dat cot dag cot dot dat dot dog cat dog dog dog dog dog cat dog cog cag cog cot dag cot cag dag dag cot cag dot dat cag cat dat cog dat cat cat cat cat dog cat dot cog cot dot dag cot cog dag dag cot cog dat cag cog cog cag dot cag dog dog dog dog dat cog dat dot dot dat cag dot cot dag dag dot cot dag cog cot dot cog cat dog cat cat cat cat cag dot cag cat dat cag cog dat cot dag dag dat cot dag cot dot dat dot dog cat dog dog dog dog dog cat dog cog cag cog cot dag cot cag dag dag cot cag dot dat cag cat dat cog dat cat cat cat cat dog cat dot cog cot dot dag cot cog dag dag cot cog dat cag cog cog cag dot cag dog dog dog dog dat cog dat dot dot dat cag dot cot dag dag dot cot dag cog cot dot cog cat dog cat cat cat cat cag dot cag cat dat cag cog dat cot dag dag dat cot dag cot dot dat dot dog cat dog dog dog dog dog cat dog cog cag cog cot dag cot cag dag dag cot cag dot dat cag cat dat cog dat cat cat cat cat dog cat dot cog cot dot dag cot cog dag dag cot cog

Code:

 main(i){for(;++i<2002;){putchar("tg  cdao"[i%4*2+i*i/97%2]);}}

What it does:

 For each i, compute i*i/97 (integer division) and take the least significant bit of the result. This gives a fairly random-looking string of 1's and 0's: 0000000011110000110001100100110110100101... We use these bits to determine whether to take a letter from cat or from dog, and we use i%4 to cycle through characters 0 through 3 of the selected string. In Python, ungolfed, it might have been ("cat ","dog ")[i*i//97%2][i%4], but combining the subscripts with math is fewer characters and much easier in C. 97 was a nice divisor because 1) it meant the output only cycled after 388 characters and 2) it happened to begin the output with the actual words I was using.

TI-BASIC (cracked by Thomas Kwa)
Range: <= 2
String: -10
Code: Xmin
There's just no fooling this guy...

You haven't already cracked it have you?

I would be seriously sad if you did this is pretty clever imo.

In Python this is ~9 (bit inversion)

Sure, but you have to answer it in TI-BASIC. At any rate it doesn't really matter; Thomas already cracked it. I think he's waiting just to be nice (?).

Cracked

AppleScript, ≤ 2 Bytes Cracked
"Brute forced... grumble grumble..."
What's this? A short AppleScript answer? :o
missing value
(yes, this DOES print to stdout)

a= or a- 1= or 1- or ? I have no idea=)

Nope. Those will throw to STDERR as error #-2741.

osascript -e 'say "Cracked."'

@squeamishossifrage You can shorten that by one byte using say"Cracked.", and, if you don't mind grammar, one more byte with say"Cracked". c:

CJam, Range <= 16
So, this is embarrassing... I lost the program. So this answer is unsafe for all eternity. Crap.
1012718281828459045273890560989306532008553692318766845459815003314423651484131591025766640342879349273517109663315842845858298095798704172839810308392757538410220264657948067181159874141715197821216275479141900392134424133920089205141202604284164776815326901737247211071688861105205078721724154952753575314718656599691373305114285

That's OK, I lost the code to my dc submission as well :P

Stuck (cracked by Thomas Kwa)
Range: <= 8
String: 46411484401953
Code: 21 6b9^
Just a silly math op. Won't be doing that again :P

No cryptographic functions were used in this since Stuck does not have them. I could I suppose evaulate a Python string that generated it but it would be far longer than 8 bytes.

Ok, I might as well remove some of the bloat in the original question then.

Cracked.

Didn't last long, but then again I didn't expect it to.

CJam, safe, <= 8
String (512 bytes):
31727830821534042803654900580041579944125099215829830038849883087237485384990372997137008773602561554524455355546965826217636264280531379575060368678123679591507670376378983011031372862444170088901246406464915421417735501844369384343529103866975162261323889938505690754099908479501571769966236353640152428123626259639270728536136695534152761505469883628985035665299649482133954805098589954263750507014493822638005349453618584045569842991716571963837585058144921186599068741714697983434201508077928870739706904563

Solution:
JK#)K#D-

The value is (19 ^ 20 + 1) ^ 20 - 13:
J   Push 19.
K   Push 20.
#   Power.
)   Increment.
K   Push 20.
#   Power.
D   Push 13.
-   Subtract.

Is the first character the spacebar or is it the 3?

@KritixiLithos It's all digits. If you select the text, you'll notice that there are no space characters at the start/end. I noticed that it almost looks like a space, but that's just an annoying formatting artifact, which I believe started showing up with the last big SE software update a few months ago.

@Optimizer I had deliberately used backtick formatting to keep the whole string visible. Using code formatting that requires substantial horizontal scrolling to see the content is not reader friendly at all, IMHO.

@RetoKoradi Most of the other answers are using the same thing. I don't see how it iwll be useful to have just one answer's complete string visible. Moreover, your approach gave false perception of newline and space.

Why argue about those things? When in doubt, list them both.

CJam (safe)
2969522710354117782268728281657874436077523451779189557858587124583732510232011182279648629302843012289537453156332620095347999870372186093569331972697450949571859995882165462952598378969103716558199013336239649166612855864402550284067775310029003979877576199234109704434192635868502534981511417768215602068546604589986237229981031515030844801890461800301300586064632275590967524506584831641691973705609466213993115716532669668183228671719799797562347371977329411936519256700981805373719919563640081628731389259795576339314694437080532378397585079403456215187549555967563283027604516908978269967118530905535308199228549578026691375975460991281557011399137527701055702769707536280006211461419462578004525812149844993765514697489735731025966784896379532108289602755662085743159982449970234950573500056692724864838103316392136519596778919106341667367801619890408628376816766014332163973769272783086065478133370857238494654315760990599225291037789853075070883915266958971748930365643994352950540496292548233966198335335092270718914517713429711934658808391076425410875435074192671012252715659331835221032454345564515855711607560938486720828374134819056045908284745381899992891870848325899309936307806608248782453178135052097370046402306272117696828073734127833151006582338686565489219479914533172914156409774220012911422325101334215197613438518304374272539625228307215875879830003850943261471668455041684061881784918857016574652559502693026187748485672247569179975106384082858131188717254923758658030214195014268064074865548117365871337277792602175655153982608733754392934636625990612708894514702745610870084535682834239693756847083681367634543706897751979399419992664301243055818300975493542084844509307521718271958163217805654531672244843277091018869783464554836938615149100691788966169099253377254362419671264475928212313071437014017258081820799682807812996637402619207718937561360621651155389611664139610329091736456106709712362258586867241270561371701064645520801674199626189861414161065280851185396832

Range ≤ 8
Solution
5e!e``Bb

Try it online.
How it works

5e! pushes all possible permutations of [0 1 2 3 4] as an array.
e` performs run-length encoding. Since all permutations are unique, that doesn't do a whole lot here. It simply turns, e.g., [0 1 2 3 4] into [1 [0 1 2 3 4]].
` pushes a string representation of the resulting array, i.e., "[[1 [0 1 2 3 4]] … [1 [4 3 2 1 0]]]".
Bb converts that string from base 11 to integer.

PARI/GP (cracked by Dennis)
362871

Range <= 4
I don't expect it to last long.

Cracked?

Fourier - Cracked
Range: <=32
String:
2122483225681922097152171798691843602879701896396861897001964269013744956211222300745198530623141535718272648361505980416138034926935811275748695117245540509049022179443407731103250484475985923078281734093318688459300007823719828521854630505113020933460422206697013398219579016739551162884034438017811742724249103942534136789516705652419749018636744941816255385595553105603228478886817941913300018121834285351114635889972008122772634701221657915276159830132698815550650166683145752253825024130799390525667397576712042121582252265796485803898145439910936080365118545524429015283005226525373306591146596380999368308977696007362554150202362972394711962091891782522350896253352112577772728002370387610430602826927993986801361806220018873011021906386675753009547945073606343415825034633858252855578020596367555775021017581896705394774043140172299149272778867192103837211440298730978220217461771857441901426311729681383820569104974145481270877016012649453231348275519970913382122931358798794913451593854784081756995081772717065856294736122642489533802911558562892537346452028109264847224473615121287113076915002394139208578086177686115257497354785332151612870275311503343425837268382273205956262450375487052304152420010520592218930639911558485308199423713696620200782955806727269571220627865960521160791605471835355486134202329528196715632135831547021667820610489669276412307052313282798182724228494489571749785803184288017511963522262363914512187106605499089158487126931984998931607232391153536046707042953355790522537094715328944294216691664397407079523074157949383649613963144290903909350911775369346530804545543989831547266901148133975781331624980745497418452932259866320677062287020172601937538303131944333834647775468710319343284001431665213130766208748703580971865899367058864133080365305110228654823694689069629811633466999394638916807976061252245511624205865226492647247562826021570513721099219359990299022601672140852584716895460404747374717998459657246694308370646635919987895996736789540655850081764170577611893869560559643310988147153698816

That's 2047 characters for the doubting person  ;)
Clue:

 This is a variant of something very common, which is known and loved (possibly) by both mathematicians and programmers.

Cracked

Python 2 (safe)
6827526938285133941673000231813168619941300497097936591748380508088909429445611165463624032127627532803234880684278865355076531262231840494975595460968129959347104225901744872847426849492584955132469122376660991207547055101929306267237604577722010893773043497283203607878662025645581606573723842423809514070028255417440212506882886554655415227255545579921342691580901906655429920934202998813117772871149920709038390132067329036138426507171331383525723381813108558141195500901960258557975441280

Range ≤ 32
Solution
a=b=9;exec"a*=b;b^=a;"*9;print b

Try it online.

PHP, Safe, Range ≤ 64
The length of the output was just to obfuscate. I left the --sign as a prefix to the numbers as a hint that trigonometric functions might be involved.
The function to calculate each number:

The source code, 42 bytes long:
for(;$i<607;)echo ceil(++$i*tan($i/pi()));

Outputs a 2044 characters long string:

12514-240-17-9-5-215102154-240-39-20-11-4292039111-240-57-29-15-54153162195-239-72-37-19-57224490333-238-83-43-21-5113059123599-236-92-48-23-41639761641319-235-98-52-24-121509621710552-233-104-55-2422862120285-2434-230-108-57-2353676147377-1234-228-111-58-22104592179507-880-225-112-58-191655109217704-710-222-113-57-1622661292621040-610-218-113-56-1230781523171741-542-215-112-53-738921783864110-494-211-111-50-247108208472-22745-456-206-108-46558126242586-3376-427-202-105-421269145281740-1922-402-196-102-372082167328962-1386-381-191-97-3129971923821310-1106-362-185-93-24391122194481935-932-346-179-87-17501302505273386-814-330-173-81-96214928562710550-727-316-166-74-076170325753-11334-661-303-159-671090193371920-3899-607-290-151-59211062194241151-2426-563-278-143-50331232474861491-1794-526-266-134-40451412795592044-1441-494-254-125-30591623146473103-1215-465-242-116-19731843547555958-1057-439-230-106-88920839988941232-939-416-218-9551062354501062-9088-848-394-206-84181252645081294-4231-774-374-194-73321442965761619-2810-713-354-181-61471663316552113-2130-661-336-169-48631893717492951-1729-616-318-156-34802144148624693-1464-577-301-142-2099241463100110548-1274-541-284-129-51182715191176-59009-1131-509-267-115111393035821404-8127-1019-480-250-100281623396541713-4459-928-452-234-85451863777372158-3112-852-426-217-69642124208352853-2411-787-402-200-53842404679524097-1978-731-379-184-3610527052010936978-1684-682-356-166-18127302579126821051-1470-638-334-149-01503376451491-22742-1306-597-313-131201753757211784-7593-1176-561-292-113402024178082188-4625-1070-526-271-95612304639092783-3355-981-495-250-758326151310283748-2648-905-464-230-5610629356911705592-2196-839-436-209-35131328631134410543-1881-780-408-188-14157366701156069591-1647-728-381-16781844077791838-15855-1466-680-355-146302134518692208-7251-1321-637-330-124542445009722729-4750-1202-596-305-1027927755310933517-3554-1101-559-281-8010431261212354852-2852-1015-523-256-5613135067614057623-2387-939-489-232-33160390748161516880-2056-873-457-207-81894348291878-98654

Python 3, Cracked
Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

<= 128 bytes. This one was posted earlier with a smaller byte count, but was deleted. I figured out how to do it in the <= 128 category.
My code (94 bytes):
p,__builtins__.print=print,lambda x:x;from this import*;p(''.join([d.get(c,c)for c in s])[4:])

Cracked.

><> Cracked by Sp3000
Requires the official Interpreter
String:
yh[cPWNkz^EKLBiQMuSvI`n\Yw|JVXDUbZmfoRC_xrq{TlpHjGt]OadFAsgeyh[

Range <= 64
Original Code (poorly golfed, I know. x.x Was rushed as trying to do other stuff, Sp3000's code is far superior)
   "%e@"&b+:r\
;v?:-1&:*}:{:<
 >&:"=@"@%+o ^

Cracked

CJam
Range <=8
31750158586652376823306770524160580239759220968490662365280697333523990463193796504719728904832671151360272625266534588786424734457574712153976494064953411059739792915722586949729210719621153746894802142918027970654609398438852308624078542639175128838831245786273442836511403960499435950211913983569988987209742058089855692071657841384645297208882183542051537989712878902231738195073256758864262540198959691481289564731544298150520509963645384433851976251199310574577965940322710082134532284930147152412624

MATLAB, <= 8
I believe we are allowed to post another answer in the same question as long as it is not in the same range. My last one was 8<r<=16 by my understanding of the rules, so for this one:
String:
    [51x51 double]

Note: This will produce ans=, but that is not part of the output string, it is simply MATLAB saying where the output ends up - but based on the comment on my last answer it is important to know.

Now that this one is safe, the code used is:
logo;{L}

As a bonus, you also get a picture of the MATLAB logo. Running the logo script produces a variable named L. If you wrap this in {} you get a cell array which because there is no semicolon MATLAB prints out the size of its contents.

That is correct, since it is in a separate range

In what sense is ans not part of the output?

So many ways to do this in 9 bytes... But 8...?

vim
Range: ≤16 (keystrokes).

Qb lbh qrznaq n fuehoorel?

Cracked. My answer got converted to a comment for some weird reason... But it's :redi@"|Ni!<CR>pg?G

@Mauris Try posting the answer without a link and then editing it in after posting. The SE software automatically converts very short answers with links in them to comments.

Oh, I never linked the answer I made. But here you go!

I typed this in and vi is saying something about a shrubbery. What is going on here??

@squeamishossifrage We are the knights who say... ni!

@Doorknob I think I need another drink.

Python, ≤ 64 bytes (safe)
range ≤ 64
output (1334 bytes)
cpKKhcKhcccpcE3lA!3 AKl!KllA cAlh  p!clAlhc!plhhE cpp3A33chEhKll ccphh  !3 l  lK!pEK3KhKEAK KK!3ph!c!3EKhKA!3AKp3lAK c3EpEp!33!EE Kl EAh!KAl3EhEccAA E3ppE3AA3pc  3pphEEK!A!!3cAhcpcEEc Al K3  33 hKpllplcKh3p3 phpAKE!Khcchp h 3 cc!hhc3EKpp!KcKcl  h!p!p3 l!clAlAch El!AE!pEhAlppAAhpK3chplApp!lApE!3 hAEKEp!AhKl3l Al3A3KEh!3 ElKK3pcp AppK33 !KKEphhpK3A EElp!lEEAEKKc h!h EhcpEEclKEp  lcllEK3lAK3E EK3KcA!cEpcpKKKllcEpAlEp!pKl3AKpAphhh!lhhhpAcKAAKlchcpA!lEhch3 hK3!l!cAcpA Ap cEl 3l ppAAAh A  !!EEKE !l!KhKEcKAc 3ch E!lhl3cAKElE3EAhlA33!pElA3c3lKl ! clp clAE3 AApA!c3cK Ac!c! hlhhhh!plcc! ppEE3chl 3!E!EE! AchpAlpAlEchchh3!lEhhEhhppK!EEE AKKEp!  lpp pKclhpAlAKA! lEAhhpAhE3 cpp!llllh lccKEcEhllKcEKEpEAcE!Ehlh3c!A 3l!EK  AAE 3 Ap3 Eplcl!!chlA3KEpE3KE!AhcKl3!p K E! KlAA3lEEKp !!p ph!!!!pA3pEK  3 c3lpp!A3!K3A! 3Kcl3pcA!AAAhA!cc!3!!Klh3 AEphppEcp3pccppAKlcpcl  pA!p!Ac3lAh!ll!phK3hKh!AAhh h!EK!pcAKhcpEAcEEEhKl lhhEpKpKlhAK3cA!!cphh!Kp c lhccEAhl3h3A! 3AElcEAlhhE hAlp3lEp E  3lEE!K3 hc3p p3 3lAlEK hKc3cEcKp   ph!K  !hhp!Alcpc3E p33 cEcplh33pA33h!pElhEc!hKEhcElcl!Ec3l3hphp! hEK 3AEAEhAplApAA! lppKApE3cEhplcclAcc3!!hA!lp3cp Kll!h!phhlllhl!clKEchElAlEcEKll p!3A KlK Kcp3EKEA!p33!c cAAAcAh3KE3K!AAhcE3hlcKhKK!! K!pE lEpcA lEl AElpEK 3EEpllA  hl  Ahl cA!ph phhp cAccK K!lp3 KhE3!Ehc  ! 3KEcc 3lE!c3KhEK EcAEApAAKK!ApEA!A c!A KE3 cl pKp l E

The code:
print(''.join(' Ac!hKlEp3'[int(i)]for i in str(2**4423-1)))

It exchanges the digit characters in the 20th Mersenne prime for some other characters.

Is this REPL or full program?

@JAtkin I looked up REPL but I'm still not sure what that would be in Python, so I'm going to guess it's considered a full program.

The REPL in python is the python console. If your program is in its own file and it uses print, its probably a full program.

JavaScript (cracked by NaN)
Range: ≤16
Output (17 bytes):
28274333882.30814

@NaN It's actually 11bytes - Math.PI*9e9, but you should post it as an answer!

@SvenTheSurfer Cheers. Cracked.

PHP, safe, <=128
Output (190 bytes):
2.550(3 6*117!> 9/:0 5;*<#<(? ;:":! "=9*%3%1;)'32'*0+=+0% .0-5,+469$081+=/6,7!5'8'9&9%:*?'<(>)%.!7"<&$ ;';%8<):((7*4*0(2,;))3!/'3/2-1(0+5#(87(6.;#9$9$;&<'?!?)<:'>#=&$$= "!!%=$6*3)0+=/+1#-54!

Update: I noticed that the output depends on certain system settings and also had contained non-printable characters, I had to change a few things to fix that, so now the result looks completely different.
Solution
<?$d=dDSzWmMtoYy;for($i=31;++$i<127;print(date($d[substr(sin(deg2rad($i)),9,2)%11],$i*1e9%14e8)^chr($i).chr(158-$i)|~ßß)&~"@@");

What it does
Use date() with parameters that result in strings with at least two characters (but independent from timezones) and with different timestamps, then XOR the result with two characters defined by a simple loop variable and restrict the result to the printable ASCII range with |"  " and &~"@@".
substr(sin(deg2rad($i)),9,2)%11 is used for pseudorandom numbers between 0 and 11, $i*1e9%14e8 for timestamps between 1970 and 2014.

I get a complete different output, when I run this code snippet, tested with PHP 5.5 and 5.6: >.=5<(? >*=1?!> =/>0<5?*<#<(? ?:>:= >==*=3=1?)?3>'>0?=?0= >0=5<+<6=$<8=+=/>,?!='<'=&=%>*?'<(>)=.=7><>$<;?;=8<)>(<7>4>0<2<;=)?!?'?/>-=(<+=#<8?(>.?#=$=$?&<'?!?)<:?>?=>$<=<"=!==<6>3=0?=?+=#=5<!

Is this on Windows, by chance? I got the same results for all current PHP versions with https://3v4l.org/

I've tested it on OS X 10.10 using built-in PHP (5.5) and MAMP's PHP 5.6. I also set the time-zone explicitly if by any change this might change the behavior. Strange thing. :)

I removed any time zone dependencies (that was part of my update). I think the problem is with $i*1e9%14e8;, the correct result of 31*1e9%14e8 is 200,000,000 and I get that on 64 bit builds where 31e9 is an integer, but on 32 bit builds it's 935,228,928 and I get the same output like you because of floating point errors :(

Oh well, so it produces the desired output only on a 64 bit system. I think that's absolutely fine. :)

Python 3, <= 64 bytes [Safe!]
The length of the string is 2034
488281245549883988617831547692636280774840973865020014963780603107176397111896466371318141671145799999516100116931775007357195385943921474836432356840327258293593328268244373089608827337244259136765312454003133867435356466747291945665131452813556182860860218727636513199372703748751775964829808191999995882592301095002084771021688666210978063483117859223581264272609313550818776145126277071553066533716607531245177459141211894859378720218443227215584306532297162157724461180923260303751492768257439729421254663312499999953317250470135192575597373141342613954121932341877988764443287222534689782349049589822587524093784585536128124558450454750616819589076506099226468592894493722831489207613738508380161381300843610672778874252672293311999995980758867671030407487171082133122351136004711631192092895451250470044131311210285791374389534671440085519551508377812451579347857531653079000271729656516751809167643331891701606391977349652432066205078262158363261572253921691562352979999952455639992082562005678372672183305842786281390032904410747023026684525733153218240423284129803473419539558263559570312453704347371323853998571474008654314614168447601734333514067334503992014034680022447274861749110375049318519655242879999955442585720255648590729575861052993076080133428436305995942336538807467336778737998817025960632277280651600727542990312457813159388868091344702678377735416228672524020138975906372029288081735639609252820049939625819171027941045148106288199999510988071352161135738504077117369852840612127100026831252796098139129398036689313362867460951379739562107142436353469314701837812451517225821015156551557938716150793921591665944009853171813660204517716847617231826616509655188296029879719407450187071999999999995206075501878221230403011972186886527880225232483852323193868364202388104593053245851065268425306380369872604520249690268019128124527576856135182837038224507291828459307030014607036933086603051264317374864588332629350176813354200221677344758284264135431219999953640857352723374082910431738430780077293947645370363

My code:
print("".join([str(int((i**6)/32-5))for i in range(50,225)]))

I think I made it to hard...

Python, 128 bytes - safe
660683327594476238907838932164883150043152487972265621586853747350018950043398241174734510500438932288265866081053722653747103105372265374710194487843821420414263599196956978488088314633969572265621599199414510512777203769809075969078413898191547525125351794463394487842685619178954944883376732710310525621623887080436463396956732734885845868512778438954957221648336500433993769772038932288265866081177179443870436488088314757426243870559858458685498167098191546389322882658648587080436414014229325327592018706883150043152487972265621599198192041376974734756265866092411747350043399376977192288290554981547599199425868537353747103080680907596932530290311821421648090747352512535179446328090759689549572265866092535204021648337648580907967302900660682191792018461130061154510488088303399401666092658710310536979648466092782080680907843846110537225401668561670994266092782093026574880883147574263599199425868537354981670981914241424093024117472315248808461130064858214191792007103105369796362414014240683352169796485796730278708043641401422932532759201858463623646290557439201870800660683376977203646315132759448759692019201870801895250080680907350018952512535179446328090759690784016735001895004339824117473438705599201870801895250093026586362352289549572216483365127796727821177154754981424092910537226537469796979648579673027870804364016685621648337648582130559895493253152537471030806808958685374685619179201870801895250093026586362352290784140117717933029031294487843858458685127796614240930241173500683352283376731574508067843845996956979623890772535204135228461179446339448784268561917883150043646315246339694537471030806796735228584562162377350018950043399401668561671006490784140117716710559895493253274784384610930265868561917895495710806809073500066105372265374710194487843821421648090759690784138981915475251241179673029006606821917920183376732759693253029031182142164809074735251253517944632796730290066068335228584562162377473475740166732784384611053722540166856154754981917920184611299475742635745068338932288265866081177179443870554
By the way, len(output) == 2046
Source code - 98 bytes:
z=lambda k:"".join(map(lambda k:str(ord(k)),k));print int(z(z(z(z(z(z(z(z(z(z("79")))))))))))/81^5`

This is an actual number, obtained by math, not a sequence of numbers without spaces between them.

Well I'm not going to try factoring it, lol. There's a reason why large-numbered answers are so boring.

@mbomb007 Factoring wouldn't help. In any case,I obtained this number by dividing an even larger number (2048 digits) by another number. That number was not mathematically obtained(You'l see if you find it).

C, safe, <= 64
String length is 2023
:;;::;;;;;:;;;;;:::;:;:::;;:;:::;:;;;::;:;::;:;;;:::;;::;:;;:;;;;;::;;:;:::;;;;;::;:;;:::;;;::;;;:;;:;;;;:;:;;:;::;:::;;::;;:;:;;;;;;;:::;:::::;;:;:;:::;;;::::;:;;:;;::;::;;:;;;;:;;;;:;::;:;::;::;;:::;;:;;;;;:;;;:;:::;:;:;::;:;:::::;;:::;:::;;;;:;:;:;;::;:::::;;;;:;:::;;::;::;:;;;;;:;;::;:::;:;;;;:;:;::;::;::::;;:;;:;::;;;:;;::;;;:;:;;;;;:;:::;:::;::;:;:;:;:;;::::::::;;;::::::;;:;;::::;;;:;;;::;;:;:;:;;;;;:::::;:::;;:::;:;:;;;;:;::::;::;::;::;:;;:;;:;;::;;:;;:;;;;;;:;;:;::::;:;;::;::;::;;;;:;;:;;;::;:;;:;:;;;::;;:::;:;;;;;;:;::;::::;::;;:;::;:;;;;::;;::;::;;;;;;;:;;;:::::;:;:;;:::;::::;;;:;:;::;;:;::::;;;;::;::;;::;;;:;;;;;;;:;:;:::::;::::;:::;:;::;:;:;:::;;:::::;:;;;;:::;::;::;;:;:;;:;;;;:::;;:;::;;:;;;::;;;;:;:;;;;::;:::;::;;;:;:;:;;;:;:::::;:;::;:::;:::;;:;:;:;:;;;:::::::;:;;:::::;::;;;:::;:;;;:;;:;::;:;:;;::;;::::;;;;;;;::;;:::::;;;;;;:::;;::::;;:;;;;::;;;:;::;;;;:;::;;;::;::;;;:;;;:;;;:;:;:;:;:;::::::::::;::::::::;:;::::::;:::;::::;:;:;:;::;:::::::;;:;:::::;;;::;:::;;:;;;:;:;;;:;:;:::;:;::::;:;:::;::;:::;:;:;;:;:;::::;;::::;::;;;;::;:;;;::;;;::;:;;;;:;;;::;::;:;:;;;:;;::::;:;:;;;::;::::;:;;;:;::;::;:;::;;:;;:::;;;;:;;;:;;::;:;:;:;;;;::::::;::;;::::;:;;;;;::;::;:::;;;:;;:;:;;:;:;;:::;;:::;;;:;;;;:;;:;:;::;:;;::::;;::;;;::;;;;;;:;;;;::::;:;::;;::;:::;;;;;;:;:;;::::;:::;;;::;:;:;;:;;;::::;;:;:;;::;;;:::;;;;;:;;:;;:::;:;;:;;;:;::;;:;:;::;;;;::::;;;::;;::;;:;;;;;;;;;:;:::::::;::;:::::;:;;:;:::;::;;::;:;:;;;;;;::::;::::;;::;:;::;;;;;:::;;;:::;;:;;:;;:;;;:;;:;;:;:;:;;:;;:::::;;:;;;:::;;;:;:;;:;;:;:::;;:;;::;:;;;:;;;;::;:;:;::;;;:::::;;;:;;:::;;:;:;;;:;;;:::;:;:;:;;:;::::::;;::;::::;;;;;:;::;;:::;::;;;;;:;:;;;:::;:::;:;;:;:;:;::;;::::::;;;;;::::;;:::;;::;;;;:;;;;;;::;:;::::;;;:::;::;;:;;:;:;;;;:;;:::;::;:;;;:;:;;::;:;:::;;;;:::;:;;::;;:;::;;;;;;::;;;::::;;;;:;;::;;::;:;;;;;;;;::;::::::;;;:;::::;;:;::;::;;;::;;:;;;:;;;;;:;:;:;:::;::::::;:;:;::::;:::::;::;:;:::;:;;:::;:;::;;;:;:::;;;:;::;:;;:;::;;::;;::;;;;;;;;;;;:::::::::;;:::::::;;;;:::::;;::;;:::;;;;;;;;:;;::::::;:;;;::::;::;:;;::;:;;::;;;;

Solution:

 main(a,b){for(a=b=2022;putchar(58+a%2),b--;a=a/2^-(a%2)&1280);}

Ruby, <= 16 (safe)
13692278437523182704300881

Solution:

 p"5#{9**28}".oct

Explanation:

 9**28 is the only two-digit power of nine (possibly the highest power) that has no 8s or 9s in its base 10 representation--which is to say, it can be interpreted as octal. I convert it to a string, prepend an extra five digit at the beginning because I'm a jerk, call .oct to convert the string, base 8, into a Numeric value, and p prints the result in base 10.

Befunge-93, <= 16 (safe)
65 72 4680 65 6120 77 6080 46 1470 58 0

Tested here. Will give different results in Befunge-98, but the output should be reliable in any Befunge-93 interpreter.
Original source code:
">:#*._@MUHAHAHA

After the initial double quote, everything that follows is pushed onto the stack as a series of ASCII values, one byte at a time. On reaching the end of the line, the program flow wraps around to the first character again, which is now treated as a closing quote.
After that, the characters >:#*._@ are interpreted as follows:

>: process instructions from left to right
:: duplicate topmost value on stack
#: skip next instruction
*: replace top two values on stack with their product
.: pop value from stack and print as numerical value
_: pop value from stack; change direction to L→R if zero, R→L otherwise
@: halt

Scala 2.11.x, <=128 (Safe!)
Using the REPL:
***********+++------+++*********+++------------+++*********+++-------------+++*****************+++----------+++**************+++-------------+++***********+++-------------+++****************+++-----------------+++***************+++-----------------+++***********
My code:
val x=Math.PI.toString.map(_.toInt-40)
val y=for(y <- x.indices)yield (if(y%2==0)"*" else "-")*x(y)
y.mkString("+++")

This is only 117 bytes so I had some room to replace PI with somthing more interesting (like "asjdfaterwerhndsfyser") but I was kinda stuck on PI ;)

C <= 64 (cracked by kennytm)
111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011111011111011101111101111101110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011111011101111101110111110111110111011111011101111101111101110111110111110111011111011101111101111101110111110111011

(output is 1974 chars long)

Is this the binary solo from Flight of the Conchords' "The Humans Are Dead?"

I would be very surprised if it were

Cracked.

Perl, <=32 (safe)
This one might be a bit tricky:
3241713134202822035372146147538395543335603758546591813832316426477542

(70 bytes of output)

Original source code:
for(b..z){$x=3+$x*7%887;print$x}

This generates the following sequence of numbers:
3 24 171 313 420 282 203 537 214 614 753 839 554 333 560 375 854 659 181 383 23 164 264 77 542

PHP 5.3+ (safe)
range <= 128 bytes
482424112994923113297121090242411210353292651229460112228399109149751282614311166121153929147198351001411661211559915116999341919231910671297471013731035012512152995121145118302468310841232211292074121155012771143923278512115501816119651154811292412150661212263019861153871918242691210635477119627297174572129747102223127312255412195242990704515918206269100332226149786699441136214126754710137310350125121529951211451183024683108412322112920741212263019861153871918242691210944191722683984510232122312004200000000000000000000000000000011224241129752128729183000000000000000000000000000000427344126627112312961782933097521287291121806311106811548172725429797110845159182062691014391471169293309747101373103501251215299512122630198611538719182426912115392115726311323861094413211027131990121094419172268398451023212239412100414296118911539278825

843 digits.
The code with some whitespace added:
ob_start();
phpcredits();
$d='';
$c=0;
foreach (str_split(ob_get_clean()) as $x) {
  $d .= ord($x^$c);
  $c=$x;
}
echo substr($d,0,843);

Safe means that it has been open for 7 days and hasn't been cracked.

Limit is 2048 bytes.

OK then let's keep only the first 843 digits. This will not disadvantage those who are already on my trail, the changes to be only 843 digits instead of 14401 does not change the trick. I also verified the code produces this output from PHP 5.3 onwards. Originally I verified only on PHP 5.6. @DanielM. I hope it will stay uncracked, obvs :)

AppleScript, ≤ 32 bytes Cracked
Output

(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)
(**)

Total: 2044 bytes
Hint

 There are FOUR STDOUT equivalents in AppleScript.

Cracked

Python <=64 Cracked by @Sp3000
[1.0, 1.005037815259212, 1.0206207261596576, 1.0482848367219182, 1.0910894511799618, 1.1547005383792517, 1.25, 1.4002800840280099, 1.666666666666667, 2.294157338705618]

Just for clarity I'm running this in Python 3.4.1 64bit on Windows.  I expect there will be slight floating point differences in the calculations on different platforms, so if you can get it to within 6 or 7 significant digits of each value you can call it cracked.  Once cracked, I'll post the code and an explanation.
Hint: I take my inspiration from the universe itself :)
Code
print([1/(1-(i/10)**2)**(1/2) for i in range(10)])

Explaination
This comes from Einstein's theory of Special Relativity, specifically the Lorentz transformation for Time Dilation.
An object traveling near the speed of light will be observed to experience less proper time than an observer at rest.  The limit as V->C, time dilation becomes infinite and time will slow to a stop for the traveling object as observed by an observer at rest.
Fun stuff to wrap your brain around :)

Cracked?

Indeed @Sp3000, good work!  You certainly got it correct.   Your code is very nearly identical to what I put together.

QBasic, <= 64 (safe)
11""111111"""11111""""1111"11""1111111""1111111""1111111""1111111""1111111""11111

Tested on QB64. There is no newline at the end of the output.
Disclaimer/hint: It's possible that the output will look slightly different in DOS QBasic, though the concept will still work. Don't even think about using Repl.it for this one.

Answer:
SCREEN 9
FOR j=1TO 8
FOR i=1TO 9
?CHR$(49-POINT(i,j));
NEXT
NEXT

It helps to break the output into 8 rows of 9 characters each:
11""11111
1"""11111
""""1111"
11""11111
11""11111
11""11111
11""11111
11""11111
11""11111

The code loops over an 8x9 rectangle of pixels near the upper-left corner of the screen, printing 1 for a black pixel (color code 0) and " for a white pixel (color code 15). At first the screen is all black, so the first character printed is 1. But afterwards, that very 1 (plus the tip of the second one) provides the data for the remaining iterations:

The ASCII math was chosen to put double quotes in the output, which should make it impossible to generate this string any other way.

Pip, <= 2 (cracked by Reto Koradi)
{Name(a,None,None)}{Name(a,None,None)}

This works in the current version of Pip as of this posting (0.15.10.04), and a couple versions prior. Future updates may change this output. I felt a bit bad about posting something so implementation-dependent, but including a <=2 that isn't blindingly obvious was too fun to pass up.

The code is O_.

_ is the identity function. It's syntactic sugar for the longer form {a}, which is equivalent to lambda a: a in Python.
In the current version of Pip, I haven't finalized the format of Blocks when converting to Scalars (i.e. strings). Eventually, it's going to look like {a}, but at the moment it wraps the parse tree in curly braces, resulting in the above {Name(a,None,None)} business.
O is a unary operator that outputs its operand (after casting to Scalar) sans newline.
Since O is an operator, the whole O_ is an expression that evaluates to the same identity function. If a Pip program ends with an expression, that expression is auto-printed. Thus, {Name(a,None,None)} gets output a second time.

Cracked

Thue, <= 64 (cracked by Thomas Kwa)
yellowyellowyellowredyellowredyellowyellowyellowredyellowredyellowyellowyellowredyellowredyellowyellowyellowredyellowredyellowyellowyellowredyellowredyellowyellowyellowredyellowred

Working on ppperry's Thue puzzle made me think about what the next level up in difficulty could be. Here, the problem (if I've successfully avoided loopholes, anyway) is to make a nondeterministic language produce nontrivial deterministic output.

Cracked? Am I missing something?

Whoops. Apparently I did.

Groovy, <= 64 [Safe!]
This is from the REPL
'11111111001000111001000011100111100100011100100000111001111001000111001111100100011100100001110011110010001110010000001110011110010001110011111001000111001000011100111100100011100111111001000111001000011100111100100011100100000111001111001000111001111100100011100100001110011110010001110010000000111001111001000111001111100100011100100001110011110010001110011111100100011100100001110011110010001110010000011100111100100011100111110010001110010000111001111001000111001111111001000111001000011100111100100011100100000111001111001000111001111100100011100100001110011110010001110010000001110011110010001110011111001000111001000011100111100100011100111111001000111001000011100111100100011100100000111001111001000111001111100100011100100001110011110010001110010000000011100111100100011100111110010001110010000111001111001000111001111110010001110010000111001111001000111001000001110011110010001110011111001000111001000011100111100100011100111111100100011100100001110011110010001110010000011100111100100011100111110010001110010000111001111001000111001000000111001111001000111001111100100011100100001110011110010001110011111100100011100100001110011110010001110010000011100111100100011100111110010001110010000111001111001000111001111111100100011100100001110011110010001110010000011100111100100011100111110010001110010000111001111001000111001000000111001111001000111001111100100011100100001110011110010001110011111100100011100100001110011110010001110010000011100111100100011100111110010001110010000111001111001000111001000000011100111100100011100111110010001110010000111001111001000111001111110010001110010000111001111001000111001000001110011110010001110011111001000111001000011100111100100011100111111100100011100100001110011110010001110010000011100111100100011100111110010001110010000111001111001000111001000000111001111001000111001111100100011100100001110011110010001110011111100100011100100001110011110010001110010000011100111100100011100111110010001110010000111001111001000111001'
Yes, those 's belong, and no, that's not a leading space
Have fun!
Original code:
t=[]
f={n->t+=n
n<2?n:f(n-2)+f(n-1)}
f(15)
t*.mod(2).join("")

I used fibonacci to create a very large number and mod each digit by 2.

Pyth (cracked by isaacg)
939524095

Range ≤ 4
Let's see how this goes...

For whatever it's worth, this is 2^27 * 7 - 1

Yes, I figured out what the value is earlier today, and have about 3 possibly interesting representations. But I don't have the faintest clue how to squeeze any of them into 4 bytes of Pyth. Not knowing Pyth is kind of a handicap. ;) Scanning through some docs did not help, anything that comes to mind looks like it would use more than 4 bytes.

Cracked

Dyalog APL (cracked)
4.58302

Range ≤ 4
This should be cracked pretty quickly...

Ack - 5 bytes is easy, but 4...

Cracked.

MATLAB, 2, Cracked
The syntax of the command is incorrect.

Took me a while to work out something in MATLAB that is only 2 chars but should be quite tricky to work out :) (he hopes).
p.s. that is the exact output. No ans=

Well that one went faster than I thought it would...

Cracked?

Lua, ≤ 64 (safe)
Output:
value   attempt
call    attempt
value   call
to      call
call    a
string  call
call    string
to      call
call    a
value   to
string  attempt
a       attempt
string  a

You need to write a Lua program or REPL command of length 64 or less.
My code size = 58 bytes.

Code:

 _,s=pcall''table.sort({s:match(('.-(%S+)'):rep(6))},print)

Ungolfed code:

 t = {'attempt', 'to', 'call', 'a', 'string', 'value'}
table.sort (t, print)
 Lua table sorting exhibits non-trivial behavior, even when any permutation of elements is accepted as possible by comparison function.

Lua 5.3, Cracked, ≤128 bytes
This is a REPL command. Output (1,954 bytes):
haha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555hahaha666666666haha333333333222222222haha777777777haha222222222haha333333333222222222haha777777777haha222222222haha666666666haha777777777haha444444444haha555555555

Original code:
(table.concat{({pcall(string.find,'',('('):rep(50))})[2]:byte(1,-1)}:gsub('.',('%0'):rep(9)):gsub('[019]+','haha')):rep(13,'ha')

Cracked.

@Dennis OK, that's much simpler than I thought. My actual code was much more complex, as you can see above. Apparently I'm not very good at this. :P

CoffeeScript, ≤ 64 bytes (Cracked by kennytm)
Output (1437 bytes):
0bnQ=bXM=bGY=bmU=bGw=b24=YXk=b24=b24=ZGU=bnQ=bWU=dGU=b24=dHk=bmQ=bnQ=ZGU=aXA=b3I=Z2U=aW4=b24=blg=blk=YXQ=dFg=dFk=emU=ZnQ=ZXI=b20=b3I=dXM=dXM=bGU=dGg=c2U=b3I=Z2U=ZXQ=YXQ=Y2U=Y2U=dGg=ZnQ=b3I=bGU=dGg=dXM=aHQ=b3I=bGU=dGg=bmc=bGU=b3A=b3I=dXM=dXM=bGU=dGg=dGg=b20=b3c=bmc=bmc=ZGU=YXI=aXA=dGg=bGU=b3I=b24=cnM=bmc=bnQ=bnQ=ZXQ=b3I=Y3g=Y3k=b24=YXk=bmU=bHM=bmQ=bGw=dHk=bGU=ZXI=ZXg=aXM=b24=b3c=b3c=bms=YXA=YXQ=b3I=dHk=bnQ=bHk=bmc=emU=Y2g=bGU=bnQ=ZXM=aHQ=YWw=YWw=aHQ=bmc=b24=bnQ=ZnQ=bmc=b3I=aHQ=bGU=Z2U=b24=cGU=aW4=b20=ZnQ=aHQ=b3A=ZXI=bmQ=aWQ=cnQ=c2s=cGU=aHQ=dGg=b20=aHQ=dGg=b20=ZGU=aXQ=b24=dHk=ZXI=b24=bnM=bmU=b3I=ZXQ=bGU=dGg=b3c=YXA=d1g=d1k=bmc=b20=ZnQ=aHQ=b3A=Z2U=ZXI=cmU=ZGU=ZXI=dmU=aW4=dHM=b24=ZXM=cg==emU=aHQ=cng=cnk=bGQ=aW4=ZGU=bmc=emU=YWs=cmM=b3I=dHk=a2U=YXk=ZXQ=YXA=aW4=aXQ=dHk=dGg=emU=dXQ=Z24=b3I=b24=bnQ=b3c=bmc=b3c=cm0=b3A=b24=cm0=aW4=bGU=b24=YXk=b24=dHk=b24=ZGk=Z2U=b20=Y3Q=Z24=dHk=b24=Y2U=aXA=dGU=aW4=ZXI=b3I=bGU=dGg=cmU=b3I=bGU=dGg=bmQ=b3I=bGU=dGg=bmc=Z2U=cnQ=b3I=bGU=dGg=bmc=Z24=YWs=b24=ZXg=dXA=ZXM=dXA=bnQ=Y2s=Y3Q=dGg=ZXI=cmU=ZGU=bnQ=YXA=bGU=b3I=bGU=dGg=YW4=dGg=bnM=ZXI=Z3M=dGE=bmc=aHQ=ZXI=aW4=YWs=bXA=bGU=aHQ=dGg=ZXI=c2U=cmU=c2U=c2U=c2U=bmQ=cnQ=c2U=c2s=Z2U=ZXQ=YXQ=Y2U=Y2U=dGg=aXA=dGU=Z2U=aW4=b24=blg=blk=YXQ=dFg=dFk=emU=aHQ=dGg=aHQ=dGg=ZXI=cmU=bmQ=cnQ=blg=blk=c3Q=bmc=b24=b3I=bmU=Y3Q=aXM=b3I=b24=bGU=b3I=b24=dHk=a2U=b3I=dGg=blg=blk=blo=YWc=Znk=Y3Q=ZGU=Y2U=d3M=dGg=Z2U=YWs=bmc=YXA=ZGU=eA==eQ==ZXg=b20=eHQ=dGg=bGU=ZW0=dWU=dHk=dHk=dHk=

This output will get alerted when ran at the Try CoffeeScript page at CoffeeScript.org in Chrome 45.0.2454.101 m.
Edit: The output changed slightly in the newest version of Chrome. Here is the output for Chrome 46.0.2490.71 m (1453 bytes):
0bnQ=bXM=bGY=bmU=bGw=b24=YXk=b24=b24=ZGU=bnQ=bWU=dGU=b24=dHk=bmQ=bnQ=ZGU=aXA=b3I=Z2U=aW4=b24=blg=blk=YXQ=dFg=dFk=emU=ZnQ=ZXI=b20=b3I=dXM=dXM=bGU=dGg=c2U=b3I=Z2U=ZXQ=YXQ=Y2U=Y2U=dGg=ZnQ=b3I=bGU=dGg=dXM=aHQ=b3I=bGU=dGg=bmc=bGU=b3A=b3I=dXM=dXM=bGU=dGg=dGg=b20=b3c=bmc=bmc=ZGU=YXI=aXA=dGg=bGU=b3I=b24=cnM=bmc=bnQ=bnQ=ZXQ=b3I=Y3g=Y3k=b24=YXk=bmU=bHM=bGw=dHk=bGU=ZXI=ZXg=aXM=b24=b3c=b3c=bms=YXA=YXQ=b3I=dHk=bnQ=bHk=bmc=emU=Y2g=bGU=bnQ=ZXM=aHQ=YWw=YWw=aHQ=bmc=b24=bnQ=ZnQ=bmc=b3I=aHQ=bGU=Z2U=b24=cGU=aW4=b20=ZnQ=aHQ=b3A=ZXI=bmQ=aWQ=cnQ=c2s=cGU=aHQ=dGg=b20=aHQ=dGg=b20=ZGU=b24=ZXQ=dGg=b24=aXQ=b24=dHk=ZXI=b24=bnM=bmU=b3I=ZXQ=bGU=dGg=b3c=YXA=d1g=d1k=bmc=b20=ZnQ=aHQ=b3A=Z2U=ZXI=cmU=ZGU=ZXI=dmU=aW4=dHM=b24=ZXM=cg==emU=aHQ=cng=cnk=bGQ=aW4=ZGU=bmc=emU=YWs=cmM=b3I=dHk=a2U=YXk=ZXQ=YXA=aW4=aXQ=dHk=dGg=emU=dXQ=Z24=b3I=b24=bnQ=b3c=bmc=b3c=cm0=b3A=b24=cm0=aW4=bGU=b24=YXk=b24=dHk=b24=ZGk=Z2U=b20=Y3Q=Z24=dHk=b24=Y2U=aXA=dGU=aW4=ZXI=b3I=bGU=dGg=cmU=b3I=bGU=dGg=bmQ=b3I=bGU=dGg=bmc=Z2U=cnQ=b3I=bGU=dGg=bmc=Z24=YWs=b24=ZXg=dXA=ZXM=dXA=bnQ=Y2s=Y3Q=dGg=ZXI=cmU=ZGU=bnQ=YXA=bGU=b3I=bGU=dGg=YW4=dGg=bnM=ZXI=Z3M=dGE=bmc=aHQ=ZXI=aW4=YWs=bXA=bGU=aHQ=dGg=ZXI=c2U=cmU=c2U=c2U=c2U=bmQ=cnQ=c2U=c2s=Z2U=ZXQ=YXQ=Y2U=Y2U=dGg=aXA=dGU=Z2U=aW4=b24=blg=blk=YXQ=dFg=dFk=emU=aHQ=dGg=aHQ=dGg=ZXI=cmU=bmQ=cnQ=blg=blk=c3Q=bmc=b24=b3I=bmU=Y3Q=aXM=b3I=b24=bGU=b3I=b24=dHk=a2U=b3I=dGg=blg=blk=blo=YWc=Znk=Y3Q=ZGU=Y2U=d3M=dGg=Z2U=YWs=bmc=YXA=ZGU=eA==eQ==ZXg=b20=eHQ=dGg=bGU=YXQ=ZW0=dWU=dHk=dHk=dHk=

Original source code:
for x of new Image(a=0).style
 a+=btoa(x.substr(-2))
alert a

Cracked

R, <= 32 (safe)
It outputs the following string (34 characters. I hope there isn't a more trivial way to print this!)
pi - 4*(4*atan(1/5) - atan(1/239))
Edit: Hints: (1) This is very crackable. (2) No mathematical calculations are involved. (3) The program that outputs this is 24 characters long.
To crack, search Google for pi - 4*(4*atan(1/5) - atan(1/239)) R language. (String chosen so that searching for it doesn't give obvious references to R!) Note that this line appears in example(pi). Note that the text of the example will be outputted if you include the give.lines=T option in example(). Arrive at the solution:
cat(example(pi,g=T)[10])

Gah. I tried looking for R sample text but found nothing.

><>, ≤16 Bytes, Cracked by Sp3000
!$'*-0369<?BEHKNQTWZ]`cfilorux{~

Output length of 32 bytes
...made sure it's ASCII this time :-/

Cracked

J (safe)
0 0 0 0 1 9 495 1287 3003 6435 12870 24310 43758 0 0 0 0 45 165

Range ≤ 8
Solution
8!/:#:!9

Try it online.
How it works

!9 calculates the factorial of 9, i.e., 362880.
#: converts the result to binary, yielding 1 0 1 1 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0.
/: "grades up", i.e., sorts the indices of the above list by the values at those indices.
This yields 1 4 5 6 8 9 12 13 14 15 16 17 18 0 2 3 7 10 11.
8! calculates nC8 for each n from above, returning the specified output.

J (safe)
0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0
1 0 0 0 0 0 1 1 1 1 0 0 0 0 1 1 0 0 0 1 1 0 0 0 0 1 1 1 1 1
1 0 0 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 1 0 1 0 0 0 1 0 0 0 1 1
1 0 1 0 1 1 0 1 1 0 0 0 1 1 0 0 0 1 0 0 0 0 1 1 0 0 1 1 0 1
1 0 1 1 0 1 1 0 1 1 1 1 0 1 1 1 1 0 0 0 0 0 0 1 0 0 0 1 0 0

Range ≤ 16
Solution
|:9|.#:\:#:p:!11

Try it online.
How it works

!11 calculates the factorial of 11, yielding 39,916,800.
p: calculates the 39,916,800th odd prime, yielding 774,825,437.
#: gives the primes' binary digits, i.e., 1 0 1 1 1 0 0 0 1 0 1 1 1 0 1 1 1 0 0 1 0 1 1 1 0 1 1 1 0 1.
\: "grades down", i.e., sorts the indices of the above list by the values at those indices in descending order. This gives
0 2 3 4 8 10 11 12 14 15 16 19 21 22 23 25 26 27 29 1 5 6 7 9 13 17 18 20 24 28

#: gives each index's binary digits, i.e.,
0 0 0 0 0
0 0 0 1 0
0 0 0 1 1
0 0 1 0 0
0 1 0 0 0
0 1 0 1 0
0 1 0 1 1
0 1 1 0 0
0 1 1 1 0
0 1 1 1 1
1 0 0 0 0
1 0 0 1 1
1 0 1 0 1
1 0 1 1 0
1 0 1 1 1
1 1 0 0 1
1 1 0 1 0
1 1 0 1 1
1 1 1 0 1
0 0 0 0 1
0 0 1 0 1
0 0 1 1 0
0 0 1 1 1
0 1 0 0 1
0 1 1 0 1
1 0 0 0 1
1 0 0 1 0
1 0 1 0 0
1 1 0 0 0
1 1 1 0 0

9|. rotates the rows nine units up, yielding
0 1 1 1 1
1 0 0 0 0
1 0 0 1 1
1 0 1 0 1
1 0 1 1 0
1 0 1 1 1
1 1 0 0 1
1 1 0 1 0
1 1 0 1 1
1 1 1 0 1
0 0 0 0 1
0 0 1 0 1
0 0 1 1 0
0 0 1 1 1
0 1 0 0 1
0 1 1 0 1
1 0 0 0 1
1 0 0 1 0
1 0 1 0 0
1 1 0 0 0
1 1 1 0 0
0 0 0 0 0
0 0 0 1 0
0 0 0 1 1
0 0 1 0 0
0 1 0 0 0
0 1 0 1 0
0 1 0 1 1
0 1 1 0 0
0 1 1 1 0

|: transposes rows and columns, yielding the final output.

ES6, safe, <= 128
Console output from Chrome 46 including "'s in case those matter
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

Source
128 characters including the var decl, you can actually leave this off and everything works fine.
 var m=25,a=11,c=17,z=3,r=(v)=>z=(a*z+c+v)%m,f=(_,i)=>String.fromCharCode(34+(i*r(i>>1)%43));Array(...Array(2046)).map(f).join``

Golfed Version of Source
103 characters
  z=3,r=(v)=>z=(11*z+17+v)%25;[...Array(2046)].map((_,i)=>String.fromCharCode(34+(i*r(i>>1)%43))).join``

How it works
First setup a basic linear congruential generator simplified from https://bocoup.com/weblog/random-numbers
var rand = function rand(offset){
  // Establish the parameters of the generator
  var m = 25,
      // a - 1 should be divisible by m's prime factors
      a = 11,
      // c and m should be co-prime
      c = 17;
  // Setting the seed
  var z = 3;
  var rand = function(offset) {
    // define the recurrence relationship
    z = (a * z + c + offset) % m;
    // return an integer
    // Could return a float in (0, 1) by dividing by m
    return z;
  };
};

Next create symbol table lookup function (less overhead than the symbol table)
var lookup = function(index){
  // From the 34th character use the next 43 characters
  // i* keeps us moving forward through the table with less predictability
  // i>>i reduces i to also make for lower predictability
  var charCode = 34+(i*rand(i>>1)%43);
  return String.fromCharCode(charCode);
};

Using the ...rest (or splat) operator create an array of 2046 (to stay under 2048 limit), execute the lookup function against every element, and then join the array back into a string.  Default behavior of browsers is to output the last computed value to the console.
Array(...Array(2046)).map(lookup).join('')

Haskell, <= 32
"[(\"[\",\"(\\\"[\\\",\\\"(\\\\\\\"[\\\\\\\",\\\\\\\"\\\\\\\\\\\\\\\\\\\\\\\")]\\\")]\")]"

This one is cute and easy.

Groovy, <= 128 (Safe!)
Have fun with this one!
Groovy Rocks!scrocoRoo kosv cRooooGrRsokyry o!yRvyr GsoooRoy o GR rRrysrv o ov ocv!c!!v!oroookoo o yGr okcG!RRoyo!o oor !k!oR  rkRo!coooooooovv kkkrk RoyroroRRR!o!GGo vyovyo GoocvcGRGkokroRGcs!oGokR!orrsGvGsy!vv!rRoooR y  kokvvvRo rr!kk GRRRoroyokvokosoRoG!cvRv ssooooRrGkGs rv!ooRcsoosRyyGvkykysokGvrRskskvkoRooookoysyycyGykocooc!vocGoksssRRyrv yksosGRGookkoRcRGGyccGvoskGoko oso krrsGyRGvovGrcrooG!ykksssvocrGGGovsokcGroyRoGyysrsG! rr!oGokR!c rvccRsoR! !ookccvoRoskv okGor! RyossosGRRyr!yvorcoRRyorGos!G  oov  Gr ccvosGkGyoycooc voRoysrrvrRyyrovkyoRRysyrk rso!cyoscrvoccyrkvy!o GRoGRook sorcvovkokrook ooGsos ryoooc oroG!sooko!oooR osocGoocorrkvGosycovysRcRG yvcosyocGrGcrGr!sooG!ovRrcRksGsyGco sooy!GGGyyr!okkoGRcvk cc cGrGG GcosoyGsvGksoR krocvs!orGRRs! sorvvRosyvvoks co !oocRoysrroorooooykGvovk!rGroscyyooGscooyyr ooooGsGosoo  oosorrovooGooR!ssGvs!oo yvcoo  cyc!oyR! koG ovGoko!ck oovvc o!s!ocGsovvGycsysoooRyRkkRrok!coovrkooysGRocGGorRooocGos!Roo!skRsRvsokosk y RGksvycGvvv!ovo  oo GGcv rvRGyR !Rsvo o !scr!vRvoRy!!yo Royycovor!ocooo!yGcookryoorrso!oro oosRcrovcGk!ccoocGkosG ovyovo vcGookok o s!vR!Roycoo RkocoGGksrryv osrkoossvG Rkokso!RR!rk !sRcooc!vRvRkccvskGoooooro!GsR!osscoRcGGcoR soyoRR!rv!oGR!scv!y!rrcoGoRooGoGRork ookvrGRcoRvoro!oro!RvG sycsoyosRyG yoyooco oRrovGyc RGoycGorG c!royo orsrGysr! ookcssG okrGRvroy roRRvGoo!so oGoo!kRo! kvGGoovGsRoco !s  oRvkoG GsGRrkk!o!c ooc skyoocvvckRcrookcGy!c rGcoosGcy!ok!ysRov GcooGcGooookoooc ycoGv RGGso RG kRycGyoGoyG Gkyov!vGorovr!RosyGkrcyrc!r  orc ovy!!cGRvr!Go krksRcRovo!korvkcsRy yyoGoc vGo!crcorrosvvoGoooGyyRrkckoGsRG voyoGoRo r RGcRsv!vkrrkGGk RyvovrGcGor!oRRk yyoG! oR!!r! Rr!cG RR   ssrororcvcksvoGy ocvcoGo!s y r!oo o oo ooyGkoookr!vskko !GoRGrysGv r okkskRo  GRvooossGoGs!voorr!y!scovGovkcc!kRvGco!ros!!okooooroo v!yvo rGvkGscRvoyovvGs!G!r osGGGrcyyork ooryGooovoyrGco rGGk R osc!GvovGryccc !r! cRG!r!RrorGkGko vyyGkks!GoRoooGrrorc!G!oko RoGookovyrkRR
This was run as a groovy script.
Original code:
 s='Groovy Rocks!'
 println(s+((89**98**20-5).toString().split("(?<=\\G.{2})").collect{s[(it as int)%13]}.join('')))

J (cracked)
4.81845e12

Range ≤ 4
Worth a shot.

Cracked.

TI-BASIC (cracked by NinjaBearMonkey)
Am currently away from my computer, will post code later.
Range: <= 7
String: 115572735
Code: πE8/e
Ran on a default calculator - the program may have different output on calculators with a certain setting changed. I hope that is OK.

Cracked.

Damn. That was fast. Nice job!

Oh, because of pi? Hm.

The rules have been modified, this is OK

Pyth
10067283832263627132507444590041695034979992997150622392563276991517087210416125987872298759981924914598996739787601264046046893914007275634929310315058

Range ≤ 4
I think there's a somewhat reasonable way to guess the solution, not just by trying lots of expressions.

Cracked

C++
String:
65033056-9151491210111217-182023222117182724-272924313024373435-363433363947444142-454342454854554853-544851585761626360-635768676668657071-727877727575727778-818786818482838489-909295949389909996-991019610310296109106107-108106105108111119116113114-117115114117120126127120125-12612012312012612712012511412012311411311711811911612111310810710610810511011196102101969999961011028795948992909192819484878685818275726977727978726966677666656871636057585159586148545548535848514241454647443341363534363338394030292427272429303123221720181920961215141391030135076

Range: <= 64

GolfScript
100100110010011100110001011101100001010011010111011101011000100000000100

Range: ≤ 8

gs2
4p2G<4p2<G4pG2<4pG<24p<2G4p<G242pG<42p<G42Gp<42G<p42<pG42<Gp4Gp2<4Gp<24G2p<4G2<p4G<p24G<2p4<p2G4<pG24<2pG4<2Gp4<Gp24<G2pp42G<p42<Gp4G2<p4G<2p4<2Gp4<G2p24G<p24<Gp2G4<p2G<4p2<4Gp2<G4pG42<pG4<2pG24<pG2<4pG<42pG<24p<42Gp<4G2p<24Gp<2G4p<G42p<G2424pG<24p<G24Gp<24G<p24<pG24<Gp2p4G<2p4<G2pG4<2pG<42p<4G2p<G42G4p<2G4<p2Gp4<2Gp<42G<4p2G<p42<4pG2<4Gp2<p4G2<pG42<G4p2<Gp4G4p2<G4p<2G42p<G42<pG4<p2G4<2pGp42<Gp4<2Gp24<Gp2<4Gp<42Gp<24G24p<G24<pG2p4<G2p<4G2<4pG2<p4G<4p2G<42pG<p42G<p24G<24pG<2p4<4p2G<4pG2<42pG<42Gp<4Gp2<4G2p<p42G<p4G2<p24G<p2G4<pG42<pG24<24pG<24Gp<2p4G<2pG4<2G4p<2Gp4<G4p2<G42p<Gp42<Gp24<G24p<G2p4

Range ≤ 8. This one should be a little more fun...

Does the solution contain non-ASCII characters?

4p2G<\x05\x93, boring.

Mitch: dammit! No idea how I missed that. (It's originally fizzbuzz mod something plus something.)

Rust, cracked!
Here's the output
AACAAEGAAACIIMOAAACAAEGQQQSYYDFAAACAAEGAAACIIMOHHHJHHLNXXXAGGKMAAACAAEGAAACIIMOAAACAAEGQQQSYYDFOOO

That's 98 characters long.
The source code is <=128 bytes
Here is the source

  fn main(){let mut i: u8 = 1;while i<99{print!("{}",(65+(i&(2*i))%25) as char);i+=1;}}

Since it was late at night I made the mistake of not making the output longer than the source code byte limit (which would have been really easy)... whoops! This might have been fun to crack otherwise. Oh well, Kudos to Doorknob.

A simple print statement would be so obvious..

uh, cracked?

@Doorknob Well I guess a bit more creative than that. You can see patterns in the text. (Too bad I don't code in rust)

I was like "Wow I'm so clever, no one will figure this out."

Python 2.5 - 2.7.9
Range: <=64
>r otnfn-lu<.liamcdaka btnymsgachu ssee
rtfn gaco lkls ldmsh bddvr P h girW
wlbdbrsd)kecnicu h s n D aon itom tebso it eeo
tic  adla bo entis ldmsh ne mtetrF
otten uuim onictD- nabt
yrmo wn h .otten uuim eisdynNbTeT)itib ss ldm>inicu itib

NOTE: This entry has been modified because it came to my attention that the output would change depending on certain factors about your computer. The above output should be possible with the same code as I have across all python 2 installations, the old output below only works on certain linux installations. I will accept a crack to be a program that can produce either output.
>cps/.nhy/i/s/ of'o ldm
ebtpo rwcbe o a enh cs;ealreuu ienh tyei ieuo ity eiopIAeT:nna
.oe eice (ch
otnfeteudaEIn tit rpio lisps irvwH.prsas elce tdden ieuo itgibei h o
niandisogbaf otee -ynna
.ce nsokeS niandisogbasspe na a h>n-lu('y'euo<d otnfn-lu<

Oh boy. If this does what I think it does it's going to take longer than The Programming Language Quiz to solve :P (just in case, can I ask which exact Python version you tested on?)

2.7.6 and what do you think it does? Ok, the program does different stuff depending on certain things that I don't think are fair, shall I change it to remove that or not?

Ok, I have a new version that's almost identical except it shouldn't matter what os you're on or other things that I don't want to say if I am allowed to replace it - if I did, it would be quite a big hint

In the interest of cracking it... @Sp3000, are you thinking that it's at least one __doc__ string (maybe multiple or multiplied) sliced? That's what I think. The > at the front encourages that theory.

Macaroni 0.0.2—cracked by kennytm
Range: ≤64.
...................................................................................................

The intended solution:
set x 99 label l print "." set x add x -1 map slice " " 0 x 1 l

That's 99 .s, right?

cracked

@kennytm Argh, I should have considered that. The intended solution was... slightly more complicated. ;)

Python 2, safe
Output (400 bytes)
2243741369805258403802281453161847831993100895210761465122158243748106741965559879210950925986787187884683594462521622978061423199763328847096978817424056039876331594730426879701090232645796839130259328243206775429644682566205913609484054454294080314366063978878893188641070706588914162057003952773480796098824291229522724034240214526221641336067994669537082582022249580216662833919604859431735474099

Range ≤32
Original code (32 bytes)
b=1337;a=2**b/b-b-13**37;print a

I like the note to self :)

@JAtkin I tend to forget that kind of thing. I'd be surprised if it lasts the whole week, but if it does, at least I'll know where my intended code is.

@Eridan Just create an account on Ideone.

@mbomb007 I have an account on Datajoy; I just tend to forget that I put code snippets there. Is there any advantage to using Ideone over Datajoy?

@Eridan Well, by looking at it, DataJoy has history, access to Github and Dropbox, but only Python and R. Ideone has a ton of languages (even different versions), and your programs can be either private, or shared by URL. I don't like that there is a run-time limit of 15 seconds for members. You can't have more than one file and have a project, maybe? Also, the box you put program input in doesn't allow pasting of raw bytes, so it can't contain "0x00", for example.

@mbomb007 Thanks for the info. I'll check ideone out.

@Eridan Also, I just found out today that Ideone allows you to import from NumPy.

Rust, Safe, ≤64
Output (440 bytes):
2EE5A53831925A9212038FBE5174381029212D926E994C46C69956F383F314D9912D4622FA13BF316AF3AFFA91A710FFAA454D5541C5B0800805B16B549B51195BFF081815B119B514EB599BC8169105BCA016D716241DDCA0941D3077697713F1D12ACA2C7E151775D80DD7ECB2B1557EF5D8132D885DF758C101DFA439E339384029EDB8405C9A9D9A17B4016EED78A11EFB61FB141A11374E4302171FB305C11202109AF17631485C8BD0EC63E61017C63128BD171BDD0C4CC71164C41131E15E1EBF25BCD2157251077F1547FB786B73315386105E0154E0B9E7

Solution:

 fn main(){for i in 100..200{print!("{:^04X}",i*i*20051%99999)}}

Python 3
Range: ≤64
String length: 1759
1450311547121626824402528317931024696537261379649312109934174763622928813537772202492826340253595039354204170803308812108106614974615992407513462378342519772879316185201191244193032905219821112379362735436273595816306408247797551887198223078132707718613741551438816716228420855210133806030879152023807281213669870947286924104806420930386226909518122591340634826667470106070805067486916003620079860533420912887938893520117652588913717930472346176939267545884056248725814428845435505286970004504538242272311816219001799408190917981242794876906923463019563132633790465573335245790782921280224126868686724604452690148708017495170944952232407517716174996669514909784703378613104880109045294268293224189609735626833741340860353297694678641117508508320027700778717534109394267437425043810487352376005634156569975311491459838272217846207077798205457351267508638726235986344105746925264997271470391586921860841952986010216300093433468007980482444450140150202011970723666974568959542215223332447146301544007477846089467045557063881769289045618456873502484742102787141509146927089727415468957468932233888307541183405820990577010792332515397454508971114910082242913202656447784249727817413159197879472620373533325157697422584249026116957034499508087753326237517531666435897781090922126023766286557629116809405490739569657792496159821300551508419666991511554805528263403378295007848547483596991780931036386960716493272927989817021495881172814505517266227891225298564264160100926161641968167450456638252346252357682659194962887041698807928559518187059146398406957924003562078098158050469520030372646913304777752187530842640087708732247607019311163659185637734636533976160365822448025321873341358014966837103376648875774633227200456239875015114894085499417129719017106310570

Mathematica 10.1, range ≤64, cracked
String length 2022.
1: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

Hint:

 The output of this program was only fixed a few centuries ago.

Program:
Print@Nest[Compress,ExampleData@{"Text","ToBeOrNotToBe"},13]

Cracked.

@alephalpha Close, but not it.

But the output is the same. Or should I add a Print@?

@alephalpha Yup. Also, what gave it away?

The 1: is a dead giveaway that you used Compress.  From there we can just apply Uncompress and we get another compressed string; rinse and repeat, and eventually "To be, or not to be, ..." emerges.

PHP, safe, <=64
Output (96 Bytes):
=WAVTBB_ZZSWsMQREFX[VPUD]LXR_SBJVPVVTpFAT@sE@THPP]]X\UBI|cBR[STBAVURLsWCTH^U^VMrpssrwpytqqpptxxy

The output depends on the source filename. I added the full path to the source file to the byte count. Note that it does not have to end in  .php.
PHP notices should be suppressed.
Solution
<?=D.bcpow(9,99,9)^(y.new Exception([].[])|str_repeat(~¿,96));

saved in the file /g (as ISO-8859-1, ¿ is 0xBF )
What it does

create a long number (999) with bcpow(9,99,9)
create an exception with the message "ArrayArray" (two empty arrays concatenated with [].[])
coerce both to strings with the concatenations D. and y. (D and y are undefined constants, treated as "D" and "y")
bitwise OR each character of the exception with 01000000 to restrict it to printable characters and fill up to 96 characters.
bitwise XOR the two strings

Pyth
Range: ≤ 8
String:
49177772591428004056910940816433485702518448313728069154605014641218367314521229637591075731850711078018713

Octave, <=4 bytes cracked by kennytm
ans =  4.8105

Cracked:
i^-i

cracked

It seems like you intend to win this challenge?=)

Why does it round to only 4 decimal places?

That is just the standard formatting, you can change that by using format long or something similar.

Python 3 (<= 32 bytes)
REPL.
177172218082085052481067589112390245408383458973982190836613425027273840834324281100485149132551246778981339968190311073240776569178878685724789960654670348361662827252973483749744632038916925690939659916043492930278567489422231220073029774565250343832768238643314785908679491540640941915666237839942314696031493953803281287102418829064719403480444915114668250543498318227260440120029605628856083175765744363390702825101686789888725560296981834662758351030421544264559750221026406067121783807117962060340615730987604546604714155531342482083463681465130945512630675950142946922773503989053740822544224822808739521839720865290854356372141124499117074370897738546403209492027955454351993333035066859502938275568857093391457569773694819414826823687786033626122521592630462668886697269593537206139576741010831202963443941784967084810577008190387631080387860331107152262177887372170404448327177863200442345178285860750842841747607378523075424463460687928269706777288437394933478285113452249795657205511632132532278321265130924156213221634753820154649629494859389730150879262081109896155213238885748358893270681278721615531236111911030373024923666321800532386588112916399442185933551569956564864083732019627140517341497168342679467249158600970283106090236941217046682435095258063945957758115971959566229732597197779697266154520814140590150

bc -l (<= 8 bytes, cracked by SuperJedi224)
1.56024766824332863615

I think I found your forumula. Now to go learn bc.

Cracked.

TI-BASIC, ≤8 bytes
-.3036143372

Grin, ≤8 bytes
0.27994163386353987

Python 2.7.9 - 64 Bytes - Safe
{qo'' y7hp t:uulo\nbtp om oo\nbo'ntsnyim o 't\yi'esp lstor:oit_r'co'bi'r'ecsd:,t
p'esc'er lrfChlry'i<ep 't\ee>r lrfChlry''d_ t,t'elo<elno\nbes>i.  ta<etmfChli\p
.n  .t  m:uiruns'ds' y7s.,tfoN'eim ttr:oituy'oojn'djn' y7jn.,t  ttOni:ui t,trotl
mnSIm i t,a<ear:oiacusf  .x:,o'denr:oio\tca<e' y7acrm fChl.,a<ear:oiactstna<ehi)
nt'dusemP2\es'sto'ir:oirp tu li.' y7ust'xo<eesi)sa:usa 't\sap cm co\nbc'ntem tu
't\nte'eaknntem to 't\nte'mim r 't\minp c'd_o(- a<ec(- em eo\nbe'h:uh t,i:utOmP2
\gcta<ec' y7tacto:,k la 't\e.,r'diobi'<e 't\s>stN'iiin_e<eu_mP2\up .:,lo<elobi':
usbi'e<et 't\ntiy'l'd_t t,t:ulmmP2\ocoom a(- .tnh:uh t,tpouslnoen4<eo.' y7en4ci<
e'l>r<enuntyo_to'eo\nLcy'c<ea t,_a let 't\rs.,no' 't\si.,o._m dl1mP2\ia.,p lpfCh
lpy'em:,r'd_nbi'_:,tn  .N'i_i  e<ed(- dc'den1fChlcs5'e'et:us'l>s:ua' y7hb>sp:,w
ly 't\e.,twfnnga lcssr:oio\e'n'dfhmP2\c'rsm p 't\rs'sc:usc 't\scp ti:,y:uogmP2\r
csm:urpfChleic_im hfChDhb>a:ur'l>tm ' y7sy'ib<eo. 't\ngs>sr:ueg' y7tet>nim e' y7
cty'<e 't\o>m'd__uns'ds' y7s.,t:,tr'dusur:oitr.,om pi)ihm c 't\ih'erN'usoend  dh
d<eo.ofChlcscp o<ecfChlbp tiN':uer:oitiy'to'tmP2\t>'dnungc:uepfChlnacs lao\nb.,l
o' 't\_y'n<en 't\as>onner'ei.lm ti' y7usny' lsi)mi'eo'ep<eeo\nbs>seN'r<ea t,f lf
 't\i.,t'eoo'(- kto'r' y7_ep .tnnti  'dt(- trcous:}

This submission requires that you use a fresh python interpreter without any previous commands executed in it.

Source code: import sys;from test import regrtest;print repr(sys.modules)[::6]

Are you using the REPL? If so, you need to state that.

Yes. I am using the REPL for this, though it should work if the ocde is the only thing in it's python file and you don't have a customized version of python.

And are using exactly python 2.7.9. This sample doesn't work on ideone. It produces totally different output. Or in PyPy.

Using a lot of __doc__ strings?

@mbomb007 No doc strings.

MATLAB, ≤ 4 bytes
String:
ans =
   0.4133 + 0.9106i

This also works with Octave and its online interpreter, though in that you will get the output:
ans =  0.41329 + 0.91060i

This will probably be solved quite quickly as there is very little you can do in MATLAB with only 4 bytes! But never the less...

Cracked.

Python, cracked by Sp3000
UUU UUC UUA UUG UCU UCC UCA UCG UAU UAC UAA UAG UGU UGC UGA UGG CUU CUC CUA CUG CCU CCC CCA CCG CAU CAC CAA CAG CGU CGC CGA CGG AUU AUC AUA AUG ACU ACC ACA ACG AAU AAC AAA AAG AGU AGC AGA AGG GUU GUC GUA GUG GCU GCC GCA GCG GAU GAC GAA GAG GGU GGC GGA GGG

Range ≤ 64

Which Python is this in? I have a solution for Python 2 but I just want to check

It should work in both. (At least, mine does.) @Sp3000

Cracked

Snails, ≤ 2 bytes (cracked)
8

I thought I'd join in the fun of everyone posting self-written languages/interpreters that no one else knows how to use.
Note to anyone who tries to brute force this: Don't run the programs ~+ or ~,, lest the interpreter attempt to consume several terabytes of memory.

Did you put any documentation anywhere?

@LegionMammal978 Um... that's the "fun" part.

Cracked

Bash
Length <= 64
This cop tries hard to be efficient, but feels trolled by inefficient bureaucracy.
UlRSelNVRkJRVUZCUVVGQlFTdDZSMjlSTUVGTlFXZEJUVXclTDBWUloxRnFVQzlFU1RZeGNWcGxa
bVplUm1OcFNXbEphVWxwU1dsSgphVWxwU1dsSmFVbHBTV2xKYVVscFNXbEphUXBKYVVscFNXbEph

What is it with you and your L0VRZ?

The cop would like to answer but has to send reports up multiple levels of management. The answer wouldn't end up any easier to read than what you already saw...

JavaScript, ≤64
Output (467 bytes):
223C2194299201F9B31FF25032420290E1138229F9E53B25F5B25FE02903F105F09962F25F09962F2EF119E5229D25050F01CF029F2130EFF502213925253012029F0190CF501C2F030B25D3450C5C3B22209FF2C35912309F22F1F1003596535BF0822F4C313496FD3C929099235024252941251259229C2523592599255F592F91225F2255192225F92CF293009C1F09291C952592593B925A252F99F01F99009912399121253125391C131A25B25F5593325292525325255920920252559F0525322996999692F225329294E990C9B509352F9F51292F92525B29399325199325921C203A5FF8223

I tested this in the console of Firefox 41.0.1 at an empty web page.
Safe! Original code:
(btoa(Object.keys(this)).match(/[\dA-F]/g)+8223).replace(/,/g,'')

Matlab/Octave, range  ≤16, cracked by kennytm
Desired output in Matlab is
ans =

        2650        2700        2750
        2703        2754        2805
        2756        2808        2860

And output on octave is
ans =

   2650   2700   2750
   2703   2754   2805
   2756   2808   2860

Good luck!

cracked

><>, ≤8 bytes - Cracked
That was fast.
Output (17 chars):
11059633333125108

Works on the official and online interpreter.

Cracked

Python 3, <= 32 (Safe!)
This one is not a full program. You run this from the python REPL.
[False, True, False, False, False, False, False, True, False, True, True, False, True, False, False, True, True, False, False, False, False, True, True, False, False, False, False, False, False, False, False, False, True, False, False, True, False, False, False, True, True, True, False, True, False, True, False, False, True, False, False, False, True, True, True, True, True, False, True, False, True, False, False, False, False, False, False, False, True, False, False, True, True, False, False, True, True, False, False, False, True, False, False, False, False, False, False, True, True, False, False, False, True, True, False, True, False, False, True, False, False, True, False, True, True, False, True, True, True, False, False, False, True, True, False, True]
This one was fun ;)
My code:
[int(i) > 5 for i in str(64 ** 64)]

(spaces added for readability)

Took a big number, converted it to binary, converted that to a list of BOOLs, Yes / NO as an array separated by "" ;)

That would be too long, but good guess!

@AlbertRenshaw Use an ASCII string instead of a number.

Uh-oh, I see this being cracked soon :)

@JAtkin I was assuming this big number would be represented by a smaller formula, for example 52^3-27 or something

Ahh Ok I see now.

That's the approach I've been working on, but got absolutely nowhere with deconstructing the number. (Just like several of the other challenges here). If it was a number, it would be int(''.join(map(str,map(int,L))),2) = 21227472847701385512593946787863437 and the creation might be [x=='1'for x in bin(?)] allowing 10 characters for the ?

If/when you crack this, please let me know and I'll show you how I did it ;)

@AlbertRenshaw I have posted my code

@TessellatingHeckler I just posted my code

NICE! Hahahahaha

PowerShell 4, (Safe) <= 64
817830,2180,26491570,269854650,290,2858936340,20,20,255794473916160,2890,23434185590,258371780,2876750,260,20,2181318319616730,2170,239970,28573390,24143634460,240,24180,20,230,28970,298454139597176550,20,20,285130,281680,2770,2746350,2840,20,2393979960,20,20,250,216134518751476350,26410,280,20,25570,250,268451577990,20,230,210,20,210,2731543879350,20,2753759190,27480,24134837490,2811158519194475560,266858480,230,2790,2664564410,240,284660,210,24537956764310,27430,240,290,2640,29390,240,2660,20,28410,2630,2379473440,21931131890,298897540,20,20,20,270,20,250,2190,20,20,240,2891335370,20,23568480,23990,2153780,28490,29349985134967880,20,21790,250,215414650,240,293880,26978738914850,23730,2771469340,2496710,25510,20,26474597990,26141560,230,21850,230,250,250,26550,298119160,264780,260,20,2430,2750,25533518530,2740,20,2390,28990,29830,27990,20,20,20,20,29990,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20

Edit - solution revealed:
([bigint]::Pow(9990,201)-split'2'-split'0'-join'0,2').trim(',2')

Gets a really big number ([bigint] requires PowerShell v4+), that coincidentally has a lot of 2's and 0's in it. Splits on 2's (i.e., removes every 2 and creates an array of strings), does the same with 0's, then joins the array back together with 0,2. Essentially, this replaces every 0 or 2 in the original number with 0,2. Finally, it trims off the last ,2 to make it cleaner and make the pattern look like ,20 rather than 0,2.

PowerShell, <= 2 (cracked by Sven the Surfer)
True

Edit -- Assumes a newly opened PowerShell session.
Code:
$?

This is actually several short-hand aliases mushed together for "Did the previous command execute successfully?" Since we're starting a new session, there isn't a previous command, so "Did nothing execute successfully?" evaluates to True.

Cracked

Lua, ≤ 32 (cracked by Doub)
Output:
1(222)33333(4444444)555555555(66666666666)7777777777777 7

You need to write a Lua program (not a REPL command).

Cracked in http://codegolf.stackexchange.com/a/60873/46213

Marbelous, Safe, ≤64
Output:
&')8~?'?*qmqAuu*`wA/0N'lX;(0<NCz55Z@+rDD{?8q]`

Online interpreter here. Assumes cylindrical boards.
Information on Marbelous.
Hint:

((3*x + 233)/2) mod 128 is used. A lot. Asides from calculating that, the only devices I used are: @n, \\, >n, !!, and calling the board that calculates that ((3*x + 233)/2) mod 128.

Code:
23@0
22{}
\\21
@0:)
::)
}0E5
<<
}0
E9
&0&0
>>\/
>V!!
\\
{</\{0

:) calculates (3x+233)/2 mod 128, and returns nothing if the result is not a printable ascii character. The top part used to just feed a marble in a loop until this condition was reached, but then I moved a couple of things around and have no idea what actually happens anymore...

Octave, ≤32 (Safe)
Fun with complex numbers!
Output:
ans =

   276.255 -   2.551i
   169.272 +  76.768i
   156.409 -  86.377i
   162.145 -  53.166i
    69.090 - 156.251i
    55.613 + 160.617i
    90.672 + 139.735i
   156.761 +  35.006i
   142.780 +  76.629i
    46.480 - 154.816i
    89.612 - 133.107i
   149.392 -  33.599i
   130.552 -  78.858i
   144.270 +  27.883i
    89.886 + 123.547i
    46.217 + 145.361i
   126.882 +  74.024i
   139.113 -  29.654i
   135.960 +  25.274i
   119.010 +  70.408i
    84.834 + 113.671i
   130.107 +  23.973i
   113.577 +  67.526i
   125.531 +  22.879i
   121.624 +  21.877i
   118.451 +  21.302i
   109.630 +  65.362i
   106.084 +  63.788i
   103.179 +  61.957i
    80.878 + 107.596i
    77.922 + 103.234i
    75.954 +  99.708i
    73.853 +  96.586i
    41.096 + 135.557i
   132.222 -  27.776i
   120.678 -  74.918i
   127.189 -  26.411i
   123.182 -  25.272i
   116.602 -  23.653i
   119.390 -  24.383i
    84.360 - 120.211i
    39.698 - 140.870i
   114.259 -  71.642i
   109.932 -  68.992i
   106.247 -  67.027i
   103.025 -  65.160i
   100.376 -  63.620i
    38.500 + 128.779i
    36.861 + 123.774i
    34.301 + 116.363i
    35.422 + 119.917i
    33.337 + 113.479i
    36.543 - 132.596i
    80.227 - 112.287i
    34.587 - 126.848i
    33.171 - 122.564i
    32.001 - 118.878i
    30.241 - 112.840i
    31.031 - 115.608i
    76.843 - 107.182i
    74.524 - 103.346i
    70.551 -  97.215i
    72.538 -  99.754i

Original code

 eig(fft(magic(63))+45).^0.4759+1

magic( should be a method in all languages.

Coffee Script, <= 16 bytes (Cracked by Sp3000)
Tested with online REPL.
2.177586090303602
17 byte output. This should go fast...
Original code:
Math.PI*Math.LN2

Cracked

Seven minutes... holy crap, dude. XD

Had I known about inverse symbolic calculators I woulda never tried this...

@JAtkin You can literally just paste the number into WolframAlpha...

Hehehe I know that now!! Wolfram and inverse calculators are my new favorite toys.

CJam, ≤8
487480661435681880634

Haskell, <= 64
"234269035277217371450204053788208058560799137025150410636234412255689818762656987340189922194199908934585754436770945621945227536480994122027390744842460652134286726113671600854494421884443688675047254139921459136558907251581541275435880046048108350763422072425649208447945247377494980796937940655701307997562317231177713235652338028417451236558995227590459444617827926812430772358074299811337678654829391325114470251619398332973724789690679216976966052216145384676794461656118897180025443680331132394850675017509197303075089601960100983874271959120860501629839988014042208671920682889138254667751623709396284481735303452673124139121777377846871850672033106472280969141703928366197810964922618740449515668724456268271448647699989156381445205967478469028588157734532905706524844819908323813305035658162074736928332593023809473156005356000353055733539612246442774946157819406373129208057258831053076086585508756487286954717132003621711976832374447894816733777893008621416274050484859334617085131384283216302606998622119582879282589199593973325446462015234491992064297172938689972846409163423245594572882877709043959807372637664123289304645760119286430615178518063617152788828056353625031963803801427210223721730258270231763792780768664884800062997419345647149704788982766859295443743499252375539507398523730009926333960108410757294547781696131123657453625024387016742581573855196031413093336350761030038596777874432933968895083735228717242953009263093968742573629027297647387126891761852949241957626049569804429541178011981933256268484794652351497560293391899479900814683813828949668729076822808628116446774100881521615133458539277068540778366277878840073320092074401621104369683572238945467129923105411003295755601858665112706827105134190951462194645064739837907120118633835684577553292202532275739715956095669642085664671234208045303605448727259339868163682440084839078742590621118695767964815678513010560919582968899674389139580927687507301062249730389625964423196961408134619058630786289121348398596872496242241800816316097838514854690220862576"

2046 bytes.
This is my first post here, hopefully I did something right!

Pip, <= 4 (cracked by Reto Koradi)
1101001

Took me a while to find something interesting that didn't involve PI or nasty implementation exploits.

Cracked

QBasic, <= 32 (Cracked by fschmengler)
 1  2    3      4        5          6            7              8

Uses pre-auto-formatter shortcut syntax. Tested with QB64.

Here's my original version:
FOR i=1TO 8
LOCATE,i*i
?i;
NEXT

The space before the 1 and also after the 8 is part of the output. (Though when you run the program, you can't exactly tell about the one at the end, unless you try to print something else immediately afterward.) QBasic prints a space before and after nonnegative numbers, though some emulators (like the one at repl.it) don't format their output correctly.

There is a space before the "1" and after the "8"?

Good question. If there is no trailing space, I have a 31 byte solution.

Yes, it has the leading space. I'll post it and leave it up to you to judge

Cracked?

Downloaded QB64, for fun and nostalgia. I totally missed that second space, but should be easy to fix...

Removed the +1, seems about right. I even can confirm the trailing space.

JavaScript, ≤16 bytes, cracked.
Ohhh, this one is a tough one.
31525197391593470

This is seventeen bytes.
Well, again, not the way I intended it, but here:
7/Number.EPSILON

I'm at -.5 points ;-;

Cracked?

You have to say if it's not a complete program, right?

@mbomb007 All JavaScript programs are complete programs.

Using the console (a REPL) is not a complete JS program. In JS, you need to use console.log for output.

@mbomb007 Huh. I'd debate that, but whatever.

If you're programming in JS, using a numeric literal does not automatically print it to the console, so it's not really debatable that it requires a REPL to work.

Math.EPSILON is giving undefined on Chrome.

@SuperJedi224 Use FireFox.

I'm getting the same thing there. Let me go ask google. (Edit: It turns out that, in both, Math.EPSILON does not exist, but Number.EPSILON does.)

@SuperJedi224 Ugh so sorry

Python, <= 64 (safe)
2048 bytes of output, counting the trailing newline (note as well the single leading space):
 z7D0R#r-Y!y6F.X!x4I*_!y6F-X!x5H+]!y7D/T"t/T"t/T"t0S#s.W!w4J)b"v3L'g$q,\!y7D0R#r-Y!y6F-X!x5G,\!y7D0S#r-X!x5H+]!y7D/T"t0S#s.V"v2M'h%m)c"u1O%m(e#s.V"v3L'g$p+\!y7D0R#r-Y!y6F-X!x5H+\!y7D0R#r-Y!y6F.X!x4I*_!y6F.X!x5H+^!y6E.V"v2N&j&k'h%m)c"u1O%l(f#r-Y!y6F-Y!y6F.W!x4I*_!x5G,[!y7D/T"t0R#r-Y!y6F-Y!x5G,Z!y6E.U"v2N&k&i%l'f#r-Y!y6F-Y!y6F-Z!y6E.W!w3K(d"t0S#s.V!w3L'f#r-Z!y6E.W!w4J)b"v2M&i%m(e#s/U"u1O%m(c"u1Q$p+^!y6E/U"u1P%n)b"v3L'g$p+]!y7D/S#s/U"u1O%m(e#s.V"v3L'g$o*^!y6E.V"v2M'h%n)b"v3L'g$o*^!y6E.W!w4J)a!w4J)b"v2M'h%n)c"v1O%l'f#q,Z!y7E/U"u1P$o*`!x5G,\!y7D0S#r.W!x4I*_!x5G,[!y7D/T"u0Q$q,\!y7D0R#r-Y!y6F-Y!x5G,[!y7D/T"t0S#r-X!x5H+\!y7D0R#r-Y!y6F-Z!y6E.W!w4J)b"v2N&j&j&j%k'h$o*`!x4I*_!y6F-X!x5G,[!y7D0S#s.V!w3K(e#s/U"u1Q$o*_!y6F-X!x5H+\!y7D0S#r-X!x5H+]!y7D/T"u0Q$p+\!y7D0R#r-Y!y6F.X!x4I*^!y6E.V"v3M'g$o*_!y6F.W!x4I*`!x5H,\!y7D0R#r-Y!y6F.X!x4I*_!y6F-X!x5H+]!y7D/T"t/T#t/T"u0R#q,[!y7D0S#s.W!w3K(c"u1P$o*`!x5H+]!y7D/S#s.U"v2N&j&j&k&i%m(d"u0Q$p+\!y7D0R#r-Y!y6F-X!x5G,\!y7D0R#r-Y!x5G,[!y7D/T"t0R#q-Z!y6E.V"v2N&j&j&j&j&k'h%n)c"v2N&k&i%l'g$p+]!y7D/T"t0R#r-Y!y6F-Y!y6F-X!x5H+\!y7D0R#r-Y!x5G,[!y7D0S#s.V"v2M'h$o*`!x4I*_!y6F-X!x5G,\!y7D0R#r-Y!y6F-X!x5H+^!y6E/U"u1O%l(e#r.W!x4I*`!x5G,\!y7D0R#r-Y!y6F-Z!y6F.W!w4I*`!x5H+^!y6E.V"v2M&i%l'f#q,[!y7D0S#s.V"v2M&i%m(c"u1Q$o*^!y6E.V!w3L'f#q,[!y7D/S#s/U"u1P%m(c"u1Q$o*_!y6F-Y!y6F-X!x5G,\!y7D0R#r-Y!x6F-Z!y6E.V!w3L(f#r-X!x5H+\!y7D0R#r-Y!y6F-X!x5H+\!y7D0R#r-Y!y6F-X!x5G,[!y7D0S#s.W!w3K(d"t/S#s/U"u1P$o*`!x5H+]!y7D/T"t/T"t/S#s.V"v2N&i%l'g$p+^!y6E.V"v2N&j%k'h$n)a!w4I*`!x5H+]!y7D/T"u0R$q,\!y7D0R#r-Y!x5G,[!y7D/T"t/T"t/T#t/T"u0Q$p+\!y7D0R#r-Y!y6F-Y!x5G-Z!y6E.V"v2M&i%l'g$p+^!y7E/U"u1P$o*`!x5H+]!y7D/T"t/T"t/T"t0S#s.V!w3K(e#s/U"u1P$n)a!w3K)c"u1O%m(d"u0Q$p+]!y7D/T"t/T"t/S#s/T"u0Q$p+]!y7D/T"t/T"t0R#r-X!x5H+\!y7D0R#r-Y!y6F-Z!y6F.W!w4I*`!x5H+]!y7D/S#s/U"u1O%m(d"u0R$q,\!y7D0R#r-Y!x5G,Z!y6E/U"u1P%n)b"v2N&j&j&j&j&k'h%n)c"v2N&k&h%m)c"u1P%m(c"u1P$n)b"w3L'f#q,\!y7D0R#r-X!x5G,\!y7D0R#r-Y!y6F.X!x4I*^!y6E.W!w3K(d"u0R#q,\!y7D0R#r-X!x5G,\!y7D0R#r-Y!y6F.X!x4I*^!y6E.V"v2M'h$n)a!w4I*`!x5H+^!y6E/U"u1P%n)c"v2N&k&i%m(c"u1Q$o*_!y6F-X!x5G,\!y7D0R#r-Y!

Can be solved in either Python 2 or 3.

Code:
x=0.0;s="";exec("x=x*x/40-60;s+=chr(92+int(x));"*2047);print(s)

Explanation:
The ASCII values of these characters are generated via chaos theory. The function f(x) = x^2 + c exhibits chaotic behavior for some choices of c; one such is -1.5. Starting from 0, here are the first few values when this function is iterated: 0.0000, -1.5000, 0.7500, -0.9375, -0.6211, -1.1142, -0.2585, -1.4332, 0.5541, -1.1930. Or, graphically:      The Python code scales this sequence of values to printable ASCII characters and spits out 2047 of them. The chaotic nature of the function creates numerous apparent cycles, such as /T"t, that degenerate as slight differences in the underlying floating-point values get magnified over successive iterations.

Pyth, ≤ 32 chars (cracked, but safe)
yx{z}|~qpsrutwvihkjmlona`cbedgfyx{z}|~qpsrutwvihkjmlona`cbedgf98;:=<?>10325476)(+*-,/.! #"%$'&98;:=<?>10325476)(+*-,/.! #"%$'&

Check this answer's source for a hint, if needed.

Cracked Very likely that you did something completely different though.

Yeah, I did. I actually got it in 17 chars, maybe I should golf off a byte.

Your submission is either cracked or safe. It can't be both.

It was cracked after the seven-day period. Is that safe?

Pyth, <= 16 (safe)
tfzxsepjgyqbiolvakdcuhrmnw

Hint:

 Here's the output from the same code with one number changed: whkoyjexfmcvbgpsztnrudaliq

Code:

 VU5=G_.iFc3G)G

What it does:

 Start with the lowercase alphabet G. Split it into three chunks (abcdefghi, jklmnopqr, stuvwxyz), then fold on .interleave. This interleaves the first two chunks (ajbkcldmenfogphqir), then interleaves the third chunk into that (asjtbukvcwlxdymzenfogphqir). Reverse and assign back to G. Repeat 5 times and print. (The hint is the result of one further iteration.)

Javascript, <=32, CRACKED
(Not expecting to last long)
In Chrome 45.0.2454.101 m:
0.1411200080598672
This is a full program. It actually prints 0.1411200090598672 if it is in a HTML5 document.
Oh I'm stupid, console.log(0.1411whatever); works. I was thinking of alert(Math.sin(3));

Cracked...

@dennis: oh fail... my answer  was alert(Math.sin(3))

ngn APL (safe)
3.2406187300653406e+102

Range ≤ 16
Sixteen bytes of APL should be way to much to get cracked, so here's a hint: The only digits the code contains are 1, 2, 3, 4, 5, 6, 7 and 8, each one exactly once, and in that order.
Solution
|(*|)12.34J56.78

Try it online.
How it works

12.34J56.78 denotes the complex number 12.34 + 56.78i.
(*|) is a train/fork.

| applies modulus to 12.34 + 56.78i, returning 58.105455853990165.
* calculates (12.34 + 56.78i)58.105455853990165.

| applies modulus to the result.

I wanted to make this a ≤ 8 submission, but I already had one, unfortunately. :/

Look ma, no Unicode!

Commodore 64 Basic, ≤32 bytes - safe
Output: 200 bytes.  Every blank line is a space followed by a newline.
/
7

*
1
1
3
?
?

?

4

9
6

!
?
?

"
(
2
!

!
(

(
'
(
'
(

?
?

!

!

,
(

(

)

"
(
"
(
?

#
,
-
8

'
'

'

(
'

<This line isn't actually output, it's a dummy line to get around the fact that SE doesn't like trailing spaces on code samples.>

Code:
1fOi=0to99:?cH(pE(i)aN63or32):nE

The first 138 or so bytes of the Commodore 64's memory are constant, or change in deterministic ways during the execution of the program.  This program takes the first 100 bytes of that memory, turns it into text, and prints it to the screen.  Getting this program down to 32 bytes limited the size of the constants I could use, with the side benefit that all the output is in the range where PETSCII and ASCII are identical.  I would have preferred
1fOi=0to118:?cH(pE(i)aN127or32);:nE

for a richer set of characters in the output and a cleaner look, but that would put me in the next size category.

CJam (safe)
Range: <=16
String:
-1757998761424490676921016856999645582687172166771732990901023822919032113856474131322376304211808153619988283134008439274637725633868254103891368425285165026468770378090155135372308987708009431738653866423053902527963127906032288661788122437508856152696997908146296016521091199803229053377715671662942187527704135032400317135628637248506389262291879310836675157035298269773565002128572484249631883681915978366368348422763684673273940395075510502820393796214460557862527316465092717359768308614013715174354726471330845504297837476047888566285525771034491348417324909599453182115064413154332558333250875021070793798910049854644817559064573856721397747003126054061162347856585377448534690237788836012961397667542666722692935386425165604581402711433056617873627041251709641777614212372373696828558813318358124653096657585640957194959404589685428128317642065010497446792032482302568447660371023038445973792552314710542567265966630122643983375527917082186662519498233404401344837146447008437657457992594647903611528282318427533140206671065997969913543629153024916689707377967665079085509461263277920838560857104814273338655611983839393046785144278966861497797144865502969288669678711952606556690911517688871027804066141321298362142430813845600699520261708534251247924822880140866847159914428320312680337671139215536945422935222183014047914184629917144775390626

Code: 5345 363#~
Yay more numbers /sarcasm

><> (cracked by Sp3000)
Range: <= 32
Code:
ff*dd*$1-:?v$n;
           >$30.

String:
563894191846824322181557735263848163944611762131417907481282961909287815042114141071535925118959126585814601613352812123491114638156704068663512650264401513800791946239391603476080341849517532994005910896839888895899232312762154139810647195016820308009

Cracked

CJam (cracked by Sp3000)
3.724191778237173

Range ≤ 4
Let's see how long this one lasts.

Cracked

I guess I have my answer...

Wolfram programming language
Output (36 bytes)
{7, 11, 14, 11, 7, 10, 10, 10, 6, 9}

Range: ≤16

Does the byte count include the Print?

Wolfram programming language, cracked by alephalpha
Output (111 bytes)
{1, 4, 1, 18, 1, 1, 1, 4, 1, 9, 9, 2, 1, 1, 1, 2, 7, 1, 1, 7, 11, 1, 1, 1, 3, 1, 6, 1, 30, 1, 4, 1, 1, 4, 1, 3}

Range: ≤32

Cracked.

 VBA,[Safe]
Range <=64
Output
-21474836332792802484224001.05297830108845E+65

Number Answers are boring but I think this one is different
Edit: I was really expecting more colorful questions but I guess number answers are only so exciting

 Solution with code

    Sub q()
    Debug.Print vb3DFace & vbBlue ^ 2 & vbCyan ^ 9
    End Sub

This is a pretty boring answer. The vbColors are hard coded values in Excel I double checked online and all installs of excel assume Blue is Blue. then i did some math to obscure those constants and concatenated them together so they would display as a long string rather then it being shortened to SE format. Cyan is already shortened to SE notation so it make it look like one big number.
 This was kind of a cheap shot but I wasn't sure if someone would notice that the middle of the number was the hex value of Pure Blue squared.

Pyth, safe, <= 16
16252320011828121914223211711247272693015813524610

This was output from a linear congruential generator.

CJam, <= 16 (safe)
 9 4 11 6 12 58 1 43 62 5 92 56 48 14 98 1 9

There is a single leading space.

Code:

 Ps{i48-_*s)S\}%

What it does:

 Convert the built-in P = pi variable to a string. For each character, subtract 48 from its ASCII value (giving the corresponding number for a digit and -2 for the decimal point). Square and convert to a string. Uncons the rightmost character from the string, push a space, and swap it with that character. This has the effect of converting a digit like 4 into 1 6. The stack is printed without delimiters, thereby obfuscating what's actually going on.

Powershell, ≤16
61788129934789836849895604649984

Python 3.5.0, Safe, ≤64
zwnj;zdot;yicy;xwedge;xoplus;xhArr;wp;vsupne;vnsub;vdash;varsigma;vangrt;utrif;urcorn;uparrow;ulcorn;udblac;uacutetscr;triangleright;topfork;timesb;thicksim;tdot;swnwar;supsetneq;suphsub;sup3succneqq;subsetneqq;submult;starf;square;sqsub;solbar;smeparsl;simgE;shy;sext;searhk;scnap;sc;rtimes;rppolint;roang;rightthreetimes;rhov;regrdldhar;rbrke;rarrtl;rarrap;radic;quotqfr;profline;precnsim;prap;plussim;plus;phiv;part;oumlorv;order;omid;oint;oelig;ocir;nwArr;nvgt;nu;nsupseteqq;nsubseteq;nsimeq;nrtrie;npre;notnivb;not;nles;nlE;nhArr;ngE;nearr;ncedil;natur;nVdash;nGt;models;middotmdash;maltese;lurdshar;ltdot;lsimg;lrhar;lowast;longleftrightarrow;lnapprox;llarr;lfr;lesges;leq;leftharpoondown;ldca;lbrack;larrsim;laquolHar;kjcy;jsercy;iukcy;iscr;intlarhk;in;iiota;iexcl;hyphen;homtht;hcirc;hArr;gtrapprox;gsime;gnapprox;ggg;ges;gbreve;frasl;frac25;frac12flat;fallingdotseq;ethequiv;epsilon;emsp;ell;efDot;easter;duarr;drcorn;dotminus;divonx;diamondsuit;deg;dbkarow;cwint;curlyvee;cupcap;ctdot;copy;compfn;cirscir;circlearrowright;chcy;ccupssm;caps;bumpe;bsim;boxvh;boxtimes;boxdl;boxVH;boxHD;bopf;blacktriangleright;biguplus;bigcirc;because;barvee;auml;aringaopf;angmsdag;ange;amalg;aelig;ac;Zdot;Ycy;Xi;Vopf;Vee;Uscr;UpTee;Union;Udblac;UacuteThinSpace;Tab;Sup;Sub;Square;Sfr;SHCHcy;RightVector;RightTeeArrow;RightArrowBar;Rcy;RBarr;Proportion;Poincareplane;OverBrace;Oscr;OgraveNu;NotSupersetEqual;NotSquareSuperset;NotPrecedes;NotLeftTriangleEqual;NotGreaterFullEqual;NotCongruent;NegativeVeryThinSpace;Mu;Lt;Longleftarrow;LessSlantEqual;LeftUpVectorBar;LeftTee;LeftArrowRightArrow;Lang;Kcy;Jfr;Iopf;Imacr;Iacute;HorizontalLine;Gscr;Gg;GT;Ffr;Equilibrium;Element;Eacute;DownTee;DownArrowUpArrow;DoubleLongLeftRightArrow;DotDot;DiacriticalAcute;DZcy;CounterClockwiseContourIntegral;CloseCurlyDoubleQuote;Cedilla;Cap;Bfr;AumlAogon;

Output is 1833 bytes. Full program (outside REPL). Should be easy ☺

Solution:

 from html.entities import*;print(''.join(sorted(html5)[:13:-9]))

AppleScript, ≤ 64 Bytes Cracked
Ooh, yes, time for another AppleScript answer.
Output String:
688.0
317.0
946.0
575.0
204.0
833.0
462.0
91.0
720.0
349.0
978.0
607.0
236.0
865.0
494.0
123.0
752.0
381.0
10.0
639.0
268.0
897.0
526.0
155.0
784.0
413.0
42.0
671.0
300.0
929.0
558.0
187.0
816.0
445.0
74.0
703.0
332.0
961.0
590.0
219.0
848.0
477.0
106.0
735.0
364.0
993.0
622.0
251.0
880.0
509.0
138.0
767.0
396.0
25.0
654.0
283.0
912.0
541.0
170.0
799.0
428.0
57.0
686.0
315.0
944.0
573.0
202.0
831.0
460.0
89.0
718.0
347.0
976.0
605.0
234.0
863.0
492.0
121.0
750.0
379.0
8.0
637.0
266.0
895.0
524.0
153.0
782.0
411.0
40.0
669.0
298.0
927.0
556.0
185.0
814.0
443.0
72.0
701.0
330.0
959.0
588.0
217.0
846.0
475.0
104.0
733.0
362.0
991.0
620.0
249.0
878.0
507.0
136.0
765.0
394.0
23.0
652.0
281.0
910.0
539.0
168.0
797.0
426.0
55.0
684.0
313.0
942.0
571.0
200.0
829.0
458.0
87.0
716.0
345.0
974.0
603.0
232.0
861.0
490.0
119.0
748.0
377.0
6.0
635.0
264.0
893.0
522.0
151.0
780.0
409.0
38.0
667.0
296.0
925.0
554.0
183.0
812.0
441.0
70.0
699.0
328.0
957.0
586.0
215.0
844.0
473.0
102.0
731.0
360.0
989.0
618.0
247.0
876.0
505.0
134.0
763.0
392.0
21.0
650.0
279.0
908.0
537.0
166.0
795.0
424.0
53.0
682.0
311.0
940.0
569.0
198.0
827.0
456.0
85.0
714.0
343.0
972.0
601.0
230.0
859.0
488.0
117.0
746.0
375.0
4.0
633.0
262.0
891.0
520.0
149.0
778.0
407.0
36.0
665.0
294.0
923.0
552.0
181.0
810.0
439.0
68.0
697.0
326.0
955.0
584.0
213.0
842.0
471.0
100.0
729.0
358.0
987.0
616.0
245.0
874.0
503.0
132.0
761.0
390.0
19.0
648.0
277.0
906.0
535.0
164.0
793.0
422.0
51.0
680.0
309.0
938.0
567.0
196.0
825.0
454.0
83.0
712.0
341.0
970.0
599.0
228.0
857.0
486.0
115.0
744.0
373.0
2.0
631.0
260.0
889.0
518.0
147.0
776.0
405.0
34.0
663.0
292.0
921.0
550.0
179.0
808.0
437.0
66.0
695.0
324.0
953.0
582.0
211.0
840.0
469.0
98.0
727.0
356.0
985.0
614.0
243.0
872.0
501.0
130.0
759.0
388.0
17.0
646.0
275.0
904.0
533.0
162.0
791.0
420.0
49.0
(1,824 characters long)

Cracked???

@kennytm Sorry, but no. I print to STDOUT.

@kennytm To be fair, you had my code almost exactly - I printed to STDOUT. You can still print that way with the bytes you had remaining.

><>, ≤64 Bytes, Cracked by Cole
"!#"$#%$&%'&(')(*)+*,+-,.-/.0/102132435465768798:9;:<;=<>=?>@?A@BACBDCEDFEGFHGIHJIKJLKMLNMONPOQPRQSRTSUTVUWVXWYXZY[Z\[]\^]_^`_a`bacbdcedfegfhgihjikjlkmlnmonpoqprqsrtsutvuwvxwyxzy{z|{}|~}{~z}y|x{wzvyuxtwsvruqtpsornqmploknjmilhkgjfiehdgcfbead`c_b^a]`\_[^Z]Y\X[WZVYUXTWSVRUQTPSORNQMPLOKNJMILHKGJFIEHDGCFBEAD@C?B>A=@<?;>:=9<8;7:69584736251403/2.1-0,/+.*-),(+'*&)%($'#&"%!$

Output length 368 bytes
Original source used:
48*v!1:*3f<.13p16-2p11p17-1p12:++aa*
:+2<o:-1o:^?)*9e:;?(*b3

Cracked.

PoGo, safe, <=32 Bytes
Output (116 Bytes)
418823741706778235498161926738634336931815369322701079743198012261458790182-1935586134-558199202-1377386932819187730

Solution
enpobeosadpeadopuftogopoopufnigo

REPL Python (tested with version 2.7.10), <=32 - Safe
Output (1196 chars):
"{CL_UCIN:11 DPTP:4 IPAEFORDVD' 8 MPAD:17 BNR_O' 5 EDFNLY:8,'EUNVLE:8,'O_LC' 7 STPLO' 2,'UL_E' 0,'O_O' ,'XEDDAG:15 STPFNLY:12 IPAETU_IIE:2,'ALFNTO_W:11 IPAEAD:7,'EU_XET:11 SOENM' 0 IPR_AE:18 LA_LBL:16 LA_AE:11 FRIE' 3 EE_TT:8,'EEENM' 1 BIDLS' 0,'OPR_P:17 BNR_R:6,'NLC_UTPY:5,'TR_AT:15 CL_UCINVR:10 STAD:16 LA_OAS:8,'OTNELO' 1,'RN_XR:7,'EEEGOA' 8 GTIE' 8 SO_OE:0 UAYNT:1,'IAYLHF' 2 LA_LSR' 3,'MOTSA' 4 IPAEO' 9 BNR_UTAT:2,'TR_A' 4 IPAEAD:5,'NLC_SIT:7,'NLC_OUO:5,'TR_TR:9,'UL_A' 0,'EU_IH:13 BNR_IIE:2,'NLC_SIT:7,'RN_TMT' 3 UPC_EUNE:9,'IAYMLIL' 0 PITNWIET' 4 NP:9 LS_PED:9,'NLC_O' 8 SOEGOA' 7 IPAESBRC' 6 IPAEPWR:6,'O_OR:5 DLT_USR:6,'IAYAD:6,'RA_OP:8,'AEFNTO' 3,'EEESIE1:5,'EEESIE0:5,'U_OX:9,'ALFNTO_A_W:12 LA_TR:16 BNR_REDVD' 7 RTTO:2 IPR_RM:19 DLT_AT:16 BNR_D' 3 LA_OS' 0,'TR_EE' 3,'NR_EAIE:1,'NR_OIIE:1,'TR_USR:6,'UL_UL' 0,'IAYPWR:1,'UL_LS' 9 UAYCNET:1,'IAYMDL' 2 DLT_LC+' 3 DLT_LC+' 2 WT_LAU' 1 DLT_TR:9,'O_UPI_RE:15 JM_FFLEO_O' 1,'RN_TM:7,'AS_AAG' 3,'LC+' 0 SIE1:3,'LC+' 2 SIE3:3,'O_UPI_AS' 1,'ODDRF:16 LA_AT:14 JM_FTU_RPP:12 BNR_LO_IIE:2,'IAYRHF' 3 BNR_USR:2,'IL_AU' 6 RTTRE:3 SOESIE0:4,'TR_LC+' 1 SOESIE2:4,'TR_LC+' 3 UAYIVR' 5 PITNWIE:7,'NLC_IIE:5,'UL_LC' 3,'UPASLT' 1,'AECOUE:14 JM_OWR' 1}"

The Code (32 chars)
import dis;('%s'%dis.opmap)[::2]

If someone could explain how to make that line wrap, and be all visible at once instead of moving out the right side of the screen I would appreciate that.

Does this depend on the OS?

Hmm, not positive, to be honest. I have OS X though. Sorry I wasn't more helpful. I'll try to check whenever I get the chance.

J, Cracked by Dennis
Length <= 8
0 1 0 0 1
0 1 0 0 0
0 1 0 1 0
0 0 1 1 1
0 1 0 1 1
0 0 1 1 0
0 1 1 0 0
0 0 1 0 1
0 1 1 0 1
0 0 1 0 0
0 1 1 1 0
0 0 0 1 1
0 1 1 1 1
0 0 0 1 0
1 0 0 0 0
0 0 0 0 1
1 0 0 0 1
0 0 0 0 0
1 0 0 1 0

Cracked.

Pyth, safe, <= 8
128834756732407702383511125730021881412948585094402384

Probably easier to reverse than my last ones, but let's see...
Solution
*7C.B.!T

Ruby, <= 64 (safe)
0
1
012
2
02
123
013
3
03
13
01234
234
0234
124
014
4
04
14
0124
24
024
12345
0134
34
0345
1345
01235
235
0235
125
015
5
05
15
0125
25
025
1235
0135
35
035
135
012345
2345
02345
1245
0145
45
045
145
01245
245
02456
12346
013456
3456
0346
1346
01236
236
0236
126
016
6
06
16
0126
26
026
1236
0136
36
036
136
012346
2346
02346
1246
0146
46
046
146
01246
246
0246
123456
01346
346
03456
13456
012356
2356
02356
1256
0156
56
056
156
01256

It took me the longest time to get this under 66 bytes... Hurrah for the Ruby golfing tips question!

Answer:
(1..99).map{|i|(0..9).map{|x|i+=(i>>x)%2>0?$><<x&&x :0}
puts}

The basic idea here is to print the binary places at which each number has 1's. The catch is that whenever a place does have a 1, we add that place's index to the number. So for example, when i is eleven:

2^0's place, 1011, output 0 and add 0 -> 11
2^1's place, 1011, output 1 and add 1 -> 12
2^2's place, 1100, output 2 and add 2 -> 14
2^3's place, 1110, output 3 and add 3 -> 17
2^4's place, 10001, output 4 and add 4 -> 21

I was wondering if anyone would catch the pattern at the beginnings of the numbers (01020103 etc.), but perhaps not.

Python3, <=128, safe
Output (2047 bytes):
["]'45625053676", '5444242', '04947233', '45395795', '61115179446404336055', '1699', '9626', '7', '1450', '2060579540', '941302396023', '43763345975992692602', '3511', '9970', '9454574', '724944929404', '', '13', '36145517660', '7243061363769519', '541175', '1', '3675533495406165', '453765010570950', '140', '33562', '43', '43446', '95921052', '3', '', '233176247199166562542', '', '12', '611629370', '9', '72', '1106327199', '964', '2', '439065339510155977233203717276', '354233356216750931043970220794929913961392', '633933', '99329', '71', '294', '1770446091', '', '6700030', '21411159', '7', '42292', '4112', '7626', '9015512756956952', '3', '052349110', '31433', '93467540', '036023662104', '10295475719', '35342', '', '4256460216150145', '2', '59427047', '9901730070390445551', '', '54', '0761', '1927322', '9736276799', '564965977', '590', '4', '', '399', '565', '902692601072445119752', '62370104660960596', '', '477391523990', '753', '09956', '041745692491123563', '354995961', '37777625076057', '7570735', '40520', '707409554', '311042911354445746753579759944996262523641325999700', '61014076359', '155932492943', '55294019352972126054', '5', '3955597', '25251', '', '0714219560377', '51042210', '', '2100', '926537625661', '90', '93915224761117505720911640440465', '2521637479904547646762696923', '15', '27353033027667052607159344699202916266232192649170', '61436', '2', '5294136761752472317903903977607754', '133556047', '2413345600', '46407', '3', '', '0307543034651930', '51921', '65', '1073015441105', '713112', '1310091135417433', '440360', '4575', '0', '9615', '42074677457', '399067261507971270271699741603647347602140691719', '003367', '7', '769106493671966', '761', '0520133', '707', '7063', '039', '996045713162390154', '36005797209770231', '560193159926439', '3732021207', '33', '010066', '51602', '9079100064164070695541073766315705', '573664390156561', '6403494973', '7', '4127314051527', '3364365', '4', '5', '473', '793710553529', '72940', '709095', '7710631011973506447709629293', '6', '0457045272264603430', "0799'["]

Code:
n=4**9;f=[0,1];o=str;
for i in range(n):f.append(f[i-1]+f[i-2])
print(o(o(o(f[n][:1564][::-1].split(' '))[::-1]).split('8'))

someone should at least try...

Retina, <= 128 (safe)
1025 bytes of output:
10998988798878776988787768776766598878776877676658776766576656554988787768776766587767665766565548776766576656554766565546554544398878776877676658776766576656554877676657665655476656554655454438776766576656554766565546554544376656554655454436554544354434332988787768776766587767665766565548776766576656554766565546554544387767665766565547665655465545443766565546554544365545443544343328776766576656554766565546554544376656554655454436554544354434332766565546554544365545443544343326554544354434332544343324332322198878776877676658776766576656554877676657665655476656554655454438776766576656554766565546554544376656554655454436554544354434332877676657665655476656554655454437665655465545443655454435443433276656554655454436554544354434332655454435443433254434332433232218776766576656554766565546554544376656554655454436554544354434332766565546554544365545443544343326554544354434332544343324332322176656554655454436554544354434332655454435443433254434332433232216554544354434332544343324332322154434332433232214332322132212110

The score is calculated as usual for Retina: the source code is spread over multiple files, with +1 byte for each file. Alternately, put all the source code in one file, separated with newlines, and count +1 for the -s flag. It's under 128 either way.

Nobody? Well, okay...
<empty>
1x012345678910
(`^\d
@$0
+`@(\d)(?=\d*x{1,99}\d*?\1(.0?))
$2@
)`@
x
^x(\d+).*
$1

This code implements OEIS A061511, in which each digit of a number is incremented by 1 and concatenated back together again. The Retina code walks a @ through the digits, incrementing the one after it using the lookup table generated in the first replacement. At the end of each pass, the @ is turned into an x:
@10xxxxxxxxxx01234567890
2@0xxxxxxxxxx01234567890
21@xxxxxxxxxx01234567890
21xxxxxxxxxxx01234567890

Once there are 100 x's, the third replacement doesn't match because it requires between 1 and 99 of them, and the loop exits. Finally, we clean up the x's and the lookup table.

Javascript (ES6, console), <= 64 Cracked by SLuck49
Original Version:
([].pop+[]).split('').sort().map((x)=>x.charCodeAt(0)).join('')

Crack:
[...[].pop+''].sort().map(x=>x.charCodeAt()+'').join('')

Merged and golfed, Just because, 53 Bytes:
[...[].pop+''].sort().map(x=>x.charCodeAt()).join('')

Due to browser differences...
Output in Firefox:
"10103232323232323240419193979999100101101102105105110110110111111111112112116116117118123125"

Output in Chrome:
"323232323240419193979999100101101102105105110110110111111111112112116116117118123125"

Is cracking one sufficient to be considered cracked?

The crack should match both, as the difference is due to differences in the browser js interpreter.
However, if you match only one, I would be interested in your method.

Cracked, ended up cracking both anyway when I realized what it must be doing

Retina, <= 32
Place code in multiple files and count +1 byte for each file beyond the first. 1358 bytes of output:
llaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalalllaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalalllaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllalallaaaallalallaaalllalallaaallalallaaalllalallaaaalalallaaalllalallaaallalallaaalllala

Mathematica (cracked by 2012rcampion)
Range: <= 64
String:
368921261379020282513891270954327186982974673706213278032469400595412966847044520376177106248857169605480346489563721888158441477887340357265444593721230093185417136793217614909721283425696418258308730582895596139457963926138833267594357117764501504

Code: GroupOrder[BabyMonsterGroupB[]]^9/10^54
Golfing this down to below 32 probably wouldn't have helped. Note to self: next time bigger is better

cracked

By the way, I'm interested to see what your method was, since my crack is pretty boring.

baby monster group ^ 9  with the trailing zeros stripped. Will post the exact code when I get home.

MATLAB, cracked <= 16 bytes
I'm going to post this, but feel free to call it invalid. The thing is although the output will always be the same on the PC I am using, it may be different on a different machines as it depends on installed licenses. If it is not valid, I'll delete the answer and will play around making something else.
String:
ans =
Bioinformatics ToolboxCommunications System ToolboxControl System ToolboxCurve Fitting ToolboxDSP System ToolboxData Acquisition ToolboxFuzzy Logic ToolboxGlobal Optimization ToolboxImage Acquisition ToolboxImage Processing ToolboxInstrument Control ToolboxMATLABMATLAB CoderMATLAB CompilerMapping ToolboxModel Predictive Control ToolboxNeural Network ToolboxOptimization ToolboxParallel Computing ToolboxPartial Differential Equation ToolboxReal-Time Windows TargetRobust Control ToolboxSignal Processing ToolboxSimDrivelineSimMechanicsSimPowerSystemsSimscapeSimulinkSimulink CoderSimulink Control DesignSimulink Design OptimizationSimulink Verification and ValidationStateflowStatistics ToolboxSymbolic Math ToolboxSystem Identification ToolboxWavelet Toolbox

Does the output really not contain ans =?

@MartinBüttner I was ignoring the ans = , but I suppose it should be added for completeness.

Cracked: http://codegolf.stackexchange.com/a/60398/45151

Groovy (cracked by kennytm)
Range <= 128
String:
eert.scireneg.tcelf
egami.tw
noitatonna.tcelf
epocs.scireneg.tcelf
snae
gniggol.li
elbat.gniws
oi
trec.ytiruce
piz.lit
resrap.scireneg.tcelf
elif.oi
ytilibissecca
emi
stcejbOevitcelfer.scireneg.tcelf
fer.gna
te
xeger.lit
snaeb.n
elif.locotorp.www.t
cs
tcelfer.gna
ytiruce
tnerrucnoc.lit
rednif.snaeb.n
yrotcaf.scireneg.tcelf
skcol.tnerrucnoc.lit
li
gna
falp.gniws
tneve.tw
eert.gniws
redrob.gniws
noitcnuf.lit
reep.tw
litu.ytiruc
lq
gniggol.lit
tcelf
lit
epip.d2av
maerts.lit
noitatonna.gna
o
laropmet.emi
rehcnu
noitca.ytiruc
tesrahc.oi
www.t
litu.snaeb.n
ekovni.gna
elacol.li
hta
yrotisoper.scireneg.tcelf
litu.t
mod.c
moeg.tw
t
dnd.tw
raj.locotorp.www.t
rotisiv.scireneg.tcelf
radnelac.li
cimota.tnerrucnoc.lit
tneve.gniws
mi.tw
tpircs
tw
txe
o
csim.tcelf
hc.o
raj.lit
sc.o
ips.tesrahc.oi
gniws

Code:
for(Package s : Package.getPackages())println new StringBuilder(s.getName().substring(6)).reverse()

cracked

Mathematica, cracked by kennytm
Output (74 bytes)
11111100001111110010000000100010010010010100100101100111001100000110010101

Range: ≤64

cracked

Math++, cracked by LegionMammal978.
Range: <=8
String: 19.86154370456891
Source: cbrt7835

Cracked.

Fishing, cracked by Mauris
Output (20 bytes)
18538111181203494721

Range: ≤32

Cracked I think?

Microscript, cracked by LegionMammal978.
Range: <=4
String:
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""0

(Length 253)
Original source:
'~cq

There are only 253 bytes in the output.

@kennytm: Thanks for pointing that out, I corrected the number given in the answer.

Cracked.

STATA, ≤ 32 bytes Cracked by @LegionMammal978
Cracked by @LegionMammal978, who also pointed out a bug in the interpreter and how to fix it, so thanks for that!
Note that this uses the free STATA interpreter. Output is 892 bytes. In the "real" STATA interpreter, the output is slightly different.
STATA is a programming language designed for statistical usage on datasets. The normal variables it has are essentially arrays of values where each one represents a different observation. It is used frequently in economics for regression analysis.
    a
1   1.125
2   2.25
3   3.375
4   4.5
5   5.625
6   6.75
7   7.875
8   9
9   10.125
10  11.25
11  12.375
12  13.5
13  14.625
14  15.75
15  16.875
16  18
17  19.125
18  20.25
19  21.375
20  22.5
21  23.625
22  24.75
23  25.875
24  27
25  28.125
26  29.25
27  30.375
28  31.5
29  32.625
30  33.75
31  34.875
32  36
33  37.125
34  38.25
35  39.375
36  40.5
37  41.625
38  42.75
39  43.875
40  45
41  46.125
42  47.25
43  48.375
44  49.5
45  50.625
46  51.75
47  52.875
48  54
49  55.125
50  56.25
51  57.375
52  58.5
53  59.625
54  60.75
55  61.875
56  63
57  64.125
58  65.25
59  66.375
60  67.5
61  68.625
62  69.75
63  70.875
64  72
65  73.125
66  74.25
67  75.375
68  76.5
69  77.625
70  78.75
71  79.875
72  81
73  82.125
74  83.25
75  84.375
76  85.5
77  86.625
78  87.75
79  88.875
80  90
81  91.125
82  92.25
83  .
84  .
85  .
86  .
87  .
88  .
89  .
90  .
91  .
92  .
93  .
94  .
95  .
96  .
97  .
98  .
99  .

Cracked? I don't understand it from 83 onward...

The output is the string I posted. You're close though.

Those are newlines, which are now considered valid.

Python 3, ≤128 bytes [Safe!]
This should be a little easier than last time. I am using ideone.
36925814736925814736925814736925814736912355881042757396194265881134578032649729518416487133567902254871941746386093255780124477931639628508315477023466992153861840735376992245689114376830629527598214467913365982052851749724366891235588104275739619426588113457803264972951841648713356790225487194174638609325578012447793163962850831547702346699215386184073537699224568911437683062952759821446791336598205285174972

My original code:
def x(l,s):
 c=0
 while c<l:
  c+=s;yield c
print("".join([str(x)[3:] for x in x(55, 0.23)]))
#                     ^ prevent the decimal giving it away

 I'm a little surprised that this survived, but that's ok :)

Everyone was scared away by the ≤128, methinks.

That's pretty funny if it's true :)

Python 2, <=64, cracked by squeamish ossifrage
Output length is 2042.
`..{{|{{{{| {|`{~`||{..{~~{~|~ |~~.~{{~.~|{~` {~|{||~{{{~ `{~`~ {{{~|~~{~{{~~~~ | ~.~~.  { {|{~~{{{`||`|{~{.{|{`~|{{|~{{.|~~|.|||~| | .{~~|{~. `~ {{{|{|{|{~{{{{`|{`{{{. |..{|~{~~ ~{{{|.|| {| .~||`|.||{{{  |` ~|~{~  .`| {||{~{{{ . |~{{{~{~.|{{.~.{| {`{~~|  |{`|`{~{ {~|.`~`||~|`|{{{~ { .{{..{{~{.{|~|{{.~{`| {{{~~`||{{{.{|{~|{|~{{|{.||~|~ {{`~{|``{{ ~`{~`{|{`..||.{|| ~{||~{.|{`|.~`{{~|`{~{{|~|~~~`|{ ..~|~{ {{{.{||.{{|~~.{~{`{{{``~.|||{~~|``~|{{|.{ ~|.|`{~~||{|{`{.|{ {`  |``|.| | {{~`|~~|.|{ |~|{{~{~|{~||{`.~~~|.{{|~~.{|``||~|~ |{{|||~   {.   .|~{||`{{{`{|| {~~~~~~`{{.{{~~`{{{``~~|`.` ~`~|~{ ~| |~ `.{| { ~.~.`{{~{ |~{{|`|{~|| {|`||`{~ || {``~.{~`` `||~ {`{...|`.~|{ {~..~`` `||~~{~||~{.|{.{~.|{|{. {.~  ~{~ `{{ ~{{{~.`~`{||{.~`~ |~|{.~{~{  {~~{|.{~`~.{~~~{{| {{{||`. || `.~{{~{| {.{{|{`~{.`.~`|`{{|~`.{{`{~{|~{~{ {|~~|{.{ `.~...{~{~|{~|~|| ..`~|`. ~{{{{|.~{`~~{|`{ `.`|{ |~{~|`{| |{|{~| .{~|`~|{{~.~`~ {{~{ .| |.{{{~{{{|{.  |~`|||``{  ~{``| ~ {|.{|~{`{`{~`..{.{{ .{| |`{{{`.~ ` `||~{|{{`~.{||~`|{.|{{~{. {{~|{| |{~ ~{.~||``|~{.`|.|{{.|||{~{|{{`~ `{|{ {`{{{~{{ {{~{|`..~{{{.||`|~|{|~ { .|`  .~|||{`|||...{{.|{{|~` {{~`.{~..{~{. |~{{.{ .{{ |`{{{~{~|~~{..{{`{{{~~|~|{||{`` ~` {``{~.|~.{{| {{~||..|{|{ |{{|{ |. {~{{~||~~|{ .|{~~~|{{|.{~| {{.`{|{~`{.~|. |{`{~{|``~{{{~.`.|||~|~~|{{~{.| ~{~|| .{|~~ ~~|.{{`` ..{.|.|` {`|`|`~ ~|{{`` ~{~~{|.{{| |~{~`~  `~.~~||~{{ {{{`~{`.| {|||{{|~`|~{~ {{.|.~|~{.||~|~.{{{~.|{.{ |{~~~ {~~{~{| . {{{{{|.~{||||.~`.~{{{{ ~`..|| ``~. {~{  ||{~|{{{| { ~{ {| |~|~ ~`{.~~|.~~|`|{ {.{{`~~~{|{~|{~~`{||{ |{|{     `{  {~~|{|.{{{{`{{{.|{~~{~ ~.`|.{. `~{{~` | ~.{ {|~`{~` || |{ {`{{~|{~ ~. {~`.||~.~{{`| ~{{ ~.~{`|{ {{{ {||~~{{` ~{{ {{ |{`|{{`~`~|{ {~ `{ { `{~|{.~ |.|{~~||~{{~|{.{{.~.~.~|~ {|{~{{|{. |{`~{~{ `.| .~ {.|| |.||| {{{`|{|~|`|{{{`. {`{{`{{{{ {{~`{{{~.~{{|{{{{{  .| ||`|``. .{~~.`{{{{ `|{{|~`  |{.{|{ | |~| |||~{`~~{|{{`|{{~`{ ~{~ ` .{|{~|{| {`.{|.{{ `|{{{{|{~ {{~{`~|~|`{ .`~~.~ |{{`{ |~.{.`{{{{{|{.{~{~~{{{`~~{{~ {.| {|{ ~|{ | `~``~{. ~{|.{|`|.~|~{` {| ~ | {{{{~{.{|{~|``{ {{ `{{ {{{{~{  ~{~`{{``.{{|`{{~{|`{||

[( /? /\ ( /< - |)

@squeamishossifrage It won't recognize as cracked if the word "cracked" isn't in the same comment as the link.

Oh, right. Cracked

Ruby, <= 32 (safe)
-1666267650187848374768490813093409259520003

Solution:

 eval e="p~e.bytes.reduce(:*)*3"

Explanation:

 Generates a big number by multiplying together the ASCII values of the characters in its own source code, then bitwise negates and multiples by 3 just to make it harder. I don't know how you'd possibly solve this one without just intuiting most of the structure out of nowhere.

Stuck
Range ≤ 16
2168925562175809192559478076880588368582100483271088024043828990422001923191680863850623927595547346407714810113472269252167445496071576662478289717285985402906310835521027527551223189006697035136670796256477571739377544867088672367472233527480869967275139523178130025731319312921602024932416527919785339865272904868900012848483524127510716100537641614277573574462059561331647147876433531460016442645381487797364639134320718738374858305349145066235346421701046899192008585135320910686590358334772389749939817058285349456617996640297934416181996318720764083266638429376950594661304355191421796441827251161752628397770607648022218312442466693740602593303954106967643143879967574065179562865748076263514503762459279801408572553675472162386743096082350162062120214037257889728756909022864263379375738597404219166174950739087587328792127529972518158959401032154717619529403824671180089027084802477351400006470562610530999268201921660851034700237833520950293994236369814409915881847765798922163600648362507129799219704206457062827349157730605338819548543898424264022113532228663886032973001113547005761720813159628839520627038518851306849732407639408570749359897756114310076317041643531733090612401595935310458821896104323038853016334166784862248018581435244460900366876040515395441052395548390475535577670850547410979423430298278900620110320897529054942911446633753414917024919919970175026606169419394696679282133474997931378104086175342341496873847171157770912965204251521157297840312816827181319386756339172825611051401958874252691478690491454151253511925877986214195338260183452471566732756149036546096295611336151462030045364499809201812069206288576927495424514214051335116682064781777241395896257305784546830600542533969732797537338559370295863809192816636221714972687740188586708045310477861787585444454638371081424481726478254013214299647094097796582071081153602490233858110112041212790693523888275456000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Self-modifying Brainfuck, Range ≤ 8
Output:
\;*

I've got a 7-byte solution but it stops to read from stdin… :S

@kennytm Try it in the Python interpreter, which handles empty input. (Note that there was a recent commit, but that was a bug fix for relevant code.) You probably found the solution, based on your comment.

It should also be noted that the Python interpreter may be fundamentally different from the others. Try the program of 46 +s in a row, which should print a .. I think the original interpreters have a bug such that dynamic code doesn't work if it's not on the "left half" of the tape.

This is what I've got.

@kennytm That is the correct code, but is it too late since you didn't post before it was safe? I'm not sure how that works.

VBScript (safe) <= 64
Output:
364821338334719204270000000000000000000000000000.000000008
You need to run it with cscript /Nologo whatevername.vbs. I'm counting cscript /Nologo as 15 bytes, the actual program is <=49 bytes.
Now that it's safe:
wscript.echo 36482&FormatNumber(Exp(97),8,,,0)&8

Javascript (Cracked)
range<=64
My code:
 a=7;b=4;c="";for(;a<2000;){a=a+b;c=c+a;}c;

1728 chars

'111519232731353943475155596367717579838791959910310711111511912312713113513914314715115515916316717117517918318719119519920320721121521922322723123523924324725125525926326727127527928328729129529930330731131531932332733133533934334735135535936336737137537938338739139539940340741141541942342743143543944344745145545946346747147547948348749149549950350751151551952352753153553954354755155555956356757157557958358759159559960360761161561962362763163563964364765165565966366767167567968368769169569970370771171571972372773173573974374775175575976376777177577978378779179579980380781181581982382783183583984384785185585986386787187587988388789189589990390791191591992392793193593994394795195595996396797197597998398799199599910031007101110151019102310271031103510391043104710511055105910631067107110751079108310871091109510991103110711111115111911231127113111351139114311471151115511591163116711711175117911831187119111951199120312071211121512191223122712311235123912431247125112551259126312671271127512791283128712911295129913031307131113151319132313271331133513391343134713511355135913631367137113751379138313871391139513991403140714111415141914231427143114351439144314471451145514591463146714711475147914831487149114951499150315071511151515191523152715311535153915431547155115551559156315671571157515791583158715911595159916031607161116151619162316271631163516391643164716511655165916631667167116751679168316871691169516991703170717111715171917231727173117351739174317471751175517591763176717711775177917831787179117951799180318071811181518191823182718311835183918431847185118551859186318671871187518791883188718911895189919031907191119151919192319271931193519391943194719511955195919631967197119751979198319871991199519992003'

Cracked

Hassium (in REPL) <= 32 Bytes
Range <= 32
truefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalsefalsefalsefalsetruefalsefalse

cracked

Python 2.7.2, ≤ 64 bytes
[('__doc__', 'DEBUG'), ('__name__', 'DOTALL'), ('__package__', 'I'), ('acos', 'IGNORECASE'), ('acosh', 'L'), ('asin', 'LOCALE'), ('asinh', 'M'), ('atan', 'MULTILINE'), ('atan2', 'S'), ('atanh', 'Scanner'), ('ceil', 'T'), ('copysign', 'TEMPLATE'), ('cos', 'U'), ('cosh', 'UNICODE'), ('degrees', 'VERBOSE'), ('e', 'X'), ('erf', '_MAXCACHE'), ('erfc', '__all__'), ('exp', '__builtins__'), ('expm1', '__doc__'), ('fabs', '__file__'), ('factorial', '__loader__'), ('floor', '__name__'), ('fmod', '__package__'), ('frexp', '__version__'), ('fsum', '_alphanum'), ('gamma', '_cache'), ('hypot', '_cache_repl'), ('isinf', '_compile'), ('isnan', '_compile_repl'), ('ldexp', '_expand'), ('lgamma', '_pattern_type'), ('log', '_pickle'), ('log10', '_subx'), ('log1p', 'compile'), ('modf', 'copy_reg'), ('pi', 'error'), ('pow', 'escape'), ('radians', 'findall'), ('sin', 'finditer'), ('sinh', 'match'), ('sqrt', 'purge'), ('tan', 'search'), ('tanh', 'split'), ('trunc', 'sre_compile')]

I don't know if this will be easy or hard....

@Sp3000 Done :D

Cracked

I'd never seen dir before, but I think anyone could see it was those two modules zipped together.

Powershell, ≤32
737784469951320029118050726512964156719794212568661655168720201723063235389283340737737814267464712527522846140016193996608429064661058322895893657034047363779079634027206122749152137684815809600182599895126968850669408878865633368185344895726788007432678130501271341728442605939659052374852779038168878407427980536208777811767898710413818785947185492107310928034987987504331382319406385208718840283454519601991959588878312550832315559921741591462280462948210386638061027843572023905437190100575987108524263909897885390736696917742316692409543025098600783974409744538115150523233950428962729802998336121720376672897228124096198982959715942250190149495981316652644361050065748827684252694810369927154522179963798781033591811

Matlab, <=64
The desired output is
ans =

     9
     9
     9
    10
    10
    12
    13
    15
    15
    15
    15
    13
    11
     8
     5
     2
    -1
    -4
    -7
    -9
   -11
   -12
   -12
   -12
   -11
    -9
    -8
    -6
    -3
    -1
     1
     3
     6
     8
     9
    10
    11
    11
    11
    10
     8
     7
     5
     3
     1
    -1
    -3
    -5
    -7
    -9
   -10
   -10
   -10
   -10
    -9
    -8
    -6
    -4
    -2
     0
     1
     3
     5
     7
     8
     9
    10
    10
     9
     9
     7
     6
     4
     3
     2
     0
     0

Good luck, robbers. Maybe there's a solution for octave but the one I have in mind does not work for octave.
Tested for Matlab R2009a and R2015a, but I think all fairly new Matlabs should give the same.

JavaScript ES6, ≤64, (Safe)
Output (377 bytes):
8713370611242731842302768403441017430132011165981526145517926807202299880256290214031488282511181647338813342970322431043762227838853600373724704524160049611722180653681845NaNNaNNaNNaNNaNNaN4940323333485005257626222668708025806893266675605952299071946499761627602800859131688906303445754712870133544819968037268118863281489690576296578800898958501055636801125338543990117123977

REPL, tested this in the Firefox 41.0.1 console.
Original
(x=_=>[...x+q+x].map((y,z)=>q+=y.charCodeAt(y)*z))(q='871337');q

Ruby <= 32 (SAFE)
"8762504450324893848651280721691835717940669000462575484369396210258048929833970016297166254385132205202235180295079454023977826406979481295799194841934758121726118165990323332304568746264850532094544184088081482476162966282924240706855704443909297279711527256266149302299801021814740563741586350307136169051997209078653010929909330725a93586825476403753528022538421975387929896553841882810474799363453046018606169377669906563915966214068307559446990614728199972565468028975641938881008153501071577230002720943376a301775966920319271087407600489642777663287722163559579935799452303905473803281788975270137361183607848516570173259033490012009540073087632403050024902293445141468992599827814385979797481372233782966926361021702340409774146157255606565210355513797874130438807686870391470600158424066431303063375213722764844392000554833276485799316866946004195323665470580216216002583900494820220735082842592105660387965775910979959250091077095653612102696221426415a648773018022294769993224545803577a3763005527251908295636358910010513363179690021387446604533222751642813a8614089268a28012273422320162366569989922699128895234357942164566077868a49814885873137022055353a9846964630645022047290930125568794081376438232094470701310117203087247248634417152203131200635901456134613462592550208341287080896325568191584605164462850564148180507a062259043076691876231279478133327773460196580784756838442111201274379859744276598757985720380892316934394451373863238543152514271552134a04282987903a61885941443856a1713313317735297699830794002789480581428834630930216199054175159184988994760007300a79656926139784321218328804337480388158663865713a59654331635998377274152630834636272411578533575176582007320a703361775217144466335735439372357821466633028157921828931151a50a479279208a9016419708326819702203778835911523016342458872497769621161340668800a410301953081688442694810179113277816543124401448721857324972408282507447735612726405995653404a909146345587007109536191051a58398126a72597728470093a32078324098a634a2571552088a5057083729347915385829431416171"

source code:

p((691**723).to_s.gsub /67/,'a')

BrainF***, <=64 bytes (cracked)
Not the most interesting, but
(P<RTVXZ\^`bdfh

That was fast.

Cracked

Python, safe
Output (2015 bytes)
['2', '1', '0', '5', '6', '6', '6', '4', '8', '5', '5', '9', '9', '5', '4', '1', '4', '2', '8', '6', '5', '0', '5', '2', '3', '5', '0', '0', '3', '0', '7', '9', '8', '8', '0', '3', '9', '2', '7', '2', '4', '2', '1', '4', '4', '3', '0', '8', '8', '6', '7', '0', '0', '8', '9', '5', '7', '2', '0', '0', '3', '9', '2', '2', '6', '6', '3', '2', '9', '0', '9', '8', '0', '2', '2', '1', '0', '7', '8', '2', '0', '9', '2', '5', '0', '5', '6', '9', '4', '2', '6', '4', '4', '4', '7', '7', '4', '9', '3', '3', '1', '6', '4', '9', '8', '3', '2', '4', '0', '7', '9', '9', '6', '8', '5', '7', '6', '3', '1', '0', '2', '2', '0', '0', '8', '6', '7', '2', '0', '2', '8', '4', '1', '5', '3', '5', '1', '4', '0', '9', '5', '7', '3', '1', '4', '2', '8', '1', '6', '6', '6', '4', '6', '5', '1', '4', '2', '7', '9', '0', '7', '2', '7', '8', '2', '8', '5', '1', '9', '5', '7', '2', '6', '7', '9', '9', '7', '6', '6', '2', '9', '4', '5', '4', '4', '3', '3', '8', '5', '7', '4', '3', '7', '0', '1', '2', '3', '9', '1', '9', '2', '0', '8', '3', '7', '4', '9', '6', '3', '1', '4', '3', '2', '2', '9', '2', '7', '1', '7', '0', '8', '7', '3', '8', '2', '5', '6', '7', '1', '1', '4', '2', '0', '8', '3', '7', '9', '9', '2', '3', '1', '5', '8', '2', '2', '0', '4', '5', '6', '7', '0', '4', '8', '0', '0', '2', '8', '5', '1', '9', '0', '0', '6', '8', '3', '9', '4', '0', '6', '5', '1', '2', '3', '1', '0', '8', '2', '9', '3', '9', '2', '3', '6', '2', '9', '9', '8', '6', '7', '0', '8', '6', '9', '9', '9', '8', '9', '6', '7', '2', '8', '9', '1', '3', '6', '6', '6', '8', '3', '5', '8', '2', '3', '1', '0', '7', '1', '6', '5', '8', '8', '0', '1', '4', '1', '6', '9', '4', '4', '7', '6', '9', '8', '8', '4', '3', '7', '8', '1', '3', '4', '0', '4', '3', '9', '2', '6', '9', '2', '4', '4', '9', '4', '1', '7', '1', '8', '8', '8', '3', '9', '1', '9', '3', '6', '8', '6', '4', '7', '1', '0', '1', '6', '0', '5', '3', '2', '6', '2', '2', '4', '0', '7', '3', '5', '8', '1', '8', '8', '7', '9', '5', '1', '9', '2', '2', '3', '4', '7', '0', '2', '6', '0']

Range: ≤64

Hint: My username might be helpful.

Code (60 bytes)
x=[]
for i in range(1,413):a=str(612**i);b=a[i];x+=b
print x

Python 2 (cracked by squeamish ossifrage), <=8
REPL
Output length is 2046.
56550386206054179162548017357607166877326950157664759075921413859637041669397059681541931877422025121256788162836088400165033570974119696468335773652909254170330164377894800079257448666099053623206382697492451971760308547104958445589133157534777018043222127988543134876613452644704759850800936953205799738580016218889332182571623100055512417089783688065420823946457447594057718076032062898420133153467680257337358757150883870017232039191113861064919471545198711249108334255880207361486470544933750513180321632870834623132014404230986442204021966286334790249690741298778020546006176853434874601354960441467281577522093672430442856498028744124837473118164554869017072520440299226812773762068658400830262998001716850918674872669415380486313573200129613863355262257158696796087045613414583091894739323523709977587718522979510033421977733039154028181774672291102216470928498134839523151867827533967685385583389265733951307766014557736071050412272700000103138880805368839091740333390987466511809550838391378366574471719695948662339861388921818773728641697498792389618912829421094414564430826315967252640705705355391466857707622261190415246891280358843190401958361815778174180433530772080212964467648374588450674577417599834611349560139046137965819475062392481412174008594126549402584696723064027103502213048689091863760516875594296477732290230660754619325574528925864460015063065896945372537214280443927053569172825326507421669896657133555074443620641276881241217748151235083009869241666409832403942898680315660811127286016399084677133462114944027018181198398191927537951299035483303847446935764723186489934280278507733148435577278184213066712159513578759803166554108576576748496080383180419238128895009010884863992209222313446817580767730125367184154002259324355017866013660533117830098852606050615247069229459748111343694655472797803674736940470112637452103829080400421952083750514134227202873323995964355616668906593351764656337351039360744044462509483339108670069907548847453283420832912274710222330634420141536739170107264032313922007829323371963L

Cracked

At least someone's trying to crack this stuff

Perl 5, SAFE, ≤32
Output:
85547195679171218736754503308731233555306328355775132346594959288367525592463131145153231485115872151324349953315183233154032535217535312775505540353147384384345753951213930993267528310951923507543975483255319544192079237930337715655555944071935651227146835247663241573532795427282356315271951195247514555671263393919951371523551968727034191501936033639407135793351615183951755475339911913075297918275031374753672103266737595511383169928472433051269140473291557145513663435913595091446726553615378357991611243910231059149199977137114935259528958194287495399492324511167278751995763117929311251379526733394715787146771129911971108317794455251118875751103512033219470755354119415545874095386711312355569131539151707359134952343554742632072619318342753514347121533637593567320745633807411506741794875187556074983317141314299639212729551539157520071515128742275451311134111335480310119155439296716833303571560316953447176743117833855987627198312273507248715992295497130272403591155117193735522337546354671510346114383164728715318314431222341074011285938747797233135369947918674863173138791275408337235079432392755834695539123914475499368746474815115526433471205520912523203118034743291362739271851531915271431279348321993819555111922113963228348271299437115031143249917434023300321152811548735432919110720672235425157398915151518756195127489921633387104713474947273946234527337590352951239365142155307138353792247439517914599423955954839144342352112312907963339420351635331167131593987257126073039254723195259807414344432367159204319477953999271543351071163527274479279953431815488720191659301522594539351926313327327405934351623258327514767579140756675703459564354152679390315631863546332555139504338911419

(1703 bytes)
Code:

print($==$=*12+135)while $=%=473

PBASIC (safe)
Range: <= 32
String: 000000184066073CB303FC6A6B901CFC14844C3543BA023499B966F6E05707C0
Code:
t VAR Byte
c VAR Word
FOR c=2016 TO 2048
  READ c, t
  DEBUG HEX2 t
NEXT
END

This is kind of a quine. In BS2, the program code is always encoded at the end of the EEPROM. So, what this does is reads 32 bytes between 2016 and 2048, which happens to correspond with where this program is stored.
(note that this was run on a regular BS2, it may not work on the BS2e or similar)
The big guns.
This is not a math op. I will give a hint in a day.
Hint: 16% of people in the world cannot do this.

Javascript ES6 (in REPL), <=16 bytes
"0.7146314631463146323"

js for the lulz
EDIT: Here's what I had

 .9.toString(8)+3

cracked

well dang, your solution is way easier than what I was coming up with. I should've put my first thought "0.111001100110011001100110011001100110011001100110011013"

bc, ≤16 bytes (safe)
283657696154934170362301055758600650791598269398973436504

<EvilGrin> Have fun with this one :-) </EvilGrin>

Original code:
OK, this was horrible. I'm sorry.
21^48/88-46^37

15 bytes, including the (required) newline at the end.

Go, safe, <= 128
The solution is a function that returns a string
Output (192 Bytes, the first one is a space):
 Er`I=a3ESiqO3v59:cdx5P1F]CN?%p[.AB.R"3X_KPTlV*iX_Pa_Tj@&09f&J"3MF,dozs1,HT!9eq0]M;xHz9jZq\B^iiAbXv>g=TuPhAJVT"T@tJfp5dsQ..oQB$C77`PfyIU~W"f']`=qve,nY,`~"aLmI4&s)K4h3':{/0,\@sVLq{{(r}]!RXR{((h

Solution
func g()(r string){
for i:=0;i<192;i++{v:=(((i*i*i*i*i*13-i*17)^(i*i*i*i-7*i*i*i+9*i*i-42*i))%95+95)%95+32
r+=string(v)}
return}

Javascript ≤ 32 bytes (Cracked)
Output to broswer console:
3.7376696182833684

I think this should be an easy one to crack :)

I think so too :o)  Cracked

@squeamishossifrage Hehe, I thought I want to do something simple with 42 as a joke (cause 42 is the answer to everything xD)

You should probably try searching WolframAlpha for your number before creating a cop post with it. The answer comes up right away.

CJam, ≤16 (safe)
354341221131.2923xyz

The code to generate that constant has 11 bytes. So I padded it with "xyz".
Original code:
PsKmesPser"xyz"

Actually golfed a byte from my original code.

Python
Output (642 bytes)
PPJRRE5SGGZJNZ6542MDZ0P63OFSMAV9H4HIVS211G8DNP9HCG8PZ80OXG1M4Z3G9IY7KM7ABJGZU6FDEFZ08WUONX12Z7NDZ0ARJIQUY17BUPO9LL4L5KFXQ3OW7GZ1228FXLLQTN5QCKVAFTO3D1PPBUY04D3ZCX3GH197UHZZKML7RWYFSBDJ3PM4H1009P5OHCZDM445PN0XA0KS9J40XS66UBNLE57X4YK0N1JUGG1QMWBU7RDH3USR67103NKNRO7YLKGCZ4GQHHHRBFCYCR7ZT5NS3WGTFNZV28OTWDE90B5UFO7U971O9MUS64VM2KM9Y4QB4HSN3N7ATROYL91EZT7OMJRG4RJU3MJVMPIRK6P77YWMXYMJCP4CERYR8ZOKR0QM6HJATFKTB9LG4WFBO24JVCEFS1ZJJTTIDBG0KTKKQ6S4FTTHI3JALK3STUDSSHL4605BVD0ZLQQ2DP07SH4E2UR7WS2DJRQ208FWCSQVQD4AXHSN7XWLASSERZMKOUXIX1SF7X4PF1LACIWBAGSPPR27CRQRDMGARR0YO0UQBSZ5CLVOPS2XY6N4Q0XM2Y4GH14C33U5G5J91Q4MOY8T3LZXO0L2PV6CK38RX04O7D5P6HNUTI2OXS

Range: ≤128

JavaScript, <=128
00358012905283655489681387343300226018309644130198260362721217094368488629994183590404114634239030553340577380700872201285119607788269124090823224360240193030803441349394723769282028569486430598787732717975019287728045155681160827279417346882416366135233161036698992604037049921949576723174944317111248204247049344351065178858829108731386362946563383737536326578078307362139981510824831845157219855804180793331892951977648790192144176446779637889945745179861103177267732169838447699101733367140795166477309527566921776354116556874970994340296441999477262815207718575097792124932847544962329445029141725463959033334260685824908474246704754802564783554165481524736423172709116794248364244586705999633058007798098332961412148731293303098179320921686978844245876697106606140568511730167487075252802104722975722646948940431590046859140943772126995315164357373334023484623029041724973481860693349391241460673665283664982738940557852863459316494285630822001663688764295910547169827240733550572529028567149028288669014271873567055995909615886243657162561111928500355946204316377505823894613678400884985233379281376397009921605127999892895750232950580210601932634603550162958693809260186624823850035456344096946392718695737536090762940491445189058460092376590329085766025273318075492759399744890292473420918371908385365150647502346180700840743486857589613318381345431850366526750179559657924663761015050227717528227556759816034980118051710382546156346747168679955551000533040609007788295740534384139573930944535893817362805990049284615329006400177479800499237213122612446840255782531513783630128583477004504177603180295784023844482078824939304925562889362636235301267113079934878387328567250130540814163709550788100595819650552271951336547808439542035000323703187263685818399760265227067797449302365339301139401093461461348866259841184270441908662733190853780689217452971238980692788822239251210320922127026630058291126644641906287260701388645158453092211553352831331266547505242978593018522814984718097697386851769976859263553375174403608111276407847927851

Output is 2048 bytes long.
This can be run in a browser and technically, when displayed, is surrounded by double quote marks. If that matters, shorten the output by 2 characters and add the quote marks.

Pyth, ≤8
41399754779690003073371865173

JavaScript, <=64
03466173801382013789090660287448084493755385432904982701050819994023780746035686706133611397893912853448991234305968272236477255727750157264016581090452025318476827471517482641864298121921289100585287388607442471878084935976649145036258648418413512666378145035800499922141984040717234397066591259492288326797804458255492874144952750047517452460147058619845424121247675620660733796233368720776034326362404794096634990164187345109949632290860517091770178113706461155145849636589065576781880641359836411760433902860336499810544243493912847452654493738201049327740264853969293929643966064027384885027194273808571014687803202049618801848303866801088592205340851282716051401144985791869047648726249487066847062548046369522854704087357799137237296731575514243513153579969851218003458027583365890865480244972230149605955753306762281021433821362647152457963086417205517324329127881287435675500435398965125557412644572316918702989215148190258444853371306431221182792036830306229972280715627421037633928881549951414764323338056907886229655549041269370463046487498514202352014795938421531313708858717904046307514199063026871499467395586069140243098366061446677108808301023099042039813004758930261276824462573614237406373259928082013303879606006089230435646012950259361222471908557806441215765421371843705727292053606341365590298522105608031744816162974333782078294681240184266489790333272582342198769582221563148276493810942870296904347800253901349102373330199357244918654760704713108993921551197485181351378162333277631045913408250977346252456096664365019635066713660893522173173496581143580328416349072963533050509728325370890079848468846551267997747954103432096372483412291118712612112465098600441803610014556687614321579644849155767610321827981798065046437930485381438233224600533288107710186090741130528323909147839757032751604707360414108342114067506933674596630261886079193622617656360272029373853948763996282094845323942766707480331950162921564490471880226270072182407764889652195408836851393705896998046436953814131340893804741979319883552549158094418

Output: 2048 characters long.
This can be run in a browser and technically, when displayed, is surrounded by double quote marks. If that matters, shorten the output by 2 characters and add the quote marks.

Python 2, ≤ 32 (SAFE)
Done in a REPL.
'xr<oane0p   ej xtr>gbtecxr<oane'

33 bytes of output >:D
Solution:

(9*`(i for i in[])`[9:~7])[::-7]

# `(i for i in[])` results in: "<generator object <genexpr> at 0x24d1680>"
# (or some other address)
# Yes, it is deterministic. I sliced off the memory address of the generator expression, along with the beginning.
# Then, I copy it 9 times and take every 7th char in reverse.

Regarding your comment from here, yes __doc__ was my thought. However, docs depend a lot on the specific minor version, so I never posted a cop with one myself. Having said that, if this does use __docs__ it'd be good to mention the minor version, although that'd probably give a few things away...

@Sp3000 It does not depend on a minor version, and I would expect it to work in all versions of Python 2.

Sigh. I just deleted my solution for good, then realized I hadn't posted it yet... I roughly know what it was at least... ugh.

Oh man, I am so lucky. Following my same train of thought got me the solution quickly.

Pip, <= 8 (safe)
Here's one that doesn't involve math:
?:\ \!\"\#\$\%\&\'\(\)\*\+\,\-\.\/0123456789\:\;\<\=\>\?\@ABCDEFGHIJKLMNOPQRSTUVWXYZ\[\\\]\^_\`abcdefghijklmnopqrstuvwxyz\{\|\}\~

Original code:
TMST XPA

Runs of three or more uppercase letters in Pip are broken up into groups of two, so the code scans as follows: TM ST X PA.

PA is a built-in variable that contains all Printable ASCII characters.
Unary X converts to a Pattern (regex) object. This does two things: first, it escapes all characters except letters, numbers, and underscore with backslashes; second, it wraps the whole thing in a non-capturing group (?:...).
ST converts back to a string.
TM is the trim operator, which removes characters from the beginning and end of a string. The binary version allows you to specify how many characters to trim from each end. But this is the unary version, which defaults to trimming one character from each end (here, the parentheses).

The result is then auto-printed.

Really? What are these then?_________⤴ (Seriously though — yes, this does make a change.)

@squeamishossifrage Edited to please your pedantry. ;^)

LOLCODE, <= 4, Cracked by Dennis
Output:
Segmentation fault (core dumped)

(I'm not expecting this to last 12 hours, to be honest.)
Edit: I realise now, this only works (as far as I know) in the official LOLCODE interpreter, justinmeza/lci and not in any of the online (javascript) ones.

I think you'll find that system errors are sent to stderr, not stdout.

For the purposes of this (and since I saw someone else use errortext), isn't stderr that gets piped to my terminal effectively the same as stdout?

Cracked.

CJam
Output (159 bytes)
217678233699230376274200601762191423470860646690253440687035259813072286171793618200693120655662580549470021092321494014584619026229869771791471554564431282176

Range: ≤8

Cracked.

dc (safe)
Range: <= 16
String:
199339092276008550131431539990658277331606397580853212910052122692972\
774962270058161510083607537469850717483606016495688567362868528504839\
312086200313771395859886273237465478825785462016628857818060996698109\
508463277753877223995999366056374895546219988417085601908866077450569\
127028454771902535032787281691702048189967745290542.733647326

Code: 9k567v237^p

gs2 (cracked by squeamish ossifrage)
Range: <= 8
155302392568755602954703791645117509171853024379829526053941914979869764308014137101580853703257316967419024475301219529235426499580989700492471117592130679578703743169643269465601721348541513593756461576285693343335323948307757460714948112300799739460308904920802096954409942913408096419432033412736062772643941590080446853373252364634969631941189995619518198884520714851905373673786301803818992437528114546902893524109693619934375650827402974283364443639166789257783558287754544152762072425073758073874087673853749491025245350759370202288198641756277483105286855126452445186433581045273785395216218774302137457946970241887040423778769507844532372395126914334350410060838193463467701758259122737262877689997254446028894627441507215258630083149823214021914691630385344730360124370246246101179225617171359948255502820724998630578414563433771734039885865200126640849581418101617590256731549974180011798541810287432442790284651150068406362365126351529058374781998017317605130002324359837801578063898318531549204801679097327112281643491227164405147112572736443606882046580363487549058621262011237393353206539463047834322740801769791931408446565925701470542859326548992533299683757135685782623491909977496699208378601007696438296190884956558923555954397532301018024430186240362810108284785909687389090161977695156919530083589605517157247030242165705875087062283656720276403790904286872963087972571265678945386772020563763263215540821764049192071134806571089438720182703434060588593593872862671044732442467813100983236427776

Code:
Hexdump: 12 17 2F 08 3E 09 33
Mnemonics: 2 7 range1 { pow } each

Does this program consist entirely of printable ASCII? The maths is easy enough on this one, but I can't find a way of entering numbers without using non-ASCII characters.

I believe that's no longer a requirement (just that the string must consist of ASCII characters).

Also have you seriously cracked it already? I mean I made it so that it wasn't impossible but I'm just kinda surprised...

"The printed string must consist of only printable ASCII characters (new lines can be included" — that means you can only use ASCII \x20–\x7e and \x0a. Factorizing this number is trivial (it's a prime number raised to the power of a factorial)

Right that's the actual output. That has nothing to do with the program.

Oh right. Yes I'm talking nonsense. Disregard all that

Not a problem. The rules have changed a lot recently :)

Cracked

AppleScript, <= 16 Cracked
I have never made a code so obfuscated in AppleScript before.
Output:
8:9: execution error: Can’t make {true, false} into type number, date or text. (-1700)
(redirection of 2>&1 was used and counted in the byte count, counting the space as well)
The 8:9: bit WILL from execution environment to execution environment. Just needs to be noted. When I tested it a second time, it had changed to 10:11:, so don't let that part of the output mess with you. c:

Cracked

Java, <= 128
13101310913101310131091310131013101310131013109131013101310131032321310131013101310913109131099131099932131099932131099131099131099131099131099131099131099131091310131013101310131091310999131099131013101310913109131091310131091310323232329131032323232323232321310323232323232323291310323232323232323232323232131032323232323232321310913109131060336879678489806932728477763280856676736732344547478751674747688468327284777632524648493284114971101151051161051111109710847476978343234104116116112584747119119119461195146111114103478482471041161091085247108111111115101461001161003462131060104116109108321089711010361341011104585833432120109108581089711010361341011104585833462131013106010410197100621310601091011169732104116116112451011131171051186134991111101161011101164511612111210134329911111011610111011661341161011201164710411610910859329910497114115101116618584704556344762131060109101116973211097109101613476971101031179710310134329911111011610111011661341011104585833447621310601091011169732110971091016134827966798483343299111110116101110116613473786869884470797676798734476213101310601161051161081016210697118974699111109583274971189732433289111117604711610511610810162131013109601091011169732110971091016134100101115991141051121161051111103432991111101161011101166134344762131096010910111697321109710910161341071011211191111141001153432991111101161011101166134106971189744321001111191101081119710011544321151111021161199711410134476213101310131060109101116973211097109101613410097116101343299111110116101110116613450484953454850454948344762101310131013101310131091310131013101310131091310321310131013106010810511010732114101108613411511612110810111510410110111634321041141011026134471039747991151154711599114101101110469911511534321161211121016134116101120116479911511534321091011001059761341159911410110111034329910497114115101116613411711610245563447621310601081051101073211410110861341151161211081011151041011011163432104114101102613447103974799115115471121141051101164699115115343211612111210161341161011201164799115115343210910110010597

Length: 2048
Good luck with this one. A couple notes (hints?) about the function used:

java.lang.Closeable was the functional interface used for the lambda expression.
The program relies on http://java.com for its output. Even so, I'm fairly certain that the output will not change anytime soon.

Python
Range <= 16
'.eoual ftj(er,eetrnr ph'

To be run in interactive mode.

Which version of Python?

@Mauris any (sorry for answering your doubt after a week :) )

CJam (safe)
Range: <= 8
Code: 52 86#~
String:
-3769533025519801141444612600471707145120923043935146475096303581721089749532607198879063741123420792669738910020570009227839890520497940913522212865

 VBA
 Range <= 32
Output
-2147483625

 Fun Fact: You can't Output in less then 16 bytes with VBA so this is the lowest class you can enter! I'm Sure this will be easy but I wanted to get something in the lowest possible Catagory for this Language

Where is this being output to?

The 2 different places that seem to be accepted as SDOUT for vba that I use are debug.print and messagebox. Both have different limitations to what/how the output.

Cracked ?

Python3 <= 64
Output: (2048 bytes) [contains a leading newline+space]
["[''", " ''", " '506'", " '2100844'", " '16480885768015478006134261'", " '31'", " '51231064846783567164130'", " '658'", " ''", " '373251426066'", " '0024374'", " '38'", " '887770'", " '1152843762281757078500'", " '423382'", " '785'", " '05438367603'", " '567564'", " '5303820606723374556206653'", " ''", " '44268'", " '88848667402548'", " '7174'", " '316'", " '306'", " ''", " '32'", " '853287'", " ''", " '5456'", " '6816008713205300041141531'", " '825'", " '76775'", " ''", " '545744'", " '83831'", " '2'", " '50421844620533737'", " '10152874572'", " '172'", " '668404688425061364680351'", " '845681'", " '37064070604810'"," '80'", " '4503'", " '7174453542130084662522727424383'", " ''", " '163125818'", " '26235757161487074433'", " '3433'", " ''", " '50511264748182'", " '5'", " '141576'", " '17'", " '7842335331482816'", " '0476674000'", " '425'", " '632632114258277'", " ''", " '22750381646086'", " '305030'", " '65'", " '5470444856387302712'", " '241145634858'", " '463'", " '42476803865'", " ''", " '13'", " '076'", " '8470'", " '854'", " '0344742'", " '61710278451047182564725'", " '5'", " '775'", " '17406521743617037663'", " '276202103'", " '8116413802'", " '51314465751'", " '52'", " '1'", " '22220'", " '888754384182'", " '3'", " '52836216418812853'", " '650361012'", " '112886663785'", " '7107'", " '047605'", " ''", " '02667'", " '188'", " '40584682045865342463662230'", " ''", " '322610688'", " '03'", " '705455'", " '446822'", " '82778633614610542447738587614445361428447386630305'", " ''", " '015403786'", " '106350626864643072234'", " ''", " ''", " '68872'", " '0625373650345'", " '83522283151523347525'", " '0624'", " ''", " '80'", " '65'", " '4568'", " '44436666612024335084654048550'", " '0'", " '841162'", " '468272'", " '808418278561140'", " '7876460'", " '74'", " '156458528033241'", " ''", " ''", " '6238'", " '4062330115717'", " '36'", " '44253041385'", " '7178'", " '063'", " '6458'", " '6'", " '621308376514372046'", " '138006421426205'", " '4201'", " '677704737'", " '65185344857310527713'", " '112434'", " '4355103

Python3 <= 32
Output: (2044 bytes)
['35629008113313067636835628350892', '303090550382', '382510656', '0', '12', '98917522299926', '137283', '386083871359278870685', '191325258786013', '69', '702628960091270', '9680', '3', '789', '62987198082992568711182568985', '7383', '2', '961820028892922056', '', '55910', '5', '1270', '98167352', '8801', '53868', '', '1537', '0681318075', '39868850', '280', '625', '88109906657915173110951', '273', '03511397768', '673', '927875717', '75829953783710259666936638967265577588770317733258336', '153', '516650', '3710', '95995', '77580893911', '9099239663159822396138768811239', '386', '2017879013510390', '86619699065875232795', '521879', '56911', '3198803', '951132391', '0997897', '626', '62236251923', '05066', '537', '13717309887895', '195069062965521', '57939', '3', '50376916612802967926098', '90791', '8178669692776880339308801890992619251957', '03812', '1871327921659198980711', '52635832176863626979', '', '2378139868', '509', '76', '360', '6133107', '57', '1', '819', '0673896', '10181', '2', '3760986203123', '1553056', '892', '2', '21216800311', '931509651', '5778', '85160', '2868810712906093959', '78', '33959186650623532562665305', '20', '560582300625888182072839396', '608092253786296', '08378865665599770130273683051519933', '32738172163006197', '5372', '85', '3063225609522398736', '6357988', '966356029109321501582953761833705', '8', '52109797059265572736551068263857859', '8', '90', '256759083233180186756987093270662365', '191099', '', '390', '1869015', '0719338193', '786331381796777925855608', '1187', '30', '811', '312', '35283779919700302109018721998572115390687', '1', '58113', '21508113000', '8525', '', '333198576', '05180', '072', '2033593510190', '68586265', '18657285682325', '', '02171225975028293', '32075152', '72606', '55053759', '', '757330833', '6978591', '69189681', '099225', '79368', '6', '250889083606', '212803600913136137785', '060362519', '70', '3', '788082786820', '220159805', '1860077138960020', '7551339892', '5', '', '3', '5776870513', '71270589678751875385', '270600', '6', '213236', '71001']

QBasic, <= 8 bytes (cracked by Mauris)
 8.851656E-03

Note the leading and trailing space.

Cracked.

QBasic, <= 16 bytes (cracked by Mauris)
"""

Yes, the output is shorter than the program. However, double quotes in QBasic are not trivial to output.

... Although there's more than one way to do it, it seems. Original code:
WRITE CHR$(34)

Should've done my original idea, which was ?"hi";:WRITE"hi" (for an output of hi"hi").

Cracked.

J, ≤4, cracked by randomra
0.000198413

(Blah blah blah blah blah. This is filler.)

Cracked

Pyth (safe)
Range: <= 16
Code: t_^745 342
String:
-18942848238846702000737756659973646779942967140220283256962974873234094651015038671495143989847386729680241862830119337956348747334505435496991960150131121034551982157083906586221042363353408334866251481833877575640325738380374503079168022891195104162339647595360613089361593444499080793276621647497053117734633055201755474710367919777029494004364776004138911600868453848171287452776512163863332098477484323757171405610690850019500967579254668662471619927914605780575892617912202737962562003554708579864138719448663400302560158574168412816418523381065735351001346267376142327158208030285036103491585408755540424848706251111628495962962429658113888676624984684325316931016006142566504870367481109174441236965833636556838972881583460166402936459951922530197633841563299276495092457476011321253117768971252551660133748392634552348895709075329070905022753303255226600059226372955583706070513126272846148280496645228763942426652598925307055362427834099836587711251922883093357086181640626

Retina, <= 64
As usual, this is multiple files with +1 byte counted for each file after the first. 1013 bytes of output:
itreinareinareinareinareiareinareiareinareiiareinareiiareinareiiiareinareiiiareintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinareitreinareiitreinareiitreinareiiitreinareiiitreintreintreinareitreinare

Javascript (Console) <= 128 Bytes
"xkvybybmhMxknadytmxadgjupalybuxsnqbEhehsnepcfsvqlqbehknytsdqtMpkfufililwrwhuxknidufilorCxitgjcfavwhknknytkvilybwrCnqtwzkfepcfybwrepsvsvgbgrEhuxsncnqtwzkfqborknidgruxUxidufsvilgbkvybehsnmxkngjEzozcfcfqlqborehcxkvybehsnYjwzsvqlmxadadojalybormhozCfilwrqborknidqbehehsnsdqtGjezaloruxidozmpilgbepsvsvGbsdqtgjezepsvybmhgrehadytItwzwzkfkvilybwraloruxidozMpilgbcnqtqtezqborehcxitwzCfqlkvilehcxkvybybmhmxknadYtqbehknytepcfybwrufililwrItgjwzupyjmpsvgbalybuxsncnQtqtezepcfsvqlcnqtwzkfqborKnidepsvsvgbsdqtgjezgruxadOjitgjcfavitwzwzkfkvilybwrKvybehsnyjwzsvqlozcfcfqlcnAdqtojozcfilwrqborknidsdgjGjupufsvilgbitwzcfqlwhuxqtOjkvybybmhyjwzmpkfqbehknytSdqtmpkfsdgjgjupufsvilgbqbEhknytepcfybwrufililwritgjWzupyjmpsvgbalybuxsncnqtqtEzepcfsvqlitwzcfqlwhuxqtojKvybybmhyjwzmpkfmxadgjupozMpilgbozcfcfqlqborehcxyjmpSvgbmxkngjezcnqtqtezqborehCxcnqtwzkfepcfybwrgruxuxidItgjwzupozcfilwrcnadwzupqbEhehsnepcfsvqlwhknqtezyjwzSvqlyjmpmpavalybormhepsvybMhsdqtmpkfitwzwzkfwhuxknidMxadgjupozmpilgbqbehehsnsdQtgjezaloruxidozmpilgbcnqtQtezqborehcxepsvybmhgrehadYtgruxuxiditgjwzupitwzcfqlWhuxqtojmxadadojalybormhmxAdgjupozmpilgbqbehehsnsdqtGjezqbehknytepcfybwrsdgjgjUpgrehuxsnyjmpsvgbalybuxsnAlororcxcnadqtojyjmpsvgbmxKngjezcnqtqtezqborehcxgruxAdojitgjcfavkvybybmhmxknadYtmxadgjupalybuxsnozcfcfqlCnadqtojqbehknytsdqtmpkfsdGjgjupufsvilgbcnqtwzkfqborKnidgruxuxidufsvilgbgruxadOjitgjcfavkvybybmhmxknadytCnqtwzkfqborknidepsvsvgbsdQtgjezkvybehsnmxkngjezmxadAdojozmpcfavsdgjmpavgrehadYtwhknknytkvilybwraloruxidCnadwzupepsvsvgbgrehuxsnyjMpsvgbmxkngjezalororcxozmpCfavcnqtwzkfepcfybwrepsvsvGbgrehuxsngruxadojufsvormhKvybybmhyjwzmpkfkvybehsnmxKngjezozcfcfqlqborehcxepsvYbmhsdqtmpkfgruxuxidufsvilGbmxadgjupozmpilgbozcfcfqlQborehcxmxadgjupalybuxsnqbEhehsnepcfsvqlufilorcxwhuxQtojyjmpmpavalybormhkvybehSnyjwzsvqlmxadadojalybormhOzcfilwrqborknidqbehehsnsdQtgjezaloruxidozmpilgbepsvSvgbsdqtgjezepsvybmhgrehadYtitwzwzkfkvilybwrqbehknytEpcfybwrsdgjgjupgrehuxsnyjMpsvgbalybuxsnalororcxcnadQtojgruxadojufsvormhkvybybMhyjwzmpkfozcfilwrqborknidSdgjgjupufsvil"

Python 3 - 32 bytes, Cracked
9511667971998764582180733448500755
REPL output.

Cracked.

APL (safe)
Range: ≤16
ADGJMPSVBEHKNQTZCFILORUWXY

Code:
⎕AV[65+⍒9|7*⍳26]

It is obvious that the formula must have the form ⎕AV[65+⍒???????]
where ??????? is sorted downwards by the permutation
1 4 7 10 13 16 19 22 2 5 8 11 14 17 20 26 3 6 9 12 15 18 21 23 24 25

for example, ??????? might be
"dcbdcbdcbdcbdcbdcbdcbdaaac"

but coding that in 7 bytes seems to be impossible.
The solution has ??????? equal to
7 4 1 7 4 1 7 4 1 7 4 1 7 4 1 7 4 1 7 4 1 7 0 0 0 4

The 7 4 1 pattern eventually fails because IEEE double precision
is no longer adequate to represent the correct integers.

Insomnia, ≤ 16 (Safe)
nhahtdh

Interpreter@StackSnippet
This should be easier to crack than the other challenge. Command 8 and 9 are not used, but you are free to implement your own interpreter. I don't think they are useful in this case.
Solution
opot~dFjyf=jdLt

Similar to the other answer, it's a machine generated program, so it's optimal or near optimal. For this challenge, the most optimal solution my program could find has 15 bytes, which was intended to make the challenge a slight bit easier, but it seems that no one bothered to crack it.

TI-BASIC, ≤2 bytes, Cracked by Thomas Kwa
.1308996939

Maybe I can get out of the negatives...

Is this in Radian or Degree mode?

@Mauris Radian mode.

Just fyi: new posts aren't scored since the challenge is closed as of Nov. 1.

Well, it's π/24. Now to figure out how to get that in 2 bytes.

@mbomb007 Thanks :) I know

@Eridan Best of luck. My friend showed this to me and made me figure it out myself. That's why the answer is late. XD

Cracked

Pyth, <= 64 bytes
01111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110111010111011111010111110111010111110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011111010111011111010111110111010111011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101110111110111010111110101110111110101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111101011111011101011111010111011111011101011101111101011111011101011101111101110101111101011101111101110101110111110101111101110101111101011101111101011111011101011101111101110101111101011101111100

That's exactly 2048 bytes :D

JavaScript, <=64 bytes
Output: 2038 bytes
00NaN573100360487769457310036048776940NaN266247541047714640NaN65254190216760520NaN34568908272755050NaN038836263287495790NaN425130624407386360NaN118277804967331650NaN50457216608722220NaN19771934664716750NaN58401370776705810NaN277160888327003360NaN66345524944689390NaN35660243000683920NaN049749610566784510NaN43604397168667510NaN129191152246620370NaN51548551336651090NaN208632693926456230NaN59492705504634680NaN28807423560629210NaN67436859672618270NaN367515777286127940NaN060662957846073230NaN44695731896596380NaN14010449952590910NaN52639886064579970NaN219546041205744950NaN60584040232563550NaN29898758288558080NaN68528194400547140NaN378429124565416660NaN071576305125361950NaN45787066624525250NaN15101784680519780NaN53731220792508840NaN230459388485033670NaN61675374960492420NaN30990093016486950NaN0030481107248148120NaN38934247184470540NaN082489652404650670NaN468784013524541240NaN161931194084486530NaN54822555520437710NaN24137273576432240NaN6276670968842130NaN320814277444158250NaN0139614580041035330NaN40025581912399410NaN093402999683939390NaN479697360803829960NaN172844541363775250NaN55913890248366580NaN25228608304361110NaN63858044416350170NaN331727624723446970NaN0248748052833922540NaN41116916640328280NaN104316346963228110NaN49061070808311870NaN183757888643063970NaN57005224976295450NaN263199430322899830NaN64949379144279040NaN34264097200273570NaN0357881525626809750NaN422082513682571550NaN115229694242516830NaN50152405536240740NaN19467123592235270NaN58096559704224330NaN274112777602188550NaN66040713872207910NaN35355431928202440NaN0467014998419696960NaN432995860961860270NaN126143041521805550NaN51243740264169610NaN20558458320164140NaN5918789443215320NaN285026124881477270NaN67132048600136780NaN364467666561313130NaN057614847121258420NaN4439092082411490NaN137056388801094280NaN52335074992098480NaN216497930480930130NaN60279229160082070NaN2959394721607660NaN68223383328065660NaN375381013840601850NaN068528194400547140NaN45482255552043770NaN1479697360803830NaN53426409720027360NaN227411277760218860NaN61370563888010940.3068528194400547

Just fyi: new posts aren't scored since the challenge is closed as of Nov. 1.

OK, at least I had fun doing this, and hopefully someone else will have fun cracking this.

authors: n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳