Make a language with the exact same syntax as ENGLISH. For example:

"This is a comment."

Create a new variable named answer.
Have the variable named answer store the value of 10.

"Don't forget, grammar and spelling matter!"

If the variable answer is equal to 10, then do the following:
  1. Add a value of 5 to the variable.
  2. Create a new variable named question.
Otherwise, do the following:
  1. Exit the function.

Now, you can say that you're favourite language is English!

I've been thinking about making a language entirely in Spanish, so you could end up with something like this:

público entero[] x = [1, 2, 7, 3]
por-cada i en x {
  poner(i)
}

I present to you my truly innovative language:

???

Code will only compile and run when the programmer has died. Therefore, no one really knows the syntax of this language because we don't know how to raise people from the dead, yet...

I present to you my truly innovative language: Singularity

You are only allowed one variable per script and it must be Elon_Musk

All functions can only return values in binary

When the script ends the program will automatically print the number 3 trending result on Google Trends

Your output will be emailed to you within 8-10 business days during which time we convert your program your program into punch cards.

All errors are returned to you with a snarky comment about your hygiene

All while loops are infinite no matter what you do

The documentation is written in Ancient Sanskrit and all attempts of trying to translate it have resulted in mildly unsuccessful careers, Although we do provide a good Dental plan

I present...

Cxx

A static language that is weakly typed with implicit type coercion no matter what you do. For example:

int number = 5;
Console.Log(typeof number);

Your output will be:

<= Array[5]: [ Number, String, Boolean, Array, Null ]

Now, imagine you have another number:

int number2 = 10;

Adding them together gives:

<= "105"

Due to type coercion. Also, the same thing does not happen to strings:

String number1 = "5";
String number2 = "10";
Console.Log(number1 + number2);

<= Error: Cannot add two arrays

Due to strings being converted into Arrays.

Because of type coercion, this is logic:

5 == "100" => true // (both can be converted into booleans of true)
0 == 0 => false // (0 is not the same as false)
2 == 1 => true // (2 = true = 1)
"string" == "string" => false // (they have become arrays and require a deep equal in order to be true)
"5" == "2" => false // (same problem as above)
(Char)"5" == (Char)"2" => true // (both have become booleans due to explicit type)

Due to the nature of RegExp, RegExp has not been considered a type. It is considered a substance. A substance is that of a type, but it cannot be coerced for it is too pure. Substances are similar to classes, but they are not.

Substance.RegExp myRe = (new)Substance.RegExp(@"[^\d][\d\w]+"gi);
Console.Log(typeof myRe); => Substance.RegExp

Equalities with substances do not give you sane answers.

