GeezerVison

In most of today's popular programming languages and operating systems, a computer program usually only has a single entry point.

In C, C++, D, Zig, Rust and Kotlin programs this is a function named main; in Java it is a static method named main (although the class must be specified at the invocation time), and in C# it is a static method named Main.^[5][6]

In many major operating systems, the standard executable format has a single entry point. In the Executable and Linkable Format (ELF), used in Unix and Unix-like systems such as Linux, the entry point is specified in the e_entry field of the ELF header. In the GNU Compiler Collection (gcc), the entry point used by the linker is the _start symbol. Similarly, in the Portable Executable format, used in Microsoft Windows, the entry point is specified by the AddressOfEntryPoint field, which is inherited from COFF. In COM files, the entry point is at the fixed offset of 0100h.

One exception to the single-entry-point paradigm is Android. Android applications do not have a single entry point – there is no special main function. Instead, they have essential components (activities and services) which the system can load and run as needed.^[7]

An occasionally used technique is the fat binary, which consists of several executables for different targets packaged in a single file. Most commonly, this is implemented by a single overall entry point, which is compatible with all targets and branches to the target-specific entry point. Alternative techniques include storing separate executables in separate forks, each with its own entry point, which is then selected by the operating system.

Historically, and in some contemporary legacy systems, such as VMS and OS/400, computer programs have a multitude of entry points, each corresponding to the different functionalities of the program. The usual way to denote entry points, as used system-wide in VMS and in PL/I and MACRO programs, is to append them at the end of the name of the executable image, delimited by a dollar sign ($), e.g. directory.exe$make.

The Apple I computer also used this to some degree. For example, an alternative entry point in Apple I's BASIC would keep the BASIC program useful when the reset button was accidentally pushed.

In APL, when a workspace is loaded, the contents of "quad LX" (latent expression) variable is interpreted as an APL expression and executed.

In C and C++, the function prototype of the main function must be equivalent to one of the following:

int main();
int main(int argc, char* argv[]);

Note that int main(); may equivalently be expressed as int main(void); and int main(int argc, char* argv[]); may equivalently be expressed as int main(int argc, char** argv);; within function parameters, these signatures are identical to the compiler.

The main() function is special; normally every C and C++ program must define it exactly once.

Prior to C89, C defined all functions without an explicit return type to return int; some main functions could simply be main() { /* ... */ }. Additionally, void main(); is a signature that is accepted on some compilers, but not officially part of the language; in such cases, the value returned to the host environment is unspecified.^[8]

The main function is the entry point for application programs written in ISO-standard C or C++. Low-level system programming (such as for a bare-metal embedded system) might specify a different entry point (for example via a reset interrupt vector) using functionality not defined by the language standard.

With trailing return types, main() may also be equivalently expressed as:

auto main() -> int;
auto main(int argc, char* argv[]) -> int;

If the signature is int main() (without argc and argv) and command-line arguments are supplied, they will simply be ignored by the program.

The parameters argc (for argument count) and argv (for argument vector)^[9] respectively give the number and values of the program's command-line arguments. The names of argc and argv may be any valid identifier, but it is common convention to use these names. Other platform-dependent formats are also allowed by the C and C++ standards, except that in C++ the return type must always be int;^[10] for example, Unix (though not POSIX.1) and Windows have a third argument giving the program's environment, otherwise accessible through getenv() in <stdlib.h>:

int main(int argc, char* argv[], char* envp[]);

Darwin-based operating systems, such as macOS, have a fourth parameter containing arbitrary OS-supplied information, such as the path to the executing binary:^[11]

int main(int argc, char* argv[], char* envp[], char* apple[]);

The value returned from the main function becomes the exit status of the process, though the C standard only ascribes specific meaning to two values: EXIT_SUCCESS (traditionally 0) and EXIT_FAILURE. The meaning of other possible return values is implementation-defined. In case a return value is not defined by the programmer, an implicit return 0; at the end of the main() function is inserted by the compiler; this behavior is required by the C++ standard.

