Why can't code be uncompiled?

4+4 is 8 But so is 6+2 And 7+1

You can't guess which two numbers I started with knowing just the answer

Code is the same, just with much bigger numbers and more of them

Very nice explanation of a complex promlem.
I would say that it's more like 4+4=8 but the original could have been (1+1+1+1)+(3+1) or (2+2)+(1+2+1) etc.

Basically it's the same thing but if you really want to understand the code and modify it in any meaningful way you have to know how it was intended and not just the results.

My point being that decompiling does give you something similar to the original. It's not just a guess that gives you random code with the correct result, but it could be very different from the source code.

The reason is that the compiler does a lot of things to make it more efficient but that just means that while 1+1+1+1 can be efficiently written as 4, there still is a good reason for 1+1+1+1 from a logical sense. For example, if you're counting something, it would make sense to say 1+1+1+1. But if you're looking at a specific value, maybe it makes more sense to just say 4.

What it produces will typically not contain the original names for variables and functions, and will not retain comments. It takes a lot more effort to understand what the intention behind the code was.

There's also legality issues.

The long answer involves a lot of technical jargon, but the short answer is that the compilation process turns high level source code into something that the machine can read, and that process usually drops a lot of unneeded data and does some low-level optimization to make things more efficient during actual processing.

One can use a decompiler to take that machine code and attempt to turn it back into something human readable, but will usually be missing data on variable names, function calls, comments, etc. and include compiler-added optimizations which makes it nearly impossible to reconstruct the original code

It's sort of the code equivalent of putting a sentence into Google translate and then immediately translating it back to the original. You often end up with differences in word choice that give you a good general idea of intent, but it's impossible to know exactly which words were in the original sentence.

Thank you, sorry to push further but my understanding is that computers deal with binary so every language is compiled to machine code, which I took as binary.

So if the language has elements being removed and the machine doesn't need them shouldn't you get back out exactly what is needed to do the task? Like if you compiled some code and then uncompiled it you would get the most efficient version of it because the computer took what it needed, discarded the rest and gave it back to you?
- It depends on the specifics of how the language is compiled. I'll use C# as an example since that's what I'm currently working with, but the process is different between all of them.
  
  C#, when compiled, actually gets compressed down to what is known as an intermediate language (MSIL for C# specifically). This intermediate file is basically a set of genericized instructions that are not linked to any specific CPU. This is useful because different CPUs require different instructions.
  
  Then, when the program is run, a second compiler known as the JIT (just-in-time) compiler takes the intermediate commands and translates them into something directly relevant to the CPU being used.
  
  When we decompile a C# dll, we're really converting from the intermediate language (generic CPU-agnostic instructions) and translating it back into source code.
  
  To your second point, you are correct that the decompiled version will be more efficient from a processing perspective, but that efficiency comes at the direct cost of being able to easily understand what is happening at a human level. :)
- The main issue is that to make code human-readable, we include a lot of conventions that computers don't need. We use specific formatting, name conventions, code structure, comments, etc. to help someone look at the code and understand its function.
  
  Let's say I write code, and I have a function named 'findUserName' that takes a variable 'text' and checks it against a global variable 'userName', to see if the user name is contained in the text, and returns 'true' if so. If I compile and decompile that, the result will be (for example) a function named 'function_002' that takes a variable 'var_local_000' and checks it against 'var_global_115'. Also, my comments will be gone, and finding where the function was called from will be difficult. Yes, you could look at that code and figure out that it's comparing the contents of two variables, but you wouldn't know that var_global_115 is a username, so you'd have to go find where that variable was set and try to puzzle out where it was coming from, and follow that rabbit hole backwards until you eventually find a request for user input which you'd have to use context clues to determine the purpose of. You also wouldn't have the context around what 'var_local_000' represented unless you found where the function was called, and followed a similar line backwards to find the origin of that variable.
  
  It's not that the code you get back from a decompiler is incorrect or inefficient, it's that it's very much not human-readable without a lot of extra investigatory work.