Substance.RegExp myRe = (new)Substance.RegExp(@"[^\d][\d\w]+"gi);
Substance.RegExp myRe2 = (new)Substance.RegExp(@".+"gi);
myRe == myRe2 => How Dare you Even Try To Compare Substances! Do you even know THE tRue Po𝑤͙͎̔̈́͠𝑒̦͔̙̓̓͌𝑟̡̫͌͑͘͜ o̸͖͚̓͆͠͝f̴̨̡̢̜͙̣̗͎̗̮̤̮̞̘̻͆̄̾̾͑̅͋͋̋͠ͅ ̶̧̧̡̱̳͔̙̬͈͈͍̗̊̌̊͌͑̓̍́̃͝s̴̢̨̞̩̱͈̙̥͖͎͖̭̣̠̓̔̔͊́̊̌̈̄̽̽̇̓͌͐͜͝ͅu̷̡̡̳̻̣̟͍̥͍͉̤̦̟̫͓̖͑̀̏͒̓͛̉̓̂̇ç̸̛͖̖̘̠̲̫̜̮̭̫͎̭͚̻̯̘̌͆̆̑͌̑̃̍̈́͒͊͘̕̚̚͝h̸̢̨̡̤̯͎͓̞͍͇̖̖̼̝͆̀̓̀̋͛̑̚ ̵̭̺̲̻̳͓͇̲͛̒̈̔̀̋̓̂̓̾̐͆͒̂͝͝t̸̞̩͙̖̞̱̭̟̭̮͉̲̠̊̑̀̌̋͆̄͂̑͑́͜͠h̵͉̰͆̔̊̐̈́͂̃̄̑̃̋̊͛͂͌ï̴̢̧͍̳͍̅̈́͛̑̓͗̿̒͌̿͛̒̄̚͠ṇ̵̢̾̊̄̈̏̎̍͐̅̌̔̀̕͝g̸̡̻̟̭͇̤͓͙͕̫̿̋͗͑͗̃̄̈́͝s̶̤͕̻̼̣͓̻̤̫͇̥̱̮͖͕̳̆̉̿̅̋̋͛̐̽͘͜ ̸̝̓̿́̎̓͘ỵ̵̨̧̯͍̱̫̲̘̩̘̏͋͑o̶̡̲̥͙̣̥̝̰̣͗͐̂͗̄̓̈́͜ű̵̠͐̓̋̓͐̊̃̿̚͠ ̵͓͉̕s̷̡̖̭̥̫̼̥̒̇͋́̏̀̚m̷͇͈̗͚̗͉̩̖̹͍͉͖͔̼̅̍̓̑̈̋̃͛͛̕a̵͚̣̯̫̮̬̞͚̙͎̹̋̈́̅̄̐͒̋̈́̇́̚͝ḽ̸̗̬͍̫̣̠̿̓͆l̷͖͕̣̳͉͙͇̀͋͒͋̊̉̄̅̀͝͠ ̴̡̡̛̻̟̖͍̘̃̈͐͛̌́͂͂́̑̃͌̆̋̽̚b̸͇̭̦̬̝͔̈́͂̊͌̿ȑ̷̨͉̱̬̮̩͉̘͎̩̩̙͓͙̊̈́́͊̿̾͠à̸̡̳̝̫̘̯͙͚͎̺̋͛̔̔͒̐͆͌̈́̕i̸̜͆̿̈́͑͌̏̂̑̾̈̎͝n̵̢͚̥͈̰͚̐̐̅́̌̉̃͆͛̈́̃̇ ̸̤̲̲͕̘͇̞͔́͊̃͐͑̅̿̓̾̊̈́̕̕͜p̵̡̖̖̙̝̬̪͈̙̖͓̙͚͛r̴̛͔̳̺̺̪̓͒̈́̄̈́͌̔̑̿̏̕ȍ̸̢̠̖̩̫͕͔̣̘͕̳̽̏̾̈̆̔́̈̄͘͘ͅģ̸̛͇̿̐͗̾͂̆̀̈́̌̋̋̍̑̈́͠ř̶͈͚̥̱͚̹͉͙̯̞͓̬̑̕à̷̰̲͕̯͇͓̖͉͚̒̉͜ͅm̶̨̦̰̱̪̤̻̯̙̔͆̈́͐́̚͝m̵̡͔̰͇͓̮̣̱̞̜̥̣̤̂͜e̶̛̠̝͉r̵̢̧̛̹͎̜̘͙̻̫̙̦̻̜̟͕̱͑̃̍͌̈́̃̓͊̿̕͜

Funnily enough, no errors are thrown.

Now, to define a function, you do:

void FunctionName(int arg1, int arg2) {
  return arg1+arg2;
}

Of course, a return value is not required. Return values follow the same implicit type coercion.

Surprisingly, you can convert functions into Substances:

void FunctionName(int arg1, int arg2) {
  // Code
}
(Substance.Generic)SubtanceFunction = FunctionName;

However, the function has become a substance, but the code does not. This means, comparing it to other Substances will give you the same result as the RegExp had:

void Function1(int arg1, int arg2) {
  // Code
}
void Function2(int arg1, int arg2) {
  // Code
}

(Substance.Generic)SubstanceFunction = Function1;
(Substance.Generic)SubstanceFunction2 = Function2;