It is guaranteed that argc is non-negative and that argv[argc] is a null pointer. By convention, the command-line arguments specified by argc and argv include the name of the program as the first element if argc is greater than 0; if a user types a command of "rm file", the shell will initialise the rm process with argc = 2 and argv = {"rm", "file", NULL}. As argv[0] is the name that processes appear under in ps, top etc., some programs, such as daemons or those running within an interpreter or virtual machine (where argv[0] would be the name of the host executable), may choose to alter their argv to give a more descriptive argv[0], usually by means of the exec system call.

On GCC and Clang, it is possible to call main(), change its signature, or even select a different function as the entry point by passing the compiler flag –nostartfiles and then defining the function _start(). Arguments from command line to main() can be retrieved using inline assembly, or using system-dependent APIs (such as GetCommandLineW() on Win32, _NSGetArgv() on Darwin (Apple), or directly reading /proc/self/cmdline on Linux).

#include <stdio.h>
#include <stdlib.h>

void _start() {
    int exitCode = Main();
    exit(exitCode);
}

// note the name is Main(), not main()
int Main() {
    printf("No main() function in this program.");
    return 0;
}

If declared, main() must be declared as if it has external linkage; it cannot be declared static or inline.

In C++, main() must be in the global namespace (i.e. ::main), and cannot be overloaded. In C++ (unlike C) main() cannot be called recursively and cannot have its address taken. If main() is not defined in the global namespace (for example if it is only defined as a member function of a class), the compiler will not detect it. The name main() is not otherwise reserved, and may be used for member functions, classes, enumerations, or non-member functions in other namespaces.

import std;

using std::span;
using std::string_view;
using std::vector;

class Main {
public:
    static void main(span<string_view> args) {
        std::println("Java-style main() function with {} arguments:", args.size());

        for (string_view arg : args) {
            std::println("  {}");
        }
    }
};

int main(int argc, char* argv[]) {
    vector<string_view> args(argv, argv + argc);
    Main::main(args);
    return 0;
}

In 2017, there was a proposal for a modernised signature for main(), more similar to Java and C# (which instead of int main(int, char*[]);, these languages use the signature void main(String[]);, taking an array of strings). The suggested signature was int main(initializer_list<string_view> args) (as at the time, span<T> was not yet part of the language), however this proposal was rejected.^[12] Another proposal for global command-line arguments access through a std::arguments class, similar to Rust's std::env::args() and C#'s System.Environment.GetCommandLineArgs(), was made in 2024.^[13]

main() may not be a coroutine^[14]; instead, coroutines called in main() must be awaited using std::this_thread::sync_wait().^[15]

import std;

using std::optional;
using std::tuple;
using std::execution::task;
using namespace std::literals;

task<void> simulateWork() {
    std::println("Performing work...");
    std::this_thread::read_env(get_scheduler);
    std::println("Work done!");
    co_return;
}

int main() {
    optional<tuple<>> result = std::this_thread::sync_wait(simulateWork());

    return static_cast<int>(result.has_value());
}

As of C++26, the main() function may have extern "C++" linkage; this allows for module implementation units to test internal entities.^[16]

module wikipedia.examples;

extern "C++" int main() {
    // ...
}

When executing a program written in C#, the CLR searches for a static method marked with the .entrypoint IL directive, which takes either no arguments, or a single argument of type string[], and has a return type of void or int, and executes it.^[17]

static void Main();
static void Main(string[] args);
static int Main();
static int Main(string[] args);

Command-line arguments are passed in args, similar to how it is done in Java. For versions of Main() returning an integer, similar to both C and C++, it is passed back to the environment as the exit status of the process.

Like Java, the entry point of a program typically resides in a named class, like so:

namespace Wikipedia.Examples;

using System;

public class HelloWorld
{
    static void Main(string[] args)
    {
        Console.WriteLine("Hello, world!");
    }
}