- The implicit assumption with decompiling code is that the goal is either to inspect how the code works, or to try compiling for a different machine. I'll try to explain why the latter is quite difficult.
  
  As you said, compilation to machine code only keeps the details needed for the CPU to accomplish what was instructed. And indeed, that is supposed to be efficient to run on that CPU, by reason of being targeted exactly for that CPU. But when decompiling, the resulting code will reflect the specificity to that same CPU. If you then try to compile that code for a different CPU, it will likely work, but will likely be inefficient because the second CPU's unique advantages won't be leveraged.
  
  To use an example, consider how someone might divide two large numbers. Person A learned long division in school, and so takes each number and breaks it down into a series of smaller multiplications and subtractions. Person B learned to do division using a calculator, which just involves entering the two numbers and requesting that they be divided.
  
  Trying to do division by blindly giving Person B that series of multiplications and subtractions to do on the calculator is extremely inefficient because Person B knows how to do division easily. But Person B is following Person A's methods, without knowing that the whole point of this exercise is to just divide the two original numbers. Compilation loses context and intent, which cannot be recovered from decompilation, for non-trivial programs.
  
  Here is an example why source code is useful when it provides context: https://en.m.wikipedia.org/wiki/Fast_inverse_square_root#Overview_of_the_code . Very few people would be able to figure out how this works from just the machine code.
- if you compiled some code and then uncompiled it you would get the most efficient version of it ... ?
  
  Sorta, an optimizing compiler will always trim dead code which isn't needed, but it will also do things that are more efficient but make the code harder to understand like unrolling loops. e.g. you might have some code that says "for numbers 1-100 call some function" the compiler can look at this and say "let's just go ahead and insert 100 calls to that function with the specific number" so instead of a small loop you'll see a big block of function calls almost the same.
  
  Other optimizations will similarly obfuscate the original programmers intent, and thinks like assertions are meant to be optimized out in production code so those won't appear in the de-compiled version of the sources.

I actually work on a C++ compiler... I think I should weigh in. The general consensus here that things are lossy is correct but perhaps non-obvious if you're not familiar with the domain.

When you compile a program you're taking the source, turning into a graph that represents every aspect of the program, and then generating some kind of IR that then gets turned into machine code.

You lose things like code comments because the machine doesn't care about the comments right off the bat.

Then you lose local variable and function parameter names because the machine doesn't care about those things.

Then you lose your class structure ... because the machine really just cares about the total size of the thing it's passing around. You can recover some of this information by looking at the functions but it's not always going to be straight forward because not every constructor initializes everything and things like unions add further complexity ... and not every memory allocation uses a constructor. You won't get any names of any data members/fields though because ... again the machine doesn't care.

So what you're left with is basically the mangled names of functions and what you can derive from how instructions access memory.

The mangled names normally tell you a lot, the namespace, the class (if any), and the argument count and types. Of course that's not guaranteed either, it's just because that's how we come up with unique stable names for the various things in your program. It could function with a bunch of UUIDs if you setup a table on the compilers side to associate everything.

But wait! There's more! The optimizer can do some really wild things in the name of speed... Including combining functions. Those constructors? Gone, now they're just some more operations in the function bodies. That function you wrote to help improve readability of your code? Gone. That function you wrote to deduplicate code? Gone. That eloquent recursive logic you wrote? Gone, now it's the moral equivalent of a giant mess of goto statements. That template code that makes use of dozens of instantiated functions? Those functions are gone now too; instead it's all the instantiated logic puked out into one giant function. That piece of logic computing a value? Well the compiler figured out it's always 27, so the logic to compute it? Gone.

Now all of that stuff doesn't happen every time, particularly not all of those things are always possible optimizations or good optimizations ... But you can see how incredibly difficult it is to reconstruct a program once it's been compiled and gone through optimization. There's a very low chance if you do reconstruct it, that it will look anything like what you started with.