SubstanceFunction = SubtanceFunction2 => How Dare you Even Try To Compare Substances! Do you even know THE tRue Po𝑤͙͎̔̈́͠𝑒̦͔̙̓̓͌𝑟̡̫͌͑͘͜ o̸͖͚̓͆͠͝f̴̨̡̢̜͙̣̗͎̗̮̤̮̞̘̻͆̄̾̾͑̅͋͋̋͠ͅ ̶̧̧̡̱̳͔̙̬͈͈͍̗̊̌̊͌͑̓̍́̃͝s̴̢̨̞̩̱͈̙̥͖͎͖̭̣̠̓̔̔͊́̊̌̈̄̽̽̇̓͌͐͜͝ͅu̷̡̡̳̻̣̟͍̥͍͉̤̦̟̫͓̖͑̀̏͒̓͛̉̓̂̇ç̸̛͖̖̘̠̲̫̜̮̭̫͎̭͚̻̯̘̌͆̆̑͌̑̃̍̈́͒͊͘̕̚̚͝h̸̢̨̡̤̯͎͓̞͍͇̖̖̼̝͆̀̓̀̋͛̑̚ ̵̭̺̲̻̳͓͇̲͛̒̈̔̀̋̓̂̓̾̐͆͒̂͝͝t̸̞̩͙̖̞̱̭̟̭̮͉̲̠̊̑̀̌̋͆̄͂̑͑́͜͠h̵͉̰͆̔̊̐̈́͂̃̄̑̃̋̊͛͂͌ï̴̢̧͍̳͍̅̈́͛̑̓͗̿̒͌̿͛̒̄̚͠ṇ̵̢̾̊̄̈̏̎̍͐̅̌̔̀̕͝g̸̡̻̟̭͇̤͓͙͕̫̿̋͗͑͗̃̄̈́͝s̶̤͕̻̼̣͓̻̤̫͇̥̱̮͖͕̳̆̉̿̅̋̋͛̐̽͘͜ ̸̝̓̿́̎̓͘ỵ̵̨̧̯͍̱̫̲̘̩̘̏͋͑o̶̡̲̥͙̣̥̝̰̣͗͐̂͗̄̓̈́͜ű̵̠͐̓̋̓͐̊̃̿̚͠ ̵͓͉̕s̷̡̖̭̥̫̼̥̒̇͋́̏̀̚m̷͇͈̗͚̗͉̩̖̹͍͉͖͔̼̅̍̓̑̈̋̃͛͛̕a̵͚̣̯̫̮̬̞͚̙͎̹̋̈́̅̄̐͒̋̈́̇́̚͝ḽ̸̗̬͍̫̣̠̿̓͆l̷͖͕̣̳͉͙͇̀͋͒͋̊̉̄̅̀͝͠ ̴̡̡̛̻̟̖͍̘̃̈͐͛̌́͂͂́̑̃͌̆̋̽̚b̸͇̭̦̬̝͔̈́͂̊͌̿ȑ̷̨͉̱̬̮̩͉̘͎̩̩̙͓͙̊̈́́͊̿̾͠à̸̡̳̝̫̘̯͙͚͎̺̋͛̔̔͒̐͆͌̈́̕i̸̜͆̿̈́͑͌̏̂̑̾̈̎͝n̵̢͚̥͈̰͚̐̐̅́̌̉̃͆͛̈́̃̇ ̸̤̲̲͕̘͇̞͔́͊̃͐͑̅̿̓̾̊̈́̕̕͜p̵̡̖̖̙̝̬̪͈̙̖͓̙͚͛r̴̛͔̳̺̺̪̓͒̈́̄̈́͌̔̑̿̏̕ȍ̸̢̠̖̩̫͕͔̣̘͕̳̽̏̾̈̆̔́̈̄͘͘ͅģ̸̛͇̿̐͗̾͂̆̀̈́̌̋̋̍̑̈́͠ř̶͈͚̥̱͚̹͉͙̯̞͓̬̑̕à̷̰̲͕̯͇͓̖͉͚̒̉͜ͅm̶̨̦̰̱̪̤̻̯̙̔͆̈́͐́̚͝m̵̡͔̰͇͓̮̣̱̞̜̥̣̤̂͜e̶̛̠̝͉r̵̢̧̛̹͎̜̘͙̻̫̙̦̻̜̟͕̱͑̃̍͌̈́̃̓͊̿̕͜