Since C#7.1 there are four more possible signatures of the entry point, which allow asynchronous execution in the Main() method; these use the System.Threading.Tasks.Task class.^[18][19]

static async Task Main();
static async Task Main(string[] args);
static async Task<int> Main();
static async Task<int> Main(string[] args);

The Task and Task<int> types are the asynchronous equivalents of void and int (note that Task<void> is invalid). async is required to allow the use of asynchronous calls (the await keyword) inside the method.

namespace Wikipedia.Examples;

using System;
using System.Threading.Tasks;

public class HelloWorld
{
    static async Task<int> Main(string[] args)
    {
        Console.WriteLine("Hello...");
        await Task.Delay(1000);
        Console.WriteLine("...world!");
        return 0;
    }
}

Clean is a functional programming language based on graph rewriting. The initial node is named Start and is of type *World -> *World if it changes the world or some fixed type if the program only prints the result after reducing Start.

Start :: *World -> *World
Start world = startIO ...

Or even simpler

Start :: String
Start = "Hello, world!"

One tells the compiler which option to use to generate the executable file.

ANSI Common Lisp does not define a main function; instead, the code is read and evaluated from top to bottom in a source file. However, the following code will emulate a main function.

(defun hello-main ()
  (format t "Hello World!~%"))

(hello-main)

In D, the function prototype of the main function looks like one of the following:

void main();
void main(string[] args);
int main();
int main(string[] args);

Command-line arguments are passed in args, similar to how it is done in C# or Java. For versions of main() returning an integer, similar to both C and C++, it is passed back to the environment as the exit status of the process.

Dart is a general-purpose programming language that is often used for building web and mobile applications. Like many other programming languages, Dart has an entry point that serves as the starting point for a Dart program. The entry point is the first function that is executed when a program runs. In Dart, the entry point is typically a function named main . When a Dart program is run, the Dart runtime looks for a function named main and executes it. Any Dart code that is intended to be executed when the program starts should be included in the main function. Here is an example of a simple main function in Dart:

void main() {
    print("Hello, world!");
}

In this example, the main function simply prints the text Hello, world! to the console when the program is run. This code will be executed automatically when the Dart program is run.

While the main function is the default entry point for a Dart program, it is possible to specify a different entry point if needed. This can be done using the @pragma("vm:entry-point") annotation in Dart. However, in most cases, the main function is the entry point that should be used for Dart programs.

FORTRAN does not have a main subroutine or function. Instead a PROGRAM statement as the first line can be used to specify that a program unit is a main program, as shown below. The PROGRAM statement cannot be used for recursive calls.^[20]

      PROGRAM HELLO
      PRINT *, "Cint!"
      END PROGRAM HELLO

Some versions of Fortran, such as those on the IBM System/360 and successor mainframes, do not support the PROGRAM statement. Many compilers from other software manufacturers will allow a fortran program to be compiled without a PROGRAM statement. In these cases, whatever module that has any non-comment statement where no SUBROUTINE, FUNCTION or BLOCK DATA statement occurs, is considered to be the Main program.

Using GNAT, the programmer is not required to write a function named main; a source file containing a single subprogram can be compiled to an executable. The binder will however create a package ada_main, which will contain and export a C-style main function.

In Go programming language, program execution starts with the main function of the package main

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

There is no way to access arguments or a return code outside of the standard library in Go. These can be accessed via os.Args and os.Exit respectively, both of which are included in the "os" package.

A Haskell program must contain a name main bound to a value of type IO t, for some type t;^[21] which is usually IO (). IO is a monad, which organizes side-effects in terms of purely functional code.^[22] The main value represents the side-effects-ful computation done by the program. The result of the computation represented by main is discarded; that is why main usually has type IO (), which indicates that the type of the result of the computation is (), the unit type, which contains no information.

main :: IO ()
main = putStrLn "Hello, World!"

Command line arguments are not given to main; they must be fetched using another IO action, such as System.Environment.getArgs.

