Source code is the human-readable form of a computer program written in a programming language or other formal language intended to express computational instructions. It consists of textual or symbolic statements that describe operations, data, control flow, interfaces, rules, declarations, and other behaviour that a computer system is ultimately expected to perform.
Depending on the language and environment, source code can contain variable declarations, functions, classes, expressions, loops, conditional statements, data definitions, imports, annotations, macros, comments, configuration-like constructs, and embedded domain-specific languages. The term distinguishes the program as authored by humans from lower-level representations such as machine code, object code, executable binaries, and processor instructions.
Source code is therefore not synonymous with a particular programming language: C, C++, Rust, Java, Python, JavaScript, Go, Swift, Fortran, SQL, shell scripts, and many other languages can all have source code. A source file is normally one physical file containing part of a program, while a source-code repository can contain thousands or millions of lines distributed across many files and components.
Source code is generally written at a level of abstraction that allows programmers to describe intended computation without individually specifying every electrical or processor-level operation. For example, an instruction such as total = price * quantity expresses a mathematical relationship, whereas the processor eventually needs concrete instructions to load values, perform arithmetic, and store a result. The exact amount of abstraction varies considerably between languages.
Assembly language is often regarded as source code even though it closely represents processor instructions, while a high-level language such as Python or Java expresses considerably more behaviour per statement. Some source code is declarative rather than explicitly procedural: SQL can specify which data is wanted without prescribing the database engine's complete execution procedure, and HTML describes document structure rather than conventional computation. Source code can also include code generated by other programs, macros expanded by preprocessors, or templates transformed into another language. Consequently, "source" describes a role in a translation or build process rather than an absolute level of abstraction.
Source code normally passes through one or more transformation stages before execution, although the exact process depends on the programming environment. A compiled language may have source files processed by a preprocessor, compiler, optimiser, assembler, linker, and related build tools to produce an executable or library. An interpreted language may have source text parsed into an abstract syntax tree, bytecode, an intermediate representation, or another internal form before an interpreter or virtual machine executes it.
Some modern systems combine compilation and interpretation, such as a runtime that initially interprets code and subsequently uses just-in-time compilation to produce native machine code for frequently executed sections. Transpilers can translate source code from one programming language into another, such as TypeScript into JavaScript. Build systems may also combine generated code, resources, libraries, configuration files, and source modules into a deployable application. Thus source code is usually an input to a software-production pipeline rather than something a processor directly executes in its original textual form.
The structure and meaning of source code are determined by a language's syntax and semantics. Syntax defines which sequences of symbols constitute valid programs, while semantics determines what those valid constructs mean. A compiler or interpreter commonly performs lexical analysis to turn characters into tokens, parsing to establish grammatical structure, and semantic analysis to identify issues such as invalid types, undeclared identifiers, incompatible operations, or incorrect language constructs.
Static type systems may detect many errors before execution, while dynamically typed languages may defer more checks until runtime. Source code can therefore contain different categories of errors: syntax errors prevent the program from being correctly parsed, semantic or type errors may violate language rules, and logically incorrect code may be syntactically valid and successfully compiled but still produce the wrong result. Runtime errors arise only when particular execution paths encounter problematic conditions. Source-level diagnostics are valuable because they can identify the location and conceptual context of an error before or during execution.
Source code is also a primary mechanism for human collaboration and software maintenance. Programmers use comments, meaningful identifiers, functions, modules, abstractions, documentation, formatting conventions, tests, and architectural boundaries to make code understandable to other people and to their future selves. Version-control systems such as Git record changes to source files, allowing developers to inspect history, compare revisions, merge independent work, create branches, and recover earlier versions.
Code review examines proposed changes for correctness, security, maintainability, performance, compatibility, and adherence to project conventions. Large projects generally divide source code into modules, packages, libraries, services, and other units to control complexity. Dependency declarations identify external components required to build or run the software. Source code therefore has a social and engineering dimension in addition to its computational meaning: software quality depends not only on whether code executes, but also on whether humans can understand, test, modify, secure, and maintain it.
The distinction between source code and executable code is particularly important in software distribution and intellectual property. Source code normally exposes implementation details to readers, whereas a compiled binary generally contains lower-level representations from which recovering the original source is difficult and often impossible in exact form. Compilation can remove comments, rename or eliminate symbols, inline functions, rearrange operations, optimise data structures, and otherwise transform the original representation.
Debug information can preserve mappings between machine instructions and source locations, making debugging easier, but it does not necessarily preserve the original source text. Some software is distributed as open source under licences that grant specified rights to inspect, modify, and redistribute the source, while proprietary software may distribute only executable forms. "Open source" therefore describes licensing and distribution practices rather than merely the existence of source code. Almost all substantial software has some form of source representation during development, regardless of whether that source is publicly available.
Source code can represent vastly different kinds of software. Operating-system kernels contain low-level code that manages processes, memory, hardware, filesystems, and security boundaries. Application source code implements user-facing functionality such as editors, browsers, accounting systems, games, and web applications. Library source code supplies reusable functionality to other programs. Firmware source code controls specialised devices and embedded systems.
Scripts automate administrative or development tasks, while configuration and infrastructure code can describe how cloud resources, containers, networks, or deployment environments should be created. Scientific and numerical source code may implement simulations and mathematical algorithms, while machine-learning systems combine conventional program logic with numerical models and data-processing pipelines. Source code may also generate source code, machine-readable schemas, documentation, or other artefacts. This breadth means that source code is best understood as a programmable representation of computational behaviour rather than as simply "the text of an application."
Several concepts are commonly confused with source code. Source code is not the same thing as source files, because one source file is merely one container for source text and a program may span many files. It is not necessarily the same thing as the program's complete source, because generated code, build scripts, dependencies, schemas, assets, and configuration may also be required to reproduce a particular build.
It is not machine code, because source code is normally intended for human authors and must be translated or otherwise processed into a form executable by a processor. It is not an algorithm either: an algorithm is an abstract, well-defined computational procedure, while source code is one concrete expression of algorithms and other program logic in a programming language.
Source code can implement the same algorithm in many different languages and can also contain declarations, interfaces, error handling, user-interface code, tests, and other material that is not itself a standalone algorithm. These distinctions are fundamental to understanding software development, compilation, execution, debugging, licensing, reverse engineering, and maintenance.