Finally, if you try to compare a normal function to a substance function, you get:

void NormalFunc(int arg1, int arg2) {
  // Code
}

(Substance.Generic)SubstanceFunc = NormalFunc;

SubstanceFunc == NormalFunc => 1

1 is the result you will get no matter what is being compared to any substance.

And that is all for this language! Rumors are that JavaScript is written on top of Cxx.

A language that throws errors no matter what you add
AKA: no correct syntax

HahaYes

Something where the syntax changes based on the previous commands. No program has the same rules. Or you can only use each syntax construct x times.

5 for loops, 10 ifs...

My wildest programming language ideas are

Objective BASIC

Like an object-oriented version of BASIC. (might actually make)

Adapt

A programming language where you can dynamically change the syntax with the ability to rewrite the program while it is running and variables with multiple types simultaneously. (in development)

XPL

A language based on XML (https://github.com/amazingmech2418/xpl)

Link

A language based on JSON that could allow programming via a flowchart. (https://github.com/AmazingMech2418/Link-Programming-Language)

Inventor

A language which is entirely based on transpiling. (https://github.com/AmazingMech2418/Inventor)

Possibly the worst programming language I have made actually. LOL!

X

A C-style language with a full graphics library, a safe memory system without buffer overflows, with prototypal OOP, and with a powerful mathematics library. (in planning stage currently)

Dictionary oriented programming. Instead of using classes and objects, use an abstract dictionary as a struct. Then you can add functions to the dictionary to make the structs into classes. (Not sure if this has been made.)

a language made up of emojis

Oh! I thought of another equally silly one! Make a language called "le twatter". For example:

tweet "Hello World!\n"
receive tweet "What is your name? "

post Animal:
  public comment legs
  public comment colour
  
  story(_legs, _colour):
    legs = _legs
    colour = _colour

  reply DisplayInfo:
    tweet "This animal has " + legs + " legs"

account.end

I present to you: Repl.It language

array = repl
vector = multiplayer repl
print = post on feed
variable = repl file
input = new repl

A very wholesome language.

TortureLang: more annoying than brainf***

basics

• File extension: .tl.
• must have as many semicolons as there are other characters on line
• you cannot have whitespace before actual code.
• no way to comment
• just says boo, you suck! when there's an error
  worse:
• processes 4 lines in one second.
• can only process 32 lines of code.
  worst:
• you have to wait an hour before output

syntax

Print syntax:

you must write the string on as many new lines as there are characters in string to print each character

1   Writethislineinconsole "Hello world!";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2   Hello world!;;;;;;;;;;;;
3   Hello world!;;;;;;;;;;;;
4   Hello world!;;;;;;;;;;;;
5   Hello world!;;;;;;;;;;;;
6   Hello world!;;;;;;;;;;;;
7   Hello world!;;;;;;;;;;;;
8   Hello world!;;;;;;;;;;;;
9   Hello world!;;;;;;;;;;;;
10  Hello world!;;;;;;;;;;;;
11  Hello world!;;;;;;;;;;;;
12  Hello world!;;;;;;;;;;;;
13  Hello world!;;;;;;;;;;;;

Will Supposed to output:

Hello world!

Capture input, variable, and if statement syntax:

there are only three available variable names and here they are:

• VaRiAbLe01
• MYSecoNdvarIABle
• ThIsistHEthiRdaNDlaSTVariabLe
  Also, this is the variable assigning sequence, =-_-__=_=
  For if statements, the entire output is in braces ({}) and you can only have one in the entire program
  Example:

1   variable VaRiAbLe01 =-_-__=_= captureuserinput ">> ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2   if VaRiAbLe01 = "Joemama" {;;;;;;;;;;;;;;;;;;;;;;;;;
3   Writethislineinconsole "is fat"{;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4   is fat;;;;;;
5   is fat;;;;;;
6   is fat;;;;;;
7   is fat;;;;;;
8   is fat;;;;;;
9   is fat};;;;;;;
10  };

Else syntax:

Elses work the same way ifs do
Same example with else statement:

1   variable VaRiAbLe01 =-_-__=_= captureuserinput ">> ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2   if VaRiAbLe01 = "Joemama" {;;;;;;;;;;;;;;;;;;;;;;;;;
3   Writethislineinconsole "is fat";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4   is fat;;;;;;
5   is fat;;;;;;
6   is fat;;;;;;
7   is fat;;;;;;
8   is fat;;;;;;
9   is fat;;;;;;
10  };
11  else{;;;;;
12  Writethislineinconsole "shut up";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
13  shut up;;;;;;;
16  shut up;;;;;;;
17  shut up;;;;;;;
18  shut up;;;;;;;
19  shut up;;;;;;;
20  shut up;;;;;;;
21  shut up;;;;;;;
22  };

That's about it Here's a sample program:

1   variable VaRiBbLe01 =-_-__=_= 10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2   variable MYSecoNdvarIABle =-_-__=_= captureuserinput "like it? >> ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3   if MYSecoNdvarIABle =-_-__=_= "yes" {;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4   Writethislineinconsole "u are evil";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5   u are evil;;;;;;;;;;
6   u are evil;;;;;;;;;;
7   u are evil;;;;;;;;;;
8   u are evil;;;;;;;;;;
9   u are evil;;;;;;;;;;
10  u are evil;;;;;;;;;;
11  u are evil;;;;;;;;;;
12  u are evil;;;;;;;;;;
13  u are evil;;;;;;;;;;
14  u are evil;;;;;;;;;;
15  };
16  else{;;;;;
17  Writethislineinconsole "you are so right";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
18  you are so right;;;;;;;;;;;;;;;;
19  you are so right;;;;;;;;;;;;;;;;
20  you are so right;;;;;;;;;;;;;;;;
21  you are so right;;;;;;;;;;;;;;;;
22  you are so right;;;;;;;;;;;;;;;;
23  you are so right;;;;;;;;;;;;;;;;
24  you are so right;;;;;;;;;;;;;;;;
25  you are so right;;;;;;;;;;;;;;;;
26  you are so right;;;;;;;;;;;;;;;;
27  you are so right;;;;;;;;;;;;;;;;
28  you are so right;;;;;;;;;;;;;;;;
29  you are so right;;;;;;;;;;;;;;;;
30  you are so right;;;;;;;;;;;;;;;;
31  you are so right;;;;;;;;;;;;;;;;
32  you are so right;;;;;;;;;;;;;;;;
33  you are so right;;;;;;;;;;;;;;;;
34  }