Java programs start executing at the main method of a class,^{[23][24][25][26]} which has one of the following method headings:

// named class-based
public static void main();
public static void main(String[] args);
public static void main(String... args);

// unnamed class-based
void main();
void main(String[] args);
void main(String... args);

Note that in Java, void main(String[] args); and void main(String args[]); are identical declarations; additionally, the variadic form void main(String... args); is identical as variadics compile to an array type (the only difference is that void main(String... args) is marked as variadic in the class metadata).

Command-line arguments are passed in args. As in C and C++, the name "main()" is special. Java's main methods do not return a value directly, but a return code can be directly returned to the operating system by calling the System.exit() method, which exits the program prematurely (but this return code does not come from main()).

Unlike C, the name of the program is not included in args, because it is the name of the class that contains the main method, so it is already known. Also unlike C, the number of arguments need not be included, since arrays in Java have a field that keeps track of how many elements there are.

The main function must be included within a class. This is because in Java everything has to be contained within a class. For instance, a hello world program in Java may look like:

package org.wikipedia.examples;

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }
}

To run this program, one must call java HelloWorld in the directory where the compiled class file HelloWorld.class) exists. Alternatively, executable JAR files use a manifest file to specify the entry point in a manner that is filesystem-independent from the user's perspective.

Since Java 25, it is possible to create a "compact source file" which implicitly declares a final class in the unnamed package. This class extends java.lang.Object and does not implement any interfaces, has only a default constructor, and has the fields and methods declared in the compact source file.^[27] Furthermore, Java 25 moves the class java.io.IO (first introduced in Java 23) to the package java.lang (thus implicitly importing it into all source files), based on System.out and System.in rather than java.io.Console. This allows a simplified Hello World program, perhaps more similar to C and C++ where main resides in the global namespace:

void main() {
    IO.println("Hello, world!");
}

In JavaScript and TypeScript, there is no "main" function as code is executed as soon as it is seen. However, it can be emulated like so:

// Non-async version:
function main(): void {
    console.log("Hello world");
}

// Async version:
async function main(): Promise<void> {
    console.log("Hello world");
}

// In this pattern, only a call to main() is top-level
// A good idea may be to call main() and catch any errors,
// then cleanly log them like so
main().catch((err) => {
    console.error(err);
    process.exit(1);
});

If using Node.js, it is possible to emulate the Python-style pattern of if __name__ == "__main__"::

function main(): void {
    console.log("Running as main module");
}

if (require.main === module) {
    main();
}

In Julia the entry point (at least for scripts, see below for compiled programs) is the program file you itself you run, i.e. from the very first line so you can simply do (or start with):

println("Hello, world! Called from $PROGRAM_FILE with following arguments:"); for x in ARGS; println(x); end

Since Julia version 1.11 there's also the possibility of defining a main function that will be called as an entry point, and it can e.g. look like this if using the associated @main macro:

(@main)(ARGS) = println("Hello World! Called from main.")

For compatibility with prior Julia versions, such as Julia 1.10 (LTS), the above line can be made to work with one extra line from the documentation, and using this way can help since the new "feature is intended to aid in the unification of compiled and interactive workflows."^[28] Other ways documented elsewhere^[29] are no longer needed.

The former println above showing the older way for an entry point without defining a main function is still perfectly fine for scripts (and ARGS is available in both cases, there directly from the a global variable; and PROGRAM_FILE in either case). Note if you do both, scripts will still run the first line as usual, and from there onward so this would also call main and print twice. But neither is necessarily the first code run unless you invoke Julia with --startup-file=no since the default Julia startup file is run before anything else (it's empty after install, but can easily be forgotten e.g. when benchmarking, if you've added to it).

The exit status is 0 by default (on success, throwing changes that), and exit(my_exit_code) exits the program with a non-default one.

In Kotlin, the main function is often top-level, like so:

fun main() {
    println("No arguments")
}

