C#, 288 bytes

Stag is a great shoW.        "="=""="="Agent"plastic"Was"tryin"to"Release"an"Astroid"."$Money$"st@le"tigers"and"Agent"plastic"got"mad"."$Money$"sic","man","t0tally"rad"."Sistrs"Rms"titAnic";"Civic"Ace"in"{sC@m}{hic}{vicis}..{cats}sAc}((@))((@)){{{>>{{{{{{}}}}}}}}}\\\\\\\;;;(@)((@)()),,;;

My strategy is for all the short ones to get cracked and nobody bothers with this considering how long it is... Also I suppose I should note that this is a full program, not just a function.

MATL, 20 bytes. Cracked

It'D-whoLl&w#ck'f0Gz

Don't attempt to crack this. It'd wholly wack fogs.

JavaScript, 1574 bytes

I spent way too much time on this. Behold the obfuscation.

(notice that an unmatch parenthesis remains throughout the entire text.

dear "sir",

|    i cannot express my loathing to you and your things. they truly are a loathsome sight. (regar'less of their quality, they function as the most appalling devices...)[1]

|    these avocads of thine possession are most unpleasent. (ce n'est pas faux.) Queer; Careful; An' in total repulsing. in this form, those are not seulement cringe... So; CAB's is quite Cruel. (Cruel indeed...)

|    intention is not great (heh, intention, ;}) run, no, run, since {tu est le ;AqC;};

{{{{============================================}}}}

[1]: see? am i not insane? You may dictate the opposite, so i dictate thus.

9 + 4 is 13. Y is this. Y + 4 is 9 + 9 minus one. N is this. f(x) is {x + x}, so f(N) is N plus N is N + N is 3.

:^) i'm cruel; not so cruel.)
                                  rrrrrrrrrr 0nnnccnnggrrrrttssBBC
{({[}(<[<))(((((){{})}[}][[]{}(]))))|} f f r 0nnnccnngrrrrrttesBBA
())(((()))))()))()()()((((()))}{{})((} f f r 0nnnccnngrrrrrttesBBY
]]}(([][]{{{}}})()({}(){}{()}{}()[])][ f f r 4nnnccnngrrrrrttesBSY
))({})(}{)({{{{(()))())))))))()))()()( f f r 4nnnccnngrrrrrtpesqSY
)()()((((((((((Z))))))))()(()((()((((( f f r 5nnnccnngrrrrrtlefoSY
(((;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;''' f f r 3nnncccngrrrrxtleifSY
''''''''''''''''''',,,,,,,,[[[[[[]]]]] f f r 3nnncccngrrrrxtleifZQ
[ ] ] + + + + + + + + + + + + + + + ++ f f r 9nnncccggrrrrxtleifZQ
+ + + + too not fun...fffffffffffffuuu f f r 5nnncccggrrrrxtlli0ZQ
uuuuuuuuuuuu.. | | | |99S            ) f f r 0nnncccggrrrrxxll01QQ

Underload, 20 bytes, Cracked!

~*)(a):*(*a:S(*S*~S)

I scrambled this via randomizing the order of the characters, because what could be more scrambled than random?

A correctly written Underload interpreter crashes when seeing a newline at the top level of the program. As usual in golfing competitions, there's no newline at the end of the program; I'm just placing this reminder here because it's very easy to add one by mistake when copying the program to an interpreter.

Retina, 20 bytes, Cracked

S`(\?)\1*

S`(\?)\1*

The program (and output) contains exactly two linefeeds.

You can try Retina online here.

A small hint:

In the process of designing this cop, I found a new shortest Retina quine, which I'll post to our quine challenge once this answer is either cracked or safe.

CJam, 39 bytes, Safe

!""$)+023345679:AEORYZZ\_```bbceeffimmz

Solution:

")A!0z`eZOmRZ$Yei`E"_`\32fm95b67b43f+:c

Uses some base encoding for obfuscation. However, since the characters are all in ASCII I would have thought someone might be able to figure out 32fm95b??b??f+:c which would be enough to brute force the rest.

Pyth, 38 bytes, Safe

Not quite golfed, but works.

````::""@@@@++++22ggKKKKKKKKNNNNZZZZ

Unsorted version:

K"K++@KZ:`K@`NZNgK2"++@KZ:`K@`NZNgK2

Vim, 22 bytes, Cracked!

pit^[^[p00tqqqq^V"ltxltx"

The ^[ are the literal escape key, and ^V is Ctrl-V, and are therefore counted as one byte, and are kept together in the scrambled code.

Python 2, 54 bytes, Cracked!

=l`;lrt,]l n`p,i=,' 1,1'lnt[ll[;,0  ]['r[`][`0'ipll] ]

JavaScript, 147 bytes, Cracked by ETHProductions

I'll be very impressed if someone manages to crack this...

   """"''''((((()))))+++++++++.//99;;;;;;=========>>[[[[[]]]]]``````````````cccdddddddeeeeeeeeeeeffiiiiiiinnnnnnnoooooooorrrrrrrrsttttuuwwwwwwx{{}}

Intended solution:

e=o=>{n=o;``[r=`constructor`][r](`return e=>{`+o+`}`)````};d=e+"";e`for(i in window)if(/ert/.exec(i))w=window[i];w('e='+d+';d=e+"";e'+d[9]+n+d[9])`

Haskell, 86 bytes, cracked by nimi

putStr$"Study:ric====>>>>yummy:candy:circus:party:in:syrirrr!!!!!!$[;['=['[$]']='];]$"

This a valid Haskell expression which prints:

Study:ric====>>>>yummy:candy:circus:party:in:syrirrr!!!!!!$[;['=['[$]']='];]$

So if Ric studies, he can go to the yummy candy circus party! That is, if he figures out where Syrirrr is.

V, 20 bytes -- Safe!

"$033lpqxx|áäéééñññ

Note the trailing newline.

I wasn't really sure how to scramble them, so I just sorted the characters by ASCII value.

Unlike most V answers, this one contains zero unprintable characters. Here is a hexdump:

0000000: 2224 3033 336c 7071 7878 7ce1 e4e9 e9e9  "$033lpqxx|.....
0000010: f1f1 f10a                                ....

Unscrambled code:

éññ3äl0éé$áx3|"qpñx

Try it online!

Side not about this link. In previous versions of V, a newline was always automatically printed, which is why this version has the trailing newline. The interpreter at the time I wrote this was a valid quine, although now you can just remove the newline to make it valid.

Explanation:

éñ                      " Insert a 'ñ' character
  ñ              ñ      " Put all of the following into register 'q' and run it when it's done recording
   3äl                  " Make 3 copies of the character under the cursor
      0                 " Move to the first column
       éé               " Insert an 'é' character
         $              " Move to the last column
          áx            " Append an 'x'
            3|          " Move to the third column
              "qp       " Paste register 'q' (all of the commands we just ran)
                  x     " Delete a character

Haskell, 99 bytes, Safe

"super.quine?"=>#$$$%%%%%&&(())))**++++,,,,/;<<==>>STaabbdeffggghhhjlmmnoppqqrrsssttttuuuvvwwwwxxxx

Another Haskell quine, this time with a nice odd 99 bytes.

g%w=(g< $ >w)++w++pure(g.last$w);main=putStr$pred%"h&x>)h=%?x*,,x,,qvsf)h/mbtu%x*qvuTus%qsfe&#"

Try it on Ideone. The spaces in "g< $ >w" must be removed, I put them there because otherwise the <,$, and > vanish (most likely being interpreted as html tag). The gibberish string is a string of the program with each char mapped to it's successor, including a final " (which is possible to include into the string without escaping because it's mapped to #). The helper function % takes the string and maps each char to it's predecessor using pred (yielding code"), then appends the original string (yielding code"gibberish_code) and the last char of the decoded string (yielding code"gibberish_code"). To convert a char c to a string it would normally suffice to put it into a list [c] as strings in Haskell are simply char lists, however the successor of [ is \, which would need escaping in the successor-encoded string, so instead pure is used which lifts arbitrary types into a Monad (which Monad to use is inferred from the context).

PHP, 110 bytes, Cracked

php$=))$)<9 php .(().)'heroes ?  $0(9carrot3?$;<.()trash3,.((3=)catarrh$$9 (,'9cry(3);  ;;tryccchhhrrrrxxxxxx

Javascript ES6, 49 bytes (cracked)

{{$((((((('`fuck rent =+> turn off fin`')))))))}}

Is it bad if I focused more on forming coherent words in the scrambled solution?

In any case, this is my first Cops and Robbers challenge.

Update: see comments for cracked code.

FurryScript, 199 bytes, Safe!

UT  TTEDU DT   T U T D   ES DGT GEL L   GL
-<<<<<<+++++++[[[[#BESTQUINEEVER!#BESTQUINEEVER!#BESTQUINEEVER!#BESTQUINEEVER!#BESTQUINEEVER!#]]]]+++++++>>>>>>-

X   XG WPW   SS  X  PW S US WWTLWP  XS  PE

Should be fairly easy to crack.

Unscrambled Code

BESTQUINE[ DUP LT +SW +GT +< BESTQUINE#> ]
EVER![ DUP EX+ SW EX- LT +SW +GT +< EVER!#> ]
<BESTQUINE[ DUP LT +SW +GT +< BESTQUINE#> ]> BESTQUINE#
<EVER![ DUP EX+ SW EX- LT +SW +GT +< EVER!#> ]> EVER!#

Just the regular quine, but with two subroutines and some more code to swap the strings.

><>, 36 bytes, Cracked!

!!!'''***+...00002333:::;???dddforrr

Befunge-93, 15 bytes, Cracked!

:::@#%+-_,<910g

Try it online!

Python 2, 105 bytes, Cracked!

    ######%%%%''(((((((())))))))****--0011::::;;==@@@@@@@@@@[[[[]]]]aaaaaaggggggiiiiiiiinnpprrrrrrrrrtt~~

The other one was cracked, so this one is more difficult.

print'To find the solution, get to work!'

Ruby, 53 bytes - Cracked

**TEN sTupID,sTupID NET,"TIN"<22"DEN"<<It<DEtINDE\n\n

The \n are literal newlines.

QB64, 89 bytes

(_+cad:effecs:fact), =+cred:scarf:attaccd?, =+eff4c3d:cars:craccd?, (_+csc:f4c3d:fact), "

Some salient points:

• The code will not work in QBasic: it uses QB64-specific features
• Syntax expansion is off
• No dollar signs and only one quotation mark
• "Poetry" would be a stretch, but it does rhyme

Befunge-93, 24 bytes

I'm afraid this is a bit late, but I wanted to attempt one without the g command.

<<_:@00278899p,**++###>!

Try it online!

OIL, 77 bytes

0
0
1
1
1
1
1
1
1
1
1
2
2
4
4
4
6
8
10
11
11
11
12
17
18
18
18
18
22
26
26
32

Good luck with that.

Jelly, 3 bytes, Cracked!

Ṙ”Ṙ

Try it online!

Here is the solution:

What, you want the solution? Find it!