Supposed to output this thing:
like it? >> {enter your choice here}
If you choose yes, it will output the following:
u are evil
If you type anything else, it will output:
you are so righ
The last character was not printed since the computer will ignore anything beyond the 32-line limit.
This is why TortureLang sucks!

Alright, so imagine a lang that is a mix from the syntax of COBOL, python, and HTML. I imagine it would look like

have Counting(num)

<wall equals"(num(counter))"><wall>
<beer equals"value(num(count(100))">on the wall<beer>

if "beer (on the wall)" != 0;
    return(line(6)) /loop\ /these are comments btw\
if not;/these are basically just if-elses\
    return(line(9));

<stop value"all">

What I did was take the easy "talkative" almost way of COBOL to make this sound like a person talking (almost), the easy function identifying of HTML, and the clean formatting of Python to make this abomination. (I used python highlighting for whatever reason)
(also i think "le twatter" is kinda funny. yes i had to put this here)

A language where absolutely nothing is immutable

All updates to all variables (called "accounts") follow rules of double entry accounting -- each account is managed by an agent who is directed to bring the balance of each of a list of other accounts to zero by making transfers to or from them!

Those accounts follow an order of priority -- each account's balance has a positive and negative limit, meaning that not all agents' goals can be satisfied every iteration.

(I implemented a system with these rules a while ago for an unreleased virtual pet game! Later I got to show my system off to some friends at Google, but they didn't hire me over it.

If the perks aren't obvious to you, try implementing them. Also consider obvious changes to this design -- giving each agent a transfer limit, or giving agents more complicated patterns of behavior. You can still get some interesting behavior out of this design by keeping agents' decisions simple, mind.)