Just wait until you see the crazy optimizers for embedded systems. They take the complete code of a system into consideration, and, in a number of compile passes, reuses code snippets from app, libraries, and OS layer to create one big tangled mess that is hard to follow even if you have the source code...
- Isn't that still the same exact process as a normal compiler except in the case of embedded systems your OS is like a couple kilobytes large and just compiled along with the rest of your code?
  
  As in, are those "crazy optimizations" not just standard compiler techniques, except applied to the entire OS+applications?

You can. It's called decompiling. Problem is you lose all the human friendly metadata that was in the original source code, meaning comments, variable names, certain code structures are lost forever because it was deleted in the compilation process. There are tools to help you reintroduce that stuff by going through the variables and trying to make sense out of what they were for but it's super tedious. With new ai tech that can certainly be improved with AI guessing what they were for but you'll never get the original meta data back.

Also if the code was run through an optimizer (which all modern games should be) the code is even harder to make sense of as it doesn't necessarily have the same structure and the same variables as the original code
- This is also very similar to if they ran the source code through an obfuscation tool. Some people do this with chrome extensions. Since they need to give you the source code for it to work on your machine they just change the variables to a, b, c, d and route things though unneeded functions so you don't know why anything is happening.

The best and simplest explanation I've seen: The machine code tells the computer what to do while the source code tells the human why it's doing it.

Your computer doesn't need all the "why" information to run the game, so the compilation process gets rid of it. What you're left with are instructions on exactly what computations to do, and that's all the computer needs.

For example, you can see in the machine code that two numbers are being added together. What do those numbers mean and why are we adding them? The source code can tell you that this is code that controls movement, one of the numbers is a velocity, the other is the player's current position.

Okay, I think that is sinking in.

I was under the impression it wasn't possible or just complete gibberish but it being just the results or instructions is helpful.
- Also, you only decompile to level of basic instructions that the processor understands. When you compile code to add two numbers, well, the processor only adds bytes. There are a quite a few steps that the compiler has to fill in.
  
  Ok, all that is not a big deal. But then you deal with compiler optimization. Optimizing basically tells the compiler to take its time and find some clever ways to save machine steps. So now the "standard way" for a compiler to implement adding numbers may have other stuff rolled into it because the compiler may see an opportunity to save steps in a seemly unrelated calculation by inserting steps into the addition it is implementing. Now it's basically unrecognizable. A human didn't write, and wouldn't have written that mess that the decompiler gives.
  
  Edit: I would also like to add that when compile with the debugger flag, you are telling the compiler to produce decompilable code. Don't change any steps and store variable names as written.

As I've read somewhere once: it's easy to make a burger out of a cow. Making a cow out of a burger is slightly harder.

That means that compiling code is a lossy process - the original code is lost in the process and can never be recovered because it doesn't exist anywhere anymore.

This is the fundamental notion of nearly 95% of cyberpunk stories re: the human soul and yet everyone always is like “but I want my cool robot hand!”
- Fuck soul, I want my cool robot hand!

The compilation process discards information in the process leaving a many to one effect. A good decompiler allows one to retrieve a program that is functionally equivalent to the source code but not exactly the source code.

@Squizzy
Lots of other people have addressed this, so I won't repeat the whole thing. You can absolutely do disassembly work, it's just a pain in the rear.
But it's actually been done for Mario, since you brought it up:
https://github.com/IsoFrieze/SMWDisX
And also Pokemon.

Code can be decompiled, but generally the end result isn't human readable. Just having the decompiler version isn't that valuable. Having the source code as written is more helpful because you get the context of what things were named and how it was organized.

Decompiled code is a bit like reading a book with all the nouns being random letters and verbs being random numbers.

Not completely random, every noun/verb would be translatable to a specific word/name. But also characters, there'd be many characters whose names, intentions and goals, relationships/links would also be in the same unreadable state. The storyline would likely not be chronological, but several actions and decisions by all kinds of actors would intertwine. It would be very hard to translate into a readable story, let alone so that it makes sense