// With arguments:
fun main(args: Array<String>) {
    println("First argument: ${args[0]}")
}

// concise-style:
fun main(args: Array<String>) = println(args.joinToString())

In the Java Virtual Machine, the JVM bytecode will represent this as a static method of a class, as the JVM does not support top-level functions. For example, if the file is named Main.kt:

public final class MainKt {
    public static void main(String[] args) {
        System.out.println("First argument: " + args[0]);
    }
}

In FMSLogo, the procedures when loaded do not execute. To make them execute, it is necessary to use this code:

to procname
 ...                 ; Startup commands (such as print [Welcome])
end

make "startup [procname]

The variable startup is used for the startup list of actions, but the convention is that this calls a procedure that runs the actions. That procedure may be of any name.

OCaml has no main function. Programs are evaluated from top to bottom.

Command-line arguments are available in an array named Sys.argv and the exit status is 0 by default.

Example:

print_endline "Hello World"

In Pascal, the main procedure is the only unnamed block in the program. Because Pascal programs define procedures and functions in a more rigorous bottom-up order than C, C++ or Java programs, the main procedure is usually the last block in the program. Pascal does not have a special meaning for the name "main" or any similar name.

program Hello(Output);
begin
  writeln('Hello, world!');
end.

Command-line arguments are counted in ParamCount and accessible as strings by ParamStr(n), with n between 0 and ParamCount.

Versions of Pascal that support units or modules may also contain an unnamed block in each, which is used to initialize the module. These blocks are executed before the main program entry point is called.

In Perl, there is no main function. Statements are executed from top to bottom, although statements in a BEGIN block are executed before normal statements.

Command-line arguments are available in the special array @ARGV. Unlike C, @ARGV does not contain the name of the program, which is $0.

PHP does not have a "main" function. Starting from the first line of a PHP script, any code not encapsulated by a function header is executed as soon as it is seen.

In Pike syntax is similar to that of C and C++. The execution begins at main. The "argc" variable keeps the number of arguments passed to the program. The "argv" variable holds the value associated with the arguments passed to the program.

Example:

 int main(int argc, array(string) argv)

Python programs are evaluated top-to-bottom, as is usual in scripting languages: the entry point is the start of the source code. Since definitions must precede use, programs are typically structured with definitions at the top and the code to execute at the bottom (unindented), similar to code for a one-pass compiler, such as in Pascal.

Alternatively, a program can be structured with an explicit main function containing the code to be executed when a program is executed directly, but which can also be invoked by importing the program as a module and calling the function. This can be done by the following idiom, which relies on the internal variable __name__ being set to __main__ when a program is executed, but not when it is imported as a module (in which case it is instead set to the module name); there are many variants of this structure:^[30][31][32]

import sys

def main(argv: list[str]) -> int:
    argc: int = len(argv) # get length of argv
    n: int = int(argv[1])
    print(n + 1)
    return 0

if __name__ == "__main__":
    sys.exit(main(sys.argv))

In this idiom, the call to the named entry point main is explicit, and the interaction with the operating system (receiving the arguments, calling system exit) are done explicitly by library calls, which are ultimately handled by the Python runtime. This contrasts with C, where these are done implicitly by the runtime, based on convention.

The QB64 language has no main function, the code that is not within a function, or subroutine is executed first, from top to bottom:

print "Hello World! a =";
a = getInteger(1.8d): print a

function getInteger(n as double)
    getInteger = int(n)
end function

Command line arguments (if any) can be read using the COMMAND$ function:

dim shared commandline as string
commandline = COMMAND$

'Several space-separated command line arguments can be read using COMMAND$(n)
commandline1 = COMMAND$(2)

In Ruby, there is no distinct main function. Instead, code written outside of any class .. end or module .. end scope is executed in the context of a special "main" object. This object can be accessed using self:

irb(main):001:0> self
=> main

It has the following properties:

irb(main):002:0> self.class
=> Object
irb(main):003:0> self.class.ancestors
=> [Object, Kernel, BasicObject]

Methods defined outside of a class or module scope are defined as private methods of the "main" object. Since the class of "main" is Object, such methods become private methods of almost every object:

irb(main):004:0> def foo
irb(main):005:1>   42
irb(main):006:1> end
=> nil
irb(main):007:0> foo
=> 42
irb(main):008:0> [].foo
NoMethodError: private method `foo' called for []:Array
	from (irb):8
	from /usr/bin/irb:12:in `<main>'
irb(main):009:0> false.foo
NoMethodError: private method `foo' called for false:FalseClass
	from (irb):9
	from /usr/bin/irb:12:in `<main>'

The number and values of command-line arguments can be determined using the ARGV constant array:

$ irb /dev/tty foo bar

tty(main):001:0> ARGV
ARGV
=> ["foo", "bar"]
tty(main):002:0> ARGV.size
ARGV.size
=> 2

The first element of ARGV, ARGV[0], contains the first command-line argument, not the name of program executed, as in C. The name of program is available using $0 or $PROGRAM_NAME.^[33]

Similar to Python, one could use:

if __FILE__ == $PROGRAM_NAME
  # Put "main" code here
end

to execute some code only if its file was specified in the ruby invocation.

In Rust, the entry point of a program is a function named main. By convention, this function is situated in a file called main.rs.

// In main.rs
fn main() {
    println!("Hello, World!");
}

main() may return any type that implements the trait std::process::Termination.^[34] Internally on the Rust runtime, these will return libc::EXIT_SUCCESS upon successful execution and libc::EXIT_FAILURE upon failure.

use std::io;

fn main() -> Result<(), io::Error> {
    println!("Hello, World!");

    Ok(())  // Return a type Result of value Ok with the content (), the unit type.
}

In the Rust standard library, the following types have implementations for std::process::Termination:

• ! (the never type)
• () (the unit type)
• std::convert::Infalliable
• std::process::ExitCode (with constants SUCCESS and FAIL)
• std::result::Result<T, E>

Rust does not have parameters in the main() function like C++ and Java or other C-style languages. Instead, it accesses command-line arguments using std::env::args(), which returns std::env::Args and can then be converted to Vec<String> using collect().

use std::env::{self, Args};
use std::io;

fn main() -> Result<(), io::Error> {
    let args: Args = env::args(); // get the command line args
    let args_vec: Vec<String> = args.collect(); // collect args into a Vec<String>

    for arg in args_vec {
        println!("{}", arg);
    }

    Ok(())
}

When run in an Xcode Playground,^[35] Swift behaves like a scripting language, executing statements from top to bottom; top-level code is allowed.

// HelloWorld.playground

let hello = "hello"
let world = "world"

let helloWorld = hello + " " + world

print(helloWorld) // hello world

Cocoa- and Cocoa Touch-based applications written in Swift are usually initialized with the @NSApplicationMain and @UIApplicationMain attributes, respectively. Those attributes are equivalent in their purpose to the main.m file in Objective-C projects: they implicitly declare the main function that calls UIApplicationMain(_:_:_:_:)^[36] which creates an instance of UIApplication.^[37]

The following code is the default way to initialize a Cocoa Touch-based iOS app and declare its application delegate.

// AppDelegate.swift

import UIKit

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
    
    var window: UIWindow?
    
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        return true
    }
    
}

In Visual Basic, when a project contains no forms, the startup object may be the Main() procedure. The Command$ function can be optionally used to access the argument portion of the command line used to launch the program:

Sub Main()
    Debug.Print "Hello World!"
    MsgBox "Arguments if any are: " & Command$
End Sub

In Xojo, there are two different project types, each with a different main entry point. Desktop (GUI) applications start with the App.Open event of the project's Application object. Console applications start with the App.Run event of the project's ConsoleApplication object. In both instances, the main function is automatically generated, and cannot be removed from the project.