language using only ψ dunno how it would work

something like php but for desktop instead of web

instead of while loops you could have a "loop to line X" so that you wouldn't have to create complicated loops that for me never work. also I want a //BS function that makes everything false just cos it would be funny if on multiplayer

I think a language with syntax like python, but made only for desktop app and game development would be cool.

A language called ERD, with absURD syntax.
For example file modifying would be like

pkg : (fs);
pkg : (debt);
!txt => pkg : (txtformat);
get file("modded.txt") into $page => {
  set $file write(!txt (ascii){
    Sample Text
  });
  export $file => ();
  debt : ($file) => {
    throw => ();
  }
}

and stupid things like this. Note debt : ($file) => {} which is just shorthand for detect : (existof : ($file)) <-> true; => {} which is awful
And Hello World be like

pkg : (io);
print => {
  Hello World!
}
export => ();

An easy thing:
Say - hi
Say h1 - hi
Say blue - hi

😁 AND SO ON...
How do you create one

Frankly speaking, I'd like to create my very own language using python, I mean, how hard would it be...?

Imagine a programming language that didnt have a lexer and parser, and was instead lexed and parsed by a machine learning algorithm!

I was thinking on making a website that was just English

Let's make...
A language like markdown but used to make a profissional website
With functions and functions should be easy but their job is too good!
So think about it...

sorry for my eng

A programming language where you have to form coherent binary commands by doing any operations on a single (initially empty) binary string and up to 2 additional arguments of the letter O. Every operation must involve 'O'. The final result of the binary string is your program.

Edit: example (result is not coherent)

BIN.append( ('O' << 3) ^ 'O')
BIN.append('O')
BIN.append(  ~('O'^'O') >> 7   )

I'm surprised no one's mentioned Snowflake yet... *cough cough* @SuperWhiskers.

Hmmm... This was hard to come up with. But I think I have an idea. Comments would be marked by two |s. One at the beginning and one at the end. Here would be a strip of code that explains the basics of this language:

|This is variable declaration|
:x: == {"This is a string variable"}
:x: == {11}
:x: == {tr} |Bool|
|Output|
/"Hello World"/
M/"Is x true? Check here: ---x---"M/ |Modified|
|Input|
:first: == *I"Do you like pancakes?"I*
:pancake_name: == {Bob}
:second: == *IM"Do you? My pancake's name is ---pancake_name---"*IM
|If, else|
:test: == {77}
#I#I ---test--- = 77
   /"77 is the number!"/
#IE#IE  |Else|
   M/"77 is not the number. The number is --test--"M/

|Lists|
(:backpack:) == {["food",,"water",,"other stuff"]}
|Iterating through lists|
M/"The first element is --backpack*0*--"M/
|Loops|
|While|
:second_test: == {0}
!W!W ---second_test--- << 10
  /"The test is not 10 yet!"/
  :test: == {---test--- ++ 1}
|For|
(:languages:) == {["English",, "Russian",, "German"]}
!F!F :lang: ---languages---
   M/"The current language is ---lang---"M/

This language is quite complicated and I'm calling it Double because as you might have noticed everything has to be surrounded by two of the same thing.