In computer science, code generation is the process by which a compiler converts a syntactically-correct program into a series of instructions that could be executed by a machine. The input to the code generation stage typically consists of a parse tree, abstract syntax tree, or intermediate language code; the target machine may be a physical machine such as a microprocessor, or an abstract machine such as a virtual machine or an intermediate language. Sophisticated compilers may use several cascaded code generation stages to fully compile code; this is due to the fact that algorithms for code optimization are more readily applicable in an intermediate code form, and also facilitates a single compiler that can target multiple architectures as only the final code generation stage (the backend) would need to change from target to target.

In more general sense, the code generation is to produce programs in some automatic manner, reducing need for human programmers to write code manually. Code generations can be done either at runtime, including load time or compiler time. Just-in-time compilers are an example of a code generator that produce native or nearly native code from byte-code or the like when programs are loaded onto the compilers. A compiler-compiler, generates a compiler, like yacc, is an example. , on the other hand, almost always generate code at compiler time on the other hand. A preprocessor is an example of the simplest code generator, which produces a target code from the source code by replacing predefined keywords.

When code generation occurs at runtime, it is important that code generation is efficiency in space and time. For example, when regular expressions are interpreted and used to generate code at runtime, a non-determistic FSA instead of deterministic one is often generated as in general the former can be created more quickly and occupies less memory space than the latter. Despite it generally generates less efficient code, a code generation at runtime can take the advantage of being done at runtime. Some people cites this fact to note that a JIT compiler can generate more efficient code than a compiler invoked before runtime, since it is more knowledgeable about the context and the execution path of the program than when the compiler generates code at compile time.

See also model-driven architecture.