Well, actually it can be. It just takes a lot more to decompile code than compile it. Depending on the objective accuracy.

Example: the Super Mario 64 Decompilation project. This was a project that used various debug data that was left in the rom to decompile the game back to a source code that compiled a byte accurate version of the rom. This took about 3 years and a lot of skilled developers to accomplish.

Side note: Super Mario Bros wasn’t built using a compiled language, but rather Assembly. So technically that would be a Disassembly not a Decompilation.

The same reason you can't unbake a cake I'd imagine.

Apparently not
Has the cake been in closed in an airtight container since it was done baking?
- I dunno.

The general difference is that you lose out on metadata - names, comments and organization that helps the source code in whatever programming language make sense, but which is not needed to actually execute the desired behavior on your CPU. Usually stuff like sensible names for bits of your code - functions/reusable logic, storage locations for "health" or "armor" or "current powerup", movement states, types of objects etc.

However, most of these are just another kind of number to the computer itself, so a lot of compilation processes strip a lot of this information. You could still reverse engineer it, but you're missing context (like all those names) from the original code and that makes the work potentially pretty difficult. Bear in mind that reading actual original source code is sometimes cryptic enough, then compare "if player is dead, show game over screen" to if (sdfdfgsdfg == jgdfg) { lkghku(); } because the "decompiler" has to invent some kind of name for everything that's missing. Now you have to deal with thousands of jfdsghklgs, and figure out what it all means.

You can get close depending on the language by using decompilers. Usually though, they're rough translations of what the decompiler thinks that the (compiled) machine code does. It's not a 1:1 deal.

Basically, a compiler translates the human-readable code to machine code that can actually be recognized and executed by your computer. A decompiler attempts to do the opposite, it translates the machine code back into the original language. But like some "translators", it's not always correct. That's the hard part - once decompiled you will likely have a lot of blanks to fill in and bugs to fix before anything will be compilable again. You'll likely never be able to get an exact copy of the original source code via decompiler.

You can certainly decompile things back down to machine code, but there could be gaps and things lost in translation between the programming language used to create the program, and the machine code that results when you take it apart again.

When you program, like actually write the code, you're using one language. When you compile it, you're passing it off to an interpreter into another language. There could be even more layers of this depending on what you're doing.

Now think about what happens when you open a translator, enter some words, translate it to one language, and then another, and back to the original. It comes out all wrong; the same thing happens with code. There's nuance and flavor imparted by the language itself that isn't kept through the interpretation of that language to the language that actually is used by the computer to do its tasks.

Code can be decompiled into code that can be recompiled, but compilers translate the human readable code into code that is easier to understand for machines. So decompiled code often ends up being nearly undecipherable for humans, and can take a long time to try and decipher.

But generally speaking it's not a reversible process and it is more difficult to do in reverse.

Same reason a cake can't be unbaked

It can, but it would just be the assembly instructions.

Usually we use high level programming languages when developing software, you'd make the cat class, the dog class, both inheriting from the animal class etc. to make our job easier.

When you compile the code, all the cute stuff gets removed, and the resulting code gets optimized as much as possible, which means you can't get back to the nice cat and dog code anymore.

A bit like a painter uses thousands of brush strokes to make a painting, it would be very hard to figure out which ones he made to make that specific painting, even if you have access to the painting.

Others have explained that decompiling is a thing.

I mainly work in Java where (due to the way Java bytecode works) decompiled code is actually very close to the original source code.

Most games are written in low level languages like C++ where that is not the case, variable and function names are lost during compilation.

It highly depends on the programming language used and how much debug information is left in the build. Production builds of software usually have debug symbols and other information useful during development stripped out to save space and improve runtime performance. Even when it is technically possible to decompile built code, the decompiled result may not be human-readable to the point of being useful. Imagine reading source code that has random names for variables, functions, modules, etc, or code that does not have any discernable organization.